prowl-tools 0.1.3 → 0.1.4

package/dist/lib.cjs

@@ -37,12 +37,12 @@ __export(visual_exports, {
   ensureBaselineDir: () => ensureBaselineDir
 });
 async function compareScreenshots(baselinePath, currentPath, diffPath, threshold) {
-  const baselineData = import_pngjs.PNG.sync.read(import_node_fs3.default.readFileSync(baselinePath));
-  const currentData = import_pngjs.PNG.sync.read(import_node_fs3.default.readFileSync(currentPath));
+  const baselineData = import_pngjs.PNG.sync.read(import_node_fs5.default.readFileSync(baselinePath));
+  const currentData = import_pngjs.PNG.sync.read(import_node_fs5.default.readFileSync(currentPath));
   const { width, height } = baselineData;
   if (currentData.width !== width || currentData.height !== height) {
     const diff2 = new import_pngjs.PNG({ width, height });
-    import_node_fs3.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
+    import_node_fs5.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
     return {
       match: false,
       diffPercentage: 1,
@@ -60,7 +60,7 @@ async function compareScreenshots(baselinePath, currentPath, diffPath, threshold
   );
   const totalPixels = width * height;
   const diffPercentage = diffPixels / totalPixels;
-  import_node_fs3.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
+  import_node_fs5.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
   return {
     match: diffPercentage <= threshold,
     diffPercentage,
@@ -68,16 +68,16 @@ async function compareScreenshots(baselinePath, currentPath, diffPath, threshold
   };
 }
 function ensureBaselineDir(configDir) {
-  const baselineDir = import_node_path3.default.join(configDir, "baselines");
-  import_node_fs3.default.mkdirSync(baselineDir, { recursive: true });
+  const baselineDir = import_node_path5.default.join(configDir, "baselines");
+  import_node_fs5.default.mkdirSync(baselineDir, { recursive: true });
   return baselineDir;
 }
-var import_node_fs3, import_node_path3, import_pngjs, import_pixelmatch;
+var import_node_fs5, import_node_path5, import_pngjs, import_pixelmatch;
 var init_visual = __esm({
   "src/runner/visual.ts"() {
     "use strict";
-    import_node_fs3 = __toESM(require("fs"), 1);
-    import_node_path3 = __toESM(require("path"), 1);
+    import_node_fs5 = __toESM(require("fs"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
     import_pngjs = require("pngjs");
     import_pixelmatch = __toESM(require("pixelmatch"), 1);
   }
@@ -87,45 +87,573 @@ var init_visual = __esm({
 var src_exports = {};
 __export(src_exports, {
   DEFAULT_FLAKY_THRESHOLD: () => DEFAULT_FLAKY_THRESHOLD,
+  DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
+  SpawnMacHelperClient: () => SpawnMacHelperClient,
+  WEB_ONLY_STEP_TYPES: () => WEB_ONLY_STEP_TYPES,
   analyzePage: () => analyzePage,
+  assertStepsSupportedByTarget: () => assertStepsSupportedByTarget,
+  assertTargetAppAllowed: () => assertTargetAppAllowed,
   buildHealCandidates: () => buildHealCandidates,
+  closeMacSession: () => closeMacSession,
   clusterFailures: () => clusterFailures,
   computeFlakeScore: () => computeFlakeScore,
   configSchema: () => configSchema,
+  createMacDriver: () => createMacDriver,
   extractFailures: () => extractFailures,
   extractSelectorIntent: () => extractSelectorIntent,
   generateHunt: () => generateHunt,
   healSelector: () => healSelector,
   huntSchema: () => huntSchema,
   interpolateHunt: () => interpolateHunt,
+  launchMacSession: () => launchMacSession,
   listHunts: () => listHunts,
   loadConfig: () => loadConfig,
   loadHunt: () => loadHunt,
   loadHuntMeta: () => loadHuntMeta,
   loadHuntTags: () => loadHuntTags,
+  macdriverBuildInstructions: () => macdriverBuildInstructions,
+  parseMacSelector: () => parseMacSelector,
   rankFlaky: () => rankFlaky,
   readHistory: () => readHistory,
   readHuntHistory: () => readHuntHistory,
+  resolveHelperBinary: () => resolveHelperBinary,
   runHunt: () => runHunt,
   runSuite: () => runSuite,
   stepSchema: () => stepSchema,
-  updateBacklogFromSuite: () => updateBacklogFromSuite
+  updateBacklogFromSuite: () => updateBacklogFromSuite,
+  webOnlyReason: () => webOnlyReason
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/runner/index.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+// src/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/config/loader.ts
+// src/browser/mac-helper.ts
+var import_node_child_process = require("child_process");
 var import_node_fs = __toESM(require("fs"), 1);
 var import_node_path = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_meta = {};
+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 = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+  const root = import_node_path.default.parse(dir).root;
+  while (dir !== root) {
+    if (import_node_fs.default.existsSync(import_node_path.default.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = import_node_path.default.dirname(dir);
+  }
+  return root;
+}
+function resolveHelperBinary(env = process.env) {
+  const override = env.PROWL_MACDRIVER_BIN;
+  if (override) {
+    if (!import_node_fs.default.existsSync(override)) {
+      throw new Error(
+        `PROWL_MACDRIVER_BIN points at a missing file: ${override}
+${macdriverBuildInstructions()}`
+      );
+    }
+    return override;
+  }
+  const root = getPackageRoot();
+  const candidates = [
+    import_node_path.default.join(root, "macdriver", ".build", "release", HELPER_BINARY),
+    import_node_path.default.join(root, "macdriver", ".build", "debug", HELPER_BINARY)
+  ];
+  for (const candidate of candidates) {
+    if (import_node_fs.default.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 = (0, import_node_child_process.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/config/target.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+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 import_node_path2.default.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 = import_node_path2.default.join(normalizeAppPath(appPath), "Contents", "Info.plist");
+  if (!import_node_fs2.default.existsSync(infoPlistPath)) {
+    return null;
+  }
+  try {
+    const parsed = parseBundleIdentifier(import_node_fs2.default.readFileSync(infoPlistPath, "utf-8"));
+    if (parsed) {
+      return parsed;
+    }
+  } catch {
+  }
+  if (process.platform !== "darwin" || !import_node_fs2.default.existsSync("/usr/bin/plutil")) {
+    return null;
+  }
+  try {
+    const output = (0, import_node_child_process2.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 = import_node_path2.default.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/runner/index.ts
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+
+// src/config/loader.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
 var import_yaml = __toESM(require("yaml"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
 
 // src/config/schema.ts
 var import_zod = require("zod");
 
+// src/types/index.ts
+var SUPPORTED_BROWSER_ENGINES = ["chromium", "firefox", "webkit"];
+
 // src/config/hunt-name.ts
 var HUNT_NAME_PATTERN = /^[A-Za-z0-9_-]+(?:\/[A-Za-z0-9_-]+)*$/;
 function isValidHuntName(name) {
@@ -140,15 +668,22 @@ function assertValidHuntName(name) {
 }
 
 // src/config/schema.ts
+var webTargetSchema = import_zod.z.object({
+  type: import_zod.z.literal("web").optional(),
+  url: import_zod.z.string().min(1)
+}).strict();
+var macosTargetSchema = import_zod.z.object({
+  type: import_zod.z.literal("macos"),
+  app: import_zod.z.string().min(1)
+}).strict();
+var targetSchema = import_zod.z.union([macosTargetSchema, webTargetSchema]);
 var configSchema = import_zod.z.object({
-  target: import_zod.z.object({
-    url: import_zod.z.string().min(1)
-  }),
+  target: targetSchema,
   browser: import_zod.z.object({
     headless: import_zod.z.boolean().optional(),
     slowMo: import_zod.z.number().optional(),
     timeout: import_zod.z.number().optional(),
-    engine: import_zod.z.enum(["chromium", "firefox", "webkit"]).optional(),
+    engine: import_zod.z.enum(SUPPORTED_BROWSER_ENGINES).optional(),
     channel: import_zod.z.enum([
       "chromium",
       "chrome",
@@ -180,6 +715,7 @@ var configSchema = import_zod.z.object({
   guardrails: import_zod.z.object({
     maxSteps: import_zod.z.number().optional(),
     allowedDomains: import_zod.z.array(import_zod.z.string()).optional(),
+    allowedApps: import_zod.z.array(import_zod.z.string()).optional(),
     forbiddenSelectors: import_zod.z.array(import_zod.z.string()).optional(),
     selfHealing: import_zod.z.boolean().optional()
   }).optional(),
@@ -427,9 +963,11 @@ var huntSchema = import_zod.z.object({
 }).strict();
 
 // src/config/loader.ts
+var DEFAULT_WEB_URL = "http://localhost:3000";
 var DEFAULT_CONFIG = {
   target: {
-    url: "http://localhost:3000"
+    type: "web",
+    url: DEFAULT_WEB_URL
   },
   browser: {
     headless: true,
@@ -453,6 +991,7 @@ var DEFAULT_CONFIG = {
   guardrails: {
     maxSteps: 50,
     allowedDomains: ["localhost", "127.0.0.1", "0.0.0.0"],
+    allowedApps: [],
     forbiddenSelectors: ["[data-danger]", ".delete-btn"],
     selfHealing: false
   },
@@ -479,12 +1018,12 @@ function findConfigPath(startDir) {
   let current = startDir;
   while (current) {
     for (const dir of [CONFIG_DIR, LEGACY_CONFIG_DIR]) {
-      const candidate = import_node_path.default.join(current, dir, "config.yml");
-      if (import_node_fs.default.existsSync(candidate)) {
+      const candidate = import_node_path3.default.join(current, dir, "config.yml");
+      if (import_node_fs3.default.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parent = import_node_path.default.dirname(current);
+    const parent = import_node_path3.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -510,11 +1049,18 @@ function resolveViewport(value) {
   }
   return value;
 }
+function resolveTarget(target) {
+  if (target && target.type === "macos") {
+    return { type: "macos", app: target.app };
+  }
+  return {
+    type: "web",
+    url: target?.url ?? DEFAULT_WEB_URL
+  };
+}
 function mergeConfig(partial) {
   return {
-    target: {
-      url: partial.target?.url ?? DEFAULT_CONFIG.target.url
-    },
+    target: resolveTarget(partial.target),
     browser: {
       headless: partial.browser?.headless ?? DEFAULT_CONFIG.browser.headless,
       slowMo: partial.browser?.slowMo ?? DEFAULT_CONFIG.browser.slowMo,
@@ -538,6 +1084,7 @@ function mergeConfig(partial) {
     guardrails: {
       maxSteps: partial.guardrails?.maxSteps ?? DEFAULT_CONFIG.guardrails.maxSteps,
       allowedDomains: partial.guardrails?.allowedDomains ?? DEFAULT_CONFIG.guardrails.allowedDomains,
+      allowedApps: partial.guardrails?.allowedApps ?? DEFAULT_CONFIG.guardrails.allowedApps,
       forbiddenSelectors: partial.guardrails?.forbiddenSelectors ?? DEFAULT_CONFIG.guardrails.forbiddenSelectors,
       selfHealing: partial.guardrails?.selfHealing ?? DEFAULT_CONFIG.guardrails.selfHealing
     },
@@ -564,56 +1111,58 @@ function ensureAllowedDomain(allowed, urlValue) {
   return allowed;
 }
 function loadConfig(configPath) {
-  const resolvedPath = configPath ? import_node_path.default.resolve(configPath) : findConfigPath(process.cwd());
+  const resolvedPath = configPath ? import_node_path3.default.resolve(configPath) : findConfigPath(process.cwd());
   if (!resolvedPath) {
     throw new Error("Could not find .prowl/config.yml. Run `prowl init` first.");
   }
-  if (!import_node_fs.default.existsSync(resolvedPath)) {
+  if (!import_node_fs3.default.existsSync(resolvedPath)) {
     throw new Error(`Config file not found at ${resolvedPath}`);
   }
-  const configDir = import_node_path.default.dirname(resolvedPath);
-  if (import_node_path.default.basename(configDir) === LEGACY_CONFIG_DIR) {
+  const configDir = import_node_path3.default.dirname(resolvedPath);
+  if (import_node_path3.default.basename(configDir) === LEGACY_CONFIG_DIR) {
     warnLegacyConfigDir();
   }
-  import_dotenv.default.config({ path: import_node_path.default.join(configDir, ".env"), override: false });
-  const raw = import_node_fs.default.readFileSync(resolvedPath, "utf-8");
+  import_dotenv.default.config({ path: import_node_path3.default.join(configDir, ".env"), override: false });
+  const raw = import_node_fs3.default.readFileSync(resolvedPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   const validated = configSchema.parse(parsed);
   const config = mergeConfig(validated);
-  config.guardrails.allowedDomains = ensureAllowedDomain(
-    config.guardrails.allowedDomains,
-    config.target.url
-  );
+  if (config.target.type === "web") {
+    config.guardrails.allowedDomains = ensureAllowedDomain(
+      config.guardrails.allowedDomains,
+      config.target.url
+    );
+  }
   return { config, configPath: resolvedPath, configDir };
 }
 function loadHunt(huntName, configDir) {
   assertValidHuntName(huntName);
-  const huntPath = import_node_path.default.join(configDir, "hunts", `${huntName}.yml`);
-  if (!import_node_fs.default.existsSync(huntPath)) {
+  const huntPath = import_node_path3.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs3.default.existsSync(huntPath)) {
     throw new Error(`Hunt file not found: ${huntPath}`);
   }
-  const raw = import_node_fs.default.readFileSync(huntPath, "utf-8");
+  const raw = import_node_fs3.default.readFileSync(huntPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   const validated = huntSchema.parse(parsed);
   return validated;
 }
 function loadHuntTags(huntName, configDir) {
   assertValidHuntName(huntName);
-  const huntPath = import_node_path.default.join(configDir, "hunts", `${huntName}.yml`);
-  if (!import_node_fs.default.existsSync(huntPath)) {
+  const huntPath = import_node_path3.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs3.default.existsSync(huntPath)) {
     return [];
   }
-  const raw = import_node_fs.default.readFileSync(huntPath, "utf-8");
+  const raw = import_node_fs3.default.readFileSync(huntPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   return Array.isArray(parsed.tags) ? parsed.tags : [];
 }
 function loadHuntMeta(huntName, configDir) {
   assertValidHuntName(huntName);
-  const huntPath = import_node_path.default.join(configDir, "hunts", `${huntName}.yml`);
-  if (!import_node_fs.default.existsSync(huntPath)) {
+  const huntPath = import_node_path3.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs3.default.existsSync(huntPath)) {
     return { tags: [] };
   }
-  const raw = import_node_fs.default.readFileSync(huntPath, "utf-8");
+  const raw = import_node_fs3.default.readFileSync(huntPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   return {
     description: typeof parsed.description === "string" ? parsed.description : void 0,
@@ -621,24 +1170,24 @@ function loadHuntMeta(huntName, configDir) {
   };
 }
 function listHunts(configDir) {
-  const huntsDir = import_node_path.default.join(configDir, "hunts");
-  if (!import_node_fs.default.existsSync(huntsDir)) {
+  const huntsDir = import_node_path3.default.join(configDir, "hunts");
+  if (!import_node_fs3.default.existsSync(huntsDir)) {
     return [];
   }
-  const stats = import_node_fs.default.statSync(huntsDir);
+  const stats = import_node_fs3.default.statSync(huntsDir);
   if (!stats.isDirectory()) {
     throw new Error(`Hunts path is not a directory: ${huntsDir}`);
   }
   const results = [];
   function scanDir(dir) {
-    const entries = import_node_fs.default.readdirSync(dir, { withFileTypes: true });
+    const entries = import_node_fs3.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".yml")) {
-        const fullPath = import_node_path.default.join(dir, entry.name);
-        const relative = import_node_path.default.relative(huntsDir, fullPath);
+        const fullPath = import_node_path3.default.join(dir, entry.name);
+        const relative = import_node_path3.default.relative(huntsDir, fullPath);
         results.push(relative.replace(/\.yml$/, ""));
       } else if (entry.isDirectory()) {
-        scanDir(import_node_path.default.join(dir, entry.name));
+        scanDir(import_node_path3.default.join(dir, entry.name));
       }
     }
   }
@@ -691,7 +1240,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++) {
@@ -700,7 +1249,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
   };
@@ -1012,81 +1561,223 @@ function interpolateHunt(hunt, env, randomVars = generateRandomVars()) {
   };
 }
 
-// src/browser/controller.ts
-var import_node_fs2 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+// src/browser/playwright-driver.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var import_playwright = require("playwright");
 var ENGINES = { chromium: import_playwright.chromium, firefox: import_playwright.firefox, webkit: import_playwright.webkit };
 async function launchBrowser(options) {
-  const engine = ENGINES[options.engine ?? "chromium"];
+  const 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 (import_node_fs2.default.existsSync(options.storageStatePath)) {
-      contextOptions.storageState = options.storageStatePath;
-    } else {
-      console.warn(`Auth state file not found: ${options.storageStatePath}. Run "prowl login" to create it.`);
+  try {
+    const contextOptions = {};
+    if (options.viewport) {
+      contextOptions.viewport = options.viewport;
     }
+    if (options.storageStatePath) {
+      if (import_node_fs4.default.existsSync(options.storageStatePath)) {
+        contextOptions.storageState = options.storageStatePath;
+      } else {
+        console.warn(`Auth state file not found: ${options.storageStatePath}. Run "prowl login" to create it.`);
+      }
+    }
+    if (options.recordHar) {
+      contextOptions.recordHar = { path: import_node_path4.default.join(options.runDir, "network.har") };
+    }
+    const context = await browser.newContext(contextOptions);
+    const page = await context.newPage();
+    page.setDefaultTimeout(options.timeout);
+    page.setDefaultNavigationTimeout(options.timeout);
+    let tracePath;
+    if (options.trace) {
+      tracePath = import_node_path4.default.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: import_node_path2.default.join(options.runDir, "network.har") };
-  }
-  const context = await browser.newContext(contextOptions);
-  const page = await context.newPage();
-  page.setDefaultTimeout(options.timeout);
-  page.setDefaultNavigationTimeout(options.timeout);
-  let tracePath;
-  if (options.trace) {
-    tracePath = import_node_path2.default.join(options.runDir, "trace.zip");
-    await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
-  }
-  return { browser, context, page, tracePath };
 }
 async function closeBrowser(session) {
-  if (session.tracePath) {
-    await session.context.tracing.stop({ path: session.tracePath });
-  }
-  await session.context.close();
-  await session.browser.close();
-}
-
-// src/runner/steps.ts
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
-
-// src/browser/actions.ts
-async function clickElement(page, selector) {
-  await page.locator(selector).click();
-}
-async function fillElement(page, selector, value) {
-  await page.locator(selector).fill(value);
-}
-async function pressKey(page, selector, key) {
-  await page.locator(selector).press(key);
+  try {
+    if (session.tracePath) {
+      await session.context.tracing.stop({ path: session.tracePath });
+    }
+    await session.context.close();
+  } finally {
+    await session.browser.close();
+  }
+}
+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
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+
 // src/runner/healing.ts
 var INTERACTIVE_TAGS = ["button", "a", "input", "select", "textarea"];
 function extractSelectorIntent(selector) {
@@ -1124,12 +1815,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;
@@ -1141,74 +1832,104 @@ async function healSelector(page, selector, options) {
   return null;
 }
 
-// src/runner/steps.ts
+// 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 };
     }
-    throw new Error(`Hunt has ${stepCount} steps. Max allowed is ${maxSteps}.`);
+    if (matched) {
+      return { selector };
+    }
+    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";
@@ -1312,17 +2033,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();
@@ -1349,56 +2059,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}"`);
@@ -1526,11 +2230,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}`);
     }
@@ -1538,22 +2242,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}`);
     }
@@ -1562,7 +2266,7 @@ async function runInlineAssert(page, assertion, forbiddenSelectors) {
   throw new Error("assert step is missing an assertion type");
 }
 function screenshotPath(screenshotsDir, fileName) {
-  return import_node_path4.default.join(screenshotsDir, fileName);
+  return import_node_path6.default.join(screenshotsDir, fileName);
 }
 function stepPath(prefix, index) {
   return prefix ? `${prefix}.${index}` : `${index}`;
@@ -1570,8 +2274,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;
 }
@@ -1579,14 +2283,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 !== import_node_path4.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
+  if (safeFilename.length === 0 || safeFilename !== suggestedFilename || safeFilename !== import_node_path6.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
     throw new Error(`Invalid download filename: "${suggestedFilename}"`);
   }
   return safeFilename;
 }
-async function captureScreenshot(page, filePath) {
+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}`);
@@ -1605,608 +2309,784 @@ async function executeNestedSteps(context, overrides) {
   }
   return result;
 }
-async function executeSteps(context) {
-  const screenshotsDir = import_node_path4.default.join(context.runDir, "screenshots");
-  import_node_fs4.default.mkdirSync(screenshotsDir, { recursive: true });
-  const currentHuntName = context.huntStack?.[context.huntStack.length - 1];
-  assertWithinMaxSteps(context.steps.length, context.maxSteps, currentHuntName);
-  const results = [];
-  const screenshots = [];
-  const runStartedAtMs = context.runStartedAtMs ?? Date.now();
-  context.runStartedAtMs = runStartedAtMs;
-  const addScreenshot = async (fileName) => {
-    const fullPath = screenshotPath(screenshotsDir, fileName);
-    await captureScreenshot(context.page, fullPath);
-    const relative = import_node_path4.default.join("screenshots", fileName);
-    screenshots.push(relative);
-    return relative;
-  };
-  for (let index = 0; index < context.steps.length; index += 1) {
-    const currentStepPath = stepPath(context.stepPathPrefix, index);
-    if (Date.now() - runStartedAtMs > context.maxTotalTimeMs) {
-      results.push({
-        type: "timeout",
-        status: "fail",
-        durationMs: 0,
-        error: `Max total time exceeded (${context.maxTotalTimeMs}ms)`
-      });
-      return { results, screenshots, failed: true, error: "Max total time exceeded" };
-    }
-    const runtimeVars = context.runtimeVars ?? /* @__PURE__ */ new Map();
-    context.runtimeVars = runtimeVars;
-    let step = context.steps[index];
-    if (runtimeVars.size > 0) {
-      step = applyRuntimeVars(step, runtimeVars);
+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 nextStep = context.steps[index + 1];
-    if (!isWaitForDownloadStep(step) && context.pendingDownload === void 0 && isWaitForDownloadStep(nextStep)) {
-      context.pendingDownload = armDownloadListener(
-        context.page,
-        nextStep.waitForDownload?.timeout ?? 3e4
-      );
-    }
-    const stepStart = Date.now();
-    const stepType = getStepType(step);
-    let stepResult = null;
-    try {
-      if ("navigate" in step) {
-        const destination = resolveNavigationTarget(context.targetUrl, step.navigate);
-        ensureAllowedUrl(destination, context.allowedDomains);
-        await context.page.goto(destination);
-        ensureAllowedUrl(context.page.url(), context.allowedDomains);
-        stepResult = { type: "navigate", status: "pass", durationMs: Date.now() - stepStart };
-      } else if ("click" in step) {
-        let selector;
-        let healedFrom;
-        if (typeof step.click === "string") {
-          selector = await clickByTextWithFallback(
-            context.page,
-            step.click,
-            context.forbiddenSelectors
-          );
-        } else {
-          const resolved = await resolveActionSelector(context, step.click.selector);
-          await clickElement(context.page, resolved.selector);
-          selector = resolved.selector;
-          healedFrom = resolved.healedFrom;
-        }
-        ensureAllowedUrl(context.page.url(), context.allowedDomains);
-        stepResult = {
+  },
+  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) => import_node_path4.default.isAbsolute(f) ? f : import_node_path4.default.join(context.configDir, f);
-        const resolvedFiles = Array.isArray(rawFiles) ? rawFiles.map(resolveFile) : resolveFile(rawFiles);
-        await setInputFiles(context.page, resolvedInput.selector, resolvedFiles);
-        ensureAllowedUrl(context.page.url(), context.allowedDomains);
-        const filesLabel = Array.isArray(rawFiles) ? rawFiles.join(", ") : rawFiles;
-        stepResult = {
+          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) => import_node_path6.default.isAbsolute(f) ? f : import_node_path6.default.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",
+        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`
+          }
+        };
+      }
+      return {
+        kind: "result",
+        result: {
+          type: "if",
           status: "pass",
-          durationMs: Date.now() - stepStart,
-          screenshot: relative
-        };
-      } else if ("if" in step) {
-        const condition = step.if;
-        const selector = condition.visible ?? condition.notVisible;
-        assertAllowedSelector(selector, context.forbiddenSelectors);
-        const count = await context.page.locator(selector).count();
-        const conditionMet = condition.visible !== void 0 ? count > 0 : count === 0;
-        if (conditionMet) {
-          const subResult = await executeNestedSteps(context, {
-            steps: condition.then,
-            stepPathPrefix: `${currentStepPath}.if.then`
+          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})`);
-          }
-          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;
+        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})`);
           }
-        } 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 = import_node_path4.default.isAbsolute(responseFile) ? responseFile : import_node_path4.default.join(context.configDir, responseFile);
-          const resolvedConfigDir = import_node_path4.default.resolve(context.configDir);
-          const resolvedFilePath = import_node_path4.default.resolve(candidateFilePath);
-          const relativePath = import_node_path4.default.relative(resolvedConfigDir, resolvedFilePath);
-          const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${import_node_path4.default.sep}`) && !import_node_path4.default.isAbsolute(relativePath);
-          if (!isWithinConfigDir) {
-            throw new Error("mock.response.file must resolve within config directory");
+          h.screenshots.push(...subResult.screenshots);
+          if (subResult.failed) {
+            return { kind: "abort", error: subResult.error };
           }
-          responseBody = await import_node_fs4.default.promises.readFile(resolvedFilePath, "utf-8");
         }
-        const contentType = mock.response.contentType ?? "application/json";
-        const status = mock.response.status;
-        await context.page.route(mock.url, (route) => {
-          route.fulfill({
-            status,
-            contentType,
-            body: responseBody
-          });
-        });
-        mocks.set(mock.url, async () => {
-          await context.page.unroute(mock.url);
-        });
-        stepResult = {
-          type: "mockRoute",
-          status: "pass",
-          durationMs: Date.now() - stepStart,
-          value: mock.url
-        };
-      } else if ("unmockRoute" in step) {
-        const url = typeof step.unmockRoute === "string" ? step.unmockRoute : step.unmockRoute.url;
-        const mocks = context.activeMocks;
-        if (!mocks || !mocks.has(url)) {
-          throw new Error(`No active mock for URL: ${url}`);
+      }
+      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 = import_node_path6.default.isAbsolute(responseFile) ? responseFile : import_node_path6.default.join(h.context.configDir, responseFile);
+        const resolvedConfigDir = import_node_path6.default.resolve(h.context.configDir);
+        const resolvedFilePath = import_node_path6.default.resolve(candidateFilePath);
+        const relativePath = import_node_path6.default.relative(resolvedConfigDir, resolvedFilePath);
+        const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${import_node_path6.default.sep}`) && !import_node_path6.default.isAbsolute(relativePath);
+        if (!isWithinConfigDir) {
+          throw new Error("mock.response.file must resolve within config directory");
         }
-        stepResult = {
+        responseBody = await import_node_fs6.default.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 = import_node_path4.default.isAbsolute(step.runScript.file) ? step.runScript.file : import_node_path4.default.join(context.configDir, step.runScript.file);
-        const fileContents = import_node_fs4.default.readFileSync(filePath, "utf-8");
-        await context.page.evaluate(fileContents);
-        stepResult = {
+        }
+      };
+    }
+  },
+  runScript: {
+    capabilities: ["evaluate"],
+    run: async (h) => {
+      if (!("runScript" in h.step)) unknownStep();
+      const filePath = import_node_path6.default.isAbsolute(h.step.runScript.file) ? h.step.runScript.file : import_node_path6.default.join(h.context.configDir, h.step.runScript.file);
+      const fileContents = import_node_fs6.default.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: compareScreenshots2, ensureBaselineDir: ensureBaselineDir2 } = await Promise.resolve().then(() => (init_visual(), visual_exports));
+      const name = h.step.assertScreenshot.name;
+      const threshold = h.step.assertScreenshot.threshold ?? 0.1;
+      const baselineDir = ensureBaselineDir2(h.context.configDir);
+      const baselinePath = import_node_path6.default.join(baselineDir, `${name}.png`);
+      const currentScreenshotPath = import_node_path6.default.join(h.context.runDir, "screenshots", `${name}-current.png`);
+      import_node_fs6.default.mkdirSync(import_node_path6.default.dirname(currentScreenshotPath), { recursive: true });
+      await h.driver.screenshot({ path: currentScreenshotPath, fullPage: true });
+      h.screenshots.push(import_node_path6.default.join("screenshots", `${name}-current.png`));
+      if (!import_node_fs6.default.existsSync(baselinePath)) {
+        import_node_fs6.default.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: compareScreenshots2, ensureBaselineDir: ensureBaselineDir2 } = await Promise.resolve().then(() => (init_visual(), visual_exports));
-        const name = step.assertScreenshot.name;
-        const threshold = step.assertScreenshot.threshold ?? 0.1;
-        const baselineDir = ensureBaselineDir2(context.configDir);
-        const baselinePath = import_node_path4.default.join(baselineDir, `${name}.png`);
-        const currentScreenshotPath = import_node_path4.default.join(context.runDir, "screenshots", `${name}-current.png`);
-        import_node_fs4.default.mkdirSync(import_node_path4.default.dirname(currentScreenshotPath), { recursive: true });
-        await context.page.screenshot({ path: currentScreenshotPath, fullPage: true });
-        screenshots.push(import_node_path4.default.join("screenshots", `${name}-current.png`));
-        if (!import_node_fs4.default.existsSync(baselinePath)) {
-          import_node_fs4.default.copyFileSync(currentScreenshotPath, baselinePath);
-          stepResult = {
+      }
+      const diffPath = import_node_path6.default.join(h.context.runDir, "screenshots", `${name}-diff.png`);
+      const comparison = await compareScreenshots2(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 = import_node_path4.default.join(context.runDir, "screenshots", `${name}-diff.png`);
-          const comparison = await compareScreenshots2(baselinePath, currentScreenshotPath, diffPath, threshold);
-          if (comparison.match) {
-            stepResult = {
-              type: "assertScreenshot",
-              status: "pass",
-              durationMs: Date.now() - stepStart,
-              value: `diff: ${(comparison.diffPercentage * 100).toFixed(2)}%`
-            };
-          } else {
-            screenshots.push(import_node_path4.default.join("screenshots", `${name}-diff.png`));
-            throw new Error(
-              `Visual regression: ${(comparison.diffPercentage * 100).toFixed(2)}% diff exceeds threshold ${(threshold * 100).toFixed(0)}%`
-            );
+            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(import_node_path6.default.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 = import_node_path4.default.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 = import_node_path6.default.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 = import_node_path6.default.join(context.runDir, "screenshots");
+  import_node_fs6.default.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 = import_node_path6.default.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);
@@ -2233,12 +3113,12 @@ async function executeSteps(context) {
   return { results, screenshots, failed: false };
 }
 async function captureFinalScreenshot(page, runDir) {
-  const screenshotsDir = import_node_path4.default.join(runDir, "screenshots");
-  import_node_fs4.default.mkdirSync(screenshotsDir, { recursive: true });
+  const screenshotsDir = import_node_path6.default.join(runDir, "screenshots");
+  import_node_fs6.default.mkdirSync(screenshotsDir, { recursive: true });
   const fileName = "final.png";
   const filePath = screenshotPath(screenshotsDir, fileName);
   await captureScreenshot(page, filePath);
-  return import_node_path4.default.join("screenshots", fileName);
+  return import_node_path6.default.join("screenshots", fileName);
 }
 
 // src/runner/assertions.ts
@@ -2398,18 +3278,18 @@ function captureTraceCorrelation(response, headerName, sink, redactionValues = [
 }
 
 // src/reporter/result.ts
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 function writeResult(runDir, result) {
   const fileName = "result.json";
-  const fullPath = import_node_path5.default.join(runDir, fileName);
-  import_node_fs5.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
+  const fullPath = import_node_path7.default.join(runDir, fileName);
+  import_node_fs7.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
   return fileName;
 }
 
 // src/reporter/summary.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 function escapeMd(text) {
   return text.replace(/([|`*_{}[\]()#+\-!\\])/g, "\\$1");
 }
@@ -2487,15 +3367,15 @@ function writeSummary(runDir, result) {
     }
   }
   const fileName = "summary.md";
-  const fullPath = import_node_path6.default.join(runDir, fileName);
-  import_node_fs6.default.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = import_node_path8.default.join(runDir, fileName);
+  import_node_fs8.default.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
 
 // src/reporter/junit.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -2539,8 +3419,8 @@ function writeJunit(runDir, result) {
   lines.push("  </testsuite>");
   lines.push("</testsuites>");
   const fileName = "junit.xml";
-  const fullPath = import_node_path7.default.join(runDir, fileName);
-  import_node_fs7.default.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = import_node_path9.default.join(runDir, fileName);
+  import_node_fs9.default.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -2574,15 +3454,15 @@ function timestamp(prefix) {
 }
 
 // src/runner/history.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var HISTORY_FILE = "history.json";
 var LOCK_FILE_SUFFIX = ".lock";
 var LOCK_RETRY_MS = 10;
 var LOCK_TIMEOUT_MS = 5e3;
 var SLEEP_BUFFER = new Int32Array(new SharedArrayBuffer(4));
 function historyPath(configDir) {
-  return import_node_path8.default.join(configDir, HISTORY_FILE);
+  return import_node_path10.default.join(configDir, HISTORY_FILE);
 }
 function isHistoryEntry(value) {
   if (!value || typeof value !== "object") {
@@ -2593,11 +3473,11 @@ function isHistoryEntry(value) {
 }
 function readHistory(configDir) {
   const filePath = historyPath(configDir);
-  if (!import_node_fs8.default.existsSync(filePath)) {
+  if (!import_node_fs10.default.existsSync(filePath)) {
     return { entries: [] };
   }
   try {
-    const raw = import_node_fs8.default.readFileSync(filePath, "utf-8");
+    const raw = import_node_fs10.default.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object" && "entries" in parsed && Array.isArray(parsed.entries)) {
       const validatedEntries = parsed.entries.filter(isHistoryEntry);
@@ -2636,12 +3516,12 @@ function sleepSync(ms) {
 function withHistoryLock(configDir, fn) {
   const filePath = historyPath(configDir);
   const lockPath = `${filePath}${LOCK_FILE_SUFFIX}`;
-  import_node_fs8.default.mkdirSync(import_node_path8.default.dirname(filePath), { recursive: true });
+  import_node_fs10.default.mkdirSync(import_node_path10.default.dirname(filePath), { recursive: true });
   const startedAt = Date.now();
   while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
     let fd;
     try {
-      fd = import_node_fs8.default.openSync(lockPath, "wx");
+      fd = import_node_fs10.default.openSync(lockPath, "wx");
     } catch (error) {
       if (error.code === "EEXIST") {
         sleepSync(LOCK_RETRY_MS);
@@ -2653,10 +3533,10 @@ function withHistoryLock(configDir, fn) {
       return fn();
     } finally {
       try {
-        import_node_fs8.default.closeSync(fd);
+        import_node_fs10.default.closeSync(fd);
       } catch {
       }
-      import_node_fs8.default.rmSync(lockPath, { force: true });
+      import_node_fs10.default.rmSync(lockPath, { force: true });
     }
   }
   throw new Error(
@@ -2669,9 +3549,9 @@ function appendEntry(configDir, entry, maxRuns) {
     const current = readHistory(configDir);
     const next = pruneEntries([...current.entries, entry], maxRuns);
     const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-    import_node_fs8.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
+    import_node_fs10.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
 `);
-    import_node_fs8.default.renameSync(tempPath, filePath);
+    import_node_fs10.default.renameSync(tempPath, filePath);
   });
 }
 
@@ -2684,11 +3564,11 @@ function parseViewportFlag(value) {
   return value;
 }
 function resolvePath(configDir, inputPath) {
-  if (import_node_path9.default.isAbsolute(inputPath)) {
+  if (import_node_path11.default.isAbsolute(inputPath)) {
     return inputPath;
   }
-  const projectRoot = import_node_path9.default.dirname(configDir);
-  return import_node_path9.default.join(projectRoot, inputPath);
+  const projectRoot = import_node_path11.default.dirname(configDir);
+  return import_node_path11.default.join(projectRoot, inputPath);
 }
 function buildRunResult(options) {
   return {
@@ -2707,12 +3587,12 @@ function buildRunResult(options) {
 }
 function writeConsoleLog(runDir, entries) {
   const fileName = "console.log";
-  const filePath = import_node_path9.default.join(runDir, fileName);
+  const filePath = import_node_path11.default.join(runDir, fileName);
   const lines = entries.map((entry) => {
     const location = entry.location ? ` (${entry.location})` : "";
     return `[${entry.type}] ${entry.text}${location}`;
   });
-  import_node_fs9.default.writeFileSync(filePath, `${lines.join("\n")}
+  import_node_fs11.default.writeFileSync(filePath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -2720,8 +3600,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 = import_node_path9.default.join(configDir, "runs", timestamp());
-  import_node_fs9.default.mkdirSync(runDir, { recursive: true });
+  const runDir = import_node_path11.default.join(configDir, "runs", timestamp());
+  import_node_fs11.default.mkdirSync(runDir, { recursive: true });
   const storageStatePath = config.auth.storageStatePath ? resolvePath(configDir, config.auth.storageStatePath) : void 0;
   const engine = options.browser ?? config.browser.engine;
   const channel = options.channel ?? config.browser.channel;
@@ -2740,6 +3620,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
   });
   let result;
   try {
+    const driver = createPlaywrightDriver(session.page);
     const consoleEntries = [];
     const networkEntries = [];
     const traceCorrelations = [];
@@ -2751,7 +3632,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);
@@ -2765,6 +3646,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
     try {
       const stepExecution = await executeSteps({
         page: session.page,
+        driver,
         steps: interpolatedHunt.steps,
         targetUrl,
         runDir,
@@ -2797,7 +3679,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;
     }
@@ -2841,6 +3723,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,
@@ -2891,9 +3776,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 = import_node_path11.default.join(configDir, "runs", timestamp());
+  import_node_fs11.default.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 = import_node_path9.default.relative(configDir, outcome.runDir);
+    const relativeRunDir = import_node_path11.default.relative(configDir, outcome.runDir);
     appendEntry(
       configDir,
       {
@@ -2910,11 +3910,11 @@ function recordHistory(configDir, outcome, maxRuns) {
 }
 
 // src/runner/suite.ts
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 
 // src/reporter/ci-summary.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var import_chalk = __toESM(require("chalk"), 1);
 function countCiResults(results) {
   return {
@@ -2944,9 +3944,9 @@ function writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky = []
     ...flaky.length > 0 ? { flaky } : {},
     ...clusters.length > 0 ? { clusters } : {}
   };
-  import_node_fs10.default.mkdirSync(ciRunDir, { recursive: true });
-  const filePath = import_node_path10.default.join(ciRunDir, "ci-result.json");
-  import_node_fs10.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
+  import_node_fs12.default.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = import_node_path12.default.join(ciRunDir, "ci-result.json");
+  import_node_fs12.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
   return filePath;
 }
 
@@ -3080,8 +4080,8 @@ function clusterFailures(failures) {
 }
 
 // src/backlog/index.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 
 // src/backlog/parse.ts
 var MARKER_FP = /<!--\s*prowl:fp=([0-9a-f]+)/;
@@ -3171,7 +4171,7 @@ ${after}`;
 // src/backlog/index.ts
 function readFileOrEmpty(filePath) {
   try {
-    return import_node_fs11.default.readFileSync(filePath, "utf-8");
+    return import_node_fs13.default.readFileSync(filePath, "utf-8");
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") return "";
@@ -3187,7 +4187,7 @@ function buildFailure(hunt) {
   if (!hunt.runDir) return failure;
   let run;
   try {
-    const resultJson = readFileOrEmpty(import_node_path11.default.join(hunt.runDir, "result.json"));
+    const resultJson = readFileOrEmpty(import_node_path13.default.join(hunt.runDir, "result.json"));
     if (!resultJson) return failure;
     run = JSON.parse(resultJson);
   } catch (error) {
@@ -3216,8 +4216,8 @@ function extractFailures(suiteResult) {
 }
 function updateBacklogFromSuite(suiteResult, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const backlogPath = options.backlogPath ?? import_node_path11.default.join(projectRoot, "docs", "backlog.md");
-  const resolvedPath = options.resolvedPath ?? import_node_path11.default.join(projectRoot, "docs", "resolved.md");
+  const backlogPath = options.backlogPath ?? import_node_path13.default.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? import_node_path13.default.join(projectRoot, "docs", "resolved.md");
   const date = options.date ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const summary = { created: [], regressions: [], skipped: [], backlogPath };
   const failures = extractFailures(suiteResult);
@@ -3249,8 +4249,8 @@ function updateBacklogFromSuite(suiteResult, options = {}) {
     }
   }
   if (ticketsToAdd.length > 0) {
-    import_node_fs11.default.mkdirSync(import_node_path11.default.dirname(backlogPath), { recursive: true });
-    import_node_fs11.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+    import_node_fs13.default.mkdirSync(import_node_path13.default.dirname(backlogPath), { recursive: true });
+    import_node_fs13.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
   }
   return summary;
 }
@@ -3411,7 +4411,7 @@ async function runSuite(options = {}) {
   const clusters = clusterFailures(
     extractFailures({ result: { hunts: results }, resultPath: null })
   ).filter((cluster) => cluster.count > 1);
-  const ciRunDir = import_node_path12.default.join(configDir, "runs", timestamp("ci"));
+  const ciRunDir = import_node_path14.default.join(configDir, "runs", timestamp("ci"));
   const resultPath = writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky, clusters);
   const { passed, failed, skipped } = countCiResults(results);
   return {
@@ -3548,7 +4548,20 @@ async function analyzePage(page) {
 
 // src/generator/index.ts
 var import_yaml2 = __toESM(require("yaml"), 1);
-var import_playwright2 = require("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 = `
@@ -3710,18 +4723,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 import_playwright2.chromium.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) {
@@ -3738,28 +4767,40 @@ async function generateHunt(options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_FLAKY_THRESHOLD,
+  DEFAULT_REQUEST_TIMEOUT_MS,
+  SpawnMacHelperClient,
+  WEB_ONLY_STEP_TYPES,
   analyzePage,
+  assertStepsSupportedByTarget,
+  assertTargetAppAllowed,
   buildHealCandidates,
+  closeMacSession,
   clusterFailures,
   computeFlakeScore,
   configSchema,
+  createMacDriver,
   extractFailures,
   extractSelectorIntent,
   generateHunt,
   healSelector,
   huntSchema,
   interpolateHunt,
+  launchMacSession,
   listHunts,
   loadConfig,
   loadHunt,
   loadHuntMeta,
   loadHuntTags,
+  macdriverBuildInstructions,
+  parseMacSelector,
   rankFlaky,
   readHistory,
   readHuntHistory,
+  resolveHelperBinary,
   runHunt,
   runSuite,
   stepSchema,
-  updateBacklogFromSuite
+  updateBacklogFromSuite,
+  webOnlyReason
 });
 //# sourceMappingURL=lib.cjs.map