prowl-tools 0.1.3 → 0.1.4

package/dist/index.cjs

@@ -30,6 +30,15 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/types/index.ts
+var SUPPORTED_BROWSER_ENGINES;
+var init_types = __esm({
+  "src/types/index.ts"() {
+    "use strict";
+    SUPPORTED_BROWSER_ENGINES = ["chromium", "firefox", "webkit"];
+  }
+});
+
 // src/config/hunt-name.ts
 function isValidHuntName(name) {
   return HUNT_NAME_PATTERN.test(name);
@@ -50,21 +59,29 @@ var init_hunt_name = __esm({
 });
 
 // src/config/schema.ts
-var import_zod, configSchema, navigateStepSchema, clickStepSchema, singleKeyValueSchema, fillStepSchema, typeStepSchema, pressStepSchema, waitForSelectorStepSchema, waitStepSchema, waitForUrlStepSchema, waitForNetworkIdleStepSchema, selectOptionStepSchema, selectStepSchema, onDialogStepSchema, setInputFilesStepSchema, inlineAssertStepSchema, runHuntStepSchema, hoverStepSchema, scrollStepSchema, scrollToStepSchema, screenshotStepSchema, ifStepSchema, repeatStepSchema, mockRouteStepSchema, unmockRouteStepSchema, evalScriptStepSchema, runScriptStepSchema, assertScreenshotStepSchema, copyTextStepSchema, waitForDownloadStepSchema, stepSchema, assertionSchema, huntSchema;
+var import_zod, webTargetSchema, macosTargetSchema, targetSchema, configSchema, navigateStepSchema, clickStepSchema, singleKeyValueSchema, fillStepSchema, typeStepSchema, pressStepSchema, waitForSelectorStepSchema, waitStepSchema, waitForUrlStepSchema, waitForNetworkIdleStepSchema, selectOptionStepSchema, selectStepSchema, onDialogStepSchema, setInputFilesStepSchema, inlineAssertStepSchema, runHuntStepSchema, hoverStepSchema, scrollStepSchema, scrollToStepSchema, screenshotStepSchema, ifStepSchema, repeatStepSchema, mockRouteStepSchema, unmockRouteStepSchema, evalScriptStepSchema, runScriptStepSchema, assertScreenshotStepSchema, copyTextStepSchema, waitForDownloadStepSchema, stepSchema, assertionSchema, huntSchema;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     "use strict";
     import_zod = require("zod");
+    init_types();
     init_hunt_name();
+    webTargetSchema = import_zod.z.object({
+      type: import_zod.z.literal("web").optional(),
+      url: import_zod.z.string().min(1)
+    }).strict();
+    macosTargetSchema = import_zod.z.object({
+      type: import_zod.z.literal("macos"),
+      app: import_zod.z.string().min(1)
+    }).strict();
+    targetSchema = import_zod.z.union([macosTargetSchema, webTargetSchema]);
     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",
@@ -96,6 +113,7 @@ var init_schema = __esm({
       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(),
@@ -398,11 +416,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,
@@ -426,6 +451,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
     },
@@ -468,10 +494,12 @@ function loadConfig(configPath) {
   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) {
@@ -533,7 +561,7 @@ function listHunts(configDir) {
   scanDir(huntsDir);
   return results.sort((a, b) => a.localeCompare(b));
 }
-var import_node_fs, import_node_path, import_yaml, import_dotenv, DEFAULT_CONFIG, CONFIG_DIR, LEGACY_CONFIG_DIR, legacyDirWarned, VIEWPORT_PRESETS;
+var import_node_fs, import_node_path, import_yaml, import_dotenv, DEFAULT_WEB_URL, DEFAULT_CONFIG, CONFIG_DIR, LEGACY_CONFIG_DIR, legacyDirWarned, VIEWPORT_PRESETS;
 var init_loader = __esm({
   "src/config/loader.ts"() {
     "use strict";
@@ -543,9 +571,11 @@ var init_loader = __esm({
     import_dotenv = __toESM(require("dotenv"), 1);
     init_schema();
     init_hunt_name();
+    DEFAULT_WEB_URL = "http://localhost:3000";
     DEFAULT_CONFIG = {
       target: {
-        url: "http://localhost:3000"
+        type: "web",
+        url: DEFAULT_WEB_URL
       },
       browser: {
         headless: true,
@@ -569,6 +599,7 @@ var init_loader = __esm({
       guardrails: {
         maxSteps: 50,
         allowedDomains: ["localhost", "127.0.0.1", "0.0.0.0"],
+        allowedApps: [],
         forbiddenSelectors: ["[data-danger]", ".delete-btn"],
         selfHealing: false
       },
@@ -597,12 +628,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,
@@ -620,7 +651,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,
@@ -628,16 +659,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);
   }
@@ -649,11 +680,11 @@ var import_commander13 = require("commander");
 // package.json
 var package_default = {
   name: "prowl-tools",
-  version: "0.1.3",
+  version: "0.1.4",
   description: "CLI-first QA testing tool for deterministic Playwright flows.",
   type: "module",
   license: "Apache-2.0",
-  author: "Michael Tookes",
+  author: "Prowl Tools",
   repository: {
     type: "git",
     url: "https://github.com/prowl-tools/prowl.git"
@@ -736,8 +767,8 @@ var import_commander = require("commander");
 var import_chalk3 = __toESM(require("chalk"), 1);
 
 // src/runner/index.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 init_loader();
 
 // src/config/interpolate.ts
@@ -785,7 +816,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++) {
@@ -794,7 +825,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
   };
@@ -1106,255 +1137,943 @@ function interpolateHunt(hunt, env, randomVars = generateRandomVars()) {
   };
 }
 
-// src/browser/controller.ts
+// src/config/target.ts
+var import_node_child_process = require("child_process");
 var import_node_fs2 = __toESM(require("fs"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
-var import_playwright = require("playwright");
-var ENGINES = { chromium: import_playwright.chromium, firefox: import_playwright.firefox, webkit: import_playwright.webkit };
-async function launchBrowser(options) {
-  const engine = ENGINES[options.engine ?? "chromium"];
-  const browser = await engine.launch({
-    headless: options.headless,
-    slowMo: options.slowMo,
-    channel: options.channel
-  });
-  const contextOptions = {};
-  if (options.viewport) {
-    contextOptions.viewport = options.viewport;
+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 (options.storageStatePath) {
-    if (import_node_fs2.default.existsSync(options.storageStatePath)) {
-      contextOptions.storageState = options.storageStatePath;
-    } else {
-      console.warn(`Auth state file not found: ${options.storageStatePath}. Run "prowl login" to create it.`);
+  if ("assert" in step) {
+    const assertion = step.assert;
+    if (assertion.urlIncludes !== void 0 || assertion.urlEquals !== void 0) {
+      return "assert (url)";
     }
   }
-  if (options.recordHar) {
-    contextOptions.recordHar = { path: import_node_path2.default.join(options.runDir, "network.har") };
+  return null;
+}
+function assertStepsSupportedByTarget(steps, target) {
+  if (target !== "macos") {
+    return;
   }
-  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 });
+  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);
+    }
   }
-  return { browser, context, page, tracePath };
 }
-async function closeBrowser(session) {
-  if (session.tracePath) {
-    await session.context.tracing.stop({ path: session.tracePath });
+function assertHuntAssertionsSupportedByTarget(assertions, target) {
+  if (target !== "macos" || !assertions || assertions.length === 0) {
+    return;
   }
-  await session.context.close();
-  await session.browser.close();
+  throw new Error(
+    "Hunt-level assertions are not supported by the macOS target. Use inline assert visible/notVisible steps instead."
+  );
 }
-
-// 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();
+function trimTrailingPathSeparators(value) {
+  return value.replace(/[\\/]+$/g, "");
 }
-async function fillElement(page, selector, value) {
-  await page.locator(selector).fill(value);
+function looksLikeMacosAppPath(app) {
+  const trimmed = trimTrailingPathSeparators(app);
+  return trimmed.includes("/") || trimmed.toLowerCase().endsWith(".app");
 }
-async function pressKey(page, selector, key) {
-  await page.locator(selector).press(key);
+function normalizeAppPath(app) {
+  return import_node_path2.default.resolve(trimTrailingPathSeparators(app));
 }
-async function selectOption(page, selector, value) {
-  await page.locator(selector).selectOption(value);
+function parseBundleIdentifier(plist) {
+  const match = /<key>\s*CFBundleIdentifier\s*<\/key>\s*<string>\s*([^<]+?)\s*<\/string>/s.exec(plist);
+  return match?.[1]?.trim() || null;
 }
-function setupDialogHandler(page, action) {
-  page.once("dialog", async (dialog) => {
-    if (action === "accept") {
-      await dialog.accept();
-    } else {
-      await dialog.dismiss();
+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;
     }
-  });
-}
-async function setInputFiles(page, selector, files) {
-  await page.locator(selector).setInputFiles(files);
-}
-
-// src/runner/steps.ts
-init_loader();
-
-// src/runner/healing.ts
-var INTERACTIVE_TAGS = ["button", "a", "input", "select", "textarea"];
-function extractSelectorIntent(selector) {
-  const raw = [];
-  for (const match of selector.matchAll(/[#.]([A-Za-z_][\w-]*)/g)) {
-    raw.push(match[1]);
+  } catch {
   }
-  for (const match of selector.matchAll(/\[[A-Za-z_:-]+\s*[~|^$*]?=\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+))\]/g)) {
-    const value = match[1] ?? match[2] ?? match[3];
-    if (value) raw.push(value);
+  if (process.platform !== "darwin" || !import_node_fs2.default.existsSync("/usr/bin/plutil")) {
+    return null;
   }
-  const words = [];
-  for (const token of raw) {
-    for (const part of splitToken(token)) {
-      const lower = part.toLowerCase();
-      if (lower.length > 0 && !words.includes(lower)) {
-        words.push(lower);
-      }
+  try {
+    const output = (0, import_node_child_process.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 { words, label: words.join(" ") };
-}
-function splitToken(token) {
-  return token.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s\-_.:]+/).filter((part) => part.length > 0);
+  return [...identities];
 }
-function buildHealCandidates(selector) {
-  const { words, label } = extractSelectorIntent(selector);
-  if (words.length === 0) return [];
-  const escaped = label.replace(/"/g, '\\"');
-  const candidates = [];
-  candidates.push({ selector: `text=${label}`, strategy: "text" });
-  candidates.push({ selector: `[aria-label*="${escaped}" i]`, strategy: "aria" });
-  for (const tag of INTERACTIVE_TAGS) {
-    candidates.push({ selector: `${tag}:has-text("${escaped}")`, strategy: "structural" });
+function assertTargetAppAllowed(allowedApps, app) {
+  if (allowedApps.length === 0) {
+    return;
   }
-  return candidates;
+  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(", ")}).`
+  );
 }
-async function healSelector(page, selector, options) {
-  if (!options.enabled) return null;
-  for (const candidate of buildHealCandidates(selector)) {
-    let count;
+
+// src/browser/playwright-driver.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __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 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
+  });
+  try {
+    const contextOptions = {};
+    if (options.viewport) {
+      contextOptions.viewport = options.viewport;
+    }
+    if (options.storageStatePath) {
+      if (import_node_fs3.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_path3.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_path3.default.join(options.runDir, "trace.zip");
+      await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
+    }
+    return { browser, context, page, tracePath };
+  } catch (error) {
     try {
-      const locator = page.locator(candidate.selector);
-      count = await locator.count();
-    } catch {
-      continue;
+      await browser.close();
+    } catch (closeError) {
+      console.warn(`Failed to close browser after setup error: ${formatError(closeError)}`);
     }
-    if (count === 1) {
-      return { selector: candidate.selector, healedFrom: selector, strategy: candidate.strategy };
+    throw error;
+  }
+}
+async function closeBrowser(session) {
+  try {
+    if (session.tracePath) {
+      await session.context.tracing.stop({ path: session.tracePath });
     }
+    await session.context.close();
+  } finally {
+    await session.browser.close();
   }
-  return null;
 }
-
-// src/runner/steps.ts
-var ALWAYS_ALLOWED_PROTOCOLS = ["about:", "data:"];
+async function saveStorageState(session, storageStatePath) {
+  await session.context.storageState({ path: storageStatePath });
+}
+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);
+}
 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 null;
   }
-  if (trimmed.startsWith("text=")) {
-    return trimmed.slice(5);
+  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 null;
-}
-function matchesForbiddenPattern(selector, forbidden) {
-  const selectorText = unwrapTextSelector(selector);
-  if (selectorText === null) {
-    return false;
-  }
-  const forbiddenText = unwrapTextSelector(forbidden);
-  if (forbiddenText !== null) {
-    return selectorText.includes(forbiddenText);
-  }
-  return selectorText.includes(forbidden);
+  return raw;
 }
-function isForbiddenSelector(selector, forbiddenSelectors) {
-  return forbiddenSelectors.some(
-    (forbidden) => selector.includes(forbidden) || matchesForbiddenPattern(selector, forbidden)
-  );
+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);
+    }
+  };
 }
-function assertAllowedSelector(selector, forbiddenSelectors) {
-  if (isForbiddenSelector(selector, forbiddenSelectors)) {
-    throw new Error(`Forbidden selector: ${selector}`);
+
+// src/browser/mac-helper.ts
+var import_node_child_process2 = require("child_process");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+
+// 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;
 }
-async function resolveActionSelector(context, selector) {
-  assertAllowedSelector(selector, context.forbiddenSelectors);
-  if (!context.selfHealing) {
-    return { selector };
+function parseMacSelector(selector) {
+  const trimmed = selector.trim();
+  const idMatch = /^id=(.+)$/s.exec(trimmed);
+  if (idMatch) {
+    return { by: "id", value: unquote(idMatch[1]) };
   }
-  let matched = false;
-  try {
-    matched = await context.page.locator(selector).count() > 0;
-  } catch {
-    return { selector };
+  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] };
   }
-  if (matched) {
-    return { selector };
+  const labelMatch = /^label=(.+)$/s.exec(trimmed);
+  if (labelMatch) {
+    return { by: "label", value: unquote(labelMatch[1]) };
   }
-  const healed = await healSelector(context.page, selector, { enabled: true });
-  if (!healed) {
-    return { selector };
+  const textMatch = /^text=(.+)$/s.exec(trimmed);
+  if (textMatch) {
+    return { by: "text", value: unquote(textMatch[1]) };
   }
-  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 };
+  return { by: "text", value: trimmed };
 }
-function assertWithinMaxSteps(stepCount, maxSteps, huntName) {
-  if (stepCount > maxSteps) {
-    if (huntName) {
-      throw new Error(`Hunt "${huntName}" has ${stepCount} steps. Max allowed is ${maxSteps}.`);
-    }
-    throw new Error(`Hunt has ${stepCount} steps. Max allowed is ${maxSteps}.`);
+function unwrapMacTextSelector(selector) {
+  const trimmed = selector.trim();
+  if (!trimmed.startsWith("text=")) {
+    return null;
   }
+  return unquote(trimmed.slice(5));
 }
-function getStepType(step) {
-  if ("navigate" in step) return "navigate";
-  if ("click" in step) return "click";
-  if ("fill" in step) return "fill";
-  if ("type" in step) return "type";
-  if ("selectOption" in step) return "selectOption";
-  if ("select" in step) return "select";
-  if ("onDialog" in step) return "onDialog";
-  if ("setInputFiles" in step) return "setInputFiles";
-  if ("runHunt" in step) return "runHunt";
-  if ("assert" in step) return "assert";
-  if ("press" in step) return "press";
-  if ("wait" in step) return "wait";
-  if ("waitForSelector" in step) return "waitForSelector";
-  if ("waitForUrl" in step) return "waitForUrl";
-  if ("waitForNetworkIdle" in step) return "waitForNetworkIdle";
-  if ("hover" in step) return "hover";
-  if ("scroll" in step) return "scroll";
-  if ("scrollTo" in step) return "scrollTo";
-  if ("screenshot" in step) return "screenshot";
-  if ("if" in step) return "if";
-  if ("repeat" in step) return "repeat";
-  if ("mockRoute" in step) return "mockRoute";
-  if ("unmockRoute" in step) return "unmockRoute";
-  if ("evalScript" in step) return "evalScript";
-  if ("runScript" in step) return "runScript";
-  if ("assertScreenshot" in step) return "assertScreenshot";
-  if ("copyText" in step) return "copyText";
-  if ("waitForDownload" in step) return "waitForDownload";
-  return "step";
-}
-var RUNTIME_VAR_PATTERN = /\{\{([A-Z0-9_]+)\}\}/g;
-function substituteRuntimeVars(input, vars) {
-  return input.replace(RUNTIME_VAR_PATTERN, (match, name) => {
-    const value = vars.get(name);
-    return value !== void 0 ? value : match;
-  });
+function num(value) {
+  return typeof value === "number" ? value : Number(value ?? 0);
 }
-function applyRuntimeVars(step, vars) {
-  const sub = (s) => substituteRuntimeVars(s, vars);
-  if ("navigate" in step) return { navigate: sub(step.navigate) };
-  if ("click" in step) {
-    if (typeof step.click === "string") return { click: sub(step.click) };
-    return { click: { selector: sub(step.click.selector) } };
+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 });
   }
-  if ("fill" in step) {
-    if ("selector" in step.fill && "value" in step.fill) {
-      const f = step.fill;
-      return { fill: { selector: sub(f.selector), value: sub(f.value) } };
+  async function clickSelector(selector) {
+    const trimmed = selector.trim();
+    if (trimmed.toLowerCase() === STATUS_ITEM_SELECTOR) {
+      await client.request("openMenu");
+      return;
+    }
+    if (trimmed.toLowerCase().startsWith(MENU_PREFIX)) {
+      await client.request("clickMenu", { title: trimmed.slice(MENU_PREFIX.length).trim() });
+      return;
+    }
+    await query("click", selector);
+  }
+  async function fillSelector(selector, value) {
+    if (selector.trim() === ":focus") {
+      await client.request("fill", { query: { by: "focused" }, value });
+      return;
+    }
+    await query("fill", selector, { value });
+  }
+  return {
+    capabilities: MAC_CAPABILITIES,
+    // navigation -----------------------------------------------------------
+    goto(_url, _options) {
+      return rejectUnsupported("navigate");
+    },
+    currentUrl() {
+      return `macos:${options.appLabel ?? ""}`;
+    },
+    // queries --------------------------------------------------------------
+    async count(selector) {
+      const result = await query("count", selector);
+      return num(result.count);
+    },
+    async textContent(selector) {
+      const result = await query("text", selector);
+      return result.text === void 0 || result.text === null ? null : String(result.text);
+    },
+    // interactions ---------------------------------------------------------
+    click: clickSelector,
+    clickFirst: clickSelector,
+    fill: fillSelector,
+    fillFirst: fillSelector,
+    async press(selector, key) {
+      await query("press", selector, { key });
+    },
+    selectOption() {
+      return rejectUnsupported("select");
+    },
+    selectOptionFirst() {
+      return rejectUnsupported("select");
+    },
+    async hover(selector) {
+      await query("hover", selector);
+    },
+    async scrollIntoView(selector) {
+      await query("scrollTo", selector);
+    },
+    setInputFiles() {
+      return rejectUnsupported("setInputFiles");
+    },
+    // semantic locators ----------------------------------------------------
+    async countByRole(role, name) {
+      const result = await client.request("count", { query: { by: "role", role, name } });
+      return num(result.count);
+    },
+    async clickFirstByRole(role, name) {
+      await client.request("click", { query: { by: "role", role, name } });
+    },
+    async countByLabel(label) {
+      const result = await client.request("count", { query: { by: "label", value: label } });
+      return num(result.count);
+    },
+    async fillFirstByLabel(label, value) {
+      await client.request("fill", { query: { by: "label", value: label }, value });
+    },
+    selectOptionFirstByLabel() {
+      return rejectUnsupported("select");
+    },
+    // waiting --------------------------------------------------------------
+    async waitForSelector(selector, waitOptions) {
+      const extra = waitOptions?.timeout !== void 0 ? { timeout: waitOptions.timeout / 1e3 } : void 0;
+      await query("waitFor", selector, extra);
+    },
+    waitForUrl() {
+      return rejectUnsupported("waitForUrl");
+    },
+    waitForNetworkIdle() {
+      return rejectUnsupported("waitForNetworkIdle");
+    },
+    // scripting & artifacts ------------------------------------------------
+    evaluate() {
+      return rejectUnsupported("evalScript");
+    },
+    async screenshot(screenshotOptions) {
+      await client.request("screenshot", { path: screenshotOptions.path });
+    },
+    // network / dialogs / downloads (all web-only) -------------------------
+    onResponse(_handler) {
+      throw unsupported("onResponse");
+    },
+    route(_url, _handler) {
+      return rejectUnsupported("mockRoute");
+    },
+    unroute() {
+      return rejectUnsupported("unmockRoute");
+    },
+    onDialog(_action) {
+      throw unsupported("onDialog");
+    },
+    waitForDownloadEvent() {
+      return rejectUnsupported("waitForDownload");
+    },
+    parseTextSelector(selector) {
+      return unwrapMacTextSelector(selector);
+    }
+  };
+}
+
+// src/browser/mac-helper.ts
+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_path4.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+  const root = import_node_path4.default.parse(dir).root;
+  while (dir !== root) {
+    if (import_node_fs4.default.existsSync(import_node_path4.default.join(dir, "package.json"))) {
+      return dir;
+    }
+    dir = import_node_path4.default.dirname(dir);
+  }
+  return root;
+}
+function resolveHelperBinary(env = process.env) {
+  const override = env.PROWL_MACDRIVER_BIN;
+  if (override) {
+    if (!import_node_fs4.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_path4.default.join(root, "macdriver", ".build", "release", HELPER_BINARY),
+    import_node_path4.default.join(root, "macdriver", ".build", "debug", HELPER_BINARY)
+  ];
+  for (const candidate of candidates) {
+    if (import_node_fs4.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_process2.spawn)(binaryPath, ["serve"], { stdio: ["pipe", "pipe", "pipe"] });
+    this.child.stdout?.setEncoding("utf-8");
+    this.child.stderr?.setEncoding("utf-8");
+    this.child.stdout?.on("data", (chunk) => this.onStdout(chunk));
+    this.child.stderr?.on("data", (chunk) => {
+      this.stderrBuffer = (this.stderrBuffer + chunk).slice(-4e3);
+    });
+    this.child.on("error", (error) => this.recordTerminalFailure(error));
+    this.child.on("exit", (code) => {
+      if (!this.closed) {
+        const detail = this.stderrBuffer.trim();
+        this.recordTerminalFailure(
+          new Error(`prowl-macdriver exited unexpectedly (code ${code ?? "null"})${detail ? `: ${detail}` : ""}`)
+        );
+      }
+    });
+  }
+  onStdout(chunk) {
+    this.stdoutBuffer += chunk;
+    let newlineIndex = this.stdoutBuffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
+      this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);
+      if (line.length > 0) {
+        this.dispatch(line);
+      }
+      newlineIndex = this.stdoutBuffer.indexOf("\n");
+    }
+  }
+  dispatch(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const id = typeof message.id === "number" ? message.id : void 0;
+    if (id === void 0) {
+      return;
+    }
+    const pending = this.pending.get(id);
+    if (!pending) {
+      return;
+    }
+    this.pending.delete(id);
+    clearTimeout(pending.timer);
+    if (message.ok === true) {
+      pending.resolve(message.result ?? {});
+    } else {
+      pending.reject(new Error(typeof message.error === "string" ? message.error : "prowl-macdriver error"));
+    }
+  }
+  failAll(error) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pending.clear();
+  }
+  recordTerminalFailure(error) {
+    this.terminalError ??= error;
+    this.closed = true;
+    this.failAll(this.terminalError);
+  }
+  /** Number of in-flight requests awaiting a response (for teardown/tests). */
+  get pendingCount() {
+    return this.pending.size;
+  }
+  request(cmd, params = {}) {
+    if (this.terminalError) {
+      return Promise.reject(this.terminalError);
+    }
+    if (this.closed) {
+      return Promise.reject(new Error("prowl-macdriver client is closed"));
+    }
+    const id = this.nextId++;
+    const payload = JSON.stringify({ id, cmd, ...params });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        if (this.pending.delete(id)) {
+          const shown = this.requestTimeoutMs >= 1e3 ? `${Math.round(this.requestTimeoutMs / 1e3)}s` : `${this.requestTimeoutMs}ms`;
+          reject(new Error(`prowl-macdriver request "${cmd}" timed out after ${shown}`));
+        }
+      }, this.requestTimeoutMs);
+      timer.unref?.();
+      this.pending.set(id, { cmd, resolve, reject, timer });
+      this.child.stdin?.write(payload + "\n", (error) => {
+        if (error && this.pending.delete(id)) {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+  }
+  async close() {
+    if (this.closed) {
+      return;
+    }
+    this.closed = true;
+    try {
+      this.child.stdin?.write(JSON.stringify({ cmd: "shutdown" }) + "\n");
+      this.child.stdin?.end();
+    } catch {
+    }
+    await new Promise((resolve) => {
+      if (this.child.exitCode !== null || this.child.signalCode !== null) {
+        resolve();
+        return;
+      }
+      const timer = setTimeout(() => {
+        this.child.kill("SIGKILL");
+        resolve();
+      }, 2e3);
+      this.child.once("exit", () => {
+        clearTimeout(timer);
+        resolve();
+      });
+    });
+    this.failAll(new Error("prowl-macdriver client is closed"));
+  }
+};
+async function launchMacSession(options) {
+  const requestTimeoutMs = Math.max(options.timeoutMs ?? 1e4, DEFAULT_REQUEST_TIMEOUT_MS) + 5e3;
+  const client = options.clientFactory ? options.clientFactory() : new SpawnMacHelperClient(resolveHelperBinary(), { requestTimeoutMs });
+  const timeoutSeconds = (options.timeoutMs ?? 1e4) / 1e3;
+  try {
+    const trust = await client.request("check");
+    if (trust.trusted !== true) {
+      throw new Error(
+        "Prowl's macOS target is not trusted for Accessibility. Grant the hosting terminal/app permission in System Settings \u2192 Privacy & Security \u2192 Accessibility, then retry."
+      );
+    }
+    const launched = await client.request("launch", { app: options.app, timeout: timeoutSeconds });
+    const bundleId = String(launched.bundleId ?? options.app);
+    const driver = createMacDriver(client, { appLabel: bundleId });
+    return { client, driver, bundleId };
+  } catch (error) {
+    await client.close().catch(() => void 0);
+    throw error;
+  }
+}
+async function closeMacSession(session) {
+  try {
+    await session.client.request("quit");
+  } catch {
+  } finally {
+    await session.client.close();
+  }
+}
+
+// src/runner/steps.ts
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+init_loader();
+
+// src/runner/healing.ts
+var INTERACTIVE_TAGS = ["button", "a", "input", "select", "textarea"];
+function extractSelectorIntent(selector) {
+  const raw = [];
+  for (const match of selector.matchAll(/[#.]([A-Za-z_][\w-]*)/g)) {
+    raw.push(match[1]);
+  }
+  for (const match of selector.matchAll(/\[[A-Za-z_:-]+\s*[~|^$*]?=\s*(?:"([^"]*)"|'([^']*)'|([^\]\s]+))\]/g)) {
+    const value = match[1] ?? match[2] ?? match[3];
+    if (value) raw.push(value);
+  }
+  const words = [];
+  for (const token of raw) {
+    for (const part of splitToken(token)) {
+      const lower = part.toLowerCase();
+      if (lower.length > 0 && !words.includes(lower)) {
+        words.push(lower);
+      }
+    }
+  }
+  return { words, label: words.join(" ") };
+}
+function splitToken(token) {
+  return token.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[\s\-_.:]+/).filter((part) => part.length > 0);
+}
+function buildHealCandidates(selector) {
+  const { words, label } = extractSelectorIntent(selector);
+  if (words.length === 0) return [];
+  const escaped = label.replace(/"/g, '\\"');
+  const candidates = [];
+  candidates.push({ selector: `text=${label}`, strategy: "text" });
+  candidates.push({ selector: `[aria-label*="${escaped}" i]`, strategy: "aria" });
+  for (const tag of INTERACTIVE_TAGS) {
+    candidates.push({ selector: `${tag}:has-text("${escaped}")`, strategy: "structural" });
+  }
+  return candidates;
+}
+async function healSelector(probe, selector, options) {
+  if (!options.enabled) return null;
+  for (const candidate of buildHealCandidates(selector)) {
+    let count;
+    try {
+      const locator = probe.locator(candidate.selector);
+      count = await locator.count();
+    } catch {
+      continue;
+    }
+    if (count === 1) {
+      return { selector: candidate.selector, healedFrom: selector, strategy: candidate.strategy };
+    }
+  }
+  return null;
+}
+
+// src/runner/policy.ts
+var ALWAYS_ALLOWED_PROTOCOLS = ["about:", "data:"];
+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);
+  }
+  function isForbiddenSelector(selector) {
+    return forbiddenSelectors.some(
+      (forbidden) => selector.includes(forbidden) || matchesForbiddenPattern(selector, forbidden)
+    );
+  }
+  function assertAllowedSelector(selector) {
+    if (isForbiddenSelector(selector)) {
+      throw new Error(`Forbidden selector: ${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}.`);
+    }
+  }
+  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}`);
+    }
+  }
+  function ensureAppAllowed(app) {
+    if (!allowedApps.includes(app)) {
+      throw new Error(`Interaction with disallowed app: ${app}`);
+    }
+  }
+  function ensureLocationAllowed(activeDriver) {
+    if (activeDriver.capabilities.has("navigate")) {
+      ensureUrlAllowed(activeDriver.currentUrl());
+    }
+  }
+  const healProbe = {
+    locator: (selector) => ({ count: () => driver.count(selector) })
+  };
+  async function resolveActionSelector(selector) {
+    assertAllowedSelector(selector);
+    if (!selfHealing) {
+      return { selector };
+    }
+    let matched = false;
+    try {
+      matched = await driver.count(selector) > 0;
+    } catch {
+      return { selector };
+    }
+    if (matched) {
+      return { selector };
+    }
+    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";
+  if ("fill" in step) return "fill";
+  if ("type" in step) return "type";
+  if ("selectOption" in step) return "selectOption";
+  if ("select" in step) return "select";
+  if ("onDialog" in step) return "onDialog";
+  if ("setInputFiles" in step) return "setInputFiles";
+  if ("runHunt" in step) return "runHunt";
+  if ("assert" in step) return "assert";
+  if ("press" in step) return "press";
+  if ("wait" in step) return "wait";
+  if ("waitForSelector" in step) return "waitForSelector";
+  if ("waitForUrl" in step) return "waitForUrl";
+  if ("waitForNetworkIdle" in step) return "waitForNetworkIdle";
+  if ("hover" in step) return "hover";
+  if ("scroll" in step) return "scroll";
+  if ("scrollTo" in step) return "scrollTo";
+  if ("screenshot" in step) return "screenshot";
+  if ("if" in step) return "if";
+  if ("repeat" in step) return "repeat";
+  if ("mockRoute" in step) return "mockRoute";
+  if ("unmockRoute" in step) return "unmockRoute";
+  if ("evalScript" in step) return "evalScript";
+  if ("runScript" in step) return "runScript";
+  if ("assertScreenshot" in step) return "assertScreenshot";
+  if ("copyText" in step) return "copyText";
+  if ("waitForDownload" in step) return "waitForDownload";
+  return "step";
+}
+var RUNTIME_VAR_PATTERN = /\{\{([A-Z0-9_]+)\}\}/g;
+function substituteRuntimeVars(input, vars) {
+  return input.replace(RUNTIME_VAR_PATTERN, (match, name) => {
+    const value = vars.get(name);
+    return value !== void 0 ? value : match;
+  });
+}
+function applyRuntimeVars(step, vars) {
+  const sub = (s) => substituteRuntimeVars(s, vars);
+  if ("navigate" in step) return { navigate: sub(step.navigate) };
+  if ("click" in step) {
+    if (typeof step.click === "string") return { click: sub(step.click) };
+    return { click: { selector: sub(step.click.selector) } };
+  }
+  if ("fill" in step) {
+    if ("selector" in step.fill && "value" in step.fill) {
+      const f = step.fill;
+      return { fill: { selector: sub(f.selector), value: sub(f.value) } };
     }
     const [key, value] = Object.entries(step.fill)[0];
     return { fill: { [sub(key)]: sub(value) } };
@@ -1409,17 +2128,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();
@@ -1446,56 +2154,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}"`);
@@ -1623,11 +2325,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}`);
     }
@@ -1635,22 +2337,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}`);
     }
@@ -1659,7 +2361,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}`;
@@ -1667,8 +2369,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;
 }
@@ -1676,14 +2378,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}`);
@@ -1702,608 +2404,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 } : {}
-        };
-      } else if ("screenshot" in step) {
-        const name = step.screenshot.name ?? `manual_step_${index + 1}.png`;
-        if (/[/\\]|\.\./.test(name)) {
-          throw new Error(`Invalid screenshot name: "${name}" must not contain path separators or ".."`);
         }
-        const fileName = name.endsWith(".png") ? name : `${name}.png`;
-        const relative = await addScreenshot(fileName);
-        stepResult = {
-          type: "screenshot",
-          status: "pass",
-          durationMs: Date.now() - stepStart,
-          screenshot: relative
-        };
-      } else if ("if" in step) {
-        const condition = step.if;
-        const selector = condition.visible ?? condition.notVisible;
-        assertAllowedSelector(selector, context.forbiddenSelectors);
-        const count = await context.page.locator(selector).count();
-        const conditionMet = condition.visible !== void 0 ? count > 0 : count === 0;
-        if (conditionMet) {
-          const subResult = await executeNestedSteps(context, {
-            steps: condition.then,
-            stepPathPrefix: `${currentStepPath}.if.then`
-          });
-          for (const sr of subResult.results) {
-            results.push({ ...sr, type: `if > ${sr.type}` });
-          }
-          screenshots.push(...subResult.screenshots);
-          if (subResult.failed) {
-            return {
-              results,
-              screenshots,
-              failed: true,
-              error: subResult.error
-            };
-          }
-          stepResult = {
+      };
+    }
+  },
+  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() - stepStart,
+            durationMs: Date.now() - h.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"
-            };
           }
+        };
+      }
+      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}` });
+        }
+        h.screenshots.push(...subResult.screenshots);
+        if (subResult.failed) {
+          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})`);
+        return {
+          kind: "result",
+          result: {
+            type: "if",
+            status: "pass",
+            durationMs: Date.now() - h.stepStart,
+            value: `condition not met, executed ${condition.else.length} else steps`
           }
-          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
-              };
-            }
+        };
+      }
+      return {
+        kind: "result",
+        result: {
+          type: "if",
+          status: "pass",
+          durationMs: Date.now() - h.stepStart,
+          value: "condition not met, skipped"
+        }
+      };
+    }
+  },
+  repeat: {
+    capabilities: ["query"],
+    run: async (h) => {
+      if (!("repeat" in h.step)) unknownStep();
+      const repeat = h.step.repeat;
+      let totalSubSteps = 0;
+      if (repeat.times !== void 0) {
+        const totalPlanned = repeat.times * repeat.steps.length;
+        if (totalPlanned + totalSubSteps > h.context.maxSteps) {
+          throw new Error(`Repeat exceeded maxSteps guardrail (${h.context.maxSteps})`);
+        }
+        for (let i = 0; i < repeat.times; i++) {
+          totalSubSteps += repeat.steps.length;
+          const subResult = await h.executeNested({
+            steps: repeat.steps,
+            stepPathPrefix: `${h.stepPath}.repeat.steps`
+          });
+          for (const sr of subResult.results) {
+            h.results.push({ ...sr, type: `repeat[${i}] > ${sr.type}` });
           }
-        } 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
-              };
-            }
+          h.screenshots.push(...subResult.screenshots);
+          if (subResult.failed) {
+            return { kind: "abort", 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");
+      } 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})`);
+          }
+          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);
@@ -2330,12 +3208,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
@@ -2495,18 +3373,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");
 }
@@ -2584,15 +3462,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;");
 }
@@ -2636,8 +3514,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;
 }
@@ -2671,15 +3549,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") {
@@ -2690,11 +3568,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);
@@ -2733,12 +3611,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);
@@ -2750,10 +3628,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(
@@ -2766,9 +3644,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);
   });
 }
 
@@ -2781,11 +3659,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 {
@@ -2804,12 +3682,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;
 }
@@ -2817,8 +3695,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;
@@ -2837,6 +3715,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
   });
   let result;
   try {
+    const driver = createPlaywrightDriver(session.page);
     const consoleEntries = [];
     const networkEntries = [];
     const traceCorrelations = [];
@@ -2848,7 +3727,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);
@@ -2862,6 +3741,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
     try {
       const stepExecution = await executeSteps({
         page: session.page,
+        driver,
         steps: interpolatedHunt.steps,
         targetUrl,
         runDir,
@@ -2894,7 +3774,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;
     }
@@ -2938,6 +3818,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,
@@ -2988,9 +3871,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,
       {
@@ -3215,37 +4213,37 @@ function buildRunCommand() {
 }
 
 // src/cli/commands/init.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
-var import_node_url = require("url");
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
 var import_commander2 = require("commander");
 var import_chalk4 = __toESM(require("chalk"), 1);
 init_loader();
-var import_meta = {};
-function getPackageRoot() {
-  const currentFile = (0, import_node_url.fileURLToPath)(import_meta.url);
-  let dir = import_node_path10.default.dirname(currentFile);
-  const root = import_node_path10.default.parse(dir).root;
+var import_meta2 = {};
+function getPackageRoot2() {
+  const currentFile = (0, import_node_url2.fileURLToPath)(import_meta2.url);
+  let dir = import_node_path12.default.dirname(currentFile);
+  const root = import_node_path12.default.parse(dir).root;
   while (dir !== root) {
-    if (import_node_fs10.default.existsSync(import_node_path10.default.join(dir, "package.json"))) {
+    if (import_node_fs12.default.existsSync(import_node_path12.default.join(dir, "package.json"))) {
       return dir;
     }
-    dir = import_node_path10.default.dirname(dir);
+    dir = import_node_path12.default.dirname(dir);
   }
-  if (import_node_fs10.default.existsSync(import_node_path10.default.join(root, "package.json"))) {
+  if (import_node_fs12.default.existsSync(import_node_path12.default.join(root, "package.json"))) {
     return root;
   }
   throw new Error("Cannot find package root. Reinstall prowl-tools.");
 }
 function copyFile(source, destination) {
-  import_node_fs10.default.mkdirSync(import_node_path10.default.dirname(destination), { recursive: true });
-  import_node_fs10.default.copyFileSync(source, destination);
+  import_node_fs12.default.mkdirSync(import_node_path12.default.dirname(destination), { recursive: true });
+  import_node_fs12.default.copyFileSync(source, destination);
 }
 function buildInitCommand() {
   const command = new import_commander2.Command("init").option("--force", `Overwrite existing ${CONFIG_DIR} directory`).action((options) => {
     const root = process.cwd();
-    const prowlDir = import_node_path10.default.join(root, CONFIG_DIR);
-    if (import_node_fs10.default.existsSync(prowlDir) && !options.force) {
+    const prowlDir = import_node_path12.default.join(root, CONFIG_DIR);
+    if (import_node_fs12.default.existsSync(prowlDir) && !options.force) {
       console.error(
         import_chalk4.default.red(
           `${CONFIG_DIR} already exists. Run with --force to reinitialize prowl configuration without deleting existing files.`
@@ -3254,21 +4252,21 @@ function buildInitCommand() {
       process.exitCode = 1;
       return;
     }
-    const packageRoot = getPackageRoot();
-    const examplesDir = import_node_path10.default.join(packageRoot, "examples");
-    const exampleConfig = import_node_path10.default.join(examplesDir, "config.yml");
-    const exampleHuntsDir = import_node_path10.default.join(examplesDir, "hunts");
-    if (!import_node_fs10.default.existsSync(exampleConfig) || !import_node_fs10.default.existsSync(exampleHuntsDir)) {
+    const packageRoot = getPackageRoot2();
+    const examplesDir = import_node_path12.default.join(packageRoot, "examples");
+    const exampleConfig = import_node_path12.default.join(examplesDir, "config.yml");
+    const exampleHuntsDir = import_node_path12.default.join(examplesDir, "hunts");
+    if (!import_node_fs12.default.existsSync(exampleConfig) || !import_node_fs12.default.existsSync(exampleHuntsDir)) {
       console.error(import_chalk4.default.red("Examples not found in package. Reinstall prowl-tools."));
       process.exitCode = 1;
       return;
     }
-    copyFile(exampleConfig, import_node_path10.default.join(prowlDir, "config.yml"));
-    const huntFiles = import_node_fs10.default.readdirSync(exampleHuntsDir).filter((f) => f.endsWith(".yml"));
+    copyFile(exampleConfig, import_node_path12.default.join(prowlDir, "config.yml"));
+    const huntFiles = import_node_fs12.default.readdirSync(exampleHuntsDir).filter((f) => f.endsWith(".yml"));
     for (const huntFile of huntFiles) {
       copyFile(
-        import_node_path10.default.join(exampleHuntsDir, huntFile),
-        import_node_path10.default.join(prowlDir, "hunts", huntFile)
+        import_node_path12.default.join(exampleHuntsDir, huntFile),
+        import_node_path12.default.join(prowlDir, "hunts", huntFile)
       );
     }
     const gitignore = [
@@ -3282,7 +4280,7 @@ function buildInitCommand() {
       ".env",
       ""
     ].join("\n");
-    import_node_fs10.default.writeFileSync(import_node_path10.default.join(prowlDir, ".gitignore"), gitignore);
+    import_node_fs12.default.writeFileSync(import_node_path12.default.join(prowlDir, ".gitignore"), gitignore);
     console.log(welcomeBanner());
     console.log(import_chalk4.default.green(`  Initialized ${CONFIG_DIR} directory.`));
     console.log(import_chalk4.default.gray("  Run ") + import_chalk4.default.bold("prowl run hello") + import_chalk4.default.gray(" to get started."));
@@ -3292,18 +4290,17 @@ function buildInitCommand() {
 }
 
 // src/cli/commands/login.ts
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 var import_node_readline = __toESM(require("readline"), 1);
 var import_chalk5 = __toESM(require("chalk"), 1);
 var import_commander3 = require("commander");
-var import_playwright2 = require("playwright");
 init_loader();
 function resolvePath2(configDir, inputPath) {
-  if (import_node_path11.default.isAbsolute(inputPath)) {
+  if (import_node_path13.default.isAbsolute(inputPath)) {
     return inputPath;
   }
-  const projectRoot = import_node_path11.default.dirname(configDir);
-  return import_node_path11.default.join(projectRoot, inputPath);
+  const projectRoot = import_node_path13.default.dirname(configDir);
+  return import_node_path13.default.join(projectRoot, inputPath);
 }
 function waitForEnter(prompt) {
   return new Promise((resolve) => {
@@ -3316,30 +4313,35 @@ function waitForEnter(prompt) {
 }
 function buildLoginCommand() {
   const command = new import_commander3.Command("login").option("--url <target>", "Override target URL").option("--config <path>", "Custom config path").action(async (options) => {
-    let browser = null;
-    let context = null;
+    let session = null;
     try {
       const { config, configDir } = loadConfig(options.config);
+      if (config.target.type === "macos") {
+        throw new Error("`prowl login` captures browser auth state and only applies to web targets.");
+      }
       const targetUrl = options.url ?? config.target.url;
       const storageStatePath = config.auth.storageStatePath ? resolvePath2(configDir, config.auth.storageStatePath) : resolvePath2(configDir, ".prowl/auth-state.json");
-      browser = await import_playwright2.chromium.launch({ headless: false });
-      context = await browser.newContext();
-      const page = await context.newPage();
-      await page.goto(targetUrl);
+      session = await launchBrowser({
+        headless: false,
+        slowMo: 0,
+        timeout: config.browser.timeout,
+        trace: false,
+        recordHar: false,
+        runDir: configDir
+      });
+      const driver = createPlaywrightDriver(session.page);
+      await driver.goto(targetUrl);
       console.log(import_chalk5.default.green("Browser opened. Log in manually."));
       await waitForEnter("Press Enter to save auth state and close the browser... ");
-      await context.storageState({ path: storageStatePath });
+      await saveStorageState(session, storageStatePath);
       console.log(import_chalk5.default.green(`Saved auth state to ${storageStatePath}`));
     } catch (error) {
       const message = error instanceof Error ? error.message : "Login failed";
       console.error(import_chalk5.default.red(`Error: ${message}`));
       process.exitCode = 1;
     } finally {
-      if (context) {
-        await context.close();
-      }
-      if (browser) {
-        await browser.close();
+      if (session) {
+        await closeBrowser(session);
       }
     }
   });
@@ -3385,18 +4387,18 @@ function buildListCommand() {
 }
 
 // src/cli/commands/watch.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
 var import_chalk7 = __toESM(require("chalk"), 1);
 var import_commander5 = require("commander");
 init_loader();
 
 // src/cli/watch-utils.ts
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 function getWatchTargets(configDir, huntName) {
   return [
-    import_node_path12.default.join(configDir, "hunts", `${huntName}.yml`),
-    import_node_path12.default.join(configDir, "config.yml"),
-    import_node_path12.default.join(configDir, ".env")
+    import_node_path14.default.join(configDir, "hunts", `${huntName}.yml`),
+    import_node_path14.default.join(configDir, "config.yml"),
+    import_node_path14.default.join(configDir, ".env")
   ];
 }
 function createDebouncer(delayMs, fn) {
@@ -3465,14 +4467,14 @@ function buildWatchCommand() {
     });
     const unwatch = [];
     for (const target of watchTargets) {
-      import_node_fs11.default.watchFile(target, { interval: 150 }, (curr, prev) => {
+      import_node_fs13.default.watchFile(target, { interval: 150 }, (curr, prev) => {
         if (curr.mtimeMs === prev.mtimeMs && curr.size === prev.size) {
           return;
         }
         console.log(import_chalk7.default.gray(`Change detected: ${target}`));
         debounced.trigger();
       });
-      unwatch.push(() => import_node_fs11.default.unwatchFile(target));
+      unwatch.push(() => import_node_fs13.default.unwatchFile(target));
     }
     const stop = () => {
       if (stopped) {
@@ -3498,12 +4500,12 @@ var import_commander6 = require("commander");
 var import_chalk9 = __toESM(require("chalk"), 1);
 
 // src/runner/suite.ts
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 init_loader();
 
 // src/reporter/ci-summary.ts
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var import_chalk8 = __toESM(require("chalk"), 1);
 function countCiResults(results) {
   return {
@@ -3567,9 +4569,9 @@ function writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky = []
     ...flaky.length > 0 ? { flaky } : {},
     ...clusters.length > 0 ? { clusters } : {}
   };
-  import_node_fs12.default.mkdirSync(ciRunDir, { recursive: true });
-  const filePath = import_node_path13.default.join(ciRunDir, "ci-result.json");
-  import_node_fs12.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
+  import_node_fs14.default.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = import_node_path15.default.join(ciRunDir, "ci-result.json");
+  import_node_fs14.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
   return filePath;
 }
 
@@ -3703,8 +4705,8 @@ function clusterFailures(failures) {
 }
 
 // src/backlog/index.ts
-var import_node_fs13 = __toESM(require("fs"), 1);
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/backlog/parse.ts
 var MARKER_FP = /<!--\s*prowl:fp=([0-9a-f]+)/;
@@ -3794,7 +4796,7 @@ ${after}`;
 // src/backlog/index.ts
 function readFileOrEmpty(filePath) {
   try {
-    return import_node_fs13.default.readFileSync(filePath, "utf-8");
+    return import_node_fs15.default.readFileSync(filePath, "utf-8");
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") return "";
@@ -3810,7 +4812,7 @@ function buildFailure(hunt) {
   if (!hunt.runDir) return failure;
   let run;
   try {
-    const resultJson = readFileOrEmpty(import_node_path14.default.join(hunt.runDir, "result.json"));
+    const resultJson = readFileOrEmpty(import_node_path16.default.join(hunt.runDir, "result.json"));
     if (!resultJson) return failure;
     run = JSON.parse(resultJson);
   } catch (error) {
@@ -3839,8 +4841,8 @@ function extractFailures(suiteResult) {
 }
 function updateBacklogFromSuite(suiteResult, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  const backlogPath = options.backlogPath ?? import_node_path14.default.join(projectRoot, "docs", "backlog.md");
-  const resolvedPath = options.resolvedPath ?? import_node_path14.default.join(projectRoot, "docs", "resolved.md");
+  const backlogPath = options.backlogPath ?? import_node_path16.default.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? import_node_path16.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);
@@ -3872,8 +4874,8 @@ function updateBacklogFromSuite(suiteResult, options = {}) {
     }
   }
   if (ticketsToAdd.length > 0) {
-    import_node_fs13.default.mkdirSync(import_node_path14.default.dirname(backlogPath), { recursive: true });
-    import_node_fs13.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+    import_node_fs15.default.mkdirSync(import_node_path16.default.dirname(backlogPath), { recursive: true });
+    import_node_fs15.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
   }
   return summary;
 }
@@ -4034,7 +5036,7 @@ async function runSuite(options = {}) {
   const clusters = clusterFailures(
     extractFailures({ result: { hunts: results }, resultPath: null })
   ).filter((cluster) => cluster.count > 1);
-  const ciRunDir = import_node_path15.default.join(configDir, "runs", timestamp("ci"));
+  const ciRunDir = import_node_path17.default.join(configDir, "runs", timestamp("ci"));
   const resultPath = writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky, clusters);
   const { passed, failed, skipped } = countCiResults(results);
   return {
@@ -4152,8 +5154,8 @@ function buildCiCommand() {
 }
 
 // src/cli/commands/update-baselines.ts
-var import_node_fs14 = __toESM(require("fs"), 1);
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_commander7 = require("commander");
 var import_chalk10 = __toESM(require("chalk"), 1);
 init_loader();
@@ -4161,33 +5163,33 @@ function buildUpdateBaselinesCommand() {
   const command = new import_commander7.Command("update-baselines").description("Accept current screenshots as new visual regression baselines").option("--run <dir>", "Specific run directory to use").option("--name <name>", "Update only a specific baseline by name").option("--config <path>", "Custom config path").option("-y, --yes", "Skip confirmation prompt").action(async (options) => {
     try {
       const { configDir } = loadConfig(options.config);
-      const baselinesDir = import_node_path16.default.join(configDir, "baselines");
-      import_node_fs14.default.mkdirSync(baselinesDir, { recursive: true });
+      const baselinesDir = import_node_path18.default.join(configDir, "baselines");
+      import_node_fs16.default.mkdirSync(baselinesDir, { recursive: true });
       let runDir;
       if (options.run) {
-        runDir = import_node_path16.default.isAbsolute(options.run) ? options.run : import_node_path16.default.resolve(options.run);
+        runDir = import_node_path18.default.isAbsolute(options.run) ? options.run : import_node_path18.default.resolve(options.run);
       } else {
-        const runsDir = import_node_path16.default.join(configDir, "runs");
-        if (!import_node_fs14.default.existsSync(runsDir)) {
+        const runsDir = import_node_path18.default.join(configDir, "runs");
+        if (!import_node_fs16.default.existsSync(runsDir)) {
           console.error(import_chalk10.default.red("  No runs directory found. Run a hunt first."));
           process.exitCode = 1;
           return;
         }
-        const entries = import_node_fs14.default.readdirSync(runsDir).filter((e) => import_node_fs14.default.statSync(import_node_path16.default.join(runsDir, e)).isDirectory()).sort().reverse();
+        const entries = import_node_fs16.default.readdirSync(runsDir).filter((e) => import_node_fs16.default.statSync(import_node_path18.default.join(runsDir, e)).isDirectory()).sort().reverse();
         if (entries.length === 0) {
           console.error(import_chalk10.default.red("  No run directories found. Run a hunt first."));
           process.exitCode = 1;
           return;
         }
-        runDir = import_node_path16.default.join(runsDir, entries[0]);
+        runDir = import_node_path18.default.join(runsDir, entries[0]);
       }
-      const screenshotsDir = import_node_path16.default.join(runDir, "screenshots");
-      if (!import_node_fs14.default.existsSync(screenshotsDir)) {
+      const screenshotsDir = import_node_path18.default.join(runDir, "screenshots");
+      if (!import_node_fs16.default.existsSync(screenshotsDir)) {
         console.error(import_chalk10.default.red(`  No screenshots found in ${runDir}`));
         process.exitCode = 1;
         return;
       }
-      const screenshots = import_node_fs14.default.readdirSync(screenshotsDir).filter((f) => f.endsWith("-current.png"));
+      const screenshots = import_node_fs16.default.readdirSync(screenshotsDir).filter((f) => f.endsWith("-current.png"));
       if (screenshots.length === 0) {
         console.log(import_chalk10.default.yellow("  No assertScreenshot results found in this run."));
         return;
@@ -4201,10 +5203,10 @@ function buildUpdateBaselinesCommand() {
       let updated = 0;
       for (const file of filtered) {
         const baselineName = file.replace("-current.png", ".png");
-        const sourcePath = import_node_path16.default.join(screenshotsDir, file);
-        const destPath = import_node_path16.default.join(baselinesDir, baselineName);
-        const exists = import_node_fs14.default.existsSync(destPath);
-        import_node_fs14.default.copyFileSync(sourcePath, destPath);
+        const sourcePath = import_node_path18.default.join(screenshotsDir, file);
+        const destPath = import_node_path18.default.join(baselinesDir, baselineName);
+        const exists = import_node_fs16.default.existsSync(destPath);
+        import_node_fs16.default.copyFileSync(sourcePath, destPath);
         updated++;
         const status = exists ? import_chalk10.default.yellow("updated") : import_chalk10.default.green("created");
         console.log(`  ${status} ${baselineName}`);
@@ -4226,7 +5228,21 @@ function buildUpdateBaselinesCommand() {
 // src/cli/commands/analyze.ts
 var import_commander8 = require("commander");
 var import_chalk11 = __toESM(require("chalk"), 1);
-var import_playwright3 = require("playwright");
+
+// src/browser/engines.ts
+init_types();
+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/analyzer/index.ts
 async function analyzePage(page) {
@@ -4345,7 +5361,6 @@ async function analyzePage(page) {
 
 // src/cli/commands/analyze.ts
 init_loader();
-var ENGINES2 = { chromium: import_playwright3.chromium, firefox: import_playwright3.firefox, webkit: import_playwright3.webkit };
 function parseViewportFlag2(value) {
   const match = /^(\d+)x(\d+)$/i.exec(value);
   if (match) {
@@ -4356,19 +5371,24 @@ function parseViewportFlag2(value) {
 function buildAnalyzeCommand() {
   const command = new import_commander8.Command("analyze").argument("<url>", "URL to analyze").description("Analyze a page to discover interactive elements and selectors").option("--json", "Output as JSON").option("--browser <engine>", "Browser engine: chromium, firefox, or webkit").option("--channel <name>", "Browser channel: chrome, msedge, etc.").option("--viewport <size>", "Viewport size: WxH or preset (mobile, tablet, desktop)").option("--headed", "Show browser window").option("--config <path>", "Custom config path").action(async (url, options) => {
     try {
-      const engine = options.browser ?? "chromium";
+      const engine = parseBrowserEngine(options.browser);
       const channel = options.channel;
       const viewport = options.viewport ? resolveViewport(parseViewportFlag2(options.viewport)) : { width: 1280, height: 720 };
-      const browserEngine = ENGINES2[engine];
-      const browser = await browserEngine.launch({
+      const session = await launchBrowser({
         headless: !options.headed,
-        channel
+        slowMo: 0,
+        timeout: 3e4,
+        trace: false,
+        recordHar: false,
+        runDir: process.cwd(),
+        engine,
+        channel,
+        viewport
       });
-      const context = await browser.newContext({ viewport });
-      const page = await context.newPage();
+      const driver = createPlaywrightDriver(session.page);
       try {
-        await page.goto(url, { waitUntil: "networkidle" });
-        const result = await analyzePage(page);
+        await driver.goto(url, { waitUntil: "networkidle" });
+        const result = await analyzePage(driver);
         if (options.json) {
           console.log(JSON.stringify(result, null, 2));
         } else {
@@ -4413,8 +5433,7 @@ function buildAnalyzeCommand() {
 `));
         }
       } finally {
-        await context.close();
-        await browser.close();
+        await closeBrowser(session);
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : "Analysis failed";
@@ -4432,15 +5451,14 @@ function buildAnalyzeCommand() {
 }
 
 // src/cli/commands/generate.ts
-var import_node_fs15 = __toESM(require("fs"), 1);
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs17 = __toESM(require("fs"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 var import_commander9 = require("commander");
 var import_chalk12 = __toESM(require("chalk"), 1);
 var import_ora = __toESM(require("ora"), 1);
 
 // src/generator/index.ts
 var import_yaml2 = __toESM(require("yaml"), 1);
-var import_playwright4 = require("playwright");
 
 // src/generator/prompt.ts
 var STEP_REFERENCE = `
@@ -4602,19 +5620,36 @@ async function generateWithOpenAi(prompt, config) {
 }
 
 // src/generator/index.ts
+init_loader();
 init_schema();
+function parseViewportFlag3(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_playwright4.chromium.launch({ headless: true });
-    const context = await browser.newContext();
-    const page = await context.newPage();
+    const engine = parseBrowserEngine(options.browser);
+    const viewport = options.viewport ? resolveViewport(parseViewportFlag3(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) {
@@ -4686,13 +5721,13 @@ function buildGenerateCommand() {
             const result = loadConfig2(options.config);
             configDir = result.configDir;
           } catch {
-            configDir = import_node_path17.default.join(process.cwd(), ".prowl");
+            configDir = import_node_path19.default.join(process.cwd(), ".prowl");
           }
-          const huntsDir = import_node_path17.default.join(configDir, "hunts");
-          import_node_fs15.default.mkdirSync(huntsDir, { recursive: true });
+          const huntsDir = import_node_path19.default.join(configDir, "hunts");
+          import_node_fs17.default.mkdirSync(huntsDir, { recursive: true });
           const fileName = options.output.endsWith(".yml") ? options.output : `${options.output}.yml`;
-          const filePath = import_node_path17.default.join(huntsDir, fileName);
-          import_node_fs15.default.writeFileSync(filePath, yamlStr + "\n", "utf-8");
+          const filePath = import_node_path19.default.join(huntsDir, fileName);
+          import_node_fs17.default.writeFileSync(filePath, yamlStr + "\n", "utf-8");
           console.log(import_chalk12.default.green(`  Saved to ${filePath}`));
         } else {
           console.log(yamlStr);
@@ -4889,7 +5924,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/mcp/tools.ts
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 init_loader();
 function listHuntsTool(configPath) {
   const { configDir } = loadConfig(configPath);
@@ -4897,7 +5932,7 @@ function listHuntsTool(configPath) {
 }
 async function runSuiteTool(args = {}, options = {}) {
   const { configPath: resolvedConfigPath, configDir, config } = loadConfig(options.configPath);
-  const projectRoot = options.projectRoot ?? import_node_path18.default.dirname(configDir);
+  const projectRoot = options.projectRoot ?? import_node_path20.default.dirname(configDir);
   const suite = await runSuite({
     configPath: resolvedConfigPath,
     includeTags: args.includeTags,
@@ -4906,8 +5941,8 @@ async function runSuiteTool(args = {}, options = {}) {
   });
   const bugLogCfg = config.bugLog ?? {};
   const logBugs = args.logBugs ?? bugLogCfg.enabled ?? true;
-  const backlogPath = bugLogCfg.backlogPath ? import_node_path18.default.resolve(projectRoot, bugLogCfg.backlogPath) : void 0;
-  const resolvedPath = bugLogCfg.resolvedPath ? import_node_path18.default.resolve(projectRoot, bugLogCfg.resolvedPath) : backlogPath ? import_node_path18.default.join(import_node_path18.default.dirname(backlogPath), "resolved.md") : void 0;
+  const backlogPath = bugLogCfg.backlogPath ? import_node_path20.default.resolve(projectRoot, bugLogCfg.backlogPath) : void 0;
+  const resolvedPath = bugLogCfg.resolvedPath ? import_node_path20.default.resolve(projectRoot, bugLogCfg.resolvedPath) : backlogPath ? import_node_path20.default.join(import_node_path20.default.dirname(backlogPath), "resolved.md") : void 0;
   const bugs = logBugs ? updateBacklogFromSuite(suite, { projectRoot, backlogPath, resolvedPath }) : { created: [], regressions: [], skipped: [], backlogPath: null };
   const { status, totalHunts, passed, failed, skipped } = suite.result;
   return {
@@ -4934,9 +5969,9 @@ async function runHuntTool(args, configPath) {
 }
 
 // src/mcp/projects.ts
-var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_fs18 = __toESM(require("fs"), 1);
 var import_node_os = __toESM(require("os"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 var import_yaml3 = __toESM(require("yaml"), 1);
 var import_zod2 = require("zod");
 var projectEntrySchema = import_zod2.z.object({
@@ -4948,37 +5983,37 @@ var projectRegistrySchema = import_zod2.z.object({
   projects: import_zod2.z.record(import_zod2.z.string().min(1), projectEntrySchema)
 }).strict();
 function defaultRegistryPath() {
-  return import_node_path19.default.join(import_node_os.default.homedir(), ".prowl", "projects.yml");
+  return import_node_path21.default.join(import_node_os.default.homedir(), ".prowl", "projects.yml");
 }
 function legacyRegistryPath() {
-  return import_node_path19.default.join(import_node_os.default.homedir(), ".prowlqa", "projects.yml");
+  return import_node_path21.default.join(import_node_os.default.homedir(), ".prowlqa", "projects.yml");
 }
 function resolveProjectConfigPath(root) {
-  const preferred = import_node_path19.default.join(root, ".prowl", "config.yml");
-  if (import_node_fs16.default.existsSync(preferred)) return preferred;
-  const legacy = import_node_path19.default.join(root, ".prowlqa", "config.yml");
-  if (import_node_fs16.default.existsSync(legacy)) return legacy;
+  const preferred = import_node_path21.default.join(root, ".prowl", "config.yml");
+  if (import_node_fs18.default.existsSync(preferred)) return preferred;
+  const legacy = import_node_path21.default.join(root, ".prowlqa", "config.yml");
+  if (import_node_fs18.default.existsSync(legacy)) return legacy;
   return preferred;
 }
 function resolveRegistryRelativePath(registry, inputPath) {
-  return import_node_path19.default.isAbsolute(inputPath) ? inputPath : import_node_path19.default.resolve(import_node_path19.default.dirname(registry.registryPath), inputPath);
+  return import_node_path21.default.isAbsolute(inputPath) ? inputPath : import_node_path21.default.resolve(import_node_path21.default.dirname(registry.registryPath), inputPath);
 }
 function resolveRegistryPath(explicitPath) {
-  if (explicitPath) return import_node_path19.default.resolve(explicitPath);
+  if (explicitPath) return import_node_path21.default.resolve(explicitPath);
   const envPath = process.env.PROWL_PROJECTS ?? process.env.PROWLQA_PROJECTS;
-  if (envPath) return import_node_path19.default.resolve(envPath);
+  if (envPath) return import_node_path21.default.resolve(envPath);
   const fallback = defaultRegistryPath();
-  if (import_node_fs16.default.existsSync(fallback)) return fallback;
+  if (import_node_fs18.default.existsSync(fallback)) return fallback;
   const legacy = legacyRegistryPath();
-  return import_node_fs16.default.existsSync(legacy) ? legacy : null;
+  return import_node_fs18.default.existsSync(legacy) ? legacy : null;
 }
 function loadProjectRegistry(explicitPath) {
   const registryPath = resolveRegistryPath(explicitPath);
   if (!registryPath) return null;
-  if (!import_node_fs16.default.existsSync(registryPath)) {
+  if (!import_node_fs18.default.existsSync(registryPath)) {
     throw new Error(`Project registry not found at ${registryPath}`);
   }
-  const raw = import_node_fs16.default.readFileSync(registryPath, "utf-8");
+  const raw = import_node_fs18.default.readFileSync(registryPath, "utf-8");
   const parsed = import_yaml3.default.parse(raw) ?? {};
   const validated = projectRegistrySchema.parse(parsed);
   return { projects: validated.projects, registryPath };