prowl-tools 0.1.3 → 0.1.4

package/dist/{chunk-T7YLXF6X.js → chunk-ZEFVTKQT.js}

@@ -1,4 +1,5 @@
 import {
+  SUPPORTED_BROWSER_ENGINES,
   ensureAllowedDomain,
   huntSchema,
   listHunts,
@@ -6,7 +7,7 @@ import {
   loadHunt,
   loadHuntTags,
   resolveViewport
-} from "./chunk-NXXGJOBG.js";
+} from "./chunk-MBAIGNVO.js";
 
 // src/config/interpolate.ts
 import crypto from "crypto";
@@ -53,7 +54,7 @@ function generateRandomVars(randomSource) {
   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 num2 = Math.floor(random() * 9e3) + 1e3;
   const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
   let text = "";
   for (let i = 0; i < 8; i++) {
@@ -62,7 +63,7 @@ function generateRandomVars(randomSource) {
   return {
     RANDOM_EMAIL: `prowl_${hex}@test.com`,
     RANDOM_NAME: `${RANDOM_FIRST_NAMES[firstIndex]} ${RANDOM_LAST_NAMES[lastIndex]}`,
-    RANDOM_NUMBER: String(num),
+    RANDOM_NUMBER: String(num2),
     RANDOM_UUID: randomUUID(),
     RANDOM_TEXT: text
   };
@@ -374,6 +375,518 @@ function interpolateHunt(hunt, env, randomVars = generateRandomVars()) {
   };
 }
 
+// src/config/target.ts
+import { execFileSync } from "child_process";
+import fs from "fs";
+import path from "path";
+var WEB_ONLY_STEP_TYPES = /* @__PURE__ */ new Set([
+  "navigate",
+  "waitForUrl",
+  "waitForNetworkIdle",
+  "mockRoute",
+  "unmockRoute",
+  "evalScript",
+  "runScript",
+  "onDialog",
+  "select",
+  "selectOption",
+  "setInputFiles",
+  "waitForDownload",
+  "scroll"
+  // directional scroll runs window.scrollBy (evaluate) — use scrollTo instead
+]);
+function webOnlyReason(step) {
+  for (const type of WEB_ONLY_STEP_TYPES) {
+    if (type in step) {
+      return type;
+    }
+  }
+  if ("assert" in step) {
+    const assertion = step.assert;
+    if (assertion.urlIncludes !== void 0 || assertion.urlEquals !== void 0) {
+      return "assert (url)";
+    }
+  }
+  return null;
+}
+function assertStepsSupportedByTarget(steps, target) {
+  if (target !== "macos") {
+    return;
+  }
+  for (const step of steps) {
+    const reason = webOnlyReason(step);
+    if (reason) {
+      throw new Error(
+        `Step "${reason}" is not supported by the macOS target. It is web-only; use a portable step (click, fill, type, press, wait, assert visible, screenshot, etc.).`
+      );
+    }
+    if ("if" in step) {
+      assertStepsSupportedByTarget(step.if.then, target);
+      if (step.if.else) {
+        assertStepsSupportedByTarget(step.if.else, target);
+      }
+    }
+    if ("repeat" in step) {
+      assertStepsSupportedByTarget(step.repeat.steps, target);
+    }
+  }
+}
+function assertHuntAssertionsSupportedByTarget(assertions, target) {
+  if (target !== "macos" || !assertions || assertions.length === 0) {
+    return;
+  }
+  throw new Error(
+    "Hunt-level assertions are not supported by the macOS target. Use inline assert visible/notVisible steps instead."
+  );
+}
+function trimTrailingPathSeparators(value) {
+  return value.replace(/[\\/]+$/g, "");
+}
+function looksLikeMacosAppPath(app) {
+  const trimmed = trimTrailingPathSeparators(app);
+  return trimmed.includes("/") || trimmed.toLowerCase().endsWith(".app");
+}
+function normalizeAppPath(app) {
+  return path.resolve(trimTrailingPathSeparators(app));
+}
+function parseBundleIdentifier(plist) {
+  const match = /<key>\s*CFBundleIdentifier\s*<\/key>\s*<string>\s*([^<]+?)\s*<\/string>/s.exec(plist);
+  return match?.[1]?.trim() || null;
+}
+function readBundleIdentifier(appPath) {
+  const infoPlistPath = path.join(normalizeAppPath(appPath), "Contents", "Info.plist");
+  if (!fs.existsSync(infoPlistPath)) {
+    return null;
+  }
+  try {
+    const parsed = parseBundleIdentifier(fs.readFileSync(infoPlistPath, "utf-8"));
+    if (parsed) {
+      return parsed;
+    }
+  } catch {
+  }
+  if (process.platform !== "darwin" || !fs.existsSync("/usr/bin/plutil")) {
+    return null;
+  }
+  try {
+    const output = execFileSync(
+      "/usr/bin/plutil",
+      ["-extract", "CFBundleIdentifier", "raw", "-o", "-", infoPlistPath],
+      { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }
+    );
+    return output.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function macosAppAllowedIdentities(app) {
+  const identities = /* @__PURE__ */ new Set([app]);
+  if (looksLikeMacosAppPath(app)) {
+    const normalizedPath = normalizeAppPath(app);
+    identities.add(trimTrailingPathSeparators(app));
+    identities.add(normalizedPath);
+    const bundleName = path.basename(normalizedPath).replace(/\.app$/i, "");
+    if (bundleName) {
+      identities.add(bundleName);
+    }
+    const bundleId = readBundleIdentifier(app);
+    if (bundleId) {
+      identities.add(bundleId);
+    }
+  }
+  return [...identities];
+}
+function assertTargetAppAllowed(allowedApps, app) {
+  if (allowedApps.length === 0) {
+    return;
+  }
+  const allowedIdentities = new Set(allowedApps.flatMap((allowedApp) => macosAppAllowedIdentities(allowedApp)));
+  if (macosAppAllowedIdentities(app).some((identity) => allowedIdentities.has(identity))) {
+    return;
+  }
+  throw new Error(
+    `Target app "${app}" is not in guardrails.allowedApps (${allowedApps.join(", ")}).`
+  );
+}
+
+// src/browser/mac-driver.ts
+var MAC_CAPABILITIES = /* @__PURE__ */ new Set([
+  "query",
+  "interact",
+  "wait",
+  "screenshot"
+]);
+var STATUS_ITEM_SELECTOR = "statusitem";
+var MENU_PREFIX = "menu=";
+function unquote(value) {
+  const trimmed = value.trim();
+  const first = trimmed[0];
+  if ((first === '"' || first === "'") && trimmed.endsWith(first) && trimmed.length >= 2) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function parseMacSelector(selector) {
+  const trimmed = selector.trim();
+  const idMatch = /^id=(.+)$/s.exec(trimmed);
+  if (idMatch) {
+    return { by: "id", value: unquote(idMatch[1]) };
+  }
+  const roleMatch = /^role=([A-Za-z][\w-]*)(?:\[name=(.+)\])?$/s.exec(trimmed);
+  if (roleMatch) {
+    const name = roleMatch[2] !== void 0 ? unquote(roleMatch[2]) : void 0;
+    return name !== void 0 && name.length > 0 ? { by: "role", role: roleMatch[1], name } : { by: "role", role: roleMatch[1] };
+  }
+  const labelMatch = /^label=(.+)$/s.exec(trimmed);
+  if (labelMatch) {
+    return { by: "label", value: unquote(labelMatch[1]) };
+  }
+  const textMatch = /^text=(.+)$/s.exec(trimmed);
+  if (textMatch) {
+    return { by: "text", value: unquote(textMatch[1]) };
+  }
+  return { by: "text", value: trimmed };
+}
+function unwrapMacTextSelector(selector) {
+  const trimmed = selector.trim();
+  if (!trimmed.startsWith("text=")) {
+    return null;
+  }
+  return unquote(trimmed.slice(5));
+}
+function num(value) {
+  return typeof value === "number" ? value : Number(value ?? 0);
+}
+function createMacDriver(client, options = {}) {
+  const unsupported = (verb) => new Error(`${verb} is not supported by the macOS target`);
+  const rejectUnsupported = (verb) => Promise.reject(unsupported(verb));
+  async function query(cmd, selector, extra) {
+    return client.request(cmd, { query: parseMacSelector(selector), ...extra });
+  }
+  async function clickSelector(selector) {
+    const trimmed = selector.trim();
+    if (trimmed.toLowerCase() === STATUS_ITEM_SELECTOR) {
+      await client.request("openMenu");
+      return;
+    }
+    if (trimmed.toLowerCase().startsWith(MENU_PREFIX)) {
+      await client.request("clickMenu", { title: trimmed.slice(MENU_PREFIX.length).trim() });
+      return;
+    }
+    await query("click", selector);
+  }
+  async function fillSelector(selector, value) {
+    if (selector.trim() === ":focus") {
+      await client.request("fill", { query: { by: "focused" }, value });
+      return;
+    }
+    await query("fill", selector, { value });
+  }
+  return {
+    capabilities: MAC_CAPABILITIES,
+    // navigation -----------------------------------------------------------
+    goto(_url, _options) {
+      return rejectUnsupported("navigate");
+    },
+    currentUrl() {
+      return `macos:${options.appLabel ?? ""}`;
+    },
+    // queries --------------------------------------------------------------
+    async count(selector) {
+      const result = await query("count", selector);
+      return num(result.count);
+    },
+    async textContent(selector) {
+      const result = await query("text", selector);
+      return result.text === void 0 || result.text === null ? null : String(result.text);
+    },
+    // interactions ---------------------------------------------------------
+    click: clickSelector,
+    clickFirst: clickSelector,
+    fill: fillSelector,
+    fillFirst: fillSelector,
+    async press(selector, key) {
+      await query("press", selector, { key });
+    },
+    selectOption() {
+      return rejectUnsupported("select");
+    },
+    selectOptionFirst() {
+      return rejectUnsupported("select");
+    },
+    async hover(selector) {
+      await query("hover", selector);
+    },
+    async scrollIntoView(selector) {
+      await query("scrollTo", selector);
+    },
+    setInputFiles() {
+      return rejectUnsupported("setInputFiles");
+    },
+    // semantic locators ----------------------------------------------------
+    async countByRole(role, name) {
+      const result = await client.request("count", { query: { by: "role", role, name } });
+      return num(result.count);
+    },
+    async clickFirstByRole(role, name) {
+      await client.request("click", { query: { by: "role", role, name } });
+    },
+    async countByLabel(label) {
+      const result = await client.request("count", { query: { by: "label", value: label } });
+      return num(result.count);
+    },
+    async fillFirstByLabel(label, value) {
+      await client.request("fill", { query: { by: "label", value: label }, value });
+    },
+    selectOptionFirstByLabel() {
+      return rejectUnsupported("select");
+    },
+    // waiting --------------------------------------------------------------
+    async waitForSelector(selector, waitOptions) {
+      const extra = waitOptions?.timeout !== void 0 ? { timeout: waitOptions.timeout / 1e3 } : void 0;
+      await query("waitFor", selector, extra);
+    },
+    waitForUrl() {
+      return rejectUnsupported("waitForUrl");
+    },
+    waitForNetworkIdle() {
+      return rejectUnsupported("waitForNetworkIdle");
+    },
+    // scripting & artifacts ------------------------------------------------
+    evaluate() {
+      return rejectUnsupported("evalScript");
+    },
+    async screenshot(screenshotOptions) {
+      await client.request("screenshot", { path: screenshotOptions.path });
+    },
+    // network / dialogs / downloads (all web-only) -------------------------
+    onResponse(_handler) {
+      throw unsupported("onResponse");
+    },
+    route(_url, _handler) {
+      return rejectUnsupported("mockRoute");
+    },
+    unroute() {
+      return rejectUnsupported("unmockRoute");
+    },
+    onDialog(_action) {
+      throw unsupported("onDialog");
+    },
+    waitForDownloadEvent() {
+      return rejectUnsupported("waitForDownload");
+    },
+    parseTextSelector(selector) {
+      return unwrapMacTextSelector(selector);
+    }
+  };
+}
+
+// src/browser/mac-helper.ts
+import { spawn } from "child_process";
+import fs2 from "fs";
+import path2 from "path";
+import { fileURLToPath } from "url";
+var HELPER_BINARY = "prowl-macdriver";
+function macdriverBuildInstructions() {
+  return "The macOS target requires the experimental `prowl-macdriver` helper, which is not shipped in the npm package. Build it locally:\n  cd macdriver && swift build -c release\nor point Prowl at a prebuilt binary via the PROWL_MACDRIVER_BIN environment variable.";
+}
+function getPackageRoot() {
+  let dir = path2.dirname(fileURLToPath(import.meta.url));
+  const root = path2.parse(dir).root;
+  while (dir !== root) {
+    if (fs2.existsSync(path2.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = path2.dirname(dir);
+  }
+  return root;
+}
+function resolveHelperBinary(env = process.env) {
+  const override = env.PROWL_MACDRIVER_BIN;
+  if (override) {
+    if (!fs2.existsSync(override)) {
+      throw new Error(
+        `PROWL_MACDRIVER_BIN points at a missing file: ${override}
+${macdriverBuildInstructions()}`
+      );
+    }
+    return override;
+  }
+  const root = getPackageRoot();
+  const candidates = [
+    path2.join(root, "macdriver", ".build", "release", HELPER_BINARY),
+    path2.join(root, "macdriver", ".build", "debug", HELPER_BINARY)
+  ];
+  for (const candidate of candidates) {
+    if (fs2.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`Could not find the ${HELPER_BINARY} helper binary.
+${macdriverBuildInstructions()}`);
+}
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var SpawnMacHelperClient = class {
+  child;
+  pending = /* @__PURE__ */ new Map();
+  requestTimeoutMs;
+  stdoutBuffer = "";
+  stderrBuffer = "";
+  nextId = 1;
+  closed = false;
+  terminalError;
+  constructor(binaryPath, options = {}) {
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    this.child = spawn(binaryPath, ["serve"], { stdio: ["pipe", "pipe", "pipe"] });
+    this.child.stdout?.setEncoding("utf-8");
+    this.child.stderr?.setEncoding("utf-8");
+    this.child.stdout?.on("data", (chunk) => this.onStdout(chunk));
+    this.child.stderr?.on("data", (chunk) => {
+      this.stderrBuffer = (this.stderrBuffer + chunk).slice(-4e3);
+    });
+    this.child.on("error", (error) => this.recordTerminalFailure(error));
+    this.child.on("exit", (code) => {
+      if (!this.closed) {
+        const detail = this.stderrBuffer.trim();
+        this.recordTerminalFailure(
+          new Error(`prowl-macdriver exited unexpectedly (code ${code ?? "null"})${detail ? `: ${detail}` : ""}`)
+        );
+      }
+    });
+  }
+  onStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    let newlineIndex = this.stdoutBuffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+      if (line.length > 0) {
+        this.dispatch(line);
+      }
+      newlineIndex = this.stdoutBuffer.indexOf("\n");
+    }
+  }
+  dispatch(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const id = typeof message.id === "number" ? message.id : void 0;
+    if (id === void 0) {
+      return;
+    }
+    const pending = this.pending.get(id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    if (message.ok === true) {
+      pending.resolve(message.result ?? {});
+    } else {
+      pending.reject(new Error(typeof message.error === "string" ? message.error : "prowl-macdriver error"));
+    }
+  }
+  failAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+  recordTerminalFailure(error) {
+    this.terminalError ??= error;
+    this.closed = true;
+    this.failAll(this.terminalError);
+  }
+  /** Number of in-flight requests awaiting a response (for teardown/tests). */
+  get pendingCount() {
+    return this.pending.size;
+  }
+  request(cmd, params = {}) {
+    if (this.terminalError) {
+      return Promise.reject(this.terminalError);
+    }
+    if (this.closed) {
+      return Promise.reject(new Error("prowl-macdriver client is closed"));
+    }
+    const id = this.nextId++;
+    const payload = JSON.stringify({ id, cmd, ...params });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(id)) {
+          const shown = this.requestTimeoutMs >= 1e3 ? `${Math.round(this.requestTimeoutMs / 1e3)}s` : `${this.requestTimeoutMs}ms`;
+          reject(new Error(`prowl-macdriver request "${cmd}" timed out after ${shown}`));
+        }
+      }, this.requestTimeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { cmd, resolve, reject, timer });
+      this.child.stdin?.write(payload + "\n", (error) => {
+        if (error && this.pending.delete(id)) {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    try {
+      this.child.stdin?.write(JSON.stringify({ cmd: "shutdown" }) + "\n");
+      this.child.stdin?.end();
+    } catch {
+    }
+    await new Promise((resolve) => {
+      if (this.child.exitCode !== null || this.child.signalCode !== null) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.child.kill("SIGKILL");
+        resolve();
+      }, 2e3);
+      this.child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+    this.failAll(new Error("prowl-macdriver client is closed"));
+  }
+};
+async function launchMacSession(options) {
+  const requestTimeoutMs = Math.max(options.timeoutMs ?? 1e4, DEFAULT_REQUEST_TIMEOUT_MS) + 5e3;
+  const client = options.clientFactory ? options.clientFactory() : new SpawnMacHelperClient(resolveHelperBinary(), { requestTimeoutMs });
+  const timeoutSeconds = (options.timeoutMs ?? 1e4) / 1e3;
+  try {
+    const trust = await client.request("check");
+    if (trust.trusted !== true) {
+      throw new Error(
+        "Prowl's macOS target is not trusted for Accessibility. Grant the hosting terminal/app permission in System Settings \u2192 Privacy & Security \u2192 Accessibility, then retry."
+      );
+    }
+    const launched = await client.request("launch", { app: options.app, timeout: timeoutSeconds });
+    const bundleId = String(launched.bundleId ?? options.app);
+    const driver = createMacDriver(client, { appLabel: bundleId });
+    return { client, driver, bundleId };
+  } catch (error) {
+    await client.close().catch(() => void 0);
+    throw error;
+  }
+}
+async function closeMacSession(session) {
+  try {
+    await session.client.request("quit");
+  } catch {
+  } finally {
+    await session.client.close();
+  }
+}
+
 // src/runner/healing.ts
 var INTERACTIVE_TAGS = ["button", "a", "input", "select", "textarea"];
 function extractSelectorIntent(selector) {
@@ -411,12 +924,12 @@ function buildHealCandidates(selector) {
   }
   return candidates;
 }
-async function healSelector(page, selector, options) {
+async function healSelector(probe, selector, options) {
   if (!options.enabled) return null;
   for (const candidate of buildHealCandidates(selector)) {
     let count;
     try {
-      const locator = page.locator(candidate.selector);
+      const locator = probe.locator(candidate.selector);
       count = await locator.count();
     } catch {
       continue;
@@ -429,15 +942,15 @@ async function healSelector(page, selector, options) {
 }
 
 // src/runner/history.ts
-import fs from "fs";
-import path from "path";
+import fs3 from "fs";
+import path3 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);
+  return path3.join(configDir, HISTORY_FILE);
 }
 function isHistoryEntry(value) {
   if (!value || typeof value !== "object") {
@@ -448,11 +961,11 @@ function isHistoryEntry(value) {
 }
 function readHistory(configDir) {
   const filePath = historyPath(configDir);
-  if (!fs.existsSync(filePath)) {
+  if (!fs3.existsSync(filePath)) {
     return { entries: [] };
   }
   try {
-    const raw = fs.readFileSync(filePath, "utf-8");
+    const raw = fs3.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);
@@ -491,12 +1004,12 @@ function sleepSync(ms) {
 function withHistoryLock(configDir, fn) {
   const filePath = historyPath(configDir);
   const lockPath = `${filePath}${LOCK_FILE_SUFFIX}`;
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
   const startedAt = Date.now();
   while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
     let fd;
     try {
-      fd = fs.openSync(lockPath, "wx");
+      fd = fs3.openSync(lockPath, "wx");
     } catch (error) {
       if (error.code === "EEXIST") {
         sleepSync(LOCK_RETRY_MS);
@@ -508,10 +1021,10 @@ function withHistoryLock(configDir, fn) {
       return fn();
     } finally {
       try {
-        fs.closeSync(fd);
+        fs3.closeSync(fd);
       } catch {
       }
-      fs.rmSync(lockPath, { force: true });
+      fs3.rmSync(lockPath, { force: true });
     }
   }
   throw new Error(
@@ -524,159 +1037,338 @@ function appendEntry(configDir, entry, maxRuns) {
     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)}
+    fs3.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
 `);
-    fs.renameSync(tempPath, filePath);
+    fs3.renameSync(tempPath, filePath);
   });
 }
 
 // src/runner/index.ts
-import fs7 from "fs";
-import path7 from "path";
+import fs9 from "fs";
+import path9 from "path";
 
-// src/browser/controller.ts
-import fs2 from "fs";
-import path2 from "path";
-import { chromium, firefox, webkit } from "playwright";
+// src/browser/playwright-driver.ts
+import fs4 from "fs";
+import path4 from "path";
+import {
+  chromium,
+  firefox,
+  webkit
+} from "playwright";
 var ENGINES = { chromium, firefox, webkit };
 async function launchBrowser(options) {
-  const engine = ENGINES[options.engine ?? "chromium"];
+  const engineName = options.engine ?? "chromium";
+  const engine = Object.prototype.hasOwnProperty.call(ENGINES, engineName) ? ENGINES[engineName] : void 0;
+  if (!engine) {
+    throw new Error(
+      `Unsupported browser engine "${String(engineName)}". Available engines: ${Object.keys(ENGINES).join(", ")}.`
+    );
+  }
   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.`);
+  try {
+    const contextOptions = {};
+    if (options.viewport) {
+      contextOptions.viewport = options.viewport;
     }
+    if (options.storageStatePath) {
+      if (fs4.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: path4.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 = path4.join(options.runDir, "trace.zip");
+      await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
+    }
+    return { browser, context, page, tracePath };
+  } catch (error) {
+    try {
+      await browser.close();
+    } catch (closeError) {
+      console.warn(`Failed to close browser after setup error: ${formatError(closeError)}`);
+    }
+    throw error;
   }
-  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 });
+  try {
+    if (session.tracePath) {
+      await session.context.tracing.stop({ path: session.tracePath });
+    }
+    await session.context.close();
+  } finally {
+    await session.browser.close();
   }
-  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 saveStorageState(session, storageStatePath) {
+  await session.context.storageState({ path: storageStatePath });
 }
-async function pressKey(page, selector, key) {
-  await page.locator(selector).press(key);
+var ALL_CAPABILITIES = /* @__PURE__ */ new Set([
+  "navigate",
+  "query",
+  "interact",
+  "wait",
+  "screenshot",
+  "evaluate",
+  "response",
+  "route",
+  "dialog",
+  "files",
+  "download"
+]);
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
 }
-async function selectOption(page, selector, value) {
-  await page.locator(selector).selectOption(value);
+function unwrapTextSelector(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("text=")) {
+    return null;
+  }
+  const raw = trimmed.slice(5);
+  const first = raw[0];
+  if (first === '"' || first === "'") {
+    const unquoted = raw.slice(1);
+    return unquoted.endsWith(first) ? unquoted.slice(0, -1) : unquoted;
+  }
+  return raw;
 }
-function setupDialogHandler(page, action) {
-  page.once("dialog", async (dialog) => {
-    if (action === "accept") {
-      await dialog.accept();
-    } else {
-      await dialog.dismiss();
+function createPlaywrightDriver(page) {
+  return {
+    capabilities: ALL_CAPABILITIES,
+    async goto(url, options) {
+      if (options?.waitUntil !== void 0) {
+        await page.goto(url, { waitUntil: options.waitUntil });
+      } else {
+        await page.goto(url);
+      }
+    },
+    currentUrl() {
+      return page.url();
+    },
+    count(selector) {
+      return page.locator(selector).count();
+    },
+    textContent(selector) {
+      return page.locator(selector).textContent();
+    },
+    async click(selector) {
+      await page.locator(selector).click();
+    },
+    async clickFirst(selector) {
+      await page.locator(selector).first().click();
+    },
+    async fill(selector, value) {
+      await page.locator(selector).fill(value);
+    },
+    async fillFirst(selector, value) {
+      await page.locator(selector).first().fill(value);
+    },
+    async press(selector, key) {
+      await page.locator(selector).press(key);
+    },
+    async selectOption(selector, value) {
+      await page.locator(selector).selectOption(value);
+    },
+    async selectOptionFirst(selector, value) {
+      await page.locator(selector).first().selectOption(value);
+    },
+    async hover(selector) {
+      await page.locator(selector).hover();
+    },
+    async scrollIntoView(selector) {
+      await page.locator(selector).scrollIntoViewIfNeeded();
+    },
+    async setInputFiles(selector, files) {
+      await page.locator(selector).setInputFiles(files);
+    },
+    countByRole(role, name) {
+      return page.getByRole(role, { name }).count();
+    },
+    async clickFirstByRole(role, name) {
+      await page.getByRole(role, { name }).first().click();
+    },
+    countByLabel(label) {
+      return page.getByLabel(label, { exact: true }).count();
+    },
+    async fillFirstByLabel(label, value) {
+      await page.getByLabel(label, { exact: true }).first().fill(value);
+    },
+    async selectOptionFirstByLabel(label, value) {
+      await page.getByLabel(label, { exact: true }).first().selectOption(value);
+    },
+    async waitForSelector(selector, options) {
+      await page.waitForSelector(selector, { timeout: options?.timeout });
+    },
+    async waitForUrl(predicate, options) {
+      await page.waitForURL((url) => predicate(url.toString()), { timeout: options?.timeout });
+    },
+    async waitForNetworkIdle(options) {
+      await page.waitForLoadState("networkidle", { timeout: options?.timeout });
+    },
+    evaluate(pageFunction, arg) {
+      const raw = page.evaluate;
+      const result = arg === void 0 ? raw.call(page, pageFunction) : raw.call(page, pageFunction, arg);
+      return result;
+    },
+    async screenshot(options) {
+      await page.screenshot({ path: options.path, fullPage: options.fullPage });
+    },
+    onResponse(handler) {
+      page.on("response", handler);
+    },
+    async route(url, handler) {
+      await page.route(url, async (pwRoute) => {
+        try {
+          await handler({
+            fulfill: (response) => pwRoute.fulfill(response)
+          });
+        } catch (error) {
+          try {
+            await pwRoute.abort("failed");
+          } catch (abortError) {
+            throw new Error(
+              `Route handler failed for ${url}: ${formatError(error)}. Route abort also failed: ${formatError(abortError)}`
+            );
+          }
+          throw new Error(`Route handler failed for ${url}: ${formatError(error)}`);
+        }
+      });
+    },
+    async unroute(url) {
+      await page.unroute(url);
+    },
+    onDialog(action) {
+      page.once("dialog", (dialog) => {
+        const response = action === "accept" ? dialog.accept() : dialog.dismiss();
+        response.catch((error) => {
+          console.warn(`Failed to ${action} dialog: ${formatError(error)}`);
+        });
+      });
+    },
+    waitForDownloadEvent(options) {
+      return page.waitForEvent("download", { timeout: options?.timeout });
+    },
+    parseTextSelector(selector) {
+      return unwrapTextSelector(selector);
     }
-  });
-}
-async function setInputFiles(page, selector, files) {
-  await page.locator(selector).setInputFiles(files);
+  };
 }
 
 // src/runner/steps.ts
+import fs5 from "fs";
+import path5 from "path";
+
+// src/runner/policy.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;
+function createRunPolicy(driver, options) {
+  const { forbiddenSelectors, allowedDomains, maxSteps, selfHealing } = options;
+  const allowedApps = options.allowedApps ?? [];
+  function matchesForbiddenPattern(selector, forbidden) {
+    const selectorText = driver.parseTextSelector(selector);
+    if (selectorText === null) {
+      return false;
+    }
+    const forbiddenText = driver.parseTextSelector(forbidden);
+    if (forbiddenText !== null) {
+      return selectorText.includes(forbiddenText);
+    }
+    return selectorText.includes(forbidden);
   }
-  const forbiddenText = unwrapTextSelector(forbidden);
-  if (forbiddenText !== null) {
-    return selectorText.includes(forbiddenText);
+  function isForbiddenSelector(selector) {
+    return forbiddenSelectors.some(
+      (forbidden) => selector.includes(forbidden) || matchesForbiddenPattern(selector, forbidden)
+    );
   }
-  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}`);
+  function assertAllowedSelector(selector) {
+    if (isForbiddenSelector(selector)) {
+      throw new Error(`Forbidden selector: ${selector}`);
+    }
   }
-}
-async function resolveActionSelector(context, selector) {
-  assertAllowedSelector(selector, context.forbiddenSelectors);
-  if (!context.selfHealing) {
-    return { selector };
+  function assertWithinMaxSteps(stepCount, 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}.`);
+    }
   }
-  let matched = false;
-  try {
-    matched = await context.page.locator(selector).count() > 0;
-  } catch {
-    return { selector };
+  function ensureUrlAllowed(urlValue) {
+    for (const protocol of ALWAYS_ALLOWED_PROTOCOLS) {
+      if (urlValue.startsWith(protocol)) {
+        return;
+      }
+    }
+    let url;
+    try {
+      url = new URL(urlValue);
+    } catch {
+      throw new Error(`Navigation target is not a valid absolute URL: ${urlValue}`);
+    }
+    if (!allowedDomains.includes(url.hostname)) {
+      throw new Error(`Navigation to disallowed domain: ${url.hostname}`);
+    }
   }
-  if (matched) {
-    return { selector };
+  function ensureAppAllowed(app) {
+    if (!allowedApps.includes(app)) {
+      throw new Error(`Interaction with disallowed app: ${app}`);
+    }
   }
-  const healed = await healSelector(context.page, selector, { enabled: true });
-  if (!healed) {
-    return { selector };
+  function ensureLocationAllowed(activeDriver) {
+    if (activeDriver.capabilities.has("navigate")) {
+      ensureUrlAllowed(activeDriver.currentUrl());
+    }
   }
-  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}.`);
+  const healProbe = {
+    locator: (selector) => ({ count: () => driver.count(selector) })
+  };
+  async function resolveActionSelector(selector) {
+    assertAllowedSelector(selector);
+    if (!selfHealing) {
+      return { selector };
+    }
+    let matched = false;
+    try {
+      matched = await driver.count(selector) > 0;
+    } catch {
+      return { selector };
+    }
+    if (matched) {
+      return { selector };
     }
-    throw new Error(`Hunt has ${stepCount} steps. Max allowed is ${maxSteps}.`);
+    const healed = await healSelector(healProbe, selector, { enabled: true });
+    if (!healed) {
+      return { selector };
+    }
+    assertAllowedSelector(healed.selector);
+    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 };
   }
+  return {
+    assertWithinMaxSteps,
+    ensureUrlAllowed,
+    ensureAppAllowed,
+    ensureLocationAllowed,
+    assertAllowedSelector,
+    resolveActionSelector
+  };
 }
+
+// src/runner/steps.ts
 function getStepType(step) {
   if ("navigate" in step) return "navigate";
   if ("click" in step) return "click";
@@ -780,17 +1472,6 @@ function applyRuntimeVars(step, vars) {
 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();
@@ -817,56 +1498,50 @@ function getSinglePair(value, stepType) {
   }
   return entries[0];
 }
-async function clickByTextWithFallback(page, text, forbiddenSelectors) {
+async function clickByTextWithFallback(driver, policy, text) {
   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();
+  policy.assertAllowedSelector(roleSelector);
+  if (await driver.countByRole("button", text)) {
+    await driver.clickFirstByRole("button", text);
     return roleSelector;
   }
   const selector = exactTextSelector(text);
-  assertAllowedSelector(selector, forbiddenSelectors);
-  await page.locator(selector).first().click();
+  policy.assertAllowedSelector(selector);
+  await driver.clickFirst(selector);
   return selector;
 }
-async function fillByLabelOrPlaceholder(page, label, value, forbiddenSelectors) {
+async function fillByLabelOrPlaceholder(driver, policy, label, value) {
   const labelSelector = `label="${escapeForAttribute(label)}"`;
-  assertAllowedSelector(labelSelector, forbiddenSelectors);
-  const byLabel = page.getByLabel(label, { exact: true });
-  if (await byLabel.count()) {
-    await byLabel.first().fill(value);
+  policy.assertAllowedSelector(labelSelector);
+  if (await driver.countByLabel(label)) {
+    await driver.fillFirstByLabel(label, 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);
+  policy.assertAllowedSelector(placeholder);
+  if (await driver.count(placeholder)) {
+    await driver.fillFirst(placeholder, value);
     return placeholder;
   }
   throw new Error(`Could not resolve fill shorthand for "${label}"`);
 }
-async function selectByLabelOrFallback(page, label, value, forbiddenSelectors) {
+async function selectByLabelOrFallback(driver, policy, label, value) {
   const labelSelector = `label="${escapeForAttribute(label)}"`;
-  assertAllowedSelector(labelSelector, forbiddenSelectors);
-  const byLabel = page.getByLabel(label, { exact: true });
-  if (await byLabel.count()) {
-    await byLabel.first().selectOption(value);
+  policy.assertAllowedSelector(labelSelector);
+  if (await driver.countByLabel(label)) {
+    await driver.selectOptionFirstByLabel(label, 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);
+  policy.assertAllowedSelector(ariaSelector);
+  if (await driver.count(ariaSelector)) {
+    await driver.selectOptionFirst(ariaSelector, 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);
+  policy.assertAllowedSelector(placeholderSelector);
+  if (await driver.count(placeholderSelector)) {
+    await driver.selectOptionFirst(placeholderSelector, value);
     return placeholderSelector;
   }
   throw new Error(`Could not resolve select shorthand for "${label}"`);
@@ -994,11 +1669,11 @@ function toVisibilitySelector(value) {
   if (looksLikeSelector(value)) return value;
   return textContainsSelector(value);
 }
-async function runInlineAssert(page, assertion, forbiddenSelectors) {
+async function runInlineAssert(driver, policy, assertion) {
   if (assertion.visible !== void 0) {
     const selector = toVisibilitySelector(assertion.visible);
-    assertAllowedSelector(selector, forbiddenSelectors);
-    const count = await page.locator(selector).count();
+    policy.assertAllowedSelector(selector);
+    const count = await driver.count(selector);
     if (count === 0) {
       throw new Error(`Expected visible: ${assertion.visible}`);
     }
@@ -1006,22 +1681,22 @@ async function runInlineAssert(page, assertion, forbiddenSelectors) {
   }
   if (assertion.notVisible !== void 0) {
     const selector = toVisibilitySelector(assertion.notVisible);
-    assertAllowedSelector(selector, forbiddenSelectors);
-    const count = await page.locator(selector).count();
+    policy.assertAllowedSelector(selector);
+    const count = await driver.count(selector);
     if (count > 0) {
       throw new Error(`Expected not visible: ${assertion.notVisible}`);
     }
     return `notVisible:${assertion.notVisible}`;
   }
   if (assertion.urlIncludes !== void 0) {
-    const current = page.url();
+    const current = driver.currentUrl();
     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();
+    const current = driver.currentUrl();
     if (current !== assertion.urlEquals) {
       throw new Error(`URL did not equal ${assertion.urlEquals}`);
     }
@@ -1030,7 +1705,7 @@ async function runInlineAssert(page, assertion, forbiddenSelectors) {
   throw new Error("assert step is missing an assertion type");
 }
 function screenshotPath(screenshotsDir, fileName) {
-  return path3.join(screenshotsDir, fileName);
+  return path5.join(screenshotsDir, fileName);
 }
 function stepPath(prefix, index) {
   return prefix ? `${prefix}.${index}` : `${index}`;
@@ -1038,8 +1713,8 @@ function stepPath(prefix, index) {
 function isWaitForDownloadStep(step) {
   return step !== void 0 && "waitForDownload" in step;
 }
-function armDownloadListener(page, timeout) {
-  const downloadPromise = page.waitForEvent("download", { timeout });
+function armDownloadListener(driver, timeout) {
+  const downloadPromise = driver.waitForDownloadEvent({ timeout });
   void downloadPromise.catch(() => void 0);
   return downloadPromise;
 }
@@ -1047,14 +1722,14 @@ 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)) {
+  if (safeFilename.length === 0 || safeFilename !== suggestedFilename || safeFilename !== path5.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
     throw new Error(`Invalid download filename: "${suggestedFilename}"`);
   }
   return safeFilename;
 }
-async function captureScreenshot(page, filePath) {
+async function captureScreenshot(taker, filePath) {
   try {
-    await page.screenshot({ path: filePath, fullPage: true });
+    await taker.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}`);
@@ -1073,608 +1748,784 @@ async function executeNestedSteps(context, overrides) {
   }
   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
-      );
+function unknownStep() {
+  throw new Error("Unknown step type");
+}
+var STEP_HANDLERS = {
+  navigate: {
+    capabilities: ["navigate"],
+    run: async (h) => {
+      if (!("navigate" in h.step)) unknownStep();
+      const destination = resolveNavigationTarget(h.context.targetUrl, h.step.navigate);
+      h.policy.ensureUrlAllowed(destination);
+      await h.driver.goto(destination);
+      h.policy.ensureLocationAllowed(h.driver);
+      return { kind: "result", result: { type: "navigate", status: "pass", durationMs: Date.now() - h.stepStart } };
     }
-    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 = {
+  },
+  click: {
+    capabilities: ["interact", "query"],
+    run: async (h) => {
+      if (!("click" in h.step)) unknownStep();
+      let selector;
+      let healedFrom;
+      if (typeof h.step.click === "string") {
+        selector = await clickByTextWithFallback(h.driver, h.policy, h.step.click);
+      } else {
+        const resolved = await h.policy.resolveActionSelector(h.step.click.selector);
+        await h.driver.click(resolved.selector);
+        selector = resolved.selector;
+        healedFrom = resolved.healedFrom;
+      }
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "click",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.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 = {
+      };
+    }
+  },
+  fill: {
+    capabilities: ["interact", "query"],
+    run: async (h) => {
+      if (!("fill" in h.step)) unknownStep();
+      let selector;
+      let value;
+      let healedFrom;
+      if (isExplicitFillStep(h.step.fill)) {
+        const resolved = await h.policy.resolveActionSelector(h.step.fill.selector);
+        await h.driver.fill(resolved.selector, h.step.fill.value);
+        selector = resolved.selector;
+        healedFrom = resolved.healedFrom;
+        value = h.step.fill.value;
+      } else {
+        const [label, shorthandValue] = getSinglePair(h.step.fill, "fill");
+        selector = await fillByLabelOrPlaceholder(h.driver, h.policy, label, shorthandValue);
+        value = shorthandValue;
+      }
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "fill",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.stepStart,
           selector,
-          value: context.redactedFillSteps.has(currentStepPath) ? "[REDACTED]" : value,
+          value: h.context.redactedFillSteps.has(h.stepPath) ? "[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: {
+    capabilities: ["interact"],
+    run: async (h) => {
+      if (!("type" in h.step)) unknownStep();
+      h.policy.assertAllowedSelector(":focus");
+      await h.driver.fill(":focus", h.step.type);
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "type",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.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 = {
+          value: h.context.redactedFillSteps.has(h.stepPath) ? "[REDACTED]" : h.step.type
+        }
+      };
+    }
+  },
+  selectOption: {
+    capabilities: ["navigate", "interact", "query"],
+    run: async (h) => {
+      if (!("selectOption" in h.step)) unknownStep();
+      const resolved = await h.policy.resolveActionSelector(h.step.selectOption.selector);
+      await h.driver.selectOption(resolved.selector, h.step.selectOption.value);
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "selectOption",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.stepStart,
           selector: resolved.selector,
-          value: step.selectOption.value,
+          value: h.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 = {
+        }
+      };
+    }
+  },
+  select: {
+    capabilities: ["navigate", "interact", "query"],
+    run: async (h) => {
+      if (!("select" in h.step)) unknownStep();
+      const [label, value] = getSinglePair(h.step.select, "select");
+      const selector = await selectByLabelOrFallback(h.driver, h.policy, label, value);
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "select",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.stepStart,
           selector,
           value
-        };
-      } else if ("onDialog" in step) {
-        setupDialogHandler(context.page, step.onDialog.action);
-        stepResult = {
+        }
+      };
+    }
+  },
+  onDialog: {
+    capabilities: ["dialog"],
+    run: async (h) => {
+      if (!("onDialog" in h.step)) unknownStep();
+      h.driver.onDialog(h.step.onDialog.action);
+      return {
+        kind: "result",
+        result: {
           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 = {
+          durationMs: Date.now() - h.stepStart,
+          value: h.step.onDialog.action
+        }
+      };
+    }
+  },
+  setInputFiles: {
+    capabilities: ["navigate", "interact", "query", "files"],
+    run: async (h) => {
+      if (!("setInputFiles" in h.step)) unknownStep();
+      const resolvedInput = await h.policy.resolveActionSelector(h.step.setInputFiles.selector);
+      const rawFiles = h.step.setInputFiles.files;
+      const resolveFile = (f) => path5.isAbsolute(f) ? f : path5.join(h.context.configDir, f);
+      const resolvedFiles = Array.isArray(rawFiles) ? rawFiles.map(resolveFile) : resolveFile(rawFiles);
+      await h.driver.setInputFiles(resolvedInput.selector, resolvedFiles);
+      h.policy.ensureLocationAllowed(h.driver);
+      const filesLabel = Array.isArray(rawFiles) ? rawFiles.join(", ") : rawFiles;
+      return {
+        kind: "result",
+        result: {
           type: "setInputFiles",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.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 = {
+      };
+    }
+  },
+  runHunt: {
+    capabilities: [],
+    run: async (h) => {
+      if (!("runHunt" in h.step)) unknownStep();
+      const huntName = typeof h.step.runHunt === "string" ? h.step.runHunt : h.step.runHunt.name;
+      const overrideVars = typeof h.step.runHunt === "string" ? void 0 : h.step.runHunt.vars;
+      const stack = h.context.huntStack ?? [];
+      if (stack.includes(huntName)) {
+        throw new Error(`Circular hunt dependency: ${[...stack, huntName].join(" \u2192 ")}`);
+      }
+      const subHunt = loadHunt(huntName, h.context.configDir);
+      if (overrideVars) {
+        subHunt.vars = { ...subHunt.vars, ...overrideVars };
+      }
+      const {
+        hunt: interpolatedSubHunt,
+        redactedFillSteps: subRedacted,
+        randomVars
+      } = interpolateHunt(subHunt, process.env, h.context.randomVars);
+      const subTargetType = h.driver.capabilities.has("navigate") ? "web" : "macos";
+      assertStepsSupportedByTarget(interpolatedSubHunt.steps, subTargetType);
+      assertHuntAssertionsSupportedByTarget(interpolatedSubHunt.assertions, subTargetType);
+      h.policy.assertWithinMaxSteps(interpolatedSubHunt.steps.length, huntName);
+      const subResult = await h.executeNested({
+        steps: interpolatedSubHunt.steps,
+        redactedFillSteps: subRedacted,
+        randomVars,
+        stepPathPrefix: void 0,
+        huntStack: [...stack, huntName],
+        onStep: h.context.onStep
+      });
+      for (const sr of subResult.results) {
+        h.results.push({ ...sr, type: `${huntName} > ${sr.type}` });
+      }
+      h.screenshots.push(...subResult.screenshots);
+      if (subResult.failed) {
+        return { kind: "abort", error: `Sub-hunt "${huntName}" failed: ${subResult.error}` };
+      }
+      return {
+        kind: "result",
+        result: { type: "runHunt", status: "pass", durationMs: Date.now() - h.stepStart, value: huntName }
+      };
+    }
+  },
+  press: {
+    capabilities: ["interact", "query"],
+    run: async (h) => {
+      if (!("press" in h.step)) unknownStep();
+      const resolved = await h.policy.resolveActionSelector(h.step.press.selector);
+      await h.driver.press(resolved.selector, h.step.press.key);
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "press",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.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 = {
+        }
+      };
+    }
+  },
+  assert: {
+    capabilities: ["query"],
+    run: async (h) => {
+      if (!("assert" in h.step)) unknownStep();
+      const value = await runInlineAssert(h.driver, h.policy, h.step.assert);
+      return {
+        kind: "result",
+        result: { type: "assert", status: "pass", durationMs: Date.now() - h.stepStart, value }
+      };
+    }
+  },
+  wait: {
+    capabilities: ["wait"],
+    run: async (h) => {
+      if (!("wait" in h.step)) unknownStep();
+      const text = typeof h.step.wait === "string" ? h.step.wait : h.step.wait.for;
+      const timeout = typeof h.step.wait === "string" ? void 0 : h.step.wait.timeout;
+      const selector = `text=${escapeForText(text)}`;
+      h.policy.assertAllowedSelector(selector);
+      await h.driver.waitForSelector(selector, { timeout });
+      return {
+        kind: "result",
+        result: { type: "wait", status: "pass", durationMs: Date.now() - h.stepStart, selector }
+      };
+    }
+  },
+  waitForSelector: {
+    capabilities: ["wait"],
+    run: async (h) => {
+      if (!("waitForSelector" in h.step)) unknownStep();
+      h.policy.assertAllowedSelector(h.step.waitForSelector.selector);
+      await h.driver.waitForSelector(h.step.waitForSelector.selector, {
+        timeout: h.step.waitForSelector.timeout
+      });
+      return {
+        kind: "result",
+        result: {
           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 = {
+          durationMs: Date.now() - h.stepStart,
+          selector: h.step.waitForSelector.selector
+        }
+      };
+    }
+  },
+  waitForUrl: {
+    capabilities: ["navigate", "wait"],
+    run: async (h) => {
+      if (!("waitForUrl" in h.step)) unknownStep();
+      const value = h.step.waitForUrl.value;
+      await h.driver.waitForUrl((url) => url.includes(value), { timeout: h.step.waitForUrl.timeout });
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: { type: "waitForUrl", status: "pass", durationMs: Date.now() - h.stepStart, value }
+      };
+    }
+  },
+  waitForNetworkIdle: {
+    capabilities: ["wait"],
+    run: async (h) => {
+      if (!("waitForNetworkIdle" in h.step)) unknownStep();
+      await h.driver.waitForNetworkIdle({ timeout: h.step.waitForNetworkIdle.timeout });
+      return {
+        kind: "result",
+        result: { type: "waitForNetworkIdle", status: "pass", durationMs: Date.now() - h.stepStart }
+      };
+    }
+  },
+  hover: {
+    capabilities: ["interact", "query"],
+    run: async (h) => {
+      if (!("hover" in h.step)) unknownStep();
+      const resolved = await h.policy.resolveActionSelector(h.step.hover.selector);
+      await h.driver.hover(resolved.selector);
+      h.policy.ensureLocationAllowed(h.driver);
+      return {
+        kind: "result",
+        result: {
           type: "hover",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.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 = {
+        }
+      };
+    }
+  },
+  scroll: {
+    capabilities: ["evaluate"],
+    run: async (h) => {
+      if (!("scroll" in h.step)) unknownStep();
+      const amount = h.step.scroll.amount ?? 500;
+      const scrollMap = {
+        up: [0, -amount],
+        down: [0, amount],
+        left: [-amount, 0],
+        right: [amount, 0]
+      };
+      const [x, y] = scrollMap[h.step.scroll.direction];
+      await h.driver.evaluate(([sx, sy]) => window.scrollBy(sx, sy), [x, y]);
+      return {
+        kind: "result",
+        result: {
           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 = {
+          durationMs: Date.now() - h.stepStart,
+          value: `${h.step.scroll.direction} ${amount}px`
+        }
+      };
+    }
+  },
+  scrollTo: {
+    capabilities: ["interact", "query"],
+    run: async (h) => {
+      if (!("scrollTo" in h.step)) unknownStep();
+      const resolved = await h.policy.resolveActionSelector(h.step.scrollTo.selector);
+      await h.driver.scrollIntoView(resolved.selector);
+      return {
+        kind: "result",
+        result: {
           type: "scrollTo",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.stepStart,
           selector: resolved.selector,
           ...resolved.healedFrom ? { healedFrom: resolved.healedFrom } : {}
+        }
+      };
+    }
+  },
+  screenshot: {
+    capabilities: ["screenshot"],
+    run: async (h) => {
+      if (!("screenshot" in h.step)) unknownStep();
+      const name = h.step.screenshot.name ?? `manual_step_${h.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 h.addScreenshot(fileName);
+      return {
+        kind: "result",
+        result: { type: "screenshot", status: "pass", durationMs: Date.now() - h.stepStart, screenshot: relative }
+      };
+    }
+  },
+  if: {
+    capabilities: ["query"],
+    run: async (h) => {
+      if (!("if" in h.step)) unknownStep();
+      const condition = h.step.if;
+      const selector = condition.visible ?? condition.notVisible;
+      h.policy.assertAllowedSelector(selector);
+      const count = await h.driver.count(selector);
+      const conditionMet = condition.visible !== void 0 ? count > 0 : count === 0;
+      if (conditionMet) {
+        const subResult = await h.executeNested({
+          steps: condition.then,
+          stepPathPrefix: `${h.stepPath}.if.then`
+        });
+        for (const sr of subResult.results) {
+          h.results.push({ ...sr, type: `if > ${sr.type}` });
+        }
+        h.screenshots.push(...subResult.screenshots);
+        if (subResult.failed) {
+          return { kind: "abort", error: subResult.error };
+        }
+        return {
+          kind: "result",
+          result: {
+            type: "if",
+            status: "pass",
+            durationMs: Date.now() - h.stepStart,
+            value: `condition met, executed ${condition.then.length} steps`
+          }
         };
-      } 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 ".."`);
+      }
+      if (condition.else && condition.else.length > 0) {
+        const subResult = await h.executeNested({
+          steps: condition.else,
+          stepPathPrefix: `${h.stepPath}.if.else`
+        });
+        for (const sr of subResult.results) {
+          h.results.push({ ...sr, type: `if > ${sr.type}` });
         }
-        const fileName = name.endsWith(".png") ? name : `${name}.png`;
-        const relative = await addScreenshot(fileName);
-        stepResult = {
-          type: "screenshot",
-          status: "pass",
-          durationMs: Date.now() - stepStart,
-          screenshot: relative
+        h.screenshots.push(...subResult.screenshots);
+        if (subResult.failed) {
+          return { kind: "abort", error: subResult.error };
+        }
+        return {
+          kind: "result",
+          result: {
+            type: "if",
+            status: "pass",
+            durationMs: Date.now() - h.stepStart,
+            value: `condition not met, executed ${condition.else.length} else steps`
+          }
         };
-      } 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`
+      }
+      return {
+        kind: "result",
+        result: {
+          type: "if",
+          status: "pass",
+          durationMs: Date.now() - h.stepStart,
+          value: "condition not met, skipped"
+        }
+      };
+    }
+  },
+  repeat: {
+    capabilities: ["query"],
+    run: async (h) => {
+      if (!("repeat" in h.step)) unknownStep();
+      const repeat = h.step.repeat;
+      let totalSubSteps = 0;
+      if (repeat.times !== void 0) {
+        const totalPlanned = repeat.times * repeat.steps.length;
+        if (totalPlanned + totalSubSteps > h.context.maxSteps) {
+          throw new Error(`Repeat exceeded maxSteps guardrail (${h.context.maxSteps})`);
+        }
+        for (let i = 0; i < repeat.times; i++) {
+          totalSubSteps += repeat.steps.length;
+          const subResult = await h.executeNested({
+            steps: repeat.steps,
+            stepPathPrefix: `${h.stepPath}.repeat.steps`
           });
           for (const sr of subResult.results) {
-            results.push({ ...sr, type: `if > ${sr.type}` });
+            h.results.push({ ...sr, type: `repeat[${i}] > ${sr.type}` });
           }
-          screenshots.push(...subResult.screenshots);
+          h.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"
-            };
+            return { kind: "abort", error: subResult.error };
           }
         }
-      } 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})`);
+      } else if (repeat.while !== void 0) {
+        const maxIter = repeat.maxIterations;
+        const whileSelector = repeat.while.visible ?? repeat.while.notVisible;
+        h.policy.assertAllowedSelector(whileSelector);
+        for (let i = 0; i < maxIter; i++) {
+          const whileCount = await h.driver.count(whileSelector);
+          const shouldContinue = repeat.while.visible !== void 0 ? whileCount > 0 : whileCount === 0;
+          if (!shouldContinue) break;
+          totalSubSteps += repeat.steps.length;
+          if (totalSubSteps > h.context.maxSteps) {
+            throw new Error(`Repeat exceeded maxSteps guardrail (${h.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 subResult = await h.executeNested({
+            steps: repeat.steps,
+            stepPathPrefix: `${h.stepPath}.repeat.steps`
+          });
+          for (const sr of subResult.results) {
+            h.results.push({ ...sr, type: `repeat[${i}] > ${sr.type}` });
           }
-          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");
+          h.screenshots.push(...subResult.screenshots);
+          if (subResult.failed) {
+            return { kind: "abort", error: subResult.error };
           }
-          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}`);
+      }
+      return {
+        kind: "result",
+        result: { type: "repeat", status: "pass", durationMs: Date.now() - h.stepStart }
+      };
+    }
+  },
+  mockRoute: {
+    capabilities: ["route"],
+    run: async (h) => {
+      if (!("mockRoute" in h.step)) unknownStep();
+      const mock = h.step.mockRoute;
+      const mocks = h.context.activeMocks ?? /* @__PURE__ */ new Map();
+      h.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 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);
+        const candidateFilePath = path5.isAbsolute(responseFile) ? responseFile : path5.join(h.context.configDir, responseFile);
+        const resolvedConfigDir = path5.resolve(h.context.configDir);
+        const resolvedFilePath = path5.resolve(candidateFilePath);
+        const relativePath = path5.relative(resolvedConfigDir, resolvedFilePath);
+        const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${path5.sep}`) && !path5.isAbsolute(relativePath);
+        if (!isWithinConfigDir) {
+          throw new Error("mock.response.file must resolve within config directory");
         }
-        stepResult = {
+        responseBody = await fs5.promises.readFile(resolvedFilePath, "utf-8");
+      }
+      const contentType = mock.response.contentType ?? "application/json";
+      const status = mock.response.status;
+      await h.driver.route(mock.url, async (route) => {
+        await route.fulfill({
+          status,
+          contentType,
+          body: responseBody
+        });
+      });
+      mocks.set(mock.url, async () => {
+        await h.driver.unroute(mock.url);
+      });
+      return {
+        kind: "result",
+        result: { type: "mockRoute", status: "pass", durationMs: Date.now() - h.stepStart, value: mock.url }
+      };
+    }
+  },
+  unmockRoute: {
+    capabilities: ["route"],
+    run: async (h) => {
+      if (!("unmockRoute" in h.step)) unknownStep();
+      const url = typeof h.step.unmockRoute === "string" ? h.step.unmockRoute : h.step.unmockRoute.url;
+      const mocks = h.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);
+      return {
+        kind: "result",
+        result: { type: "unmockRoute", status: "pass", durationMs: Date.now() - h.stepStart, value: url }
+      };
+    }
+  },
+  evalScript: {
+    capabilities: ["evaluate"],
+    run: async (h) => {
+      if (!("evalScript" in h.step)) unknownStep();
+      const expression = typeof h.step.evalScript === "string" ? h.step.evalScript : h.step.evalScript.expression;
+      const result = await h.driver.evaluate(expression);
+      const resultStr = String(result);
+      if (typeof h.step.evalScript !== "string" && h.step.evalScript.as) {
+        h.runtimeVars.set(h.step.evalScript.as, resultStr);
+      }
+      return {
+        kind: "result",
+        result: {
           type: "evalScript",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.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 = {
+        }
+      };
+    }
+  },
+  runScript: {
+    capabilities: ["evaluate"],
+    run: async (h) => {
+      if (!("runScript" in h.step)) unknownStep();
+      const filePath = path5.isAbsolute(h.step.runScript.file) ? h.step.runScript.file : path5.join(h.context.configDir, h.step.runScript.file);
+      const fileContents = fs5.readFileSync(filePath, "utf-8");
+      await h.driver.evaluate(fileContents);
+      return {
+        kind: "result",
+        result: {
           type: "runScript",
           status: "pass",
-          durationMs: Date.now() - stepStart,
-          value: step.runScript.file
+          durationMs: Date.now() - h.stepStart,
+          value: h.step.runScript.file
+        }
+      };
+    }
+  },
+  assertScreenshot: {
+    capabilities: ["screenshot"],
+    run: async (h) => {
+      if (!("assertScreenshot" in h.step)) unknownStep();
+      const { compareScreenshots, ensureBaselineDir } = await import("./visual-FSARM2JS.js");
+      const name = h.step.assertScreenshot.name;
+      const threshold = h.step.assertScreenshot.threshold ?? 0.1;
+      const baselineDir = ensureBaselineDir(h.context.configDir);
+      const baselinePath = path5.join(baselineDir, `${name}.png`);
+      const currentScreenshotPath = path5.join(h.context.runDir, "screenshots", `${name}-current.png`);
+      fs5.mkdirSync(path5.dirname(currentScreenshotPath), { recursive: true });
+      await h.driver.screenshot({ path: currentScreenshotPath, fullPage: true });
+      h.screenshots.push(path5.join("screenshots", `${name}-current.png`));
+      if (!fs5.existsSync(baselinePath)) {
+        fs5.copyFileSync(currentScreenshotPath, baselinePath);
+        return {
+          kind: "result",
+          result: { type: "assertScreenshot", status: "pass", durationMs: Date.now() - h.stepStart, value: "baseline created" }
         };
-      } 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 = {
+      }
+      const diffPath = path5.join(h.context.runDir, "screenshots", `${name}-diff.png`);
+      const comparison = await compareScreenshots(baselinePath, currentScreenshotPath, diffPath, threshold);
+      if (comparison.match) {
+        return {
+          kind: "result",
+          result: {
             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)}%`
-            );
+            durationMs: Date.now() - h.stepStart,
+            value: `diff: ${(comparison.diffPercentage * 100).toFixed(2)}%`
           }
-        }
-      } 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 = {
+        };
+      }
+      h.screenshots.push(path5.join("screenshots", `${name}-diff.png`));
+      throw new Error(
+        `Visual regression: ${(comparison.diffPercentage * 100).toFixed(2)}% diff exceeds threshold ${(threshold * 100).toFixed(0)}%`
+      );
+    }
+  },
+  copyText: {
+    capabilities: ["query"],
+    run: async (h) => {
+      if (!("copyText" in h.step)) unknownStep();
+      h.policy.assertAllowedSelector(h.step.copyText.selector);
+      const text = await h.driver.textContent(h.step.copyText.selector);
+      if (text === null) {
+        throw new Error(`No text content found for selector: ${h.step.copyText.selector}`);
+      }
+      h.runtimeVars.set(h.step.copyText.as, text);
+      return {
+        kind: "result",
+        result: {
           type: "copyText",
           status: "pass",
-          durationMs: Date.now() - stepStart,
-          selector: step.copyText.selector,
+          durationMs: Date.now() - h.stepStart,
+          selector: h.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 = {
+      };
+    }
+  },
+  waitForDownload: {
+    capabilities: ["download"],
+    run: async (h) => {
+      if (!("waitForDownload" in h.step)) unknownStep();
+      const opts = h.step.waitForDownload;
+      const downloadPromise = h.context.pendingDownload ?? armDownloadListener(h.driver, opts?.timeout ?? 3e4);
+      h.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 = path5.join(h.context.runDir, suggestedFilename);
+      await download.saveAs(savePath);
+      return {
+        kind: "result",
+        result: {
           type: "waitForDownload",
           status: "pass",
-          durationMs: Date.now() - stepStart,
+          durationMs: Date.now() - h.stepStart,
           value: suggestedFilename
-        };
-      }
-      if (!stepResult) {
+        }
+      };
+    }
+  }
+};
+async function executeSteps(context) {
+  let driver = context.driver;
+  if (!driver) {
+    if (!context.page) {
+      throw new Error("executeSteps requires a driver or a Playwright page");
+    }
+    driver = createPlaywrightDriver(context.page);
+  }
+  const policy = createRunPolicy(driver, {
+    forbiddenSelectors: context.forbiddenSelectors,
+    allowedDomains: context.allowedDomains,
+    allowedApps: context.allowedApps,
+    maxSteps: context.maxSteps,
+    selfHealing: context.selfHealing
+  });
+  const screenshotsDir = path5.join(context.runDir, "screenshots");
+  fs5.mkdirSync(screenshotsDir, { recursive: true });
+  const currentHuntName = context.huntStack?.[context.huntStack.length - 1];
+  policy.assertWithinMaxSteps(context.steps.length, 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(driver, fullPath);
+    const relative = path5.join("screenshots", fileName);
+    screenshots.push(relative);
+    return relative;
+  };
+  const executeNested = (overrides) => executeNestedSteps(context, { driver, ...overrides });
+  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(
+        driver,
+        nextStep.waitForDownload?.timeout ?? 3e4
+      );
+    }
+    const stepStart = Date.now();
+    const stepType = getStepType(step);
+    let stepResult = null;
+    try {
+      const handler = STEP_HANDLERS[stepType];
+      if (!handler) {
         throw new Error("Unknown step type");
       }
+      for (const capability of handler.capabilities) {
+        if (!driver.capabilities.has(capability)) {
+          throw new Error(
+            `Driver does not support capability "${capability}" required by step "${stepType}"`
+          );
+        }
+      }
+      const outcome = await handler.run({
+        driver,
+        policy,
+        context,
+        step,
+        index,
+        stepPath: currentStepPath,
+        stepStart,
+        runtimeVars,
+        results,
+        screenshots,
+        addScreenshot,
+        executeNested
+      });
+      if (outcome.kind === "abort") {
+        return { results, screenshots, failed: true, error: outcome.error };
+      }
+      stepResult = outcome.result;
       if (context.screenshotsMode === "all" && stepResult.type !== "screenshot") {
         const fileName = `step_${index + 1}.png`;
         await addScreenshot(fileName);
@@ -1701,12 +2552,12 @@ async function executeSteps(context) {
   return { results, screenshots, failed: false };
 }
 async function captureFinalScreenshot(page, runDir) {
-  const screenshotsDir = path3.join(runDir, "screenshots");
-  fs3.mkdirSync(screenshotsDir, { recursive: true });
+  const screenshotsDir = path5.join(runDir, "screenshots");
+  fs5.mkdirSync(screenshotsDir, { recursive: true });
   const fileName = "final.png";
   const filePath = screenshotPath(screenshotsDir, fileName);
   await captureScreenshot(page, filePath);
-  return path3.join("screenshots", fileName);
+  return path5.join("screenshots", fileName);
 }
 
 // src/runner/assertions.ts
@@ -1866,18 +2717,18 @@ function captureTraceCorrelation(response, headerName, sink, redactionValues = [
 }
 
 // src/reporter/result.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs6 from "fs";
+import path6 from "path";
 function writeResult(runDir, result) {
   const fileName = "result.json";
-  const fullPath = path4.join(runDir, fileName);
-  fs4.writeFileSync(fullPath, JSON.stringify(result, null, 2));
+  const fullPath = path6.join(runDir, fileName);
+  fs6.writeFileSync(fullPath, JSON.stringify(result, null, 2));
   return fileName;
 }
 
 // src/reporter/summary.ts
-import fs5 from "fs";
-import path5 from "path";
+import fs7 from "fs";
+import path7 from "path";
 function escapeMd(text) {
   return text.replace(/([|`*_{}[\]()#+\-!\\])/g, "\\$1");
 }
@@ -1955,15 +2806,15 @@ function writeSummary(runDir, result) {
     }
   }
   const fileName = "summary.md";
-  const fullPath = path5.join(runDir, fileName);
-  fs5.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = path7.join(runDir, fileName);
+  fs7.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
 
 // src/reporter/junit.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs8 from "fs";
+import path8 from "path";
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -2007,8 +2858,8 @@ function writeJunit(runDir, result) {
   lines.push("  </testsuite>");
   lines.push("</testsuites>");
   const fileName = "junit.xml";
-  const fullPath = path6.join(runDir, fileName);
-  fs6.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = path8.join(runDir, fileName);
+  fs8.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -2050,11 +2901,11 @@ function parseViewportFlag(value) {
   return value;
 }
 function resolvePath(configDir, inputPath) {
-  if (path7.isAbsolute(inputPath)) {
+  if (path9.isAbsolute(inputPath)) {
     return inputPath;
   }
-  const projectRoot = path7.dirname(configDir);
-  return path7.join(projectRoot, inputPath);
+  const projectRoot = path9.dirname(configDir);
+  return path9.join(projectRoot, inputPath);
 }
 function buildRunResult(options) {
   return {
@@ -2073,12 +2924,12 @@ function buildRunResult(options) {
 }
 function writeConsoleLog(runDir, entries) {
   const fileName = "console.log";
-  const filePath = path7.join(runDir, fileName);
+  const filePath = path9.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")}
+  fs9.writeFileSync(filePath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -2086,8 +2937,8 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
   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 runDir = path9.join(configDir, "runs", timestamp());
+  fs9.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;
@@ -2106,6 +2957,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
   });
   let result;
   try {
+    const driver = createPlaywrightDriver(session.page);
     const consoleEntries = [];
     const networkEntries = [];
     const traceCorrelations = [];
@@ -2117,7 +2969,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
         location: message.location().url
       });
     });
-    session.page.on("response", (response) => {
+    driver.onResponse((response) => {
       if (response.status() >= 400) {
         networkEntries.push({ url: response.url(), status: response.status() });
         captureTraceCorrelation(response, traceHeader, traceCorrelations, redactionValues);
@@ -2131,6 +2983,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
     try {
       const stepExecution = await executeSteps({
         page: session.page,
+        driver,
         steps: interpolatedHunt.steps,
         targetUrl,
         runDir,
@@ -2163,7 +3016,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
     }
     let finalScreenshot;
     try {
-      finalScreenshot = await captureFinalScreenshot(session.page, runDir);
+      finalScreenshot = await captureFinalScreenshot(driver, runDir);
     } catch {
       finalScreenshot = void 0;
     }
@@ -2207,6 +3060,9 @@ function delay(ms) {
 }
 async function runHunt(options) {
   const { config, configDir } = loadConfig(options.configPath);
+  if (config.target.type === "macos") {
+    return runMacHunt(options, config, configDir, config.target);
+  }
   const hunt = loadHunt(options.huntName, configDir);
   const {
     hunt: interpolatedHunt,
@@ -2257,9 +3113,124 @@ async function runHunt(options) {
   }
   return lastResult;
 }
+async function executeMacHuntAttempt(options, config, configDir, target, interpolatedHunt, redactedFillSteps, randomVars, allowedApps) {
+  const maxSteps = config.guardrails.maxSteps;
+  const runDir = path9.join(configDir, "runs", timestamp());
+  fs9.mkdirSync(runDir, { recursive: true });
+  const session = await launchMacSession({
+    app: target.app,
+    timeoutMs: config.browser.timeout,
+    clientFactory: options.macClientFactory
+  });
+  let result;
+  try {
+    const targetLabel = `macos:${session.bundleId}`;
+    const effectiveAllowedApps = [.../* @__PURE__ */ new Set([...allowedApps, target.app, session.bundleId])];
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const startTime = Date.now();
+    let stepResults = [];
+    let stepScreenshots = [];
+    let stepFailed = false;
+    try {
+      const stepExecution = await executeSteps({
+        driver: session.driver,
+        steps: interpolatedHunt.steps,
+        targetUrl: targetLabel,
+        runDir,
+        screenshotsMode: config.artifacts.screenshots,
+        forbiddenSelectors: config.guardrails.forbiddenSelectors,
+        allowedDomains: [],
+        allowedApps: effectiveAllowedApps,
+        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.driver, runDir);
+    } catch {
+      finalScreenshot = void 0;
+    }
+    const durationMs = Date.now() - startTime;
+    const status = stepFailed ? "fail" : "pass";
+    const artifacts = {
+      screenshots: finalScreenshot ? [...stepScreenshots, finalScreenshot] : stepScreenshots
+    };
+    const runResult = buildRunResult({
+      status,
+      startedAt,
+      durationMs,
+      hunt: options.huntName,
+      targetUrl: targetLabel,
+      steps: stepResults,
+      assertions: [],
+      artifacts
+    });
+    result = writeReports(runDir, runResult, { junit: options.junit ?? config.artifacts.junit });
+  } finally {
+    await closeMacSession(session);
+  }
+  return { result, runDir, steps: interpolatedHunt.steps };
+}
+async function runMacHunt(options, config, configDir, target) {
+  const hunt = loadHunt(options.huntName, configDir);
+  const { hunt: interpolatedHunt, redactedFillSteps, randomVars } = interpolateHunt(hunt, process.env);
+  assertStepsSupportedByTarget(interpolatedHunt.steps, "macos");
+  assertHuntAssertionsSupportedByTarget(interpolatedHunt.assertions, "macos");
+  assertTargetAppAllowed(config.guardrails.allowedApps, target.app);
+  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 executeMacHuntAttempt(
+      options,
+      config,
+      configDir,
+      target,
+      interpolatedHunt,
+      redactedFillSteps,
+      randomVars,
+      config.guardrails.allowedApps
+    );
+    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);
+    const relativeRunDir = path9.relative(configDir, outcome.runDir);
     appendEntry(
       configDir,
       {
@@ -2380,8 +3351,8 @@ function clusterFailures(failures) {
 }
 
 // src/backlog/index.ts
-import fs8 from "fs";
-import path8 from "path";
+import fs10 from "fs";
+import path10 from "path";
 
 // src/backlog/parse.ts
 var MARKER_FP = /<!--\s*prowl:fp=([0-9a-f]+)/;
@@ -2471,7 +3442,7 @@ ${after}`;
 // src/backlog/index.ts
 function readFileOrEmpty(filePath) {
   try {
-    return fs8.readFileSync(filePath, "utf-8");
+    return fs10.readFileSync(filePath, "utf-8");
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") return "";
@@ -2487,7 +3458,7 @@ function buildFailure(hunt) {
   if (!hunt.runDir) return failure;
   let run;
   try {
-    const resultJson = readFileOrEmpty(path8.join(hunt.runDir, "result.json"));
+    const resultJson = readFileOrEmpty(path10.join(hunt.runDir, "result.json"));
     if (!resultJson) return failure;
     run = JSON.parse(resultJson);
   } catch (error) {
@@ -2516,8 +3487,8 @@ function extractFailures(suiteResult) {
 }
 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 backlogPath = options.backlogPath ?? path10.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? path10.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);
@@ -2549,18 +3520,18 @@ function updateBacklogFromSuite(suiteResult, options = {}) {
     }
   }
   if (ticketsToAdd.length > 0) {
-    fs8.mkdirSync(path8.dirname(backlogPath), { recursive: true });
-    fs8.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+    fs10.mkdirSync(path10.dirname(backlogPath), { recursive: true });
+    fs10.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
   }
   return summary;
 }
 
 // src/runner/suite.ts
-import path10 from "path";
+import path12 from "path";
 
 // src/reporter/ci-summary.ts
-import fs9 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path11 from "path";
 import chalk from "chalk";
 function countCiResults(results) {
   return {
@@ -2624,9 +3595,9 @@ function writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky = []
     ...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");
+  fs11.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = path11.join(ciRunDir, "ci-result.json");
+  fs11.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
   return filePath;
 }
 
@@ -2811,7 +3782,7 @@ async function runSuite(options = {}) {
   const clusters = clusterFailures(
     extractFailures({ result: { hunts: results }, resultPath: null })
   ).filter((cluster) => cluster.count > 1);
-  const ciRunDir = path10.join(configDir, "runs", timestamp("ci"));
+  const ciRunDir = path12.join(configDir, "runs", timestamp("ci"));
   const resultPath = writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky, clusters);
   const { passed, failed, skipped } = countCiResults(results);
   return {
@@ -2948,7 +3919,20 @@ async function analyzePage(page) {
 
 // src/generator/index.ts
 import yaml from "yaml";
-import { chromium as chromium2 } from "playwright";
+
+// src/browser/engines.ts
+function formatSupportedBrowserEngines() {
+  return SUPPORTED_BROWSER_ENGINES.join(", ");
+}
+function parseBrowserEngine(value, fallback = "chromium") {
+  if (value === void 0 || value.length === 0) {
+    return fallback;
+  }
+  if (SUPPORTED_BROWSER_ENGINES.includes(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported browser engine "${value}". Use ${formatSupportedBrowserEngines()}.`);
+}
 
 // src/generator/prompt.ts
 var STEP_REFERENCE = `
@@ -3110,18 +4094,34 @@ async function generateWithOpenAi(prompt, config) {
 }
 
 // src/generator/index.ts
+function parseViewportFlag2(value) {
+  const match = /^(\d+)x(\d+)$/i.exec(value);
+  if (match) {
+    return { width: Number(match[1]), height: Number(match[2]) };
+  }
+  return value;
+}
 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();
+    const engine = parseBrowserEngine(options.browser);
+    const viewport = options.viewport ? resolveViewport(parseViewportFlag2(options.viewport)) : resolveViewport(void 0);
+    const session = await launchBrowser({
+      headless: true,
+      slowMo: 0,
+      timeout: 3e4,
+      trace: false,
+      recordHar: false,
+      runDir: process.cwd(),
+      engine,
+      viewport
+    });
+    const driver = createPlaywrightDriver(session.page);
     try {
-      await page.goto(options.url, { waitUntil: "networkidle" });
-      analysis = await analyzePage(page);
+      await driver.goto(options.url, { waitUntil: "networkidle" });
+      analysis = await analyzePage(driver);
     } finally {
-      await context.close();
-      await browser.close();
+      await closeBrowser(session);
     }
   }
   if (!analysis) {
@@ -3138,6 +4138,22 @@ async function generateHunt(options) {
 
 export {
   interpolateHunt,
+  WEB_ONLY_STEP_TYPES,
+  webOnlyReason,
+  assertStepsSupportedByTarget,
+  assertTargetAppAllowed,
+  launchBrowser,
+  closeBrowser,
+  saveStorageState,
+  createPlaywrightDriver,
+  parseMacSelector,
+  createMacDriver,
+  macdriverBuildInstructions,
+  resolveHelperBinary,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  SpawnMacHelperClient,
+  launchMacSession,
+  closeMacSession,
   extractSelectorIntent,
   buildHealCandidates,
   healSelector,
@@ -3152,7 +4168,8 @@ export {
   extractFailures,
   updateBacklogFromSuite,
   runSuite,
+  parseBrowserEngine,
   analyzePage,
   generateHunt
 };
-//# sourceMappingURL=chunk-T7YLXF6X.js.map
+//# sourceMappingURL=chunk-ZEFVTKQT.js.map