prowl-tools 0.1.3

package/dist/chunk-T7YLXF6X.js

@@ -0,0 +1,3158 @@
+import {
+  ensureAllowedDomain,
+  huntSchema,
+  listHunts,
+  loadConfig,
+  loadHunt,
+  loadHuntTags,
+  resolveViewport
+} from "./chunk-NXXGJOBG.js";
+
+// src/config/interpolate.ts
+import crypto from "crypto";
+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 ?? crypto.randomBytes;
+  const randomUUID = randomSource?.randomUUID ?? crypto.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/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/history.ts
+import fs from "fs";
+import path from "path";
+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 path.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 (!fs.existsSync(filePath)) {
+    return { entries: [] };
+  }
+  try {
+    const raw = fs.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}`;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
+    let fd;
+    try {
+      fd = fs.openSync(lockPath, "wx");
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        sleepSync(LOCK_RETRY_MS);
+        continue;
+      }
+      throw error;
+    }
+    try {
+      return fn();
+    } finally {
+      try {
+        fs.closeSync(fd);
+      } catch {
+      }
+      fs.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`;
+    fs.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
+`);
+    fs.renameSync(tempPath, filePath);
+  });
+}
+
+// src/runner/index.ts
+import fs7 from "fs";
+import path7 from "path";
+
+// src/browser/controller.ts
+import fs2 from "fs";
+import path2 from "path";
+import { chromium, firefox, webkit } from "playwright";
+var ENGINES = { chromium, firefox, 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 (fs2.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: path2.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 = path2.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
+import fs3 from "fs";
+import path3 from "path";
+
+// 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/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 path3.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 !== path3.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 = path3.join(context.runDir, "screenshots");
+  fs3.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 = path3.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) => path3.isAbsolute(f) ? f : path3.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 = path3.isAbsolute(responseFile) ? responseFile : path3.join(context.configDir, responseFile);
+          const resolvedConfigDir = path3.resolve(context.configDir);
+          const resolvedFilePath = path3.resolve(candidateFilePath);
+          const relativePath = path3.relative(resolvedConfigDir, resolvedFilePath);
+          const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${path3.sep}`) && !path3.isAbsolute(relativePath);
+          if (!isWithinConfigDir) {
+            throw new Error("mock.response.file must resolve within config directory");
+          }
+          responseBody = await fs3.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 = path3.isAbsolute(step.runScript.file) ? step.runScript.file : path3.join(context.configDir, step.runScript.file);
+        const fileContents = fs3.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, ensureBaselineDir } = await import("./visual-FSARM2JS.js");
+        const name = step.assertScreenshot.name;
+        const threshold = step.assertScreenshot.threshold ?? 0.1;
+        const baselineDir = ensureBaselineDir(context.configDir);
+        const baselinePath = path3.join(baselineDir, `${name}.png`);
+        const currentScreenshotPath = path3.join(context.runDir, "screenshots", `${name}-current.png`);
+        fs3.mkdirSync(path3.dirname(currentScreenshotPath), { recursive: true });
+        await context.page.screenshot({ path: currentScreenshotPath, fullPage: true });
+        screenshots.push(path3.join("screenshots", `${name}-current.png`));
+        if (!fs3.existsSync(baselinePath)) {
+          fs3.copyFileSync(currentScreenshotPath, baselinePath);
+          stepResult = {
+            type: "assertScreenshot",
+            status: "pass",
+            durationMs: Date.now() - stepStart,
+            value: "baseline created"
+          };
+        } else {
+          const diffPath = path3.join(context.runDir, "screenshots", `${name}-diff.png`);
+          const comparison = await compareScreenshots(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(path3.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 = path3.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 = path3.join(runDir, "screenshots");
+  fs3.mkdirSync(screenshotsDir, { recursive: true });
+  const fileName = "final.png";
+  const filePath = screenshotPath(screenshotsDir, fileName);
+  await captureScreenshot(page, filePath);
+  return path3.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
+import fs4 from "fs";
+import path4 from "path";
+function writeResult(runDir, result) {
+  const fileName = "result.json";
+  const fullPath = path4.join(runDir, fileName);
+  fs4.writeFileSync(fullPath, JSON.stringify(result, null, 2));
+  return fileName;
+}
+
+// src/reporter/summary.ts
+import fs5 from "fs";
+import path5 from "path";
+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 = path5.join(runDir, fileName);
+  fs5.writeFileSync(fullPath, `${lines.join("\n")}
+`);
+  return fileName;
+}
+
+// src/reporter/junit.ts
+import fs6 from "fs";
+import path6 from "path";
+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 = path6.join(runDir, fileName);
+  fs6.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/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 (path7.isAbsolute(inputPath)) {
+    return inputPath;
+  }
+  const projectRoot = path7.dirname(configDir);
+  return path7.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 = path7.join(runDir, fileName);
+  const lines = entries.map((entry) => {
+    const location = entry.location ? ` (${entry.location})` : "";
+    return `[${entry.type}] ${entry.text}${location}`;
+  });
+  fs7.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 = path7.join(configDir, "runs", timestamp());
+  fs7.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 = path7.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/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
+import { createHash } from "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 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
+import fs8 from "fs";
+import path8 from "path";
+
+// 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 fs8.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(path8.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 ?? path8.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? path8.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) {
+    fs8.mkdirSync(path8.dirname(backlogPath), { recursive: true });
+    fs8.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+  }
+  return summary;
+}
+
+// src/runner/suite.ts
+import path10 from "path";
+
+// src/reporter/ci-summary.ts
+import fs9 from "fs";
+import path9 from "path";
+import chalk from "chalk";
+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 printCiSummary(results, totalDurationMs, flaky = [], clusters = []) {
+  const { passed, failed, skipped } = countCiResults(results);
+  const lineWidth = 45;
+  console.log(`
+  \u2500\u2500 CI Summary ${"\u2500".repeat(lineWidth - 15)}`);
+  for (const r of results) {
+    const icon = r.status === "pass" ? chalk.green("\u2713") : r.status === "fail" ? chalk.red("\u2717") : chalk.yellow("\u25CB");
+    const name = r.status === "fail" ? chalk.red(r.hunt) : r.status === "skipped" ? chalk.yellow(r.hunt) : r.hunt;
+    const duration = r.status === "skipped" ? "" : chalk.gray(`(${r.durationMs}ms)`);
+    const pad = " ".repeat(Math.max(1, 40 - r.hunt.length));
+    console.log(`  ${icon} ${name}${pad}${duration}`);
+  }
+  console.log(`  ${"\u2500".repeat(lineWidth)}`);
+  const parts = [];
+  if (passed > 0) parts.push(chalk.green(`${passed} passed`));
+  if (failed > 0) parts.push(chalk.red(`${failed} failed`));
+  if (skipped > 0) parts.push(chalk.yellow(`${skipped} skipped`));
+  parts.push(chalk.gray(`(${totalDurationMs}ms)`));
+  console.log(`  ${parts.join("  ")}`);
+  if (flaky.length > 0) {
+    console.log(`
+  ${chalk.yellow("Flaky hunts")} (oscillating pass/fail):`);
+    for (const entry of flaky) {
+      console.log(`  ${chalk.yellow("~")} ${entry.hunt} ${chalk.gray(`(score ${entry.score.toFixed(2)})`)}`);
+    }
+  }
+  if (clusters.length > 0) {
+    console.log(`
+  ${chalk.red("Failure clusters")} (shared root causes):`);
+    for (const cluster of clusters) {
+      console.log(`  ${chalk.red("\u2717")} ${cluster.cause} ${chalk.gray(`(${cluster.count} hunts: ${cluster.hunts.join(", ")})`)}`);
+    }
+  }
+}
+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 } : {}
+  };
+  fs9.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = path9.join(ciRunDir, "ci-result.json");
+  fs9.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/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 = path10.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
+import yaml from "yaml";
+import { chromium as chromium2 } from "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 chromium2.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 = yaml.parse(yamlStr);
+  huntSchema.parse(parsed);
+  return yamlStr;
+}
+
+export {
+  interpolateHunt,
+  extractSelectorIntent,
+  buildHealCandidates,
+  healSelector,
+  readHistory,
+  readHuntHistory,
+  runHunt,
+  printCiSummary,
+  DEFAULT_FLAKY_THRESHOLD,
+  computeFlakeScore,
+  rankFlaky,
+  clusterFailures,
+  extractFailures,
+  updateBacklogFromSuite,
+  runSuite,
+  analyzePage,
+  generateHunt
+};
+//# sourceMappingURL=chunk-T7YLXF6X.js.map