prowl-tools 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -59,7 +59,7 @@ var init_hunt_name = __esm({
 });
 
 // src/config/schema.ts
-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 import_zod, webTargetSchema, macosTargetSchema, androidTargetSchema, iosTargetSchema, 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, assertWithAiStepSchema, copyTextStepSchema, waitForDownloadStepSchema, stepSchema, assertionSchema, huntSchema;
 var init_schema = __esm({
   "src/config/schema.ts"() {
     "use strict";
@@ -74,7 +74,24 @@ var init_schema = __esm({
       type: import_zod.z.literal("macos"),
       app: import_zod.z.string().min(1)
     }).strict();
-    targetSchema = import_zod.z.union([macosTargetSchema, webTargetSchema]);
+    androidTargetSchema = import_zod.z.object({
+      type: import_zod.z.literal("android"),
+      app: import_zod.z.string().min(1),
+      deviceSerial: import_zod.z.string().min(1).optional(),
+      coldStart: import_zod.z.boolean().optional()
+    }).strict();
+    iosTargetSchema = import_zod.z.object({
+      type: import_zod.z.literal("ios"),
+      app: import_zod.z.string().min(1),
+      udid: import_zod.z.string().min(1).optional(),
+      coldStart: import_zod.z.boolean().optional()
+    }).strict();
+    targetSchema = import_zod.z.union([
+      macosTargetSchema,
+      androidTargetSchema,
+      iosTargetSchema,
+      webTargetSchema
+    ]);
     configSchema = import_zod.z.object({
       target: targetSchema,
       browser: import_zod.z.object({
@@ -294,6 +311,9 @@ var init_schema = __esm({
         threshold: import_zod.z.number().min(0).max(1).optional()
       }).strict()
     }).strict();
+    assertWithAiStepSchema = import_zod.z.object({
+      assertWithAI: import_zod.z.string().min(1)
+    }).strict();
     copyTextStepSchema = import_zod.z.object({
       copyText: import_zod.z.object({
         selector: import_zod.z.string().min(1),
@@ -336,6 +356,7 @@ var init_schema = __esm({
       evalScriptStepSchema,
       runScriptStepSchema,
       assertScreenshotStepSchema,
+      assertWithAiStepSchema,
       copyTextStepSchema,
       waitForDownloadStepSchema
     ]);
@@ -417,9 +438,28 @@ function resolveViewport(value) {
   return value;
 }
 function resolveTarget(target) {
-  if (target && target.type === "macos") {
+  const type = target?.type;
+  if (type === "macos") {
     return { type: "macos", app: target.app };
   }
+  if (type === "android") {
+    const androidTarget = target;
+    return {
+      type: "android",
+      app: androidTarget.app,
+      ...androidTarget.deviceSerial !== void 0 ? { deviceSerial: androidTarget.deviceSerial } : {},
+      ...androidTarget.coldStart !== void 0 ? { coldStart: androidTarget.coldStart } : {}
+    };
+  }
+  if (type === "ios") {
+    const iosTarget = target;
+    return {
+      type: "ios",
+      app: iosTarget.app,
+      ...iosTarget.udid !== void 0 ? { udid: iosTarget.udid } : {},
+      ...iosTarget.coldStart !== void 0 ? { coldStart: iosTarget.coldStart } : {}
+    };
+  }
   return {
     type: "web",
     url: target?.url ?? DEFAULT_WEB_URL
@@ -628,12 +668,12 @@ __export(visual_exports, {
   ensureBaselineDir: () => ensureBaselineDir
 });
 async function compareScreenshots(baselinePath, currentPath, diffPath, threshold) {
-  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 baselineData = import_pngjs.PNG.sync.read(import_node_fs8.default.readFileSync(baselinePath));
+  const currentData = import_pngjs.PNG.sync.read(import_node_fs8.default.readFileSync(currentPath));
   const { width, height } = baselineData;
   if (currentData.width !== width || currentData.height !== height) {
     const diff2 = new import_pngjs.PNG({ width, height });
-    import_node_fs5.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
+    import_node_fs8.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
     return {
       match: false,
       diffPercentage: 1,
@@ -651,7 +691,7 @@ async function compareScreenshots(baselinePath, currentPath, diffPath, threshold
   );
   const totalPixels = width * height;
   const diffPercentage = diffPixels / totalPixels;
-  import_node_fs5.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
+  import_node_fs8.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
   return {
     match: diffPercentage <= threshold,
     diffPercentage,
@@ -659,16 +699,16 @@ async function compareScreenshots(baselinePath, currentPath, diffPath, threshold
   };
 }
 function ensureBaselineDir(configDir) {
-  const baselineDir = import_node_path5.default.join(configDir, "baselines");
-  import_node_fs5.default.mkdirSync(baselineDir, { recursive: true });
+  const baselineDir = import_node_path8.default.join(configDir, "baselines");
+  import_node_fs8.default.mkdirSync(baselineDir, { recursive: true });
   return baselineDir;
 }
-var import_node_fs5, import_node_path5, import_pngjs, import_pixelmatch;
+var import_node_fs8, import_node_path8, import_pngjs, import_pixelmatch;
 var init_visual = __esm({
   "src/runner/visual.ts"() {
     "use strict";
-    import_node_fs5 = __toESM(require("fs"), 1);
-    import_node_path5 = __toESM(require("path"), 1);
+    import_node_fs8 = __toESM(require("fs"), 1);
+    import_node_path8 = __toESM(require("path"), 1);
     import_pngjs = require("pngjs");
     import_pixelmatch = __toESM(require("pixelmatch"), 1);
   }
@@ -680,7 +720,7 @@ var import_commander13 = require("commander");
 // package.json
 var package_default = {
   name: "prowl-tools",
-  version: "0.1.4",
+  version: "0.1.6",
   description: "CLI-first QA testing tool for deterministic Playwright flows.",
   type: "module",
   license: "Apache-2.0",
@@ -750,6 +790,10 @@ var package_default = {
     yaml: "^2.6.1",
     zod: "^3.23.8"
   },
+  optionalDependencies: {
+    "appium-uiautomator2-server": "10.6.2",
+    "appium-webdriveragent": "16.4.0"
+  },
   devDependencies: {
     "@types/node": "^22.13.1",
     "@types/pngjs": "^6.0.5",
@@ -767,8 +811,8 @@ var import_commander = require("commander");
 var import_chalk3 = __toESM(require("chalk"), 1);
 
 // src/runner/index.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 init_loader();
 
 // src/config/interpolate.ts
@@ -1065,6 +1109,11 @@ function interpolateStep(step, vars, stepPath2, redacted) {
       }
     };
   }
+  if ("assertWithAI" in step) {
+    return {
+      assertWithAI: interpolateString(step.assertWithAI, vars).value
+    };
+  }
   if ("copyText" in step) {
     return {
       copyText: {
@@ -1171,15 +1220,25 @@ function webOnlyReason(step) {
   }
   return null;
 }
+function nativeTargetLabel(target) {
+  if (target === "android") {
+    return "Android";
+  }
+  if (target === "ios") {
+    return "iOS";
+  }
+  return "macOS";
+}
 function assertStepsSupportedByTarget(steps, target) {
-  if (target !== "macos") {
+  if (target === "web") {
     return;
   }
+  const label = nativeTargetLabel(target);
   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.).`
+        `Step "${reason}" is not supported by the ${label} target. It is web-only; use a portable step (click, fill, type, press, wait, assert visible, screenshot, etc.).`
       );
     }
     if ("if" in step) {
@@ -1194,20 +1253,34 @@ function assertStepsSupportedByTarget(steps, target) {
   }
 }
 function assertHuntAssertionsSupportedByTarget(assertions, target) {
-  if (target !== "macos" || !assertions || assertions.length === 0) {
+  if (target === "web" || !assertions || assertions.length === 0) {
     return;
   }
   throw new Error(
-    "Hunt-level assertions are not supported by the macOS target. Use inline assert visible/notVisible steps instead."
+    `Hunt-level assertions are not supported by the ${nativeTargetLabel(target)} target. Use inline assert visible/notVisible steps instead.`
   );
 }
 function trimTrailingPathSeparators(value) {
   return value.replace(/[\\/]+$/g, "");
 }
-function looksLikeMacosAppPath(app) {
+function looksLikeAppBundlePath(app) {
   const trimmed = trimTrailingPathSeparators(app);
   return trimmed.includes("/") || trimmed.toLowerCase().endsWith(".app");
 }
+function looksLikeIosAppPath(app) {
+  const trimmed = trimTrailingPathSeparators(app);
+  if (trimmed.includes("/") || trimmed.includes("\\")) {
+    return true;
+  }
+  if (trimmed.toLowerCase().endsWith(".app")) {
+    try {
+      return import_node_fs2.default.statSync(normalizeAppPath(app)).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
 function normalizeAppPath(app) {
   return import_node_path2.default.resolve(trimTrailingPathSeparators(app));
 }
@@ -1215,8 +1288,8 @@ function parseBundleIdentifier(plist) {
   const match = /<key>\s*CFBundleIdentifier\s*<\/key>\s*<string>\s*([^<]+?)\s*<\/string>/s.exec(plist);
   return match?.[1]?.trim() || null;
 }
-function readBundleIdentifier(appPath) {
-  const infoPlistPath = import_node_path2.default.join(normalizeAppPath(appPath), "Contents", "Info.plist");
+function readBundleIdentifier(appPath, ...plistSubPath) {
+  const infoPlistPath = import_node_path2.default.join(normalizeAppPath(appPath), ...plistSubPath);
   if (!import_node_fs2.default.existsSync(infoPlistPath)) {
     return null;
   }
@@ -1241,9 +1314,15 @@ function readBundleIdentifier(appPath) {
     return null;
   }
 }
-function macosAppAllowedIdentities(app) {
+function readMacosBundleIdentifier(appPath) {
+  return readBundleIdentifier(appPath, "Contents", "Info.plist");
+}
+function readIosBundleIdentifier(appPath) {
+  return readBundleIdentifier(appPath, "Info.plist");
+}
+function appBundleAllowedIdentities(app, readBundleId, isAppPath = looksLikeAppBundlePath) {
   const identities = /* @__PURE__ */ new Set([app]);
-  if (looksLikeMacosAppPath(app)) {
+  if (isAppPath(app)) {
     const normalizedPath = normalizeAppPath(app);
     identities.add(trimTrailingPathSeparators(app));
     identities.add(normalizedPath);
@@ -1251,19 +1330,56 @@ function macosAppAllowedIdentities(app) {
     if (bundleName) {
       identities.add(bundleName);
     }
-    const bundleId = readBundleIdentifier(app);
+    const bundleId = readBundleId(app);
     if (bundleId) {
       identities.add(bundleId);
     }
   }
   return [...identities];
 }
+function macosAppAllowedIdentities(app) {
+  return appBundleAllowedIdentities(app, readMacosBundleIdentifier);
+}
+function iosAppAllowedIdentities(app) {
+  return appBundleAllowedIdentities(app, readIosBundleIdentifier, looksLikeIosAppPath);
+}
 function assertTargetAppAllowed(allowedApps, app) {
+  assertNativeAppAllowed(allowedApps, app, macosAppAllowedIdentities);
+}
+function assertIosAppAllowed(allowedApps, app) {
+  assertNativeAppAllowed(allowedApps, app, iosAppAllowedIdentities);
+}
+function looksLikeApkPath(app) {
+  const trimmed = trimTrailingPathSeparators(app);
+  return trimmed.includes("/") || trimmed.includes("\\") || trimmed.toLowerCase().endsWith(".apk");
+}
+function normalizeAndroidApkPath(app) {
+  const resolved = import_node_path2.default.resolve(trimTrailingPathSeparators(app));
+  try {
+    return import_node_fs2.default.realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function androidAppAllowedIdentities(app, resolvedPackage) {
+  if (looksLikeApkPath(app)) {
+    return resolvedPackage ? [normalizeAndroidApkPath(app), resolvedPackage] : [normalizeAndroidApkPath(app)];
+  }
+  return [app];
+}
+function assertAndroidAppAllowed(allowedApps, app, resolvedPackage) {
+  assertNativeAppAllowed(
+    allowedApps,
+    app,
+    (value) => androidAppAllowedIdentities(value, value === app ? resolvedPackage : void 0)
+  );
+}
+function assertNativeAppAllowed(allowedApps, app, resolveIdentities) {
   if (allowedApps.length === 0) {
     return;
   }
-  const allowedIdentities = new Set(allowedApps.flatMap((allowedApp) => macosAppAllowedIdentities(allowedApp)));
-  if (macosAppAllowedIdentities(app).some((identity) => allowedIdentities.has(identity))) {
+  const allowedIdentities = new Set(allowedApps.flatMap((allowedApp) => resolveIdentities(allowedApp)));
+  if (resolveIdentities(app).some((identity) => allowedIdentities.has(identity))) {
     return;
   }
   throw new Error(
@@ -1641,7 +1757,11 @@ function createMacDriver(client, options = {}) {
       return rejectUnsupported("evalScript");
     },
     async screenshot(screenshotOptions) {
-      await client.request("screenshot", { path: screenshotOptions.path });
+      const result = await client.request("screenshot", { path: screenshotOptions.path });
+      const warning = result.warning;
+      if (typeof warning === "string" && warning.length > 0) {
+        console.warn(`macOS screenshot fell back to full screen: ${warning}`);
+      }
     },
     // network / dialogs / downloads (all web-only) -------------------------
     onResponse(_handler) {
@@ -1868,154 +1988,2177 @@ async function closeMacSession(session) {
   }
 }
 
-// src/runner/steps.ts
+// src/browser/android-helper.ts
+var import_node_module = require("module");
+var import_node_child_process4 = require("child_process");
 var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
-init_loader();
+var import_node_path5 = __toESM(require("path"), 1);
 
-// 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);
+// src/browser/android-driver.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+
+// src/analyzer/xml.ts
+var ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(value) {
+  if (!value.includes("&")) {
+    return 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 value.replace(/&(#(?:[xX][0-9a-fA-F]+|[0-9]+)|[a-zA-Z]+);/g, (match, code) => {
+    if (code[0] === "#") {
+      const hex = code[1] === "x" || code[1] === "X";
+      const num2 = Number.parseInt(code.slice(hex ? 2 : 1), hex ? 16 : 10);
+      return Number.isSafeInteger(num2) && num2 <= 1114111 ? String.fromCodePoint(num2) : match;
     }
-  }
-  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;
+    const named = ENTITIES[code];
+    return named ?? match;
+  });
 }
-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 {
+var ATTR_RE = /([^\s=/]+)\s*=\s*("([^"]*)"|'([^']*)')/g;
+function parseTagBody(body) {
+  const trimmed = body.trim();
+  const nameMatch = /^([^\s/>]+)/.exec(trimmed);
+  const tag = nameMatch ? nameMatch[1] : "";
+  const attrs = {};
+  const rest = trimmed.slice(tag.length);
+  ATTR_RE.lastIndex = 0;
+  let m;
+  while ((m = ATTR_RE.exec(rest)) !== null) {
+    const rawValue = m[3] !== void 0 ? m[3] : m[4] ?? "";
+    attrs[m[1]] = decodeXmlEntities(rawValue);
+  }
+  return { tag, attrs };
+}
+function parseXml(input) {
+  const n = input.length;
+  const stack = [];
+  let root = null;
+  let i = 0;
+  while (i < n) {
+    const lt = input.indexOf("<", i);
+    if (lt < 0) {
+      break;
+    }
+    i = lt + 1;
+    const ch = input[i];
+    if (ch === "?") {
+      const end = input.indexOf("?>", i);
+      i = end < 0 ? n : end + 2;
       continue;
     }
-    if (count === 1) {
-      return { selector: candidate.selector, healedFrom: selector, strategy: candidate.strategy };
+    if (ch === "!") {
+      if (input.startsWith("!--", i)) {
+        const end = input.indexOf("-->", i);
+        i = end < 0 ? n : end + 3;
+      } else {
+        const end = input.indexOf(">", i);
+        i = end < 0 ? n : end + 1;
+      }
+      continue;
+    }
+    if (ch === "/") {
+      const gt = input.indexOf(">", i);
+      i = gt < 0 ? n : gt + 1;
+      stack.pop();
+      continue;
+    }
+    let j = i;
+    let quote2 = null;
+    while (j < n) {
+      const c = input[j];
+      if (quote2 !== null) {
+        if (c === quote2) {
+          quote2 = null;
+        }
+      } else if (c === '"' || c === "'") {
+        quote2 = c;
+      } else if (c === ">") {
+        break;
+      }
+      j += 1;
+    }
+    const inner = input.slice(i, j);
+    i = j + 1;
+    const selfClose = inner.endsWith("/");
+    const body = selfClose ? inner.slice(0, -1) : inner;
+    const { tag, attrs } = parseTagBody(body);
+    if (tag.length === 0) {
+      continue;
+    }
+    const element = { tag, attrs, children: [] };
+    const parent = stack[stack.length - 1];
+    if (parent) {
+      parent.children.push(element);
+    }
+    if (root === null) {
+      root = element;
+    }
+    if (!selfClose) {
+      stack.push(element);
     }
   }
-  return null;
+  return root;
 }
 
-// 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);
+// src/selector/native.ts
+function unquoteSelectorValue(value) {
+  const trimmed = value.trim();
+  const first = trimmed[0];
+  if ((first === '"' || first === "'") && trimmed.endsWith(first) && trimmed.length >= 2) {
+    return trimmed.slice(1, -1);
   }
-  function isForbiddenSelector(selector) {
-    return forbiddenSelectors.some(
-      (forbidden) => selector.includes(forbidden) || matchesForbiddenPattern(selector, forbidden)
+  return trimmed;
+}
+function quoteSelectorValue(value) {
+  return `"${value}"`;
+}
+var ROLE_SELECTOR_RE = /^role=([A-Za-z][\w.$-]*)(?:\[name=(.+)\])?$/s;
+var NATIVE_SELECTOR_PREFIX_RE = /^(id|label|text|role)=/;
+function invalidSelectorMessage(selector, reason) {
+  return `Invalid native selector ${JSON.stringify(selector)}: ${reason}.`;
+}
+function parseNativeSelector(selector) {
+  const trimmed = selector.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      invalidSelectorMessage(
+        selector,
+        "selector is empty; use id=, label=, text=, role=, :focus, or a bare text value"
+      )
     );
   }
-  function assertAllowedSelector(selector) {
-    if (isForbiddenSelector(selector)) {
-      throw new Error(`Forbidden selector: ${selector}`);
-    }
+  if (trimmed === ":focus") {
+    return { kind: "focused" };
   }
-  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}.`);
-    }
+  const idMatch = /^id=(.+)$/s.exec(trimmed);
+  if (idMatch) {
+    return { kind: "id", value: unquoteSelectorValue(idMatch[1]) };
   }
-  function ensureUrlAllowed(urlValue) {
-    for (const protocol of ALWAYS_ALLOWED_PROTOCOLS) {
-      if (urlValue.startsWith(protocol)) {
-        return;
+  const roleMatch = ROLE_SELECTOR_RE.exec(trimmed);
+  if (roleMatch) {
+    const name = roleMatch[2] !== void 0 ? unquoteSelectorValue(roleMatch[2]) : void 0;
+    return name !== void 0 && name.length > 0 ? { kind: "role", role: roleMatch[1], name } : { kind: "role", role: roleMatch[1] };
+  }
+  const labelMatch = /^label=(.+)$/s.exec(trimmed);
+  if (labelMatch) {
+    return { kind: "label", value: unquoteSelectorValue(labelMatch[1]) };
+  }
+  const textMatch = /^text=(.+)$/s.exec(trimmed);
+  if (textMatch) {
+    return { kind: "text", value: unquoteSelectorValue(textMatch[1]) };
+  }
+  const prefix = NATIVE_SELECTOR_PREFIX_RE.exec(trimmed);
+  if (prefix) {
+    throw new Error(
+      invalidSelectorMessage(
+        selector,
+        `malformed ${prefix[1]}= selector; expected id=<value>, label=<value>, text=<value>, or role=<Type>[name=<value>]`
+      )
+    );
+  }
+  return { kind: "text", value: trimmed };
+}
+function unwrapNativeTextSelector(selector) {
+  const trimmed = selector.trim();
+  if (!trimmed.startsWith("text=")) {
+    return null;
+  }
+  return unquoteSelectorValue(trimmed.slice("text=".length));
+}
+function qualifyResourceId(value, appPackage) {
+  if (value.includes(":") || !appPackage) {
+    return value;
+  }
+  return `${appPackage}:id/${value}`;
+}
+function normalizeXcuiClassName(role) {
+  return role.startsWith("XCUIElementType") ? role : `XCUIElementType${role}`;
+}
+function shortIosType(type) {
+  return type.startsWith("XCUIElementType") ? type.slice("XCUIElementType".length) : type;
+}
+function rankNativeSelectors(fields) {
+  const selectors = [];
+  if (fields.id) {
+    selectors.push(`id=${fields.id}`);
+  }
+  if (fields.label) {
+    selectors.push(`label=${quoteSelectorValue(fields.label)}`);
+  }
+  if (fields.role && fields.name) {
+    selectors.push(`role=${fields.role}[name=${quoteSelectorValue(fields.name)}]`);
+  }
+  if (fields.name) {
+    selectors.push(`text=${quoteSelectorValue(fields.name)}`);
+  }
+  if (selectors.length === 0 && fields.role) {
+    selectors.push(`role=${fields.role}`);
+  }
+  return selectors;
+}
+
+// src/browser/android-driver.ts
+var ANDROID_CAPABILITIES = /* @__PURE__ */ new Set([
+  "query",
+  "interact",
+  "wait",
+  "screenshot"
+]);
+var WAIT_POLL_INTERVAL_MS = 250;
+var DEFAULT_WAIT_TIMEOUT_MS = 5e3;
+var ANDROID_KEYCODES = {
+  enter: 66,
+  return: 66,
+  tab: 61,
+  space: 62,
+  backspace: 67,
+  delete: 67,
+  del: 67,
+  escape: 111,
+  esc: 111,
+  back: 4,
+  home: 3,
+  menu: 82,
+  search: 84,
+  up: 19,
+  arrowup: 19,
+  down: 20,
+  arrowdown: 20,
+  left: 21,
+  arrowleft: 21,
+  right: 22,
+  arrowright: 22,
+  pageup: 92,
+  pagedown: 93
+};
+function escapeUiSelectorArg(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function toAndroidQuery(selector) {
+  switch (selector.kind) {
+    case "focused":
+      return { by: "focused" };
+    case "id":
+      return { by: "id", value: selector.value };
+    case "role":
+      return selector.name !== void 0 ? { by: "role", role: selector.role, name: selector.name } : { by: "role", role: selector.role };
+    case "label":
+      return { by: "accessibilityId", value: selector.value };
+    case "text":
+      return { by: "text", value: selector.value };
+  }
+}
+function parseAndroidSelector(selector) {
+  return toAndroidQuery(parseNativeSelector(selector));
+}
+function locator(strategy, selector) {
+  return { strategy, selector, context: "" };
+}
+function androidQueryToLocator(query, options = {}) {
+  switch (query.by) {
+    case "id":
+      return locator("id", qualifyResourceId(query.value, options.appPackage));
+    case "accessibilityId":
+      return locator("accessibility id", query.value);
+    case "text":
+      return locator(
+        "-android uiautomator",
+        `new UiSelector().textContains("${escapeUiSelectorArg(query.value)}")`
+      );
+    case "focused":
+      return locator("-android uiautomator", "new UiSelector().focused(true)");
+    case "role": {
+      const className = escapeUiSelectorArg(query.role);
+      if (query.name === void 0 || query.name.length === 0) {
+        return locator("class name", query.role);
       }
-    }
-    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}`);
+      return locator(
+        "-android uiautomator",
+        `new UiSelector().className("${className}").textContains("${escapeUiSelectorArg(query.name)}")`
+      );
     }
   }
-  function ensureAppAllowed(app) {
-    if (!allowedApps.includes(app)) {
-      throw new Error(`Interaction with disallowed app: ${app}`);
-    }
+}
+function unwrapAndroidTextSelector(selector) {
+  return unwrapNativeTextSelector(selector);
+}
+function keyCodeFor(key) {
+  const code = ANDROID_KEYCODES[key.trim().toLowerCase()];
+  if (code === void 0) {
+    throw new Error(
+      `Unsupported key "${key}" for the Android target. Supported keys: ${Object.keys(ANDROID_KEYCODES).sort().join(", ")}.`
+    );
   }
-  function ensureLocationAllowed(activeDriver) {
-    if (activeDriver.capabilities.has("navigate")) {
-      ensureUrlAllowed(activeDriver.currentUrl());
+  return code;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function createAndroidDriver(client, options = {}) {
+  const unsupported = (verb) => new Error(`${verb} is not supported by the Android target`);
+  const rejectUnsupported = (verb) => Promise.reject(unsupported(verb));
+  async function resolveOne(selector) {
+    const id = await client.findElement(parseAndroidSelector(selector));
+    if (id === null) {
+      throw new Error(`No element matched selector: ${selector}`);
     }
+    return id;
   }
-  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 };
+  async function clickSelector(selector) {
+    await client.click(await resolveOne(selector));
+  }
+  async function fillSelector(selector, value) {
+    await client.setValue(await resolveOne(selector), value);
   }
   return {
-    assertWithinMaxSteps,
+    capabilities: ANDROID_CAPABILITIES,
+    // navigation -----------------------------------------------------------
+    goto(_url, _options) {
+      return rejectUnsupported("navigate");
+    },
+    currentUrl() {
+      return `android:${options.appLabel ?? ""}`;
+    },
+    // queries --------------------------------------------------------------
+    async count(selector) {
+      return (await client.findElements(parseAndroidSelector(selector))).length;
+    },
+    async textContent(selector) {
+      const id = await client.findElement(parseAndroidSelector(selector));
+      if (id === null) {
+        return null;
+      }
+      return client.getText(id);
+    },
+    // interactions ---------------------------------------------------------
+    click: clickSelector,
+    clickFirst: clickSelector,
+    fill: fillSelector,
+    fillFirst: fillSelector,
+    async press(_selector, key) {
+      await client.pressKeyCode(keyCodeFor(key));
+    },
+    selectOption() {
+      return rejectUnsupported("select");
+    },
+    selectOptionFirst() {
+      return rejectUnsupported("select");
+    },
+    hover() {
+      return rejectUnsupported("hover");
+    },
+    scrollIntoView() {
+      return rejectUnsupported("scrollTo");
+    },
+    setInputFiles() {
+      return rejectUnsupported("setInputFiles");
+    },
+    // semantic locators ----------------------------------------------------
+    async countByRole(role, name) {
+      return (await client.findElements({ by: "role", role, name })).length;
+    },
+    async clickFirstByRole(role, name) {
+      const id = await client.findElement({ by: "role", role, name });
+      if (id === null) {
+        throw new Error(`No element matched role=${role}[name="${name}"]`);
+      }
+      await client.click(id);
+    },
+    async countByLabel(label) {
+      return (await client.findElements({ by: "accessibilityId", value: label })).length;
+    },
+    async fillFirstByLabel(label, value) {
+      const id = await client.findElement({ by: "accessibilityId", value: label });
+      if (id === null) {
+        throw new Error(`No element matched label="${label}"`);
+      }
+      await client.setValue(id, value);
+    },
+    selectOptionFirstByLabel() {
+      return rejectUnsupported("select");
+    },
+    // waiting --------------------------------------------------------------
+    async waitForSelector(selector, waitOptions) {
+      const query = parseAndroidSelector(selector);
+      const timeoutMs = waitOptions?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+      const deadline = Date.now() + timeoutMs;
+      for (; ; ) {
+        if ((await client.findElements(query)).length > 0) {
+          return;
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(`Timed out after ${timeoutMs}ms waiting for selector: ${selector}`);
+        }
+        await delay(Math.min(WAIT_POLL_INTERVAL_MS, Math.max(0, deadline - Date.now())));
+      }
+    },
+    waitForUrl() {
+      return rejectUnsupported("waitForUrl");
+    },
+    waitForNetworkIdle() {
+      return rejectUnsupported("waitForNetworkIdle");
+    },
+    // scripting & artifacts ------------------------------------------------
+    evaluate() {
+      return rejectUnsupported("evalScript");
+    },
+    async screenshot(screenshotOptions) {
+      const png = await client.screenshotPng();
+      import_node_fs5.default.writeFileSync(screenshotOptions.path, png);
+    },
+    // 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 unwrapAndroidTextSelector(selector);
+    }
+  };
+}
+
+// src/browser/android-adb.ts
+var import_node_child_process3 = require("child_process");
+var execFileAdbRunner = (args, options) => new Promise((resolve) => {
+  (0, import_node_child_process3.execFile)(
+    "adb",
+    args,
+    { encoding: "utf-8", timeout: options?.timeoutMs, maxBuffer: 16 * 1024 * 1024 },
+    (error, stdout, stderr) => {
+      const code = error && typeof error.code === "number" ? error.code : error ? 1 : 0;
+      const capturedStderr = stderr ?? "";
+      resolve({
+        stdout: stdout ?? "",
+        stderr: capturedStderr.trim() ? capturedStderr : error?.message ?? "",
+        code
+      });
+    }
+  );
+});
+var spawnAdbProcess = (args) => {
+  const child = (0, import_node_child_process3.spawn)("adb", args, { stdio: "ignore" });
+  child.on("error", () => {
+  });
+  return { kill: () => child.kill() };
+};
+function withSerial(serial, args) {
+  return serial ? ["-s", serial, ...args] : args;
+}
+function parseAdbDevices(stdout) {
+  const devices = [];
+  for (const rawLine of stdout.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || /^list of devices attached/i.test(line)) {
+      continue;
+    }
+    const [serial, state, ...rest] = line.split(/\s+/);
+    if (!serial || !state) {
+      continue;
+    }
+    const description = {};
+    for (const token of rest) {
+      const eq = token.indexOf(":");
+      if (eq > 0) {
+        description[token.slice(0, eq)] = token.slice(eq + 1);
+      }
+    }
+    devices.push({ serial, state, description });
+  }
+  return devices;
+}
+function bootedDevices(devices) {
+  return devices.filter((device) => device.state === "device");
+}
+function selectDeviceSerial(devices, requested) {
+  const booted = bootedDevices(devices);
+  if (requested) {
+    const match = devices.find((device) => device.serial === requested);
+    if (!match) {
+      const attached = devices.length > 0 ? devices.map((d) => d.serial).join(", ") : "none";
+      throw new Error(
+        `Android device "${requested}" is not attached. Attached devices: ${attached}. Check \`adb devices -l\`.`
+      );
+    }
+    if (match.state !== "device") {
+      throw new Error(
+        `Android device "${requested}" is present but not ready (state: ${match.state}). Boot or authorize it, then retry.`
+      );
+    }
+    return requested;
+  }
+  if (booted.length === 0) {
+    throw new Error(
+      "No booted Android device found. Start an emulator or connect a device with USB debugging, then confirm it appears in `adb devices -l`."
+    );
+  }
+  if (booted.length > 1) {
+    throw new Error(
+      `Multiple Android devices attached (${booted.map((d) => d.serial).join(", ")}). Set target.deviceSerial to pick one.`
+    );
+  }
+  return booted[0].serial;
+}
+async function listDevices(runner) {
+  const result = await runner(["devices", "-l"], { timeoutMs: 1e4 });
+  if (result.code !== 0) {
+    throw new Error(
+      `\`adb devices\` failed (exit ${result.code}). Is adb on PATH and the server running? ` + (result.stderr.trim() || "").slice(0, 400)
+    );
+  }
+  return parseAdbDevices(result.stdout);
+}
+function parseForwardPort(stdout) {
+  const port = Number.parseInt(stdout.trim(), 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`Could not parse a forwarded port from adb output: "${stdout.trim()}"`);
+  }
+  return port;
+}
+function parseAaptPackage(stdout) {
+  const match = /package:\s*name='([^']+)'/.exec(stdout);
+  return match?.[1] ?? null;
+}
+async function forwardDynamicPort(runner, serial, remotePort) {
+  const result = await runner(withSerial(serial, ["forward", "tcp:0", `tcp:${remotePort}`]), {
+    timeoutMs: 1e4
+  });
+  if (result.code !== 0) {
+    throw new Error(`adb forward failed (exit ${result.code}): ${result.stderr.trim()}`);
+  }
+  return parseForwardPort(result.stdout);
+}
+async function removeForward(runner, serial, localPort) {
+  await runner(withSerial(serial, ["forward", "--remove", `tcp:${localPort}`]), { timeoutMs: 1e4 }).catch(
+    () => void 0
+  );
+}
+async function installApk(runner, serial, apkPath) {
+  const result = await runner(withSerial(serial, ["install", "-r", "-t", "-g", apkPath]), {
+    timeoutMs: 12e4
+  });
+  if (result.code !== 0 || /failure/i.test(result.stdout)) {
+    throw new Error(
+      `Failed to install APK "${apkPath}" (exit ${result.code}): ${(result.stderr.trim() || result.stdout.trim()).slice(0, 400)}`
+    );
+  }
+}
+function formatUnknownError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function runnerPhaseError(message, error) {
+  return new Error(`${message}: ${formatUnknownError(error)}`, { cause: error });
+}
+function parseResolvedComponent(stdout, pkg) {
+  const lines = stdout.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (/^[\w.]+\/[\w.$]+$/.test(lines[i]) && lines[i].startsWith(`${pkg}/`)) {
+      return lines[i];
+    }
+  }
+  return null;
+}
+async function launchPackage(runner, serial, pkg) {
+  let resolved;
+  try {
+    resolved = await runner(
+      withSerial(serial, [
+        "shell",
+        "cmd",
+        "package",
+        "resolve-activity",
+        "--brief",
+        "-c",
+        "android.intent.category.LAUNCHER",
+        pkg
+      ]),
+      { timeoutMs: 3e4 }
+    );
+  } catch (error) {
+    throw runnerPhaseError(
+      `Failed to resolve the launcher activity for Android package "${pkg}" via adb`,
+      error
+    );
+  }
+  const component = parseResolvedComponent(resolved.stdout, pkg);
+  if (resolved.code !== 0 || !component) {
+    throw new Error(
+      `Could not resolve a launcher activity for Android package "${pkg}" (exit ${resolved.code})${(resolved.stdout + resolved.stderr).trim() ? `: ${(resolved.stdout + resolved.stderr).trim().slice(0, 300)}` : ""}. Is it installed?`
+    );
+  }
+  let start;
+  try {
+    start = await runner(withSerial(serial, ["shell", "am", "start", "-n", component]), {
+      timeoutMs: 3e4
+    });
+  } catch (error) {
+    throw runnerPhaseError(
+      `Failed to launch Android package "${pkg}" with \`am start\` (${component}) via adb`,
+      error
+    );
+  }
+  if (start.code !== 0 || /error|does not exist|cannot start/i.test(start.stdout + start.stderr)) {
+    throw new Error(
+      `Failed to launch Android package "${pkg}" (${component}, exit ${start.code}): ${(start.stdout + start.stderr).trim().slice(0, 400)}.`
+    );
+  }
+}
+async function forceStop(runner, serial, pkg) {
+  await runner(withSerial(serial, ["shell", "am", "force-stop", pkg]), { timeoutMs: 3e4 });
+}
+async function clearPackage(runner, serial, pkg) {
+  const result = await runner(withSerial(serial, ["shell", "pm", "clear", pkg]), { timeoutMs: 3e4 });
+  if (result.code !== 0 || !/success/i.test(result.stdout)) {
+    throw new Error(
+      `Failed to clear Android package "${pkg}" for cold start (exit ${result.code}): ${(result.stdout + result.stderr).trim().slice(0, 300)}`
+    );
+  }
+}
+function startInstrumentation(spawner, serial) {
+  return spawner(
+    withSerial(serial, [
+      "shell",
+      "am",
+      "instrument",
+      "-w",
+      "-e",
+      "disableAnalytics",
+      "true",
+      "io.appium.uiautomator2.server.test/androidx.test.runner.AndroidJUnitRunner"
+    ])
+  );
+}
+
+// src/browser/android-agent.ts
+var DEFAULT_AGENT_REQUEST_TIMEOUT_MS = 3e4;
+var W3C_ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
+var Uia2HttpError = class extends Error {
+  constructor(message, status, webdriverError) {
+    super(message);
+    this.status = status;
+    this.webdriverError = webdriverError;
+    this.name = "Uia2HttpError";
+  }
+};
+var Uia2Transport = class {
+  baseUrl;
+  requestTimeoutMs;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_AGENT_REQUEST_TIMEOUT_MS;
+    const injected = options.fetchImpl;
+    if (injected) {
+      this.fetchImpl = injected;
+    } else if (typeof fetch === "function") {
+      this.fetchImpl = (url, init) => fetch(url, init);
+    } else {
+      throw new Error("global fetch is unavailable; Node 20+ is required for the Android target");
+    }
+  }
+  /**
+   * Send one request and return the parsed `value` field. Rejects with a
+   * {@link Uia2HttpError} on a non-2xx response, or a timeout error when the
+   * per-request deadline elapses.
+   */
+  async request(method, path25, body, timeoutMs) {
+    const requestTimeoutMs = timeoutMs ?? this.requestTimeoutMs;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+    timer.unref?.();
+    const url = `${this.baseUrl}${path25}`;
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        signal: controller.signal,
+        headers: body !== void 0 ? { "content-type": "application/json" } : void 0,
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    } catch (error) {
+      if (controller.signal.aborted) {
+        const shown = requestTimeoutMs >= 1e3 ? `${Math.round(requestTimeoutMs / 1e3)}s` : `${requestTimeoutMs}ms`;
+        throw new Error(`uiautomator2 request ${method} ${path25} timed out after ${shown}`);
+      }
+      throw error instanceof Error ? error : new Error(String(error));
+    } finally {
+      clearTimeout(timer);
+    }
+    const text = await response.text();
+    const parsed = parseJson(text);
+    if (!response.ok) {
+      const wdError = extractWebdriverError(parsed);
+      throw new Uia2HttpError(
+        `uiautomator2 ${method} ${path25} failed (${response.status})${wdError ? `: ${wdError}` : ""}`,
+        response.status,
+        wdError
+      );
+    }
+    return parsed?.value;
+  }
+};
+function parseJson(text) {
+  if (!text) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function extractWebdriverError(parsed) {
+  const value = parsed?.value;
+  if (value && typeof value === "object") {
+    const record = value;
+    const error = typeof record.error === "string" ? record.error : void 0;
+    const message = typeof record.message === "string" ? record.message : void 0;
+    return error ?? message;
+  }
+  return void 0;
+}
+function extractElementId(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const id = record[W3C_ELEMENT_KEY] ?? record.ELEMENT;
+  return typeof id === "string" ? id : null;
+}
+function isNoSuchElement(error) {
+  if (error instanceof Uia2HttpError) {
+    return error.status === 404 || (error.webdriverError ?? "").includes("no such element");
+  }
+  return false;
+}
+async function createUia2Session(transport) {
+  const value = await transport.request("POST", "/session", {
+    capabilities: { alwaysMatch: {}, firstMatch: [{}] }
+  });
+  const record = value ?? {};
+  const sessionId = record.sessionId;
+  if (typeof sessionId === "string" && sessionId.length > 0) {
+    return sessionId;
+  }
+  throw new Error("uiautomator2 did not return a session id");
+}
+async function waitForAgentReady(transport, options = { deadlineMs: 3e4 }) {
+  const interval = options.intervalMs ?? 300;
+  const deadline = Date.now() + options.deadlineMs;
+  let lastError;
+  for (; ; ) {
+    try {
+      const remainingMs = Math.max(1, deadline - Date.now());
+      const value = await transport.request("GET", "/status", void 0, Math.min(remainingMs, 5e3));
+      const ready = value?.ready;
+      if (ready === void 0 || ready === true) {
+        return;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+    if (Date.now() >= deadline) {
+      const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+      throw new Error(`uiautomator2 agent did not become ready within ${options.deadlineMs}ms${detail}`);
+    }
+    await sleep(Math.min(interval, Math.max(0, deadline - Date.now())));
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+function createUia2AgentClient(transport, sessionId, options = {}) {
+  const base = `/session/${sessionId}`;
+  async function locate(query, path25) {
+    return transport.request(
+      "POST",
+      `${base}${path25}`,
+      androidQueryToLocator(query, { appPackage: options.appPackage })
+    );
+  }
+  return {
+    async findElement(query) {
+      try {
+        return extractElementId(await locate(query, "/element"));
+      } catch (error) {
+        if (isNoSuchElement(error)) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async findElements(query) {
+      const value = await locate(query, "/elements");
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.map((entry) => extractElementId(entry)).filter((id) => id !== null);
+    },
+    async click(elementId) {
+      await transport.request("POST", `${base}/element/${elementId}/click`, {});
+    },
+    async setValue(elementId, text) {
+      await transport.request("POST", `${base}/element/${elementId}/value`, { text });
+    },
+    async getText(elementId) {
+      const value = await transport.request("GET", `${base}/element/${elementId}/text`);
+      return typeof value === "string" ? value : value == null ? null : String(value);
+    },
+    async pressKeyCode(keyCode) {
+      await transport.request("POST", `${base}/appium/device/press_keycode`, { keycode: keyCode });
+    },
+    async screenshotPng() {
+      const value = await transport.request("GET", `${base}/screenshot`);
+      if (typeof value !== "string") {
+        throw new Error("uiautomator2 screenshot did not return base64 data");
+      }
+      return Buffer.from(value, "base64");
+    },
+    async source() {
+      const value = await transport.request("GET", `${base}/source`);
+      if (typeof value !== "string") {
+        throw new Error("uiautomator2 /source did not return XML text; cannot analyze Android UI hierarchy");
+      }
+      return value;
+    },
+    async close() {
+      await transport.request("DELETE", base).catch(() => void 0);
+    }
+  };
+}
+
+// src/browser/android-helper.ts
+var import_meta2 = {};
+var UIA2_REMOTE_PORT = 6790;
+function resolveAgentApks(requireFn = (0, import_node_module.createRequire)(import_meta2.url)) {
+  let pkgJsonPath;
+  try {
+    pkgJsonPath = requireFn.resolve("appium-uiautomator2-server/package.json");
+  } catch {
+    throw new Error(
+      "The Android target requires the `appium-uiautomator2-server` package (its prebuilt APKs). It is an optional dependency of prowl-tools; it may have been skipped (--omit=optional) or failed to install. Restore it for a global Prowl install with: npm install -g appium-uiautomator2-server@10.6.2. If Prowl is installed locally in a project, run: npm install appium-uiautomator2-server@10.6.2"
+    );
+  }
+  const pkgDir = import_node_path5.default.dirname(pkgJsonPath);
+  const version = requireFn(pkgJsonPath).version;
+  const serverApk = import_node_path5.default.join(pkgDir, "apks", `appium-uiautomator2-server-v${version}.apk`);
+  const testApk = import_node_path5.default.join(pkgDir, "apks", "appium-uiautomator2-server-debug-androidTest.apk");
+  for (const apk of [serverApk, testApk]) {
+    if (!import_node_fs6.default.existsSync(apk)) {
+      throw new Error(`Expected uiautomator2 agent APK is missing: ${apk}. Reinstall dependencies.`);
+    }
+  }
+  return { serverApk, testApk };
+}
+function looksLikeApk(app) {
+  return app.toLowerCase().endsWith(".apk");
+}
+var execFileAaptResolver = async (apkPath) => {
+  for (const tool of ["aapt", "aapt2"]) {
+    const output = await new Promise((resolve) => {
+      (0, import_node_child_process4.execFile)(
+        tool,
+        ["dump", "badging", apkPath],
+        { encoding: "utf-8", timeout: 2e4, maxBuffer: 8 * 1024 * 1024 },
+        (error, stdout) => resolve(error ? null : stdout)
+      );
+    });
+    const pkg = output ? parseAaptPackage(output) : null;
+    if (pkg) {
+      return pkg;
+    }
+  }
+  return null;
+};
+var defaultAgentConnector = async ({
+  host,
+  port,
+  requestTimeoutMs,
+  readyDeadlineMs,
+  appPackage
+}) => {
+  const transport = new Uia2Transport({
+    baseUrl: `http://${host}:${port}/wd/hub`,
+    requestTimeoutMs
+  });
+  await waitForAgentReady(transport, { deadlineMs: readyDeadlineMs });
+  const sessionId = await createUia2Session(transport);
+  return createUia2AgentClient(transport, sessionId, { appPackage });
+};
+async function resolvePackage(app, runner, serial, aaptResolver, allowedApps) {
+  if (!looksLikeApk(app)) {
+    assertAndroidAppAllowed(allowedApps, app);
+    return app;
+  }
+  const apkPath = import_node_path5.default.resolve(app);
+  if (!import_node_fs6.default.existsSync(apkPath)) {
+    throw new Error(`APK not found: ${apkPath}`);
+  }
+  const pkg = await aaptResolver(apkPath);
+  if (!pkg) {
+    throw new Error(
+      `Could not determine the package name for "${app}". Put Android build-tools \`aapt\`/\`aapt2\` on PATH, or set target.app to the package name instead of the .apk path.`
+    );
+  }
+  assertAndroidAppAllowed(allowedApps, apkPath, pkg);
+  await installApk(runner, serial, apkPath);
+  return pkg;
+}
+async function launchAndroidSession(options) {
+  const runner = options.runner ?? execFileAdbRunner;
+  const spawner = options.spawner ?? spawnAdbProcess;
+  const connector = options.agentConnector ?? defaultAgentConnector;
+  const aaptResolver = options.aaptResolver ?? execFileAaptResolver;
+  const apks = options.apks ?? resolveAgentApks();
+  const requestTimeoutMs = Math.max(options.timeoutMs ?? 1e4, DEFAULT_AGENT_REQUEST_TIMEOUT_MS) + 5e3;
+  const readyDeadlineMs = Math.max(options.timeoutMs ?? 1e4, DEFAULT_AGENT_REQUEST_TIMEOUT_MS);
+  const devices = await listDevices(runner);
+  const serial = selectDeviceSerial(devices, options.deviceSerial);
+  const pkg = await resolvePackage(options.app, runner, serial, aaptResolver, options.allowedApps ?? []);
+  await installApk(runner, serial, apks.serverApk);
+  await installApk(runner, serial, apks.testApk);
+  if (options.coldStart) {
+    await clearPackage(runner, serial, pkg);
+  }
+  await launchPackage(runner, serial, pkg);
+  let instrumentation;
+  let localPort;
+  let client;
+  let tornDown = false;
+  const teardown = async () => {
+    if (tornDown) {
+      return;
+    }
+    tornDown = true;
+    if (client) {
+      await client.close().catch(() => void 0);
+    }
+    instrumentation?.kill();
+    const forwardedPort = localPort;
+    localPort = void 0;
+    if (forwardedPort !== void 0) {
+      await removeForward(runner, serial, forwardedPort);
+    }
+    await forceStop(runner, serial, pkg).catch(() => void 0);
+  };
+  try {
+    instrumentation = startInstrumentation(spawner, serial);
+    localPort = await forwardDynamicPort(runner, serial, UIA2_REMOTE_PORT);
+    client = await connector({
+      host: "127.0.0.1",
+      port: localPort,
+      requestTimeoutMs,
+      readyDeadlineMs,
+      appPackage: pkg
+    });
+    const driver = createAndroidDriver(client, { appLabel: pkg });
+    return { client, driver, package: pkg, serial, teardown };
+  } catch (error) {
+    await teardown();
+    throw error;
+  }
+}
+async function closeAndroidSession(session) {
+  await session.teardown();
+}
+
+// src/browser/ios-helper.ts
+var import_node_module2 = require("module");
+var import_node_child_process6 = require("child_process");
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
+
+// src/browser/ios-driver.ts
+var IOS_CAPABILITIES = /* @__PURE__ */ new Set([
+  "query",
+  "interact",
+  "wait",
+  "screenshot"
+]);
+var WAIT_POLL_INTERVAL_MS2 = 250;
+var DEFAULT_WAIT_TIMEOUT_MS2 = 5e3;
+var IOS_PRESS_KEYS = ["backspace", "del", "delete", "enter", "home", "return"];
+function escapePredicateArg(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function toIosQuery(selector) {
+  switch (selector.kind) {
+    case "focused":
+      return { by: "focused" };
+    case "id":
+      return { by: "accessibilityId", value: selector.value };
+    case "role":
+      return selector.name !== void 0 ? { by: "role", role: selector.role, name: selector.name } : { by: "role", role: selector.role };
+    case "label":
+      return { by: "label", value: selector.value };
+    case "text":
+      return { by: "text", value: selector.value };
+  }
+}
+function parseIosSelector(selector) {
+  return toIosQuery(parseNativeSelector(selector));
+}
+function iosQueryToLocator(query) {
+  switch (query.by) {
+    case "accessibilityId":
+      return { using: "accessibility id", value: query.value };
+    case "label":
+      return { using: "predicate string", value: `label == "${escapePredicateArg(query.value)}"` };
+    case "text": {
+      const escaped = escapePredicateArg(query.value);
+      return {
+        using: "predicate string",
+        value: `label CONTAINS "${escaped}" OR value CONTAINS "${escaped}"`
+      };
+    }
+    case "focused":
+      return { using: "predicate string", value: "hasKeyboardFocus == 1" };
+    case "role": {
+      const className = normalizeXcuiClassName(query.role);
+      if (query.name === void 0 || query.name.length === 0) {
+        return { using: "class name", value: className };
+      }
+      const escapedClass = escapePredicateArg(className);
+      const escapedName = escapePredicateArg(query.name);
+      return {
+        using: "predicate string",
+        value: `type == "${escapedClass}" AND (label CONTAINS "${escapedName}" OR value CONTAINS "${escapedName}")`
+      };
+    }
+  }
+}
+function unwrapIosTextSelector(selector) {
+  return unwrapNativeTextSelector(selector);
+}
+function delay2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function createIosDriver(client, options) {
+  const unsupported = (verb) => new Error(`${verb} is not supported by the iOS target`);
+  const rejectUnsupported = (verb) => Promise.reject(unsupported(verb));
+  async function resolveOne(selector) {
+    const id = await client.findElement(parseIosSelector(selector));
+    if (id === null) {
+      throw new Error(`No element matched selector: ${selector}`);
+    }
+    return id;
+  }
+  async function clickSelector(selector) {
+    await client.click(await resolveOne(selector));
+  }
+  async function fillSelector(selector, value) {
+    await client.setValue(await resolveOne(selector), value);
+  }
+  async function pressKey(key) {
+    const name = key.trim().toLowerCase();
+    if (name === "enter" || name === "return") {
+      await client.sendKeys(["\n"]);
+      return;
+    }
+    if (name === "delete" || name === "backspace" || name === "del") {
+      await client.sendKeys(["\b"]);
+      return;
+    }
+    if (name === "home") {
+      await client.homescreen();
+      return;
+    }
+    throw new Error(
+      `Unsupported key "${key}" for the iOS target. Supported keys: ${IOS_PRESS_KEYS.join(", ")}.`
+    );
+  }
+  return {
+    capabilities: IOS_CAPABILITIES,
+    // navigation -----------------------------------------------------------
+    goto(_url, _options) {
+      return rejectUnsupported("navigate");
+    },
+    currentUrl() {
+      return `ios:${options.appLabel ?? ""}`;
+    },
+    // queries --------------------------------------------------------------
+    async count(selector) {
+      return (await client.findElements(parseIosSelector(selector))).length;
+    },
+    async textContent(selector) {
+      const id = await client.findElement(parseIosSelector(selector));
+      if (id === null) {
+        return null;
+      }
+      return client.getText(id);
+    },
+    // interactions ---------------------------------------------------------
+    click: clickSelector,
+    clickFirst: clickSelector,
+    fill: fillSelector,
+    fillFirst: fillSelector,
+    async press(_selector, key) {
+      await pressKey(key);
+    },
+    selectOption() {
+      return rejectUnsupported("select");
+    },
+    selectOptionFirst() {
+      return rejectUnsupported("select");
+    },
+    hover() {
+      return rejectUnsupported("hover");
+    },
+    scrollIntoView() {
+      return rejectUnsupported("scrollTo");
+    },
+    setInputFiles() {
+      return rejectUnsupported("setInputFiles");
+    },
+    // semantic locators ----------------------------------------------------
+    async countByRole(role, name) {
+      return (await client.findElements({ by: "role", role, name })).length;
+    },
+    async clickFirstByRole(role, name) {
+      const id = await client.findElement({ by: "role", role, name });
+      if (id === null) {
+        throw new Error(`No element matched role=${role}[name="${name}"]`);
+      }
+      await client.click(id);
+    },
+    async countByLabel(label) {
+      return (await client.findElements({ by: "label", value: label })).length;
+    },
+    async fillFirstByLabel(label, value) {
+      const id = await client.findElement({ by: "label", value: label });
+      if (id === null) {
+        throw new Error(`No element matched label="${label}"`);
+      }
+      await client.setValue(id, value);
+    },
+    selectOptionFirstByLabel() {
+      return rejectUnsupported("select");
+    },
+    // waiting --------------------------------------------------------------
+    async waitForSelector(selector, waitOptions) {
+      const query = parseIosSelector(selector);
+      const timeoutMs = waitOptions?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS2;
+      const deadline = Date.now() + timeoutMs;
+      for (; ; ) {
+        if ((await client.findElements(query)).length > 0) {
+          return;
+        }
+        if (Date.now() >= deadline) {
+          throw new Error(`Timed out after ${timeoutMs}ms waiting for selector: ${selector}`);
+        }
+        await delay2(Math.min(WAIT_POLL_INTERVAL_MS2, Math.max(0, deadline - Date.now())));
+      }
+    },
+    waitForUrl() {
+      return rejectUnsupported("waitForUrl");
+    },
+    waitForNetworkIdle() {
+      return rejectUnsupported("waitForNetworkIdle");
+    },
+    // scripting & artifacts ------------------------------------------------
+    evaluate() {
+      return rejectUnsupported("evalScript");
+    },
+    async screenshot(screenshotOptions) {
+      await options.captureScreenshot(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 unwrapIosTextSelector(selector);
+    }
+  };
+}
+
+// src/browser/ios-simctl.ts
+var import_node_child_process5 = require("child_process");
+var import_promises = require("fs/promises");
+var import_node_net = __toESM(require("net"), 1);
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var spawnXcrunProcess = (args, options) => {
+  const child = (0, import_node_child_process5.spawn)("xcrun", args, {
+    stdio: "ignore",
+    env: options?.env ? { ...process.env, ...options.env } : process.env
+  });
+  child.on("error", () => {
+  });
+  return {
+    kill: () => {
+      child.kill();
+    }
+  };
+};
+var DEFAULT_SIMULATOR_LOCK_ROOT = import_node_path6.default.join(import_node_os.default.tmpdir(), "prowl-ios-simulator-locks");
+var SIMULATOR_LOCK_OWNER_FILE = "owner.json";
+var execFileXcrunRunner = (args, options) => new Promise((resolve) => {
+  (0, import_node_child_process5.execFile)(
+    "xcrun",
+    args,
+    {
+      encoding: "utf-8",
+      timeout: options?.timeoutMs,
+      maxBuffer: 32 * 1024 * 1024,
+      env: options?.env ? { ...process.env, ...options.env } : process.env
+    },
+    (error, stdout, stderr) => {
+      const code = error && typeof error.code === "number" ? error.code : error ? 1 : 0;
+      const capturedStderr = stderr ?? "";
+      resolve({
+        stdout: stdout ?? "",
+        stderr: capturedStderr.trim() ? capturedStderr : error?.message ?? "",
+        code
+      });
+    }
+  );
+});
+function simulatorLockName(udid) {
+  const safe = udid.replace(/[^A-Za-z0-9_.-]/g, "_");
+  return `${safe || "simulator"}.lock`;
+}
+function isErrno(error, code) {
+  return error?.code === code;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isErrno(error, "EPERM");
+  }
+}
+async function removeStaleSimulatorLock(lockPath) {
+  try {
+    const ownerText = await (0, import_promises.readFile)(import_node_path6.default.join(lockPath, SIMULATOR_LOCK_OWNER_FILE), "utf8");
+    const owner = JSON.parse(ownerText);
+    if (typeof owner.pid === "number" && Number.isInteger(owner.pid) && owner.pid > 0 && !isProcessAlive(owner.pid)) {
+      await (0, import_promises.rm)(lockPath, { recursive: true, force: true });
+      return true;
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
+function simulatorReservedError(udid) {
+  return new Error(
+    `iOS simulator "${udid}" is already reserved by another Prowl process. Wait for that run to finish, or boot/select a different simulator with target.udid.`
+  );
+}
+async function reserveSimulatorUdid(udid, options = {}) {
+  const lockRoot = options.lockRoot ?? DEFAULT_SIMULATOR_LOCK_ROOT;
+  const lockPath = import_node_path6.default.join(lockRoot, simulatorLockName(udid));
+  await (0, import_promises.mkdir)(lockRoot, { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      await (0, import_promises.mkdir)(lockPath);
+    } catch (error) {
+      if (!isErrno(error, "EEXIST")) {
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+      if (attempt === 0 && await removeStaleSimulatorLock(lockPath)) {
+        continue;
+      }
+      throw simulatorReservedError(udid);
+    }
+    let released = false;
+    const release = async () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      await (0, import_promises.rm)(lockPath, { recursive: true, force: true });
+    };
+    try {
+      await (0, import_promises.writeFile)(
+        import_node_path6.default.join(lockPath, SIMULATOR_LOCK_OWNER_FILE),
+        `${JSON.stringify({ pid: process.pid, udid, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
+`,
+        { flag: "wx" }
+      );
+    } catch (error) {
+      await release().catch(() => void 0);
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+    return { udid, release };
+  }
+  throw simulatorReservedError(udid);
+}
+function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const server = import_node_net.default.createServer();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address === "object") {
+        const { port } = address;
+        server.close(() => resolve(port));
+      } else {
+        server.close(() => reject(new Error("Could not allocate a local port")));
+      }
+    });
+  });
+}
+function parseSimctlDevices(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new Error("Could not parse `simctl list devices --json` output.");
+  }
+  const byRuntime = parsed?.devices;
+  if (!byRuntime || typeof byRuntime !== "object") {
+    return [];
+  }
+  const devices = [];
+  for (const [runtime, entries] of Object.entries(byRuntime)) {
+    if (!Array.isArray(entries)) {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      const record = entry;
+      const udid = typeof record.udid === "string" ? record.udid : void 0;
+      const name = typeof record.name === "string" ? record.name : void 0;
+      const state = typeof record.state === "string" ? record.state : "Unknown";
+      if (!udid || !name) {
+        continue;
+      }
+      devices.push({
+        udid,
+        name,
+        state,
+        runtime,
+        isAvailable: record.isAvailable !== false
+      });
+    }
+  }
+  return devices;
+}
+function bootedSimulators(devices) {
+  return devices.filter((device) => device.state === "Booted");
+}
+function describeSimulator(device) {
+  const runtime = device.runtime.replace(/^com\.apple\.CoreSimulator\.SimRuntime\./, "");
+  return `${device.name} [${runtime}] (${device.udid})`;
+}
+function selectSimulatorUdid(devices, requested) {
+  const booted = bootedSimulators(devices);
+  if (requested) {
+    const match = devices.find((device) => device.udid === requested);
+    if (!match) {
+      const known = devices.length > 0 ? devices.map((d) => d.udid).join(", ") : "none";
+      throw new Error(
+        `iOS simulator "${requested}" was not found. Known simulators: ${known}. Check \`xcrun simctl list devices\`.`
+      );
+    }
+    if (match.state !== "Booted") {
+      throw new Error(
+        `iOS simulator "${requested}" is not booted (state: ${match.state}). Boot it with \`xcrun simctl boot ${requested}\`, then retry.`
+      );
+    }
+    return requested;
+  }
+  if (booted.length === 0) {
+    throw new Error(
+      "No booted iOS simulator found. Boot one from Xcode or with `xcrun simctl boot <udid>` (see `xcrun simctl list devices available`), then retry."
+    );
+  }
+  if (booted.length > 1) {
+    throw new Error(
+      `Multiple iOS simulators are booted (${booted.map(describeSimulator).join("; ")}). Set target.udid to pick one.`
+    );
+  }
+  return booted[0].udid;
+}
+async function listSimulators(runner) {
+  const result = await runner(["simctl", "list", "devices", "--json"], { timeoutMs: 3e4 });
+  if (result.code !== 0) {
+    throw new Error(
+      `\`xcrun simctl list devices\` failed. Is Xcode installed and are the command-line tools selected (\`xcode-select -p\`)? ${(result.stderr.trim() || "").slice(0, 400)}`
+    );
+  }
+  return parseSimctlDevices(result.stdout);
+}
+async function installApp(runner, udid, appPath) {
+  const result = await runner(["simctl", "install", udid, appPath], { timeoutMs: 12e4 });
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to install "${appPath}" onto simulator ${udid}: ${(result.stderr.trim() || result.stdout.trim()).slice(0, 400)}`
+    );
+  }
+}
+async function uninstallApp(runner, udid, bundleId) {
+  await runner(["simctl", "uninstall", udid, bundleId], { timeoutMs: 6e4 }).catch(() => void 0);
+}
+async function launchApp(runner, udid, bundleId, childEnv = {}) {
+  const env = {};
+  for (const [key, value] of Object.entries(childEnv)) {
+    env[`SIMCTL_CHILD_${key}`] = value;
+  }
+  const result = await runner(["simctl", "launch", udid, bundleId], {
+    timeoutMs: 6e4,
+    env: Object.keys(env).length > 0 ? env : void 0
+  });
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to launch "${bundleId}" on simulator ${udid}: ${(result.stderr.trim() || result.stdout.trim()).slice(0, 400)}. Is it installed?`
+    );
+  }
+}
+async function terminateApp(runner, udid, bundleId) {
+  await runner(["simctl", "terminate", udid, bundleId], { timeoutMs: 3e4 }).catch(() => void 0);
+}
+async function captureScreenshot(runner, udid, outPath) {
+  const result = await runner(["simctl", "io", udid, "screenshot", outPath], { timeoutMs: 3e4 });
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to capture a simulator screenshot (${udid}): ${(result.stderr.trim() || result.stdout.trim()).slice(0, 300)}`
+    );
+  }
+}
+function parseXcodeVersion(stdout) {
+  const match = /Xcode\s+([\d.]+)/i.exec(stdout);
+  return match?.[1] ?? null;
+}
+async function xcodeVersion(runner) {
+  const result = await runner(["xcodebuild", "-version"], { timeoutMs: 3e4 });
+  if (result.code !== 0) {
+    return null;
+  }
+  return parseXcodeVersion(result.stdout);
+}
+
+// src/browser/ios-agent.ts
+var DEFAULT_WDA_REQUEST_TIMEOUT_MS = 3e4;
+var W3C_ELEMENT_KEY2 = "element-6066-11e4-a52e-4f735466cecf";
+var WdaHttpError = class extends Error {
+  constructor(message, status, webdriverError) {
+    super(message);
+    this.status = status;
+    this.webdriverError = webdriverError;
+    this.name = "WdaHttpError";
+  }
+};
+var WdaTransport = class {
+  baseUrl;
+  requestTimeoutMs;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_WDA_REQUEST_TIMEOUT_MS;
+    const injected = options.fetchImpl;
+    if (injected) {
+      this.fetchImpl = injected;
+    } else if (typeof fetch === "function") {
+      this.fetchImpl = (url, init) => fetch(url, init);
+    } else {
+      throw new Error("global fetch is unavailable; Node 20+ is required for the iOS target");
+    }
+  }
+  /**
+   * Send one request and return the full parsed JSON body. Rejects with a
+   * {@link WdaHttpError} on a non-2xx response, or a timeout error when the
+   * per-request deadline elapses.
+   */
+  async requestFull(method, path25, body, timeoutMs) {
+    const requestTimeoutMs = timeoutMs ?? this.requestTimeoutMs;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+    timer.unref?.();
+    const url = `${this.baseUrl}${path25}`;
+    const timeoutError = () => {
+      const shown = requestTimeoutMs >= 1e3 ? `${Math.round(requestTimeoutMs / 1e3)}s` : `${requestTimeoutMs}ms`;
+      return new Error(`WebDriverAgent request ${method} ${path25} timed out after ${shown}`);
+    };
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        signal: controller.signal,
+        headers: body !== void 0 ? { "content-type": "application/json" } : void 0,
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    } catch (error) {
+      clearTimeout(timer);
+      if (controller.signal.aborted) {
+        throw timeoutError();
+      }
+      throw error instanceof Error ? error : new Error(String(error));
+    }
+    let text;
+    try {
+      text = await response.text();
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw timeoutError();
+      }
+      throw error instanceof Error ? error : new Error(String(error));
+    } finally {
+      clearTimeout(timer);
+    }
+    const parsed = parseJson2(text);
+    if (!response.ok) {
+      const wdError = extractWebdriverError2(parsed);
+      throw new WdaHttpError(
+        `WebDriverAgent ${method} ${path25} failed (${response.status})${wdError ? `: ${wdError}` : ""}`,
+        response.status,
+        wdError
+      );
+    }
+    return parsed;
+  }
+  /** Like {@link requestFull} but returns just the `value` field. */
+  async request(method, path25, body, timeoutMs) {
+    const parsed = await this.requestFull(method, path25, body, timeoutMs);
+    return parsed?.value;
+  }
+};
+function parseJson2(text) {
+  if (!text) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function extractWebdriverError2(parsed) {
+  const value = parsed?.value;
+  if (value && typeof value === "object") {
+    const record = value;
+    const error = typeof record.error === "string" ? record.error : void 0;
+    const message = typeof record.message === "string" ? record.message : void 0;
+    return error ?? message;
+  }
+  return void 0;
+}
+function extractElementId2(value) {
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const record = value;
+  const id = record[W3C_ELEMENT_KEY2] ?? record.ELEMENT;
+  return typeof id === "string" ? id : null;
+}
+function isNoSuchElement2(error) {
+  if (error instanceof WdaHttpError) {
+    return error.status === 404 || (error.webdriverError ?? "").includes("no such element");
+  }
+  return false;
+}
+async function createWdaSession(transport, bundleId) {
+  const body = await transport.requestFull("POST", "/session", {
+    capabilities: { alwaysMatch: { bundleId }, firstMatch: [{}] }
+  });
+  const envelope = body ?? {};
+  const value = envelope.value ?? {};
+  const sessionId = typeof value.sessionId === "string" && value.sessionId || typeof envelope.sessionId === "string" && envelope.sessionId || "";
+  if (sessionId.length > 0) {
+    return sessionId;
+  }
+  throw new Error("WebDriverAgent did not return a session id");
+}
+async function waitForWdaReady(transport, options = { deadlineMs: 6e4 }) {
+  const interval = options.intervalMs ?? 300;
+  const deadline = Date.now() + options.deadlineMs;
+  let lastError;
+  for (; ; ) {
+    try {
+      const remainingMs = Math.max(1, deadline - Date.now());
+      await transport.request("GET", "/status", void 0, Math.min(remainingMs, 5e3));
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+    if (Date.now() >= deadline) {
+      const detail = lastError instanceof Error ? `: ${lastError.message}` : "";
+      throw new Error(`WebDriverAgent did not become ready within ${options.deadlineMs}ms${detail}`);
+    }
+    await sleep2(Math.min(interval, Math.max(0, deadline - Date.now())));
+  }
+}
+function sleep2(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+function createWdaAgentClient(transport, sessionId) {
+  const base = `/session/${sessionId}`;
+  async function locate(query, path25) {
+    return transport.request("POST", `${base}${path25}`, iosQueryToLocator(query));
+  }
+  return {
+    async findElement(query) {
+      try {
+        return extractElementId2(await locate(query, "/element"));
+      } catch (error) {
+        if (isNoSuchElement2(error)) {
+          return null;
+        }
+        throw error;
+      }
+    },
+    async findElements(query) {
+      const value = await locate(query, "/elements");
+      if (!Array.isArray(value)) {
+        return [];
+      }
+      return value.map((entry) => extractElementId2(entry)).filter((id) => id !== null);
+    },
+    async click(elementId) {
+      await transport.request("POST", `${base}/element/${elementId}/click`, {});
+    },
+    async setValue(elementId, text) {
+      await transport.request("POST", `${base}/element/${elementId}/value`, { text });
+    },
+    async getText(elementId) {
+      const value = await transport.request("GET", `${base}/element/${elementId}/text`);
+      return typeof value === "string" ? value : value == null ? null : String(value);
+    },
+    async sendKeys(keys) {
+      await transport.request("POST", `${base}/wda/keys`, { value: keys });
+    },
+    async homescreen() {
+      await transport.request("POST", "/wda/homescreen", {});
+    },
+    async source() {
+      const value = await transport.request("GET", "/source");
+      if (typeof value !== "string") {
+        throw new Error("WebDriverAgent /source did not return XML text; cannot analyze iOS UI hierarchy");
+      }
+      return value;
+    },
+    async close() {
+      await transport.request("DELETE", base).catch(() => void 0);
+    }
+  };
+}
+
+// src/browser/ios-helper.ts
+var import_meta3 = {};
+var WDA_RUNNER_BUNDLE_ID = "com.facebook.WebDriverAgentRunner.xctrunner";
+var WDA_USE_PORT_ENV = "USE_PORT";
+var PREPARED_XCTESTRUN_PREFIX = "prowl-wda-xctestrun-";
+var WDA_STARTUP_ATTEMPTS = 2;
+var defaultIosAgentConnector = async ({
+  host,
+  port,
+  bundleId,
+  requestTimeoutMs,
+  readyDeadlineMs
+}) => {
+  const transport = new WdaTransport({ baseUrl: `http://${host}:${port}`, requestTimeoutMs });
+  await waitForWdaReady(transport, { deadlineMs: readyDeadlineMs });
+  const sessionId = await createWdaSession(transport, bundleId);
+  return createWdaAgentClient(transport, sessionId);
+};
+function resolveWdaProject(requireFn = (0, import_node_module2.createRequire)(import_meta3.url)) {
+  let pkgJsonPath;
+  try {
+    pkgJsonPath = requireFn.resolve("appium-webdriveragent/package.json");
+  } catch {
+    throw new Error(
+      "The iOS target requires the `appium-webdriveragent` package (its WDA Xcode project). It is an optional dependency of prowl-tools; it may have been skipped (--omit=optional) or failed to install. Restore it for a global Prowl install with: npm install -g appium-webdriveragent@16.4.0. If Prowl is installed locally in a project, run: npm install appium-webdriveragent@16.4.0"
+    );
+  }
+  const pkgDir = import_node_path7.default.dirname(pkgJsonPath);
+  const version = requireFn(pkgJsonPath).version;
+  const projectPath = import_node_path7.default.join(pkgDir, "WebDriverAgent.xcodeproj");
+  if (!import_node_fs7.default.existsSync(projectPath)) {
+    throw new Error(`Expected WebDriverAgent project is missing: ${projectPath}. Reinstall dependencies.`);
+  }
+  return { projectPath, version };
+}
+function wdaCacheDir(wdaVersion, xcode, homeDir = import_node_os2.default.homedir()) {
+  return import_node_path7.default.join(homeDir, ".prowl", "wda", `${wdaVersion}-xcode${xcode}`);
+}
+function productsDir(derivedDataPath) {
+  return import_node_path7.default.join(derivedDataPath, "Build", "Products");
+}
+function findXctestrunIn(dir) {
+  let entries;
+  try {
+    entries = import_node_fs7.default.readdirSync(dir);
+  } catch {
+    return null;
+  }
+  const match = entries.filter((name) => name.endsWith(".xctestrun") && !name.startsWith(PREPARED_XCTESTRUN_PREFIX)).sort()[0];
+  return match ? import_node_path7.default.join(dir, match) : null;
+}
+function resolveOverrideXctestrun(override) {
+  if (!import_node_fs7.default.existsSync(override)) {
+    throw new Error(`PROWL_WDA_RUNNER points at a missing path: ${override}`);
+  }
+  if (override.endsWith(".xctestrun")) {
+    return override;
+  }
+  const candidates = [];
+  const stat = import_node_fs7.default.statSync(override);
+  if (override.endsWith(".app")) {
+    candidates.push(import_node_path7.default.dirname(import_node_path7.default.dirname(override)));
+  } else if (stat.isDirectory()) {
+    candidates.push(override, productsDir(override));
+  }
+  for (const dir of candidates) {
+    const found = findXctestrunIn(dir);
+    if (found) {
+      return found;
+    }
+  }
+  throw new Error(
+    `PROWL_WDA_RUNNER (${override}) does not resolve to a WebDriverAgent .xctestrun. Point it at the generated \`*.xctestrun\`, at the \`-derivedDataPath\` directory from \`xcodebuild build-for-testing\`, or at that build's runner \`.app\`.`
+  );
+}
+async function resolveWdaTestRun(options = {}) {
+  const runner = options.runner ?? execFileXcrunRunner;
+  const env = options.env ?? process.env;
+  const homeDir = options.homeDir ?? import_node_os2.default.homedir();
+  const log = options.logger ?? ((message) => process.stderr.write(`${message}
+`));
+  const override = env.PROWL_WDA_RUNNER;
+  if (override) {
+    return resolveOverrideXctestrun(override);
+  }
+  const { projectPath, version } = resolveWdaProject(options.requireFn);
+  const xcode = await xcodeVersion(runner);
+  if (!xcode) {
+    throw new Error(
+      "Could not determine the Xcode version (`xcrun xcodebuild -version`). The iOS target requires Xcode on macOS. Install it and run `xcode-select --switch`, then retry."
+    );
+  }
+  const cacheDir = wdaCacheDir(version, xcode, homeDir);
+  const cached = findXctestrunIn(productsDir(cacheDir));
+  if (cached) {
+    return cached;
+  }
+  log(
+    `Prowl: building WebDriverAgent for the iOS target (first run only; this can take a few minutes)\u2026`
+  );
+  import_node_fs7.default.mkdirSync(cacheDir, { recursive: true });
+  const result = await runner(
+    [
+      "xcodebuild",
+      "build-for-testing",
+      "-project",
+      projectPath,
+      "-scheme",
+      "WebDriverAgentRunner",
+      "-destination",
+      "generic/platform=iOS Simulator",
+      "-derivedDataPath",
+      cacheDir,
+      "CODE_SIGNING_ALLOWED=NO"
+    ],
+    { timeoutMs: 12e5 }
+  );
+  if (result.code !== 0) {
+    throw new Error(
+      `Failed to build WebDriverAgent with \`xcodebuild build-for-testing\`. Ensure a full Xcode (not just the command-line tools) is installed and selected (\`xcode-select -p\`). Details: ${(result.stderr.trim() || result.stdout.trim()).slice(-800)}`
+    );
+  }
+  const built = findXctestrunIn(productsDir(cacheDir));
+  if (!built) {
+    throw new Error(
+      `WebDriverAgent build succeeded but no .xctestrun was found under ${productsDir(cacheDir)}. This may indicate an Xcode layout change; set PROWL_WDA_RUNNER to a prebuilt runner/xctestrun.`
+    );
+  }
+  return built;
+}
+function injectUsePortIntoXctestrun(plist, port) {
+  const clone = structuredClone(plist);
+  let injected = 0;
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      for (const entry of node) {
+        visit(entry);
+      }
+      return;
+    }
+    if (!node || typeof node !== "object") {
+      return;
+    }
+    const obj = node;
+    const isTarget = typeof obj.TestBundlePath === "string" || typeof obj.TestHostPath === "string";
+    const existingEnv = obj.EnvironmentVariables && typeof obj.EnvironmentVariables === "object" && !Array.isArray(obj.EnvironmentVariables) ? obj.EnvironmentVariables : void 0;
+    if (isTarget || existingEnv) {
+      const env = existingEnv ?? {};
+      env[WDA_USE_PORT_ENV] = String(port);
+      obj.EnvironmentVariables = env;
+      injected += 1;
+    }
+    for (const value of Object.values(obj)) {
+      visit(value);
+    }
+  };
+  visit(clone);
+  if (injected === 0) {
+    throw new Error(
+      "Could not find a test target in the WebDriverAgent .xctestrun to set USE_PORT. The xctestrun format may have changed; set PROWL_WDA_RUNNER to a compatible runner."
+    );
+  }
+  return clone;
+}
+function runPlutil(args) {
+  return new Promise((resolve, reject) => {
+    (0, import_node_child_process6.execFile)(
+      "plutil",
+      args,
+      { encoding: "utf-8", maxBuffer: 32 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          reject(
+            new Error(
+              `\`plutil ${args.join(" ")}\` failed: ${(stderr || error.message).slice(0, 400)}`
+            )
+          );
+          return;
+        }
+        resolve(stdout ?? "");
+      }
+    );
+  });
+}
+var defaultWdaTestRunPreparer = async ({ xctestrunPath, port }) => {
+  const json = await runPlutil(["-convert", "json", "-o", "-", xctestrunPath]);
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    throw new Error(`Could not parse the WebDriverAgent .xctestrun as JSON: ${xctestrunPath}`);
+  }
+  const injected = injectUsePortIntoXctestrun(parsed, port);
+  const stem = `${PREPARED_XCTESTRUN_PREFIX}${port}-${process.pid}`;
+  const outPath = import_node_path7.default.join(import_node_path7.default.dirname(xctestrunPath), `${stem}.xctestrun`);
+  const jsonPath = import_node_path7.default.join(import_node_os2.default.tmpdir(), `${stem}.json`);
+  import_node_fs7.default.writeFileSync(jsonPath, JSON.stringify(injected));
+  try {
+    await runPlutil(["-convert", "xml1", jsonPath, "-o", outPath]);
+  } finally {
+    import_node_fs7.default.rmSync(jsonPath, { force: true });
+  }
+  return outPath;
+};
+function cleanupPreparedTestRun(preparedPath) {
+  if (!preparedPath) {
+    return;
+  }
+  if (!import_node_path7.default.basename(preparedPath).startsWith(PREPARED_XCTESTRUN_PREFIX)) {
+    return;
+  }
+  import_node_fs7.default.rmSync(preparedPath, { force: true });
+}
+function wdaTestRunArgs(xctestrunPath, udid) {
+  return [
+    "xcodebuild",
+    "test-without-building",
+    "-xctestrun",
+    xctestrunPath,
+    "-destination",
+    `id=${udid}`
+  ];
+}
+async function resolveBundleId(app, runner, udid, coldStart, allowedApps) {
+  if (!looksLikeIosAppPath(app)) {
+    assertIosAppAllowed(allowedApps, app);
+    if (coldStart) {
+      throw new Error(
+        `coldStart requires target.app to be a built .app bundle path (a bare bundle id like "${app}" cannot be reinstalled). Point target.app at the .app, or drop coldStart.`
+      );
+    }
+    return app;
+  }
+  const appPath = import_node_path7.default.resolve(app);
+  if (!import_node_fs7.default.existsSync(appPath)) {
+    throw new Error(`.app bundle not found: ${appPath}`);
+  }
+  const bundleId = readIosBundleIdentifier(appPath);
+  if (!bundleId) {
+    throw new Error(
+      `Could not read CFBundleIdentifier from "${appPath}" (root Info.plist). Ensure target.app points at a built iOS .app bundle.`
+    );
+  }
+  assertIosAppAllowed(allowedApps, appPath);
+  if (coldStart) {
+    await uninstallApp(runner, udid, bundleId);
+  }
+  await installApp(runner, udid, appPath);
+  return bundleId;
+}
+async function launchIosSession(options) {
+  const runner = options.runner ?? execFileXcrunRunner;
+  const spawner = options.spawner ?? spawnXcrunProcess;
+  const preparer = options.testRunPreparer ?? defaultWdaTestRunPreparer;
+  const portAllocator = options.portAllocator ?? findFreePort;
+  const connector = options.agentConnector ?? defaultIosAgentConnector;
+  const requestTimeoutMs = Math.max(options.timeoutMs ?? 1e4, DEFAULT_WDA_REQUEST_TIMEOUT_MS) + 5e3;
+  const readyDeadlineMs = Math.max(options.timeoutMs ?? 1e4, 6e4);
+  const devices = await listSimulators(runner);
+  const udid = selectSimulatorUdid(devices, options.udid);
+  const reservation = await reserveSimulatorUdid(udid, { lockRoot: options.simulatorLockRoot });
+  let reservationReleased = false;
+  const releaseReservation = async () => {
+    if (reservationReleased) {
+      return;
+    }
+    reservationReleased = true;
+    await reservation.release();
+  };
+  try {
+    const bundleId = await resolveBundleId(
+      options.app,
+      runner,
+      udid,
+      options.coldStart ?? false,
+      options.allowedApps ?? []
+    );
+    const baseTestRun = options.wdaTestRun ?? await resolveWdaTestRun({ runner, logger: options.logger });
+    for (let attempt = 1; attempt <= WDA_STARTUP_ATTEMPTS; attempt += 1) {
+      let client;
+      let wdaProcess;
+      let preparedTestRun;
+      let tornDown = false;
+      let terminateTarget = false;
+      let stage = "prepare";
+      const teardownAttempt = async () => {
+        if (tornDown) {
+          return;
+        }
+        tornDown = true;
+        if (client) {
+          await client.close().catch(() => void 0);
+        }
+        wdaProcess?.kill();
+        await terminateApp(runner, udid, WDA_RUNNER_BUNDLE_ID);
+        if (terminateTarget) {
+          await terminateApp(runner, udid, bundleId);
+        }
+        cleanupPreparedTestRun(preparedTestRun);
+      };
+      try {
+        const port = await portAllocator();
+        preparedTestRun = await preparer({ xctestrunPath: baseTestRun, port });
+        stage = "wda-launch";
+        wdaProcess = spawner(wdaTestRunArgs(preparedTestRun, udid));
+        stage = "target-launch";
+        terminateTarget = true;
+        await launchApp(runner, udid, bundleId);
+        stage = "connect";
+        client = await connector({ host: "127.0.0.1", port, bundleId, requestTimeoutMs, readyDeadlineMs });
+        const driver = createIosDriver(client, {
+          appLabel: bundleId,
+          captureScreenshot: (outPath) => captureScreenshot(runner, udid, outPath)
+        });
+        const teardown = async () => {
+          await teardownAttempt();
+          await releaseReservation();
+        };
+        return { client, driver, bundleId, udid, teardown };
+      } catch (error) {
+        await teardownAttempt();
+        if (stage === "target-launch" || attempt >= WDA_STARTUP_ATTEMPTS) {
+          throw error instanceof Error ? error : new Error(String(error));
+        }
+      }
+    }
+    throw new Error("WebDriverAgent startup failed without an error.");
+  } catch (error) {
+    await releaseReservation().catch(() => void 0);
+    throw error;
+  }
+}
+async function closeIosSession(session) {
+  await session.teardown();
+}
+
+// src/runner/steps.ts
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path9 = __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 locator2 = probe.locator(candidate.selector);
+      count = await locator2.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,
@@ -2024,6 +4167,246 @@ function createRunPolicy(driver, options) {
   };
 }
 
+// src/generator/ai.ts
+var DEFAULT_BASE_URL = {
+  anthropic: "https://api.anthropic.com",
+  openai: "https://api.openai.com"
+};
+var AI_REQUEST_TIMEOUT_MS = 3e4;
+function apiRoot(config) {
+  return config.baseUrl ?? DEFAULT_BASE_URL[config.provider];
+}
+function defaultModelFor(provider) {
+  return provider === "anthropic" ? "claude-sonnet-4-5-20250929" : "gpt-4o";
+}
+function resolveAiEnv() {
+  const provider = process.env.PROWL_AI_PROVIDER ?? "anthropic";
+  if (provider !== "anthropic" && provider !== "openai") {
+    throw new Error(`Unsupported AI provider: ${provider}. Use "anthropic" or "openai".`);
+  }
+  const model = process.env.PROWL_AI_MODEL ?? defaultModelFor(provider);
+  const baseUrl = normalizeBaseUrl(process.env.PROWL_AI_BASE_URL) ?? DEFAULT_BASE_URL[provider];
+  return { provider, model, baseUrl, apiKey: process.env.PROWL_AI_KEY };
+}
+function normalizeBaseUrl(value) {
+  if (value === void 0) return void 0;
+  const trimmed = value.trim().replace(/\/+$/, "");
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveAiConfig() {
+  const env = resolveAiEnv();
+  if (!env.apiKey) {
+    throw new Error(
+      "PROWL_AI_KEY environment variable is required. Set it to your Anthropic or OpenAI API key."
+    );
+  }
+  return { provider: env.provider, model: env.model, apiKey: env.apiKey, baseUrl: env.baseUrl };
+}
+function tryResolveAiConfig() {
+  const env = resolveAiEnv();
+  if (!env.apiKey) {
+    return null;
+  }
+  return { provider: env.provider, model: env.model, apiKey: env.apiKey, baseUrl: env.baseUrl };
+}
+async function generateWithAi(prompt, config) {
+  if (config.provider === "anthropic") {
+    return generateWithAnthropic(prompt, config);
+  }
+  return generateWithOpenAi(prompt, config);
+}
+async function generateWithAnthropic(prompt, config) {
+  const data = await postJson(
+    "Anthropic",
+    `${apiRoot(config)}/v1/messages`,
+    anthropicHeaders(config),
+    {
+      model: config.model,
+      max_tokens: 4096,
+      messages: [
+        { role: "user", content: prompt }
+      ]
+    }
+  );
+  return extractAnthropicText(data);
+}
+async function generateWithOpenAi(prompt, config) {
+  const data = await postJson(
+    "OpenAI",
+    `${apiRoot(config)}/v1/chat/completions`,
+    openAiHeaders(config),
+    {
+      model: config.model,
+      messages: [
+        { role: "user", content: prompt }
+      ],
+      max_tokens: 4096
+    }
+  );
+  return extractOpenAiText(data);
+}
+function buildVisionPrompt(assertion) {
+  return [
+    "You are a meticulous QA reviewer. You are given a screenshot of an application",
+    "and a single assertion describing what should be true about it.",
+    "",
+    "Assertion:",
+    assertion,
+    "",
+    "Decide whether the assertion holds for the screenshot. Judge ONLY what is",
+    "visible; do not assume behavior you cannot see. Be strict: if the assertion",
+    "is not clearly satisfied, it fails.",
+    "",
+    "Reply with ONLY a single JSON object on one line, no markdown, no code fences:",
+    '{"pass": <true|false>, "reason": "<one concise sentence explaining the verdict>"}'
+  ].join("\n");
+}
+function parseVisionVerdict(raw) {
+  const cleaned = stripCodeFences(raw).trim();
+  const candidate = extractJsonObject(cleaned);
+  if (candidate === null) {
+    throw new Error(
+      `Could not parse a JSON verdict from the AI response: ${truncateForError(raw)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(candidate);
+  } catch {
+    throw new Error(
+      `AI verdict was not valid JSON: ${truncateForError(raw)}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error(`AI verdict was not a JSON object: ${truncateForError(raw)}`);
+  }
+  const record = parsed;
+  if (typeof record.pass !== "boolean") {
+    throw new Error(
+      `AI verdict is missing a boolean "pass" field: ${truncateForError(raw)}`
+    );
+  }
+  const reason = typeof record.reason === "string" && record.reason.trim().length > 0 ? record.reason.trim() : record.pass ? "Assertion satisfied." : "Assertion not satisfied.";
+  return { pass: record.pass, reason };
+}
+function stripCodeFences(text) {
+  const fence = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  return fence ? fence[1] : text;
+}
+function extractJsonObject(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith("{") && trimmed.endsWith("}")) {
+    return trimmed;
+  }
+  const first = trimmed.indexOf("{");
+  const last = trimmed.lastIndexOf("}");
+  if (first === -1 || last === -1 || last <= first) {
+    return null;
+  }
+  return trimmed.slice(first, last + 1);
+}
+function truncateForError(text) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.length > 200 ? `${collapsed.slice(0, 199)}\u2026` : collapsed;
+}
+async function assertWithAiVision(input, config) {
+  const raw = config.provider === "anthropic" ? await visionWithAnthropic(input, config) : await visionWithOpenAi(input, config);
+  return parseVisionVerdict(raw);
+}
+async function visionWithAnthropic(input, config) {
+  const data = await postJson(
+    "Anthropic",
+    `${apiRoot(config)}/v1/messages`,
+    anthropicHeaders(config),
+    {
+      model: config.model,
+      max_tokens: 1024,
+      temperature: 0,
+      messages: [
+        {
+          role: "user",
+          content: [
+            {
+              type: "image",
+              source: {
+                type: "base64",
+                media_type: input.mediaType,
+                data: input.imageBase64
+              }
+            },
+            { type: "text", text: buildVisionPrompt(input.assertion) }
+          ]
+        }
+      ]
+    }
+  );
+  return extractAnthropicText(data);
+}
+async function visionWithOpenAi(input, config) {
+  const data = await postJson(
+    "OpenAI",
+    `${apiRoot(config)}/v1/chat/completions`,
+    openAiHeaders(config),
+    {
+      model: config.model,
+      max_tokens: 1024,
+      temperature: 0,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: buildVisionPrompt(input.assertion) },
+            {
+              type: "image_url",
+              image_url: { url: `data:${input.mediaType};base64,${input.imageBase64}` }
+            }
+          ]
+        }
+      ]
+    }
+  );
+  return extractOpenAiText(data);
+}
+async function postJson(provider, url, headers, body) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(AI_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    const responseBody = await response.text();
+    throw new Error(`${provider} API error (${response.status}): ${responseBody}`);
+  }
+  return await response.json();
+}
+function anthropicHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    "x-api-key": config.apiKey,
+    "anthropic-version": "2023-06-01"
+  };
+}
+function openAiHeaders(config) {
+  return {
+    "Content-Type": "application/json",
+    "Authorization": `Bearer ${config.apiKey}`
+  };
+}
+function extractAnthropicText(data) {
+  const textBlock = data.content?.find((c) => c.type === "text");
+  if (!textBlock?.text) {
+    throw new Error("Anthropic API returned no text content");
+  }
+  return textBlock.text;
+}
+function extractOpenAiText(data) {
+  if (!data.choices?.[0]?.message?.content) {
+    throw new Error("OpenAI API returned no content");
+  }
+  return data.choices[0].message.content;
+}
+
 // src/runner/steps.ts
 function getStepType(step) {
   if ("navigate" in step) return "navigate";
@@ -2052,6 +4435,7 @@ function getStepType(step) {
   if ("evalScript" in step) return "evalScript";
   if ("runScript" in step) return "runScript";
   if ("assertScreenshot" in step) return "assertScreenshot";
+  if ("assertWithAI" in step) return "assertWithAI";
   if ("copyText" in step) return "copyText";
   if ("waitForDownload" in step) return "waitForDownload";
   return "step";
@@ -2111,6 +4495,9 @@ function applyRuntimeVars(step, vars) {
       }
     };
   }
+  if ("assertWithAI" in step) {
+    return { assertWithAI: sub(step.assertWithAI) };
+  }
   if ("copyText" in step) {
     return { copyText: { selector: sub(step.copyText.selector), as: step.copyText.as } };
   }
@@ -2361,7 +4748,7 @@ async function runInlineAssert(driver, policy, assertion) {
   throw new Error("assert step is missing an assertion type");
 }
 function screenshotPath(screenshotsDir, fileName) {
-  return import_node_path6.default.join(screenshotsDir, fileName);
+  return import_node_path9.default.join(screenshotsDir, fileName);
 }
 function stepPath(prefix, index) {
   return prefix ? `${prefix}.${index}` : `${index}`;
@@ -2378,12 +4765,12 @@ 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_path6.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
+  if (safeFilename.length === 0 || safeFilename !== suggestedFilename || safeFilename !== import_node_path9.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
     throw new Error(`Invalid download filename: "${suggestedFilename}"`);
   }
   return safeFilename;
 }
-async function captureScreenshot(taker, filePath) {
+async function captureScreenshot2(taker, filePath) {
   try {
     await taker.screenshot({ path: filePath, fullPage: true });
   } catch (error) {
@@ -2558,7 +4945,7 @@ var STEP_HANDLERS = {
       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 resolveFile = (f) => import_node_path9.default.isAbsolute(f) ? f : import_node_path9.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);
@@ -2595,7 +4982,7 @@ var STEP_HANDLERS = {
         redactedFillSteps: subRedacted,
         randomVars
       } = interpolateHunt(subHunt, process.env, h.context.randomVars);
-      const subTargetType = h.driver.capabilities.has("navigate") ? "web" : "macos";
+      const subTargetType = h.context.targetType ?? (h.driver.capabilities.has("navigate") ? "web" : "macos");
       assertStepsSupportedByTarget(interpolatedSubHunt.steps, subTargetType);
       assertHuntAssertionsSupportedByTarget(interpolatedSubHunt.assertions, subTargetType);
       h.policy.assertWithinMaxSteps(interpolatedSubHunt.steps.length, huntName);
@@ -2920,15 +5307,15 @@ var STEP_HANDLERS = {
         if (!responseFile) {
           throw new Error("mock.response must include either body or file");
         }
-        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);
+        const candidateFilePath = import_node_path9.default.isAbsolute(responseFile) ? responseFile : import_node_path9.default.join(h.context.configDir, responseFile);
+        const resolvedConfigDir = import_node_path9.default.resolve(h.context.configDir);
+        const resolvedFilePath = import_node_path9.default.resolve(candidateFilePath);
+        const relativePath = import_node_path9.default.relative(resolvedConfigDir, resolvedFilePath);
+        const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${import_node_path9.default.sep}`) && !import_node_path9.default.isAbsolute(relativePath);
         if (!isWithinConfigDir) {
           throw new Error("mock.response.file must resolve within config directory");
         }
-        responseBody = await import_node_fs6.default.promises.readFile(resolvedFilePath, "utf-8");
+        responseBody = await import_node_fs9.default.promises.readFile(resolvedFilePath, "utf-8");
       }
       const contentType = mock.response.contentType ?? "application/json";
       const status = mock.response.status;
@@ -2991,8 +5378,8 @@ var STEP_HANDLERS = {
     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");
+      const filePath = import_node_path9.default.isAbsolute(h.step.runScript.file) ? h.step.runScript.file : import_node_path9.default.join(h.context.configDir, h.step.runScript.file);
+      const fileContents = import_node_fs9.default.readFileSync(filePath, "utf-8");
       await h.driver.evaluate(fileContents);
       return {
         kind: "result",
@@ -3013,19 +5400,19 @@ var STEP_HANDLERS = {
       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 });
+      const baselinePath = import_node_path9.default.join(baselineDir, `${name}.png`);
+      const currentScreenshotPath = import_node_path9.default.join(h.context.runDir, "screenshots", `${name}-current.png`);
+      import_node_fs9.default.mkdirSync(import_node_path9.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);
+      h.screenshots.push(import_node_path9.default.join("screenshots", `${name}-current.png`));
+      if (!import_node_fs9.default.existsSync(baselinePath)) {
+        import_node_fs9.default.copyFileSync(currentScreenshotPath, baselinePath);
         return {
           kind: "result",
           result: { type: "assertScreenshot", status: "pass", durationMs: Date.now() - h.stepStart, value: "baseline created" }
         };
       }
-      const diffPath = import_node_path6.default.join(h.context.runDir, "screenshots", `${name}-diff.png`);
+      const diffPath = import_node_path9.default.join(h.context.runDir, "screenshots", `${name}-diff.png`);
       const comparison = await compareScreenshots2(baselinePath, currentScreenshotPath, diffPath, threshold);
       if (comparison.match) {
         return {
@@ -3038,12 +5425,54 @@ var STEP_HANDLERS = {
           }
         };
       }
-      h.screenshots.push(import_node_path6.default.join("screenshots", `${name}-diff.png`));
+      h.screenshots.push(import_node_path9.default.join("screenshots", `${name}-diff.png`));
       throw new Error(
         `Visual regression: ${(comparison.diffPercentage * 100).toFixed(2)}% diff exceeds threshold ${(threshold * 100).toFixed(0)}%`
       );
     }
   },
+  assertWithAI: {
+    capabilities: ["screenshot"],
+    run: async (h) => {
+      if (!("assertWithAI" in h.step)) unknownStep();
+      const assertion = h.step.assertWithAI;
+      const resolve = h.context.resolveAiConfig ?? tryResolveAiConfig;
+      const aiConfig = resolve();
+      if (!aiConfig) {
+        return {
+          kind: "result",
+          result: {
+            type: "assertWithAI",
+            status: "warn",
+            durationMs: Date.now() - h.stepStart,
+            value: `skipped: no AI provider configured (set PROWL_AI_KEY to enable) \u2014 "${assertion}"`
+          }
+        };
+      }
+      const fileName = `assertWithAI_step_${h.index + 1}.png`;
+      const relative = await h.addScreenshot(fileName);
+      const screenshotFullPath = import_node_path9.default.join(h.context.runDir, relative);
+      const imageBase64 = import_node_fs9.default.readFileSync(screenshotFullPath).toString("base64");
+      const assertVision = h.context.assertVision ?? assertWithAiVision;
+      const verdict = await assertVision(
+        { imageBase64, mediaType: "image/png", assertion },
+        aiConfig
+      );
+      if (verdict.pass) {
+        return {
+          kind: "result",
+          result: {
+            type: "assertWithAI",
+            status: "pass",
+            durationMs: Date.now() - h.stepStart,
+            value: verdict.reason,
+            screenshot: relative
+          }
+        };
+      }
+      throw new Error(`AI assertion failed: ${verdict.reason}`);
+    }
+  },
   copyText: {
     capabilities: ["query"],
     run: async (h) => {
@@ -3080,7 +5509,7 @@ var STEP_HANDLERS = {
           `Download filename mismatch: expected "${opts.filename}", got "${suggestedFilename}"`
         );
       }
-      const savePath = import_node_path6.default.join(h.context.runDir, suggestedFilename);
+      const savePath = import_node_path9.default.join(h.context.runDir, suggestedFilename);
       await download.saveAs(savePath);
       return {
         kind: "result",
@@ -3109,8 +5538,8 @@ async function executeSteps(context) {
     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 screenshotsDir = import_node_path9.default.join(context.runDir, "screenshots");
+  import_node_fs9.default.mkdirSync(screenshotsDir, { recursive: true });
   const currentHuntName = context.huntStack?.[context.huntStack.length - 1];
   policy.assertWithinMaxSteps(context.steps.length, currentHuntName);
   const results = [];
@@ -3119,8 +5548,8 @@ async function executeSteps(context) {
   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);
+    await captureScreenshot2(driver, fullPath);
+    const relative = import_node_path9.default.join("screenshots", fileName);
     screenshots.push(relative);
     return relative;
   };
@@ -3208,12 +5637,12 @@ async function executeSteps(context) {
   return { results, screenshots, failed: false };
 }
 async function captureFinalScreenshot(page, runDir) {
-  const screenshotsDir = import_node_path6.default.join(runDir, "screenshots");
-  import_node_fs6.default.mkdirSync(screenshotsDir, { recursive: true });
+  const screenshotsDir = import_node_path9.default.join(runDir, "screenshots");
+  import_node_fs9.default.mkdirSync(screenshotsDir, { recursive: true });
   const fileName = "final.png";
   const filePath = screenshotPath(screenshotsDir, fileName);
-  await captureScreenshot(page, filePath);
-  return import_node_path6.default.join("screenshots", fileName);
+  await captureScreenshot2(page, filePath);
+  return import_node_path9.default.join("screenshots", fileName);
 }
 
 // src/runner/assertions.ts
@@ -3373,18 +5802,18 @@ function captureTraceCorrelation(response, headerName, sink, redactionValues = [
 }
 
 // src/reporter/result.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 function writeResult(runDir, result) {
   const fileName = "result.json";
-  const fullPath = import_node_path7.default.join(runDir, fileName);
-  import_node_fs7.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
+  const fullPath = import_node_path10.default.join(runDir, fileName);
+  import_node_fs10.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
   return fileName;
 }
 
 // src/reporter/summary.ts
-var import_node_fs8 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 function escapeMd(text) {
   return text.replace(/([|`*_{}[\]()#+\-!\\])/g, "\\$1");
 }
@@ -3462,15 +5891,15 @@ function writeSummary(runDir, result) {
     }
   }
   const fileName = "summary.md";
-  const fullPath = import_node_path8.default.join(runDir, fileName);
-  import_node_fs8.default.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = import_node_path11.default.join(runDir, fileName);
+  import_node_fs11.default.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
 
 // src/reporter/junit.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
@@ -3514,8 +5943,8 @@ function writeJunit(runDir, result) {
   lines.push("  </testsuite>");
   lines.push("</testsuites>");
   const fileName = "junit.xml";
-  const fullPath = import_node_path9.default.join(runDir, fileName);
-  import_node_fs9.default.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = import_node_path12.default.join(runDir, fileName);
+  import_node_fs12.default.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -3549,15 +5978,15 @@ function timestamp(prefix) {
 }
 
 // src/runner/history.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path13 = __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_path10.default.join(configDir, HISTORY_FILE);
+  return import_node_path13.default.join(configDir, HISTORY_FILE);
 }
 function isHistoryEntry(value) {
   if (!value || typeof value !== "object") {
@@ -3568,11 +5997,11 @@ function isHistoryEntry(value) {
 }
 function readHistory(configDir) {
   const filePath = historyPath(configDir);
-  if (!import_node_fs10.default.existsSync(filePath)) {
+  if (!import_node_fs13.default.existsSync(filePath)) {
     return { entries: [] };
   }
   try {
-    const raw = import_node_fs10.default.readFileSync(filePath, "utf-8");
+    const raw = import_node_fs13.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);
@@ -3611,12 +6040,12 @@ function sleepSync(ms) {
 function withHistoryLock(configDir, fn) {
   const filePath = historyPath(configDir);
   const lockPath = `${filePath}${LOCK_FILE_SUFFIX}`;
-  import_node_fs10.default.mkdirSync(import_node_path10.default.dirname(filePath), { recursive: true });
+  import_node_fs13.default.mkdirSync(import_node_path13.default.dirname(filePath), { recursive: true });
   const startedAt = Date.now();
   while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
     let fd;
     try {
-      fd = import_node_fs10.default.openSync(lockPath, "wx");
+      fd = import_node_fs13.default.openSync(lockPath, "wx");
     } catch (error) {
       if (error.code === "EEXIST") {
         sleepSync(LOCK_RETRY_MS);
@@ -3628,10 +6057,10 @@ function withHistoryLock(configDir, fn) {
       return fn();
     } finally {
       try {
-        import_node_fs10.default.closeSync(fd);
+        import_node_fs13.default.closeSync(fd);
       } catch {
       }
-      import_node_fs10.default.rmSync(lockPath, { force: true });
+      import_node_fs13.default.rmSync(lockPath, { force: true });
     }
   }
   throw new Error(
@@ -3644,9 +6073,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_fs10.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
+    import_node_fs13.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
 `);
-    import_node_fs10.default.renameSync(tempPath, filePath);
+    import_node_fs13.default.renameSync(tempPath, filePath);
   });
 }
 
@@ -3659,11 +6088,11 @@ function parseViewportFlag(value) {
   return value;
 }
 function resolvePath(configDir, inputPath) {
-  if (import_node_path11.default.isAbsolute(inputPath)) {
+  if (import_node_path14.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_path14.default.dirname(configDir);
+  return import_node_path14.default.join(projectRoot, inputPath);
 }
 function buildRunResult(options) {
   return {
@@ -3682,12 +6111,12 @@ function buildRunResult(options) {
 }
 function writeConsoleLog(runDir, entries) {
   const fileName = "console.log";
-  const filePath = import_node_path11.default.join(runDir, fileName);
+  const filePath = import_node_path14.default.join(runDir, fileName);
   const lines = entries.map((entry) => {
     const location = entry.location ? ` (${entry.location})` : "";
     return `[${entry.type}] ${entry.text}${location}`;
   });
-  import_node_fs11.default.writeFileSync(filePath, `${lines.join("\n")}
+  import_node_fs14.default.writeFileSync(filePath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -3695,8 +6124,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_path11.default.join(configDir, "runs", timestamp());
-  import_node_fs11.default.mkdirSync(runDir, { recursive: true });
+  const runDir = import_node_path14.default.join(configDir, "runs", timestamp());
+  import_node_fs14.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;
@@ -3813,7 +6242,7 @@ async function executeHuntAttempt(options, config, configDir, interpolatedHunt,
   }
   return { result, runDir, steps: interpolatedHunt.steps };
 }
-function delay(ms) {
+function delay3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function runHunt(options) {
@@ -3821,6 +6250,12 @@ async function runHunt(options) {
   if (config.target.type === "macos") {
     return runMacHunt(options, config, configDir, config.target);
   }
+  if (config.target.type === "android") {
+    return runAndroidHunt(options, config, configDir, config.target);
+  }
+  if (config.target.type === "ios") {
+    return runIosHunt(options, config, configDir, config.target);
+  }
   const hunt = loadHunt(options.huntName, configDir);
   const {
     hunt: interpolatedHunt,
@@ -3842,7 +6277,7 @@ async function runHunt(options) {
   let lastResult;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0 && retryDelay > 0) {
-      await delay(retryDelay);
+      await delay3(retryDelay);
     }
     lastResult = await executeHuntAttempt(
       options,
@@ -3871,19 +6306,17 @@ async function runHunt(options) {
   }
   return lastResult;
 }
-async function executeMacHuntAttempt(options, config, configDir, target, interpolatedHunt, redactedFillSteps, randomVars, allowedApps) {
+async function executeNativeHuntAttempt(options, config, configDir, interpolatedHunt, redactedFillSteps, randomVars, allowedApps, native) {
   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
-  });
+  const runDir = import_node_path14.default.join(configDir, "runs", timestamp());
+  import_node_fs14.default.mkdirSync(runDir, { recursive: true });
+  const session = await native.launchSession();
   let result;
   try {
-    const targetLabel = `macos:${session.bundleId}`;
-    const effectiveAllowedApps = [.../* @__PURE__ */ new Set([...allowedApps, target.app, session.bundleId])];
+    const driver = native.sessionDriver(session);
+    const appIdentity = native.sessionAppIdentity(session);
+    const targetLabel = `${native.targetType}:${appIdentity}`;
+    const effectiveAllowedApps = [.../* @__PURE__ */ new Set([...allowedApps, native.targetApp, appIdentity])];
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startTime = Date.now();
     let stepResults = [];
@@ -3891,7 +6324,8 @@ async function executeMacHuntAttempt(options, config, configDir, target, interpo
     let stepFailed = false;
     try {
       const stepExecution = await executeSteps({
-        driver: session.driver,
+        driver,
+        targetType: native.targetType,
         steps: interpolatedHunt.steps,
         targetUrl: targetLabel,
         runDir,
@@ -3918,7 +6352,7 @@ async function executeMacHuntAttempt(options, config, configDir, target, interpo
     }
     let finalScreenshot;
     try {
-      finalScreenshot = await captureFinalScreenshot(session.driver, runDir);
+      finalScreenshot = await captureFinalScreenshot(driver, runDir);
     } catch {
       finalScreenshot = void 0;
     }
@@ -3939,16 +6373,116 @@ async function executeMacHuntAttempt(options, config, configDir, target, interpo
     });
     result = writeReports(runDir, runResult, { junit: options.junit ?? config.artifacts.junit });
   } finally {
-    await closeMacSession(session);
+    await native.closeSession(session);
   }
   return { result, runDir, steps: interpolatedHunt.steps };
 }
+async function executeMacHuntAttempt(options, config, configDir, target, interpolatedHunt, redactedFillSteps, randomVars, allowedApps) {
+  return executeNativeHuntAttempt(
+    options,
+    config,
+    configDir,
+    interpolatedHunt,
+    redactedFillSteps,
+    randomVars,
+    allowedApps,
+    {
+      targetType: "macos",
+      targetApp: target.app,
+      launchSession: () => launchMacSession({
+        app: target.app,
+        timeoutMs: config.browser.timeout,
+        clientFactory: options.macClientFactory
+      }),
+      closeSession: closeMacSession,
+      sessionDriver: (session) => session.driver,
+      sessionAppIdentity: (session) => session.bundleId
+    }
+  );
+}
 async function runMacHunt(options, config, configDir, target) {
+  return runNativeHunt(options, config, configDir, target, {
+    targetType: "macos",
+    assertAppAllowed: (allowedApps, nativeTarget) => assertTargetAppAllowed(allowedApps, nativeTarget.app),
+    attempt: executeMacHuntAttempt
+  });
+}
+async function executeAndroidHuntAttempt(options, config, configDir, target, interpolatedHunt, redactedFillSteps, randomVars, allowedApps) {
+  const launch = options.androidSessionFactory ?? launchAndroidSession;
+  return executeNativeHuntAttempt(
+    options,
+    config,
+    configDir,
+    interpolatedHunt,
+    redactedFillSteps,
+    randomVars,
+    allowedApps,
+    {
+      targetType: "android",
+      targetApp: target.app,
+      launchSession: () => launch({
+        app: target.app,
+        deviceSerial: target.deviceSerial,
+        coldStart: target.coldStart,
+        timeoutMs: config.browser.timeout,
+        allowedApps
+      }),
+      closeSession: closeAndroidSession,
+      sessionDriver: (session) => session.driver,
+      sessionAppIdentity: (session) => session.package
+    }
+  );
+}
+async function runAndroidHunt(options, config, configDir, target) {
+  return runNativeHunt(options, config, configDir, target, {
+    targetType: "android",
+    assertAppAllowed: (allowedApps, nativeTarget) => {
+      if (!nativeTarget.app.toLowerCase().endsWith(".apk")) {
+        assertAndroidAppAllowed(allowedApps, nativeTarget.app);
+      }
+    },
+    attempt: executeAndroidHuntAttempt
+  });
+}
+async function executeIosHuntAttempt(options, config, configDir, target, interpolatedHunt, redactedFillSteps, randomVars, allowedApps) {
+  const launch = options.iosSessionFactory ?? launchIosSession;
+  return executeNativeHuntAttempt(
+    options,
+    config,
+    configDir,
+    interpolatedHunt,
+    redactedFillSteps,
+    randomVars,
+    allowedApps,
+    {
+      targetType: "ios",
+      targetApp: target.app,
+      launchSession: () => launch({
+        app: target.app,
+        udid: target.udid,
+        coldStart: target.coldStart,
+        timeoutMs: config.browser.timeout,
+        allowedApps
+      }),
+      closeSession: closeIosSession,
+      sessionDriver: (session) => session.driver,
+      sessionAppIdentity: (session) => session.bundleId
+    }
+  );
+}
+async function runIosHunt(options, config, configDir, target) {
+  return runNativeHunt(options, config, configDir, target, {
+    targetType: "ios",
+    assertAppAllowed: (allowedApps, nativeTarget) => assertIosAppAllowed(allowedApps, nativeTarget.app),
+    attempt: executeIosHuntAttempt
+  });
+}
+async function runNativeHunt(options, config, configDir, target, native) {
   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);
+  assertStepsSupportedByTarget(interpolatedHunt.steps, native.targetType);
+  assertHuntAssertionsSupportedByTarget(interpolatedHunt.assertions, native.targetType);
+  native.assertAppAllowed(config.guardrails.allowedApps, target);
   const maxSteps = config.guardrails.maxSteps;
   if (interpolatedHunt.steps.length > maxSteps) {
     throw new Error(`Hunt has ${interpolatedHunt.steps.length} steps. Max allowed is ${maxSteps}.`);
@@ -3958,9 +6492,9 @@ async function runMacHunt(options, config, configDir, target) {
   let lastResult;
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     if (attempt > 0 && retryDelay > 0) {
-      await delay(retryDelay);
+      await delay3(retryDelay);
     }
-    lastResult = await executeMacHuntAttempt(
+    lastResult = await native.attempt(
       options,
       config,
       configDir,
@@ -3988,7 +6522,7 @@ async function runMacHunt(options, config, configDir, target) {
 }
 function recordHistory(configDir, outcome, maxRuns) {
   try {
-    const relativeRunDir = import_node_path11.default.relative(configDir, outcome.runDir);
+    const relativeRunDir = import_node_path14.default.relative(configDir, outcome.runDir);
     appendEntry(
       configDir,
       {
@@ -4081,6 +6615,7 @@ function describeStep(step) {
     const th = step.assertScreenshot.threshold !== void 0 ? ` (threshold: ${step.assertScreenshot.threshold})` : "";
     return `assertScreenshot "${step.assertScreenshot.name}"${th}`;
   }
+  if ("assertWithAI" in step) return `assertWithAI "${truncate(step.assertWithAI, 60)}"`;
   return "unknown step";
 }
 function truncate(text, max) {
@@ -4096,6 +6631,9 @@ function printStepResult(result, step, _index) {
   const duration = import_chalk.default.gray(`(${result.durationMs}ms)`);
   if (result.status === "pass") {
     console.log(`    ${import_chalk.default.green("\u2713")} ${label} ${duration}`);
+  } else if (result.status === "warn") {
+    const note = result.value ? import_chalk.default.gray(` \u2014 ${result.value}`) : "";
+    console.log(`    ${import_chalk.default.yellow("\u25CB")} ${label} ${duration}${note}`);
   } else {
     const error = result.error ? import_chalk.default.gray(` \u2014 ${result.error}`) : "";
     console.log(`    ${import_chalk.default.red("\u2717")} ${label} ${duration}${error}`);
@@ -4213,37 +6751,37 @@ function buildRunCommand() {
 }
 
 // src/cli/commands/init.ts
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
+var import_node_path15 = __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_meta2 = {};
+var import_meta4 = {};
 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;
+  const currentFile = (0, import_node_url2.fileURLToPath)(import_meta4.url);
+  let dir = import_node_path15.default.dirname(currentFile);
+  const root = import_node_path15.default.parse(dir).root;
   while (dir !== root) {
-    if (import_node_fs12.default.existsSync(import_node_path12.default.join(dir, "package.json"))) {
+    if (import_node_fs15.default.existsSync(import_node_path15.default.join(dir, "package.json"))) {
       return dir;
     }
-    dir = import_node_path12.default.dirname(dir);
+    dir = import_node_path15.default.dirname(dir);
   }
-  if (import_node_fs12.default.existsSync(import_node_path12.default.join(root, "package.json"))) {
+  if (import_node_fs15.default.existsSync(import_node_path15.default.join(root, "package.json"))) {
     return root;
   }
   throw new Error("Cannot find package root. Reinstall prowl-tools.");
 }
 function copyFile(source, destination) {
-  import_node_fs12.default.mkdirSync(import_node_path12.default.dirname(destination), { recursive: true });
-  import_node_fs12.default.copyFileSync(source, destination);
+  import_node_fs15.default.mkdirSync(import_node_path15.default.dirname(destination), { recursive: true });
+  import_node_fs15.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_path12.default.join(root, CONFIG_DIR);
-    if (import_node_fs12.default.existsSync(prowlDir) && !options.force) {
+    const prowlDir = import_node_path15.default.join(root, CONFIG_DIR);
+    if (import_node_fs15.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.`
@@ -4253,20 +6791,20 @@ function buildInitCommand() {
       return;
     }
     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)) {
+    const examplesDir = import_node_path15.default.join(packageRoot, "examples");
+    const exampleConfig = import_node_path15.default.join(examplesDir, "config.yml");
+    const exampleHuntsDir = import_node_path15.default.join(examplesDir, "hunts");
+    if (!import_node_fs15.default.existsSync(exampleConfig) || !import_node_fs15.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_path12.default.join(prowlDir, "config.yml"));
-    const huntFiles = import_node_fs12.default.readdirSync(exampleHuntsDir).filter((f) => f.endsWith(".yml"));
+    copyFile(exampleConfig, import_node_path15.default.join(prowlDir, "config.yml"));
+    const huntFiles = import_node_fs15.default.readdirSync(exampleHuntsDir).filter((f) => f.endsWith(".yml"));
     for (const huntFile of huntFiles) {
       copyFile(
-        import_node_path12.default.join(exampleHuntsDir, huntFile),
-        import_node_path12.default.join(prowlDir, "hunts", huntFile)
+        import_node_path15.default.join(exampleHuntsDir, huntFile),
+        import_node_path15.default.join(prowlDir, "hunts", huntFile)
       );
     }
     const gitignore = [
@@ -4280,7 +6818,7 @@ function buildInitCommand() {
       ".env",
       ""
     ].join("\n");
-    import_node_fs12.default.writeFileSync(import_node_path12.default.join(prowlDir, ".gitignore"), gitignore);
+    import_node_fs15.default.writeFileSync(import_node_path15.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."));
@@ -4290,17 +6828,17 @@ function buildInitCommand() {
 }
 
 // src/cli/commands/login.ts
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 var import_node_readline = __toESM(require("readline"), 1);
 var import_chalk5 = __toESM(require("chalk"), 1);
 var import_commander3 = require("commander");
 init_loader();
 function resolvePath2(configDir, inputPath) {
-  if (import_node_path13.default.isAbsolute(inputPath)) {
+  if (import_node_path16.default.isAbsolute(inputPath)) {
     return inputPath;
   }
-  const projectRoot = import_node_path13.default.dirname(configDir);
-  return import_node_path13.default.join(projectRoot, inputPath);
+  const projectRoot = import_node_path16.default.dirname(configDir);
+  return import_node_path16.default.join(projectRoot, inputPath);
 }
 function waitForEnter(prompt) {
   return new Promise((resolve) => {
@@ -4316,7 +6854,7 @@ function buildLoginCommand() {
     let session = null;
     try {
       const { config, configDir } = loadConfig(options.config);
-      if (config.target.type === "macos") {
+      if (config.target.type !== "web") {
         throw new Error("`prowl login` captures browser auth state and only applies to web targets.");
       }
       const targetUrl = options.url ?? config.target.url;
@@ -4387,18 +6925,18 @@ function buildListCommand() {
 }
 
 // src/cli/commands/watch.ts
-var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_fs16 = __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_path14 = __toESM(require("path"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 function getWatchTargets(configDir, huntName) {
   return [
-    import_node_path14.default.join(configDir, "hunts", `${huntName}.yml`),
-    import_node_path14.default.join(configDir, "config.yml"),
-    import_node_path14.default.join(configDir, ".env")
+    import_node_path17.default.join(configDir, "hunts", `${huntName}.yml`),
+    import_node_path17.default.join(configDir, "config.yml"),
+    import_node_path17.default.join(configDir, ".env")
   ];
 }
 function createDebouncer(delayMs, fn) {
@@ -4467,14 +7005,14 @@ function buildWatchCommand() {
     });
     const unwatch = [];
     for (const target of watchTargets) {
-      import_node_fs13.default.watchFile(target, { interval: 150 }, (curr, prev) => {
+      import_node_fs16.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_fs13.default.unwatchFile(target));
+      unwatch.push(() => import_node_fs16.default.unwatchFile(target));
     }
     const stop = () => {
       if (stopped) {
@@ -4500,12 +7038,12 @@ var import_commander6 = require("commander");
 var import_chalk9 = __toESM(require("chalk"), 1);
 
 // src/runner/suite.ts
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path20 = __toESM(require("path"), 1);
 init_loader();
 
 // src/reporter/ci-summary.ts
-var import_node_fs14 = __toESM(require("fs"), 1);
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs17 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 var import_chalk8 = __toESM(require("chalk"), 1);
 function countCiResults(results) {
   return {
@@ -4569,9 +7107,9 @@ function writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky = []
     ...flaky.length > 0 ? { flaky } : {},
     ...clusters.length > 0 ? { clusters } : {}
   };
-  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");
+  import_node_fs17.default.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = import_node_path18.default.join(ciRunDir, "ci-result.json");
+  import_node_fs17.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
   return filePath;
 }
 
@@ -4705,8 +7243,8 @@ function clusterFailures(failures) {
 }
 
 // src/backlog/index.ts
-var import_node_fs15 = __toESM(require("fs"), 1);
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs18 = __toESM(require("fs"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 
 // src/backlog/parse.ts
 var MARKER_FP = /<!--\s*prowl:fp=([0-9a-f]+)/;
@@ -4796,7 +7334,7 @@ ${after}`;
 // src/backlog/index.ts
 function readFileOrEmpty(filePath) {
   try {
-    return import_node_fs15.default.readFileSync(filePath, "utf-8");
+    return import_node_fs18.default.readFileSync(filePath, "utf-8");
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") return "";
@@ -4812,7 +7350,7 @@ function buildFailure(hunt) {
   if (!hunt.runDir) return failure;
   let run;
   try {
-    const resultJson = readFileOrEmpty(import_node_path16.default.join(hunt.runDir, "result.json"));
+    const resultJson = readFileOrEmpty(import_node_path19.default.join(hunt.runDir, "result.json"));
     if (!resultJson) return failure;
     run = JSON.parse(resultJson);
   } catch (error) {
@@ -4841,8 +7379,8 @@ function extractFailures(suiteResult) {
 }
 function updateBacklogFromSuite(suiteResult, options = {}) {
   const projectRoot = options.projectRoot ?? process.cwd();
-  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 backlogPath = options.backlogPath ?? import_node_path19.default.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? import_node_path19.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);
@@ -4874,8 +7412,8 @@ function updateBacklogFromSuite(suiteResult, options = {}) {
     }
   }
   if (ticketsToAdd.length > 0) {
-    import_node_fs15.default.mkdirSync(import_node_path16.default.dirname(backlogPath), { recursive: true });
-    import_node_fs15.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+    import_node_fs18.default.mkdirSync(import_node_path19.default.dirname(backlogPath), { recursive: true });
+    import_node_fs18.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
   }
   return summary;
 }
@@ -5036,7 +7574,7 @@ async function runSuite(options = {}) {
   const clusters = clusterFailures(
     extractFailures({ result: { hunts: results }, resultPath: null })
   ).filter((cluster) => cluster.count > 1);
-  const ciRunDir = import_node_path17.default.join(configDir, "runs", timestamp("ci"));
+  const ciRunDir = import_node_path20.default.join(configDir, "runs", timestamp("ci"));
   const resultPath = writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky, clusters);
   const { passed, failed, skipped } = countCiResults(results);
   return {
@@ -5154,8 +7692,8 @@ function buildCiCommand() {
 }
 
 // src/cli/commands/update-baselines.ts
-var import_node_fs16 = __toESM(require("fs"), 1);
-var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs19 = __toESM(require("fs"), 1);
+var import_node_path21 = __toESM(require("path"), 1);
 var import_commander7 = require("commander");
 var import_chalk10 = __toESM(require("chalk"), 1);
 init_loader();
@@ -5163,33 +7701,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_path18.default.join(configDir, "baselines");
-      import_node_fs16.default.mkdirSync(baselinesDir, { recursive: true });
+      const baselinesDir = import_node_path21.default.join(configDir, "baselines");
+      import_node_fs19.default.mkdirSync(baselinesDir, { recursive: true });
       let runDir;
       if (options.run) {
-        runDir = import_node_path18.default.isAbsolute(options.run) ? options.run : import_node_path18.default.resolve(options.run);
+        runDir = import_node_path21.default.isAbsolute(options.run) ? options.run : import_node_path21.default.resolve(options.run);
       } else {
-        const runsDir = import_node_path18.default.join(configDir, "runs");
-        if (!import_node_fs16.default.existsSync(runsDir)) {
+        const runsDir = import_node_path21.default.join(configDir, "runs");
+        if (!import_node_fs19.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_fs16.default.readdirSync(runsDir).filter((e) => import_node_fs16.default.statSync(import_node_path18.default.join(runsDir, e)).isDirectory()).sort().reverse();
+        const entries = import_node_fs19.default.readdirSync(runsDir).filter((e) => import_node_fs19.default.statSync(import_node_path21.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_path18.default.join(runsDir, entries[0]);
+        runDir = import_node_path21.default.join(runsDir, entries[0]);
       }
-      const screenshotsDir = import_node_path18.default.join(runDir, "screenshots");
-      if (!import_node_fs16.default.existsSync(screenshotsDir)) {
+      const screenshotsDir = import_node_path21.default.join(runDir, "screenshots");
+      if (!import_node_fs19.default.existsSync(screenshotsDir)) {
         console.error(import_chalk10.default.red(`  No screenshots found in ${runDir}`));
         process.exitCode = 1;
         return;
       }
-      const screenshots = import_node_fs16.default.readdirSync(screenshotsDir).filter((f) => f.endsWith("-current.png"));
+      const screenshots = import_node_fs19.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;
@@ -5203,10 +7741,10 @@ function buildUpdateBaselinesCommand() {
       let updated = 0;
       for (const file of filtered) {
         const baselineName = file.replace("-current.png", ".png");
-        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);
+        const sourcePath = import_node_path21.default.join(screenshotsDir, file);
+        const destPath = import_node_path21.default.join(baselinesDir, baselineName);
+        const exists = import_node_fs19.default.existsSync(destPath);
+        import_node_fs19.default.copyFileSync(sourcePath, destPath);
         updated++;
         const status = exists ? import_chalk10.default.yellow("updated") : import_chalk10.default.green("created");
         console.log(`  ${status} ${baselineName}`);
@@ -5334,30 +7872,372 @@ async function analyzePage(page) {
       ...el.formIndex >= 0 ? { formGroup: el.formIndex } : {}
     };
   });
-  const links = raw.elements.filter((el) => el.tag === "a" && el.href).map((el) => {
-    let selector;
-    if (el.testId) {
-      selector = `[data-testid="${el.testId}"]`;
-    } else if (el.href) {
-      selector = `a[href="${el.href}"]`;
-    } else {
-      selector = `a`;
+  const links = raw.elements.filter((el) => el.tag === "a" && el.href).map((el) => {
+    let selector;
+    if (el.testId) {
+      selector = `[data-testid="${el.testId}"]`;
+    } else if (el.href) {
+      selector = `a[href="${el.href}"]`;
+    } else {
+      selector = `a`;
+    }
+    return {
+      text: el.text || "",
+      href: el.href,
+      selector
+    };
+  });
+  const forms = raw.forms;
+  return {
+    url: raw.url,
+    title: raw.title,
+    elements,
+    forms,
+    links
+  };
+}
+
+// src/analyzer/mac.ts
+var INTERACTIVE_ROLES = /* @__PURE__ */ new Set([
+  "AXButton",
+  "AXTextField",
+  "AXSecureTextField",
+  "AXTextArea",
+  "AXCheckBox",
+  "AXRadioButton",
+  "AXPopUpButton",
+  "AXMenuButton",
+  "AXLink",
+  "AXMenuItem",
+  "AXComboBox",
+  "AXSlider",
+  "AXDisclosureTriangle"
+]);
+var DEFAULT_ANALYZE_TREE_DEPTH = 20;
+function str(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function toNode(raw) {
+  const node = raw ?? {};
+  const children = Array.isArray(node.children) ? node.children.map(toNode) : void 0;
+  return {
+    role: str(node.role),
+    title: str(node.title),
+    description: str(node.description),
+    value: str(node.value),
+    identifier: str(node.identifier),
+    enabled: typeof node.enabled === "boolean" ? node.enabled : void 0,
+    ...children ? { children } : {}
+  };
+}
+function quote(value) {
+  return `"${value}"`;
+}
+function rankMacSelectors(node) {
+  const selectors = [];
+  const identifier = node.identifier;
+  const exactLabel = node.title ?? node.description;
+  const name = node.title ?? node.description ?? node.value;
+  if (identifier) {
+    selectors.push(`id=${identifier}`);
+  }
+  if (exactLabel) {
+    selectors.push(`label=${quote(exactLabel)}`);
+  }
+  if (node.role && name) {
+    selectors.push(`role=${node.role}[name=${quote(name)}]`);
+  }
+  if (name) {
+    selectors.push(`text=${quote(name)}`);
+  }
+  if (selectors.length === 0 && node.role) {
+    selectors.push(`role=${node.role}`);
+  }
+  return selectors;
+}
+function toElement(node, source) {
+  return {
+    role: node.role ?? "?",
+    ...node.title ? { title: node.title } : {},
+    ...node.description ? { description: node.description } : {},
+    ...node.value ? { value: node.value } : {},
+    ...node.identifier ? { identifier: node.identifier } : {},
+    ...node.enabled !== void 0 ? { enabled: node.enabled } : {},
+    source,
+    selectors: rankMacSelectors(node)
+  };
+}
+function collectInteractive(root) {
+  const out = [];
+  const visit = (node) => {
+    if (node.role && INTERACTIVE_ROLES.has(node.role)) {
+      out.push(toElement(node, "window"));
+    }
+    for (const child of node.children ?? []) {
+      visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+function toWindow(node) {
+  const [best] = rankMacSelectors(node);
+  return {
+    ...node.title ? { title: node.title } : {},
+    ...node.identifier ? { identifier: node.identifier } : {},
+    selector: best ?? "role=AXWindow"
+  };
+}
+async function analyzeMacApp(client, options) {
+  const depth = options.treeDepth ?? DEFAULT_ANALYZE_TREE_DEPTH;
+  const treeResult = await client.request("tree", { depth });
+  const elements = collectInteractive(toNode(treeResult.tree));
+  const windowsResult = await client.request("windows");
+  const rawWindows = Array.isArray(windowsResult.windows) ? windowsResult.windows : [];
+  const windows = rawWindows.map((raw) => toWindow(toNode(raw)));
+  const menuItems = await readStatusMenu(client, options.menuTimeoutSeconds);
+  return { app: options.app, elements, windows, menuItems };
+}
+async function readStatusMenu(client, menuTimeoutSeconds) {
+  let statusItems;
+  try {
+    const status = await client.request("statusItems");
+    statusItems = Array.isArray(status.items) ? status.items : [];
+  } catch {
+    return [];
+  }
+  if (statusItems.length === 0) {
+    return [];
+  }
+  const params = menuTimeoutSeconds !== void 0 ? { timeout: menuTimeoutSeconds } : {};
+  try {
+    const menu = await client.request("openMenu", params);
+    const rawItems = Array.isArray(menu.items) ? menu.items : [];
+    return rawItems.map((raw) => toNode(raw)).filter((node) => node.role !== "AXMenuItem" || node.title || node.identifier || node.description).map((node) => toElement(node, "menu"));
+  } catch {
+    return [];
+  } finally {
+    await client.request("closeMenu").catch(() => void 0);
+  }
+}
+
+// src/analyzer/android.ts
+var ANDROID_INTERACTIVE_CLASSES = /* @__PURE__ */ new Set([
+  "android.widget.Button",
+  "android.widget.ImageButton",
+  "android.widget.EditText",
+  "android.widget.CheckBox",
+  "android.widget.RadioButton",
+  "android.widget.Switch",
+  "android.widget.ToggleButton",
+  "android.widget.Spinner",
+  "android.widget.SeekBar",
+  "android.widget.RatingBar",
+  "android.widget.CompoundButton",
+  "android.widget.AutoCompleteTextView",
+  "android.widget.MultiAutoCompleteTextView",
+  "android.widget.CheckedTextView",
+  "androidx.appcompat.widget.SwitchCompat",
+  "androidx.appcompat.widget.AppCompatButton",
+  "androidx.appcompat.widget.AppCompatEditText"
+]);
+function str2(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function bool(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value === "true";
+}
+function toAndroidNode(element) {
+  const a = element.attrs;
+  return {
+    className: str2(a["class"]),
+    resourceId: str2(a["resource-id"]),
+    contentDesc: str2(a["content-desc"]),
+    text: str2(a.text),
+    package: str2(a.package),
+    clickable: bool(a.clickable),
+    longClickable: bool(a["long-clickable"]),
+    checkable: bool(a.checkable),
+    checked: bool(a.checked),
+    scrollable: bool(a.scrollable),
+    focusable: bool(a.focusable),
+    focused: bool(a.focused),
+    enabled: bool(a.enabled),
+    children: element.children.map(toAndroidNode)
+  };
+}
+function parseAndroidHierarchy(xml) {
+  const root = parseXml(xml);
+  return root ? toAndroidNode(root) : null;
+}
+function isAndroidInteractive(node) {
+  if (node.clickable || node.longClickable || node.checkable || node.scrollable) {
+    return true;
+  }
+  return node.className !== void 0 && ANDROID_INTERACTIVE_CLASSES.has(node.className);
+}
+function rankAndroidSelectors(node) {
+  return rankNativeSelectors({
+    id: node.resourceId,
+    label: node.contentDesc,
+    role: node.className,
+    name: node.text
+  });
+}
+function toElement2(node) {
+  return {
+    className: node.className ?? "?",
+    ...node.resourceId ? { resourceId: node.resourceId } : {},
+    ...node.contentDesc ? { contentDesc: node.contentDesc } : {},
+    ...node.text ? { text: node.text } : {},
+    ...node.clickable !== void 0 ? { clickable: node.clickable } : {},
+    ...node.checkable !== void 0 ? { checkable: node.checkable } : {},
+    ...node.scrollable !== void 0 ? { scrollable: node.scrollable } : {},
+    ...node.enabled !== void 0 ? { enabled: node.enabled } : {},
+    selectors: rankAndroidSelectors(node)
+  };
+}
+function collectInteractive2(root) {
+  const out = [];
+  const visit = (node) => {
+    if (isAndroidInteractive(node)) {
+      out.push(toElement2(node));
     }
-    return {
-      text: el.text || "",
-      href: el.href,
-      selector
-    };
+    for (const child of node.children) {
+      visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+async function analyzeAndroidApp(client, options) {
+  const xml = await client.source();
+  const root = parseAndroidHierarchy(xml);
+  const elements = root ? collectInteractive2(root) : [];
+  return { app: options.app, elements };
+}
+
+// src/analyzer/ios.ts
+var IOS_INTERACTIVE_TYPES = /* @__PURE__ */ new Set([
+  "XCUIElementTypeButton",
+  "XCUIElementTypeCell",
+  "XCUIElementTypeTextField",
+  "XCUIElementTypeSecureTextField",
+  "XCUIElementTypeSearchField",
+  "XCUIElementTypeSwitch",
+  "XCUIElementTypeToggle",
+  "XCUIElementTypeLink",
+  "XCUIElementTypeMenuItem",
+  "XCUIElementTypeSlider",
+  "XCUIElementTypeStepper",
+  "XCUIElementTypeTextView",
+  "XCUIElementTypePickerWheel",
+  "XCUIElementTypeTab",
+  "XCUIElementTypeSegmentedControl",
+  "XCUIElementTypeCheckBox",
+  "XCUIElementTypeRadioButton",
+  "XCUIElementTypeKey"
+]);
+var IOS_WINDOW_TYPE = "XCUIElementTypeWindow";
+function str3(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function bool2(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  return value === "true" || value === "1";
+}
+function toIosNode(element) {
+  const a = element.attrs;
+  return {
+    type: str3(a.type) ?? str3(element.tag),
+    name: str3(a.name),
+    label: str3(a.label),
+    value: str3(a.value),
+    enabled: bool2(a.enabled),
+    visible: bool2(a.visible),
+    children: element.children.map(toIosNode)
+  };
+}
+function parseIosHierarchy(xml) {
+  const root = parseXml(xml);
+  return root ? toIosNode(root) : null;
+}
+function hasAccessibilityId(node) {
+  return node.name !== void 0 && node.name !== node.label;
+}
+function rankIosSelectors(node) {
+  return rankNativeSelectors({
+    id: hasAccessibilityId(node) ? node.name : void 0,
+    label: node.label,
+    role: node.type ? shortIosType(node.type) : void 0,
+    name: node.label ?? node.value
   });
-  const forms = raw.forms;
+}
+function toElement3(node) {
   return {
-    url: raw.url,
-    title: raw.title,
-    elements,
-    forms,
-    links
+    type: node.type ?? "?",
+    ...node.name ? { name: node.name } : {},
+    ...node.label ? { label: node.label } : {},
+    ...node.value ? { value: node.value } : {},
+    ...node.enabled !== void 0 ? { enabled: node.enabled } : {},
+    ...node.visible !== void 0 ? { visible: node.visible } : {},
+    selectors: rankIosSelectors(node)
   };
 }
+function toWindow2(node) {
+  const [best] = rankIosSelectors(node);
+  return {
+    ...node.name ? { name: node.name } : {},
+    ...node.label ? { label: node.label } : {},
+    selector: best ?? `role=${shortIosType(IOS_WINDOW_TYPE)}`
+  };
+}
+function isIosInteractive(node) {
+  return node.type !== void 0 && IOS_INTERACTIVE_TYPES.has(node.type);
+}
+function collect(root) {
+  const elements = [];
+  const windows = [];
+  const visit = (node) => {
+    if (node.type === IOS_WINDOW_TYPE) {
+      windows.push(toWindow2(node));
+    }
+    if (isIosInteractive(node)) {
+      elements.push(toElement3(node));
+    }
+    for (const child of node.children) {
+      visit(child);
+    }
+  };
+  visit(root);
+  return { elements, windows };
+}
+async function analyzeIosApp(client, options) {
+  const xml = await client.source();
+  const root = parseIosHierarchy(xml);
+  if (!root) {
+    return { app: options.app, elements: [], windows: [] };
+  }
+  const { elements, windows } = collect(root);
+  return { app: options.app, elements, windows };
+}
 
 // src/cli/commands/analyze.ts
 init_loader();
@@ -5368,73 +8248,313 @@ function parseViewportFlag2(value) {
   }
   return 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 = parseBrowserEngine(options.browser);
-      const channel = options.channel;
-      const viewport = options.viewport ? resolveViewport(parseViewportFlag2(options.viewport)) : { width: 1280, height: 720 };
-      const session = await launchBrowser({
-        headless: !options.headed,
-        slowMo: 0,
-        timeout: 3e4,
-        trace: false,
-        recordHar: false,
-        runDir: process.cwd(),
-        engine,
-        channel,
-        viewport
-      });
-      const driver = createPlaywrightDriver(session.page);
-      try {
-        await driver.goto(url, { waitUntil: "networkidle" });
-        const result = await analyzePage(driver);
-        if (options.json) {
-          console.log(JSON.stringify(result, null, 2));
-        } else {
-          console.log(`
+function tryLoadConfig(configPath) {
+  const configLocation = configPath !== void 0 ? configPath : findConfigPath(process.cwd());
+  if (configLocation === null) {
+    return null;
+  }
+  try {
+    return loadConfig(configLocation).config;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown configuration error";
+    throw new Error(`Failed to load config at ${configLocation}: ${message}`);
+  }
+}
+function looksLikeApk2(app) {
+  return /\.apk$/i.test(app.trim());
+}
+function pickNativePlatform(platformFlag, config, app) {
+  if (platformFlag !== void 0) {
+    const normalized = platformFlag.trim().toLowerCase();
+    if (normalized === "macos" || normalized === "android" || normalized === "ios") {
+      return normalized;
+    }
+    throw new Error(`Unknown --platform "${platformFlag}". Use one of: macos, android, ios.`);
+  }
+  const configType = config?.target.type;
+  if (configType === "macos" || configType === "android" || configType === "ios") {
+    return configType;
+  }
+  return looksLikeApk2(app) ? "android" : "macos";
+}
+async function runWebAnalyze(url, options) {
+  const engine = parseBrowserEngine(options.browser);
+  const channel = options.channel;
+  const viewport = options.viewport ? resolveViewport(parseViewportFlag2(options.viewport)) : { width: 1280, height: 720 };
+  const session = await launchBrowser({
+    headless: !options.headed,
+    slowMo: 0,
+    timeout: 3e4,
+    trace: false,
+    recordHar: false,
+    runDir: process.cwd(),
+    engine,
+    channel,
+    viewport
+  });
+  const driver = createPlaywrightDriver(session.page);
+  try {
+    await driver.goto(url, { waitUntil: "networkidle" });
+    const result = await analyzePage(driver);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`
   ${import_chalk11.default.bold("Page Analysis:")} ${result.title}`);
-          console.log(`  ${import_chalk11.default.gray("URL:")} ${result.url}
+      console.log(`  ${import_chalk11.default.gray("URL:")} ${result.url}
 `);
-          if (result.forms.length > 0) {
-            console.log(import_chalk11.default.bold("  Forms:"));
-            for (const form of result.forms) {
-              const method = form.method ? import_chalk11.default.cyan(form.method) : "";
-              const action = form.action ? import_chalk11.default.gray(form.action) : "";
-              console.log(`    [${form.index}] ${method} ${action} (${form.fieldCount} fields)`);
-            }
-            console.log();
-          }
-          if (result.elements.length > 0) {
-            console.log(import_chalk11.default.bold("  Interactive Elements:"));
-            for (const el of result.elements) {
-              const tag = import_chalk11.default.cyan(el.tag);
-              const type = el.type ? import_chalk11.default.gray(`[${el.type}]`) : "";
-              const bestSelector = el.selectors.testId ?? el.selectors.label ?? el.selectors.ariaLabel ?? el.selectors.css ?? el.selectors.name ?? "";
-              const selectorStr = bestSelector ? import_chalk11.default.yellow(bestSelector) : import_chalk11.default.gray("(no selector)");
-              const req = el.required ? import_chalk11.default.red(" *") : "";
-              const form = el.formGroup !== void 0 ? import_chalk11.default.gray(` form[${el.formGroup}]`) : "";
-              console.log(`    ${tag}${type} ${selectorStr}${req}${form}`);
-            }
-            console.log();
-          }
-          if (result.links.length > 0) {
-            console.log(import_chalk11.default.bold("  Links:"));
-            for (const link of result.links.slice(0, 20)) {
-              const text = link.text || import_chalk11.default.gray("(no text)");
-              console.log(`    ${text} ${import_chalk11.default.gray("\u2192")} ${import_chalk11.default.blue(link.href)}`);
-            }
-            if (result.links.length > 20) {
-              console.log(import_chalk11.default.gray(`    ... and ${result.links.length - 20} more`));
-            }
-            console.log();
-          }
-          console.log(import_chalk11.default.gray(`  ${result.elements.length} elements, ${result.forms.length} forms, ${result.links.length} links
+      if (result.forms.length > 0) {
+        console.log(import_chalk11.default.bold("  Forms:"));
+        for (const form of result.forms) {
+          const method = form.method ? import_chalk11.default.cyan(form.method) : "";
+          const action = form.action ? import_chalk11.default.gray(form.action) : "";
+          console.log(`    [${form.index}] ${method} ${action} (${form.fieldCount} fields)`);
+        }
+        console.log();
+      }
+      if (result.elements.length > 0) {
+        console.log(import_chalk11.default.bold("  Interactive Elements:"));
+        for (const el of result.elements) {
+          const tag = import_chalk11.default.cyan(el.tag);
+          const type = el.type ? import_chalk11.default.gray(`[${el.type}]`) : "";
+          const bestSelector = el.selectors.testId ?? el.selectors.label ?? el.selectors.ariaLabel ?? el.selectors.css ?? el.selectors.name ?? "";
+          const selectorStr = bestSelector ? import_chalk11.default.yellow(bestSelector) : import_chalk11.default.gray("(no selector)");
+          const req = el.required ? import_chalk11.default.red(" *") : "";
+          const form = el.formGroup !== void 0 ? import_chalk11.default.gray(` form[${el.formGroup}]`) : "";
+          console.log(`    ${tag}${type} ${selectorStr}${req}${form}`);
+        }
+        console.log();
+      }
+      if (result.links.length > 0) {
+        console.log(import_chalk11.default.bold("  Links:"));
+        for (const link of result.links.slice(0, 20)) {
+          const text = link.text || import_chalk11.default.gray("(no text)");
+          console.log(`    ${text} ${import_chalk11.default.gray("\u2192")} ${import_chalk11.default.blue(link.href)}`);
+        }
+        if (result.links.length > 20) {
+          console.log(import_chalk11.default.gray(`    ... and ${result.links.length - 20} more`));
+        }
+        console.log();
+      }
+      console.log(import_chalk11.default.gray(`  ${result.elements.length} elements, ${result.forms.length} forms, ${result.links.length} links
+`));
+    }
+  } finally {
+    await closeBrowser(session);
+  }
+}
+function printMacElement(el) {
+  const role = import_chalk11.default.cyan(el.role);
+  const [best] = el.selectors;
+  const selectorStr = best ? import_chalk11.default.yellow(best) : import_chalk11.default.gray("(no selector)");
+  const label = el.title ?? el.description ?? el.value;
+  const labelStr = label ? ` ${import_chalk11.default.gray(`"${label}"`)}` : "";
+  const disabled = el.enabled === false ? import_chalk11.default.gray(" (disabled)") : "";
+  console.log(`    ${role} ${selectorStr}${labelStr}${disabled}`);
+}
+async function runMacAnalyze(app, config, options) {
+  const allowedApps = config?.guardrails.allowedApps ?? [];
+  assertTargetAppAllowed(allowedApps, app);
+  const session = await launchMacSession({ app, timeoutMs: config?.browser.timeout });
+  try {
+    const result = await analyzeMacApp(session.client, { app: session.bundleId });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`
+  ${import_chalk11.default.bold("App Analysis:")} ${result.app}
+`);
+      if (result.windows.length > 0) {
+        console.log(import_chalk11.default.bold("  Windows:"));
+        for (const win of result.windows) {
+          const title = win.title ? import_chalk11.default.gray(`"${win.title}"`) : import_chalk11.default.gray("(untitled)");
+          console.log(`    ${title} ${import_chalk11.default.yellow(win.selector)}`);
+        }
+        console.log();
+      }
+      if (result.elements.length > 0) {
+        console.log(import_chalk11.default.bold("  Interactive Elements:"));
+        for (const el of result.elements) {
+          printMacElement(el);
+        }
+        console.log();
+      }
+      if (result.menuItems.length > 0) {
+        console.log(import_chalk11.default.bold("  Menu Bar:"));
+        for (const el of result.menuItems) {
+          printMacElement(el);
+        }
+        console.log();
+      }
+      console.log(
+        import_chalk11.default.gray(
+          `  ${result.elements.length} elements, ${result.windows.length} windows, ${result.menuItems.length} menu items
+`
+        )
+      );
+    }
+  } finally {
+    await session.client.close();
+  }
+}
+function printAndroidElement(el) {
+  const role = import_chalk11.default.cyan(el.className);
+  const [best] = el.selectors;
+  const selectorStr = best ? import_chalk11.default.yellow(best) : import_chalk11.default.gray("(no selector)");
+  const label = el.contentDesc ?? el.text;
+  const labelStr = label ? ` ${import_chalk11.default.gray(`"${label}"`)}` : "";
+  const disabled = el.enabled === false ? import_chalk11.default.gray(" (disabled)") : "";
+  console.log(`    ${role} ${selectorStr}${labelStr}${disabled}`);
+}
+async function runAndroidAnalyze(app, config, options, deviceSerial) {
+  const allowedApps = config?.guardrails.allowedApps ?? [];
+  if (!looksLikeApk2(app)) {
+    assertAndroidAppAllowed(allowedApps, app);
+  }
+  const session = await launchAndroidSession({
+    app,
+    ...deviceSerial ? { deviceSerial } : {},
+    timeoutMs: config?.browser.timeout,
+    allowedApps
+  });
+  try {
+    const sourceFn = session.client.source;
+    if (typeof sourceFn !== "function") {
+      throw new Error(
+        "The Android agent client does not expose source(); a live uiautomator2 session is required to analyze."
+      );
+    }
+    const result = await analyzeAndroidApp(
+      { source: () => sourceFn.call(session.client) },
+      { app: session.package }
+    );
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`
+  ${import_chalk11.default.bold("App Analysis:")} ${result.app}
+`);
+      if (result.elements.length > 0) {
+        console.log(import_chalk11.default.bold("  Interactive Elements:"));
+        for (const el of result.elements) {
+          printAndroidElement(el);
+        }
+        console.log();
+      }
+      console.log(import_chalk11.default.gray(`  ${result.elements.length} elements
 `));
+    }
+  } finally {
+    await session.teardown();
+  }
+}
+function printIosElement(el) {
+  const role = import_chalk11.default.cyan(el.type);
+  const [best] = el.selectors;
+  const selectorStr = best ? import_chalk11.default.yellow(best) : import_chalk11.default.gray("(no selector)");
+  const label = el.label ?? el.value ?? el.name;
+  const labelStr = label ? ` ${import_chalk11.default.gray(`"${label}"`)}` : "";
+  const disabled = el.enabled === false ? import_chalk11.default.gray(" (disabled)") : "";
+  console.log(`    ${role} ${selectorStr}${labelStr}${disabled}`);
+}
+async function runIosAnalyze(app, config, options, udid) {
+  const allowedApps = config?.guardrails.allowedApps ?? [];
+  if (!/\//.test(app) && !/\.app$/i.test(app.trim())) {
+    assertIosAppAllowed(allowedApps, app);
+  }
+  const session = await launchIosSession({
+    app,
+    ...udid ? { udid } : {},
+    timeoutMs: config?.browser.timeout,
+    allowedApps
+  });
+  try {
+    const sourceFn = session.client.source;
+    if (typeof sourceFn !== "function") {
+      throw new Error(
+        "The iOS agent client does not expose source(); a live WebDriverAgent session is required to analyze."
+      );
+    }
+    const result = await analyzeIosApp(
+      { source: () => sourceFn.call(session.client) },
+      { app: session.bundleId }
+    );
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(`
+  ${import_chalk11.default.bold("App Analysis:")} ${result.app}
+`);
+      if (result.windows.length > 0) {
+        console.log(import_chalk11.default.bold("  Windows:"));
+        for (const win of result.windows) {
+          const title = win.label ?? win.name;
+          const titleStr = title ? import_chalk11.default.gray(`"${title}"`) : import_chalk11.default.gray("(untitled)");
+          console.log(`    ${titleStr} ${import_chalk11.default.yellow(win.selector)}`);
         }
-      } finally {
-        await closeBrowser(session);
+        console.log();
+      }
+      if (result.elements.length > 0) {
+        console.log(import_chalk11.default.bold("  Interactive Elements:"));
+        for (const el of result.elements) {
+          printIosElement(el);
+        }
+        console.log();
+      }
+      console.log(import_chalk11.default.gray(`  ${result.elements.length} elements, ${result.windows.length} windows
+`));
+    }
+  } finally {
+    await session.teardown();
+  }
+}
+async function runNativeAnalyze(platform, app, config, options, device) {
+  if (platform === "android") {
+    await runAndroidAnalyze(app, config, options, device.deviceSerial);
+    return;
+  }
+  if (platform === "ios") {
+    await runIosAnalyze(app, config, options, device.udid);
+    return;
+  }
+  await runMacAnalyze(app, config, options);
+}
+function buildAnalyzeCommand() {
+  const command = new import_commander8.Command("analyze").argument("[url]", "URL to analyze (web target)").description("Analyze a page or native app to discover interactive elements and selectors").option("--json", "Output as JSON").option("--app <app>", "Native app to analyze: bundle id / package / .app / .apk (macOS, Android, or iOS)").option("--platform <name>", "Native platform for --app: macos, android, or ios (else inferred)").option("--device <serial>", "Android adb device serial (native Android target)").option("--udid <udid>", "iOS simulator UDID (native iOS target)").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 {
+      if (options.app && url) {
+        throw new Error("Pass either a URL argument (web) or --app (native), not both.");
+      }
+      if (options.app) {
+        const config2 = tryLoadConfig(options.config);
+        const platform = pickNativePlatform(options.platform, config2, options.app);
+        await runNativeAnalyze(platform, options.app, config2, options, {
+          deviceSerial: options.device,
+          udid: options.udid
+        });
+        return;
+      }
+      if (url) {
+        await runWebAnalyze(url, options);
+        return;
+      }
+      const config = tryLoadConfig(options.config);
+      const target = config?.target;
+      if (target?.type === "macos") {
+        await runMacAnalyze(target.app, config, options);
+        return;
       }
+      if (target?.type === "android") {
+        await runAndroidAnalyze(target.app, config, options, options.device ?? target.deviceSerial);
+        return;
+      }
+      if (target?.type === "ios") {
+        await runIosAnalyze(target.app, config, options, options.udid ?? target.udid);
+        return;
+      }
+      throw new Error(
+        "analyze needs a target: pass a URL for the web target, or use --app <bundle-id|package|.app|.apk> (optionally with --platform), or set a native target.type in .prowl/config.yml."
+      );
     } catch (error) {
       const message = error instanceof Error ? error.message : "Analysis failed";
       if (options.json) {
@@ -5451,8 +8571,8 @@ function buildAnalyzeCommand() {
 }
 
 // src/cli/commands/generate.ts
-var import_node_fs17 = __toESM(require("fs"), 1);
-var import_node_path19 = __toESM(require("path"), 1);
+var import_node_fs20 = __toESM(require("fs"), 1);
+var import_node_path22 = __toESM(require("path"), 1);
 var import_commander9 = require("commander");
 var import_chalk12 = __toESM(require("chalk"), 1);
 var import_ora = __toESM(require("ora"), 1);
@@ -5503,6 +8623,7 @@ var STEP_REFERENCE = `
 
 ### Visual Regression
 - assertScreenshot: { name: "baseline-name", threshold: 0.1 }
+- assertWithAI: "The login form should show email and password fields" \u2014 AI checks the screenshot against the claim
 
 ### Control Flow
 - if: { visible: ".banner", then: [steps...] }
@@ -5544,81 +8665,6 @@ function extractYamlFromResponse(response) {
   return response.trim();
 }
 
-// src/generator/ai.ts
-function resolveAiConfig() {
-  const provider = process.env.PROWL_AI_PROVIDER ?? "anthropic";
-  if (provider !== "anthropic" && provider !== "openai") {
-    throw new Error(`Unsupported AI provider: ${provider}. Use "anthropic" or "openai".`);
-  }
-  const apiKey = process.env.PROWL_AI_KEY;
-  if (!apiKey) {
-    throw new Error(
-      "PROWL_AI_KEY environment variable is required. Set it to your Anthropic or OpenAI API key."
-    );
-  }
-  const defaultModel = provider === "anthropic" ? "claude-sonnet-4-5-20250929" : "gpt-4o";
-  const model = process.env.PROWL_AI_MODEL ?? defaultModel;
-  return { provider, model, apiKey };
-}
-async function generateWithAi(prompt, config) {
-  if (config.provider === "anthropic") {
-    return generateWithAnthropic(prompt, config);
-  }
-  return generateWithOpenAi(prompt, config);
-}
-async function generateWithAnthropic(prompt, config) {
-  const response = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-api-key": config.apiKey,
-      "anthropic-version": "2023-06-01"
-    },
-    body: JSON.stringify({
-      model: config.model,
-      max_tokens: 4096,
-      messages: [
-        { role: "user", content: prompt }
-      ]
-    })
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`Anthropic API error (${response.status}): ${body}`);
-  }
-  const data = await response.json();
-  const textBlock = data.content.find((c) => c.type === "text");
-  if (!textBlock?.text) {
-    throw new Error("Anthropic API returned no text content");
-  }
-  return textBlock.text;
-}
-async function generateWithOpenAi(prompt, config) {
-  const response = await fetch("https://api.openai.com/v1/chat/completions", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "Authorization": `Bearer ${config.apiKey}`
-    },
-    body: JSON.stringify({
-      model: config.model,
-      messages: [
-        { role: "user", content: prompt }
-      ],
-      max_tokens: 4096
-    })
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`OpenAI API error (${response.status}): ${body}`);
-  }
-  const data = await response.json();
-  if (!data.choices?.[0]?.message?.content) {
-    throw new Error("OpenAI API returned no content");
-  }
-  return data.choices[0].message.content;
-}
-
 // src/generator/index.ts
 init_loader();
 init_schema();
@@ -5721,13 +8767,13 @@ function buildGenerateCommand() {
             const result = loadConfig2(options.config);
             configDir = result.configDir;
           } catch {
-            configDir = import_node_path19.default.join(process.cwd(), ".prowl");
+            configDir = import_node_path22.default.join(process.cwd(), ".prowl");
           }
-          const huntsDir = import_node_path19.default.join(configDir, "hunts");
-          import_node_fs17.default.mkdirSync(huntsDir, { recursive: true });
+          const huntsDir = import_node_path22.default.join(configDir, "hunts");
+          import_node_fs20.default.mkdirSync(huntsDir, { recursive: true });
           const fileName = options.output.endsWith(".yml") ? options.output : `${options.output}.yml`;
-          const filePath = import_node_path19.default.join(huntsDir, fileName);
-          import_node_fs17.default.writeFileSync(filePath, yamlStr + "\n", "utf-8");
+          const filePath = import_node_path22.default.join(huntsDir, fileName);
+          import_node_fs20.default.writeFileSync(filePath, yamlStr + "\n", "utf-8");
           console.log(import_chalk12.default.green(`  Saved to ${filePath}`));
         } else {
           console.log(yamlStr);
@@ -5924,7 +8970,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_path20 = __toESM(require("path"), 1);
+var import_node_path23 = __toESM(require("path"), 1);
 init_loader();
 function listHuntsTool(configPath) {
   const { configDir } = loadConfig(configPath);
@@ -5932,7 +8978,7 @@ function listHuntsTool(configPath) {
 }
 async function runSuiteTool(args = {}, options = {}) {
   const { configPath: resolvedConfigPath, configDir, config } = loadConfig(options.configPath);
-  const projectRoot = options.projectRoot ?? import_node_path20.default.dirname(configDir);
+  const projectRoot = options.projectRoot ?? import_node_path23.default.dirname(configDir);
   const suite = await runSuite({
     configPath: resolvedConfigPath,
     includeTags: args.includeTags,
@@ -5941,8 +8987,8 @@ async function runSuiteTool(args = {}, options = {}) {
   });
   const bugLogCfg = config.bugLog ?? {};
   const logBugs = args.logBugs ?? bugLogCfg.enabled ?? true;
-  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 backlogPath = bugLogCfg.backlogPath ? import_node_path23.default.resolve(projectRoot, bugLogCfg.backlogPath) : void 0;
+  const resolvedPath = bugLogCfg.resolvedPath ? import_node_path23.default.resolve(projectRoot, bugLogCfg.resolvedPath) : backlogPath ? import_node_path23.default.join(import_node_path23.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 {
@@ -5969,9 +9015,9 @@ async function runHuntTool(args, configPath) {
 }
 
 // src/mcp/projects.ts
-var import_node_fs18 = __toESM(require("fs"), 1);
-var import_node_os = __toESM(require("os"), 1);
-var import_node_path21 = __toESM(require("path"), 1);
+var import_node_fs21 = __toESM(require("fs"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path24 = __toESM(require("path"), 1);
 var import_yaml3 = __toESM(require("yaml"), 1);
 var import_zod2 = require("zod");
 var projectEntrySchema = import_zod2.z.object({
@@ -5983,37 +9029,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_path21.default.join(import_node_os.default.homedir(), ".prowl", "projects.yml");
+  return import_node_path24.default.join(import_node_os3.default.homedir(), ".prowl", "projects.yml");
 }
 function legacyRegistryPath() {
-  return import_node_path21.default.join(import_node_os.default.homedir(), ".prowlqa", "projects.yml");
+  return import_node_path24.default.join(import_node_os3.default.homedir(), ".prowlqa", "projects.yml");
 }
 function resolveProjectConfigPath(root) {
-  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;
+  const preferred = import_node_path24.default.join(root, ".prowl", "config.yml");
+  if (import_node_fs21.default.existsSync(preferred)) return preferred;
+  const legacy = import_node_path24.default.join(root, ".prowlqa", "config.yml");
+  if (import_node_fs21.default.existsSync(legacy)) return legacy;
   return preferred;
 }
 function resolveRegistryRelativePath(registry, inputPath) {
-  return import_node_path21.default.isAbsolute(inputPath) ? inputPath : import_node_path21.default.resolve(import_node_path21.default.dirname(registry.registryPath), inputPath);
+  return import_node_path24.default.isAbsolute(inputPath) ? inputPath : import_node_path24.default.resolve(import_node_path24.default.dirname(registry.registryPath), inputPath);
 }
 function resolveRegistryPath(explicitPath) {
-  if (explicitPath) return import_node_path21.default.resolve(explicitPath);
+  if (explicitPath) return import_node_path24.default.resolve(explicitPath);
   const envPath = process.env.PROWL_PROJECTS ?? process.env.PROWLQA_PROJECTS;
-  if (envPath) return import_node_path21.default.resolve(envPath);
+  if (envPath) return import_node_path24.default.resolve(envPath);
   const fallback = defaultRegistryPath();
-  if (import_node_fs18.default.existsSync(fallback)) return fallback;
+  if (import_node_fs21.default.existsSync(fallback)) return fallback;
   const legacy = legacyRegistryPath();
-  return import_node_fs18.default.existsSync(legacy) ? legacy : null;
+  return import_node_fs21.default.existsSync(legacy) ? legacy : null;
 }
 function loadProjectRegistry(explicitPath) {
   const registryPath = resolveRegistryPath(explicitPath);
   if (!registryPath) return null;
-  if (!import_node_fs18.default.existsSync(registryPath)) {
+  if (!import_node_fs21.default.existsSync(registryPath)) {
     throw new Error(`Project registry not found at ${registryPath}`);
   }
-  const raw = import_node_fs18.default.readFileSync(registryPath, "utf-8");
+  const raw = import_node_fs21.default.readFileSync(registryPath, "utf-8");
   const parsed = import_yaml3.default.parse(raw) ?? {};
   const validated = projectRegistrySchema.parse(parsed);
   return { projects: validated.projects, registryPath };