doc-detective 4.0.1 → 4.0.2-dev.10

package/dist/index.cjs

@@ -107,6 +107,26 @@ var schemas_default = {
               307,
               308
             ]
+          },
+          headers: {
+            description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+            default: {},
+            anyOf: [
+              {
+                title: "Request headers (object)",
+                description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                type: "object",
+                additionalProperties: {
+                  type: "string"
+                },
+                properties: {}
+              },
+              {
+                title: "Request headers (string)",
+                description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                type: "string"
+              }
+            ]
           }
         }
       }
@@ -170,6 +190,26 @@ var schemas_default = {
                 307,
                 308
               ]
+            },
+            headers: {
+              description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+              default: {},
+              anyOf: [
+                {
+                  title: "Request headers (object)",
+                  description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                  type: "object",
+                  additionalProperties: {
+                    type: "string"
+                  },
+                  properties: {}
+                },
+                {
+                  title: "Request headers (string)",
+                  description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                  type: "string"
+                }
+              ]
             }
           }
         }
@@ -494,6 +534,18 @@ var schemas_default = {
         type: "string",
         default: "."
       },
+      reporters: {
+        description: "Reporters to use when emitting test results. Built-in reporters: `terminal`, `json`, `html`. Custom reporters registered via `registerReporter()` can also be referenced by name.",
+        type: "array",
+        items: {
+          type: "string",
+          minLength: 1
+        },
+        default: [
+          "terminal",
+          "json"
+        ]
+      },
       recursive: {
         description: "If `true` searches `input`, `setup`, and `cleanup` paths recursively for test specifications and source files.",
         type: "boolean",
@@ -1559,6 +1611,26 @@ var schemas_default = {
                                                             307,
                                                             308
                                                           ]
+                                                        },
+                                                        headers: {
+                                                          description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                          default: {},
+                                                          anyOf: [
+                                                            {
+                                                              title: "Request headers (object)",
+                                                              description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                              type: "object",
+                                                              additionalProperties: {
+                                                                type: "string"
+                                                              },
+                                                              properties: {}
+                                                            },
+                                                            {
+                                                              title: "Request headers (string)",
+                                                              description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                              type: "string"
+                                                            }
+                                                          ]
                                                         }
                                                       }
                                                     }
@@ -1622,6 +1694,26 @@ var schemas_default = {
                                                               307,
                                                               308
                                                             ]
+                                                          },
+                                                          headers: {
+                                                            description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                            default: {},
+                                                            anyOf: [
+                                                              {
+                                                                title: "Request headers (object)",
+                                                                description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                                type: "object",
+                                                                additionalProperties: {
+                                                                  type: "string"
+                                                                },
+                                                                properties: {}
+                                                              },
+                                                              {
+                                                                title: "Request headers (string)",
+                                                                description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                                type: "string"
+                                                              }
+                                                            ]
                                                           }
                                                         }
                                                       }
@@ -10182,6 +10274,26 @@ var schemas_default = {
                                               307,
                                               308
                                             ]
+                                          },
+                                          headers: {
+                                            description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                            default: {},
+                                            anyOf: [
+                                              {
+                                                title: "Request headers (object)",
+                                                description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                type: "object",
+                                                additionalProperties: {
+                                                  type: "string"
+                                                },
+                                                properties: {}
+                                              },
+                                              {
+                                                title: "Request headers (string)",
+                                                description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                type: "string"
+                                              }
+                                            ]
                                           }
                                         }
                                       }
@@ -10245,6 +10357,26 @@ var schemas_default = {
                                                 307,
                                                 308
                                               ]
+                                            },
+                                            headers: {
+                                              description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                              default: {},
+                                              anyOf: [
+                                                {
+                                                  title: "Request headers (object)",
+                                                  description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                  type: "object",
+                                                  additionalProperties: {
+                                                    type: "string"
+                                                  },
+                                                  properties: {}
+                                                },
+                                                {
+                                                  title: "Request headers (string)",
+                                                  description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                  type: "string"
+                                                }
+                                              ]
                                             }
                                           }
                                         }
@@ -17845,6 +17977,11 @@ var schemas_default = {
         loadVariables: ".env",
         fileTypes: [
           "markdown"
+        ],
+        reporters: [
+          "terminal",
+          "json",
+          "html"
         ]
       },
       {
@@ -22153,6 +22290,18 @@ var schemas_default = {
             type: "string",
             default: "."
           },
+          reporters: {
+            description: "Reporters to use when emitting test results. Built-in reporters: `terminal`, `json`, `html`. Custom reporters registered via `registerReporter()` can also be referenced by name.",
+            type: "array",
+            items: {
+              type: "string",
+              minLength: 1
+            },
+            default: [
+              "terminal",
+              "json"
+            ]
+          },
           recursive: {
             description: "If `true` searches `input`, `setup`, and `cleanup` paths recursively for test specifications and source files.",
             type: "boolean",
@@ -23218,6 +23367,26 @@ var schemas_default = {
                                                                 307,
                                                                 308
                                                               ]
+                                                            },
+                                                            headers: {
+                                                              description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                              default: {},
+                                                              anyOf: [
+                                                                {
+                                                                  title: "Request headers (object)",
+                                                                  description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                                  type: "object",
+                                                                  additionalProperties: {
+                                                                    type: "string"
+                                                                  },
+                                                                  properties: {}
+                                                                },
+                                                                {
+                                                                  title: "Request headers (string)",
+                                                                  description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                                  type: "string"
+                                                                }
+                                                              ]
                                                             }
                                                           }
                                                         }
@@ -23281,6 +23450,26 @@ var schemas_default = {
                                                                   307,
                                                                   308
                                                                 ]
+                                                              },
+                                                              headers: {
+                                                                description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                                default: {},
+                                                                anyOf: [
+                                                                  {
+                                                                    title: "Request headers (object)",
+                                                                    description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                                    type: "object",
+                                                                    additionalProperties: {
+                                                                      type: "string"
+                                                                    },
+                                                                    properties: {}
+                                                                  },
+                                                                  {
+                                                                    title: "Request headers (string)",
+                                                                    description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                                    type: "string"
+                                                                  }
+                                                                ]
                                                               }
                                                             }
                                                           }
@@ -31841,6 +32030,26 @@ var schemas_default = {
                                                   307,
                                                   308
                                                 ]
+                                              },
+                                              headers: {
+                                                description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                default: {},
+                                                anyOf: [
+                                                  {
+                                                    title: "Request headers (object)",
+                                                    description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                    type: "object",
+                                                    additionalProperties: {
+                                                      type: "string"
+                                                    },
+                                                    properties: {}
+                                                  },
+                                                  {
+                                                    title: "Request headers (string)",
+                                                    description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                    type: "string"
+                                                  }
+                                                ]
                                               }
                                             }
                                           }
@@ -31904,6 +32113,26 @@ var schemas_default = {
                                                     307,
                                                     308
                                                   ]
+                                                },
+                                                headers: {
+                                                  description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                  default: {},
+                                                  anyOf: [
+                                                    {
+                                                      title: "Request headers (object)",
+                                                      description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                      type: "object",
+                                                      additionalProperties: {
+                                                        type: "string"
+                                                      },
+                                                      properties: {}
+                                                    },
+                                                    {
+                                                      title: "Request headers (string)",
+                                                      description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                      type: "string"
+                                                    }
+                                                  ]
                                                 }
                                               }
                                             }
@@ -39504,6 +39733,11 @@ var schemas_default = {
             loadVariables: ".env",
             fileTypes: [
               "markdown"
+            ],
+            reporters: [
+              "terminal",
+              "json",
+              "html"
             ]
           },
           {
@@ -41153,6 +41387,26 @@ var schemas_default = {
                                                     307,
                                                     308
                                                   ]
+                                                },
+                                                headers: {
+                                                  description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                  default: {},
+                                                  anyOf: [
+                                                    {
+                                                      title: "Request headers (object)",
+                                                      description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                      type: "object",
+                                                      additionalProperties: {
+                                                        type: "string"
+                                                      },
+                                                      properties: {}
+                                                    },
+                                                    {
+                                                      title: "Request headers (string)",
+                                                      description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                      type: "string"
+                                                    }
+                                                  ]
                                                 }
                                               }
                                             }
@@ -41216,6 +41470,26 @@ var schemas_default = {
                                                       307,
                                                       308
                                                     ]
+                                                  },
+                                                  headers: {
+                                                    description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                    default: {},
+                                                    anyOf: [
+                                                      {
+                                                        title: "Request headers (object)",
+                                                        description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                        type: "object",
+                                                        additionalProperties: {
+                                                          type: "string"
+                                                        },
+                                                        properties: {}
+                                                      },
+                                                      {
+                                                        title: "Request headers (string)",
+                                                        description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                        type: "string"
+                                                      }
+                                                    ]
                                                   }
                                                 }
                                               }
@@ -49250,6 +49524,26 @@ var schemas_default = {
                                                           307,
                                                           308
                                                         ]
+                                                      },
+                                                      headers: {
+                                                        description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                        default: {},
+                                                        anyOf: [
+                                                          {
+                                                            title: "Request headers (object)",
+                                                            description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                            type: "object",
+                                                            additionalProperties: {
+                                                              type: "string"
+                                                            },
+                                                            properties: {}
+                                                          },
+                                                          {
+                                                            title: "Request headers (string)",
+                                                            description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                            type: "string"
+                                                          }
+                                                        ]
                                                       }
                                                     }
                                                   }
@@ -49313,6 +49607,26 @@ var schemas_default = {
                                                             307,
                                                             308
                                                           ]
+                                                        },
+                                                        headers: {
+                                                          description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                          default: {},
+                                                          anyOf: [
+                                                            {
+                                                              title: "Request headers (object)",
+                                                              description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                              type: "object",
+                                                              additionalProperties: {
+                                                                type: "string"
+                                                              },
+                                                              properties: {}
+                                                            },
+                                                            {
+                                                              title: "Request headers (string)",
+                                                              description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                              type: "string"
+                                                            }
+                                                          ]
                                                         }
                                                       }
                                                     }
@@ -59057,6 +59371,26 @@ var schemas_default = {
                                                     307,
                                                     308
                                                   ]
+                                                },
+                                                headers: {
+                                                  description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                  default: {},
+                                                  anyOf: [
+                                                    {
+                                                      title: "Request headers (object)",
+                                                      description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                      type: "object",
+                                                      additionalProperties: {
+                                                        type: "string"
+                                                      },
+                                                      properties: {}
+                                                    },
+                                                    {
+                                                      title: "Request headers (string)",
+                                                      description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                      type: "string"
+                                                    }
+                                                  ]
                                                 }
                                               }
                                             }
@@ -59120,6 +59454,26 @@ var schemas_default = {
                                                       307,
                                                       308
                                                     ]
+                                                  },
+                                                  headers: {
+                                                    description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                    default: {},
+                                                    anyOf: [
+                                                      {
+                                                        title: "Request headers (object)",
+                                                        description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                        type: "object",
+                                                        additionalProperties: {
+                                                          type: "string"
+                                                        },
+                                                        properties: {}
+                                                      },
+                                                      {
+                                                        title: "Request headers (string)",
+                                                        description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                        type: "string"
+                                                      }
+                                                    ]
                                                   }
                                                 }
                                               }
@@ -67154,6 +67508,26 @@ var schemas_default = {
                                                           307,
                                                           308
                                                         ]
+                                                      },
+                                                      headers: {
+                                                        description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                        default: {},
+                                                        anyOf: [
+                                                          {
+                                                            title: "Request headers (object)",
+                                                            description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                            type: "object",
+                                                            additionalProperties: {
+                                                              type: "string"
+                                                            },
+                                                            properties: {}
+                                                          },
+                                                          {
+                                                            title: "Request headers (string)",
+                                                            description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                            type: "string"
+                                                          }
+                                                        ]
                                                       }
                                                     }
                                                   }
@@ -67217,6 +67591,26 @@ var schemas_default = {
                                                             307,
                                                             308
                                                           ]
+                                                        },
+                                                        headers: {
+                                                          description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                          default: {},
+                                                          anyOf: [
+                                                            {
+                                                              title: "Request headers (object)",
+                                                              description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                              type: "object",
+                                                              additionalProperties: {
+                                                                type: "string"
+                                                              },
+                                                              properties: {}
+                                                            },
+                                                            {
+                                                              title: "Request headers (string)",
+                                                              description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                              type: "string"
+                                                            }
+                                                          ]
                                                         }
                                                       }
                                                     }
@@ -78343,6 +78737,26 @@ var schemas_default = {
                                           307,
                                           308
                                         ]
+                                      },
+                                      headers: {
+                                        description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                        default: {},
+                                        anyOf: [
+                                          {
+                                            title: "Request headers (object)",
+                                            description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                            type: "object",
+                                            additionalProperties: {
+                                              type: "string"
+                                            },
+                                            properties: {}
+                                          },
+                                          {
+                                            title: "Request headers (string)",
+                                            description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                            type: "string"
+                                          }
+                                        ]
                                       }
                                     }
                                   }
@@ -78406,6 +78820,26 @@ var schemas_default = {
                                             307,
                                             308
                                           ]
+                                        },
+                                        headers: {
+                                          description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                          default: {},
+                                          anyOf: [
+                                            {
+                                              title: "Request headers (object)",
+                                              description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                              type: "object",
+                                              additionalProperties: {
+                                                type: "string"
+                                              },
+                                              properties: {}
+                                            },
+                                            {
+                                              title: "Request headers (string)",
+                                              description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                              type: "string"
+                                            }
+                                          ]
                                         }
                                       }
                                     }
@@ -86440,6 +86874,26 @@ var schemas_default = {
                                                 307,
                                                 308
                                               ]
+                                            },
+                                            headers: {
+                                              description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                              default: {},
+                                              anyOf: [
+                                                {
+                                                  title: "Request headers (object)",
+                                                  description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                  type: "object",
+                                                  additionalProperties: {
+                                                    type: "string"
+                                                  },
+                                                  properties: {}
+                                                },
+                                                {
+                                                  title: "Request headers (string)",
+                                                  description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                  type: "string"
+                                                }
+                                              ]
                                             }
                                           }
                                         }
@@ -86503,6 +86957,26 @@ var schemas_default = {
                                                   307,
                                                   308
                                                 ]
+                                              },
+                                              headers: {
+                                                description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                                default: {},
+                                                anyOf: [
+                                                  {
+                                                    title: "Request headers (object)",
+                                                    description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                                    type: "object",
+                                                    additionalProperties: {
+                                                      type: "string"
+                                                    },
+                                                    properties: {}
+                                                  },
+                                                  {
+                                                    title: "Request headers (string)",
+                                                    description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                                    type: "string"
+                                                  }
+                                                ]
                                               }
                                             }
                                           }
@@ -94817,6 +95291,26 @@ var schemas_default = {
                           307,
                           308
                         ]
+                      },
+                      headers: {
+                        description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                        default: {},
+                        anyOf: [
+                          {
+                            title: "Request headers (object)",
+                            description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                            type: "object",
+                            additionalProperties: {
+                              type: "string"
+                            },
+                            properties: {}
+                          },
+                          {
+                            title: "Request headers (string)",
+                            description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                            type: "string"
+                          }
+                        ]
                       }
                     }
                   }
@@ -94880,6 +95374,26 @@ var schemas_default = {
                             307,
                             308
                           ]
+                        },
+                        headers: {
+                          description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                          default: {},
+                          anyOf: [
+                            {
+                              title: "Request headers (object)",
+                              description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                              type: "object",
+                              additionalProperties: {
+                                type: "string"
+                              },
+                              properties: {}
+                            },
+                            {
+                              title: "Request headers (string)",
+                              description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                              type: "string"
+                            }
+                          ]
                         }
                       }
                     }
@@ -103267,6 +103781,26 @@ var schemas_default = {
                                 307,
                                 308
                               ]
+                            },
+                            headers: {
+                              description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                              default: {},
+                              anyOf: [
+                                {
+                                  title: "Request headers (object)",
+                                  description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                  type: "object",
+                                  additionalProperties: {
+                                    type: "string"
+                                  },
+                                  properties: {}
+                                },
+                                {
+                                  title: "Request headers (string)",
+                                  description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                  type: "string"
+                                }
+                              ]
                             }
                           }
                         }
@@ -103330,6 +103864,26 @@ var schemas_default = {
                                   307,
                                   308
                                 ]
+                              },
+                              headers: {
+                                description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                default: {},
+                                anyOf: [
+                                  {
+                                    title: "Request headers (object)",
+                                    description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                    type: "object",
+                                    additionalProperties: {
+                                      type: "string"
+                                    },
+                                    properties: {}
+                                  },
+                                  {
+                                    title: "Request headers (string)",
+                                    description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                    type: "string"
+                                  }
+                                ]
                               }
                             }
                           }
@@ -111364,6 +111918,26 @@ var schemas_default = {
                                       307,
                                       308
                                     ]
+                                  },
+                                  headers: {
+                                    description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                    default: {},
+                                    anyOf: [
+                                      {
+                                        title: "Request headers (object)",
+                                        description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                        type: "object",
+                                        additionalProperties: {
+                                          type: "string"
+                                        },
+                                        properties: {}
+                                      },
+                                      {
+                                        title: "Request headers (string)",
+                                        description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                        type: "string"
+                                      }
+                                    ]
                                   }
                                 }
                               }
@@ -111427,6 +112001,26 @@ var schemas_default = {
                                         307,
                                         308
                                       ]
+                                    },
+                                    headers: {
+                                      description: "Additional HTTP headers to include in the request. Merged on top of Doc Detective's default browser-mimicking headers. Useful for sites behind bot protection or WAFs that allowlist specific headers (for example, a Cloudflare Access service token or a `Cookie` with a `cf_clearance` value).",
+                                      default: {},
+                                      anyOf: [
+                                        {
+                                          title: "Request headers (object)",
+                                          description: "Headers to include in the HTTP request, in key/value format. Values must be strings.",
+                                          type: "object",
+                                          additionalProperties: {
+                                            type: "string"
+                                          },
+                                          properties: {}
+                                        },
+                                        {
+                                          title: "Request headers (string)",
+                                          description: "Headers to include in the HTTP request, as newline-separated values. For example, `X-Api-Key: abc123\nAuthorization: Bearer token`.",
+                                          type: "string"
+                                        }
+                                      ]
                                     }
                                   }
                                 }
@@ -128419,14 +129013,15 @@ function transformToSchemaKey({ currentSchema = "", targetSchema = "", object =
     } else if (currentSchema === "stopRecording_v2") {
       transformedObject.stopRecord = true;
     } else if (currentSchema === "wait_v2") {
-      transformedObject.wait = object;
+      transformedObject.wait = object.duration ?? 5e3;
     }
     const result = validate({
       schemaKey: "step_v3",
       object: transformedObject
     });
     if (!result.valid) {
-      throw new Error(`Invalid object: ${result.errors}`);
+      throw new Error(`Failed to transform object to step.
+Errors: ${result.errors}`);
     }
     return result.object;
   } else if (targetSchema === "config_v3") {
@@ -129278,11 +129873,17 @@ var defaultFileTypes = {
     inlineStatements: {
       testStart: [
         "<\\?doc-detective\\s+test([\\s\\S]*?)\\?>",
-        "<!--\\s*test([\\s\\S]+?)-->"
+        "<!--\\s*test([\\s\\S]+?)-->",
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value='test\\s+([^']+?)'[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value="test\\s+([^"]+?)"[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value='test\\s+([^']+?)'[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value="test\\s+([^"]+?)"[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`
       ],
       testEnd: [
         "<\\?doc-detective\\s+test\\s+end\\s*\\?>",
-        "<!--\\s*test end([\\s\\S]+?)-->"
+        "<!--\\s*test end([\\s\\S]+?)-->",
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value=["']test end["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value=["']test end["'][^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`
       ],
       ignoreStart: [
         "<\\?doc-detective\\s+test\\s+ignore\\s+start\\s*\\?>",
@@ -129295,7 +129896,11 @@ var defaultFileTypes = {
       step: [
         "<\\?doc-detective\\s+step\\s+([\\s\\S]*?)\\s*\\?>",
         "<!--\\s*step([\\s\\S]+?)-->",
-        '<data\\s+name="step"\\s*>([\\s\\S]*?)<\\/data>'
+        '<data\\s+name="step"\\s*>([\\s\\S]*?)<\\/data>',
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value='step\\s+([^']+?)'[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value="step\\s+([^"]+?)"[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value='step\\s+([^']+?)'[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value="step\\s+([^"]+?)"[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`
       ]
     },
     markup: [
@@ -129729,10 +130334,10 @@ async function getAvailableApps({ config }) {
 }
 
 // dist/core/detectTests.js
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path5 = __toESM(require("node:path"), 1);
-var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var import_node_fs5 = __toESM(require("node:fs"), 1);
+var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_crypto3 = __toESM(require("node:crypto"), 1);
 var import_yaml3 = __toESM(require("yaml"), 1);
 
 // dist/common/src/detectTests.js
@@ -129758,11 +130363,17 @@ var defaultFileTypesBase = {
     inlineStatements: {
       testStart: [
         "<\\?doc-detective\\s+test([\\s\\S]*?)\\?>",
-        "<!--\\s*test([\\s\\S]+?)-->"
+        "<!--\\s*test([\\s\\S]+?)-->",
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value='test\\s+([^']+?)'[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value="test\\s+([^"]+?)"[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value='test\\s+([^']+?)'[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value="test\\s+([^"]+?)"[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`
       ],
       testEnd: [
         "<\\?doc-detective\\s+test\\s+end\\s*\\?>",
-        "<!--\\s*test end([\\s\\S]+?)-->"
+        "<!--\\s*test end([\\s\\S]+?)-->",
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value=["']test end["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value=["']test end["'][^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`
       ],
       ignoreStart: [
         "<\\?doc-detective\\s+test\\s+ignore\\s+start\\s*\\?>",
@@ -129775,7 +130386,11 @@ var defaultFileTypesBase = {
       step: [
         "<\\?doc-detective\\s+step\\s+([\\s\\S]*?)\\s*\\?>",
         "<!--\\s*step([\\s\\S]+?)-->",
-        '<data\\s+name="step"\\s*>([\\s\\S]*?)<\\/data>'
+        '<data\\s+name="step"\\s*>([\\s\\S]*?)<\\/data>',
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value='step\\s+([^']+?)'[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?name=["']doc-detective["'][^>]*?value="step\\s+([^"]+?)"[^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value='step\\s+([^']+?)'[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`,
+        `<data\\s+[^>]*?value="step\\s+([^"]+?)"[^>]*?name=["']doc-detective["'][^>]*?(?:\\/\\s*>|>\\s*<\\/data>)`
       ]
     },
     markup: [
@@ -130128,6 +130743,9 @@ function parseXmlAttributes({ stringifiedObject }) {
 }
 function parseObject({ stringifiedObject }) {
   if (typeof stringifiedObject === "string") {
+    if (/&(?:#\d+|#x[0-9a-fA-F]+|amp|lt|gt|quot|apos);/.test(stringifiedObject)) {
+      stringifiedObject = stringifiedObject.replace(/&#39;|&apos;/g, "'").replace(/&#34;|&quot;/g, '"').replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&");
+    }
     const xmlAttrs = parseXmlAttributes({ stringifiedObject });
     if (xmlAttrs !== null) {
       return xmlAttrs;
@@ -130387,17 +131005,7 @@ async function parseContent({ config = {}, content, filePath = "", fileType }) {
               if (step.screenshot && config._herettoPathMapping) {
                 const herettoIntegration = findHerettoIntegration(config, filePath);
                 if (herettoIntegration) {
-                  if (typeof step.screenshot === "string") {
-                    step.screenshot = { path: step.screenshot };
-                  } else if (typeof step.screenshot === "boolean") {
-                    step.screenshot = {};
-                  }
-                  step.screenshot.sourceIntegration = {
-                    type: "heretto",
-                    integrationName: herettoIntegration,
-                    filePath: step.screenshot.path || "",
-                    contentPath: filePath
-                  };
+                  attachHerettoScreenshotSourceIntegration(step, herettoIntegration, filePath);
                 }
               }
             }
@@ -130463,6 +131071,12 @@ async function parseContent({ config = {}, content, filePath = "", fileType }) {
             endIndex: statement._endIndex
           };
         }
+        if (step.screenshot && config._herettoPathMapping) {
+          const herettoIntegration = findHerettoIntegration(config, filePath);
+          if (herettoIntegration) {
+            attachHerettoScreenshotSourceIntegration(step, herettoIntegration, filePath);
+          }
+        }
         const validation = validate({
           schemaKey: "step_v3",
           object: step,
@@ -130501,6 +131115,19 @@ async function parseContent({ config = {}, content, filePath = "", fileType }) {
   });
   return validatedTests;
 }
+function attachHerettoScreenshotSourceIntegration(step, integrationName, contentPath) {
+  if (typeof step.screenshot === "string") {
+    step.screenshot = { path: step.screenshot };
+  } else if (step.screenshot === null || typeof step.screenshot !== "object" || Array.isArray(step.screenshot)) {
+    step.screenshot = {};
+  }
+  step.screenshot.sourceIntegration = {
+    type: "heretto",
+    integrationName,
+    filePath: step.screenshot.path || "",
+    contentPath
+  };
+}
 function findHerettoIntegration(config, filePath) {
   if (!config._herettoPathMapping)
     return null;
@@ -130532,6 +131159,1130 @@ function log2(config, level, message) {
   }
 }
 
+// dist/core/integrations/heretto.js
+var import_node_fs4 = __toESM(require("node:fs"), 1);
+var import_node_path5 = __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);
+var import_node_os3 = __toESM(require("node:os"), 1);
+var import_node_crypto2 = __toESM(require("node:crypto"), 1);
+var import_adm_zip = __toESM(require("adm-zip"), 1);
+var HerettoUploader = class {
+  /**
+   * Checks if this uploader can handle the given source integration.
+   * @param {Object} sourceIntegration - Source integration metadata
+   * @returns {boolean} True if this uploader handles Heretto integrations
+   */
+  canHandle(sourceIntegration) {
+    return sourceIntegration?.type === "heretto";
+  }
+  /**
+   * Uploads a file to Heretto CMS.
+   * @param {Object} options - Upload options
+   * @param {Object} options.config - Doc Detective config
+   * @param {Object} options.integrationConfig - Heretto integration config
+   * @param {string} options.localFilePath - Local file path to upload
+   * @param {Object} options.sourceIntegration - Source integration metadata
+   * @param {Function} options.log - Logging function
+   * @returns {Promise<Object>} Upload result with status and description
+   */
+  async upload({ config, integrationConfig, localFilePath, sourceIntegration, log: log3 }) {
+    const result = {
+      status: "FAIL",
+      description: ""
+    };
+    if (!integrationConfig) {
+      result.description = "No Heretto integration configuration found";
+      return result;
+    }
+    if (!integrationConfig.organizationId || !integrationConfig.apiToken) {
+      result.description = "Heretto integration missing organizationId or apiToken";
+      return result;
+    }
+    const apiBaseUrl = `https://${integrationConfig.organizationId}.heretto.com`;
+    let fileId = sourceIntegration.fileId;
+    let parentFolderId = sourceIntegration.parentFolderId;
+    const filename = import_node_path5.default.basename(sourceIntegration.filePath);
+    const relativeFilePath = sourceIntegration.filePath;
+    if (!fileId && integrationConfig.resourceDependencies) {
+      const resolvedFile = this.resolveFromDependencies({
+        resourceDependencies: integrationConfig.resourceDependencies,
+        filePath: relativeFilePath,
+        filename,
+        log: (level, msg) => log3(config, level, msg)
+      });
+      if (resolvedFile) {
+        fileId = resolvedFile.uuid;
+        if (!parentFolderId && resolvedFile.parentFolderId) {
+          parentFolderId = resolvedFile.parentFolderId;
+        }
+        log3(config, "debug", `Resolved from dependencies: ${relativeFilePath} -> ${fileId}`);
+      }
+    }
+    if (!fileId) {
+      log3(config, "debug", `No fileId found, resolving correct folder for: ${sourceIntegration.filePath}`);
+      try {
+        if (!parentFolderId && integrationConfig.resourceDependencies) {
+          const folderResolution = this.findParentFolderFromDependencies({
+            resourceDependencies: integrationConfig.resourceDependencies,
+            filePath: relativeFilePath,
+            log: (level, msg) => log3(config, level, msg)
+          });
+          parentFolderId = folderResolution.folderId;
+          if (!parentFolderId && folderResolution.ditamapParentFolderId && folderResolution.targetFolderName) {
+            log3(config, "debug", `Searching for folder '${folderResolution.targetFolderName}' in ditamap's parent folder`);
+            parentFolderId = await this.getChildFolderByName({
+              apiBaseUrl,
+              apiToken: integrationConfig.apiToken,
+              username: integrationConfig.username || "",
+              parentFolderId: folderResolution.ditamapParentFolderId,
+              folderName: folderResolution.targetFolderName,
+              log: (level, msg) => log3(config, level, msg)
+            });
+          }
+        }
+        if (!parentFolderId && relativeFilePath) {
+          const parentDirPath = import_node_path5.default.dirname(relativeFilePath);
+          if (parentDirPath && parentDirPath !== ".") {
+            const folderName = import_node_path5.default.basename(parentDirPath);
+            log3(config, "debug", `Searching for parent folder by name: ${folderName}`);
+            parentFolderId = await this.searchFolderByName({
+              apiBaseUrl,
+              apiToken: integrationConfig.apiToken,
+              username: integrationConfig.username || "",
+              folderName,
+              log: (level, msg) => log3(config, level, msg)
+            });
+          }
+        }
+        if (parentFolderId) {
+          log3(config, "debug", `Looking for file '${filename}' in target folder ${parentFolderId}`);
+          fileId = await this.getFileInFolder({
+            apiBaseUrl,
+            apiToken: integrationConfig.apiToken,
+            username: integrationConfig.username || "",
+            folderId: parentFolderId,
+            filename,
+            log: (level, msg) => log3(config, level, msg)
+          });
+          if (fileId) {
+            log3(config, "debug", `Found existing file in target folder with ID: ${fileId}`);
+          } else {
+            log3(config, "debug", `File not in target folder, creating new document`);
+            const mimeType = this.getContentType(localFilePath);
+            const createResult = await this.createDocument({
+              apiBaseUrl,
+              apiToken: integrationConfig.apiToken,
+              username: integrationConfig.username || "",
+              parentFolderId,
+              filename,
+              mimeType,
+              log: (level, msg) => log3(config, level, msg)
+            });
+            if (createResult.created) {
+              fileId = createResult.documentId;
+              log3(config, "info", `Created new document in Heretto with ID: ${fileId}`);
+            } else if (createResult.existsInFolder) {
+              log3(config, "debug", `File exists in folder (race condition), searching for its ID`);
+              fileId = await this.getFileInFolder({
+                apiBaseUrl,
+                apiToken: integrationConfig.apiToken,
+                username: integrationConfig.username || "",
+                folderId: parentFolderId,
+                filename,
+                log: (level, msg) => log3(config, level, msg)
+              });
+              if (!fileId) {
+                result.description = `File exists in folder but could not get its ID: ${filename}`;
+                return result;
+              }
+            } else {
+              result.description = `Failed to create document in Heretto: ${filename}`;
+              return result;
+            }
+          }
+        } else {
+          log3(config, "debug", `No target folder found, searching globally for file: ${filename}`);
+          fileId = await this.searchFileByName({
+            apiBaseUrl,
+            apiToken: integrationConfig.apiToken,
+            username: integrationConfig.username || "",
+            filename,
+            log: (level, msg) => log3(config, level, msg)
+          });
+          if (!fileId) {
+            result.description = `Could not find file or parent folder in Heretto: ${sourceIntegration.filePath}`;
+            return result;
+          }
+        }
+      } catch (error) {
+        result.description = `Error searching/creating file: ${error.message}`;
+        return result;
+      }
+    }
+    if (!import_node_fs4.default.existsSync(localFilePath)) {
+      result.description = `Local file not found: ${localFilePath}`;
+      return result;
+    }
+    const fileContent = import_node_fs4.default.readFileSync(localFilePath);
+    const contentType = this.getContentType(localFilePath);
+    try {
+      await this.uploadFile({
+        apiBaseUrl,
+        apiToken: integrationConfig.apiToken,
+        username: integrationConfig.username || "",
+        documentId: fileId,
+        content: fileContent,
+        contentType,
+        log: (level, msg) => log3(config, level, msg)
+      });
+      result.status = "PASS";
+      result.description = `Successfully uploaded to Heretto (document ID: ${fileId})`;
+    } catch (error) {
+      result.description = `Upload failed: ${error.message}`;
+    }
+    return result;
+  }
+  /**
+   * Resolves a file path to its UUID using the resource dependencies map.
+   * @param {Object} options - Resolution options
+   * @param {Object.<string, {uuid: string, parentFolderId: string}>} options.resourceDependencies - Map of resource paths to resource metadata
+   * @param {string} options.filePath - Original file path to resolve
+   * @param {string} options.filename - Filename extracted from the file path
+   * @param {Function} options.log - Logging function
+   * @returns {{uuid: string, parentFolderId: string}|null} File info with uuid and parentFolderId, or null if not found
+   */
+  resolveFromDependencies({ resourceDependencies, filePath, filename, log: log3 }) {
+    if (!resourceDependencies)
+      return null;
+    const normalizedPath = import_node_path5.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^\.\.\/+/g, "").replace(/^\.\//, "");
+    for (const [depPath, info] of Object.entries(resourceDependencies)) {
+      if (depPath.startsWith("_"))
+        continue;
+      const normalizedDepPath = depPath.replace(/\\/g, "/");
+      if (normalizedDepPath === normalizedPath || normalizedDepPath.endsWith("/" + normalizedPath) || normalizedDepPath.endsWith(normalizedPath)) {
+        log3("debug", `Found exact path match in dependencies: ${depPath}`);
+        return info;
+      }
+    }
+    const parentDir = import_node_path5.default.dirname(normalizedPath);
+    const parentFolderName = import_node_path5.default.basename(parentDir);
+    for (const [depPath, info] of Object.entries(resourceDependencies)) {
+      if (depPath.startsWith("_"))
+        continue;
+      const depFilename = import_node_path5.default.basename(depPath);
+      const depParentDir = import_node_path5.default.dirname(depPath);
+      const depParentFolderName = import_node_path5.default.basename(depParentDir);
+      if (depFilename === filename && depParentFolderName === parentFolderName) {
+        log3("debug", `Found filename+folder match in dependencies: ${depPath}`);
+        return info;
+      }
+    }
+    for (const [depPath, info] of Object.entries(resourceDependencies)) {
+      if (depPath.startsWith("_"))
+        continue;
+      const depFilename = import_node_path5.default.basename(depPath);
+      if (depFilename === filename) {
+        log3("debug", `Found filename match in dependencies: ${depPath}`);
+        return info;
+      }
+    }
+    log3("debug", `No match found in dependencies for: ${filePath}`);
+    return null;
+  }
+  /**
+   * Finds the parent folder ID for a file path using resource dependencies.
+   * Returns the target folder name for API lookup if not found in dependencies.
+   * @param {Object} options - Resolution options
+   * @param {Object.<string, {uuid: string, parentFolderId: string}>} options.resourceDependencies - Map of resource paths to resource metadata.
+   *   Keys are relative file paths, values are objects with uuid and parentFolderId.
+   *   Special keys starting with '_' (e.g., '_ditamapParentFolderId') store internal metadata.
+   * @param {string} options.filePath - File path to find parent folder for (can be relative with ../ or ./ prefixes)
+   * @param {Function} options.log - Logging function with signature (level, message)
+   * @returns {{folderId: string|null, targetFolderName: string|null, ditamapParentFolderId: string|null}} Resolution result containing:
+   *   - folderId: The parent folder UUID if found in dependencies, null otherwise
+   *   - targetFolderName: The name of the target folder extracted from the file path
+   *   - ditamapParentFolderId: The ditamap's parent folder ID from dependencies (for API fallback lookup)
+   */
+  findParentFolderFromDependencies({ resourceDependencies, filePath, log: log3 }) {
+    const result = {
+      folderId: null,
+      targetFolderName: null,
+      ditamapParentFolderId: null
+    };
+    if (!resourceDependencies)
+      return result;
+    const normalizedPath = import_node_path5.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^(\.\.\/)+/g, "").replace(/^\.\//, "");
+    const parentDir = import_node_path5.default.dirname(normalizedPath);
+    const targetFolderName = import_node_path5.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_path5.default.dirname(depPath);
+      const depFolderName = import_node_path5.default.basename(depParentDir);
+      if (depFolderName === targetFolderName && info.parentFolderId) {
+        log3("debug", `Found sibling file ${depPath} with parent folder ID: ${info.parentFolderId}`);
+        result.folderId = info.parentFolderId;
+        return result;
+      }
+    }
+    for (const [depPath, info] of Object.entries(resourceDependencies)) {
+      if (depPath.startsWith("_"))
+        continue;
+      if (depPath.endsWith("/" + targetFolderName) || depPath === targetFolderName) {
+        log3("debug", `Found folder ${depPath} with ID: ${info.uuid}`);
+        result.folderId = info.uuid;
+        return result;
+      }
+    }
+    log3("debug", `Could not find parent folder '${targetFolderName}' in dependencies, will search via API`);
+    return result;
+  }
+  /**
+   * Gets a child folder within a parent folder by name.
+   * @param {Object} options - Search options
+   * @returns {Promise<string|null>} Child folder ID if found, null otherwise
+   */
+  async getChildFolderByName({ apiBaseUrl, apiToken, username, parentFolderId, folderName, log: log3 }) {
+    const folderUrl = new URL(`/rest/all-files/${parentFolderId}`, apiBaseUrl);
+    return new Promise((resolve, reject) => {
+      const protocol = folderUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: folderUrl.hostname,
+        port: folderUrl.port || (folderUrl.protocol === "https:" ? 443 : 80),
+        path: folderUrl.pathname,
+        method: "GET",
+        headers: {
+          "Authorization": `Basic ${authString}`,
+          "Accept": "application/xml"
+        }
+      };
+      log3("debug", `Looking for child folder '${folderName}' in parent ${parentFolderId}`);
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            try {
+              const escapedFolderName = folderName.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+              const folderMatch = data.match(new RegExp(`<folder\\s+name="${escapedFolderName}"\\s+id="([^"]+)"`, "i"));
+              if (folderMatch && folderMatch[1]) {
+                log3("debug", `Found child folder '${folderName}' with ID: ${folderMatch[1]}`);
+                resolve(folderMatch[1]);
+              } else {
+                log3("debug", `Child folder '${folderName}' not found in parent ${parentFolderId}`);
+                resolve(null);
+              }
+            } catch (parseError) {
+              log3("debug", `Error parsing folder contents: ${parseError.message}`);
+              resolve(null);
+            }
+          } else {
+            log3("debug", `Failed to get parent folder contents: ${res.statusCode}`);
+            resolve(null);
+          }
+        });
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.on("error", (error) => {
+        log3("debug", `Error getting folder contents: ${error.message}`);
+        resolve(null);
+      });
+      req.end();
+    });
+  }
+  /**
+   * Creates a new document in Heretto.
+   * @param {Object} options - Creation options
+   * @returns {Promise<Object>} Result with created: boolean, documentId: string (if successful or already exists)
+   */
+  async createDocument({ apiBaseUrl, apiToken, username, parentFolderId, filename, mimeType, log: log3 }) {
+    const createUrl = new URL(`/rest/all-files/${parentFolderId}`, apiBaseUrl);
+    const createBody = `<resource><name>${this.escapeXml(filename)}</name><mime-type>${mimeType}</mime-type></resource>`;
+    return new Promise((resolve, reject) => {
+      const protocol = createUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: createUrl.hostname,
+        port: createUrl.port || (createUrl.protocol === "https:" ? 443 : 80),
+        path: createUrl.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/xml",
+          "Authorization": `Basic ${authString}`,
+          "Content-Length": Buffer.byteLength(createBody)
+        }
+      };
+      log3("debug", `Creating document at ${createUrl.toString()}`);
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200 || res.statusCode === 201) {
+            try {
+              const idMatch = data.match(/id="([^"]+)"/);
+              if (idMatch && idMatch[1]) {
+                log3("debug", `Document created successfully with ID: ${idMatch[1]}`);
+                resolve({ created: true, documentId: idMatch[1] });
+              } else {
+                log3("warning", `Document created but could not parse ID from response: ${data}`);
+                reject(new Error("Could not parse document ID from create response"));
+              }
+            } catch (parseError) {
+              reject(new Error(`Failed to parse create response: ${parseError.message}`));
+            }
+          } else if (res.statusCode === 400 && data.includes("already exists")) {
+            log3("debug", `Document already exists in folder, will search for existing file`);
+            resolve({ created: false, existsInFolder: true, parentFolderId });
+          } else {
+            reject(new Error(`Create document failed with status ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Create document request error: ${error.message}`));
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.write(createBody);
+      req.end();
+    });
+  }
+  /**
+   * Gets file information from a specific folder.
+   * @param {Object} options - Options
+   * @returns {Promise<string|null>} File ID if found, null otherwise
+   */
+  async getFileInFolder({ apiBaseUrl, apiToken, username, folderId, filename, log: log3 }) {
+    const folderUrl = new URL(`/rest/all-files/${folderId}`, apiBaseUrl);
+    return new Promise((resolve, reject) => {
+      const protocol = folderUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: folderUrl.hostname,
+        port: folderUrl.port || (folderUrl.protocol === "https:" ? 443 : 80),
+        path: folderUrl.pathname,
+        method: "GET",
+        headers: {
+          "Authorization": `Basic ${authString}`,
+          "Accept": "application/xml"
+        }
+      };
+      log3("debug", `Getting folder contents: ${folderUrl.toString()}`);
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            try {
+              const escapedFilename = filename.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
+              const nameIdMatch = data.match(new RegExp(`id="([^"]+)"[^>]*name="${escapedFilename}"`, "i"));
+              const idNameMatch = data.match(new RegExp(`name="${escapedFilename}"[^>]*id="([^"]+)"`, "i"));
+              const match = nameIdMatch || idNameMatch;
+              if (match && match[1]) {
+                log3("debug", `Found file ${filename} with ID: ${match[1]}`);
+                resolve(match[1]);
+              } else {
+                log3("debug", `File ${filename} not found in folder ${folderId}`);
+                resolve(null);
+              }
+            } catch (parseError) {
+              log3("debug", `Error parsing folder contents: ${parseError.message}`);
+              resolve(null);
+            }
+          } else {
+            log3("debug", `Failed to get folder contents: ${res.statusCode}`);
+            resolve(null);
+          }
+        });
+      });
+      req.on("error", (error) => {
+        log3("debug", `Error getting folder contents: ${error.message}`);
+        resolve(null);
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.end();
+    });
+  }
+  /**
+   * Escapes special characters for XML.
+   * @param {string} str - String to escape
+   * @returns {string} Escaped string
+   */
+  escapeXml(str) {
+    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+  }
+  /**
+   * Searches for a folder in Heretto by name.
+   * @param {Object} options - Search options
+   * @returns {Promise<string|null>} Folder ID if found, null otherwise
+   */
+  async searchFolderByName({ apiBaseUrl, apiToken, username, folderName, log: log3 }) {
+    const searchUrl = new URL("/ezdnxtgen/api/search", apiBaseUrl);
+    const searchBody = JSON.stringify({
+      queryString: folderName,
+      searchResultType: "FOLDERS_ONLY"
+    });
+    return new Promise((resolve, reject) => {
+      const protocol = searchUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: searchUrl.hostname,
+        port: searchUrl.port || (searchUrl.protocol === "https:" ? 443 : 80),
+        path: searchUrl.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Basic ${authString}`,
+          "Content-Length": Buffer.byteLength(searchBody)
+        }
+      };
+      log3("debug", `Searching for folder: ${folderName}`);
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              if (!data || data.trim() === "") {
+                log3("debug", "Folder search returned empty response - no results found");
+                resolve(null);
+                return;
+              }
+              const result = JSON.parse(data);
+              if (result.searchResults && result.searchResults.length > 0) {
+                const match = result.searchResults.find((r) => r.name === folderName || r.title === folderName);
+                if (match) {
+                  log3("debug", `Found folder: ${folderName} with ID: ${match.uuid || match.id}`);
+                  resolve(match.uuid || match.id);
+                } else {
+                  log3("debug", `Exact folder match not found, using first result: ${result.searchResults[0].uuid || result.searchResults[0].id}`);
+                  resolve(result.searchResults[0].uuid || result.searchResults[0].id);
+                }
+              } else {
+                log3("debug", `No folders found matching: ${folderName}`);
+                resolve(null);
+              }
+            } catch (parseError) {
+              reject(new Error(`Failed to parse folder search response: ${parseError.message}`));
+            }
+          } else {
+            reject(new Error(`Folder search request failed with status ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Folder search request error: ${error.message}`));
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.write(searchBody);
+      req.end();
+    });
+  }
+  /**
+   * Searches for a file in Heretto by filename.
+   * @param {Object} options - Search options
+   * @returns {Promise<string|null>} Document ID if found, null otherwise
+   */
+  async searchFileByName({ apiBaseUrl, apiToken, username, filename, log: log3 }) {
+    const searchUrl = new URL("/ezdnxtgen/api/search", apiBaseUrl);
+    const searchBody = JSON.stringify({
+      queryString: filename,
+      searchResultType: "FILES_ONLY"
+    });
+    return new Promise((resolve, reject) => {
+      const protocol = searchUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: searchUrl.hostname,
+        port: searchUrl.port || (searchUrl.protocol === "https:" ? 443 : 80),
+        path: searchUrl.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Basic ${authString}`,
+          "Content-Length": Buffer.byteLength(searchBody)
+        }
+      };
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            try {
+              if (!data || data.trim() === "") {
+                log3("debug", "Search returned empty response - no results found");
+                resolve(null);
+                return;
+              }
+              const result = JSON.parse(data);
+              if (result.searchResults && result.searchResults.length > 0) {
+                const match = result.searchResults.find((r) => r.name === filename || r.title === filename);
+                if (match) {
+                  resolve(match.uuid || match.id);
+                } else {
+                  resolve(result.searchResults[0].uuid || result.searchResults[0].id);
+                }
+              } else {
+                resolve(null);
+              }
+            } catch (parseError) {
+              reject(new Error(`Failed to parse search response: ${parseError.message}`));
+            }
+          } else {
+            reject(new Error(`Search request failed with status ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Search request error: ${error.message}`));
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.write(searchBody);
+      req.end();
+    });
+  }
+  /**
+   * Uploads file content to Heretto.
+   * @param {Object} options - Upload options
+   * @returns {Promise<void>}
+   */
+  async uploadFile({ apiBaseUrl, apiToken, username, documentId, content, contentType, log: log3 }) {
+    const uploadUrl = new URL(`/rest/all-files/${documentId}/content`, apiBaseUrl);
+    return new Promise((resolve, reject) => {
+      const protocol = uploadUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: uploadUrl.hostname,
+        port: uploadUrl.port || (uploadUrl.protocol === "https:" ? 443 : 80),
+        path: uploadUrl.pathname,
+        method: "PUT",
+        headers: {
+          "Content-Type": contentType,
+          "Authorization": `Basic ${authString}`,
+          "Content-Length": Buffer.byteLength(content)
+        }
+      };
+      log3("debug", `Uploading to ${uploadUrl.toString()}`);
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode >= 200 && res.statusCode < 300) {
+            log3("debug", `Upload successful: ${res.statusCode}`);
+            resolve();
+          } else {
+            reject(new Error(`Upload failed with status ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Upload request error: ${error.message}`));
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.write(content);
+      req.end();
+    });
+  }
+  /**
+   * Gets document information from Heretto.
+   * @param {Object} options - Options
+   * @returns {Promise<Object>} Document info including id, name, mimeType, folderUuid, uri
+   */
+  async getDocumentInfo({ apiBaseUrl, apiToken, username, documentId, log: log3 }) {
+    const docUrl = new URL(`/rest/all-files/${documentId}`, apiBaseUrl);
+    return new Promise((resolve, reject) => {
+      const protocol = docUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: docUrl.hostname,
+        port: docUrl.port || (docUrl.protocol === "https:" ? 443 : 80),
+        path: docUrl.pathname,
+        method: "GET",
+        headers: {
+          "Authorization": `Basic ${authString}`,
+          "Accept": "application/xml"
+        }
+      };
+      log3("debug", `Getting document info: ${docUrl.toString()}`);
+      const req = protocol.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            try {
+              const resourceMatch = data.match(/<resource\s+([^>]+)>/);
+              let id = null;
+              let folderUuid = null;
+              if (resourceMatch) {
+                const attrs = resourceMatch[1];
+                const idMatch = attrs.match(/\bid="([^"]+)"/);
+                const folderMatch = attrs.match(/\bfolder-uuid="([^"]+)"/);
+                id = idMatch ? idMatch[1] : null;
+                folderUuid = folderMatch ? folderMatch[1] : null;
+              }
+              const nameMatch = data.match(/<name>([^<]+)<\/name>/);
+              const mimeMatch = data.match(/<mime-type>([^<]+)<\/mime-type>/);
+              const uriMatch = data.match(/<xmldb-uri>([^<]+)<\/xmldb-uri>/);
+              resolve({
+                id,
+                name: nameMatch ? nameMatch[1] : null,
+                mimeType: mimeMatch ? mimeMatch[1] : null,
+                folderUuid,
+                uri: uriMatch ? uriMatch[1] : null,
+                rawXml: data
+              });
+            } catch (parseError) {
+              reject(new Error(`Failed to parse document info: ${parseError.message}`));
+            }
+          } else {
+            reject(new Error(`Get document info failed with status ${res.statusCode}: ${data}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Get document info request error: ${error.message}`));
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.end();
+    });
+  }
+  /**
+   * Gets document content from Heretto.
+   * @param {Object} options - Options
+   * @returns {Promise<Buffer>} Document content as buffer
+   */
+  async getDocumentContent({ apiBaseUrl, apiToken, username, documentId, log: log3 }) {
+    const contentUrl = new URL(`/rest/all-files/${documentId}/content`, apiBaseUrl);
+    return new Promise((resolve, reject) => {
+      const protocol = contentUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
+      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
+      const options = {
+        hostname: contentUrl.hostname,
+        port: contentUrl.port || (contentUrl.protocol === "https:" ? 443 : 80),
+        path: contentUrl.pathname,
+        method: "GET",
+        headers: {
+          "Authorization": `Basic ${authString}`
+        }
+      };
+      log3("debug", `Getting document content: ${contentUrl.toString()}`);
+      const req = protocol.request(options, (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            resolve(Buffer.concat(chunks));
+          } else {
+            reject(new Error(`Get document content failed with status ${res.statusCode}`));
+          }
+        });
+      });
+      req.on("error", (error) => {
+        reject(new Error(`Get document content request error: ${error.message}`));
+      });
+      req.setTimeout(3e4, () => {
+        req.destroy(new Error("Request timeout"));
+      });
+      req.end();
+    });
+  }
+  /**
+   * Determines the content type based on file extension.
+   * @param {string} filePath - File path
+   * @returns {string} MIME content type
+   */
+  getContentType(filePath) {
+    const ext = import_node_path5.default.extname(filePath).toLowerCase();
+    const contentTypes = {
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".svg": "image/svg+xml",
+      ".webp": "image/webp",
+      ".bmp": "image/bmp",
+      ".ico": "image/x-icon",
+      ".pdf": "application/pdf",
+      ".xml": "application/xml",
+      ".dita": "application/xml",
+      ".ditamap": "application/xml"
+    };
+    return contentTypes[ext] || "application/octet-stream";
+  }
+};
+var POLLING_INTERVAL_MS = 5e3;
+var POLLING_TIMEOUT_MS = 3e5;
+var API_REQUEST_TIMEOUT_MS = 3e4;
+var DOWNLOAD_TIMEOUT_MS = 3e5;
+var DEFAULT_SCENARIO_NAME = "Doc Detective";
+function createAuthHeader(username, apiToken) {
+  const credentials = `${username}:${apiToken}`;
+  return Buffer.from(credentials).toString("base64");
+}
+function getBaseUrl(organizationId) {
+  return `https://${organizationId}.heretto.com/ezdnxtgen/api/v2`;
+}
+function validateDitamapInAssets(assets) {
+  return assets.some((assetPath) => assetPath.startsWith("ot-output/dita/") && assetPath.endsWith(".ditamap"));
+}
+function createApiClient(herettoConfig) {
+  const authHeader = createAuthHeader(herettoConfig.username, herettoConfig.apiToken);
+  return import_axios3.default.create({
+    baseURL: getBaseUrl(herettoConfig.organizationId),
+    timeout: API_REQUEST_TIMEOUT_MS,
+    headers: {
+      Authorization: `Basic ${authHeader}`,
+      "Content-Type": "application/json"
+    }
+  });
+}
+function createRestApiClient(herettoConfig) {
+  const authHeader = createAuthHeader(herettoConfig.username, herettoConfig.apiToken);
+  return import_axios3.default.create({
+    baseURL: `https://${herettoConfig.organizationId}.heretto.com`,
+    timeout: API_REQUEST_TIMEOUT_MS,
+    headers: {
+      Authorization: `Basic ${authHeader}`,
+      Accept: "application/xml, text/xml, */*"
+    }
+  });
+}
+async function findScenario(client, log3, config, scenarioName) {
+  try {
+    const scenariosResp = await client.get("/publishes/scenarios");
+    const scenarios = scenariosResp.data.content || [];
+    const foundScenario = scenarios.find((s) => s.name === scenarioName);
+    if (!foundScenario) {
+      log3(config, "error", `No existing "${scenarioName}" scenario found.`);
+      return null;
+    }
+    const paramsResp = await client.get(`/publishes/scenarios/${foundScenario.id}/parameters`);
+    const scenarioParameters = paramsResp.data;
+    if (!scenarioParameters) {
+      log3(config, "error", `Failed to retrieve scenario details for ID: ${foundScenario.id}`);
+      return null;
+    }
+    log3(config, "debug", `Scenario parameters: ${JSON.stringify(scenarioParameters.content?.map((p) => ({ name: p.name, type: p.type, value: p.value })))}`);
+    const transtypeParam = scenarioParameters.content?.find((param) => param.name === "transtype");
+    if (!transtypeParam || transtypeParam.value !== "dita" && transtypeParam.options?.[0]?.value !== "dita") {
+      log3(config, "error", `Existing "${scenarioName}" scenario: "transtype" must be set to "dita".`);
+      return null;
+    }
+    const toolKitParam = scenarioParameters.content?.find((param) => param.name === "tool-kit-name");
+    if (!toolKitParam || !toolKitParam.value) {
+      log3(config, "error", `Existing "${scenarioName}" scenario has incorrect "tool-kit-name" parameter settings.`);
+      return null;
+    }
+    const fileUuidPickerParam = scenarioParameters.content?.find((param) => param.type === "file_uuid_picker");
+    if (!fileUuidPickerParam || !fileUuidPickerParam.value) {
+      log3(config, "error", `Existing "${scenarioName}" scenario has incorrect "file_uuid_picker" parameter settings. Make sure it has a valid value.`);
+      return null;
+    }
+    log3(config, "debug", `Found existing "${scenarioName}" scenario: ${foundScenario.id}`);
+    return {
+      scenarioId: foundScenario.id,
+      fileId: fileUuidPickerParam.value
+    };
+  } catch (error) {
+    log3(config, "error", `Failed to find publishing scenario: ${error.message}`);
+    return null;
+  }
+}
+async function triggerPublishingJob(client, fileId, scenarioId) {
+  const response = await client.post(`/files/${fileId}/publishes`, {
+    scenario: scenarioId,
+    parameters: []
+  });
+  if (!response.data?.jobId) {
+    throw new Error("Publishing job response missing jobId");
+  }
+  return response.data;
+}
+async function getJobStatus(client, fileId, jobId) {
+  const response = await client.get(`/files/${fileId}/publishes/${jobId}`);
+  return response.data;
+}
+async function getJobAssetDetails(client, fileId, jobId, log3, config) {
+  const allAssets = [];
+  let page = 0;
+  const pageSize = 100;
+  const maxPages = 1e3;
+  let hasMorePages = true;
+  while (hasMorePages && page < maxPages) {
+    const response = await client.get(`/files/${fileId}/publishes/${jobId}/assets`, { params: { page, size: pageSize } });
+    const data = response.data;
+    const content = data.content || [];
+    for (const asset of content) {
+      if (asset.filePath) {
+        allAssets.push(asset.filePath);
+      }
+    }
+    const totalPages = data.totalPages || 1;
+    page++;
+    hasMorePages = page < totalPages;
+    if (page === maxPages && totalPages > maxPages && log3) {
+      log3(config, "warning", `Job ${jobId} asset pagination truncated at ${maxPages} pages (API reports ${totalPages} total). Asset list may be incomplete.`);
+    }
+  }
+  return allAssets;
+}
+async function pollJobStatus(client, fileId, jobId, log3, config) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < POLLING_TIMEOUT_MS) {
+    try {
+      const job = await getJobStatus(client, fileId, jobId);
+      log3(config, "debug", `Job ${jobId} status: ${job?.status?.status}`);
+      if (job?.status?.result) {
+        log3(config, "debug", `Job ${jobId} completed with result: ${job.status.result}`);
+        if (job.status.result !== "success") {
+          log3(config, "warning", `Publishing job ${jobId} finished with non-success result: ${job.status.result}. Checking if output files are available...`);
+        }
+        try {
+          const assets = await getJobAssetDetails(client, fileId, jobId, log3, config);
+          log3(config, "debug", `Job ${jobId} has ${assets.length} assets`);
+          if (validateDitamapInAssets(assets)) {
+            log3(config, "debug", `Found .ditamap file in ot-output/dita/`);
+            if (job.status.result !== "success") {
+              log3(config, "info", `Publishing job ${jobId} result was "${job.status.result}" but required output files are present. Proceeding.`);
+            }
+            return job;
+          }
+          log3(config, "warning", `Publishing job ${jobId} completed but no .ditamap file found in ot-output/dita/`);
+          return null;
+        } catch (assetError) {
+          log3(config, "warning", `Failed to validate job assets: ${assetError.message}`);
+          return null;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, POLLING_INTERVAL_MS));
+    } catch (error) {
+      log3(config, "warning", `Error polling job status: ${error.message}`);
+      return null;
+    }
+  }
+  log3(config, "warning", `Publishing job ${jobId} timed out after ${POLLING_TIMEOUT_MS / 1e3} seconds`);
+  return null;
+}
+async function downloadAndExtractOutput(client, fileId, jobId, herettoName, log3, config, deps) {
+  const fsModule = deps?.fsModule || import_node_fs4.default;
+  const ZipClass = deps?.ZipClass || import_adm_zip.default;
+  const tempDir = import_node_path5.default.join(import_node_os3.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_path5.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_path5.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_path5.default.resolve(outputDir);
+    for (const entry of zip.getEntries()) {
+      const normalizedName = import_node_path5.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_path5.default.resolve(outputDir, normalizedName);
+      if (!resolvedPath.startsWith(resolvedOutputDir + import_node_path5.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_path5.default.dirname(resolvedPath), { recursive: true });
+        fsModule.writeFileSync(resolvedPath, entry.getData());
+      }
+    }
+    fsModule.unlinkSync(zipPath);
+    log3(config, "info", `Heretto content "${herettoName}" extracted to ${outputDir}`);
+    return outputDir;
+  } catch (error) {
+    try {
+      const zipCleanupPath = import_node_path5.default.join(tempDir, `heretto_${hash}.zip`);
+      if (fsModule.existsSync(zipCleanupPath)) {
+        fsModule.unlinkSync(zipCleanupPath);
+      }
+    } catch {
+    }
+    try {
+      const cleanupOutputDir = import_node_path5.default.join(tempDir, `heretto_${hash}`);
+      if (fsModule.existsSync(cleanupOutputDir)) {
+        fsModule.rmSync(cleanupOutputDir, { recursive: true, force: true });
+      }
+    } catch {
+    }
+    log3(config, "warning", `Failed to download or extract output: ${error.message}`);
+    return null;
+  }
+}
+async function getResourceDependencies(restClient, ditamapId, log3, config) {
+  const { XMLParser } = await import("fast-xml-parser");
+  const xmlParser = new XMLParser({
+    ignoreAttributes: false,
+    attributeNamePrefix: "@_"
+  });
+  const pathToUuidMap = {};
+  const REST_API_PATH = "/rest/all-files";
+  try {
+    log3(config, "debug", `Fetching ditamap info for: ${ditamapId}`);
+    const ditamapInfo = await restClient.get(`${REST_API_PATH}/${ditamapId}`);
+    const ditamapParsed = xmlParser.parse(ditamapInfo.data);
+    const ditamapUri = ditamapParsed.resource?.["xmldb-uri"] || ditamapParsed["@_uri"];
+    const ditamapName = ditamapParsed.resource?.name || ditamapParsed["@_name"];
+    const ditamapParentFolder = ditamapParsed.resource?.["folder-uuid"] || ditamapParsed.resource?.["@_folder-uuid"] || ditamapParsed["@_folder-uuid"];
+    if (ditamapUri) {
+      let relativePath = ditamapUri;
+      const orgPathMatch = relativePath?.match(/\/db\/organizations\/[^/]+\/(.+)/);
+      if (orgPathMatch) {
+        relativePath = orgPathMatch[1];
+      }
+      pathToUuidMap[relativePath] = {
+        uuid: ditamapId,
+        fullPath: ditamapUri,
+        name: ditamapName,
+        parentFolderId: ditamapParentFolder,
+        isDitamap: true
+      };
+      pathToUuidMap._ditamapPath = relativePath;
+      pathToUuidMap._ditamapId = ditamapId;
+      pathToUuidMap._ditamapParentFolderId = ditamapParentFolder;
+    }
+  } catch (ditamapError) {
+    log3(config, "warning", `Could not get ditamap info: ${ditamapError.message}`);
+  }
+  try {
+    log3(config, "debug", `Fetching resource dependencies for ditamap: ${ditamapId}`);
+    const response = await restClient.get(`${REST_API_PATH}/${ditamapId}/dependencies`);
+    const parsed = xmlParser.parse(response.data);
+    const extractDependencies = (obj) => {
+      if (!obj)
+        return;
+      let dependencies = obj.dependencies?.dependency || obj.dependency;
+      if (!dependencies) {
+        if (obj["@_id"] && obj["@_uri"]) {
+          dependencies = [obj];
+        } else if (Array.isArray(obj)) {
+          dependencies = obj;
+        }
+      }
+      if (!dependencies)
+        return;
+      if (!Array.isArray(dependencies)) {
+        dependencies = [dependencies];
+      }
+      for (const dep of dependencies) {
+        const uuid = dep["@_id"] || dep["@_uuid"] || dep.id || dep.uuid;
+        const uri = dep["@_uri"] || dep["@_path"] || dep.uri || dep.path || dep["xmldb-uri"];
+        const name = dep["@_name"] || dep.name;
+        const parentFolderId = dep["@_folder-uuid"] || dep["@_parent"] || dep["folder-uuid"];
+        if (uuid && (uri || name)) {
+          let relativePath = uri || name;
+          const orgPathMatch = relativePath?.match(/\/db\/organizations\/[^/]+\/(.+)/);
+          if (orgPathMatch) {
+            relativePath = orgPathMatch[1];
+          }
+          pathToUuidMap[relativePath] = {
+            uuid,
+            fullPath: uri,
+            name: name || import_node_path5.default.basename(relativePath || ""),
+            parentFolderId
+          };
+        }
+        if (dep.dependencies || dep.dependency) {
+          extractDependencies(dep);
+        }
+      }
+    };
+    extractDependencies(parsed);
+    log3(config, "info", `Retrieved ${Object.keys(pathToUuidMap).length} resource dependencies from Heretto`);
+  } catch (error) {
+    const statusCode = error.response?.status;
+    log3(config, "debug", `Dependencies endpoint not available (${statusCode}), will use ditamap info as fallback`);
+  }
+  return pathToUuidMap;
+}
+async function loadHerettoContent(herettoConfig, log3, config, deps) {
+  const createApiClientFn = deps?.createApiClientFn || createApiClient;
+  const createRestApiClientFn = deps?.createRestApiClientFn || createRestApiClient;
+  const downloadFn = deps?.downloadFn || downloadAndExtractOutput;
+  const getResourceDependenciesFn = deps?.getResourceDependenciesFn || getResourceDependencies;
+  log3(config, "info", `Loading content from Heretto "${herettoConfig.name}"...`);
+  try {
+    const client = createApiClientFn(herettoConfig);
+    const restClient = createRestApiClientFn(herettoConfig);
+    const scenarioName = herettoConfig.scenarioName || DEFAULT_SCENARIO_NAME;
+    const scenario = await findScenario(client, log3, config, scenarioName);
+    if (!scenario) {
+      log3(config, "warning", `Skipping Heretto "${herettoConfig.name}" - could not find publishing scenario`);
+      return null;
+    }
+    if (herettoConfig.uploadOnChange) {
+      log3(config, "debug", `Fetching resource dependencies for ditamap ${scenario.fileId}...`);
+      const resourceDependencies = await getResourceDependenciesFn(restClient, scenario.fileId, log3, config);
+      herettoConfig.resourceDependencies = {
+        ...resourceDependencies,
+        ...herettoConfig.resourceDependencies || {}
+      };
+    }
+    log3(config, "debug", `Triggering publishing job for file ${scenario.fileId}...`);
+    const job = await triggerPublishingJob(client, scenario.fileId, scenario.scenarioId);
+    log3(config, "debug", `Publishing job started: ${job.jobId}`);
+    log3(config, "info", `Waiting for publishing job to complete...`);
+    const completedJob = await pollJobStatus(client, scenario.fileId, job.jobId, log3, config);
+    if (!completedJob) {
+      log3(config, "warning", `Skipping Heretto "${herettoConfig.name}" - publishing job failed or timed out`);
+      return null;
+    }
+    const outputPath = await downloadFn(client, scenario.fileId, job.jobId, herettoConfig.name, log3, config);
+    return outputPath;
+  } catch (error) {
+    log3(config, "warning", `Failed to load Heretto "${herettoConfig.name}": ${error.message}`);
+    return null;
+  }
+}
+
 // dist/core/detectTests.js
 async function detectTests2({ config }) {
   const files = await qualifyFiles({ config });
@@ -130543,15 +132294,15 @@ async function detectTests2({ config }) {
   return specs;
 }
 function generateSpecId(filePath) {
-  const absolutePath = import_node_path5.default.resolve(filePath);
+  const absolutePath = import_node_path6.default.resolve(filePath);
   const cwd = process.cwd();
   let relativePath;
   if (absolutePath.startsWith(cwd)) {
-    relativePath = import_node_path5.default.relative(cwd, absolutePath);
+    relativePath = import_node_path6.default.relative(cwd, absolutePath);
   } else {
     relativePath = absolutePath;
   }
-  const normalizedPath = relativePath.split(import_node_path5.default.sep).join("/").replace(/^\.\//, "").replace(/[^a-zA-Z0-9._\-\/]/g, "_");
+  const normalizedPath = relativePath.split(import_node_path6.default.sep).join("/").replace(/^\.\//, "").replace(/[^a-zA-Z0-9._\-\/]/g, "_");
   return normalizedPath;
 }
 async function isValidSourceFile({ config, files, source }) {
@@ -130562,7 +132313,7 @@ async function isValidSourceFile({ config, files, source }) {
   });
   if (files.indexOf(source) >= 0)
     return false;
-  if (import_node_path5.default.extname(source) === ".json" || import_node_path5.default.extname(source) === ".yaml" || import_node_path5.default.extname(source) === ".yml") {
+  if (import_node_path6.default.extname(source) === ".json" || import_node_path6.default.extname(source) === ".yaml" || import_node_path6.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.`);
@@ -130582,11 +132333,11 @@ async function isValidSourceFile({ config, files, source }) {
       if (test.before) {
         let beforePath = "";
         if (config.relativePathBase === "file") {
-          beforePath = import_node_path5.default.resolve(import_node_path5.default.dirname(source), test.before);
+          beforePath = import_node_path6.default.resolve(import_node_path6.default.dirname(source), test.before);
         } else {
-          beforePath = import_node_path5.default.resolve(test.before);
+          beforePath = import_node_path6.default.resolve(test.before);
         }
-        if (!import_node_fs4.default.existsSync(beforePath)) {
+        if (!import_node_fs5.default.existsSync(beforePath)) {
           log(config, "debug", `${beforePath} is specified to run before a test but isn't a valid file. Skipping ${source}.`);
           return false;
         }
@@ -130594,18 +132345,18 @@ async function isValidSourceFile({ config, files, source }) {
       if (test.after) {
         let afterPath = "";
         if (config.relativePathBase === "file") {
-          afterPath = import_node_path5.default.resolve(import_node_path5.default.dirname(source), test.after);
+          afterPath = import_node_path6.default.resolve(import_node_path6.default.dirname(source), test.after);
         } else {
-          afterPath = import_node_path5.default.resolve(test.after);
+          afterPath = import_node_path6.default.resolve(test.after);
         }
-        if (!import_node_fs4.default.existsSync(afterPath)) {
+        if (!import_node_fs5.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_path5.default.extname(source).substring(1);
+  const extension = import_node_path6.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;
@@ -130613,12 +132364,12 @@ async function isValidSourceFile({ config, files, source }) {
   return true;
 }
 async function processDitaMap({ config, source }) {
-  const hash = import_node_crypto2.default.createHash("md5").update(source).digest("hex");
-  const tmpBase = import_node_path5.default.join(import_node_os3.default.tmpdir(), "doc-detective");
-  const outputDir = import_node_path5.default.join(tmpBase, `ditamap_${hash}`);
-  if (!import_node_fs4.default.existsSync(tmpBase)) {
+  const hash = import_node_crypto3.default.createHash("md5").update(source).digest("hex");
+  const tmpBase = import_node_path6.default.join(import_node_os4.default.tmpdir(), "doc-detective");
+  const outputDir = import_node_path6.default.join(tmpBase, `ditamap_${hash}`);
+  if (!import_node_fs5.default.existsSync(tmpBase)) {
     log(config, "debug", `Creating temp directory: ${tmpBase}`);
-    import_node_fs4.default.mkdirSync(tmpBase, { recursive: true });
+    import_node_fs5.default.mkdirSync(tmpBase, { recursive: true });
   }
   const ditaVersion = await spawnCommand("dita", ["--version"]);
   if (ditaVersion.exitCode !== 0) {
@@ -130660,10 +132411,52 @@ async function qualifyFiles({ config }) {
   if (!config._herettoPathMapping) {
     config._herettoPathMapping = {};
   }
-  for (let source of sequence) {
+  for (let i = 0; i < sequence.length; i++) {
+    let source = sequence[i];
     log(config, "debug", `source: ${source}`);
     if (source.startsWith("heretto:")) {
-      log(config, "warning", `Heretto integration "${source}" is not supported in core. Use the resolver module for Heretto support.`);
+      const herettoName = source.substring(8);
+      const herettoConfig = config?.integrations?.heretto?.find((h) => h.name === herettoName);
+      if (!herettoConfig) {
+        log(config, "warning", `Heretto integration "${herettoName}" not found in config. Skipping.`);
+        continue;
+      }
+      if (!herettoConfig.outputPath) {
+        try {
+          const outputPath = await loadHerettoContent(herettoConfig, log, config);
+          if (outputPath) {
+            herettoConfig.outputPath = outputPath;
+            config._herettoPathMapping[outputPath] = herettoName;
+            sequence.splice(i + 1, 0, outputPath);
+            ignoredDitaMaps.push(outputPath);
+          } else {
+            log(config, "warning", `Failed to load Heretto content for "${herettoName}". Skipping.`);
+          }
+        } catch (error) {
+          log(config, "warning", `Failed to load Heretto content from "${herettoName}": ${error.message}`);
+        }
+      } else {
+        config._herettoPathMapping[herettoConfig.outputPath] = herettoName;
+        if (!ignoredDitaMaps.includes(herettoConfig.outputPath)) {
+          ignoredDitaMaps.push(herettoConfig.outputPath);
+        }
+        if (!sequence.includes(herettoConfig.outputPath)) {
+          sequence.splice(i + 1, 0, herettoConfig.outputPath);
+        }
+        if (herettoConfig.uploadOnChange && !herettoConfig.resourceDependencies) {
+          try {
+            const client = createApiClient(herettoConfig);
+            const scenarioName = herettoConfig.scenarioName || DEFAULT_SCENARIO_NAME;
+            const scenario = await findScenario(client, log, config, scenarioName);
+            if (scenario) {
+              const restClient = createRestApiClient(herettoConfig);
+              herettoConfig.resourceDependencies = await getResourceDependencies(restClient, scenario.fileId, log, config);
+            }
+          } catch (error) {
+            log(config, "warning", `Failed to fetch resource dependencies for "${herettoName}": ${error.message}`);
+          }
+        }
+      }
       continue;
     }
     let isURL = source.startsWith("http://") || source.startsWith("https://");
@@ -130678,13 +132471,13 @@ async function qualifyFiles({ config }) {
     let isFile = false;
     let isDir = false;
     try {
-      isFile = import_node_fs4.default.statSync(source).isFile();
-      isDir = import_node_fs4.default.statSync(source).isDirectory();
+      isFile = import_node_fs5.default.statSync(source).isFile();
+      isDir = import_node_fs5.default.statSync(source).isDirectory();
     } catch {
       log(config, "warning", `Cannot access path: ${source}. Skipping.`);
       continue;
     }
-    if (isFile && import_node_path5.default.extname(source) === ".ditamap" && !ignoredDitaMaps.some((ignored) => source.includes(ignored)) && config.processDitaMaps) {
+    if (isFile && import_node_path6.default.extname(source) === ".ditamap" && !ignoredDitaMaps.some((ignored) => source.includes(ignored)) && config.processDitaMaps) {
       const ditaOutput = await processDitaMap({ config, source });
       if (ditaOutput) {
         const currentIndex = sequence.indexOf(source);
@@ -130694,20 +132487,20 @@ async function qualifyFiles({ config }) {
       continue;
     }
     if (isFile && await isValidSourceFile({ config, files, source })) {
-      files.push(import_node_path5.default.resolve(source));
+      files.push(import_node_path6.default.resolve(source));
     } else if (isDir) {
       dirs = [];
       dirs[0] = source;
       for (const dir of dirs) {
-        const objects = import_node_fs4.default.readdirSync(dir);
+        const objects = import_node_fs5.default.readdirSync(dir);
         for (const object of objects) {
-          const content = import_node_path5.default.resolve(dir + "/" + object);
+          const content = import_node_path6.default.resolve(dir + "/" + object);
           if (content.includes("node_modules"))
             continue;
-          const isFile2 = import_node_fs4.default.statSync(content).isFile();
-          const isDir2 = import_node_fs4.default.statSync(content).isDirectory();
+          const isFile2 = import_node_fs5.default.statSync(content).isFile();
+          const isDir2 = import_node_fs5.default.statSync(content).isDirectory();
           if (isFile2 && await isValidSourceFile({ config, files, source: content })) {
-            files.push(import_node_path5.default.resolve(content));
+            files.push(import_node_path6.default.resolve(content));
           } else if (isDir2 && config.recursive) {
             dirs.push(content);
           }
@@ -130721,12 +132514,12 @@ async function parseTests({ config, files }) {
   let specs = [];
   for (const file of files) {
     log(config, "debug", `file: ${file}`);
-    const extension = import_node_path5.default.extname(file).slice(1);
+    const extension = import_node_path6.default.extname(file).slice(1);
     let content = "";
     let rawContent;
     if (extension === "json" || extension === "yaml" || extension === "yml") {
       try {
-        rawContent = await import_node_fs4.default.promises.readFile(file, "utf8");
+        rawContent = await import_node_fs5.default.promises.readFile(file, "utf8");
         if (extension === "json") {
           content = JSON.parse(rawContent);
         } else {
@@ -130915,7 +132708,7 @@ async function parseTests({ config, files }) {
 }
 
 // dist/core/resolveTests.js
-var import_node_crypto3 = __toESM(require("node:crypto"), 1);
+var import_node_crypto4 = __toESM(require("node:crypto"), 1);
 var driverActions = [
   "click",
   "dragAndDrop",
@@ -131014,7 +132807,7 @@ ${JSON.stringify(openApiDocuments, null, 2)}`);
   return openApiDocuments;
 }
 async function resolveContext({ config, test, context }) {
-  const contextId = context.contextId || import_node_crypto3.default.randomUUID();
+  const contextId = context.contextId || import_node_crypto4.default.randomUUID();
   log(config, "debug", `RESOLVING CONTEXT ID ${contextId}:
 ${JSON.stringify(context, null, 2)}`);
   const resolvedContext = {
@@ -131029,7 +132822,7 @@ ${JSON.stringify(resolvedContext, null, 2)}`);
   return resolvedContext;
 }
 async function resolveTest({ config, spec, test }) {
-  const testId = test.testId || import_node_crypto3.default.randomUUID();
+  const testId = test.testId || import_node_crypto4.default.randomUUID();
   log(config, "debug", `RESOLVING TEST ID ${testId}:
 ${JSON.stringify(test, null, 2)}`);
   const resolvedTest = {
@@ -131061,7 +132854,7 @@ ${JSON.stringify(resolvedTest, null, 2)}`);
   return resolvedTest;
 }
 async function resolveSpec({ config, spec }) {
-  const specId = spec.specId || import_node_crypto3.default.randomUUID();
+  const specId = spec.specId || import_node_crypto4.default.randomUUID();
   log(config, "debug", `RESOLVING SPEC ID ${specId}:
 ${JSON.stringify(spec, null, 2)}`);
   const resolvedSpec = {
@@ -131090,7 +132883,7 @@ async function resolveTests({ config, detectedTests }) {
   log(config, "debug", `RESOLVING DETECTED TEST SPECS:
 ${JSON.stringify(detectedTests, null, 2)}`);
   const resolvedTests = {
-    resolvedTestsId: import_node_crypto3.default.randomUUID(),
+    resolvedTestsId: import_node_crypto4.default.randomUUID(),
     config,
     specs: []
   };
@@ -131107,8 +132900,8 @@ ${JSON.stringify(resolvedTests, null, 2)}`);
 // dist/core/tests.js
 var import_tree_kill = __toESM(require("tree-kill"), 1);
 var wdio = __toESM(require("webdriverio"), 1);
-var import_node_os6 = __toESM(require("node:os"), 1);
-var import_axios5 = __toESM(require("axios"), 1);
+var import_node_os7 = __toESM(require("node:os"), 1);
+var import_axios6 = __toESM(require("axios"), 1);
 
 // dist/core/tests/moveTo.js
 async function instantiateCursor(driver, options = { position: "current" }) {
@@ -132328,8 +134121,8 @@ async function waitForDOMStable(driver, idleTime, timeout) {
 }
 
 // dist/core/tests/runShell.js
-var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path6 = __toESM(require("node:path"), 1);
+var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path7 = __toESM(require("node:path"), 1);
 async function runShell({ config, step }) {
   const result = {
     status: "PASS",
@@ -132402,24 +134195,24 @@ async function runShell({ config, step }) {
     }
   }
   if (step.runShell.path) {
-    const dir = import_node_path6.default.dirname(step.runShell.path);
-    if (!import_node_fs5.default.existsSync(dir)) {
-      import_node_fs5.default.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path7.default.dirname(step.runShell.path);
+    if (!import_node_fs6.default.existsSync(dir)) {
+      import_node_fs6.default.mkdirSync(dir, { recursive: true });
     }
     let filePath = step.runShell.path;
     log(config, "debug", `Saving stdio to file: ${filePath}`);
-    if (!import_node_fs5.default.existsSync(filePath)) {
-      import_node_fs5.default.writeFileSync(filePath, result.outputs.stdio.stdout);
+    if (!import_node_fs6.default.existsSync(filePath)) {
+      import_node_fs6.default.writeFileSync(filePath, result.outputs.stdio.stdout);
     } else {
       if (step.runShell.overwrite == "false") {
         result.description = result.description + ` Didn't save output. File already exists.`;
       }
-      const existingFile = import_node_fs5.default.readFileSync(filePath, "utf8");
+      const existingFile = import_node_fs6.default.readFileSync(filePath, "utf8");
       const fractionalDiff = calculateFractionalDifference(existingFile, result.outputs.stdio.stdout);
       log(config, "debug", `Fractional difference: ${fractionalDiff}`);
       if (fractionalDiff > step.runShell.maxVariation) {
         if (step.runShell.overwrite == "aboveVariation") {
-          import_node_fs5.default.writeFileSync(filePath, result.outputs.stdio.stdout);
+          import_node_fs6.default.writeFileSync(filePath, result.outputs.stdio.stdout);
           result.description += ` Saved output to file.`;
         }
         result.status = "WARNING";
@@ -132427,7 +134220,7 @@ async function runShell({ config, step }) {
         return result;
       }
       if (step.runShell.overwrite == "true") {
-        import_node_fs5.default.writeFileSync(filePath, result.outputs.stdio.stdout);
+        import_node_fs6.default.writeFileSync(filePath, result.outputs.stdio.stdout);
         result.description += ` Saved output to file.`;
       }
     }
@@ -132436,7 +134229,103 @@ async function runShell({ config, step }) {
 }
 
 // dist/core/tests/checkLink.js
-var import_axios3 = __toESM(require("axios"), 1);
+var import_axios4 = __toESM(require("axios"), 1);
+var DEFAULT_HEADERS = {
+  "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9",
+  "Accept-Encoding": "gzip, deflate, br",
+  "Upgrade-Insecure-Requests": "1",
+  "Sec-Fetch-Site": "none",
+  "Sec-Fetch-Mode": "navigate",
+  "Sec-Fetch-Dest": "document",
+  "Sec-Fetch-User": "?1",
+  "Sec-Ch-Ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
+  "Sec-Ch-Ua-Mobile": "?0",
+  "Sec-Ch-Ua-Platform": '"Windows"'
+};
+var MAX_ATTEMPTS = 4;
+var BASE_BACKOFF_MS = 1e3;
+var MAX_RETRY_AFTER_MS = 1e4;
+function parseHeaderString(raw) {
+  const out = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const idx = line.indexOf(":");
+    if (idx === -1)
+      continue;
+    const key = line.slice(0, idx).trim();
+    const value = line.slice(idx + 1).trim();
+    if (key && value)
+      out[key] = value;
+  }
+  return out;
+}
+function mergeHeaders(userHeaders) {
+  const merged = { ...DEFAULT_HEADERS };
+  if (!userHeaders)
+    return merged;
+  const parsed = typeof userHeaders === "string" ? parseHeaderString(userHeaders) : userHeaders;
+  for (const userKey of Object.keys(parsed)) {
+    const raw = parsed[userKey];
+    if (raw === null || raw === void 0)
+      continue;
+    const value = typeof raw === "string" ? raw : String(raw);
+    const lower = userKey.toLowerCase();
+    for (const existingKey of Object.keys(merged)) {
+      if (existingKey.toLowerCase() === lower)
+        delete merged[existingKey];
+    }
+    merged[userKey] = value;
+  }
+  return merged;
+}
+function parseRetryAfter(value) {
+  const candidate = Array.isArray(value) ? value[0] : value;
+  if (typeof candidate !== "string" && typeof candidate !== "number")
+    return null;
+  const str = String(candidate).trim();
+  if (!str)
+    return null;
+  const seconds = Number(str);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS));
+  }
+  const date = Date.parse(str);
+  if (!Number.isNaN(date)) {
+    return Math.max(0, Math.min(date - Date.now(), MAX_RETRY_AFTER_MS));
+  }
+  return null;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetry(statusCode) {
+  if (statusCode === null)
+    return false;
+  return statusCode === 429 || statusCode >= 500;
+}
+async function attemptRequest(method, url, headers) {
+  try {
+    const res = await import_axios4.default.request({
+      method,
+      url,
+      headers,
+      timeout: 1e4,
+      maxRedirects: 5,
+      validateStatus: () => true
+    });
+    const retryAfter = parseRetryAfter(res.headers?.["retry-after"] ?? res.headers?.["Retry-After"]);
+    return { statusCode: res.status, retryAfter };
+  } catch (error) {
+    if (error?.response?.status) {
+      return {
+        statusCode: error.response.status,
+        retryAfter: parseRetryAfter(error.response.headers?.["retry-after"] ?? error.response.headers?.["Retry-After"])
+      };
+    }
+    return { statusCode: null, retryAfter: null };
+  }
+}
 async function checkLink({ config, step }) {
   let result = { status: "PASS", description: "Checked link." };
   if (typeof step.checkLink === "string") {
@@ -132468,43 +134357,46 @@ async function checkLink({ config, step }) {
   } else if (typeof step.checkLink.statusCodes === "number") {
     step.checkLink.statusCodes = [step.checkLink.statusCodes];
   }
-  const requestConfig = {
-    headers: {
-      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
-      "Accept-Language": "en-US,en;q=0.9"
-    },
-    timeout: 1e4,
-    // 10 second timeout
-    maxRedirects: 5
-  };
-  let req = await import_axios3.default.get(step.checkLink.url, requestConfig).then((res) => {
-    return { statusCode: res.status };
-  }).catch((error) => {
-    return { error };
-  });
-  if (req.error) {
-    result.status = "FAIL";
-    if (req.error.response && req.error.response.status) {
-      result.description = `Returned ${req.error.response.status}. Expected one of ${JSON.stringify(step.checkLink.statusCodes)}`;
-    } else {
-      result.description = `Invalid or unresolvable URL: ${step.checkLink.url}`;
+  const headers = mergeHeaders(step.checkLink.headers);
+  const url = step.checkLink.url;
+  const acceptedCodes = step.checkLink.statusCodes;
+  const isAccepted = (code) => code !== null && acceptedCodes.indexOf(code) >= 0;
+  let last = { statusCode: null, retryAfter: null };
+  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+    last = await attemptRequest("get", url, headers);
+    if (isAccepted(last.statusCode))
+      break;
+    if (!shouldRetry(last.statusCode))
+      break;
+    if (attempt < MAX_ATTEMPTS - 1) {
+      const backoff = last.retryAfter ?? BASE_BACKOFF_MS * Math.pow(2, attempt);
+      await sleep(backoff);
+    }
+  }
+  if (!isAccepted(last.statusCode) && (last.statusCode === 429 || last.statusCode === 403)) {
+    const headResult = await attemptRequest("head", url, headers);
+    if (isAccepted(headResult.statusCode)) {
+      last = headResult;
     }
+  }
+  if (last.statusCode === null) {
+    result.status = "FAIL";
+    result.description = `Invalid or unresolvable URL: ${url}`;
     return result;
   }
-  if (step.checkLink.statusCodes.indexOf(req.statusCode) >= 0) {
+  if (step.checkLink.statusCodes.indexOf(last.statusCode) >= 0) {
     result.status = "PASS";
-    result.description = `Returned ${req.statusCode}`;
+    result.description = `Returned ${last.statusCode}`;
   } else {
     result.status = "FAIL";
-    result.description = `Returned ${req.statusCode}. Expected one of ${JSON.stringify(step.checkLink.statusCodes)}`;
+    result.description = `Returned ${last.statusCode}. Expected one of ${JSON.stringify(step.checkLink.statusCodes)}`;
   }
   return result;
 }
 
 // dist/core/tests/saveScreenshot.js
-var import_node_path7 = __toESM(require("node:path"), 1);
-var import_node_fs6 = __toESM(require("node:fs"), 1);
+var import_node_path8 = __toESM(require("node:path"), 1);
+var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_pngjs = require("pngjs");
 var import_sharp = __toESM(require("sharp"), 1);
 var pixelmatch;
@@ -132540,7 +134432,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_path7.default.resolve(step.screenshot.directory, step.screenshot.path);
+      step.screenshot.path = import_node_path8.default.resolve(step.screenshot.directory, step.screenshot.path);
     }
   }
   step.screenshot = {
@@ -132557,19 +134449,19 @@ async function saveScreenshot({ config, step, driver }) {
     };
   }
   let filePath = step.screenshot.path;
-  const dir = import_node_path7.default.dirname(step.screenshot.path);
-  if (!import_node_fs6.default.existsSync(dir)) {
-    import_node_fs6.default.mkdirSync(dir, { recursive: true });
+  const dir = import_node_path8.default.dirname(step.screenshot.path);
+  if (!import_node_fs7.default.existsSync(dir)) {
+    import_node_fs7.default.mkdirSync(dir, { recursive: true });
   }
   let existFilePath;
-  if (import_node_fs6.default.existsSync(filePath)) {
+  if (import_node_fs7.default.existsSync(filePath)) {
     if (step.screenshot.overwrite == "false") {
       result.status = "SKIPPED";
       result.description = `File already exists: ${filePath}`;
       return result;
     } else {
       existFilePath = filePath;
-      filePath = import_node_path7.default.join(dir, `${step.stepId}_${Date.now()}.png`);
+      filePath = import_node_path8.default.join(dir, `${step.stepId}_${Date.now()}.png`);
     }
   }
   if (step.screenshot.crop) {
@@ -132657,8 +134549,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_fs6.default.existsSync(filePath)) {
-      import_node_fs6.default.unlinkSync(filePath);
+    if (existFilePath && filePath !== existFilePath && import_node_fs7.default.existsSync(filePath)) {
+      import_node_fs7.default.unlinkSync(filePath);
     }
     return result;
   }
@@ -132711,7 +134603,7 @@ async function saveScreenshot({ config, step, driver }) {
       rect.height = imgMeta.height - rect.y;
     }
     log(config, "debug", { padded_rect: rect });
-    const croppedPath = import_node_path7.default.join(dir, `cropped_${step.stepId || Date.now()}.png`);
+    const croppedPath = import_node_path8.default.join(dir, `cropped_${step.stepId || Date.now()}.png`);
     try {
       await (0, import_sharp.default)(filePath).extract({
         left: rect.x,
@@ -132719,12 +134611,12 @@ async function saveScreenshot({ config, step, driver }) {
         width: rect.width,
         height: rect.height
       }).toFile(croppedPath);
-      import_node_fs6.default.renameSync(croppedPath, filePath);
+      import_node_fs7.default.renameSync(croppedPath, filePath);
     } catch (error) {
       result.status = "FAIL";
       result.description = `Couldn't crop image. ${error}`;
-      if (existFilePath && filePath !== existFilePath && import_node_fs6.default.existsSync(filePath)) {
-        import_node_fs6.default.unlinkSync(filePath);
+      if (existFilePath && filePath !== existFilePath && import_node_fs7.default.existsSync(filePath)) {
+        import_node_fs7.default.unlinkSync(filePath);
       }
       return result;
     }
@@ -132732,7 +134624,7 @@ async function saveScreenshot({ config, step, driver }) {
   if (existFilePath) {
     if (step.screenshot.overwrite == "true") {
       result.description += ` Overwrote existing file.`;
-      import_node_fs6.default.renameSync(filePath, existFilePath);
+      import_node_fs7.default.renameSync(filePath, existFilePath);
       result.outputs.screenshotPath = existFilePath;
       result.outputs.changed = true;
       if (step.screenshot.sourceIntegration) {
@@ -132742,13 +134634,13 @@ async function saveScreenshot({ config, step, driver }) {
     }
     let fractionalDiff;
     if (step.screenshot.maxVariation != null) {
-      const img1 = import_pngjs.PNG.sync.read(import_node_fs6.default.readFileSync(existFilePath));
-      const img2 = import_pngjs.PNG.sync.read(import_node_fs6.default.readFileSync(filePath));
+      const img1 = import_pngjs.PNG.sync.read(import_node_fs7.default.readFileSync(existFilePath));
+      const img2 = import_pngjs.PNG.sync.read(import_node_fs7.default.readFileSync(filePath));
       if (Math.round(img1.width / img1.height * 100) / 100 !== Math.round(img2.width / img2.height * 100) / 100) {
         result.status = "FAIL";
         result.description = `Couldn't compare images. Images have different aspect ratios.`;
-        if (existFilePath && filePath !== existFilePath && import_node_fs6.default.existsSync(filePath)) {
-          import_node_fs6.default.unlinkSync(filePath);
+        if (existFilePath && filePath !== existFilePath && import_node_fs7.default.existsSync(filePath)) {
+          import_node_fs7.default.unlinkSync(filePath);
         }
         return result;
       }
@@ -132779,7 +134671,7 @@ async function saveScreenshot({ config, step, driver }) {
       });
       if (fractionalDiff > step.screenshot.maxVariation) {
         if (step.screenshot.overwrite == "aboveVariation") {
-          import_node_fs6.default.renameSync(filePath, existFilePath);
+          import_node_fs7.default.renameSync(filePath, existFilePath);
         }
         result.status = "WARNING";
         result.description += ` The difference between the existing screenshot and new screenshot (${fractionalDiff.toFixed(2)}) is greater than the max accepted variation (${step.screenshot.maxVariation}).`;
@@ -132796,7 +134688,7 @@ async function saveScreenshot({ config, step, driver }) {
           result.outputs.sourceIntegration = step.screenshot.sourceIntegration;
         }
         if (step.screenshot.overwrite != "true") {
-          import_node_fs6.default.unlinkSync(filePath);
+          import_node_fs7.default.unlinkSync(filePath);
         }
       }
     }
@@ -132812,9 +134704,9 @@ async function saveScreenshot({ config, step, driver }) {
 }
 
 // dist/core/tests/startRecording.js
-var import_node_path8 = __toESM(require("node:path"), 1);
-var import_node_fs7 = __toESM(require("node:fs"), 1);
-var import_node_os4 = __toESM(require("node:os"), 1);
+var import_node_path9 = __toESM(require("node:path"), 1);
+var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_os5 = __toESM(require("node:os"), 1);
 async function startRecording({ config, context, step, driver }) {
   let result = {
     status: "PASS",
@@ -132836,7 +134728,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_path8.default.resolve(step.record.directory, step.record.path);
+      step.record.path = import_node_path9.default.resolve(step.record.directory, step.record.path);
     }
   }
   step.record = {
@@ -132849,12 +134741,12 @@ async function startRecording({ config, context, step, driver }) {
     return result;
   }
   let filePath = step.record.path;
-  const baseName = import_node_path8.default.basename(filePath, import_node_path8.default.extname(filePath));
-  const dir = import_node_path8.default.dirname(step.record.path);
-  if (!import_node_fs7.default.existsSync(dir)) {
-    import_node_fs7.default.mkdirSync(dir, { recursive: true });
+  const baseName = import_node_path9.default.basename(filePath, import_node_path9.default.extname(filePath));
+  const dir = import_node_path9.default.dirname(step.record.path);
+  if (!import_node_fs8.default.existsSync(dir)) {
+    import_node_fs8.default.mkdirSync(dir, { recursive: true });
   }
-  if (import_node_fs7.default.existsSync(filePath) && step.record.overwrite == "false") {
+  if (import_node_fs8.default.existsSync(filePath) && step.record.overwrite == "false") {
     result.status = "SKIPPED";
     result.description = `File already exists: ${filePath}`;
     return result;
@@ -132960,7 +134852,7 @@ async function startRecording({ config, context, step, driver }) {
     result.recording = {
       type: "MediaRecorder",
       tab: recorderTab.handle,
-      downloadPath: import_node_path8.default.join(import_node_os4.default.tmpdir(), `${baseName}.webm`),
+      downloadPath: import_node_path9.default.join(import_node_os5.default.tmpdir(), `${baseName}.webm`),
       // Where the recording will be downloaded.
       targetPath: filePath
       // Where the recording will be saved.
@@ -132975,8 +134867,8 @@ async function startRecording({ config, context, step, driver }) {
 
 // dist/core/tests/stopRecording.js
 var import_node_child_process2 = require("node:child_process");
-var import_node_path9 = __toESM(require("node:path"), 1);
-var import_node_fs8 = __toESM(require("node:fs"), 1);
+var import_node_path10 = __toESM(require("node:path"), 1);
+var import_node_fs9 = __toESM(require("node:fs"), 1);
 var import_ffmpeg = __toESM(require("@ffmpeg-installer/ffmpeg"), 1);
 var ffmpegPath = import_ffmpeg.default.path;
 async function stopRecording({ config, step, driver }) {
@@ -133018,11 +134910,11 @@ async function stopRecording({ config, step, driver }) {
         window.recorder.stop();
       });
       let waitCount = 0;
-      while (!import_node_fs8.default.existsSync(config.recording.downloadPath) && waitCount < 60) {
+      while (!import_node_fs9.default.existsSync(config.recording.downloadPath) && waitCount < 60) {
         await new Promise((r) => setTimeout(r, 1e3));
         waitCount++;
       }
-      if (!import_node_fs8.default.existsSync(config.recording.downloadPath)) {
+      if (!import_node_fs9.default.existsSync(config.recording.downloadPath)) {
         result.status = "FAIL";
         result.description = "Recording download timed out.";
         return result;
@@ -133037,7 +134929,7 @@ async function stopRecording({ config, step, driver }) {
       const downloadPath = `${config.recording.downloadPath}`;
       const endMessage = `Finished processing file: ${config.recording.targetPath}`;
       const ffmpegArgs = ["-y", "-i", downloadPath, "-pix_fmt", "yuv420p"];
-      if (import_node_path9.default.extname(targetPath) === ".gif") {
+      if (import_node_path10.default.extname(targetPath) === ".gif") {
         ffmpegArgs.push("-vf", "scale=iw:-1:flags=lanczos");
       }
       ffmpegArgs.push(targetPath);
@@ -133046,7 +134938,7 @@ async function stopRecording({ config, step, driver }) {
           if (code === 0) {
             if (targetPath !== downloadPath) {
               try {
-                import_node_fs8.default.unlinkSync(downloadPath);
+                import_node_fs9.default.unlinkSync(downloadPath);
               } catch {
               }
             }
@@ -133087,8 +134979,8 @@ async function loadVariables({ step }) {
 }
 
 // dist/core/tests/saveCookie.js
-var import_node_path10 = __toESM(require("node:path"), 1);
-var import_node_fs9 = __toESM(require("node:fs"), 1);
+var import_node_path11 = __toESM(require("node:path"), 1);
+var import_node_fs10 = __toESM(require("node:fs"), 1);
 async function saveCookie({ config, step, driver }) {
   let result = {
     status: "PASS",
@@ -133105,7 +134997,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_path10.default.basename(step.saveCookie, ".txt");
+      cookieName = import_node_path11.default.basename(step.saveCookie, ".txt");
       filePath = step.saveCookie;
     } else {
       cookieName = step.saveCookie;
@@ -133154,15 +135046,15 @@ async function saveCookie({ config, step, driver }) {
     }
     if (filePath) {
       const outputDirectory = directory || config.output || process.cwd();
-      const fullPath = import_node_path10.default.resolve(outputDirectory, filePath);
-      if (import_node_fs9.default.existsSync(fullPath) && !(overwrite === true || overwrite === "true")) {
+      const fullPath = import_node_path11.default.resolve(outputDirectory, filePath);
+      if (import_node_fs10.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_path10.default.dirname(fullPath);
-      if (!import_node_fs9.default.existsSync(dir)) {
-        import_node_fs9.default.mkdirSync(dir, { recursive: true });
+      const dir = import_node_path11.default.dirname(fullPath);
+      if (!import_node_fs10.default.existsSync(dir)) {
+        import_node_fs10.default.mkdirSync(dir, { recursive: true });
       }
       if (targetCookie) {
         const netscapeCookie = formatCookieForNetscape(targetCookie);
@@ -133170,11 +135062,11 @@ async function saveCookie({ config, step, driver }) {
 # This is a cookie file saved by Doc Detective
 ${netscapeCookie}
 `;
-        import_node_fs9.default.writeFileSync(fullPath, content, "utf8");
+        import_node_fs10.default.writeFileSync(fullPath, content, "utf8");
         result.description = `Saved cookie '${cookieName}' to '${fullPath}'.`;
         log(config, "debug", `Saved cookie '${cookieName}' to file: ${fullPath}`);
       } else {
-        import_node_fs9.default.writeFileSync(fullPath, "# No cookie data\n", "utf8");
+        import_node_fs10.default.writeFileSync(fullPath, "# No cookie data\n", "utf8");
         result.description = `Created empty cookie file at '${fullPath}'.`;
         log(config, "debug", `Created empty cookie file: ${fullPath}`);
       }
@@ -133199,8 +135091,8 @@ function formatCookieForNetscape(cookie) {
 }
 
 // dist/core/tests/loadCookie.js
-var import_node_path11 = __toESM(require("node:path"), 1);
-var import_node_fs10 = __toESM(require("node:fs"), 1);
+var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_fs11 = __toESM(require("node:fs"), 1);
 async function loadCookie({ config, step, driver }) {
   let result = {
     status: "PASS",
@@ -133217,7 +135109,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_path11.default.basename(step.loadCookie, ".txt");
+      cookieName = import_node_path12.default.basename(step.loadCookie, ".txt");
       filePath = step.loadCookie;
     } else {
       cookieName = step.loadCookie;
@@ -133230,9 +135122,9 @@ async function loadCookie({ config, step, driver }) {
     domain = step.loadCookie.domain;
     variable = step.loadCookie.variable;
     if (filePath && !cookieName) {
-      const ext = import_node_path11.default.extname(filePath).toLowerCase();
+      const ext = import_node_path12.default.extname(filePath).toLowerCase();
       if (ext === ".txt") {
-        cookieName = import_node_path11.default.basename(filePath, ext);
+        cookieName = import_node_path12.default.basename(filePath, ext);
       }
     }
   }
@@ -133255,14 +135147,14 @@ async function loadCookie({ config, step, driver }) {
       }
     } else if (filePath) {
       const inputDirectory = directory || config.output || process.cwd();
-      const fullPath = import_node_path11.default.resolve(inputDirectory, filePath);
-      if (!import_node_fs10.default.existsSync(fullPath)) {
+      const fullPath = import_node_path12.default.resolve(inputDirectory, filePath);
+      if (!import_node_fs11.default.existsSync(fullPath)) {
         result.status = "FAIL";
         result.description = `Cookie file '${fullPath}' not found`;
         return result;
       }
       try {
-        const fileContent = import_node_fs10.default.readFileSync(fullPath, "utf8");
+        const fileContent = import_node_fs11.default.readFileSync(fullPath, "utf8");
         const cookies = parseNetscapeCookieFile(fileContent);
         if (cookies.length === 0) {
           result.status = "FAIL";
@@ -133305,6 +135197,15 @@ async function loadCookie({ config, step, driver }) {
     const isHttps = currentUrl.startsWith("https://");
     let sameSite = targetCookie.sameSite || "Lax";
     let secure = targetCookie.secure || false;
+    if (typeof sameSite === "string") {
+      const lower = sameSite.toLowerCase();
+      if (lower === "none")
+        sameSite = "None";
+      else if (lower === "strict")
+        sameSite = "Strict";
+      else
+        sameSite = "Lax";
+    }
     if (sameSite === "None") {
       if (isHttps) {
         secure = true;
@@ -133417,9 +135318,9 @@ function isDomainCompatible(currentDomain, cookieDomain) {
 }
 
 // dist/core/tests/httpRequest.js
-var import_axios4 = __toESM(require("axios"), 1);
-var import_node_fs11 = __toESM(require("node:fs"), 1);
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_axios5 = __toESM(require("axios"), 1);
+var import_node_fs12 = __toESM(require("node:fs"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var import_ajv2 = __toESM(require("ajv"), 1);
 var Ajv2 = import_ajv2.default;
 async function httpRequest({ config, step, openApiDefinitions = [] }) {
@@ -133602,7 +135503,7 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
   }
   let response = {};
   if (!step?.httpRequest?.openApi?.mockResponse) {
-    response = await (0, import_axios4.default)(request).then((response2) => {
+    response = await (0, import_axios5.default)(request).then((response2) => {
       return response2;
     }).catch((error) => {
       return { error };
@@ -133722,25 +135623,25 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
     }
   }
   if (step.httpRequest.path) {
-    const dir = import_node_path12.default.dirname(step.httpRequest.path);
-    if (!import_node_fs11.default.existsSync(dir)) {
-      import_node_fs11.default.mkdirSync(dir, { recursive: true });
+    const dir = import_node_path13.default.dirname(step.httpRequest.path);
+    if (!import_node_fs12.default.existsSync(dir)) {
+      import_node_fs12.default.mkdirSync(dir, { recursive: true });
     }
     let filePath = step.httpRequest.path;
     log(config, "debug", `Saving output to file: ${filePath}`);
-    if (!import_node_fs11.default.existsSync(filePath)) {
-      await import_node_fs11.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
+    if (!import_node_fs12.default.existsSync(filePath)) {
+      await import_node_fs12.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
       result.description += ` Saved output to file.`;
     } else {
       if (step.httpRequest.overwrite == "false") {
         result.description += ` 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, JSON.stringify(response.data, null, 2));
       log(config, "debug", `Fractional difference: ${fractionalDiff}`);
       if (fractionalDiff > step.httpRequest.maxVariation) {
         if (step.httpRequest.overwrite == "aboveVariation") {
-          await import_node_fs11.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
+          await import_node_fs12.default.promises.writeFile(filePath, JSON.stringify(response.data, null, 2));
           result.description += ` Saved response to file.`;
         }
         result.status = "WARNING";
@@ -133748,7 +135649,7 @@ async function httpRequest({ config, step, openApiDefinitions = [] }) {
         return result;
       }
       if (step.httpRequest.overwrite == "true") {
-        import_node_fs11.default.writeFileSync(filePath, JSON.stringify(response.data, null, 2));
+        import_node_fs12.default.writeFileSync(filePath, JSON.stringify(response.data, null, 2));
         result.description += ` Saved response to file.`;
       }
     }
@@ -133922,9 +135823,9 @@ async function clickElement({ config, step, driver }) {
 }
 
 // dist/core/tests/runCode.js
-var import_node_fs12 = __toESM(require("node:fs"), 1);
-var import_node_path13 = __toESM(require("node:path"), 1);
-var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_fs13 = __toESM(require("node:fs"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
 function createTempScript(code, language) {
   let extension;
   switch (language) {
@@ -133943,10 +135844,10 @@ function createTempScript(code, language) {
     default:
       extension = "";
   }
-  const tmpDir = import_node_os5.default.tmpdir();
-  const tmpFile = import_node_path13.default.join(tmpDir, `doc-detective-${Date.now()}${extension}`);
+  const tmpDir = import_node_os6.default.tmpdir();
+  const tmpFile = import_node_path14.default.join(tmpDir, `doc-detective-${Date.now()}${extension}`);
   try {
-    import_node_fs12.default.writeFileSync(tmpFile, code);
+    import_node_fs13.default.writeFileSync(tmpFile, code);
   } catch (error) {
     throw new Error(`Failed to create temporary script: ${error.message}`);
   }
@@ -134009,7 +135910,7 @@ async function runCode({ config, step }) {
       result.description = `Command ${command} is unavailable. Make sure it's installed and in your PATH.`;
       return result;
     }
-    if (import_node_os5.default.platform() === "win32" && command === "bash") {
+    if (import_node_os6.default.platform() === "win32" && command === "bash") {
       result.status = "FAIL";
       result.description = `runCode currently doesn't support bash on Windows. Use a different command, a different language, or a runShell step.`;
       return result;
@@ -134030,7 +135931,7 @@ async function runCode({ config, step }) {
     result.description = error.message;
   } finally {
     try {
-      import_node_fs12.default.unlinkSync(scriptPath);
+      import_node_fs13.default.unlinkSync(scriptPath);
       log(config, "debug", `Removed temporary script: ${scriptPath}`);
     } catch (error) {
       log(config, "warn", `Failed to remove temporary script: ${scriptPath}`);
@@ -134160,7 +136061,7 @@ async function dragAndDropElement({ config, step, driver }) {
 // dist/core/tests.js
 var import_node_path15 = __toESM(require("node:path"), 1);
 var import_node_child_process3 = require("node:child_process");
-var import_node_crypto4 = require("node:crypto");
+var import_node_crypto5 = require("node:crypto");
 
 // dist/core/expressions.js
 var import_jq_web = __toESM(require("jq-web"), 1);
@@ -134409,789 +136310,6 @@ function preprocessExpression(expression) {
   return expression;
 }
 
-// dist/core/integrations/heretto.js
-var import_node_fs13 = __toESM(require("node:fs"), 1);
-var import_node_path14 = __toESM(require("node:path"), 1);
-var import_node_https = __toESM(require("node:https"), 1);
-var import_node_http = __toESM(require("node:http"), 1);
-var HerettoUploader = class {
-  /**
-   * Checks if this uploader can handle the given source integration.
-   * @param {Object} sourceIntegration - Source integration metadata
-   * @returns {boolean} True if this uploader handles Heretto integrations
-   */
-  canHandle(sourceIntegration) {
-    return sourceIntegration?.type === "heretto";
-  }
-  /**
-   * Uploads a file to Heretto CMS.
-   * @param {Object} options - Upload options
-   * @param {Object} options.config - Doc Detective config
-   * @param {Object} options.integrationConfig - Heretto integration config
-   * @param {string} options.localFilePath - Local file path to upload
-   * @param {Object} options.sourceIntegration - Source integration metadata
-   * @param {Function} options.log - Logging function
-   * @returns {Promise<Object>} Upload result with status and description
-   */
-  async upload({ config, integrationConfig, localFilePath, sourceIntegration, log: log3 }) {
-    const result = {
-      status: "FAIL",
-      description: ""
-    };
-    if (!integrationConfig) {
-      result.description = "No Heretto integration configuration found";
-      return result;
-    }
-    if (!integrationConfig.organizationId || !integrationConfig.apiToken) {
-      result.description = "Heretto integration missing organizationId or apiToken";
-      return result;
-    }
-    const apiBaseUrl = `https://${integrationConfig.organizationId}.heretto.com`;
-    let fileId = sourceIntegration.fileId;
-    let parentFolderId = sourceIntegration.parentFolderId;
-    const filename = import_node_path14.default.basename(sourceIntegration.filePath);
-    const relativeFilePath = sourceIntegration.filePath;
-    if (!fileId && integrationConfig.resourceDependencies) {
-      const resolvedFile = this.resolveFromDependencies({
-        resourceDependencies: integrationConfig.resourceDependencies,
-        filePath: relativeFilePath,
-        filename,
-        log: (level, msg) => log3(config, level, msg)
-      });
-      if (resolvedFile) {
-        fileId = resolvedFile.uuid;
-        if (!parentFolderId && resolvedFile.parentFolderId) {
-          parentFolderId = resolvedFile.parentFolderId;
-        }
-        log3(config, "debug", `Resolved from dependencies: ${relativeFilePath} -> ${fileId}`);
-      }
-    }
-    if (!fileId) {
-      log3(config, "debug", `No fileId found, resolving correct folder for: ${sourceIntegration.filePath}`);
-      try {
-        if (!parentFolderId && integrationConfig.resourceDependencies) {
-          const folderResolution = this.findParentFolderFromDependencies({
-            resourceDependencies: integrationConfig.resourceDependencies,
-            filePath: relativeFilePath,
-            log: (level, msg) => log3(config, level, msg)
-          });
-          parentFolderId = folderResolution.folderId;
-          if (!parentFolderId && folderResolution.ditamapParentFolderId && folderResolution.targetFolderName) {
-            log3(config, "debug", `Searching for folder '${folderResolution.targetFolderName}' in ditamap's parent folder`);
-            parentFolderId = await this.getChildFolderByName({
-              apiBaseUrl,
-              apiToken: integrationConfig.apiToken,
-              username: integrationConfig.username || "",
-              parentFolderId: folderResolution.ditamapParentFolderId,
-              folderName: folderResolution.targetFolderName,
-              log: (level, msg) => log3(config, level, msg)
-            });
-          }
-        }
-        if (!parentFolderId && relativeFilePath) {
-          const parentDirPath = import_node_path14.default.dirname(relativeFilePath);
-          if (parentDirPath && parentDirPath !== ".") {
-            const folderName = import_node_path14.default.basename(parentDirPath);
-            log3(config, "debug", `Searching for parent folder by name: ${folderName}`);
-            parentFolderId = await this.searchFolderByName({
-              apiBaseUrl,
-              apiToken: integrationConfig.apiToken,
-              username: integrationConfig.username || "",
-              folderName,
-              log: (level, msg) => log3(config, level, msg)
-            });
-          }
-        }
-        if (parentFolderId) {
-          log3(config, "debug", `Looking for file '${filename}' in target folder ${parentFolderId}`);
-          fileId = await this.getFileInFolder({
-            apiBaseUrl,
-            apiToken: integrationConfig.apiToken,
-            username: integrationConfig.username || "",
-            folderId: parentFolderId,
-            filename,
-            log: (level, msg) => log3(config, level, msg)
-          });
-          if (fileId) {
-            log3(config, "debug", `Found existing file in target folder with ID: ${fileId}`);
-          } else {
-            log3(config, "debug", `File not in target folder, creating new document`);
-            const mimeType = this.getContentType(localFilePath);
-            const createResult = await this.createDocument({
-              apiBaseUrl,
-              apiToken: integrationConfig.apiToken,
-              username: integrationConfig.username || "",
-              parentFolderId,
-              filename,
-              mimeType,
-              log: (level, msg) => log3(config, level, msg)
-            });
-            if (createResult.created) {
-              fileId = createResult.documentId;
-              log3(config, "info", `Created new document in Heretto with ID: ${fileId}`);
-            } else if (createResult.existsInFolder) {
-              log3(config, "debug", `File exists in folder (race condition), searching for its ID`);
-              fileId = await this.getFileInFolder({
-                apiBaseUrl,
-                apiToken: integrationConfig.apiToken,
-                username: integrationConfig.username || "",
-                folderId: parentFolderId,
-                filename,
-                log: (level, msg) => log3(config, level, msg)
-              });
-              if (!fileId) {
-                result.description = `File exists in folder but could not get its ID: ${filename}`;
-                return result;
-              }
-            } else {
-              result.description = `Failed to create document in Heretto: ${filename}`;
-              return result;
-            }
-          }
-        } else {
-          log3(config, "debug", `No target folder found, searching globally for file: ${filename}`);
-          fileId = await this.searchFileByName({
-            apiBaseUrl,
-            apiToken: integrationConfig.apiToken,
-            username: integrationConfig.username || "",
-            filename,
-            log: (level, msg) => log3(config, level, msg)
-          });
-          if (!fileId) {
-            result.description = `Could not find file or parent folder in Heretto: ${sourceIntegration.filePath}`;
-            return result;
-          }
-        }
-      } catch (error) {
-        result.description = `Error searching/creating file: ${error.message}`;
-        return result;
-      }
-    }
-    if (!import_node_fs13.default.existsSync(localFilePath)) {
-      result.description = `Local file not found: ${localFilePath}`;
-      return result;
-    }
-    const fileContent = import_node_fs13.default.readFileSync(localFilePath);
-    const contentType = this.getContentType(localFilePath);
-    try {
-      await this.uploadFile({
-        apiBaseUrl,
-        apiToken: integrationConfig.apiToken,
-        username: integrationConfig.username || "",
-        documentId: fileId,
-        content: fileContent,
-        contentType,
-        log: (level, msg) => log3(config, level, msg)
-      });
-      result.status = "PASS";
-      result.description = `Successfully uploaded to Heretto (document ID: ${fileId})`;
-    } catch (error) {
-      result.description = `Upload failed: ${error.message}`;
-    }
-    return result;
-  }
-  /**
-   * Resolves a file path to its UUID using the resource dependencies map.
-   * @param {Object} options - Resolution options
-   * @param {Object.<string, {uuid: string, parentFolderId: string}>} options.resourceDependencies - Map of resource paths to resource metadata
-   * @param {string} options.filePath - Original file path to resolve
-   * @param {string} options.filename - Filename extracted from the file path
-   * @param {Function} options.log - Logging function
-   * @returns {{uuid: string, parentFolderId: string}|null} File info with uuid and parentFolderId, or null if not found
-   */
-  resolveFromDependencies({ resourceDependencies, filePath, filename, log: log3 }) {
-    if (!resourceDependencies)
-      return null;
-    const normalizedPath = import_node_path14.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^\.\.\/+/g, "").replace(/^\.\//, "");
-    for (const [depPath, info] of Object.entries(resourceDependencies)) {
-      if (depPath.startsWith("_"))
-        continue;
-      const normalizedDepPath = depPath.replace(/\\/g, "/");
-      if (normalizedDepPath === normalizedPath || normalizedDepPath.endsWith("/" + normalizedPath) || normalizedDepPath.endsWith(normalizedPath)) {
-        log3("debug", `Found exact path match in dependencies: ${depPath}`);
-        return info;
-      }
-    }
-    const parentDir = import_node_path14.default.dirname(normalizedPath);
-    const parentFolderName = import_node_path14.default.basename(parentDir);
-    for (const [depPath, info] of Object.entries(resourceDependencies)) {
-      if (depPath.startsWith("_"))
-        continue;
-      const depFilename = import_node_path14.default.basename(depPath);
-      const depParentDir = import_node_path14.default.dirname(depPath);
-      const depParentFolderName = import_node_path14.default.basename(depParentDir);
-      if (depFilename === filename && depParentFolderName === parentFolderName) {
-        log3("debug", `Found filename+folder match in dependencies: ${depPath}`);
-        return info;
-      }
-    }
-    for (const [depPath, info] of Object.entries(resourceDependencies)) {
-      if (depPath.startsWith("_"))
-        continue;
-      const depFilename = import_node_path14.default.basename(depPath);
-      if (depFilename === filename) {
-        log3("debug", `Found filename match in dependencies: ${depPath}`);
-        return info;
-      }
-    }
-    log3("debug", `No match found in dependencies for: ${filePath}`);
-    return null;
-  }
-  /**
-   * Finds the parent folder ID for a file path using resource dependencies.
-   * Returns the target folder name for API lookup if not found in dependencies.
-   * @param {Object} options - Resolution options
-   * @param {Object.<string, {uuid: string, parentFolderId: string}>} options.resourceDependencies - Map of resource paths to resource metadata.
-   *   Keys are relative file paths, values are objects with uuid and parentFolderId.
-   *   Special keys starting with '_' (e.g., '_ditamapParentFolderId') store internal metadata.
-   * @param {string} options.filePath - File path to find parent folder for (can be relative with ../ or ./ prefixes)
-   * @param {Function} options.log - Logging function with signature (level, message)
-   * @returns {{folderId: string|null, targetFolderName: string|null, ditamapParentFolderId: string|null}} Resolution result containing:
-   *   - folderId: The parent folder UUID if found in dependencies, null otherwise
-   *   - targetFolderName: The name of the target folder extracted from the file path
-   *   - ditamapParentFolderId: The ditamap's parent folder ID from dependencies (for API fallback lookup)
-   */
-  findParentFolderFromDependencies({ resourceDependencies, filePath, log: log3 }) {
-    const result = {
-      folderId: null,
-      targetFolderName: null,
-      ditamapParentFolderId: null
-    };
-    if (!resourceDependencies)
-      return result;
-    const normalizedPath = import_node_path14.default.posix.normalize(filePath.replace(/\\/g, "/")).replace(/^(\.\.\/)+/g, "").replace(/^\.\//, "");
-    const parentDir = import_node_path14.default.dirname(normalizedPath);
-    const targetFolderName = import_node_path14.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_path14.default.dirname(depPath);
-      const depFolderName = import_node_path14.default.basename(depParentDir);
-      if (depFolderName === targetFolderName && info.parentFolderId) {
-        log3("debug", `Found sibling file ${depPath} with parent folder ID: ${info.parentFolderId}`);
-        result.folderId = info.parentFolderId;
-        return result;
-      }
-    }
-    for (const [depPath, info] of Object.entries(resourceDependencies)) {
-      if (depPath.startsWith("_"))
-        continue;
-      if (depPath.endsWith("/" + targetFolderName) || depPath === targetFolderName) {
-        log3("debug", `Found folder ${depPath} with ID: ${info.uuid}`);
-        result.folderId = info.uuid;
-        return result;
-      }
-    }
-    log3("debug", `Could not find parent folder '${targetFolderName}' in dependencies, will search via API`);
-    return result;
-  }
-  /**
-   * Gets a child folder within a parent folder by name.
-   * @param {Object} options - Search options
-   * @returns {Promise<string|null>} Child folder ID if found, null otherwise
-   */
-  async getChildFolderByName({ apiBaseUrl, apiToken, username, parentFolderId, folderName, log: log3 }) {
-    const folderUrl = new URL(`/rest/all-files/${parentFolderId}`, apiBaseUrl);
-    return new Promise((resolve, reject) => {
-      const protocol = folderUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: folderUrl.hostname,
-        port: folderUrl.port || (folderUrl.protocol === "https:" ? 443 : 80),
-        path: folderUrl.pathname,
-        method: "GET",
-        headers: {
-          "Authorization": `Basic ${authString}`,
-          "Accept": "application/xml"
-        }
-      };
-      log3("debug", `Looking for child folder '${folderName}' in parent ${parentFolderId}`);
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode === 200) {
-            try {
-              const escapedFolderName = folderName.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
-              const folderMatch = data.match(new RegExp(`<folder\\s+name="${escapedFolderName}"\\s+id="([^"]+)"`, "i"));
-              if (folderMatch && folderMatch[1]) {
-                log3("debug", `Found child folder '${folderName}' with ID: ${folderMatch[1]}`);
-                resolve(folderMatch[1]);
-              } else {
-                log3("debug", `Child folder '${folderName}' not found in parent ${parentFolderId}`);
-                resolve(null);
-              }
-            } catch (parseError) {
-              log3("debug", `Error parsing folder contents: ${parseError.message}`);
-              resolve(null);
-            }
-          } else {
-            log3("debug", `Failed to get parent folder contents: ${res.statusCode}`);
-            resolve(null);
-          }
-        });
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.on("error", (error) => {
-        log3("debug", `Error getting folder contents: ${error.message}`);
-        resolve(null);
-      });
-      req.end();
-    });
-  }
-  /**
-   * Creates a new document in Heretto.
-   * @param {Object} options - Creation options
-   * @returns {Promise<Object>} Result with created: boolean, documentId: string (if successful or already exists)
-   */
-  async createDocument({ apiBaseUrl, apiToken, username, parentFolderId, filename, mimeType, log: log3 }) {
-    const createUrl = new URL(`/rest/all-files/${parentFolderId}`, apiBaseUrl);
-    const createBody = `<resource><name>${this.escapeXml(filename)}</name><mime-type>${mimeType}</mime-type></resource>`;
-    return new Promise((resolve, reject) => {
-      const protocol = createUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: createUrl.hostname,
-        port: createUrl.port || (createUrl.protocol === "https:" ? 443 : 80),
-        path: createUrl.pathname,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/xml",
-          "Authorization": `Basic ${authString}`,
-          "Content-Length": Buffer.byteLength(createBody)
-        }
-      };
-      log3("debug", `Creating document at ${createUrl.toString()}`);
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode === 200 || res.statusCode === 201) {
-            try {
-              const idMatch = data.match(/id="([^"]+)"/);
-              if (idMatch && idMatch[1]) {
-                log3("debug", `Document created successfully with ID: ${idMatch[1]}`);
-                resolve({ created: true, documentId: idMatch[1] });
-              } else {
-                log3("warning", `Document created but could not parse ID from response: ${data}`);
-                reject(new Error("Could not parse document ID from create response"));
-              }
-            } catch (parseError) {
-              reject(new Error(`Failed to parse create response: ${parseError.message}`));
-            }
-          } else if (res.statusCode === 400 && data.includes("already exists")) {
-            log3("debug", `Document already exists in folder, will search for existing file`);
-            resolve({ created: false, existsInFolder: true, parentFolderId });
-          } else {
-            reject(new Error(`Create document failed with status ${res.statusCode}: ${data}`));
-          }
-        });
-      });
-      req.on("error", (error) => {
-        reject(new Error(`Create document request error: ${error.message}`));
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.write(createBody);
-      req.end();
-    });
-  }
-  /**
-   * Gets file information from a specific folder.
-   * @param {Object} options - Options
-   * @returns {Promise<string|null>} File ID if found, null otherwise
-   */
-  async getFileInFolder({ apiBaseUrl, apiToken, username, folderId, filename, log: log3 }) {
-    const folderUrl = new URL(`/rest/all-files/${folderId}`, apiBaseUrl);
-    return new Promise((resolve, reject) => {
-      const protocol = folderUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: folderUrl.hostname,
-        port: folderUrl.port || (folderUrl.protocol === "https:" ? 443 : 80),
-        path: folderUrl.pathname,
-        method: "GET",
-        headers: {
-          "Authorization": `Basic ${authString}`,
-          "Accept": "application/xml"
-        }
-      };
-      log3("debug", `Getting folder contents: ${folderUrl.toString()}`);
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode === 200) {
-            try {
-              const escapedFilename = filename.replace(/[.*+?^${}()|[\]\\/]/g, "\\$&");
-              const nameIdMatch = data.match(new RegExp(`id="([^"]+)"[^>]*name="${escapedFilename}"`, "i"));
-              const idNameMatch = data.match(new RegExp(`name="${escapedFilename}"[^>]*id="([^"]+)"`, "i"));
-              const match = nameIdMatch || idNameMatch;
-              if (match && match[1]) {
-                log3("debug", `Found file ${filename} with ID: ${match[1]}`);
-                resolve(match[1]);
-              } else {
-                log3("debug", `File ${filename} not found in folder ${folderId}`);
-                resolve(null);
-              }
-            } catch (parseError) {
-              log3("debug", `Error parsing folder contents: ${parseError.message}`);
-              resolve(null);
-            }
-          } else {
-            log3("debug", `Failed to get folder contents: ${res.statusCode}`);
-            resolve(null);
-          }
-        });
-      });
-      req.on("error", (error) => {
-        log3("debug", `Error getting folder contents: ${error.message}`);
-        resolve(null);
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.end();
-    });
-  }
-  /**
-   * Escapes special characters for XML.
-   * @param {string} str - String to escape
-   * @returns {string} Escaped string
-   */
-  escapeXml(str) {
-    return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-  }
-  /**
-   * Searches for a folder in Heretto by name.
-   * @param {Object} options - Search options
-   * @returns {Promise<string|null>} Folder ID if found, null otherwise
-   */
-  async searchFolderByName({ apiBaseUrl, apiToken, username, folderName, log: log3 }) {
-    const searchUrl = new URL("/ezdnxtgen/api/search", apiBaseUrl);
-    const searchBody = JSON.stringify({
-      queryString: folderName,
-      searchResultType: "FOLDERS_ONLY"
-    });
-    return new Promise((resolve, reject) => {
-      const protocol = searchUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: searchUrl.hostname,
-        port: searchUrl.port || (searchUrl.protocol === "https:" ? 443 : 80),
-        path: searchUrl.pathname,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Basic ${authString}`,
-          "Content-Length": Buffer.byteLength(searchBody)
-        }
-      };
-      log3("debug", `Searching for folder: ${folderName}`);
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            try {
-              if (!data || data.trim() === "") {
-                log3("debug", "Folder search returned empty response - no results found");
-                resolve(null);
-                return;
-              }
-              const result = JSON.parse(data);
-              if (result.searchResults && result.searchResults.length > 0) {
-                const match = result.searchResults.find((r) => r.name === folderName || r.title === folderName);
-                if (match) {
-                  log3("debug", `Found folder: ${folderName} with ID: ${match.uuid || match.id}`);
-                  resolve(match.uuid || match.id);
-                } else {
-                  log3("debug", `Exact folder match not found, using first result: ${result.searchResults[0].uuid || result.searchResults[0].id}`);
-                  resolve(result.searchResults[0].uuid || result.searchResults[0].id);
-                }
-              } else {
-                log3("debug", `No folders found matching: ${folderName}`);
-                resolve(null);
-              }
-            } catch (parseError) {
-              reject(new Error(`Failed to parse folder search response: ${parseError.message}`));
-            }
-          } else {
-            reject(new Error(`Folder search request failed with status ${res.statusCode}: ${data}`));
-          }
-        });
-      });
-      req.on("error", (error) => {
-        reject(new Error(`Folder search request error: ${error.message}`));
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.write(searchBody);
-      req.end();
-    });
-  }
-  /**
-   * Searches for a file in Heretto by filename.
-   * @param {Object} options - Search options
-   * @returns {Promise<string|null>} Document ID if found, null otherwise
-   */
-  async searchFileByName({ apiBaseUrl, apiToken, username, filename, log: log3 }) {
-    const searchUrl = new URL("/ezdnxtgen/api/search", apiBaseUrl);
-    const searchBody = JSON.stringify({
-      queryString: filename,
-      searchResultType: "FILES_ONLY"
-    });
-    return new Promise((resolve, reject) => {
-      const protocol = searchUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: searchUrl.hostname,
-        port: searchUrl.port || (searchUrl.protocol === "https:" ? 443 : 80),
-        path: searchUrl.pathname,
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Basic ${authString}`,
-          "Content-Length": Buffer.byteLength(searchBody)
-        }
-      };
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            try {
-              if (!data || data.trim() === "") {
-                log3("debug", "Search returned empty response - no results found");
-                resolve(null);
-                return;
-              }
-              const result = JSON.parse(data);
-              if (result.searchResults && result.searchResults.length > 0) {
-                const match = result.searchResults.find((r) => r.name === filename || r.title === filename);
-                if (match) {
-                  resolve(match.uuid || match.id);
-                } else {
-                  resolve(result.searchResults[0].uuid || result.searchResults[0].id);
-                }
-              } else {
-                resolve(null);
-              }
-            } catch (parseError) {
-              reject(new Error(`Failed to parse search response: ${parseError.message}`));
-            }
-          } else {
-            reject(new Error(`Search request failed with status ${res.statusCode}: ${data}`));
-          }
-        });
-      });
-      req.on("error", (error) => {
-        reject(new Error(`Search request error: ${error.message}`));
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.write(searchBody);
-      req.end();
-    });
-  }
-  /**
-   * Uploads file content to Heretto.
-   * @param {Object} options - Upload options
-   * @returns {Promise<void>}
-   */
-  async uploadFile({ apiBaseUrl, apiToken, username, documentId, content, contentType, log: log3 }) {
-    const uploadUrl = new URL(`/rest/all-files/${documentId}/content`, apiBaseUrl);
-    return new Promise((resolve, reject) => {
-      const protocol = uploadUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: uploadUrl.hostname,
-        port: uploadUrl.port || (uploadUrl.protocol === "https:" ? 443 : 80),
-        path: uploadUrl.pathname,
-        method: "PUT",
-        headers: {
-          "Content-Type": contentType,
-          "Authorization": `Basic ${authString}`,
-          "Content-Length": Buffer.byteLength(content)
-        }
-      };
-      log3("debug", `Uploading to ${uploadUrl.toString()}`);
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            log3("debug", `Upload successful: ${res.statusCode}`);
-            resolve();
-          } else {
-            reject(new Error(`Upload failed with status ${res.statusCode}: ${data}`));
-          }
-        });
-      });
-      req.on("error", (error) => {
-        reject(new Error(`Upload request error: ${error.message}`));
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.write(content);
-      req.end();
-    });
-  }
-  /**
-   * Gets document information from Heretto.
-   * @param {Object} options - Options
-   * @returns {Promise<Object>} Document info including id, name, mimeType, folderUuid, uri
-   */
-  async getDocumentInfo({ apiBaseUrl, apiToken, username, documentId, log: log3 }) {
-    const docUrl = new URL(`/rest/all-files/${documentId}`, apiBaseUrl);
-    return new Promise((resolve, reject) => {
-      const protocol = docUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: docUrl.hostname,
-        port: docUrl.port || (docUrl.protocol === "https:" ? 443 : 80),
-        path: docUrl.pathname,
-        method: "GET",
-        headers: {
-          "Authorization": `Basic ${authString}`,
-          "Accept": "application/xml"
-        }
-      };
-      log3("debug", `Getting document info: ${docUrl.toString()}`);
-      const req = protocol.request(options, (res) => {
-        let data = "";
-        res.on("data", (chunk) => {
-          data += chunk;
-        });
-        res.on("end", () => {
-          if (res.statusCode === 200) {
-            try {
-              const resourceMatch = data.match(/<resource\s+([^>]+)>/);
-              let id = null;
-              let folderUuid = null;
-              if (resourceMatch) {
-                const attrs = resourceMatch[1];
-                const idMatch = attrs.match(/\bid="([^"]+)"/);
-                const folderMatch = attrs.match(/\bfolder-uuid="([^"]+)"/);
-                id = idMatch ? idMatch[1] : null;
-                folderUuid = folderMatch ? folderMatch[1] : null;
-              }
-              const nameMatch = data.match(/<name>([^<]+)<\/name>/);
-              const mimeMatch = data.match(/<mime-type>([^<]+)<\/mime-type>/);
-              const uriMatch = data.match(/<xmldb-uri>([^<]+)<\/xmldb-uri>/);
-              resolve({
-                id,
-                name: nameMatch ? nameMatch[1] : null,
-                mimeType: mimeMatch ? mimeMatch[1] : null,
-                folderUuid,
-                uri: uriMatch ? uriMatch[1] : null,
-                rawXml: data
-              });
-            } catch (parseError) {
-              reject(new Error(`Failed to parse document info: ${parseError.message}`));
-            }
-          } else {
-            reject(new Error(`Get document info failed with status ${res.statusCode}: ${data}`));
-          }
-        });
-      });
-      req.on("error", (error) => {
-        reject(new Error(`Get document info request error: ${error.message}`));
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.end();
-    });
-  }
-  /**
-   * Gets document content from Heretto.
-   * @param {Object} options - Options
-   * @returns {Promise<Buffer>} Document content as buffer
-   */
-  async getDocumentContent({ apiBaseUrl, apiToken, username, documentId, log: log3 }) {
-    const contentUrl = new URL(`/rest/all-files/${documentId}/content`, apiBaseUrl);
-    return new Promise((resolve, reject) => {
-      const protocol = contentUrl.protocol === "https:" ? import_node_https.default : import_node_http.default;
-      const authString = Buffer.from(`${username}:${apiToken}`).toString("base64");
-      const options = {
-        hostname: contentUrl.hostname,
-        port: contentUrl.port || (contentUrl.protocol === "https:" ? 443 : 80),
-        path: contentUrl.pathname,
-        method: "GET",
-        headers: {
-          "Authorization": `Basic ${authString}`
-        }
-      };
-      log3("debug", `Getting document content: ${contentUrl.toString()}`);
-      const req = protocol.request(options, (res) => {
-        const chunks = [];
-        res.on("data", (chunk) => {
-          chunks.push(chunk);
-        });
-        res.on("end", () => {
-          if (res.statusCode === 200) {
-            resolve(Buffer.concat(chunks));
-          } else {
-            reject(new Error(`Get document content failed with status ${res.statusCode}`));
-          }
-        });
-      });
-      req.on("error", (error) => {
-        reject(new Error(`Get document content request error: ${error.message}`));
-      });
-      req.setTimeout(3e4, () => {
-        req.destroy(new Error("Request timeout"));
-      });
-      req.end();
-    });
-  }
-  /**
-   * Determines the content type based on file extension.
-   * @param {string} filePath - File path
-   * @returns {string} MIME content type
-   */
-  getContentType(filePath) {
-    const ext = import_node_path14.default.extname(filePath).toLowerCase();
-    const contentTypes = {
-      ".png": "image/png",
-      ".jpg": "image/jpeg",
-      ".jpeg": "image/jpeg",
-      ".gif": "image/gif",
-      ".svg": "image/svg+xml",
-      ".webp": "image/webp",
-      ".bmp": "image/bmp",
-      ".ico": "image/x-icon",
-      ".pdf": "application/pdf",
-      ".xml": "application/xml",
-      ".dita": "application/xml",
-      ".ditamap": "application/xml"
-    };
-    return contentTypes[ext] || "application/octet-stream";
-  }
-};
-
 // dist/core/integrations/index.js
 var uploaders = [
   new HerettoUploader()
@@ -135425,7 +136543,7 @@ function getDriverCapabilities({ runnerDetails, name, options }) {
             // Reference: https://chromedriver.chromium.org/capabilities#h.p_ID_102
             args,
             prefs: {
-              "download.default_directory": import_node_os6.default.tmpdir(),
+              "download.default_directory": import_node_os7.default.tmpdir(),
               "download.prompt_for_download": false,
               "download.directory_upgrade": true
             },
@@ -135521,7 +136639,7 @@ async function runViaApi({ resolvedTests, apiKey, config = {} }) {
   };
   let createResponse;
   try {
-    createResponse = await import_axios5.default.post(apiUrl, resolvedTests, axiosConfig);
+    createResponse = await import_axios6.default.post(apiUrl, resolvedTests, axiosConfig);
   } catch (error) {
     return {
       status: error.response?.status,
@@ -135534,7 +136652,7 @@ async function runViaApi({ resolvedTests, apiKey, config = {} }) {
   const runId = createResponse.data.run.runId;
   let startResponse;
   try {
-    startResponse = await import_axios5.default.post(`${apiUrl}/${runId}/start`, {}, axiosConfig);
+    startResponse = await import_axios6.default.post(`${apiUrl}/${runId}/start`, {}, axiosConfig);
   } catch (error) {
     return {
       status: error.response?.status,
@@ -135558,7 +136676,7 @@ async function runViaApi({ resolvedTests, apiKey, config = {} }) {
       };
     }
     try {
-      response = await import_axios5.default.get(`${apiUrl}/${runId}`, axiosConfig);
+      response = await import_axios6.default.get(`${apiUrl}/${runId}`, axiosConfig);
     } catch (error) {
       return {
         status: error.response?.status,
@@ -135674,7 +136792,7 @@ async function runSpecs({ resolvedTests }) {
           context.browser = getDefaultBrowser({ runnerDetails });
         }
         let contextReport = {
-          contextId: context.contextId || (0, import_node_crypto4.randomUUID)(),
+          contextId: context.contextId || (0, import_node_crypto5.randomUUID)(),
           platform: context.platform,
           browser: context.browser,
           steps: []
@@ -135752,7 +136870,7 @@ ${JSON.stringify(context, null, 2)}`);
         let stepExecutionFailed = false;
         for (let step of context.steps) {
           if (!step.stepId)
-            step.stepId = (0, import_node_crypto4.randomUUID)();
+            step.stepId = (0, import_node_crypto5.randomUUID)();
           log(config, "debug", `STEP:
 ${JSON.stringify(step, null, 2)}`);
           if (step.unsafe && runnerDetails.allowUnsafeSteps === false) {
@@ -135807,7 +136925,7 @@ ${JSON.stringify(stepResult, null, 2)}`);
           const stopRecordStep = {
             stopRecord: true,
             description: "Stopping recording",
-            stepId: (0, import_node_crypto4.randomUUID)()
+            stepId: (0, import_node_crypto5.randomUUID)()
           };
           const stepResult = await runStep({
             config,
@@ -136011,7 +137129,7 @@ async function appiumIsReady(timeoutMs = 12e4) {
     }
     await new Promise((resolve) => setTimeout(resolve, 1e3));
     try {
-      let resp = await import_axios5.default.get("http://127.0.0.1:4723/status");
+      let resp = await import_axios6.default.get("http://127.0.0.1:4723/status");
       if (resp.status === 200)
         isReady = true;
     } catch {
@@ -136100,7 +137218,7 @@ async function getRunner(options = {}) {
 }
 
 // dist/core/telem.js
-var import_node_os7 = __toESM(require("node:os"), 1);
+var import_node_os8 = __toESM(require("node:os"), 1);
 var import_posthog_node = require("posthog-node");
 var import_node_module = require("node:module");
 var require2 = (0, import_node_module.createRequire)(importMetaUrl);
@@ -136125,11 +137243,11 @@ function sendTelemetry(config, command, results) {
   telemetryData.dist_interface = telemetryData.dist_interface || "package";
   telemetryData.core_version = pkg.version;
   telemetryData.dist_version = telemetryData.dist_version || telemetryData.core_version;
-  telemetryData.core_platform = platformMap2[import_node_os7.default.platform()] || import_node_os7.default.platform();
+  telemetryData.core_platform = platformMap2[import_node_os8.default.platform()] || import_node_os8.default.platform();
   telemetryData.dist_platform = telemetryData.dist_platform || telemetryData.core_platform;
-  telemetryData.core_platform_version = import_node_os7.default.release();
+  telemetryData.core_platform_version = import_node_os8.default.release();
   telemetryData.dist_platform_version = telemetryData.dist_platform_version || telemetryData.core_platform_version;
-  telemetryData.core_platform_arch = import_node_os7.default.arch();
+  telemetryData.core_platform_arch = import_node_os8.default.arch();
   telemetryData.dist_platform_arch = telemetryData.dist_platform_arch || telemetryData.core_platform_arch;
   telemetryData.core_deployment = telemetryData.core_deployment || "node";
   telemetryData.dist_deployment = telemetryData.dist_deployment || telemetryData.core_deployment;