prowl-tools 0.1.3

package/dist/lib.cjs

@@ -0,0 +1,3765 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runner/visual.ts
+var visual_exports = {};
+__export(visual_exports, {
+  compareScreenshots: () => compareScreenshots,
+  ensureBaselineDir: () => ensureBaselineDir
+});
+async function compareScreenshots(baselinePath, currentPath, diffPath, threshold) {
+  const baselineData = import_pngjs.PNG.sync.read(import_node_fs3.default.readFileSync(baselinePath));
+  const currentData = import_pngjs.PNG.sync.read(import_node_fs3.default.readFileSync(currentPath));
+  const { width, height } = baselineData;
+  if (currentData.width !== width || currentData.height !== height) {
+    const diff2 = new import_pngjs.PNG({ width, height });
+    import_node_fs3.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
+    return {
+      match: false,
+      diffPercentage: 1,
+      diffImagePath: diffPath
+    };
+  }
+  const diff = new import_pngjs.PNG({ width, height });
+  const diffPixels = (0, import_pixelmatch.default)(
+    baselineData.data,
+    currentData.data,
+    diff.data,
+    width,
+    height,
+    { threshold: 0.1 }
+  );
+  const totalPixels = width * height;
+  const diffPercentage = diffPixels / totalPixels;
+  import_node_fs3.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
+  return {
+    match: diffPercentage <= threshold,
+    diffPercentage,
+    diffImagePath: diffPath
+  };
+}
+function ensureBaselineDir(configDir) {
+  const baselineDir = import_node_path3.default.join(configDir, "baselines");
+  import_node_fs3.default.mkdirSync(baselineDir, { recursive: true });
+  return baselineDir;
+}
+var import_node_fs3, import_node_path3, import_pngjs, import_pixelmatch;
+var init_visual = __esm({
+  "src/runner/visual.ts"() {
+    "use strict";
+    import_node_fs3 = __toESM(require("fs"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+    import_pngjs = require("pngjs");
+    import_pixelmatch = __toESM(require("pixelmatch"), 1);
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_FLAKY_THRESHOLD: () => DEFAULT_FLAKY_THRESHOLD,
+  analyzePage: () => analyzePage,
+  buildHealCandidates: () => buildHealCandidates,
+  clusterFailures: () => clusterFailures,
+  computeFlakeScore: () => computeFlakeScore,
+  configSchema: () => configSchema,
+  extractFailures: () => extractFailures,
+  extractSelectorIntent: () => extractSelectorIntent,
+  generateHunt: () => generateHunt,
+  healSelector: () => healSelector,
+  huntSchema: () => huntSchema,
+  interpolateHunt: () => interpolateHunt,
+  listHunts: () => listHunts,
+  loadConfig: () => loadConfig,
+  loadHunt: () => loadHunt,
+  loadHuntMeta: () => loadHuntMeta,
+  loadHuntTags: () => loadHuntTags,
+  rankFlaky: () => rankFlaky,
+  readHistory: () => readHistory,
+  readHuntHistory: () => readHuntHistory,
+  runHunt: () => runHunt,
+  runSuite: () => runSuite,
+  stepSchema: () => stepSchema,
+  updateBacklogFromSuite: () => updateBacklogFromSuite
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/runner/index.ts
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
+
+// src/config/loader.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_yaml = __toESM(require("yaml"), 1);
+var import_dotenv = __toESM(require("dotenv"), 1);
+
+// src/config/schema.ts
+var import_zod = require("zod");
+
+// src/config/hunt-name.ts
+var HUNT_NAME_PATTERN = /^[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/;
+function isValidHuntName(name) {
+  return HUNT_NAME_PATTERN.test(name);
+}
+function assertValidHuntName(name) {
+  if (!isValidHuntName(name)) {
+    throw new Error(
+      `Invalid hunt name: "${name}". Use only letters, numbers, hyphens, underscores, and forward slashes.`
+    );
+  }
+}
+
+// src/config/schema.ts
+var configSchema = import_zod.z.object({
+  target: import_zod.z.object({
+    url: import_zod.z.string().min(1)
+  }),
+  browser: import_zod.z.object({
+    headless: import_zod.z.boolean().optional(),
+    slowMo: import_zod.z.number().optional(),
+    timeout: import_zod.z.number().optional(),
+    engine: import_zod.z.enum(["chromium", "firefox", "webkit"]).optional(),
+    channel: import_zod.z.enum([
+      "chromium",
+      "chrome",
+      "chrome-beta",
+      "chrome-canary",
+      "chrome-dev",
+      "msedge",
+      "msedge-beta",
+      "msedge-canary",
+      "msedge-dev"
+    ]).optional(),
+    viewport: import_zod.z.union([
+      import_zod.z.enum(["mobile", "tablet", "desktop"]),
+      import_zod.z.object({ width: import_zod.z.number().int().positive(), height: import_zod.z.number().int().positive() }).strict()
+    ]).optional()
+  }).optional(),
+  artifacts: import_zod.z.object({
+    screenshots: import_zod.z.enum(["on-failure", "all"]).optional(),
+    networkHar: import_zod.z.boolean().optional(),
+    console: import_zod.z.boolean().optional(),
+    junit: import_zod.z.boolean().optional()
+  }).optional(),
+  assertions: import_zod.z.object({
+    noConsoleErrors: import_zod.z.boolean().optional(),
+    noNetworkErrors: import_zod.z.boolean().optional(),
+    maxTotalTimeMs: import_zod.z.number().optional(),
+    networkIgnorePatterns: import_zod.z.array(import_zod.z.string()).optional()
+  }).optional(),
+  guardrails: import_zod.z.object({
+    maxSteps: import_zod.z.number().optional(),
+    allowedDomains: import_zod.z.array(import_zod.z.string()).optional(),
+    forbiddenSelectors: import_zod.z.array(import_zod.z.string()).optional(),
+    selfHealing: import_zod.z.boolean().optional()
+  }).optional(),
+  auth: import_zod.z.object({
+    storageStatePath: import_zod.z.string().optional()
+  }).optional(),
+  history: import_zod.z.object({
+    maxRuns: import_zod.z.number().int().positive().optional()
+  }).optional(),
+  bugLog: import_zod.z.object({
+    enabled: import_zod.z.boolean().optional(),
+    backlogPath: import_zod.z.string().min(1).optional(),
+    resolvedPath: import_zod.z.string().min(1).optional()
+  }).strict().optional(),
+  tracing: import_zod.z.object({
+    header: import_zod.z.string().min(1).optional()
+  }).strict().optional(),
+  reliability: import_zod.z.object({
+    flakyThreshold: import_zod.z.number().min(0).max(1).optional()
+  }).strict().optional()
+}).strict();
+var navigateStepSchema = import_zod.z.object({ navigate: import_zod.z.string().min(1) }).strict();
+var clickStepSchema = import_zod.z.object({
+  click: import_zod.z.union([import_zod.z.object({ selector: import_zod.z.string().min(1) }).strict(), import_zod.z.string().min(1)])
+}).strict();
+var singleKeyValueSchema = import_zod.z.record(import_zod.z.string().min(1), import_zod.z.string()).refine((record) => Object.keys(record).length === 1, {
+  message: "Expected exactly one key-value pair"
+});
+var fillStepSchema = import_zod.z.object({
+  fill: import_zod.z.union([
+    import_zod.z.object({ selector: import_zod.z.string().min(1), value: import_zod.z.string() }).strict(),
+    singleKeyValueSchema
+  ])
+}).strict();
+var typeStepSchema = import_zod.z.object({ type: import_zod.z.string() }).strict();
+var pressStepSchema = import_zod.z.object({
+  press: import_zod.z.object({ selector: import_zod.z.string().min(1), key: import_zod.z.string().min(1) }).strict()
+}).strict();
+var waitForSelectorStepSchema = import_zod.z.object({
+  waitForSelector: import_zod.z.object({ selector: import_zod.z.string().min(1), timeout: import_zod.z.number().optional() }).strict()
+}).strict();
+var waitStepSchema = import_zod.z.object({
+  wait: import_zod.z.union([
+    import_zod.z.string().min(1),
+    import_zod.z.object({ for: import_zod.z.string().min(1), timeout: import_zod.z.number().optional() }).strict()
+  ])
+}).strict();
+var waitForUrlStepSchema = import_zod.z.object({
+  waitForUrl: import_zod.z.object({ value: import_zod.z.string().min(1), timeout: import_zod.z.number().optional() }).strict()
+}).strict();
+var waitForNetworkIdleStepSchema = import_zod.z.object({
+  waitForNetworkIdle: import_zod.z.object({ timeout: import_zod.z.number().optional() }).strict()
+}).strict();
+var selectOptionStepSchema = import_zod.z.object({
+  selectOption: import_zod.z.object({ selector: import_zod.z.string().min(1), value: import_zod.z.string() }).strict()
+}).strict();
+var selectStepSchema = import_zod.z.object({
+  select: singleKeyValueSchema
+}).strict();
+var onDialogStepSchema = import_zod.z.object({
+  onDialog: import_zod.z.object({ action: import_zod.z.enum(["accept", "dismiss"]) }).strict()
+}).strict();
+var setInputFilesStepSchema = import_zod.z.object({
+  setInputFiles: import_zod.z.object({
+    selector: import_zod.z.string().min(1),
+    files: import_zod.z.union([import_zod.z.string().min(1), import_zod.z.array(import_zod.z.string().min(1)).min(1)])
+  }).strict()
+}).strict();
+var inlineAssertStepSchema = import_zod.z.object({
+  assert: import_zod.z.object({
+    visible: import_zod.z.string().min(1).optional(),
+    notVisible: import_zod.z.string().min(1).optional(),
+    urlIncludes: import_zod.z.string().min(1).optional(),
+    urlEquals: import_zod.z.string().min(1).optional()
+  }).strict().refine(
+    (value) => [value.visible, value.notVisible, value.urlIncludes, value.urlEquals].filter(
+      (entry) => entry !== void 0
+    ).length === 1,
+    {
+      message: "assert requires exactly one of visible, notVisible, urlIncludes, urlEquals"
+    }
+  )
+}).strict();
+var runHuntStepSchema = import_zod.z.object({
+  runHunt: import_zod.z.union([
+    import_zod.z.string().min(1).refine(isValidHuntName, {
+      message: "Invalid hunt name. Use only letters, numbers, hyphens, underscores, and forward slashes."
+    }),
+    import_zod.z.object({
+      name: import_zod.z.string().min(1).refine(isValidHuntName, {
+        message: "Invalid hunt name. Use only letters, numbers, hyphens, underscores, and forward slashes."
+      }),
+      vars: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+    }).strict()
+  ])
+}).strict();
+var hoverStepSchema = import_zod.z.object({
+  hover: import_zod.z.object({ selector: import_zod.z.string().min(1) }).strict()
+}).strict();
+var scrollStepSchema = import_zod.z.object({
+  scroll: import_zod.z.object({
+    direction: import_zod.z.enum(["up", "down", "left", "right"]),
+    amount: import_zod.z.number().optional()
+  }).strict()
+}).strict();
+var scrollToStepSchema = import_zod.z.object({
+  scrollTo: import_zod.z.object({ selector: import_zod.z.string().min(1) }).strict()
+}).strict();
+var screenshotStepSchema = import_zod.z.object({
+  screenshot: import_zod.z.object({ name: import_zod.z.string().optional() }).strict()
+}).strict();
+var ifStepSchema = import_zod.z.object({
+  if: import_zod.z.object({
+    visible: import_zod.z.string().min(1).optional(),
+    notVisible: import_zod.z.string().min(1).optional(),
+    then: import_zod.z.lazy(() => import_zod.z.array(stepSchema).min(1)),
+    else: import_zod.z.lazy(() => import_zod.z.array(stepSchema).min(1)).optional()
+  }).strict().refine(
+    (value) => [value.visible, value.notVisible].filter((v) => v !== void 0).length === 1,
+    { message: "if requires exactly one of visible or notVisible" }
+  )
+}).strict();
+var repeatStepSchema = import_zod.z.object({
+  repeat: import_zod.z.object({
+    times: import_zod.z.number().int().positive().optional(),
+    while: import_zod.z.object({
+      visible: import_zod.z.string().min(1).optional(),
+      notVisible: import_zod.z.string().min(1).optional()
+    }).strict().refine(
+      (value) => [value.visible, value.notVisible].filter((v) => v !== void 0).length === 1,
+      { message: "while requires exactly one of visible or notVisible" }
+    ).optional(),
+    maxIterations: import_zod.z.number().int().positive().optional(),
+    steps: import_zod.z.lazy(() => import_zod.z.array(stepSchema).min(1))
+  }).strict().refine((value) => !(value.times !== void 0 && value.while !== void 0), {
+    message: "repeat requires either times or while, not both"
+  }).refine((value) => value.times !== void 0 || value.while !== void 0, {
+    message: "repeat requires either times or while"
+  }).refine((value) => !(value.while !== void 0 && value.maxIterations === void 0), {
+    message: "while requires maxIterations"
+  })
+}).strict();
+var mockRouteStepSchema = import_zod.z.object({
+  mockRoute: import_zod.z.object({
+    url: import_zod.z.string().min(1),
+    response: import_zod.z.object({
+      status: import_zod.z.number().int(),
+      contentType: import_zod.z.string().min(1).optional(),
+      body: import_zod.z.string().min(1).optional(),
+      file: import_zod.z.string().min(1).optional()
+    }).strict().refine(
+      (value) => [value.body, value.file].filter((v) => v !== void 0).length === 1,
+      { message: "response requires exactly one of body or file" }
+    )
+  }).strict()
+}).strict();
+var unmockRouteStepSchema = import_zod.z.object({
+  unmockRoute: import_zod.z.union([
+    import_zod.z.string().min(1),
+    import_zod.z.object({ url: import_zod.z.string().min(1) }).strict()
+  ])
+}).strict();
+var evalScriptStepSchema = import_zod.z.object({
+  evalScript: import_zod.z.union([
+    import_zod.z.string().min(1),
+    import_zod.z.object({
+      expression: import_zod.z.string().min(1),
+      as: import_zod.z.string().min(1).optional()
+    }).strict()
+  ])
+}).strict();
+var runScriptStepSchema = import_zod.z.object({
+  runScript: import_zod.z.object({ file: import_zod.z.string().min(1) }).strict()
+}).strict();
+var assertScreenshotStepSchema = import_zod.z.object({
+  assertScreenshot: import_zod.z.object({
+    name: import_zod.z.string().min(1),
+    threshold: import_zod.z.number().min(0).max(1).optional()
+  }).strict()
+}).strict();
+var copyTextStepSchema = import_zod.z.object({
+  copyText: import_zod.z.object({
+    selector: import_zod.z.string().min(1),
+    as: import_zod.z.string().min(1)
+  }).strict()
+}).strict();
+var waitForDownloadStepSchema = import_zod.z.object({
+  waitForDownload: import_zod.z.union([
+    import_zod.z.object({
+      filename: import_zod.z.string().min(1).optional(),
+      timeout: import_zod.z.number().int().positive().optional()
+    }).strict(),
+    import_zod.z.null()
+  ])
+}).strict();
+var stepSchema = import_zod.z.union([
+  navigateStepSchema,
+  clickStepSchema,
+  fillStepSchema,
+  typeStepSchema,
+  pressStepSchema,
+  waitStepSchema,
+  selectOptionStepSchema,
+  selectStepSchema,
+  onDialogStepSchema,
+  setInputFilesStepSchema,
+  inlineAssertStepSchema,
+  runHuntStepSchema,
+  waitForSelectorStepSchema,
+  waitForUrlStepSchema,
+  waitForNetworkIdleStepSchema,
+  hoverStepSchema,
+  scrollStepSchema,
+  scrollToStepSchema,
+  screenshotStepSchema,
+  ifStepSchema,
+  repeatStepSchema,
+  mockRouteStepSchema,
+  unmockRouteStepSchema,
+  evalScriptStepSchema,
+  runScriptStepSchema,
+  assertScreenshotStepSchema,
+  copyTextStepSchema,
+  waitForDownloadStepSchema
+]);
+var assertionSchema = import_zod.z.union([
+  import_zod.z.object({ selectorExists: import_zod.z.string().min(1) }).strict(),
+  import_zod.z.object({ selectorNotExists: import_zod.z.string().min(1) }).strict(),
+  import_zod.z.object({ urlIncludes: import_zod.z.string().min(1) }).strict(),
+  import_zod.z.object({ urlEquals: import_zod.z.string().min(1) }).strict(),
+  import_zod.z.object({ noConsoleErrors: import_zod.z.boolean() }).strict(),
+  import_zod.z.object({ noNetworkErrors: import_zod.z.boolean() }).strict()
+]);
+var huntSchema = import_zod.z.object({
+  name: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  tags: import_zod.z.array(import_zod.z.string().min(1)).optional(),
+  vars: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional(),
+  steps: import_zod.z.array(stepSchema),
+  assertions: import_zod.z.array(assertionSchema).optional(),
+  retry: import_zod.z.object({
+    maxRetries: import_zod.z.number().int().min(0),
+    delay: import_zod.z.number().int().min(0).optional()
+  }).strict().optional()
+}).strict();
+
+// src/config/loader.ts
+var DEFAULT_CONFIG = {
+  target: {
+    url: "http://localhost:3000"
+  },
+  browser: {
+    headless: true,
+    slowMo: 0,
+    timeout: 3e4,
+    engine: "chromium",
+    viewport: { width: 1280, height: 720 }
+  },
+  artifacts: {
+    screenshots: "on-failure",
+    networkHar: false,
+    console: true,
+    junit: false
+  },
+  assertions: {
+    noConsoleErrors: true,
+    noNetworkErrors: true,
+    maxTotalTimeMs: 3e4,
+    networkIgnorePatterns: []
+  },
+  guardrails: {
+    maxSteps: 50,
+    allowedDomains: ["localhost", "127.0.0.1", "0.0.0.0"],
+    forbiddenSelectors: ["[data-danger]", ".delete-btn"],
+    selfHealing: false
+  },
+  auth: {
+    storageStatePath: ".prowl/auth-state.json"
+  },
+  history: {
+    maxRuns: 100
+  }
+};
+var CONFIG_DIR = ".prowl";
+var LEGACY_CONFIG_DIR = ".prowlqa";
+var legacyDirWarned = false;
+function warnLegacyConfigDir() {
+  if (legacyDirWarned) {
+    return;
+  }
+  legacyDirWarned = true;
+  console.warn(
+    'Warning: the ".prowlqa/" config directory is deprecated; rename it to ".prowl/". Support for ".prowlqa/" will be removed in a future release.'
+  );
+}
+function findConfigPath(startDir) {
+  let current = startDir;
+  while (current) {
+    for (const dir of [CONFIG_DIR, LEGACY_CONFIG_DIR]) {
+      const candidate = import_node_path.default.join(current, dir, "config.yml");
+      if (import_node_fs.default.existsSync(candidate)) {
+        return candidate;
+      }
+    }
+    const parent = import_node_path.default.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return null;
+}
+var VIEWPORT_PRESETS = {
+  mobile: { width: 375, height: 812 },
+  tablet: { width: 768, height: 1024 },
+  desktop: { width: 1280, height: 720 }
+};
+function resolveViewport(value) {
+  if (value === void 0) {
+    return DEFAULT_CONFIG.browser.viewport;
+  }
+  if (typeof value === "string") {
+    const preset = VIEWPORT_PRESETS[value];
+    if (!preset) {
+      throw new Error(`Unknown viewport preset: "${value}". Use mobile, tablet, or desktop.`);
+    }
+    return preset;
+  }
+  return value;
+}
+function mergeConfig(partial) {
+  return {
+    target: {
+      url: partial.target?.url ?? DEFAULT_CONFIG.target.url
+    },
+    browser: {
+      headless: partial.browser?.headless ?? DEFAULT_CONFIG.browser.headless,
+      slowMo: partial.browser?.slowMo ?? DEFAULT_CONFIG.browser.slowMo,
+      timeout: partial.browser?.timeout ?? DEFAULT_CONFIG.browser.timeout,
+      engine: partial.browser?.engine ?? DEFAULT_CONFIG.browser.engine,
+      channel: partial.browser?.channel,
+      viewport: resolveViewport(partial.browser?.viewport)
+    },
+    artifacts: {
+      screenshots: partial.artifacts?.screenshots ?? DEFAULT_CONFIG.artifacts.screenshots,
+      networkHar: partial.artifacts?.networkHar ?? DEFAULT_CONFIG.artifacts.networkHar,
+      console: partial.artifacts?.console ?? DEFAULT_CONFIG.artifacts.console,
+      junit: partial.artifacts?.junit ?? DEFAULT_CONFIG.artifacts.junit
+    },
+    assertions: {
+      noConsoleErrors: partial.assertions?.noConsoleErrors ?? DEFAULT_CONFIG.assertions.noConsoleErrors,
+      noNetworkErrors: partial.assertions?.noNetworkErrors ?? DEFAULT_CONFIG.assertions.noNetworkErrors,
+      maxTotalTimeMs: partial.assertions?.maxTotalTimeMs ?? DEFAULT_CONFIG.assertions.maxTotalTimeMs,
+      networkIgnorePatterns: partial.assertions?.networkIgnorePatterns ?? DEFAULT_CONFIG.assertions.networkIgnorePatterns
+    },
+    guardrails: {
+      maxSteps: partial.guardrails?.maxSteps ?? DEFAULT_CONFIG.guardrails.maxSteps,
+      allowedDomains: partial.guardrails?.allowedDomains ?? DEFAULT_CONFIG.guardrails.allowedDomains,
+      forbiddenSelectors: partial.guardrails?.forbiddenSelectors ?? DEFAULT_CONFIG.guardrails.forbiddenSelectors,
+      selfHealing: partial.guardrails?.selfHealing ?? DEFAULT_CONFIG.guardrails.selfHealing
+    },
+    auth: {
+      storageStatePath: partial.auth?.storageStatePath ?? (partial.auth !== void 0 ? DEFAULT_CONFIG.auth.storageStatePath : void 0)
+    },
+    history: {
+      maxRuns: partial.history?.maxRuns ?? DEFAULT_CONFIG.history.maxRuns
+    },
+    bugLog: partial.bugLog,
+    tracing: partial.tracing,
+    reliability: partial.reliability
+  };
+}
+function ensureAllowedDomain(allowed, urlValue) {
+  try {
+    const host = new URL(urlValue).hostname;
+    if (!allowed.includes(host)) {
+      return [...allowed, host];
+    }
+  } catch {
+    return allowed;
+  }
+  return allowed;
+}
+function loadConfig(configPath) {
+  const resolvedPath = configPath ? import_node_path.default.resolve(configPath) : findConfigPath(process.cwd());
+  if (!resolvedPath) {
+    throw new Error("Could not find .prowl/config.yml. Run `prowl init` first.");
+  }
+  if (!import_node_fs.default.existsSync(resolvedPath)) {
+    throw new Error(`Config file not found at ${resolvedPath}`);
+  }
+  const configDir = import_node_path.default.dirname(resolvedPath);
+  if (import_node_path.default.basename(configDir) === LEGACY_CONFIG_DIR) {
+    warnLegacyConfigDir();
+  }
+  import_dotenv.default.config({ path: import_node_path.default.join(configDir, ".env"), override: false });
+  const raw = import_node_fs.default.readFileSync(resolvedPath, "utf-8");
+  const parsed = import_yaml.default.parse(raw) ?? {};
+  const validated = configSchema.parse(parsed);
+  const config = mergeConfig(validated);
+  config.guardrails.allowedDomains = ensureAllowedDomain(
+    config.guardrails.allowedDomains,
+    config.target.url
+  );
+  return { config, configPath: resolvedPath, configDir };
+}
+function loadHunt(huntName, configDir) {
+  assertValidHuntName(huntName);
+  const huntPath = import_node_path.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs.default.existsSync(huntPath)) {
+    throw new Error(`Hunt file not found: ${huntPath}`);
+  }
+  const raw = import_node_fs.default.readFileSync(huntPath, "utf-8");
+  const parsed = import_yaml.default.parse(raw) ?? {};
+  const validated = huntSchema.parse(parsed);
+  return validated;
+}
+function loadHuntTags(huntName, configDir) {
+  assertValidHuntName(huntName);
+  const huntPath = import_node_path.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs.default.existsSync(huntPath)) {
+    return [];
+  }
+  const raw = import_node_fs.default.readFileSync(huntPath, "utf-8");
+  const parsed = import_yaml.default.parse(raw) ?? {};
+  return Array.isArray(parsed.tags) ? parsed.tags : [];
+}
+function loadHuntMeta(huntName, configDir) {
+  assertValidHuntName(huntName);
+  const huntPath = import_node_path.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs.default.existsSync(huntPath)) {
+    return { tags: [] };
+  }
+  const raw = import_node_fs.default.readFileSync(huntPath, "utf-8");
+  const parsed = import_yaml.default.parse(raw) ?? {};
+  return {
+    description: typeof parsed.description === "string" ? parsed.description : void 0,
+    tags: Array.isArray(parsed.tags) ? parsed.tags : []
+  };
+}
+function listHunts(configDir) {
+  const huntsDir = import_node_path.default.join(configDir, "hunts");
+  if (!import_node_fs.default.existsSync(huntsDir)) {
+    return [];
+  }
+  const stats = import_node_fs.default.statSync(huntsDir);
+  if (!stats.isDirectory()) {
+    throw new Error(`Hunts path is not a directory: ${huntsDir}`);
+  }
+  const results = [];
+  function scanDir(dir) {
+    const entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".yml")) {
+        const fullPath = import_node_path.default.join(dir, entry.name);
+        const relative = import_node_path.default.relative(huntsDir, fullPath);
+        results.push(relative.replace(/\.yml$/, ""));
+      } else if (entry.isDirectory()) {
+        scanDir(import_node_path.default.join(dir, entry.name));
+      }
+    }
+  }
+  scanDir(huntsDir);
+  return results.sort((a, b) => a.localeCompare(b));
+}
+
+// src/config/interpolate.ts
+var import_node_crypto = __toESM(require("crypto"), 1);
+var VAR_PATTERN = /\{\{([A-Z0-9_]+)\}\}/g;
+function collectInterpolatedValues(input, vars, values) {
+  if (typeof input === "string") {
+    for (const match of input.matchAll(VAR_PATTERN)) {
+      const varValue = vars[match[1]];
+      if (varValue) values.add(varValue);
+    }
+    return;
+  }
+  if (Array.isArray(input)) {
+    for (const item of input) {
+      collectInterpolatedValues(item, vars, values);
+    }
+    return;
+  }
+  if (input && typeof input === "object") {
+    for (const [key, value] of Object.entries(input)) {
+      collectInterpolatedValues(key, vars, values);
+      collectInterpolatedValues(value, vars, values);
+    }
+  }
+}
+function interpolateString(input, vars) {
+  const usedVars = [];
+  const value = input.replace(VAR_PATTERN, (_, name) => {
+    const varValue = vars[name];
+    if (varValue === void 0) {
+      throw new Error(`Missing variable: ${name}`);
+    }
+    usedVars.push(name);
+    return varValue;
+  });
+  return { value, usedVars };
+}
+var RANDOM_FIRST_NAMES = ["Alex", "Jordan", "Morgan", "Taylor", "Casey", "Riley", "Quinn", "Avery"];
+var RANDOM_LAST_NAMES = ["Smith", "Johnson", "Brown", "Davis", "Wilson", "Clark", "Hall", "Young"];
+function generateRandomVars(randomSource) {
+  const random = randomSource?.random ?? Math.random;
+  const randomBytes = randomSource?.randomBytes ?? import_node_crypto.default.randomBytes;
+  const randomUUID = randomSource?.randomUUID ?? import_node_crypto.default.randomUUID;
+  const hex = randomBytes(4).toString("hex");
+  const firstIndex = Math.floor(random() * RANDOM_FIRST_NAMES.length);
+  const lastIndex = Math.floor(random() * RANDOM_LAST_NAMES.length);
+  const num = Math.floor(random() * 9e3) + 1e3;
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let text = "";
+  for (let i = 0; i < 8; i++) {
+    text += chars[Math.floor(random() * chars.length)];
+  }
+  return {
+    RANDOM_EMAIL: `prowl_${hex}@test.com`,
+    RANDOM_NAME: `${RANDOM_FIRST_NAMES[firstIndex]} ${RANDOM_LAST_NAMES[lastIndex]}`,
+    RANDOM_NUMBER: String(num),
+    RANDOM_UUID: randomUUID(),
+    RANDOM_TEXT: text
+  };
+}
+function interpolateStep(step, vars, stepPath2, redacted) {
+  const isExplicitFill = (value) => typeof value.selector === "string" && typeof value.value === "string";
+  const interpolateSinglePair = (record) => {
+    const entries = Object.entries(record);
+    if (entries.length !== 1) {
+      throw new Error("Shorthand step expects exactly one key-value pair");
+    }
+    const [key, value] = entries[0];
+    return {
+      [interpolateString(key, vars).value]: interpolateString(value, vars).value
+    };
+  };
+  if ("navigate" in step) {
+    const result = interpolateString(step.navigate, vars);
+    return { navigate: result.value };
+  }
+  if ("click" in step) {
+    if (typeof step.click === "string") {
+      return { click: interpolateString(step.click, vars).value };
+    }
+    const result = interpolateString(step.click.selector, vars);
+    return { click: { selector: result.value } };
+  }
+  if ("fill" in step) {
+    if (isExplicitFill(step.fill)) {
+      const selectorResult = interpolateString(step.fill.selector, vars);
+      const valueResult2 = interpolateString(step.fill.value, vars);
+      if (valueResult2.usedVars.length > 0) {
+        redacted.add(stepPath2);
+      }
+      return { fill: { selector: selectorResult.value, value: valueResult2.value } };
+    }
+    const [rawLabel, rawValue] = Object.entries(step.fill)[0] ?? [];
+    if (rawLabel === void 0 || rawValue === void 0) {
+      throw new Error("Shorthand fill expects exactly one key-value pair");
+    }
+    const labelResult = interpolateString(rawLabel, vars);
+    const valueResult = interpolateString(rawValue, vars);
+    if (valueResult.usedVars.length > 0) {
+      redacted.add(stepPath2);
+    }
+    return {
+      fill: {
+        [labelResult.value]: valueResult.value
+      }
+    };
+  }
+  if ("type" in step) {
+    const valueResult = interpolateString(step.type, vars);
+    if (valueResult.usedVars.length > 0) {
+      redacted.add(stepPath2);
+    }
+    return { type: valueResult.value };
+  }
+  if ("selectOption" in step) {
+    const selectorResult = interpolateString(step.selectOption.selector, vars);
+    const valueResult = interpolateString(step.selectOption.value, vars);
+    return { selectOption: { selector: selectorResult.value, value: valueResult.value } };
+  }
+  if ("select" in step) {
+    return { select: interpolateSinglePair(step.select) };
+  }
+  if ("press" in step) {
+    const selectorResult = interpolateString(step.press.selector, vars);
+    const keyResult = interpolateString(step.press.key, vars);
+    return { press: { selector: selectorResult.value, key: keyResult.value } };
+  }
+  if ("onDialog" in step) {
+    return { onDialog: { action: step.onDialog.action } };
+  }
+  if ("setInputFiles" in step) {
+    const selectorResult = interpolateString(step.setInputFiles.selector, vars);
+    const rawFiles = step.setInputFiles.files;
+    const files = Array.isArray(rawFiles) ? rawFiles.map((f) => interpolateString(f, vars).value) : interpolateString(rawFiles, vars).value;
+    return { setInputFiles: { selector: selectorResult.value, files } };
+  }
+  if ("runHunt" in step) {
+    if (typeof step.runHunt === "string") {
+      return { runHunt: interpolateString(step.runHunt, vars).value };
+    }
+    const nameResult = interpolateString(step.runHunt.name, vars);
+    const interpolatedVars = {};
+    for (const [key, value] of Object.entries(step.runHunt.vars ?? {})) {
+      interpolatedVars[key] = interpolateString(value, vars).value;
+    }
+    return {
+      runHunt: {
+        name: nameResult.value,
+        ...Object.keys(interpolatedVars).length > 0 ? { vars: interpolatedVars } : {}
+      }
+    };
+  }
+  if ("assert" in step) {
+    if (step.assert.visible !== void 0) {
+      return { assert: { visible: interpolateString(step.assert.visible, vars).value } };
+    }
+    if (step.assert.notVisible !== void 0) {
+      return { assert: { notVisible: interpolateString(step.assert.notVisible, vars).value } };
+    }
+    if (step.assert.urlIncludes !== void 0) {
+      return { assert: { urlIncludes: interpolateString(step.assert.urlIncludes, vars).value } };
+    }
+    if (step.assert.urlEquals !== void 0) {
+      return { assert: { urlEquals: interpolateString(step.assert.urlEquals, vars).value } };
+    }
+    return step;
+  }
+  if ("wait" in step) {
+    if (typeof step.wait === "string") {
+      return { wait: interpolateString(step.wait, vars).value };
+    }
+    return {
+      wait: {
+        for: interpolateString(step.wait.for, vars).value,
+        timeout: step.wait.timeout
+      }
+    };
+  }
+  if ("waitForSelector" in step) {
+    const selectorResult = interpolateString(step.waitForSelector.selector, vars);
+    return {
+      waitForSelector: {
+        selector: selectorResult.value,
+        timeout: step.waitForSelector.timeout
+      }
+    };
+  }
+  if ("waitForUrl" in step) {
+    const valueResult = interpolateString(step.waitForUrl.value, vars);
+    return {
+      waitForUrl: {
+        value: valueResult.value,
+        timeout: step.waitForUrl.timeout
+      }
+    };
+  }
+  if ("waitForNetworkIdle" in step) {
+    return { waitForNetworkIdle: { timeout: step.waitForNetworkIdle.timeout } };
+  }
+  if ("hover" in step) {
+    const selectorResult = interpolateString(step.hover.selector, vars);
+    return { hover: { selector: selectorResult.value } };
+  }
+  if ("scroll" in step) {
+    return { scroll: { direction: step.scroll.direction, amount: step.scroll.amount } };
+  }
+  if ("scrollTo" in step) {
+    const selectorResult = interpolateString(step.scrollTo.selector, vars);
+    return { scrollTo: { selector: selectorResult.value } };
+  }
+  if ("screenshot" in step) {
+    return { screenshot: { name: step.screenshot.name } };
+  }
+  if ("if" in step) {
+    const condition = step.if;
+    const thenSteps = condition.then.map(
+      (s, i) => interpolateStep(s, vars, `${stepPath2}.if.then.${i}`, redacted)
+    );
+    const elseSteps = condition.else?.map(
+      (s, i) => interpolateStep(s, vars, `${stepPath2}.if.else.${i}`, redacted)
+    );
+    return {
+      if: {
+        ...condition.visible !== void 0 ? { visible: interpolateString(condition.visible, vars).value } : {},
+        ...condition.notVisible !== void 0 ? { notVisible: interpolateString(condition.notVisible, vars).value } : {},
+        then: thenSteps,
+        ...elseSteps !== void 0 ? { else: elseSteps } : {}
+      }
+    };
+  }
+  if ("repeat" in step) {
+    const repeat = step.repeat;
+    const subSteps = repeat.steps.map(
+      (s, i) => interpolateStep(s, vars, `${stepPath2}.repeat.steps.${i}`, redacted)
+    );
+    return {
+      repeat: {
+        ...repeat.times !== void 0 ? { times: repeat.times } : {},
+        ...repeat.while !== void 0 ? {
+          while: {
+            ...repeat.while.visible !== void 0 ? { visible: interpolateString(repeat.while.visible, vars).value } : {},
+            ...repeat.while.notVisible !== void 0 ? { notVisible: interpolateString(repeat.while.notVisible, vars).value } : {}
+          }
+        } : {},
+        ...repeat.maxIterations !== void 0 ? { maxIterations: repeat.maxIterations } : {},
+        steps: subSteps
+      }
+    };
+  }
+  if ("mockRoute" in step) {
+    const mock = step.mockRoute;
+    return {
+      mockRoute: {
+        url: interpolateString(mock.url, vars).value,
+        response: {
+          status: mock.response.status,
+          ...mock.response.contentType !== void 0 ? { contentType: interpolateString(mock.response.contentType, vars).value } : {},
+          ...mock.response.body !== void 0 ? { body: interpolateString(mock.response.body, vars).value } : {},
+          ...mock.response.file !== void 0 ? { file: interpolateString(mock.response.file, vars).value } : {}
+        }
+      }
+    };
+  }
+  if ("unmockRoute" in step) {
+    if (typeof step.unmockRoute === "string") {
+      return { unmockRoute: interpolateString(step.unmockRoute, vars).value };
+    }
+    return {
+      unmockRoute: { url: interpolateString(step.unmockRoute.url, vars).value }
+    };
+  }
+  if ("evalScript" in step) {
+    if (typeof step.evalScript === "string") {
+      return { evalScript: interpolateString(step.evalScript, vars).value };
+    }
+    return {
+      evalScript: {
+        expression: interpolateString(step.evalScript.expression, vars).value,
+        ...step.evalScript.as !== void 0 ? { as: step.evalScript.as } : {}
+      }
+    };
+  }
+  if ("runScript" in step) {
+    return {
+      runScript: { file: interpolateString(step.runScript.file, vars).value }
+    };
+  }
+  if ("assertScreenshot" in step) {
+    return {
+      assertScreenshot: {
+        name: interpolateString(step.assertScreenshot.name, vars).value,
+        ...step.assertScreenshot.threshold !== void 0 ? { threshold: step.assertScreenshot.threshold } : {}
+      }
+    };
+  }
+  if ("copyText" in step) {
+    return {
+      copyText: {
+        selector: interpolateString(step.copyText.selector, vars).value,
+        as: step.copyText.as
+      }
+    };
+  }
+  if ("waitForDownload" in step) {
+    if (step.waitForDownload === null) {
+      return { waitForDownload: null };
+    }
+    return {
+      waitForDownload: {
+        ...step.waitForDownload.filename !== void 0 ? { filename: interpolateString(step.waitForDownload.filename, vars).value } : {},
+        ...step.waitForDownload.timeout !== void 0 ? { timeout: step.waitForDownload.timeout } : {}
+      }
+    };
+  }
+  return step;
+}
+function interpolateAssertion(assertion, vars) {
+  if ("selectorExists" in assertion) {
+    return { selectorExists: interpolateString(assertion.selectorExists, vars).value };
+  }
+  if ("selectorNotExists" in assertion) {
+    return { selectorNotExists: interpolateString(assertion.selectorNotExists, vars).value };
+  }
+  if ("urlIncludes" in assertion) {
+    return { urlIncludes: interpolateString(assertion.urlIncludes, vars).value };
+  }
+  if ("urlEquals" in assertion) {
+    return { urlEquals: interpolateString(assertion.urlEquals, vars).value };
+  }
+  if ("noConsoleErrors" in assertion) {
+    return { noConsoleErrors: assertion.noConsoleErrors };
+  }
+  if ("noNetworkErrors" in assertion) {
+    return { noNetworkErrors: assertion.noNetworkErrors };
+  }
+  return assertion;
+}
+function interpolateHunt(hunt, env, randomVars = generateRandomVars()) {
+  const redactedFillSteps = /* @__PURE__ */ new Set();
+  const envVars = Object.fromEntries(
+    Object.entries(env).filter(([, value]) => value !== void 0)
+  );
+  const baseVars = { ...randomVars, ...envVars };
+  const resolvedHuntVars = {};
+  for (const [key, value] of Object.entries(hunt.vars ?? {})) {
+    resolvedHuntVars[key] = interpolateString(value, baseVars).value;
+  }
+  const vars = { ...baseVars, ...resolvedHuntVars };
+  const redactionValues = /* @__PURE__ */ new Set();
+  collectInterpolatedValues(hunt.steps, vars, redactionValues);
+  collectInterpolatedValues(hunt.assertions, vars, redactionValues);
+  const steps = hunt.steps.map(
+    (step, index) => interpolateStep(step, vars, `${index}`, redactedFillSteps)
+  );
+  const assertions = hunt.assertions?.map((assertion) => interpolateAssertion(assertion, vars));
+  return {
+    hunt: {
+      ...hunt,
+      steps,
+      assertions
+    },
+    redactedFillSteps,
+    randomVars,
+    redactionValues: [...redactionValues]
+  };
+}
+
+// src/browser/controller.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var import_playwright = require("playwright");
+var ENGINES = { chromium: import_playwright.chromium, firefox: import_playwright.firefox, webkit: import_playwright.webkit };
+async function launchBrowser(options) {
+  const engine = ENGINES[options.engine ?? "chromium"];
+  const browser = await engine.launch({
+    headless: options.headless,
+    slowMo: options.slowMo,
+    channel: options.channel
+  });
+  const contextOptions = {};
+  if (options.viewport) {
+    contextOptions.viewport = options.viewport;
+  }
+  if (options.storageStatePath) {
+    if (import_node_fs2.default.existsSync(options.storageStatePath)) {
+      contextOptions.storageState = options.storageStatePath;
+    } else {
+      console.warn(`Auth state file not found: ${options.storageStatePath}. Run "prowl login" to create it.`);
+    }
+  }
+  if (options.recordHar) {
+    contextOptions.recordHar = { path: import_node_path2.default.join(options.runDir, "network.har") };
+  }
+  const context = await browser.newContext(contextOptions);
+  const page = await context.newPage();
+  page.setDefaultTimeout(options.timeout);
+  page.setDefaultNavigationTimeout(options.timeout);
+  let tracePath;
+  if (options.trace) {
+    tracePath = import_node_path2.default.join(options.runDir, "trace.zip");
+    await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
+  }
+  return { browser, context, page, tracePath };
+}
+async function closeBrowser(session) {
+  if (session.tracePath) {
+    await session.context.tracing.stop({ path: session.tracePath });
+  }
+  await session.context.close();
+  await session.browser.close();
+}
+
+// src/runner/steps.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+
+// src/browser/actions.ts
+async function clickElement(page, selector) {
+  await page.locator(selector).click();
+}
+async function fillElement(page, selector, value) {
+  await page.locator(selector).fill(value);
+}
+async function pressKey(page, selector, key) {
+  await page.locator(selector).press(key);
+}
+async function selectOption(page, selector, value) {
+  await page.locator(selector).selectOption(value);
+}
+function setupDialogHandler(page, action) {
+  page.once("dialog", async (dialog) => {
+    if (action === "accept") {
+      await dialog.accept();
+    } else {
+      await dialog.dismiss();
+    }
+  });
+}
+async function setInputFiles(page, selector, files) {
+  await page.locator(selector).setInputFiles(files);
+}
+
+// src/runner/healing.ts
+var INTERACTIVE_TAGS = ["button", "a", "input", "select", "textarea"];
+function extractSelectorIntent(selector) {
+  const raw = [];
+  for (const match of selector.matchAll(/[#.]([A-Za-z_][\w-]*)/g)) {
+    raw.push(match[1]);
+  }
+  for (const match of selector.matchAll(/\[[A-Za-z_:-]+\s*[~|^$*]?=\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+))\]/g)) {
+    const value = match[1] ?? match[2] ?? match[3];
+    if (value) raw.push(value);
+  }
+  const words = [];
+  for (const token of raw) {
+    for (const part of splitToken(token)) {
+      const lower = part.toLowerCase();
+      if (lower.length > 0 && !words.includes(lower)) {
+        words.push(lower);
+      }
+    }
+  }
+  return { words, label: words.join(" ") };
+}
+function splitToken(token) {
+  return token.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s\-_.:]+/).filter((part) => part.length > 0);
+}
+function buildHealCandidates(selector) {
+  const { words, label } = extractSelectorIntent(selector);
+  if (words.length === 0) return [];
+  const escaped = label.replace(/"/g, '\\"');
+  const candidates = [];
+  candidates.push({ selector: `text=${label}`, strategy: "text" });
+  candidates.push({ selector: `[aria-label*="${escaped}" i]`, strategy: "aria" });
+  for (const tag of INTERACTIVE_TAGS) {
+    candidates.push({ selector: `${tag}:has-text("${escaped}")`, strategy: "structural" });
+  }
+  return candidates;
+}
+async function healSelector(page, selector, options) {
+  if (!options.enabled) return null;
+  for (const candidate of buildHealCandidates(selector)) {
+    let count;
+    try {
+      const locator = page.locator(candidate.selector);
+      count = await locator.count();
+    } catch {
+      continue;
+    }
+    if (count === 1) {
+      return { selector: candidate.selector, healedFrom: selector, strategy: candidate.strategy };
+    }
+  }
+  return null;
+}
+
+// src/runner/steps.ts
+var ALWAYS_ALLOWED_PROTOCOLS = ["about:", "data:"];
+function unwrapTextSelector(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('text="') && trimmed.endsWith('"')) {
+    return trimmed.slice(6, -1);
+  }
+  if (trimmed.startsWith("text='") && trimmed.endsWith("'")) {
+    return trimmed.slice(6, -1);
+  }
+  if (trimmed.startsWith("text=")) {
+    return trimmed.slice(5);
+  }
+  return null;
+}
+function matchesForbiddenPattern(selector, forbidden) {
+  const selectorText = unwrapTextSelector(selector);
+  if (selectorText === null) {
+    return false;
+  }
+  const forbiddenText = unwrapTextSelector(forbidden);
+  if (forbiddenText !== null) {
+    return selectorText.includes(forbiddenText);
+  }
+  return selectorText.includes(forbidden);
+}
+function isForbiddenSelector(selector, forbiddenSelectors) {
+  return forbiddenSelectors.some(
+    (forbidden) => selector.includes(forbidden) || matchesForbiddenPattern(selector, forbidden)
+  );
+}
+function assertAllowedSelector(selector, forbiddenSelectors) {
+  if (isForbiddenSelector(selector, forbiddenSelectors)) {
+    throw new Error(`Forbidden selector: ${selector}`);
+  }
+}
+async function resolveActionSelector(context, selector) {
+  assertAllowedSelector(selector, context.forbiddenSelectors);
+  if (!context.selfHealing) {
+    return { selector };
+  }
+  let matched = false;
+  try {
+    matched = await context.page.locator(selector).count() > 0;
+  } catch {
+    return { selector };
+  }
+  if (matched) {
+    return { selector };
+  }
+  const healed = await healSelector(context.page, selector, { enabled: true });
+  if (!healed) {
+    return { selector };
+  }
+  assertAllowedSelector(healed.selector, context.forbiddenSelectors);
+  console.warn(
+    `Self-healed selector: "${selector}" \u2192 "${healed.selector}" (${healed.strategy}). Update your hunt to use a stable selector.`
+  );
+  return { selector: healed.selector, healedFrom: healed.healedFrom };
+}
+function assertWithinMaxSteps(stepCount, maxSteps, huntName) {
+  if (stepCount > maxSteps) {
+    if (huntName) {
+      throw new Error(`Hunt "${huntName}" has ${stepCount} steps. Max allowed is ${maxSteps}.`);
+    }
+    throw new Error(`Hunt has ${stepCount} steps. Max allowed is ${maxSteps}.`);
+  }
+}
+function getStepType(step) {
+  if ("navigate" in step) return "navigate";
+  if ("click" in step) return "click";
+  if ("fill" in step) return "fill";
+  if ("type" in step) return "type";
+  if ("selectOption" in step) return "selectOption";
+  if ("select" in step) return "select";
+  if ("onDialog" in step) return "onDialog";
+  if ("setInputFiles" in step) return "setInputFiles";
+  if ("runHunt" in step) return "runHunt";
+  if ("assert" in step) return "assert";
+  if ("press" in step) return "press";
+  if ("wait" in step) return "wait";
+  if ("waitForSelector" in step) return "waitForSelector";
+  if ("waitForUrl" in step) return "waitForUrl";
+  if ("waitForNetworkIdle" in step) return "waitForNetworkIdle";
+  if ("hover" in step) return "hover";
+  if ("scroll" in step) return "scroll";
+  if ("scrollTo" in step) return "scrollTo";
+  if ("screenshot" in step) return "screenshot";
+  if ("if" in step) return "if";
+  if ("repeat" in step) return "repeat";
+  if ("mockRoute" in step) return "mockRoute";
+  if ("unmockRoute" in step) return "unmockRoute";
+  if ("evalScript" in step) return "evalScript";
+  if ("runScript" in step) return "runScript";
+  if ("assertScreenshot" in step) return "assertScreenshot";
+  if ("copyText" in step) return "copyText";
+  if ("waitForDownload" in step) return "waitForDownload";
+  return "step";
+}
+var RUNTIME_VAR_PATTERN = /\{\{([A-Z0-9_]+)\}\}/g;
+function substituteRuntimeVars(input, vars) {
+  return input.replace(RUNTIME_VAR_PATTERN, (match, name) => {
+    const value = vars.get(name);
+    return value !== void 0 ? value : match;
+  });
+}
+function applyRuntimeVars(step, vars) {
+  const sub = (s) => substituteRuntimeVars(s, vars);
+  if ("navigate" in step) return { navigate: sub(step.navigate) };
+  if ("click" in step) {
+    if (typeof step.click === "string") return { click: sub(step.click) };
+    return { click: { selector: sub(step.click.selector) } };
+  }
+  if ("fill" in step) {
+    if ("selector" in step.fill && "value" in step.fill) {
+      const f = step.fill;
+      return { fill: { selector: sub(f.selector), value: sub(f.value) } };
+    }
+    const [key, value] = Object.entries(step.fill)[0];
+    return { fill: { [sub(key)]: sub(value) } };
+  }
+  if ("type" in step) return { type: sub(step.type) };
+  if ("assert" in step) {
+    const a = step.assert;
+    if (a.visible !== void 0) return { assert: { visible: sub(a.visible) } };
+    if (a.notVisible !== void 0) return { assert: { notVisible: sub(a.notVisible) } };
+    if (a.urlIncludes !== void 0) return { assert: { urlIncludes: sub(a.urlIncludes) } };
+    if (a.urlEquals !== void 0) return { assert: { urlEquals: sub(a.urlEquals) } };
+    return step;
+  }
+  if ("wait" in step) {
+    if (typeof step.wait === "string") return { wait: sub(step.wait) };
+    return { wait: { for: sub(step.wait.for), timeout: step.wait.timeout } };
+  }
+  if ("waitForSelector" in step) {
+    return { waitForSelector: { selector: sub(step.waitForSelector.selector), timeout: step.waitForSelector.timeout } };
+  }
+  if ("evalScript" in step) {
+    if (typeof step.evalScript === "string") return { evalScript: sub(step.evalScript) };
+    return {
+      evalScript: {
+        expression: sub(step.evalScript.expression),
+        ...step.evalScript.as !== void 0 ? { as: step.evalScript.as } : {}
+      }
+    };
+  }
+  if ("assertScreenshot" in step) {
+    return {
+      assertScreenshot: {
+        name: sub(step.assertScreenshot.name),
+        ...step.assertScreenshot.threshold !== void 0 ? { threshold: step.assertScreenshot.threshold } : {}
+      }
+    };
+  }
+  if ("copyText" in step) {
+    return { copyText: { selector: sub(step.copyText.selector), as: step.copyText.as } };
+  }
+  if ("waitForDownload" in step) {
+    if (step.waitForDownload === null) return step;
+    return {
+      waitForDownload: {
+        ...step.waitForDownload.filename !== void 0 ? { filename: sub(step.waitForDownload.filename) } : {},
+        ...step.waitForDownload.timeout !== void 0 ? { timeout: step.waitForDownload.timeout } : {}
+      }
+    };
+  }
+  return step;
+}
+function isExplicitFillStep(value) {
+  return typeof value.selector === "string" && typeof value.value === "string";
+}
+function ensureAllowedUrl(urlValue, allowedDomains) {
+  for (const protocol of ALWAYS_ALLOWED_PROTOCOLS) {
+    if (urlValue.startsWith(protocol)) {
+      return;
+    }
+  }
+  const url = new URL(urlValue);
+  if (!allowedDomains.includes(url.hostname)) {
+    throw new Error(`Navigation to disallowed domain: ${url.hostname}`);
+  }
+}
+function resolveNavigationTarget(targetUrl, value) {
+  try {
+    return new URL(value, targetUrl).toString();
+  } catch {
+    return value;
+  }
+}
+function escapeForText(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function escapeForAttribute(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function exactTextSelector(text) {
+  return `text="${escapeForText(text)}"`;
+}
+function textContainsSelector(text) {
+  return `text=${escapeForText(text)}`;
+}
+function getSinglePair(value, stepType) {
+  const entries = Object.entries(value);
+  if (entries.length !== 1) {
+    throw new Error(`${stepType} shorthand expects exactly one key-value pair`);
+  }
+  return entries[0];
+}
+async function clickByTextWithFallback(page, text, forbiddenSelectors) {
+  const roleSelector = `role=button[name="${escapeForAttribute(text)}"]`;
+  assertAllowedSelector(roleSelector, forbiddenSelectors);
+  const button = page.getByRole("button", { name: text });
+  if (await button.count()) {
+    await button.first().click();
+    return roleSelector;
+  }
+  const selector = exactTextSelector(text);
+  assertAllowedSelector(selector, forbiddenSelectors);
+  await page.locator(selector).first().click();
+  return selector;
+}
+async function fillByLabelOrPlaceholder(page, label, value, forbiddenSelectors) {
+  const labelSelector = `label="${escapeForAttribute(label)}"`;
+  assertAllowedSelector(labelSelector, forbiddenSelectors);
+  const byLabel = page.getByLabel(label, { exact: true });
+  if (await byLabel.count()) {
+    await byLabel.first().fill(value);
+    return labelSelector;
+  }
+  const placeholder = `input[placeholder="${escapeForAttribute(label)}"], textarea[placeholder="${escapeForAttribute(label)}"]`;
+  assertAllowedSelector(placeholder, forbiddenSelectors);
+  const byPlaceholder = page.locator(placeholder);
+  if (await byPlaceholder.count()) {
+    await byPlaceholder.first().fill(value);
+    return placeholder;
+  }
+  throw new Error(`Could not resolve fill shorthand for "${label}"`);
+}
+async function selectByLabelOrFallback(page, label, value, forbiddenSelectors) {
+  const labelSelector = `label="${escapeForAttribute(label)}"`;
+  assertAllowedSelector(labelSelector, forbiddenSelectors);
+  const byLabel = page.getByLabel(label, { exact: true });
+  if (await byLabel.count()) {
+    await byLabel.first().selectOption(value);
+    return labelSelector;
+  }
+  const ariaSelector = `select[aria-label="${escapeForAttribute(label)}"]`;
+  assertAllowedSelector(ariaSelector, forbiddenSelectors);
+  const byAria = page.locator(ariaSelector);
+  if (await byAria.count()) {
+    await byAria.first().selectOption(value);
+    return ariaSelector;
+  }
+  const placeholderSelector = `select[placeholder="${escapeForAttribute(label)}"]`;
+  assertAllowedSelector(placeholderSelector, forbiddenSelectors);
+  const byPlaceholder = page.locator(placeholderSelector);
+  if (await byPlaceholder.count()) {
+    await byPlaceholder.first().selectOption(value);
+    return placeholderSelector;
+  }
+  throw new Error(`Could not resolve select shorthand for "${label}"`);
+}
+var SELECTOR_ENGINE_PREFIX = /^(?:css|xpath|text|id|role|data-testid)=/i;
+var HTML_TYPE_SELECTORS = /* @__PURE__ */ new Set([
+  "a",
+  "article",
+  "aside",
+  "body",
+  "button",
+  "canvas",
+  "dialog",
+  "div",
+  "fieldset",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "header",
+  "html",
+  "iframe",
+  "img",
+  "input",
+  "label",
+  "li",
+  "main",
+  "nav",
+  "ol",
+  "option",
+  "p",
+  "section",
+  "select",
+  "span",
+  "table",
+  "tbody",
+  "td",
+  "textarea",
+  "th",
+  "thead",
+  "tr",
+  "ul"
+]);
+function isKnownCssTypeSelector(value) {
+  return value === "*" || value.includes("-") || HTML_TYPE_SELECTORS.has(value.toLowerCase());
+}
+function readCssTypeSelector(value, start) {
+  const match = /^(?:[A-Za-z][\w-]*|\*)/.exec(value.slice(start));
+  if (!match) return null;
+  return { end: start + match[0].length, isKnown: isKnownCssTypeSelector(match[0]) };
+}
+function readCssStructuralSelectorPart(value, start) {
+  const rest = value.slice(start);
+  const classOrId = /^[.#][A-Za-z_][\w-]*/.exec(rest);
+  if (classOrId) return start + classOrId[0].length;
+  const attribute = /^\[[A-Za-z_][\w:-]*(?:\s*(?:[~|^$*]?=)\s*(?:"[^"]*"|'[^']*'|[^\]\s]+))?\]/.exec(rest);
+  if (attribute) return start + attribute[0].length;
+  return null;
+}
+function readCssCompoundSelector(value, start) {
+  let cursor = start;
+  const type = readCssTypeSelector(value, cursor);
+  if (type) {
+    cursor = type.end;
+  }
+  let hasStructuralPart = false;
+  for (; ; ) {
+    const next = readCssStructuralSelectorPart(value, cursor);
+    if (next === null) break;
+    hasStructuralPart = true;
+    cursor = next;
+  }
+  if (cursor === start) return null;
+  if (type && !type.isKnown) return null;
+  return { end: cursor, hasStructuralPart };
+}
+function readCssSelectorSeparator(value, start) {
+  let cursor = start;
+  let sawWhitespace = false;
+  while (/\s/.test(value[cursor] ?? "")) {
+    sawWhitespace = true;
+    cursor += 1;
+  }
+  if (/[>+~]/.test(value[cursor] ?? "")) {
+    cursor += 1;
+    while (/\s/.test(value[cursor] ?? "")) {
+      cursor += 1;
+    }
+    return cursor;
+  }
+  return sawWhitespace ? cursor : null;
+}
+function isCssSelectorSequence(value) {
+  const first = readCssCompoundSelector(value, 0);
+  if (!first) return false;
+  let cursor = first.end;
+  let sawSeparator = false;
+  let hasStructuralPart = first.hasStructuralPart;
+  while (cursor < value.length) {
+    const afterSeparator = readCssSelectorSeparator(value, cursor);
+    if (afterSeparator === null) return false;
+    const next = readCssCompoundSelector(value, afterSeparator);
+    if (!next) return false;
+    sawSeparator = true;
+    hasStructuralPart = hasStructuralPart || next.hasStructuralPart;
+    cursor = next.end;
+  }
+  return sawSeparator && hasStructuralPart;
+}
+function looksLikeSelector(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return false;
+  if (SELECTOR_ENGINE_PREFIX.test(trimmed) || trimmed.startsWith("//")) return true;
+  if (/^[.#]/.test(trimmed)) return true;
+  const compound = readCssCompoundSelector(trimmed, 0);
+  if (compound?.end === trimmed.length && compound.hasStructuralPart) return true;
+  if (isCssSelectorSequence(trimmed)) return true;
+  return false;
+}
+function toVisibilitySelector(value) {
+  if (looksLikeSelector(value)) return value;
+  return textContainsSelector(value);
+}
+async function runInlineAssert(page, assertion, forbiddenSelectors) {
+  if (assertion.visible !== void 0) {
+    const selector = toVisibilitySelector(assertion.visible);
+    assertAllowedSelector(selector, forbiddenSelectors);
+    const count = await page.locator(selector).count();
+    if (count === 0) {
+      throw new Error(`Expected visible: ${assertion.visible}`);
+    }
+    return `visible:${assertion.visible}`;
+  }
+  if (assertion.notVisible !== void 0) {
+    const selector = toVisibilitySelector(assertion.notVisible);
+    assertAllowedSelector(selector, forbiddenSelectors);
+    const count = await page.locator(selector).count();
+    if (count > 0) {
+      throw new Error(`Expected not visible: ${assertion.notVisible}`);
+    }
+    return `notVisible:${assertion.notVisible}`;
+  }
+  if (assertion.urlIncludes !== void 0) {
+    const current = page.url();
+    if (!current.includes(assertion.urlIncludes)) {
+      throw new Error(`URL did not include ${assertion.urlIncludes}`);
+    }
+    return `urlIncludes:${assertion.urlIncludes}`;
+  }
+  if (assertion.urlEquals !== void 0) {
+    const current = page.url();
+    if (current !== assertion.urlEquals) {
+      throw new Error(`URL did not equal ${assertion.urlEquals}`);
+    }
+    return `urlEquals:${assertion.urlEquals}`;
+  }
+  throw new Error("assert step is missing an assertion type");
+}
+function screenshotPath(screenshotsDir, fileName) {
+  return import_node_path4.default.join(screenshotsDir, fileName);
+}
+function stepPath(prefix, index) {
+  return prefix ? `${prefix}.${index}` : `${index}`;
+}
+function isWaitForDownloadStep(step) {
+  return step !== void 0 && "waitForDownload" in step;
+}
+function armDownloadListener(page, timeout) {
+  const downloadPromise = page.waitForEvent("download", { timeout });
+  void downloadPromise.catch(() => void 0);
+  return downloadPromise;
+}
+function validateDownloadFilename(suggestedFilename) {
+  const safeFilename = suggestedFilename.trim();
+  const allowedFilenamePattern = /^[^<>:"/\\|?*]+$/;
+  const hasControlCharacter = Array.from(safeFilename).some((char) => char.charCodeAt(0) < 32);
+  if (safeFilename.length === 0 || safeFilename !== suggestedFilename || safeFilename !== import_node_path4.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
+    throw new Error(`Invalid download filename: "${suggestedFilename}"`);
+  }
+  return safeFilename;
+}
+async function captureScreenshot(page, filePath) {
+  try {
+    await page.screenshot({ path: filePath, fullPage: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Screenshot failed";
+    throw new Error(`Failed to capture screenshot at ${filePath}: ${message}`);
+  }
+}
+async function executeNestedSteps(context, overrides) {
+  const nestedContext = {
+    ...context,
+    ...overrides,
+    pendingDownload: context.pendingDownload
+  };
+  const result = await executeSteps(nestedContext);
+  context.pendingDownload = nestedContext.pendingDownload;
+  if (nestedContext.randomVars !== void 0) {
+    context.randomVars = nestedContext.randomVars;
+  }
+  return result;
+}
+async function executeSteps(context) {
+  const screenshotsDir = import_node_path4.default.join(context.runDir, "screenshots");
+  import_node_fs4.default.mkdirSync(screenshotsDir, { recursive: true });
+  const currentHuntName = context.huntStack?.[context.huntStack.length - 1];
+  assertWithinMaxSteps(context.steps.length, context.maxSteps, currentHuntName);
+  const results = [];
+  const screenshots = [];
+  const runStartedAtMs = context.runStartedAtMs ?? Date.now();
+  context.runStartedAtMs = runStartedAtMs;
+  const addScreenshot = async (fileName) => {
+    const fullPath = screenshotPath(screenshotsDir, fileName);
+    await captureScreenshot(context.page, fullPath);
+    const relative = import_node_path4.default.join("screenshots", fileName);
+    screenshots.push(relative);
+    return relative;
+  };
+  for (let index = 0; index < context.steps.length; index += 1) {
+    const currentStepPath = stepPath(context.stepPathPrefix, index);
+    if (Date.now() - runStartedAtMs > context.maxTotalTimeMs) {
+      results.push({
+        type: "timeout",
+        status: "fail",
+        durationMs: 0,
+        error: `Max total time exceeded (${context.maxTotalTimeMs}ms)`
+      });
+      return { results, screenshots, failed: true, error: "Max total time exceeded" };
+    }
+    const runtimeVars = context.runtimeVars ?? /* @__PURE__ */ new Map();
+    context.runtimeVars = runtimeVars;
+    let step = context.steps[index];
+    if (runtimeVars.size > 0) {
+      step = applyRuntimeVars(step, runtimeVars);
+    }
+    const nextStep = context.steps[index + 1];
+    if (!isWaitForDownloadStep(step) && context.pendingDownload === void 0 && isWaitForDownloadStep(nextStep)) {
+      context.pendingDownload = armDownloadListener(
+        context.page,
+        nextStep.waitForDownload?.timeout ?? 3e4
+      );
+    }
+    const stepStart = Date.now();
+    const stepType = getStepType(step);
+    let stepResult = null;
+    try {
+      if ("navigate" in step) {
+        const destination = resolveNavigationTarget(context.targetUrl, step.navigate);
+        ensureAllowedUrl(destination, context.allowedDomains);
+        await context.page.goto(destination);
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = { type: "navigate", status: "pass", durationMs: Date.now() - stepStart };
+      } else if ("click" in step) {
+        let selector;
+        let healedFrom;
+        if (typeof step.click === "string") {
+          selector = await clickByTextWithFallback(
+            context.page,
+            step.click,
+            context.forbiddenSelectors
+          );
+        } else {
+          const resolved = await resolveActionSelector(context, step.click.selector);
+          await clickElement(context.page, resolved.selector);
+          selector = resolved.selector;
+          healedFrom = resolved.healedFrom;
+        }
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "click",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector,
+          ...healedFrom ? { healedFrom } : {}
+        };
+      } else if ("fill" in step) {
+        let selector;
+        let value;
+        let healedFrom;
+        if (isExplicitFillStep(step.fill)) {
+          const resolved = await resolveActionSelector(context, step.fill.selector);
+          await fillElement(context.page, resolved.selector, step.fill.value);
+          selector = resolved.selector;
+          healedFrom = resolved.healedFrom;
+          value = step.fill.value;
+        } else {
+          const [label, shorthandValue] = getSinglePair(step.fill, "fill");
+          selector = await fillByLabelOrPlaceholder(
+            context.page,
+            label,
+            shorthandValue,
+            context.forbiddenSelectors
+          );
+          value = shorthandValue;
+        }
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "fill",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector,
+          value: context.redactedFillSteps.has(currentStepPath) ? "[REDACTED]" : value,
+          ...healedFrom ? { healedFrom } : {}
+        };
+      } else if ("type" in step) {
+        assertAllowedSelector(":focus", context.forbiddenSelectors);
+        await fillElement(context.page, ":focus", step.type);
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "type",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: ":focus",
+          value: context.redactedFillSteps.has(currentStepPath) ? "[REDACTED]" : step.type
+        };
+      } else if ("selectOption" in step) {
+        const resolved = await resolveActionSelector(context, step.selectOption.selector);
+        await selectOption(context.page, resolved.selector, step.selectOption.value);
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "selectOption",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: resolved.selector,
+          value: step.selectOption.value,
+          ...resolved.healedFrom ? { healedFrom: resolved.healedFrom } : {}
+        };
+      } else if ("select" in step) {
+        const [label, value] = getSinglePair(step.select, "select");
+        const selector = await selectByLabelOrFallback(
+          context.page,
+          label,
+          value,
+          context.forbiddenSelectors
+        );
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "select",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector,
+          value
+        };
+      } else if ("onDialog" in step) {
+        setupDialogHandler(context.page, step.onDialog.action);
+        stepResult = {
+          type: "onDialog",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: step.onDialog.action
+        };
+      } else if ("setInputFiles" in step) {
+        const resolvedInput = await resolveActionSelector(context, step.setInputFiles.selector);
+        const rawFiles = step.setInputFiles.files;
+        const resolveFile = (f) => import_node_path4.default.isAbsolute(f) ? f : import_node_path4.default.join(context.configDir, f);
+        const resolvedFiles = Array.isArray(rawFiles) ? rawFiles.map(resolveFile) : resolveFile(rawFiles);
+        await setInputFiles(context.page, resolvedInput.selector, resolvedFiles);
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        const filesLabel = Array.isArray(rawFiles) ? rawFiles.join(", ") : rawFiles;
+        stepResult = {
+          type: "setInputFiles",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: resolvedInput.selector,
+          ...resolvedInput.healedFrom ? { healedFrom: resolvedInput.healedFrom } : {},
+          value: filesLabel
+        };
+      } else if ("runHunt" in step) {
+        const huntName = typeof step.runHunt === "string" ? step.runHunt : step.runHunt.name;
+        const overrideVars = typeof step.runHunt === "string" ? void 0 : step.runHunt.vars;
+        const stack = context.huntStack ?? [];
+        if (stack.includes(huntName)) {
+          throw new Error(`Circular hunt dependency: ${[...stack, huntName].join(" \u2192 ")}`);
+        }
+        const subHunt = loadHunt(huntName, context.configDir);
+        if (overrideVars) {
+          subHunt.vars = { ...subHunt.vars, ...overrideVars };
+        }
+        const {
+          hunt: interpolatedSubHunt,
+          redactedFillSteps: subRedacted,
+          randomVars
+        } = interpolateHunt(
+          subHunt,
+          process.env,
+          context.randomVars
+        );
+        assertWithinMaxSteps(interpolatedSubHunt.steps.length, context.maxSteps, huntName);
+        const subResult = await executeNestedSteps(context, {
+          steps: interpolatedSubHunt.steps,
+          redactedFillSteps: subRedacted,
+          randomVars,
+          stepPathPrefix: void 0,
+          huntStack: [...stack, huntName],
+          onStep: context.onStep
+        });
+        for (const sr of subResult.results) {
+          results.push({ ...sr, type: `${huntName} > ${sr.type}` });
+        }
+        screenshots.push(...subResult.screenshots);
+        if (subResult.failed) {
+          return {
+            results,
+            screenshots,
+            failed: true,
+            error: `Sub-hunt "${huntName}" failed: ${subResult.error}`
+          };
+        }
+        stepResult = {
+          type: "runHunt",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: huntName
+        };
+      } else if ("press" in step) {
+        const resolved = await resolveActionSelector(context, step.press.selector);
+        await pressKey(context.page, resolved.selector, step.press.key);
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "press",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: resolved.selector,
+          ...resolved.healedFrom ? { healedFrom: resolved.healedFrom } : {}
+        };
+      } else if ("assert" in step) {
+        const value = await runInlineAssert(context.page, step.assert, context.forbiddenSelectors);
+        stepResult = {
+          type: "assert",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value
+        };
+      } else if ("wait" in step) {
+        const text = typeof step.wait === "string" ? step.wait : step.wait.for;
+        const timeout = typeof step.wait === "string" ? void 0 : step.wait.timeout;
+        const selector = `text=${escapeForText(text)}`;
+        assertAllowedSelector(selector, context.forbiddenSelectors);
+        await context.page.waitForSelector(selector, { timeout });
+        stepResult = {
+          type: "wait",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector
+        };
+      } else if ("waitForSelector" in step) {
+        assertAllowedSelector(step.waitForSelector.selector, context.forbiddenSelectors);
+        await context.page.waitForSelector(step.waitForSelector.selector, {
+          timeout: step.waitForSelector.timeout
+        });
+        stepResult = {
+          type: "waitForSelector",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: step.waitForSelector.selector
+        };
+      } else if ("waitForUrl" in step) {
+        await context.page.waitForURL(
+          (url) => url.toString().includes(step.waitForUrl.value),
+          { timeout: step.waitForUrl.timeout }
+        );
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "waitForUrl",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: step.waitForUrl.value
+        };
+      } else if ("waitForNetworkIdle" in step) {
+        await context.page.waitForLoadState("networkidle", {
+          timeout: step.waitForNetworkIdle.timeout
+        });
+        stepResult = {
+          type: "waitForNetworkIdle",
+          status: "pass",
+          durationMs: Date.now() - stepStart
+        };
+      } else if ("hover" in step) {
+        const resolved = await resolveActionSelector(context, step.hover.selector);
+        await context.page.locator(resolved.selector).hover();
+        ensureAllowedUrl(context.page.url(), context.allowedDomains);
+        stepResult = {
+          type: "hover",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: resolved.selector,
+          ...resolved.healedFrom ? { healedFrom: resolved.healedFrom } : {}
+        };
+      } else if ("scroll" in step) {
+        const amount = step.scroll.amount ?? 500;
+        const scrollMap = {
+          up: [0, -amount],
+          down: [0, amount],
+          left: [-amount, 0],
+          right: [amount, 0]
+        };
+        const [x, y] = scrollMap[step.scroll.direction];
+        await context.page.evaluate(([sx, sy]) => window.scrollBy(sx, sy), [x, y]);
+        stepResult = {
+          type: "scroll",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: `${step.scroll.direction} ${amount}px`
+        };
+      } else if ("scrollTo" in step) {
+        const resolved = await resolveActionSelector(context, step.scrollTo.selector);
+        await context.page.locator(resolved.selector).scrollIntoViewIfNeeded();
+        stepResult = {
+          type: "scrollTo",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: resolved.selector,
+          ...resolved.healedFrom ? { healedFrom: resolved.healedFrom } : {}
+        };
+      } else if ("screenshot" in step) {
+        const name = step.screenshot.name ?? `manual_step_${index + 1}.png`;
+        if (/[/\\]|\.\./.test(name)) {
+          throw new Error(`Invalid screenshot name: "${name}" must not contain path separators or ".."`);
+        }
+        const fileName = name.endsWith(".png") ? name : `${name}.png`;
+        const relative = await addScreenshot(fileName);
+        stepResult = {
+          type: "screenshot",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          screenshot: relative
+        };
+      } else if ("if" in step) {
+        const condition = step.if;
+        const selector = condition.visible ?? condition.notVisible;
+        assertAllowedSelector(selector, context.forbiddenSelectors);
+        const count = await context.page.locator(selector).count();
+        const conditionMet = condition.visible !== void 0 ? count > 0 : count === 0;
+        if (conditionMet) {
+          const subResult = await executeNestedSteps(context, {
+            steps: condition.then,
+            stepPathPrefix: `${currentStepPath}.if.then`
+          });
+          for (const sr of subResult.results) {
+            results.push({ ...sr, type: `if > ${sr.type}` });
+          }
+          screenshots.push(...subResult.screenshots);
+          if (subResult.failed) {
+            return {
+              results,
+              screenshots,
+              failed: true,
+              error: subResult.error
+            };
+          }
+          stepResult = {
+            type: "if",
+            status: "pass",
+            durationMs: Date.now() - stepStart,
+            value: `condition met, executed ${condition.then.length} steps`
+          };
+        } else {
+          if (condition.else && condition.else.length > 0) {
+            const subResult = await executeNestedSteps(context, {
+              steps: condition.else,
+              stepPathPrefix: `${currentStepPath}.if.else`
+            });
+            for (const sr of subResult.results) {
+              results.push({ ...sr, type: `if > ${sr.type}` });
+            }
+            screenshots.push(...subResult.screenshots);
+            if (subResult.failed) {
+              return {
+                results,
+                screenshots,
+                failed: true,
+                error: subResult.error
+              };
+            }
+            stepResult = {
+              type: "if",
+              status: "pass",
+              durationMs: Date.now() - stepStart,
+              value: `condition not met, executed ${condition.else.length} else steps`
+            };
+          } else {
+            stepResult = {
+              type: "if",
+              status: "pass",
+              durationMs: Date.now() - stepStart,
+              value: "condition not met, skipped"
+            };
+          }
+        }
+      } else if ("repeat" in step) {
+        const repeat = step.repeat;
+        let totalSubSteps = 0;
+        if (repeat.times !== void 0) {
+          const totalPlanned = repeat.times * repeat.steps.length;
+          if (totalPlanned + totalSubSteps > context.maxSteps) {
+            throw new Error(`Repeat exceeded maxSteps guardrail (${context.maxSteps})`);
+          }
+          for (let i = 0; i < repeat.times; i++) {
+            totalSubSteps += repeat.steps.length;
+            const subResult = await executeNestedSteps(context, {
+              steps: repeat.steps,
+              stepPathPrefix: `${currentStepPath}.repeat.steps`
+            });
+            for (const sr of subResult.results) {
+              results.push({ ...sr, type: `repeat[${i}] > ${sr.type}` });
+            }
+            screenshots.push(...subResult.screenshots);
+            if (subResult.failed) {
+              return {
+                results,
+                screenshots,
+                failed: true,
+                error: subResult.error
+              };
+            }
+          }
+        } else if (repeat.while !== void 0) {
+          const maxIter = repeat.maxIterations;
+          const whileSelector = repeat.while.visible ?? repeat.while.notVisible;
+          assertAllowedSelector(whileSelector, context.forbiddenSelectors);
+          for (let i = 0; i < maxIter; i++) {
+            const whileCount = await context.page.locator(whileSelector).count();
+            const shouldContinue = repeat.while.visible !== void 0 ? whileCount > 0 : whileCount === 0;
+            if (!shouldContinue) break;
+            totalSubSteps += repeat.steps.length;
+            if (totalSubSteps > context.maxSteps) {
+              throw new Error(`Repeat exceeded maxSteps guardrail (${context.maxSteps})`);
+            }
+            const subResult = await executeNestedSteps(context, {
+              steps: repeat.steps,
+              stepPathPrefix: `${currentStepPath}.repeat.steps`
+            });
+            for (const sr of subResult.results) {
+              results.push({ ...sr, type: `repeat[${i}] > ${sr.type}` });
+            }
+            screenshots.push(...subResult.screenshots);
+            if (subResult.failed) {
+              return {
+                results,
+                screenshots,
+                failed: true,
+                error: subResult.error
+              };
+            }
+          }
+        }
+        stepResult = {
+          type: "repeat",
+          status: "pass",
+          durationMs: Date.now() - stepStart
+        };
+      } else if ("mockRoute" in step) {
+        const mock = step.mockRoute;
+        const mocks = context.activeMocks ?? /* @__PURE__ */ new Map();
+        context.activeMocks = mocks;
+        let responseBody;
+        if (mock.response.body !== void 0) {
+          responseBody = mock.response.body;
+        } else {
+          const responseFile = mock.response.file;
+          if (!responseFile) {
+            throw new Error("mock.response must include either body or file");
+          }
+          const candidateFilePath = import_node_path4.default.isAbsolute(responseFile) ? responseFile : import_node_path4.default.join(context.configDir, responseFile);
+          const resolvedConfigDir = import_node_path4.default.resolve(context.configDir);
+          const resolvedFilePath = import_node_path4.default.resolve(candidateFilePath);
+          const relativePath = import_node_path4.default.relative(resolvedConfigDir, resolvedFilePath);
+          const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${import_node_path4.default.sep}`) && !import_node_path4.default.isAbsolute(relativePath);
+          if (!isWithinConfigDir) {
+            throw new Error("mock.response.file must resolve within config directory");
+          }
+          responseBody = await import_node_fs4.default.promises.readFile(resolvedFilePath, "utf-8");
+        }
+        const contentType = mock.response.contentType ?? "application/json";
+        const status = mock.response.status;
+        await context.page.route(mock.url, (route) => {
+          route.fulfill({
+            status,
+            contentType,
+            body: responseBody
+          });
+        });
+        mocks.set(mock.url, async () => {
+          await context.page.unroute(mock.url);
+        });
+        stepResult = {
+          type: "mockRoute",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: mock.url
+        };
+      } else if ("unmockRoute" in step) {
+        const url = typeof step.unmockRoute === "string" ? step.unmockRoute : step.unmockRoute.url;
+        const mocks = context.activeMocks;
+        if (!mocks || !mocks.has(url)) {
+          throw new Error(`No active mock for URL: ${url}`);
+        }
+        const cleanup = mocks.get(url);
+        await cleanup();
+        mocks.delete(url);
+        stepResult = {
+          type: "unmockRoute",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: url
+        };
+      } else if ("evalScript" in step) {
+        const expression = typeof step.evalScript === "string" ? step.evalScript : step.evalScript.expression;
+        const result = await context.page.evaluate(expression);
+        const resultStr = String(result);
+        if (typeof step.evalScript !== "string" && step.evalScript.as) {
+          runtimeVars.set(step.evalScript.as, resultStr);
+        }
+        stepResult = {
+          type: "evalScript",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: resultStr.length > 200 ? resultStr.slice(0, 200) + "\u2026" : resultStr
+        };
+      } else if ("runScript" in step) {
+        const filePath = import_node_path4.default.isAbsolute(step.runScript.file) ? step.runScript.file : import_node_path4.default.join(context.configDir, step.runScript.file);
+        const fileContents = import_node_fs4.default.readFileSync(filePath, "utf-8");
+        await context.page.evaluate(fileContents);
+        stepResult = {
+          type: "runScript",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: step.runScript.file
+        };
+      } else if ("assertScreenshot" in step) {
+        const { compareScreenshots: compareScreenshots2, ensureBaselineDir: ensureBaselineDir2 } = await Promise.resolve().then(() => (init_visual(), visual_exports));
+        const name = step.assertScreenshot.name;
+        const threshold = step.assertScreenshot.threshold ?? 0.1;
+        const baselineDir = ensureBaselineDir2(context.configDir);
+        const baselinePath = import_node_path4.default.join(baselineDir, `${name}.png`);
+        const currentScreenshotPath = import_node_path4.default.join(context.runDir, "screenshots", `${name}-current.png`);
+        import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(currentScreenshotPath), { recursive: true });
+        await context.page.screenshot({ path: currentScreenshotPath, fullPage: true });
+        screenshots.push(import_node_path4.default.join("screenshots", `${name}-current.png`));
+        if (!import_node_fs4.default.existsSync(baselinePath)) {
+          import_node_fs4.default.copyFileSync(currentScreenshotPath, baselinePath);
+          stepResult = {
+            type: "assertScreenshot",
+            status: "pass",
+            durationMs: Date.now() - stepStart,
+            value: "baseline created"
+          };
+        } else {
+          const diffPath = import_node_path4.default.join(context.runDir, "screenshots", `${name}-diff.png`);
+          const comparison = await compareScreenshots2(baselinePath, currentScreenshotPath, diffPath, threshold);
+          if (comparison.match) {
+            stepResult = {
+              type: "assertScreenshot",
+              status: "pass",
+              durationMs: Date.now() - stepStart,
+              value: `diff: ${(comparison.diffPercentage * 100).toFixed(2)}%`
+            };
+          } else {
+            screenshots.push(import_node_path4.default.join("screenshots", `${name}-diff.png`));
+            throw new Error(
+              `Visual regression: ${(comparison.diffPercentage * 100).toFixed(2)}% diff exceeds threshold ${(threshold * 100).toFixed(0)}%`
+            );
+          }
+        }
+      } else if ("copyText" in step) {
+        assertAllowedSelector(step.copyText.selector, context.forbiddenSelectors);
+        const text = await context.page.locator(step.copyText.selector).textContent();
+        if (text === null) {
+          throw new Error(`No text content found for selector: ${step.copyText.selector}`);
+        }
+        runtimeVars.set(step.copyText.as, text);
+        stepResult = {
+          type: "copyText",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          selector: step.copyText.selector,
+          value: "[REDACTED]"
+        };
+      } else if ("waitForDownload" in step) {
+        const opts = step.waitForDownload;
+        const downloadPromise = context.pendingDownload ?? armDownloadListener(
+          context.page,
+          opts?.timeout ?? 3e4
+        );
+        context.pendingDownload = void 0;
+        const download = await downloadPromise;
+        const suggestedFilename = validateDownloadFilename(download.suggestedFilename());
+        if (opts?.filename !== void 0 && suggestedFilename !== opts.filename) {
+          throw new Error(
+            `Download filename mismatch: expected "${opts.filename}", got "${suggestedFilename}"`
+          );
+        }
+        const savePath = import_node_path4.default.join(context.runDir, suggestedFilename);
+        await download.saveAs(savePath);
+        stepResult = {
+          type: "waitForDownload",
+          status: "pass",
+          durationMs: Date.now() - stepStart,
+          value: suggestedFilename
+        };
+      }
+      if (!stepResult) {
+        throw new Error("Unknown step type");
+      }
+      if (context.screenshotsMode === "all" && stepResult.type !== "screenshot") {
+        const fileName = `step_${index + 1}.png`;
+        await addScreenshot(fileName);
+      }
+      results.push(stepResult);
+      context.onStep?.(stepResult, step, index);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Step failed";
+      stepResult = {
+        type: stepResult?.type ?? stepType,
+        status: "fail",
+        durationMs: Date.now() - stepStart,
+        error: message
+      };
+      if (context.screenshotsMode === "on-failure") {
+        const fileName = `failure_step_${index + 1}.png`;
+        await addScreenshot(fileName);
+      }
+      results.push(stepResult);
+      context.onStep?.(stepResult, step, index);
+      return { results, screenshots, failed: true, error: message };
+    }
+  }
+  return { results, screenshots, failed: false };
+}
+async function captureFinalScreenshot(page, runDir) {
+  const screenshotsDir = import_node_path4.default.join(runDir, "screenshots");
+  import_node_fs4.default.mkdirSync(screenshotsDir, { recursive: true });
+  const fileName = "final.png";
+  const filePath = screenshotPath(screenshotsDir, fileName);
+  await captureScreenshot(page, filePath);
+  return import_node_path4.default.join("screenshots", fileName);
+}
+
+// src/runner/assertions.ts
+function shouldIgnoreNetwork(url, patterns) {
+  return patterns.some((pattern) => url.includes(pattern));
+}
+function filterNetworkEntries(entries, patterns) {
+  if (patterns.length === 0) {
+    return entries;
+  }
+  return entries.filter((entry) => !shouldIgnoreNetwork(entry.url, patterns));
+}
+function mergeAssertions(config, huntAssertions = []) {
+  let noConsoleErrors = config.assertions.noConsoleErrors;
+  let noNetworkErrors = config.assertions.noNetworkErrors;
+  for (const assertion of huntAssertions) {
+    if ("noConsoleErrors" in assertion) {
+      noConsoleErrors = assertion.noConsoleErrors;
+    }
+    if ("noNetworkErrors" in assertion) {
+      noNetworkErrors = assertion.noNetworkErrors;
+    }
+  }
+  const merged = [];
+  if (noConsoleErrors) {
+    merged.push({ noConsoleErrors: true });
+  }
+  if (noNetworkErrors) {
+    merged.push({ noNetworkErrors: true });
+  }
+  for (const assertion of huntAssertions) {
+    if ("noConsoleErrors" in assertion || "noNetworkErrors" in assertion) {
+      continue;
+    }
+    merged.push(assertion);
+  }
+  return merged;
+}
+async function evaluateAssertions(options) {
+  const assertions = mergeAssertions(options.config, options.huntAssertions);
+  const results = [];
+  const networkEntries = filterNetworkEntries(
+    options.networkEntries,
+    options.config.assertions.networkIgnorePatterns
+  );
+  for (const assertion of assertions) {
+    try {
+      if ("selectorExists" in assertion) {
+        const count = await options.page.locator(assertion.selectorExists).count();
+        results.push({
+          type: "selectorExists",
+          value: assertion.selectorExists,
+          status: count > 0 ? "pass" : "fail",
+          error: count > 0 ? void 0 : "Selector not found"
+        });
+        continue;
+      }
+      if ("selectorNotExists" in assertion) {
+        const count = await options.page.locator(assertion.selectorNotExists).count();
+        results.push({
+          type: "selectorNotExists",
+          value: assertion.selectorNotExists,
+          status: count === 0 ? "pass" : "fail",
+          error: count === 0 ? void 0 : "Selector exists"
+        });
+        continue;
+      }
+      if ("urlIncludes" in assertion) {
+        const current = options.page.url();
+        const pass = current.includes(assertion.urlIncludes);
+        results.push({
+          type: "urlIncludes",
+          value: assertion.urlIncludes,
+          status: pass ? "pass" : "fail",
+          error: pass ? void 0 : `URL did not include ${assertion.urlIncludes}`
+        });
+        continue;
+      }
+      if ("urlEquals" in assertion) {
+        const current = options.page.url();
+        const pass = current === assertion.urlEquals;
+        results.push({
+          type: "urlEquals",
+          value: assertion.urlEquals,
+          status: pass ? "pass" : "fail",
+          error: pass ? void 0 : `URL did not equal ${assertion.urlEquals}`
+        });
+        continue;
+      }
+      if ("noConsoleErrors" in assertion) {
+        const errors = options.consoleEntries.filter((entry) => entry.type === "error");
+        const pass = errors.length === 0;
+        results.push({
+          type: "noConsoleErrors",
+          value: true,
+          status: pass ? "pass" : "fail",
+          error: pass ? void 0 : `${errors.length} console error(s)`
+        });
+        continue;
+      }
+      if ("noNetworkErrors" in assertion) {
+        const pass = networkEntries.length === 0;
+        results.push({
+          type: "noNetworkErrors",
+          value: true,
+          status: pass ? "pass" : "fail",
+          error: pass ? void 0 : `${networkEntries.length} network error(s)`
+        });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Assertion failed";
+      const type = Object.keys(assertion)[0] ?? "assertion";
+      results.push({
+        type,
+        status: "fail",
+        error: message
+      });
+    }
+  }
+  return results;
+}
+
+// src/runner/tracing.ts
+var DEFAULT_TRACE_HEADER = "traceparent";
+function parseTraceId(headerValue) {
+  const raw = headerValue.trim();
+  if (raw.length === 0) return void 0;
+  const parts = raw.split("-");
+  if (parts.length >= 3 && /^[0-9a-f]{32}$/i.test(parts[1])) {
+    return parts[1];
+  }
+  return raw;
+}
+function readHeader(headers, headerName) {
+  const normalizedName = headerName.toLowerCase();
+  return headers[normalizedName];
+}
+function redactValues(text, values) {
+  let redacted = text;
+  for (const value of values) {
+    if (value.length === 0) continue;
+    redacted = redacted.split(value).join("[REDACTED]");
+  }
+  return redacted;
+}
+function captureTraceCorrelation(response, headerName, sink, redactionValues = []) {
+  const value = readHeader(response.headers(), headerName);
+  if (!value) return;
+  const traceId = parseTraceId(value);
+  if (!traceId) return;
+  sink.push({
+    url: redactValues(response.url(), redactionValues),
+    status: response.status(),
+    traceId,
+    header: value
+  });
+}
+
+// src/reporter/result.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+function writeResult(runDir, result) {
+  const fileName = "result.json";
+  const fullPath = import_node_path5.default.join(runDir, fileName);
+  import_node_fs5.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
+  return fileName;
+}
+
+// src/reporter/summary.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+function escapeMd(text) {
+  return text.replace(/([|`*_{}[\]()#+\-!\\])/g, "\\$1");
+}
+function formatStep(step) {
+  const base = `- [${step.status.toUpperCase()}] ${step.type} (${step.durationMs}ms)`;
+  const selector = step.selector ? ` selector=${step.selector}` : "";
+  const healed = step.healedFrom ? ` healed-from=${escapeMd(step.healedFrom)}` : "";
+  const value = step.value ? ` value=${escapeMd(step.value)}` : "";
+  const error = step.error ? ` error=${escapeMd(step.error)}` : "";
+  return `${base}${selector}${healed}${value}${error}`;
+}
+function formatAssertion(assertion) {
+  const value = assertion.value !== void 0 ? ` value=${typeof assertion.value === "string" ? escapeMd(assertion.value) : assertion.value}` : "";
+  const error = assertion.error ? ` error=${escapeMd(assertion.error)}` : "";
+  return `- [${assertion.status.toUpperCase()}] ${assertion.type}${value}${error}`;
+}
+function writeSummary(runDir, result) {
+  const lines = [];
+  lines.push("# Prowl Run Summary");
+  lines.push("");
+  lines.push(`Status: ${result.status.toUpperCase()}`);
+  lines.push(`Hunt: ${result.hunt}`);
+  lines.push(`Target: ${result.targetUrl}`);
+  lines.push(`Started: ${result.startedAt}`);
+  lines.push(`Duration: ${result.durationMs}ms`);
+  lines.push("");
+  lines.push("## Steps");
+  for (const step of result.steps) {
+    lines.push(formatStep(step));
+  }
+  const healed = result.steps.filter((step) => step.healedFrom);
+  if (healed.length > 0) {
+    lines.push("");
+    lines.push("## Self-Healed Selectors");
+    lines.push("These selectors no longer matched and were auto-healed. Update your hunt to use the healed selector (or a stable `data-testid`):");
+    for (const step of healed) {
+      lines.push(`- ${escapeMd(step.healedFrom ?? "")} \u2192 ${escapeMd(step.selector ?? "")}`);
+    }
+  }
+  lines.push("");
+  lines.push("## Assertions");
+  for (const assertion of result.assertions) {
+    lines.push(formatAssertion(assertion));
+  }
+  if (result.traceCorrelations && result.traceCorrelations.length > 0) {
+    lines.push("");
+    lines.push("## Trace Correlations");
+    for (const correlation of result.traceCorrelations) {
+      lines.push(
+        `- [${correlation.status}] ${escapeMd(correlation.url)} traceId=${escapeMd(correlation.traceId)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push("## Artifacts");
+  const artifacts = result.artifacts;
+  if (artifacts.summary) {
+    lines.push(`- summary: ${artifacts.summary}`);
+  }
+  if (artifacts.console) {
+    lines.push(`- console: ${artifacts.console}`);
+  }
+  if (artifacts.trace) {
+    lines.push(`- trace: ${artifacts.trace}`);
+  }
+  if (artifacts.networkHar) {
+    lines.push(`- network: ${artifacts.networkHar}`);
+  }
+  if (artifacts.junit) {
+    lines.push(`- junit: ${artifacts.junit}`);
+  }
+  if (artifacts.screenshots && artifacts.screenshots.length > 0) {
+    for (const screenshot of artifacts.screenshots) {
+      lines.push(`- screenshot: ${screenshot}`);
+    }
+  }
+  const fileName = "summary.md";
+  const fullPath = import_node_path6.default.join(runDir, fileName);
+  import_node_fs6.default.writeFileSync(fullPath, `${lines.join("\n")}
+`);
+  return fileName;
+}
+
+// src/reporter/junit.ts
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function writeJunit(runDir, result) {
+  const totalTests = result.steps.length + result.assertions.length;
+  const failures = result.steps.filter((s) => s.status === "fail").length + result.assertions.filter((a) => a.status === "fail").length;
+  const timeSeconds = (result.durationMs / 1e3).toFixed(3);
+  const huntName = escapeXml(result.hunt);
+  const lines = [];
+  lines.push('<?xml version="1.0" encoding="UTF-8"?>');
+  lines.push("<testsuites>");
+  lines.push(
+    `  <testsuite name="${huntName}" tests="${totalTests}" failures="${failures}" errors="0" time="${timeSeconds}" timestamp="${escapeXml(result.startedAt)}">`
+  );
+  for (let i = 0; i < result.steps.length; i++) {
+    const step = result.steps[i];
+    const stepTime = (step.durationMs / 1e3).toFixed(3);
+    const caseName = escapeXml(`step ${i + 1}: ${step.type}`);
+    if (step.status === "fail") {
+      const failureText = step.error ?? `Step ${step.type} failed with no error provided`;
+      const escapedFailureText = escapeXml(failureText);
+      lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="${stepTime}">`);
+      lines.push(`      <failure message="${escapedFailureText}" type="step">${escapedFailureText}</failure>`);
+      lines.push("    </testcase>");
+    } else {
+      lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="${stepTime}"/>`);
+    }
+  }
+  for (const assertion of result.assertions) {
+    const caseName = escapeXml(`assertion: ${assertion.type}`);
+    if (assertion.status === "fail") {
+      const failureText = assertion.error ?? `Assertion ${assertion.type} failed with no error provided`;
+      const escapedFailureText = escapeXml(failureText);
+      lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="0">`);
+      lines.push(`      <failure message="${escapedFailureText}" type="assertion">${escapedFailureText}</failure>`);
+      lines.push("    </testcase>");
+    } else {
+      lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="0"/>`);
+    }
+  }
+  lines.push("  </testsuite>");
+  lines.push("</testsuites>");
+  const fileName = "junit.xml";
+  const fullPath = import_node_path7.default.join(runDir, fileName);
+  import_node_fs7.default.writeFileSync(fullPath, `${lines.join("\n")}
+`);
+  return fileName;
+}
+
+// src/reporter/index.ts
+function writeReports(runDir, result, options) {
+  const summary = writeSummary(runDir, result);
+  const updated = {
+    ...result,
+    artifacts: {
+      ...result.artifacts,
+      summary
+    }
+  };
+  if (options?.junit) {
+    updated.artifacts.junit = writeJunit(runDir, updated);
+  }
+  writeResult(runDir, updated);
+  return updated;
+}
+
+// src/utils/timestamp.ts
+function timestamp(prefix) {
+  const now = /* @__PURE__ */ new Date();
+  const pad = (value) => value.toString().padStart(2, "0");
+  const pad3 = (value) => value.toString().padStart(3, "0");
+  const ts = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(
+    now.getHours()
+  )}-${pad(now.getMinutes())}-${pad(now.getSeconds())}-${pad3(now.getMilliseconds())}`;
+  return prefix ? `${prefix}-${ts}` : ts;
+}
+
+// src/runner/history.ts
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+var HISTORY_FILE = "history.json";
+var LOCK_FILE_SUFFIX = ".lock";
+var LOCK_RETRY_MS = 10;
+var LOCK_TIMEOUT_MS = 5e3;
+var SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
+function historyPath(configDir) {
+  return import_node_path8.default.join(configDir, HISTORY_FILE);
+}
+function isHistoryEntry(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const entry = value;
+  return typeof entry.hunt === "string" && (entry.status === "pass" || entry.status === "fail") && typeof entry.durationMs === "number" && Number.isFinite(entry.durationMs) && typeof entry.startedAt === "string" && (entry.runDir === void 0 || typeof entry.runDir === "string");
+}
+function readHistory(configDir) {
+  const filePath = historyPath(configDir);
+  if (!import_node_fs8.default.existsSync(filePath)) {
+    return { entries: [] };
+  }
+  try {
+    const raw = import_node_fs8.default.readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && "entries" in parsed && Array.isArray(parsed.entries)) {
+      const validatedEntries = parsed.entries.filter(isHistoryEntry);
+      return { entries: validatedEntries };
+    }
+    return { entries: [] };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to read history file at ${filePath}: ${message}`);
+    return { entries: [] };
+  }
+}
+function readHuntHistory(configDir, huntName) {
+  const { entries } = readHistory(configDir);
+  return entries.filter((entry) => entry.hunt === huntName);
+}
+function pruneEntries(entries, maxRuns) {
+  const perHunt = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list = perHunt.get(entry.hunt) ?? [];
+    list.push(entry);
+    perHunt.set(entry.hunt, list);
+  }
+  const keptEntries = /* @__PURE__ */ new Set();
+  for (const list of perHunt.values()) {
+    const kept = list.length > maxRuns ? list.slice(list.length - maxRuns) : list;
+    for (const entry of kept) {
+      keptEntries.add(entry);
+    }
+  }
+  return entries.filter((entry) => keptEntries.has(entry));
+}
+function sleepSync(ms) {
+  Atomics.wait(SLEEP_BUFFER, 0, 0, ms);
+}
+function withHistoryLock(configDir, fn) {
+  const filePath = historyPath(configDir);
+  const lockPath = `${filePath}${LOCK_FILE_SUFFIX}`;
+  import_node_fs8.default.mkdirSync(import_node_path8.default.dirname(filePath), { recursive: true });
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
+    let fd;
+    try {
+      fd = import_node_fs8.default.openSync(lockPath, "wx");
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        sleepSync(LOCK_RETRY_MS);
+        continue;
+      }
+      throw error;
+    }
+    try {
+      return fn();
+    } finally {
+      try {
+        import_node_fs8.default.closeSync(fd);
+      } catch {
+      }
+      import_node_fs8.default.rmSync(lockPath, { force: true });
+    }
+  }
+  throw new Error(
+    `Failed to acquire history lock before timeout (${LOCK_TIMEOUT_MS}ms): ${lockPath}; started waiting at ${new Date(startedAt).toISOString()}`
+  );
+}
+function appendEntry(configDir, entry, maxRuns) {
+  const filePath = historyPath(configDir);
+  withHistoryLock(configDir, () => {
+    const current = readHistory(configDir);
+    const next = pruneEntries([...current.entries, entry], maxRuns);
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    import_node_fs8.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
+`);
+    import_node_fs8.default.renameSync(tempPath, filePath);
+  });
+}
+
+// src/runner/index.ts
+function parseViewportFlag(value) {
+  const match = /^(\d+)x(\d+)$/i.exec(value);
+  if (match) {
+    return { width: Number(match[1]), height: Number(match[2]) };
+  }
+  return value;
+}
+function resolvePath(configDir, inputPath) {
+  if (import_node_path9.default.isAbsolute(inputPath)) {
+    return inputPath;
+  }
+  const projectRoot = import_node_path9.default.dirname(configDir);
+  return import_node_path9.default.join(projectRoot, inputPath);
+}
+function buildRunResult(options) {
+  return {
+    status: options.status,
+    exitCode: options.status === "pass" ? 0 : 1,
+    startedAt: options.startedAt,
+    durationMs: options.durationMs,
+    hunt: options.hunt,
+    targetUrl: options.targetUrl,
+    steps: options.steps,
+    assertions: options.assertions,
+    artifacts: options.artifacts,
+    // Omit entirely when there are no correlations, so passing/clean runs stay tidy.
+    ...options.traceCorrelations && options.traceCorrelations.length > 0 ? { traceCorrelations: options.traceCorrelations } : {}
+  };
+}
+function writeConsoleLog(runDir, entries) {
+  const fileName = "console.log";
+  const filePath = import_node_path9.default.join(runDir, fileName);
+  const lines = entries.map((entry) => {
+    const location = entry.location ? ` (${entry.location})` : "";
+    return `[${entry.type}] ${entry.text}${location}`;
+  });
+  import_node_fs9.default.writeFileSync(filePath, `${lines.join("\n")}
+`);
+  return fileName;
+}
+async function executeHuntAttempt(options, config, configDir, interpolatedHunt, redactedFillSteps, randomVars, redactionValues, targetUrl, allowedDomains) {
+  const headless = options.headed ? false : config.browser.headless;
+  const slowMo = options.slowMo ?? config.browser.slowMo;
+  const maxSteps = config.guardrails.maxSteps;
+  const runDir = import_node_path9.default.join(configDir, "runs", timestamp());
+  import_node_fs9.default.mkdirSync(runDir, { recursive: true });
+  const storageStatePath = config.auth.storageStatePath ? resolvePath(configDir, config.auth.storageStatePath) : void 0;
+  const engine = options.browser ?? config.browser.engine;
+  const channel = options.channel ?? config.browser.channel;
+  const viewport = options.viewport ? resolveViewport(parseViewportFlag(options.viewport)) : config.browser.viewport;
+  const session = await launchBrowser({
+    headless,
+    slowMo,
+    timeout: config.browser.timeout,
+    storageStatePath,
+    trace: Boolean(options.trace),
+    recordHar: config.artifacts.networkHar,
+    runDir,
+    engine,
+    channel,
+    viewport
+  });
+  let result;
+  try {
+    const consoleEntries = [];
+    const networkEntries = [];
+    const traceCorrelations = [];
+    const traceHeader = config.tracing?.header ?? DEFAULT_TRACE_HEADER;
+    session.page.on("console", (message) => {
+      consoleEntries.push({
+        type: message.type(),
+        text: message.text(),
+        location: message.location().url
+      });
+    });
+    session.page.on("response", (response) => {
+      if (response.status() >= 400) {
+        networkEntries.push({ url: response.url(), status: response.status() });
+        captureTraceCorrelation(response, traceHeader, traceCorrelations, redactionValues);
+      }
+    });
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    let stepResults = [];
+    let stepScreenshots = [];
+    let stepFailed = false;
+    try {
+      const stepExecution = await executeSteps({
+        page: session.page,
+        steps: interpolatedHunt.steps,
+        targetUrl,
+        runDir,
+        screenshotsMode: config.artifacts.screenshots,
+        forbiddenSelectors: config.guardrails.forbiddenSelectors,
+        allowedDomains,
+        maxSteps,
+        maxTotalTimeMs: config.assertions.maxTotalTimeMs,
+        selfHealing: config.guardrails.selfHealing,
+        redactedFillSteps,
+        randomVars,
+        configDir,
+        huntStack: [options.huntName],
+        onStep: options.onStep
+      });
+      stepResults = stepExecution.results;
+      stepScreenshots = stepExecution.screenshots;
+      stepFailed = stepExecution.failed;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Step execution failed";
+      stepResults = [
+        {
+          type: "steps",
+          status: "fail",
+          durationMs: 0,
+          error: message
+        }
+      ];
+      stepFailed = true;
+    }
+    let finalScreenshot;
+    try {
+      finalScreenshot = await captureFinalScreenshot(session.page, runDir);
+    } catch {
+      finalScreenshot = void 0;
+    }
+    const assertionResults = await evaluateAssertions({
+      page: session.page,
+      config,
+      huntAssertions: interpolatedHunt.assertions,
+      consoleEntries,
+      networkEntries
+    });
+    const durationMs = Date.now() - startTime;
+    const assertionsFailed = assertionResults.some((assertion) => assertion.status === "fail");
+    const status = stepFailed || assertionsFailed ? "fail" : "pass";
+    const artifacts = {
+      screenshots: finalScreenshot ? [...stepScreenshots, finalScreenshot] : stepScreenshots,
+      trace: session.tracePath ? "trace.zip" : void 0,
+      networkHar: config.artifacts.networkHar ? "network.har" : void 0
+    };
+    if (config.artifacts.console) {
+      artifacts.console = writeConsoleLog(runDir, consoleEntries);
+    }
+    const runResult = buildRunResult({
+      status,
+      startedAt,
+      durationMs,
+      hunt: options.huntName,
+      targetUrl,
+      steps: stepResults,
+      assertions: assertionResults,
+      artifacts,
+      traceCorrelations
+    });
+    result = writeReports(runDir, runResult, { junit: options.junit ?? config.artifacts.junit });
+  } finally {
+    await closeBrowser(session);
+  }
+  return { result, runDir, steps: interpolatedHunt.steps };
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function runHunt(options) {
+  const { config, configDir } = loadConfig(options.configPath);
+  const hunt = loadHunt(options.huntName, configDir);
+  const {
+    hunt: interpolatedHunt,
+    redactedFillSteps,
+    randomVars,
+    redactionValues = []
+  } = interpolateHunt(
+    hunt,
+    process.env
+  );
+  const targetUrl = options.urlOverride ?? config.target.url;
+  const allowedDomains = ensureAllowedDomain([...config.guardrails.allowedDomains], targetUrl);
+  const maxSteps = config.guardrails.maxSteps;
+  if (interpolatedHunt.steps.length > maxSteps) {
+    throw new Error(`Hunt has ${interpolatedHunt.steps.length} steps. Max allowed is ${maxSteps}.`);
+  }
+  const maxRetries = hunt.retry?.maxRetries ?? 0;
+  const retryDelay = hunt.retry?.delay ?? 0;
+  let lastResult;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (attempt > 0 && retryDelay > 0) {
+      await delay(retryDelay);
+    }
+    lastResult = await executeHuntAttempt(
+      options,
+      config,
+      configDir,
+      interpolatedHunt,
+      redactedFillSteps,
+      randomVars,
+      redactionValues,
+      targetUrl,
+      allowedDomains
+    );
+    if (lastResult.result.status === "pass") {
+      if (attempt > 0) {
+        lastResult.result.artifacts.summary = `Passed on attempt ${attempt + 1} of ${maxRetries + 1}`;
+      }
+      recordHistory(configDir, lastResult, config.history.maxRuns);
+      return lastResult;
+    }
+  }
+  if (maxRetries > 0 && lastResult) {
+    lastResult.result.artifacts.summary = `Failed after ${maxRetries + 1} attempts`;
+  }
+  if (lastResult) {
+    recordHistory(configDir, lastResult, config.history.maxRuns);
+  }
+  return lastResult;
+}
+function recordHistory(configDir, outcome, maxRuns) {
+  try {
+    const relativeRunDir = import_node_path9.default.relative(configDir, outcome.runDir);
+    appendEntry(
+      configDir,
+      {
+        hunt: outcome.result.hunt,
+        status: outcome.result.status,
+        durationMs: outcome.result.durationMs,
+        startedAt: outcome.result.startedAt,
+        runDir: relativeRunDir || void 0
+      },
+      maxRuns
+    );
+  } catch {
+  }
+}
+
+// src/runner/suite.ts
+var import_node_path12 = __toESM(require("path"), 1);
+
+// src/reporter/ci-summary.ts
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
+function countCiResults(results) {
+  return {
+    passed: results.filter((r) => r.status === "pass").length,
+    failed: results.filter((r) => r.status === "fail").length,
+    skipped: results.filter((r) => r.status === "skipped").length
+  };
+}
+function resolveCiStatus(results) {
+  if (results.length === 0) return "no-hunts";
+  const { failed, passed } = countCiResults(results);
+  if (failed > 0) return "fail";
+  if (passed > 0) return "pass";
+  return "all-skipped";
+}
+function writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky = [], clusters = []) {
+  const { passed, failed, skipped } = countCiResults(results);
+  const ciResult = {
+    status: resolveCiStatus(results),
+    startedAt,
+    durationMs: totalDurationMs,
+    totalHunts: results.length,
+    passed,
+    failed,
+    skipped,
+    hunts: results,
+    ...flaky.length > 0 ? { flaky } : {},
+    ...clusters.length > 0 ? { clusters } : {}
+  };
+  import_node_fs10.default.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = import_node_path10.default.join(ciRunDir, "ci-result.json");
+  import_node_fs10.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
+  return filePath;
+}
+
+// src/utils/concurrency.ts
+async function runWithConcurrency(tasks, concurrency) {
+  const normalizedConcurrency = Number.isFinite(concurrency) && concurrency > 0 ? Math.floor(concurrency) : 1;
+  const results = new Array(tasks.length);
+  let nextIndex = 0;
+  async function worker() {
+    while (nextIndex < tasks.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      try {
+        const value = await tasks[index]();
+        results[index] = { status: "fulfilled", value };
+      } catch (reason) {
+        results[index] = { status: "rejected", reason };
+      }
+    }
+  }
+  const workers = Array.from(
+    { length: Math.min(normalizedConcurrency, tasks.length) },
+    () => worker()
+  );
+  await Promise.all(workers);
+  return results;
+}
+
+// src/runner/flaky.ts
+var DEFAULT_FLAKY_THRESHOLD = 0.3;
+function computeFlakeScore(entries, lastN) {
+  const slice = lastN !== void 0 && lastN > 0 ? entries.slice(-lastN) : entries;
+  if (slice.length < 2) return 0;
+  let transitions = 0;
+  for (let i = 1; i < slice.length; i++) {
+    if (slice[i].status !== slice[i - 1].status) {
+      transitions += 1;
+    }
+  }
+  return transitions / (slice.length - 1);
+}
+function rankFlaky(configDir, options = {}) {
+  const threshold = options.threshold ?? DEFAULT_FLAKY_THRESHOLD;
+  const { entries } = readHistory(configDir);
+  const byHunt = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const list = byHunt.get(entry.hunt) ?? [];
+    list.push(entry);
+    byHunt.set(entry.hunt, list);
+  }
+  const scores = [];
+  for (const [hunt, huntEntries] of byHunt) {
+    const considered = options.lastN !== void 0 && options.lastN > 0 ? huntEntries.slice(-options.lastN) : huntEntries;
+    const score = computeFlakeScore(considered);
+    scores.push({
+      hunt,
+      score,
+      runs: considered.length,
+      flaky: score >= threshold
+    });
+  }
+  scores.sort((a, b) => b.score - a.score || b.runs - a.runs || a.hunt.localeCompare(b.hunt));
+  return scores;
+}
+
+// src/backlog/fingerprint.ts
+var import_node_crypto2 = require("crypto");
+function normalizeError(error) {
+  return error.toLowerCase().replace(/0x[0-9a-f]+/g, "").replace(/\b\d+(?:\.\d+)?\s*(?:ms|s|px)\b/g, "").replace(/\s+/g, " ").trim();
+}
+function stepLabel(failure) {
+  if (failure.stepType === void 0 && failure.selector === void 0) {
+    return "-";
+  }
+  const index = failure.stepIndex === void 0 ? "?" : String(failure.stepIndex);
+  const type = failure.stepType ?? "?";
+  const selector = failure.selector ? `@${failure.selector}` : "";
+  return `${index}:${type}${selector}`;
+}
+function sanitizeMarkerValue(value) {
+  return value.replace(/\r?\n/g, " ").replace(/-->/g, "--&gt;").trim();
+}
+function computeFingerprint(failure) {
+  const parts = [
+    failure.hunt,
+    failure.stepType ?? "",
+    failure.selector ?? "",
+    normalizeError(failure.error)
+  ];
+  return (0, import_node_crypto2.createHash)("sha1").update(parts.join("|")).digest("hex").slice(0, 8);
+}
+function buildMarker(failure, hash) {
+  const hunt = sanitizeMarkerValue(failure.hunt);
+  const step = sanitizeMarkerValue(stepLabel(failure));
+  return `<!-- prowl:fp=${hash} hunt=${hunt} step=${step} -->`;
+}
+
+// src/runner/clustering.ts
+function clusterKey(failure, normalizedError) {
+  return [failure.stepType ?? "", failure.selector ?? "", normalizedError].join("|");
+}
+function describeCause(failure, error) {
+  const where = failure.stepType ? `${failure.stepType}${failure.selector ? ` (${failure.selector})` : ""}` : "run";
+  return `${where}: ${error}`;
+}
+function clusterFailures(failures) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const failure of failures) {
+    const error = normalizeError(failure.error);
+    const key = clusterKey(failure, error);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.hunts.add(failure.hunt);
+    } else {
+      groups.set(key, { sample: failure, error, hunts: /* @__PURE__ */ new Set([failure.hunt]) });
+    }
+  }
+  const clusters = [];
+  for (const { sample, error, hunts } of groups.values()) {
+    clusters.push({
+      cause: describeCause(sample, error),
+      stepType: sample.stepType,
+      selector: sample.selector,
+      error,
+      count: hunts.size,
+      hunts: [...hunts].sort()
+    });
+  }
+  clusters.sort((a, b) => b.count - a.count || a.cause.localeCompare(b.cause));
+  return clusters;
+}
+
+// src/backlog/index.ts
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+
+// src/backlog/parse.ts
+var MARKER_FP = /<!--\s*prowl:fp=([0-9a-f]+)/;
+var TICKET_ID = /\bQA-(\d+)\b/;
+var TICKET_ID_GLOBAL = /\bQA-(\d+)\b/g;
+var HEADING = /^#{1,6}\s/;
+function extractFingerprints(content) {
+  const map = /* @__PURE__ */ new Map();
+  let currentId;
+  for (const line of content.split("\n")) {
+    if (HEADING.test(line)) {
+      const idMatch = TICKET_ID.exec(line);
+      currentId = idMatch ? `QA-${idMatch[1]}` : void 0;
+    }
+    const fpMatch = MARKER_FP.exec(line);
+    if (fpMatch && currentId) {
+      map.set(fpMatch[1], currentId);
+    }
+  }
+  return map;
+}
+function nextTicketId(contents) {
+  let max = 0;
+  for (const content of contents) {
+    for (const match of content.matchAll(TICKET_ID_GLOBAL)) {
+      const n = Number(match[1]);
+      if (n > max) max = n;
+    }
+  }
+  return `QA-${String(max + 1).padStart(3, "0")}`;
+}
+function classifyFingerprint(fp, activeFps, resolvedFps) {
+  const openId = activeFps.get(fp);
+  if (openId) return { kind: "open", ticketId: openId };
+  const resolvedId = resolvedFps.get(fp);
+  if (resolvedId) return { kind: "regression", resolvedId };
+  return { kind: "new" };
+}
+
+// src/backlog/write.ts
+var SECTION_HEADING = "## QA Findings (automated)";
+function renderTicket(opts) {
+  const { id, failure, marker, regressionOf, date } = opts;
+  const spot = failure.stepType ? `${failure.stepType}${failure.selector ? ` (${failure.selector})` : ""}` : "run failed before steps executed";
+  const lines = [];
+  lines.push(`### ${id}: ${failure.hunt} \u2014 ${spot}`);
+  lines.push(marker);
+  lines.push(`**Logged**: ${date}`);
+  if (regressionOf) {
+    lines.push(`**Regression of**: ${regressionOf} (previously resolved \u2014 see resolved.md)`);
+  }
+  lines.push(`**Hunt**: ${failure.hunt}`);
+  const stepDesc = failure.stepType ? `step ${failure.stepIndex ?? "?"} \u2014 ${failure.stepType}${failure.selector ? ` ${failure.selector}` : ""}` : "n/a (hunt did not produce step results)";
+  lines.push(`**Failing step**: ${stepDesc}`);
+  lines.push(`**Error**: ${failure.error}`);
+  if (failure.runDir) {
+    lines.push(`**Artifacts**: ${failure.runDir}`);
+  }
+  return lines.join("\n");
+}
+function insertTickets(content, tickets) {
+  if (tickets.length === 0) return content;
+  const block = tickets.join("\n\n");
+  const headingIndex = content.indexOf(SECTION_HEADING);
+  if (headingIndex === -1) {
+    const base = content.replace(/\n*$/, "");
+    const prefix = base ? `${base}
+
+` : "";
+    return `${prefix}${SECTION_HEADING}
+
+${block}
+`;
+  }
+  const afterHeading = headingIndex + SECTION_HEADING.length;
+  const rest = content.slice(afterHeading);
+  const nextHeadingRel = rest.search(/\n## /);
+  const insertAt = nextHeadingRel === -1 ? content.length : afterHeading + nextHeadingRel;
+  const before = content.slice(0, insertAt).replace(/\n*$/, "");
+  const after = content.slice(insertAt);
+  return `${before}
+
+${block}
+${after}`;
+}
+
+// src/backlog/index.ts
+function readFileOrEmpty(filePath) {
+  try {
+    return import_node_fs11.default.readFileSync(filePath, "utf-8");
+  } catch (error) {
+    const err = error;
+    if (err.code === "ENOENT") return "";
+    throw new Error(`Failed to read "${filePath}": ${err.message}`);
+  }
+}
+function buildFailure(hunt) {
+  const failure = {
+    hunt: hunt.hunt,
+    error: hunt.error ?? "Run failed",
+    runDir: hunt.runDir
+  };
+  if (!hunt.runDir) return failure;
+  let run;
+  try {
+    const resultJson = readFileOrEmpty(import_node_path11.default.join(hunt.runDir, "result.json"));
+    if (!resultJson) return failure;
+    run = JSON.parse(resultJson);
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    return failure;
+  }
+  if (!run || !Array.isArray(run.steps)) return failure;
+  const stepIndex = run.steps.findIndex((step) => step.status === "fail");
+  if (stepIndex !== -1) {
+    const step = run.steps[stepIndex];
+    failure.stepIndex = stepIndex;
+    failure.stepType = step.type;
+    failure.selector = step.selector;
+    if (step.error) failure.error = step.error;
+    return failure;
+  }
+  const failedAssertion = run.assertions?.find((assertion) => assertion.status === "fail");
+  if (failedAssertion) {
+    failure.stepType = `assert:${failedAssertion.type}`;
+    if (failedAssertion.error) failure.error = failedAssertion.error;
+  }
+  return failure;
+}
+function extractFailures(suiteResult) {
+  return suiteResult.result.hunts.filter((hunt) => hunt.status === "fail").map(buildFailure);
+}
+function updateBacklogFromSuite(suiteResult, options = {}) {
+  const projectRoot = options.projectRoot ?? process.cwd();
+  const backlogPath = options.backlogPath ?? import_node_path11.default.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? import_node_path11.default.join(projectRoot, "docs", "resolved.md");
+  const date = options.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const summary = { created: [], regressions: [], skipped: [], backlogPath };
+  const failures = extractFailures(suiteResult);
+  if (failures.length === 0) return summary;
+  const backlogContent = readFileOrEmpty(backlogPath);
+  const resolvedContent = readFileOrEmpty(resolvedPath);
+  const activeFps = extractFingerprints(backlogContent);
+  const resolvedFps = extractFingerprints(resolvedContent);
+  let counter = Number(nextTicketId([backlogContent, resolvedContent]).slice(3));
+  const makeId = () => `QA-${String(counter++).padStart(3, "0")}`;
+  const seenThisRun = /* @__PURE__ */ new Set();
+  const ticketsToAdd = [];
+  for (const failure of failures) {
+    const fp = computeFingerprint(failure);
+    if (seenThisRun.has(fp)) continue;
+    seenThisRun.add(fp);
+    const classification = classifyFingerprint(fp, activeFps, resolvedFps);
+    if (classification.kind === "open") {
+      summary.skipped.push(classification.ticketId);
+      continue;
+    }
+    const id = makeId();
+    const regressionOf = classification.kind === "regression" ? classification.resolvedId : void 0;
+    ticketsToAdd.push(renderTicket({ id, failure, marker: buildMarker(failure, fp), regressionOf, date }));
+    if (regressionOf) {
+      summary.regressions.push(id);
+    } else {
+      summary.created.push(id);
+    }
+  }
+  if (ticketsToAdd.length > 0) {
+    import_node_fs11.default.mkdirSync(import_node_path11.default.dirname(backlogPath), { recursive: true });
+    import_node_fs11.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+  }
+  return summary;
+}
+
+// src/runner/suite.ts
+function normalizeTagFilter(tags) {
+  const normalized = tags?.map((tag) => tag.trim()).filter(Boolean);
+  return normalized && normalized.length > 0 ? normalized : void 0;
+}
+async function callHook(callback) {
+  if (!callback) return;
+  try {
+    await callback();
+  } catch {
+  }
+}
+function safeOnStep(hooks) {
+  if (!hooks.onStep) return void 0;
+  return (result, step, index) => {
+    try {
+      hooks.onStep?.(result, step, index);
+    } catch {
+    }
+  };
+}
+function firstRunFailureMessage(result) {
+  const failedStep = result.steps.find((step) => step.status === "fail" && step.error);
+  if (failedStep?.error) return failedStep.error;
+  const failedAssertion = result.assertions.find((assertion) => assertion.status === "fail" && assertion.error);
+  return failedAssertion?.error;
+}
+async function runSuite(options = {}) {
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const startTime = Date.now();
+  const hooks = options.hooks ?? {};
+  const { config, configDir } = loadConfig(options.configPath);
+  const hunts = listHunts(configDir);
+  if (hunts.length === 0) {
+    return {
+      result: {
+        status: "no-hunts",
+        startedAt,
+        durationMs: 0,
+        totalHunts: 0,
+        passed: 0,
+        failed: 0,
+        skipped: 0,
+        hunts: []
+      },
+      resultPath: null
+    };
+  }
+  const includeTags = normalizeTagFilter(options.includeTags);
+  const excludeTags = normalizeTagFilter(options.excludeTags);
+  const resultsByIndex = new Array(hunts.length);
+  const onStep = safeOnStep(hooks);
+  const huntsToRun = [];
+  for (let index = 0; index < hunts.length; index++) {
+    const huntName = hunts[index];
+    if (includeTags || excludeTags) {
+      const tags = loadHuntTags(huntName, configDir);
+      if (includeTags && !includeTags.some((t) => tags.includes(t))) {
+        await callHook(() => hooks.onHuntSkipped?.(huntName, "include"));
+        resultsByIndex[index] = { hunt: huntName, status: "skipped", durationMs: 0 };
+        continue;
+      }
+      if (excludeTags && excludeTags.some((t) => tags.includes(t))) {
+        await callHook(() => hooks.onHuntSkipped?.(huntName, "exclude"));
+        resultsByIndex[index] = { hunt: huntName, status: "skipped", durationMs: 0 };
+        continue;
+      }
+    }
+    huntsToRun.push({ huntName, index });
+  }
+  const buildTask = (huntName) => async () => {
+    const huntStart = Date.now();
+    try {
+      await callHook(() => hooks.onHuntStart?.(huntName));
+      const { result, runDir } = await runHunt({
+        huntName,
+        urlOverride: options.urlOverride,
+        headed: options.headed,
+        slowMo: options.slowMo,
+        trace: options.trace,
+        browser: options.browser,
+        channel: options.channel,
+        viewport: options.viewport,
+        junit: options.junit,
+        configPath: options.configPath,
+        onStep
+      });
+      const error = result.status === "fail" ? firstRunFailureMessage(result) ?? "Run failed" : void 0;
+      if (error) {
+        await callHook(() => hooks.onHuntFailure?.(huntName, error));
+      } else {
+        await callHook(() => hooks.onHuntSuccess?.(huntName, result, runDir));
+      }
+      return {
+        hunt: huntName,
+        status: result.status,
+        durationMs: result.durationMs,
+        runDir,
+        error
+      };
+    } catch (error) {
+      const durationMs = Date.now() - huntStart;
+      const message = error instanceof Error ? error.message : "Run failed";
+      await callHook(() => hooks.onHuntFailure?.(huntName, message));
+      return {
+        hunt: huntName,
+        status: "fail",
+        durationMs,
+        error: message
+      };
+    }
+  };
+  const parallel = options.parallel;
+  if (parallel !== void 0 && parallel > 1) {
+    const tasks = huntsToRun.map((entry) => ({ ...entry, task: buildTask(entry.huntName) }));
+    const parallelResults = await runWithConcurrency(
+      tasks.map((entry) => entry.task),
+      parallel
+    );
+    for (let i = 0; i < parallelResults.length; i++) {
+      const pr = parallelResults[i];
+      const task = tasks[i];
+      if (pr.status === "fulfilled") {
+        resultsByIndex[task.index] = pr.value;
+      } else {
+        const message = pr.reason instanceof Error ? pr.reason.message : "Run failed";
+        resultsByIndex[task.index] = {
+          hunt: task.huntName,
+          status: "fail",
+          durationMs: 0,
+          error: message
+        };
+      }
+    }
+  } else {
+    for (const { huntName, index } of huntsToRun) {
+      resultsByIndex[index] = await buildTask(huntName)();
+    }
+  }
+  const totalDurationMs = Date.now() - startTime;
+  const results = resultsByIndex.map((result, index) => {
+    return result ?? {
+      hunt: hunts[index],
+      status: "fail",
+      durationMs: 0,
+      error: "Run did not produce a result"
+    };
+  });
+  const threshold = config.reliability?.flakyThreshold ?? DEFAULT_FLAKY_THRESHOLD;
+  const ranThisSuite = new Set(
+    results.filter((r) => r.status !== "skipped").map((r) => r.hunt)
+  );
+  const flaky = rankFlaky(configDir, { threshold }).filter((entry) => entry.flaky && ranThisSuite.has(entry.hunt)).map((entry) => ({ hunt: entry.hunt, score: entry.score }));
+  const clusters = clusterFailures(
+    extractFailures({ result: { hunts: results }, resultPath: null })
+  ).filter((cluster) => cluster.count > 1);
+  const ciRunDir = import_node_path12.default.join(configDir, "runs", timestamp("ci"));
+  const resultPath = writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky, clusters);
+  const { passed, failed, skipped } = countCiResults(results);
+  return {
+    result: {
+      status: resolveCiStatus(results),
+      startedAt,
+      durationMs: totalDurationMs,
+      totalHunts: results.length,
+      passed,
+      failed,
+      skipped,
+      hunts: results,
+      ...flaky.length > 0 ? { flaky } : {},
+      ...clusters.length > 0 ? { clusters } : {}
+    },
+    resultPath
+  };
+}
+
+// src/analyzer/index.ts
+async function analyzePage(page) {
+  const raw = await page.evaluate(() => {
+    const forms2 = Array.from(document.querySelectorAll("form"));
+    const formData = forms2.map((form, index) => ({
+      index,
+      action: form.getAttribute("action") || void 0,
+      method: (form.getAttribute("method") || "GET").toUpperCase(),
+      fieldCount: form.querySelectorAll("input, textarea, select").length
+    }));
+    function getFormIndex(el) {
+      const form = el.closest("form");
+      if (!form) return -1;
+      return forms2.indexOf(form);
+    }
+    function getLabel(el) {
+      const id = el.getAttribute("id");
+      if (id) {
+        const label = document.querySelector(`label[for="${id}"]`);
+        if (label) return label.textContent?.trim() || void 0;
+      }
+      const parentLabel = el.closest("label");
+      if (parentLabel) return parentLabel.textContent?.trim() || void 0;
+      return void 0;
+    }
+    const selectors = "input, textarea, select, button, [role=button], a";
+    const rawElements = Array.from(document.querySelectorAll(selectors));
+    const elements2 = rawElements.filter((el) => {
+      if (el.tagName.toLowerCase() === "input" && el.getAttribute("type") === "hidden") {
+        return false;
+      }
+      return true;
+    }).map((el) => {
+      const tag = el.tagName.toLowerCase();
+      const type = el.getAttribute("type") || void 0;
+      const testId = el.getAttribute("data-testid") || void 0;
+      const ariaLabel = el.getAttribute("aria-label") || void 0;
+      const role = el.getAttribute("role") || void 0;
+      const id = el.getAttribute("id") || void 0;
+      const name = el.getAttribute("name") || void 0;
+      const label = getLabel(el);
+      const placeholder = el.getAttribute("placeholder") || void 0;
+      const required = el.hasAttribute("required");
+      const formIndex = getFormIndex(el);
+      const text = el.textContent?.trim() || void 0;
+      const href = el.getAttribute("href") || void 0;
+      return {
+        tag,
+        type: type || void 0,
+        testId,
+        ariaLabel,
+        role,
+        id,
+        name,
+        label,
+        placeholder,
+        required,
+        formIndex,
+        text: tag === "a" || tag === "button" || role === "button" ? text : void 0,
+        href: tag === "a" ? href : void 0
+      };
+    });
+    return {
+      title: document.title,
+      url: window.location.href,
+      elements: elements2,
+      forms: formData
+    };
+  });
+  const elements = raw.elements.filter((el) => el.tag !== "a").map((el) => {
+    const selectors = {};
+    if (el.testId) selectors.testId = `[data-testid="${el.testId}"]`;
+    if (el.ariaLabel) selectors.ariaLabel = el.ariaLabel;
+    if (el.label) selectors.label = el.label;
+    if (el.id) selectors.css = `#${el.id}`;
+    if (el.name) selectors.name = `[name="${el.name}"]`;
+    if (el.placeholder) selectors.placeholder = el.placeholder;
+    if (el.text) selectors.text = el.text;
+    if (el.role) selectors.role = el.role;
+    return {
+      tag: el.tag,
+      ...el.type ? { type: el.type } : {},
+      selectors,
+      ...el.role ? { role: el.role } : {},
+      ...el.label ? { label: el.label } : {},
+      ...el.placeholder ? { placeholder: el.placeholder } : {},
+      required: el.required,
+      ...el.formIndex >= 0 ? { formGroup: el.formIndex } : {}
+    };
+  });
+  const links = raw.elements.filter((el) => el.tag === "a" && el.href).map((el) => {
+    let selector;
+    if (el.testId) {
+      selector = `[data-testid="${el.testId}"]`;
+    } else if (el.href) {
+      selector = `a[href="${el.href}"]`;
+    } else {
+      selector = `a`;
+    }
+    return {
+      text: el.text || "",
+      href: el.href,
+      selector
+    };
+  });
+  const forms = raw.forms;
+  return {
+    url: raw.url,
+    title: raw.title,
+    elements,
+    forms,
+    links
+  };
+}
+
+// src/generator/index.ts
+var import_yaml2 = __toESM(require("yaml"), 1);
+var import_playwright2 = require("playwright");
+
+// src/generator/prompt.ts
+var STEP_REFERENCE = `
+## Prowl Step Types
+
+### Navigation & Waiting
+- navigate: "/path" \u2014 navigate to URL (relative to target)
+- wait: "Text" \u2014 wait for text to appear
+- wait: { for: "Text", timeout: 5000 } \u2014 with timeout
+- waitForSelector: { selector: "#el", timeout: 5000 }
+- waitForUrl: { value: "/path", timeout: 5000 }
+- waitForNetworkIdle: { timeout: 5000 }
+
+### Interaction
+- click: "Button Text" \u2014 click by text (tries role=button first)
+- click: { selector: "[data-testid=btn]" } \u2014 click by selector
+- fill: { "Label": "value" } \u2014 fill by label/placeholder
+- fill: { selector: "#input", value: "text" } \u2014 fill by selector
+- type: "text" \u2014 type into focused element
+- press: { selector: "#input", key: "Enter" }
+- hover: { selector: "#menu" }
+- selectOption: { selector: "select", value: "option" }
+- select: { "Label": "value" } \u2014 select by label
+- setInputFiles: { selector: "#file", files: "path.png" }
+- onDialog: { action: "accept" } \u2014 handle browser dialogs
+
+### Assertions
+- assert: { visible: "Text" }
+- assert: { notVisible: "Error" }
+- assert: { urlIncludes: "/dashboard" }
+- assert: { urlEquals: "https://..." }
+
+### Scrolling & Screenshots
+- scroll: { direction: "down", amount: 500 }
+- scrollTo: { selector: "#section" }
+- screenshot: { name: "step-name" }
+
+### Script Execution
+- evalScript: "document.title" \u2014 evaluate JS expression
+- evalScript: { expression: "expr", as: "VAR" } \u2014 capture to variable
+- runScript: { file: "scripts/setup.js" }
+
+### Visual Regression
+- assertScreenshot: { name: "baseline-name", threshold: 0.1 }
+
+### Control Flow
+- if: { visible: ".banner", then: [steps...] }
+- repeat: { times: 3, steps: [steps...] }
+- repeat: { while: { visible: ".more" }, maxIterations: 10, steps: [steps...] }
+- runHunt: "other-hunt" \u2014 run another hunt file
+- mockRoute: { url: "**/api/data", response: { status: 200, body: "{}" } }
+- unmockRoute: { url: "**/api/data" }
+`.trim();
+function buildGenerationPrompt(analysis, intent) {
+  return `You are a QA test generator for Prowl. Generate a YAML hunt file that tests the described intent using the page analysis data below.
+
+${STEP_REFERENCE}
+
+## Page Analysis
+\`\`\`json
+${JSON.stringify(analysis, null, 2)}
+\`\`\`
+
+## Test Intent
+${intent}
+
+## Instructions
+1. Output ONLY a valid Prowl YAML hunt between \`\`\`yaml fences
+2. Use shorthand syntax when possible (click: "Text", fill: { "Label": "value" })
+3. Prefer stable selectors: data-testid > aria-label > text > CSS selectors
+4. Include assertions to verify expected outcomes
+5. Add a descriptive name and description
+6. Keep steps focused and minimal \u2014 test exactly what the intent describes
+
+\`\`\`yaml
+`;
+}
+function extractYamlFromResponse(response) {
+  const fenceMatch = response.match(/```ya?ml\n?([\s\S]*?)```/);
+  if (fenceMatch) {
+    return fenceMatch[1].trim();
+  }
+  return response.trim();
+}
+
+// src/generator/ai.ts
+function resolveAiConfig() {
+  const provider = process.env.PROWL_AI_PROVIDER ?? "anthropic";
+  if (provider !== "anthropic" && provider !== "openai") {
+    throw new Error(`Unsupported AI provider: ${provider}. Use "anthropic" or "openai".`);
+  }
+  const apiKey = process.env.PROWL_AI_KEY;
+  if (!apiKey) {
+    throw new Error(
+      "PROWL_AI_KEY environment variable is required. Set it to your Anthropic or OpenAI API key."
+    );
+  }
+  const defaultModel = provider === "anthropic" ? "claude-sonnet-4-5-20250929" : "gpt-4o";
+  const model = process.env.PROWL_AI_MODEL ?? defaultModel;
+  return { provider, model, apiKey };
+}
+async function generateWithAi(prompt, config) {
+  if (config.provider === "anthropic") {
+    return generateWithAnthropic(prompt, config);
+  }
+  return generateWithOpenAi(prompt, config);
+}
+async function generateWithAnthropic(prompt, config) {
+  const response = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model: config.model,
+      max_tokens: 4096,
+      messages: [
+        { role: "user", content: prompt }
+      ]
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`Anthropic API error (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  const textBlock = data.content.find((c) => c.type === "text");
+  if (!textBlock?.text) {
+    throw new Error("Anthropic API returned no text content");
+  }
+  return textBlock.text;
+}
+async function generateWithOpenAi(prompt, config) {
+  const response = await fetch("https://api.openai.com/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${config.apiKey}`
+    },
+    body: JSON.stringify({
+      model: config.model,
+      messages: [
+        { role: "user", content: prompt }
+      ],
+      max_tokens: 4096
+    })
+  });
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`OpenAI API error (${response.status}): ${body}`);
+  }
+  const data = await response.json();
+  if (!data.choices?.[0]?.message?.content) {
+    throw new Error("OpenAI API returned no content");
+  }
+  return data.choices[0].message.content;
+}
+
+// src/generator/index.ts
+async function generateHunt(options) {
+  let analysis = options.analysis;
+  if (!analysis && options.url) {
+    const browser = await import_playwright2.chromium.launch({ headless: true });
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    try {
+      await page.goto(options.url, { waitUntil: "networkidle" });
+      analysis = await analyzePage(page);
+    } finally {
+      await context.close();
+      await browser.close();
+    }
+  }
+  if (!analysis) {
+    throw new Error("Either --url or piped analysis JSON is required");
+  }
+  const config = options.aiConfig ?? resolveAiConfig();
+  const prompt = buildGenerationPrompt(analysis, options.intent);
+  const response = await generateWithAi(prompt, config);
+  const yamlStr = extractYamlFromResponse(response);
+  const parsed = import_yaml2.default.parse(yamlStr);
+  huntSchema.parse(parsed);
+  return yamlStr;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FLAKY_THRESHOLD,
+  analyzePage,
+  buildHealCandidates,
+  clusterFailures,
+  computeFlakeScore,
+  configSchema,
+  extractFailures,
+  extractSelectorIntent,
+  generateHunt,
+  healSelector,
+  huntSchema,
+  interpolateHunt,
+  listHunts,
+  loadConfig,
+  loadHunt,
+  loadHuntMeta,
+  loadHuntTags,
+  rankFlaky,
+  readHistory,
+  readHuntHistory,
+  runHunt,
+  runSuite,
+  stepSchema,
+  updateBacklogFromSuite
+});
+//# sourceMappingURL=lib.cjs.map