prowl-tools 0.1.5 → 0.1.7

package/dist/lib.cjs

@@ -37,12 +37,12 @@ __export(visual_exports, {
   ensureBaselineDir: () => ensureBaselineDir
 });
 async function compareScreenshots(baselinePath, currentPath, diffPath, threshold) {
-  const baselineData = import_pngjs.PNG.sync.read(import_node_fs8.default.readFileSync(baselinePath));
-  const currentData = import_pngjs.PNG.sync.read(import_node_fs8.default.readFileSync(currentPath));
+  const baselineData = import_pngjs.PNG.sync.read(import_node_fs9.default.readFileSync(baselinePath));
+  const currentData = import_pngjs.PNG.sync.read(import_node_fs9.default.readFileSync(currentPath));
   const { width, height } = baselineData;
   if (currentData.width !== width || currentData.height !== height) {
     const diff2 = new import_pngjs.PNG({ width, height });
-    import_node_fs8.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
+    import_node_fs9.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff2));
     return {
       match: false,
       diffPercentage: 1,
@@ -60,7 +60,7 @@ async function compareScreenshots(baselinePath, currentPath, diffPath, threshold
   );
   const totalPixels = width * height;
   const diffPercentage = diffPixels / totalPixels;
-  import_node_fs8.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
+  import_node_fs9.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
   return {
     match: diffPercentage <= threshold,
     diffPercentage,
@@ -68,16 +68,16 @@ async function compareScreenshots(baselinePath, currentPath, diffPath, threshold
   };
 }
 function ensureBaselineDir(configDir) {
-  const baselineDir = import_node_path8.default.join(configDir, "baselines");
-  import_node_fs8.default.mkdirSync(baselineDir, { recursive: true });
+  const baselineDir = import_node_path10.default.join(configDir, "baselines");
+  import_node_fs9.default.mkdirSync(baselineDir, { recursive: true });
   return baselineDir;
 }
-var import_node_fs8, import_node_path8, import_pngjs, import_pixelmatch;
+var import_node_fs9, import_node_path10, import_pngjs, import_pixelmatch;
 var init_visual = __esm({
   "src/runner/visual.ts"() {
     "use strict";
-    import_node_fs8 = __toESM(require("fs"), 1);
-    import_node_path8 = __toESM(require("path"), 1);
+    import_node_fs9 = __toESM(require("fs"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
     import_pngjs = require("pngjs");
     import_pixelmatch = __toESM(require("pixelmatch"), 1);
   }
@@ -86,27 +86,43 @@ var init_visual = __esm({
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ANDROID_INTERACTIVE_CLASSES: () => ANDROID_INTERACTIVE_CLASSES,
   ANDROID_KEYCODES: () => ANDROID_KEYCODES,
+  ANDROID_MATCH_DIALECT: () => ANDROID_MATCH_DIALECT,
   DEFAULT_AGENT_REQUEST_TIMEOUT_MS: () => DEFAULT_AGENT_REQUEST_TIMEOUT_MS,
   DEFAULT_ANALYZE_TREE_DEPTH: () => DEFAULT_ANALYZE_TREE_DEPTH,
   DEFAULT_FLAKY_THRESHOLD: () => DEFAULT_FLAKY_THRESHOLD,
   DEFAULT_REQUEST_TIMEOUT_MS: () => DEFAULT_REQUEST_TIMEOUT_MS,
   DEFAULT_SIMULATOR_LOCK_ROOT: () => DEFAULT_SIMULATOR_LOCK_ROOT,
   DEFAULT_WDA_REQUEST_TIMEOUT_MS: () => DEFAULT_WDA_REQUEST_TIMEOUT_MS,
+  HELPER_BINARY: () => HELPER_BINARY,
   INTERACTIVE_ROLES: () => INTERACTIVE_ROLES,
+  IOS_INTERACTIVE_TYPES: () => IOS_INTERACTIVE_TYPES,
+  IOS_MATCH_DIALECT: () => IOS_MATCH_DIALECT,
   IOS_PRESS_KEYS: () => IOS_PRESS_KEYS,
+  IOS_WINDOW_TYPE: () => IOS_WINDOW_TYPE,
+  MACDRIVER_REPO: () => MACDRIVER_REPO,
+  MACDRIVER_SIGNING_AUTHORITY_PREFIX: () => MACDRIVER_SIGNING_AUTHORITY_PREFIX,
+  MACDRIVER_SIGNING_IDENTIFIER: () => MACDRIVER_SIGNING_IDENTIFIER,
+  MACDRIVER_VERSION: () => MACDRIVER_VERSION,
+  MACDRIVER_VERSION_PATTERN: () => MACDRIVER_VERSION_PATTERN,
+  MACOS_MATCH_DIALECT: () => MACOS_MATCH_DIALECT,
+  NATIVE_ATTRIBUTE_MAP: () => NATIVE_ATTRIBUTE_MAP,
   SpawnMacHelperClient: () => SpawnMacHelperClient,
   UIA2_REMOTE_PORT: () => UIA2_REMOTE_PORT,
   Uia2HttpError: () => Uia2HttpError,
   Uia2Transport: () => Uia2Transport,
-  WDA_RUNNER_APP_NAME: () => WDA_RUNNER_APP_NAME,
   WDA_RUNNER_BUNDLE_ID: () => WDA_RUNNER_BUNDLE_ID,
+  WDA_USE_PORT_ENV: () => WDA_USE_PORT_ENV,
   WEB_ONLY_STEP_TYPES: () => WEB_ONLY_STEP_TYPES,
   WdaHttpError: () => WdaHttpError,
   WdaTransport: () => WdaTransport,
+  analyzeAndroidApp: () => analyzeAndroidApp,
+  analyzeIosApp: () => analyzeIosApp,
   analyzeMacApp: () => analyzeMacApp,
   analyzePage: () => analyzePage,
   androidAppAllowedIdentities: () => androidAppAllowedIdentities,
+  androidNodeToNative: () => androidNodeToNative,
   androidQueryToLocator: () => androidQueryToLocator,
   assertAndroidAppAllowed: () => assertAndroidAppAllowed,
   assertIosAppAllowed: () => assertIosAppAllowed,
@@ -119,6 +135,8 @@ __export(src_exports, {
   closeIosSession: () => closeIosSession,
   closeMacSession: () => closeMacSession,
   clusterFailures: () => clusterFailures,
+  codesignVerifier: () => codesignVerifier,
+  collectMacdriverStatus: () => collectMacdriverStatus,
   computeFlakeScore: () => computeFlakeScore,
   configSchema: () => configSchema,
   createAndroidDriver: () => createAndroidDriver,
@@ -128,8 +146,12 @@ __export(src_exports, {
   createUia2Session: () => createUia2Session,
   createWdaAgentClient: () => createWdaAgentClient,
   createWdaSession: () => createWdaSession,
+  decodeXmlEntities: () => decodeXmlEntities,
   defaultAgentConnector: () => defaultAgentConnector,
   defaultIosAgentConnector: () => defaultIosAgentConnector,
+  defaultWdaTestRunPreparer: () => defaultWdaTestRunPreparer,
+  dittoExtractor: () => dittoExtractor,
+  downloadAndVerify: () => downloadAndVerify,
   escapePredicateArg: () => escapePredicateArg,
   escapeUiSelectorArg: () => escapeUiSelectorArg,
   extractElementId: () => extractElementId,
@@ -139,9 +161,14 @@ __export(src_exports, {
   generateHunt: () => generateHunt,
   healSelector: () => healSelector,
   huntSchema: () => huntSchema,
+  injectUsePortIntoXctestrun: () => injectUsePortIntoXctestrun,
+  installMacdriver: () => installMacdriver,
   interpolateHunt: () => interpolateHunt,
   iosAppAllowedIdentities: () => iosAppAllowedIdentities,
+  iosNodeToNative: () => iosNodeToNative,
   iosQueryToLocator: () => iosQueryToLocator,
+  isAndroidInteractive: () => isAndroidInteractive,
+  isIosInteractive: () => isIosInteractive,
   launchAndroidSession: () => launchAndroidSession,
   launchIosSession: () => launchIosSession,
   launchMacSession: () => launchMacSession,
@@ -152,18 +179,41 @@ __export(src_exports, {
   loadHunt: () => loadHunt,
   loadHuntMeta: () => loadHuntMeta,
   loadHuntTags: () => loadHuntTags,
+  macdriverAssetName: () => macdriverAssetName,
+  macdriverAssetUrl: () => macdriverAssetUrl,
   macdriverBuildInstructions: () => macdriverBuildInstructions,
+  macdriverChecksumName: () => macdriverChecksumName,
+  macdriverInstallRoot: () => macdriverInstallRoot,
+  macdriverInstalledBinary: () => macdriverInstalledBinary,
+  macdriverReleaseTag: () => macdriverReleaseTag,
+  macdriverVersionDir: () => macdriverVersionDir,
+  matchAndroidSelector: () => matchAndroidSelector,
+  matchIosSelector: () => matchIosSelector,
+  matchNativeTree: () => matchNativeTree,
+  nodeMatchesSelector: () => nodeMatchesSelector,
   normalizeXcuiClassName: () => normalizeXcuiClassName,
   parseAaptPackage: () => parseAaptPackage,
   parseAdbDevices: () => parseAdbDevices,
+  parseAndroidHierarchy: () => parseAndroidHierarchy,
   parseAndroidSelector: () => parseAndroidSelector,
+  parseChecksumFile: () => parseChecksumFile,
+  parseCodesignDetails: () => parseCodesignDetails,
   parseForwardPort: () => parseForwardPort,
+  parseIosHierarchy: () => parseIosHierarchy,
   parseIosSelector: () => parseIosSelector,
   parseMacSelector: () => parseMacSelector,
+  parseNativeSelector: () => parseNativeSelector,
   parseSimctlDevices: () => parseSimctlDevices,
+  parseSnapshot: () => parseSnapshot,
   parseXcodeVersion: () => parseXcodeVersion,
+  parseXml: () => parseXml,
+  qualifyResourceId: () => qualifyResourceId,
+  quoteSelectorValue: () => quoteSelectorValue,
+  rankAndroidSelectors: () => rankAndroidSelectors,
   rankFlaky: () => rankFlaky,
+  rankIosSelectors: () => rankIosSelectors,
   rankMacSelectors: () => rankMacSelectors,
+  rankNativeSelectors: () => rankNativeSelectors,
   readHistory: () => readHistory,
   readHuntHistory: () => readHuntHistory,
   readIosBundleIdentifier: () => readIosBundleIdentifier,
@@ -171,19 +221,30 @@ __export(src_exports, {
   resolveAgentApks: () => resolveAgentApks,
   resolveHelperBinary: () => resolveHelperBinary,
   resolveWdaProject: () => resolveWdaProject,
-  resolveWdaRunner: () => resolveWdaRunner,
+  resolveWdaTestRun: () => resolveWdaTestRun,
   runHunt: () => runHunt,
   runSuite: () => runSuite,
+  runVersionProbe: () => runVersionProbe,
   selectDeviceSerial: () => selectDeviceSerial,
   selectSimulatorUdid: () => selectSimulatorUdid,
+  sha256Hex: () => sha256Hex,
+  shortIosType: () => shortIosType,
   stepSchema: () => stepSchema,
+  tccGuidance: () => tccGuidance,
+  unquoteSelectorValue: () => unquoteSelectorValue,
   unwrapAndroidTextSelector: () => unwrapAndroidTextSelector,
   unwrapIosTextSelector: () => unwrapIosTextSelector,
+  unwrapNativeTextSelector: () => unwrapNativeTextSelector,
   updateBacklogFromSuite: () => updateBacklogFromSuite,
+  validateMacdriverArchiveEntries: () => validateMacdriverArchiveEntries,
+  validateMacdriverVersion: () => validateMacdriverVersion,
+  verifyMacdriverSignature: () => verifyMacdriverSignature,
   waitForAgentReady: () => waitForAgentReady,
   waitForWdaReady: () => waitForWdaReady,
   wdaCacheDir: () => wdaCacheDir,
-  webOnlyReason: () => webOnlyReason
+  wdaTestRunArgs: () => wdaTestRunArgs,
+  webOnlyReason: () => webOnlyReason,
+  zipinfoArchiveLister: () => zipinfoArchiveLister
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -366,25 +427,71 @@ function createMacDriver(client, options = {}) {
 // src/browser/mac-helper.ts
 var import_node_child_process = require("child_process");
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
+var import_node_os2 = __toESM(require("os"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_node_url = require("url");
-var import_meta = {};
+
+// src/browser/macdriver-release.ts
+var import_node_os = __toESM(require("os"), 1);
+var import_node_path = __toESM(require("path"), 1);
 var HELPER_BINARY = "prowl-macdriver";
+var MACDRIVER_VERSION = "0.1.0";
+var MACDRIVER_REPO = "prowl-tools/prowl";
+var MACDRIVER_SIGNING_IDENTIFIER = "tools.prowl.macdriver";
+var MACDRIVER_SIGNING_AUTHORITY_PREFIX = "Developer ID Application: Genkei Labs";
+var MACDRIVER_VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z][0-9A-Za-z.-]*)?(?:\+[0-9A-Za-z][0-9A-Za-z.-]*)?$/;
+function validateMacdriverVersion(version) {
+  if (!MACDRIVER_VERSION_PATTERN.test(version)) {
+    throw new Error(
+      `Invalid prowl-macdriver version "${version}". Expected a release version like 0.1.0.`
+    );
+  }
+  return version;
+}
+function macdriverReleaseTag(version = MACDRIVER_VERSION) {
+  return `macdriver-v${validateMacdriverVersion(version)}`;
+}
+function macdriverAssetName(version = MACDRIVER_VERSION) {
+  return `prowl-macdriver-v${validateMacdriverVersion(version)}-universal.zip`;
+}
+function macdriverChecksumName(version = MACDRIVER_VERSION) {
+  return `${macdriverAssetName(version)}.sha256`;
+}
+function macdriverAssetUrl(assetName, version = MACDRIVER_VERSION) {
+  return `https://github.com/${MACDRIVER_REPO}/releases/download/${macdriverReleaseTag(version)}/${assetName}`;
+}
+function macdriverInstallRoot(homedir = import_node_os.default.homedir()) {
+  return import_node_path.default.join(homedir, ".prowl", "macdriver");
+}
+function macdriverVersionDir(version = MACDRIVER_VERSION, homedir = import_node_os.default.homedir()) {
+  const root = import_node_path.default.resolve(macdriverInstallRoot(homedir));
+  const versionDir = import_node_path.default.resolve(root, validateMacdriverVersion(version));
+  if (!versionDir.startsWith(root + import_node_path.default.sep)) {
+    throw new Error(`Resolved prowl-macdriver version directory escaped install root: ${versionDir}`);
+  }
+  return versionDir;
+}
+function macdriverInstalledBinary(version = MACDRIVER_VERSION, homedir = import_node_os.default.homedir()) {
+  return import_node_path.default.join(macdriverVersionDir(version, homedir), HELPER_BINARY);
+}
+
+// src/browser/mac-helper.ts
+var import_meta = {};
 function macdriverBuildInstructions() {
-  return "The macOS target requires the experimental `prowl-macdriver` helper, which is not shipped in the npm package. Build it locally:\n  cd macdriver && swift build -c release\nor point Prowl at a prebuilt binary via the PROWL_MACDRIVER_BIN environment variable.";
+  return "The macOS target needs the `prowl-macdriver` helper. Install the prebuilt, signed binary (recommended):\n  prowl macdriver install\nContributors building from source can instead run:\n  cd macdriver && swift build -c release\nor point Prowl at a prebuilt binary via the PROWL_MACDRIVER_BIN environment variable.";
 }
 function getPackageRoot() {
-  let dir = import_node_path.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
-  const root = import_node_path.default.parse(dir).root;
+  let dir = import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(import_meta.url));
+  const root = import_node_path2.default.parse(dir).root;
   while (dir !== root) {
-    if (import_node_fs.default.existsSync(import_node_path.default.join(dir, "package.json"))) {
+    if (import_node_fs.default.existsSync(import_node_path2.default.join(dir, "package.json"))) {
       return dir;
     }
-    dir = import_node_path.default.dirname(dir);
+    dir = import_node_path2.default.dirname(dir);
   }
   return root;
 }
-function resolveHelperBinary(env = process.env) {
+function resolveHelperBinary(env = process.env, options = {}) {
   const override = env.PROWL_MACDRIVER_BIN;
   if (override) {
     if (!import_node_fs.default.existsSync(override)) {
@@ -395,10 +502,15 @@ ${macdriverBuildInstructions()}`
     }
     return override;
   }
+  const homedir = options.homedir ?? import_node_os2.default.homedir();
+  const userBinary = macdriverInstalledBinary(MACDRIVER_VERSION, homedir);
+  if (import_node_fs.default.existsSync(userBinary)) {
+    return userBinary;
+  }
   const root = getPackageRoot();
   const candidates = [
-    import_node_path.default.join(root, "macdriver", ".build", "release", HELPER_BINARY),
-    import_node_path.default.join(root, "macdriver", ".build", "debug", HELPER_BINARY)
+    import_node_path2.default.join(root, "macdriver", ".build", "release", HELPER_BINARY),
+    import_node_path2.default.join(root, "macdriver", ".build", "debug", HELPER_BINARY)
   ];
   for (const candidate of candidates) {
     if (import_node_fs.default.existsSync(candidate)) {
@@ -570,8 +682,583 @@ async function closeMacSession(session) {
   }
 }
 
-// src/browser/android-driver.ts
+// src/browser/macdriver-install.ts
+var import_node_child_process2 = require("child_process");
+var import_node_crypto = require("crypto");
 var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_os3 = __toESM(require("os"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_util = require("util");
+var execFileAsync = (0, import_node_util.promisify)(import_node_child_process2.execFile);
+function parseChecksumFile(text) {
+  const token = text.trim().split(/\s+/, 1)[0] ?? "";
+  const digest = token.toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(digest)) {
+    throw new Error(`Malformed .sha256 checksum file (expected a 64-char hex digest, got: ${text.trim().slice(0, 80)})`);
+  }
+  return digest;
+}
+function sha256Hex(bytes) {
+  return (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+}
+var commandRunner = async (file, args) => execFileAsync(file, args);
+function commandOutput(result) {
+  return [result.stdout, result.stderr].filter((value) => value !== void 0).map((value) => value.toString()).join("\n").trim();
+}
+function commandErrorDetail(error) {
+  const err = error;
+  return [err.stderr, err.stdout, err.message].filter((value) => value !== void 0 && value !== "").map((value) => value.toString()).join("\n").trim();
+}
+async function runRequiredCommand(run, binaryPath, command, args, label) {
+  try {
+    return await run(command, args);
+  } catch (error) {
+    const detail = commandErrorDetail(error);
+    throw new Error(`${label} failed for ${binaryPath}${detail ? `: ${detail}` : ""}`);
+  }
+}
+var zipinfoArchiveLister = async (zipPath) => {
+  try {
+    const { stdout } = await execFileAsync("zipinfo", ["-1", zipPath]);
+    return stdout.toString().split(/\r?\n/).filter((entry) => entry.length > 0);
+  } catch (error) {
+    const detail = commandErrorDetail(error);
+    throw new Error(`Failed to inspect release archive ${zipPath} with zipinfo${detail ? `: ${detail}` : ""}`);
+  }
+};
+function normalizeArchiveEntryName(entry) {
+  if (entry.length === 0 || entry !== entry.trim() || entry.includes("\0") || entry.includes("\\")) {
+    throw new Error(`Unsafe path in prowl-macdriver release archive: ${JSON.stringify(entry)}`);
+  }
+  if (entry.endsWith("/")) {
+    throw new Error(`Unexpected directory in prowl-macdriver release archive: ${entry}`);
+  }
+  if (import_node_path3.default.posix.isAbsolute(entry)) {
+    throw new Error(`Unsafe absolute path in prowl-macdriver release archive: ${entry}`);
+  }
+  const parts = entry.split("/");
+  if (parts.some((part) => part === "" || part === "." || part === "..")) {
+    throw new Error(`Unsafe path in prowl-macdriver release archive: ${entry}`);
+  }
+  return entry;
+}
+function validateMacdriverArchiveEntries(entries) {
+  const normalized = entries.map(normalizeArchiveEntryName);
+  if (normalized.length !== 1 || normalized[0] !== HELPER_BINARY) {
+    const shown = normalized.length > 0 ? normalized.join(", ") : "(empty archive)";
+    throw new Error(
+      `Unexpected prowl-macdriver release archive contents: ${shown}. Expected exactly "${HELPER_BINARY}" at the archive root.`
+    );
+  }
+}
+var dittoExtractor = async (zipPath, destDir) => {
+  await execFileAsync("ditto", ["-x", "-k", zipPath, destDir]);
+};
+function parseCodesignDetails(text) {
+  const details = { identifier: null, authorities: [], teamIdentifier: null };
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("Identifier=")) {
+      details.identifier = trimmed.slice("Identifier=".length);
+    } else if (trimmed.startsWith("Authority=")) {
+      details.authorities.push(trimmed.slice("Authority=".length));
+    } else if (trimmed.startsWith("TeamIdentifier=")) {
+      details.teamIdentifier = trimmed.slice("TeamIdentifier=".length);
+    }
+  }
+  return details;
+}
+function validateCodesignDetails(details, binaryPath) {
+  if (details.identifier !== MACDRIVER_SIGNING_IDENTIFIER) {
+    throw new Error(
+      `codesign verification failed for ${binaryPath}: expected identifier "${MACDRIVER_SIGNING_IDENTIFIER}", got "${details.identifier ?? "missing"}"`
+    );
+  }
+  const developerIdAuthority = details.authorities.find(
+    (authority) => authority.startsWith(`${MACDRIVER_SIGNING_AUTHORITY_PREFIX} (`)
+  );
+  const authorityTeamId = developerIdAuthority?.match(/\(([A-Z0-9]{10})\)$/)?.[1] ?? null;
+  if (!developerIdAuthority || !authorityTeamId) {
+    const shown = details.authorities.length > 0 ? details.authorities.join(" / ") : "missing";
+    throw new Error(
+      `codesign verification failed for ${binaryPath}: expected ${MACDRIVER_SIGNING_AUTHORITY_PREFIX} signer, got ${shown}`
+    );
+  }
+  if (!details.teamIdentifier) {
+    throw new Error(`codesign verification failed for ${binaryPath}: missing TeamIdentifier`);
+  }
+  if (details.teamIdentifier !== authorityTeamId) {
+    throw new Error(
+      `codesign verification failed for ${binaryPath}: TeamIdentifier ${details.teamIdentifier} does not match Developer ID authority team ${authorityTeamId}`
+    );
+  }
+}
+async function verifyMacdriverSignature(binaryPath, run = commandRunner) {
+  await runRequiredCommand(run, binaryPath, "codesign", ["--verify", "--strict", binaryPath], "codesign verification");
+  const display = await runRequiredCommand(
+    run,
+    binaryPath,
+    "codesign",
+    ["--display", "--verbose=4", binaryPath],
+    "codesign detail inspection"
+  );
+  validateCodesignDetails(parseCodesignDetails(commandOutput(display)), binaryPath);
+  await runRequiredCommand(
+    run,
+    binaryPath,
+    "spctl",
+    ["--assess", "--type", "execute", "--verbose=4", binaryPath],
+    "spctl assessment"
+  );
+}
+var codesignVerifier = async (binaryPath) => {
+  await verifyMacdriverSignature(binaryPath);
+};
+async function downloadAndVerify(options = {}) {
+  const version = options.version ?? MACDRIVER_VERSION;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const assetName = macdriverAssetName(version);
+  const zipUrl = macdriverAssetUrl(assetName, version);
+  const sumUrl = macdriverAssetUrl(macdriverChecksumName(version), version);
+  const [zipRes, sumRes] = await Promise.all([
+    fetchImpl(zipUrl, { redirect: "follow" }),
+    fetchImpl(sumUrl, { redirect: "follow" })
+  ]);
+  if (zipRes.status === 404 || sumRes.status === 404) {
+    throw new Error(
+      `No published prowl-macdriver release for ${macdriverReleaseTag(version)} yet.
+The signed binary is cut by the maintainer; until then build from source:
+  cd macdriver && swift build -c release`
+    );
+  }
+  if (!zipRes.ok) {
+    throw new Error(`Failed to download ${assetName} (HTTP ${zipRes.status}) from ${zipUrl}`);
+  }
+  if (!sumRes.ok) {
+    throw new Error(`Failed to download the checksum (HTTP ${sumRes.status}) from ${sumUrl}`);
+  }
+  const zipBytes = Buffer.from(await zipRes.arrayBuffer());
+  const expected = parseChecksumFile(await sumRes.text());
+  const actual = sha256Hex(zipBytes);
+  if (actual !== expected) {
+    throw new Error(
+      `Checksum mismatch for ${assetName}.
+  expected: ${expected}
+  actual:   ${actual}
+The download was rejected and discarded; re-run the install, and report it if it repeats.`
+    );
+  }
+  return zipBytes;
+}
+async function installMacdriver(options = {}) {
+  const version = validateMacdriverVersion(options.version ?? MACDRIVER_VERSION);
+  const homedir = options.homedir ?? import_node_os3.default.homedir();
+  const listArchiveEntries = options.listArchiveEntries ?? zipinfoArchiveLister;
+  const extract = options.extract ?? dittoExtractor;
+  const verifySignature = options.verifySignature ?? codesignVerifier;
+  const installRoot = macdriverInstallRoot(homedir);
+  const versionDir = macdriverVersionDir(version, homedir);
+  const binaryPath = macdriverInstalledBinary(version, homedir);
+  if (!options.force && import_node_fs2.default.existsSync(binaryPath)) {
+    return { version, binaryPath, alreadyInstalled: true };
+  }
+  const zipBytes = await downloadAndVerify({ version, fetchImpl: options.fetchImpl });
+  import_node_fs2.default.mkdirSync(installRoot, { recursive: true });
+  const stagingDir = import_node_fs2.default.mkdtempSync(import_node_path3.default.join(installRoot, `.tmp-${version}-`));
+  const extractDir = import_node_path3.default.join(stagingDir, "extract");
+  const zipPath = import_node_path3.default.join(stagingDir, macdriverAssetName(version));
+  try {
+    import_node_fs2.default.mkdirSync(extractDir);
+    import_node_fs2.default.writeFileSync(zipPath, zipBytes);
+    validateMacdriverArchiveEntries(await listArchiveEntries(zipPath));
+    await extract(zipPath, extractDir);
+    const stagedBinaryPath = import_node_path3.default.join(extractDir, HELPER_BINARY);
+    assertExtractedHelper(extractDir, stagedBinaryPath);
+    import_node_fs2.default.chmodSync(stagedBinaryPath, 493);
+    await verifySignature(stagedBinaryPath);
+    replaceVersionDir(versionDir, extractDir, installRoot);
+  } finally {
+    import_node_fs2.default.rmSync(stagingDir, { recursive: true, force: true });
+  }
+  return { version, binaryPath, alreadyInstalled: false };
+}
+function assertExtractedHelper(extractDir, binaryPath) {
+  const entries = import_node_fs2.default.readdirSync(extractDir);
+  if (!entries.includes(HELPER_BINARY)) {
+    throw new Error(`The release archive did not contain a "${HELPER_BINARY}" binary.`);
+  }
+  if (entries.length !== 1 || entries[0] !== HELPER_BINARY) {
+    const shown = entries.length > 0 ? entries.join(", ") : "(empty directory)";
+    throw new Error(
+      `Unexpected extracted prowl-macdriver archive contents: ${shown}. Expected exactly "${HELPER_BINARY}".`
+    );
+  }
+  let stat = null;
+  try {
+    stat = import_node_fs2.default.lstatSync(binaryPath);
+  } catch {
+  }
+  if (!stat?.isFile()) {
+    throw new Error(`The release archive "${HELPER_BINARY}" entry is not a regular file.`);
+  }
+}
+function replaceVersionDir(versionDir, stagedVersionDir, installRoot) {
+  const backupDir = import_node_path3.default.join(installRoot, `.previous-${import_node_path3.default.basename(versionDir)}-${process.pid}-${Date.now()}`);
+  let backedUp = false;
+  try {
+    if (import_node_fs2.default.existsSync(versionDir)) {
+      import_node_fs2.default.renameSync(versionDir, backupDir);
+      backedUp = true;
+    }
+    import_node_fs2.default.renameSync(stagedVersionDir, versionDir);
+    if (backedUp) {
+      import_node_fs2.default.rmSync(backupDir, { recursive: true, force: true });
+    }
+  } catch (error) {
+    if (backedUp && !import_node_fs2.default.existsSync(versionDir) && import_node_fs2.default.existsSync(backupDir)) {
+      import_node_fs2.default.renameSync(backupDir, versionDir);
+    }
+    throw error;
+  }
+}
+var runVersionProbe = async (binaryPath) => {
+  try {
+    const { stdout } = await execFileAsync(binaryPath, ["version"], { timeout: 5e3 });
+    const match = stdout.match(/prowl-macdriver\s+(\S+)/);
+    return match ? match[1] : stdout.trim() || null;
+  } catch {
+    return null;
+  }
+};
+async function collectMacdriverStatus(options = {}) {
+  const env = options.env ?? process.env;
+  const homedir = options.homedir ?? import_node_os3.default.homedir();
+  const probe = options.probe ?? runVersionProbe;
+  let resolved = null;
+  try {
+    const resolvedPath = resolveHelperBinary(env, { homedir });
+    resolved = { path: resolvedPath, source: classifyResolvedSource(resolvedPath, env, homedir) };
+  } catch {
+    resolved = null;
+  }
+  const installed = [];
+  const root = macdriverInstallRoot(homedir);
+  if (import_node_fs2.default.existsSync(root)) {
+    for (const entry of import_node_fs2.default.readdirSync(root, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      let binaryPath;
+      try {
+        binaryPath = macdriverInstalledBinary(entry.name, homedir);
+      } catch {
+        continue;
+      }
+      if (import_node_fs2.default.existsSync(binaryPath)) {
+        installed.push({ version: entry.name, binaryPath });
+      }
+    }
+    installed.sort((a, b) => a.version.localeCompare(b.version));
+  }
+  const probedVersion = resolved ? await probe(resolved.path) : null;
+  return { resolved, pinnedVersion: MACDRIVER_VERSION, installed, probedVersion };
+}
+function classifyResolvedSource(resolvedPath, env, homedir) {
+  if (env.PROWL_MACDRIVER_BIN && resolvedPath === env.PROWL_MACDRIVER_BIN) {
+    return "env";
+  }
+  if (resolvedPath.startsWith(macdriverInstallRoot(homedir) + import_node_path3.default.sep)) {
+    return "user-install";
+  }
+  return "source-build";
+}
+function tccGuidance() {
+  return "macOS permissions: the app that hosts Prowl (your terminal \u2014 Terminal, iTerm, VS Code, \u2026)\nmust be granted, in System Settings \u2192 Privacy & Security:\n  \u2022 Accessibility \u2014 required to drive the target app\n  \u2022 Screen Recording \u2014 required for screenshots / visual baselines\nGrant both to the terminal app, not to prowl-macdriver itself, then re-run your hunt.";
+}
+
+// src/browser/android-driver.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+
+// src/analyzer/xml.ts
+var ENTITIES = {
+  amp: "&",
+  lt: "<",
+  gt: ">",
+  quot: '"',
+  apos: "'"
+};
+function decodeXmlEntities(value) {
+  if (!value.includes("&")) {
+    return value;
+  }
+  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;
+    }
+    const named = ENTITIES[code];
+    return named ?? match;
+  });
+}
+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 (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 root;
+}
+
+// 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);
+  }
+  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"
+      )
+    );
+  }
+  if (trimmed === ":focus") {
+    return { kind: "focused" };
+  }
+  const idMatch = /^id=(.+)$/s.exec(trimmed);
+  if (idMatch) {
+    return { kind: "id", value: unquoteSelectorValue(idMatch[1]) };
+  }
+  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;
+}
+var NATIVE_ATTRIBUTE_MAP = {
+  android: {
+    id: { attribute: "resource-id", match: "exact (package-qualified)" },
+    label: { attribute: "content-desc", match: "exact" },
+    text: { attribute: "text", match: "substring" },
+    role: { attribute: "class", match: "exact" }
+  },
+  ios: {
+    id: { attribute: "accessibility id (name)", match: "exact" },
+    label: { attribute: "label", match: "exact" },
+    text: { attribute: "label | value", match: "substring" },
+    role: { attribute: "type (XCUIElementType\u2026)", match: "exact" }
+  },
+  macos: {
+    id: { attribute: "AXIdentifier", match: "exact" },
+    label: { attribute: "title | description", match: "exact" },
+    text: { attribute: "title | description | value", match: "substring" },
+    role: { attribute: "AXRole", match: "exact" }
+  }
+};
+var ANDROID_MATCH_DIALECT = {
+  platform: "android",
+  normalizeRole: (role) => role,
+  normalizeId: (value, options) => qualifyResourceId(value, options.appPackage)
+};
+var IOS_MATCH_DIALECT = {
+  platform: "ios",
+  normalizeRole: (role) => normalizeXcuiClassName(role),
+  normalizeId: (value) => value
+};
+var MACOS_MATCH_DIALECT = {
+  platform: "macos",
+  normalizeRole: (role) => role,
+  normalizeId: (value) => value
+};
+function nodeMatchesSelector(dialect, selector, node, options = {}) {
+  switch (selector.kind) {
+    case "id":
+      return node.id !== void 0 && node.id === dialect.normalizeId(selector.value, options);
+    case "label":
+      return node.label !== void 0 && node.label === selector.value;
+    case "text":
+      return node.textValues.some((t) => t.includes(selector.value));
+    case "focused":
+      return node.focused === true;
+    case "role": {
+      if (node.role === void 0) {
+        return false;
+      }
+      if (dialect.normalizeRole(node.role) !== dialect.normalizeRole(selector.role)) {
+        return false;
+      }
+      if (selector.name === void 0 || selector.name.length === 0) {
+        return true;
+      }
+      const name = selector.name;
+      return node.textValues.some((t) => t.includes(name));
+    }
+  }
+}
+function matchNativeTree(dialect, selector, root, project, children, options = {}) {
+  const out = [];
+  const visit = (node) => {
+    if (nodeMatchesSelector(dialect, selector, project(node), options)) {
+      out.push(node);
+    }
+    for (const child of children(node)) {
+      visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+function parseSnapshot(xml) {
+  return parseXml(xml);
+}
+
+// src/browser/android-driver.ts
 var ANDROID_CAPABILITIES = /* @__PURE__ */ new Set([
   "query",
   "interact",
@@ -605,50 +1292,29 @@ var ANDROID_KEYCODES = {
   pageup: 92,
   pagedown: 93
 };
-function unquote2(value) {
-  const trimmed = value.trim();
-  const first = trimmed[0];
-  if ((first === '"' || first === "'") && trimmed.endsWith(first) && trimmed.length >= 2) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
 function escapeUiSelectorArg(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
-function parseAndroidSelector(selector) {
-  const trimmed = selector.trim();
-  if (trimmed === ":focus") {
-    return { by: "focused" };
-  }
-  const idMatch = /^id=(.+)$/s.exec(trimmed);
-  if (idMatch) {
-    return { by: "id", value: unquote2(idMatch[1]) };
-  }
-  const roleMatch = /^role=([A-Za-z][\w.$-]*)(?:\[name=(.+)\])?$/s.exec(trimmed);
-  if (roleMatch) {
-    const name = roleMatch[2] !== void 0 ? unquote2(roleMatch[2]) : void 0;
-    return name !== void 0 && name.length > 0 ? { by: "role", role: roleMatch[1], name } : { by: "role", role: roleMatch[1] };
-  }
-  const labelMatch = /^label=(.+)$/s.exec(trimmed);
-  if (labelMatch) {
-    return { by: "accessibilityId", value: unquote2(labelMatch[1]) };
-  }
-  const textMatch = /^text=(.+)$/s.exec(trimmed);
-  if (textMatch) {
-    return { by: "text", value: unquote2(textMatch[1]) };
+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 };
   }
-  return { by: "text", value: trimmed };
+}
+function parseAndroidSelector(selector) {
+  return toAndroidQuery(parseNativeSelector(selector));
 }
 function locator(strategy, selector) {
   return { strategy, selector, context: "" };
 }
-function qualifyResourceId(value, appPackage) {
-  if (value.includes(":") || !appPackage) {
-    return value;
-  }
-  return `${appPackage}:id/${value}`;
-}
 function androidQueryToLocator(query, options = {}) {
   switch (query.by) {
     case "id":
@@ -675,11 +1341,7 @@ function androidQueryToLocator(query, options = {}) {
   }
 }
 function unwrapAndroidTextSelector(selector) {
-  const trimmed = selector.trim();
-  if (!trimmed.startsWith("text=")) {
-    return null;
-  }
-  return unquote2(trimmed.slice(5));
+  return unwrapNativeTextSelector(selector);
 }
 function keyCodeFor(key) {
   const code = ANDROID_KEYCODES[key.trim().toLowerCase()];
@@ -805,7 +1467,7 @@ function createAndroidDriver(client, options = {}) {
     },
     async screenshot(screenshotOptions) {
       const png = await client.screenshotPng();
-      import_node_fs2.default.writeFileSync(screenshotOptions.path, png);
+      import_node_fs3.default.writeFileSync(screenshotOptions.path, png);
     },
     // network / dialogs / downloads (all web-only) -------------------------
     onResponse(_handler) {
@@ -831,14 +1493,14 @@ function createAndroidDriver(client, options = {}) {
 
 // src/browser/android-helper.ts
 var import_node_module = require("module");
-var import_node_child_process4 = require("child_process");
-var import_node_fs4 = __toESM(require("fs"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_child_process5 = require("child_process");
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 
 // src/browser/android-adb.ts
-var import_node_child_process2 = require("child_process");
+var import_node_child_process3 = require("child_process");
 var execFileAdbRunner = (args, options) => new Promise((resolve) => {
-  (0, import_node_child_process2.execFile)(
+  (0, import_node_child_process3.execFile)(
     "adb",
     args,
     { encoding: "utf-8", timeout: options?.timeoutMs, maxBuffer: 16 * 1024 * 1024 },
@@ -854,7 +1516,7 @@ var execFileAdbRunner = (args, options) => new Promise((resolve) => {
   );
 });
 var spawnAdbProcess = (args) => {
-  const child = (0, import_node_child_process2.spawn)("adb", args, { stdio: "ignore" });
+  const child = (0, import_node_child_process3.spawn)("adb", args, { stdio: "ignore" });
   child.on("error", () => {
   });
   return { kill: () => child.kill() };
@@ -960,22 +1622,63 @@ async function installApk(runner, serial, apkPath) {
     );
   }
 }
+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) {
-  const result = await runner(
-    withSerial(serial, [
-      "shell",
-      "monkey",
-      "-p",
-      pkg,
-      "-c",
-      "android.intent.category.LAUNCHER",
-      "1"
-    ]),
-    { timeoutMs: 3e4 }
-  );
-  if (result.code !== 0 || /no activities found|aborted|cannot launch/i.test(result.stdout + result.stderr)) {
+  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}" (exit ${result.code}): ${(result.stdout + result.stderr).trim().slice(0, 400)}. Is it installed?`
+      `Failed to launch Android package "${pkg}" (${component}, exit ${start.code}): ${(start.stdout + start.stderr).trim().slice(0, 400)}.`
     );
   }
 }
@@ -1037,12 +1740,12 @@ var Uia2Transport = class {
    * {@link Uia2HttpError} on a non-2xx response, or a timeout error when the
    * per-request deadline elapses.
    */
-  async request(method, path18, body, timeoutMs) {
+  async request(method, path20, body, timeoutMs) {
     const requestTimeoutMs = timeoutMs ?? this.requestTimeoutMs;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
     timer.unref?.();
-    const url = `${this.baseUrl}${path18}`;
+    const url = `${this.baseUrl}${path20}`;
     let response;
     try {
       response = await this.fetchImpl(url, {
@@ -1054,7 +1757,7 @@ var Uia2Transport = class {
     } catch (error) {
       if (controller.signal.aborted) {
         const shown = requestTimeoutMs >= 1e3 ? `${Math.round(requestTimeoutMs / 1e3)}s` : `${requestTimeoutMs}ms`;
-        throw new Error(`uiautomator2 request ${method} ${path18} timed out after ${shown}`);
+        throw new Error(`uiautomator2 request ${method} ${path20} timed out after ${shown}`);
       }
       throw error instanceof Error ? error : new Error(String(error));
     } finally {
@@ -1065,7 +1768,7 @@ var Uia2Transport = class {
     if (!response.ok) {
       const wdError = extractWebdriverError(parsed);
       throw new Uia2HttpError(
-        `uiautomator2 ${method} ${path18} failed (${response.status})${wdError ? `: ${wdError}` : ""}`,
+        `uiautomator2 ${method} ${path20} failed (${response.status})${wdError ? `: ${wdError}` : ""}`,
         response.status,
         wdError
       );
@@ -1148,10 +1851,10 @@ function sleep(ms) {
 }
 function createUia2AgentClient(transport, sessionId, options = {}) {
   const base = `/session/${sessionId}`;
-  async function locate(query, path18) {
+  async function locate(query, path20) {
     return transport.request(
       "POST",
-      `${base}${path18}`,
+      `${base}${path20}`,
       androidQueryToLocator(query, { appPackage: options.appPackage })
     );
   }
@@ -1193,6 +1896,13 @@ function createUia2AgentClient(transport, sessionId, options = {}) {
       }
       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);
     }
@@ -1200,9 +1910,9 @@ function createUia2AgentClient(transport, sessionId, options = {}) {
 }
 
 // src/config/target.ts
-var import_node_child_process3 = require("child_process");
-var import_node_fs3 = __toESM(require("fs"), 1);
-var import_node_path2 = __toESM(require("path"), 1);
+var import_node_child_process4 = require("child_process");
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var WEB_ONLY_STEP_TYPES = /* @__PURE__ */ new Set([
   "navigate",
   "waitForUrl",
@@ -1287,7 +1997,7 @@ function looksLikeIosAppPath(app) {
   }
   if (trimmed.toLowerCase().endsWith(".app")) {
     try {
-      return import_node_fs3.default.statSync(normalizeAppPath(app)).isDirectory();
+      return import_node_fs4.default.statSync(normalizeAppPath(app)).isDirectory();
     } catch {
       return false;
     }
@@ -1295,29 +2005,29 @@ function looksLikeIosAppPath(app) {
   return false;
 }
 function normalizeAppPath(app) {
-  return import_node_path2.default.resolve(trimTrailingPathSeparators(app));
+  return import_node_path4.default.resolve(trimTrailingPathSeparators(app));
 }
 function parseBundleIdentifier(plist) {
   const match = /<key>\s*CFBundleIdentifier\s*<\/key>\s*<string>\s*([^<]+?)\s*<\/string>/s.exec(plist);
   return match?.[1]?.trim() || null;
 }
 function readBundleIdentifier(appPath, ...plistSubPath) {
-  const infoPlistPath = import_node_path2.default.join(normalizeAppPath(appPath), ...plistSubPath);
-  if (!import_node_fs3.default.existsSync(infoPlistPath)) {
+  const infoPlistPath = import_node_path4.default.join(normalizeAppPath(appPath), ...plistSubPath);
+  if (!import_node_fs4.default.existsSync(infoPlistPath)) {
     return null;
   }
   try {
-    const parsed = parseBundleIdentifier(import_node_fs3.default.readFileSync(infoPlistPath, "utf-8"));
+    const parsed = parseBundleIdentifier(import_node_fs4.default.readFileSync(infoPlistPath, "utf-8"));
     if (parsed) {
       return parsed;
     }
   } catch {
   }
-  if (process.platform !== "darwin" || !import_node_fs3.default.existsSync("/usr/bin/plutil")) {
+  if (process.platform !== "darwin" || !import_node_fs4.default.existsSync("/usr/bin/plutil")) {
     return null;
   }
   try {
-    const output = (0, import_node_child_process3.execFileSync)(
+    const output = (0, import_node_child_process4.execFileSync)(
       "/usr/bin/plutil",
       ["-extract", "CFBundleIdentifier", "raw", "-o", "-", infoPlistPath],
       { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"], timeout: 1e3 }
@@ -1339,7 +2049,7 @@ function appBundleAllowedIdentities(app, readBundleId, isAppPath = looksLikeAppB
     const normalizedPath = normalizeAppPath(app);
     identities.add(trimTrailingPathSeparators(app));
     identities.add(normalizedPath);
-    const bundleName = import_node_path2.default.basename(normalizedPath).replace(/\.app$/i, "");
+    const bundleName = import_node_path4.default.basename(normalizedPath).replace(/\.app$/i, "");
     if (bundleName) {
       identities.add(bundleName);
     }
@@ -1367,9 +2077,9 @@ function looksLikeApkPath(app) {
   return trimmed.includes("/") || trimmed.includes("\\") || trimmed.toLowerCase().endsWith(".apk");
 }
 function normalizeAndroidApkPath(app) {
-  const resolved = import_node_path2.default.resolve(trimTrailingPathSeparators(app));
+  const resolved = import_node_path4.default.resolve(trimTrailingPathSeparators(app));
   try {
-    return import_node_fs3.default.realpathSync.native(resolved);
+    return import_node_fs4.default.realpathSync.native(resolved);
   } catch {
     return resolved;
   }
@@ -1412,12 +2122,12 @@ function resolveAgentApks(requireFn = (0, import_node_module.createRequire)(impo
       "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_path3.default.dirname(pkgJsonPath);
+  const pkgDir = import_node_path5.default.dirname(pkgJsonPath);
   const version = requireFn(pkgJsonPath).version;
-  const serverApk = import_node_path3.default.join(pkgDir, "apks", `appium-uiautomator2-server-v${version}.apk`);
-  const testApk = import_node_path3.default.join(pkgDir, "apks", "appium-uiautomator2-server-debug-androidTest.apk");
+  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_fs4.default.existsSync(apk)) {
+    if (!import_node_fs5.default.existsSync(apk)) {
       throw new Error(`Expected uiautomator2 agent APK is missing: ${apk}. Reinstall dependencies.`);
     }
   }
@@ -1429,7 +2139,7 @@ function looksLikeApk(app) {
 var execFileAaptResolver = async (apkPath) => {
   for (const tool of ["aapt", "aapt2"]) {
     const output = await new Promise((resolve) => {
-      (0, import_node_child_process4.execFile)(
+      (0, import_node_child_process5.execFile)(
         tool,
         ["dump", "badging", apkPath],
         { encoding: "utf-8", timeout: 2e4, maxBuffer: 8 * 1024 * 1024 },
@@ -1463,8 +2173,8 @@ async function resolvePackage(app, runner, serial, aaptResolver, allowedApps) {
     assertAndroidAppAllowed(allowedApps, app);
     return app;
   }
-  const apkPath = import_node_path3.default.resolve(app);
-  if (!import_node_fs4.default.existsSync(apkPath)) {
+  const apkPath = import_node_path5.default.resolve(app);
+  if (!import_node_fs5.default.existsSync(apkPath)) {
     throw new Error(`APK not found: ${apkPath}`);
   }
   const pkg = await aaptResolver(apkPath);
@@ -1545,43 +2255,25 @@ var IOS_CAPABILITIES = /* @__PURE__ */ new Set([
 var WAIT_POLL_INTERVAL_MS2 = 250;
 var DEFAULT_WAIT_TIMEOUT_MS2 = 5e3;
 var IOS_PRESS_KEYS = ["backspace", "del", "delete", "enter", "home", "return"];
-function unquote3(value) {
-  const trimmed = value.trim();
-  const first = trimmed[0];
-  if ((first === '"' || first === "'") && trimmed.endsWith(first) && trimmed.length >= 2) {
-    return trimmed.slice(1, -1);
-  }
-  return trimmed;
-}
 function escapePredicateArg(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
-function normalizeXcuiClassName(role) {
-  return role.startsWith("XCUIElementType") ? role : `XCUIElementType${role}`;
+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) {
-  const trimmed = selector.trim();
-  if (trimmed === ":focus") {
-    return { by: "focused" };
-  }
-  const idMatch = /^id=(.+)$/s.exec(trimmed);
-  if (idMatch) {
-    return { by: "accessibilityId", value: unquote3(idMatch[1]) };
-  }
-  const roleMatch = /^role=([A-Za-z][\w.$-]*)(?:\[name=(.+)\])?$/s.exec(trimmed);
-  if (roleMatch) {
-    const name = roleMatch[2] !== void 0 ? unquote3(roleMatch[2]) : void 0;
-    return name !== void 0 && name.length > 0 ? { by: "role", role: roleMatch[1], name } : { by: "role", role: roleMatch[1] };
-  }
-  const labelMatch = /^label=(.+)$/s.exec(trimmed);
-  if (labelMatch) {
-    return { by: "label", value: unquote3(labelMatch[1]) };
-  }
-  const textMatch = /^text=(.+)$/s.exec(trimmed);
-  if (textMatch) {
-    return { by: "text", value: unquote3(textMatch[1]) };
-  }
-  return { by: "text", value: trimmed };
+  return toIosQuery(parseNativeSelector(selector));
 }
 function iosQueryToLocator(query) {
   switch (query.by) {
@@ -1613,11 +2305,7 @@ function iosQueryToLocator(query) {
   }
 }
 function unwrapIosTextSelector(selector) {
-  const trimmed = selector.trim();
-  if (!trimmed.startsWith("text=")) {
-    return null;
-  }
-  return unquote3(trimmed.slice(5));
+  return unwrapNativeTextSelector(selector);
 }
 function delay2(ms) {
   return new Promise((resolve) => {
@@ -1777,20 +2465,34 @@ function createIosDriver(client, options) {
 
 // src/browser/ios-helper.ts
 var import_node_module2 = require("module");
-var import_node_fs5 = __toESM(require("fs"), 1);
-var import_node_os2 = __toESM(require("os"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_child_process7 = require("child_process");
+var import_node_fs6 = __toESM(require("fs"), 1);
+var import_node_os5 = __toESM(require("os"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/browser/ios-simctl.ts
-var import_node_child_process5 = require("child_process");
+var import_node_child_process6 = 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_path4 = __toESM(require("path"), 1);
-var DEFAULT_SIMULATOR_LOCK_ROOT = import_node_path4.default.join(import_node_os.default.tmpdir(), "prowl-ios-simulator-locks");
+var import_node_os4 = __toESM(require("os"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var spawnXcrunProcess = (args, options) => {
+  const child = (0, import_node_child_process6.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_os4.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)(
+  (0, import_node_child_process6.execFile)(
     "xcrun",
     args,
     {
@@ -1827,7 +2529,7 @@ function isProcessAlive(pid) {
 }
 async function removeStaleSimulatorLock(lockPath) {
   try {
-    const ownerText = await (0, import_promises.readFile)(import_node_path4.default.join(lockPath, SIMULATOR_LOCK_OWNER_FILE), "utf8");
+    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 });
@@ -1845,7 +2547,7 @@ function simulatorReservedError(udid) {
 }
 async function reserveSimulatorUdid(udid, options = {}) {
   const lockRoot = options.lockRoot ?? DEFAULT_SIMULATOR_LOCK_ROOT;
-  const lockPath = import_node_path4.default.join(lockRoot, simulatorLockName(udid));
+  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 {
@@ -1869,7 +2571,7 @@ async function reserveSimulatorUdid(udid, options = {}) {
     };
     try {
       await (0, import_promises.writeFile)(
-        import_node_path4.default.join(lockPath, SIMULATOR_LOCK_OWNER_FILE),
+        import_node_path6.default.join(lockPath, SIMULATOR_LOCK_OWNER_FILE),
         `${JSON.stringify({ pid: process.pid, udid, createdAt: (/* @__PURE__ */ new Date()).toISOString() })}
 `,
         { flag: "wx" }
@@ -2061,15 +2763,15 @@ var WdaTransport = class {
    * {@link WdaHttpError} on a non-2xx response, or a timeout error when the
    * per-request deadline elapses.
    */
-  async requestFull(method, path18, body, timeoutMs) {
+  async requestFull(method, path20, body, timeoutMs) {
     const requestTimeoutMs = timeoutMs ?? this.requestTimeoutMs;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
     timer.unref?.();
-    const url = `${this.baseUrl}${path18}`;
+    const url = `${this.baseUrl}${path20}`;
     const timeoutError = () => {
       const shown = requestTimeoutMs >= 1e3 ? `${Math.round(requestTimeoutMs / 1e3)}s` : `${requestTimeoutMs}ms`;
-      return new Error(`WebDriverAgent request ${method} ${path18} timed out after ${shown}`);
+      return new Error(`WebDriverAgent request ${method} ${path20} timed out after ${shown}`);
     };
     let response;
     try {
@@ -2101,7 +2803,7 @@ var WdaTransport = class {
     if (!response.ok) {
       const wdError = extractWebdriverError2(parsed);
       throw new WdaHttpError(
-        `WebDriverAgent ${method} ${path18} failed (${response.status})${wdError ? `: ${wdError}` : ""}`,
+        `WebDriverAgent ${method} ${path20} failed (${response.status})${wdError ? `: ${wdError}` : ""}`,
         response.status,
         wdError
       );
@@ -2109,8 +2811,8 @@ var WdaTransport = class {
     return parsed;
   }
   /** Like {@link requestFull} but returns just the `value` field. */
-  async request(method, path18, body, timeoutMs) {
-    const parsed = await this.requestFull(method, path18, body, timeoutMs);
+  async request(method, path20, body, timeoutMs) {
+    const parsed = await this.requestFull(method, path20, body, timeoutMs);
     return parsed?.value;
   }
 };
@@ -2186,8 +2888,8 @@ function sleep2(ms) {
 }
 function createWdaAgentClient(transport, sessionId) {
   const base = `/session/${sessionId}`;
-  async function locate(query, path18) {
-    return transport.request("POST", `${base}${path18}`, iosQueryToLocator(query));
+  async function locate(query, path20) {
+    return transport.request("POST", `${base}${path20}`, iosQueryToLocator(query));
   }
   return {
     async findElement(query) {
@@ -2223,6 +2925,13 @@ function createWdaAgentClient(transport, sessionId) {
     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);
     }
@@ -2232,8 +2941,8 @@ function createWdaAgentClient(transport, sessionId) {
 // src/browser/ios-helper.ts
 var import_meta3 = {};
 var WDA_RUNNER_BUNDLE_ID = "com.facebook.WebDriverAgentRunner.xctrunner";
-var WDA_RUNNER_APP_NAME = "WebDriverAgentRunner-Runner.app";
 var WDA_USE_PORT_ENV = "USE_PORT";
+var PREPARED_XCTESTRUN_PREFIX = "prowl-wda-xctestrun-";
 var WDA_STARTUP_ATTEMPTS = 2;
 var defaultIosAgentConnector = async ({
   host,
@@ -2256,32 +2965,63 @@ function resolveWdaProject(requireFn = (0, import_node_module2.createRequire)(im
       "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_path5.default.dirname(pkgJsonPath);
+  const pkgDir = import_node_path7.default.dirname(pkgJsonPath);
   const version = requireFn(pkgJsonPath).version;
-  const projectPath = import_node_path5.default.join(pkgDir, "WebDriverAgent.xcodeproj");
-  if (!import_node_fs5.default.existsSync(projectPath)) {
+  const projectPath = import_node_path7.default.join(pkgDir, "WebDriverAgent.xcodeproj");
+  if (!import_node_fs6.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_path5.default.join(homeDir, ".prowl", "wda", `${wdaVersion}-xcode${xcode}`);
+function wdaCacheDir(wdaVersion, xcode, homeDir = import_node_os5.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_fs6.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 runnerAppPath(derivedDataPath) {
-  return import_node_path5.default.join(derivedDataPath, "Build", "Products", "Debug-iphonesimulator", WDA_RUNNER_APP_NAME);
+function resolveOverrideXctestrun(override) {
+  if (!import_node_fs6.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_fs6.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 resolveWdaRunner(options = {}) {
+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 homeDir = options.homeDir ?? import_node_os5.default.homedir();
   const log = options.logger ?? ((message) => process.stderr.write(`${message}
 `));
   const override = env.PROWL_WDA_RUNNER;
   if (override) {
-    if (!import_node_fs5.default.existsSync(override)) {
-      throw new Error(`PROWL_WDA_RUNNER points at a missing path: ${override}`);
-    }
-    return override;
+    return resolveOverrideXctestrun(override);
   }
   const { projectPath, version } = resolveWdaProject(options.requireFn);
   const xcode = await xcodeVersion(runner);
@@ -2291,14 +3031,14 @@ async function resolveWdaRunner(options = {}) {
     );
   }
   const cacheDir = wdaCacheDir(version, xcode, homeDir);
-  const cachedRunner = runnerAppPath(cacheDir);
-  if (import_node_fs5.default.existsSync(cachedRunner)) {
-    return cachedRunner;
+  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_fs5.default.mkdirSync(cacheDir, { recursive: true });
+  import_node_fs6.default.mkdirSync(cacheDir, { recursive: true });
   const result = await runner(
     [
       "xcodebuild",
@@ -2320,12 +3060,106 @@ async function resolveWdaRunner(options = {}) {
       `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)}`
     );
   }
-  if (!import_node_fs5.default.existsSync(cachedRunner)) {
+  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(
-      `WebDriverAgent build succeeded but the runner app was not found at ${cachedRunner}. This may indicate an Xcode layout change; set PROWL_WDA_RUNNER to a prebuilt runner.`
+      "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_process7.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_os5.default.tmpdir(), `${stem}.json`);
+  import_node_fs6.default.writeFileSync(jsonPath, JSON.stringify(injected));
+  try {
+    await runPlutil(["-convert", "xml1", jsonPath, "-o", outPath]);
+  } finally {
+    import_node_fs6.default.rmSync(jsonPath, { force: true });
+  }
+  return outPath;
+};
+function cleanupPreparedTestRun(preparedPath) {
+  if (!preparedPath) {
+    return;
   }
-  return cachedRunner;
+  if (!import_node_path7.default.basename(preparedPath).startsWith(PREPARED_XCTESTRUN_PREFIX)) {
+    return;
+  }
+  import_node_fs6.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)) {
@@ -2337,8 +3171,8 @@ async function resolveBundleId(app, runner, udid, coldStart, allowedApps) {
     }
     return app;
   }
-  const appPath = import_node_path5.default.resolve(app);
-  if (!import_node_fs5.default.existsSync(appPath)) {
+  const appPath = import_node_path7.default.resolve(app);
+  if (!import_node_fs6.default.existsSync(appPath)) {
     throw new Error(`.app bundle not found: ${appPath}`);
   }
   const bundleId = readIosBundleIdentifier(appPath);
@@ -2356,6 +3190,8 @@ async function resolveBundleId(app, runner, udid, coldStart, allowedApps) {
 }
 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;
@@ -2379,14 +3215,14 @@ async function launchIosSession(options) {
       options.coldStart ?? false,
       options.allowedApps ?? []
     );
-    const wdaRunnerApp = options.wdaRunnerApp ?? await resolveWdaRunner({ runner, logger: options.logger });
-    await installApp(runner, udid, wdaRunnerApp);
+    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 terminateWda = false;
       let terminateTarget = false;
-      let stage = "port";
+      let stage = "prepare";
       const teardownAttempt = async () => {
         if (tornDown) {
           return;
@@ -2395,18 +3231,18 @@ async function launchIosSession(options) {
         if (client) {
           await client.close().catch(() => void 0);
         }
-        if (terminateWda) {
-          await terminateApp(runner, udid, WDA_RUNNER_BUNDLE_ID);
-        }
+        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";
-        terminateWda = true;
-        await launchApp(runner, udid, WDA_RUNNER_BUNDLE_ID, { [WDA_USE_PORT_ENV]: String(port) });
+        wdaProcess = spawner(wdaTestRunArgs(preparedTestRun, udid));
         stage = "target-launch";
         terminateTarget = true;
         await launchApp(runner, udid, bundleId);
@@ -2439,12 +3275,12 @@ async function closeIosSession(session) {
 }
 
 // src/runner/index.ts
-var import_node_fs14 = __toESM(require("fs"), 1);
-var import_node_path14 = __toESM(require("path"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
+var import_node_path16 = __toESM(require("path"), 1);
 
 // src/config/loader.ts
-var import_node_fs6 = __toESM(require("fs"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_yaml = __toESM(require("yaml"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
 
@@ -2462,7 +3298,7 @@ function isValidHuntName(name) {
 function assertValidHuntName(name) {
   if (!isValidHuntName(name)) {
     throw new Error(
-      `Invalid hunt name: "${name}". Use only letters, numbers, hyphens, underscores, and forward slashes.`
+      `Invalid hunt name: "${name}". A hunt name is its file name under .prowl/hunts/ (letters, numbers, hyphens, underscores, and forward slashes for nested hunts). Accepted forms: a bare name (homepage), a nested name (admin/users), or a path (.prowl/hunts/homepage.yml or hunts/homepage.yml).`
     );
   }
 }
@@ -2713,6 +3549,9 @@ var assertScreenshotStepSchema = import_zod.z.object({
     threshold: import_zod.z.number().min(0).max(1).optional()
   }).strict()
 }).strict();
+var assertWithAiStepSchema = import_zod.z.object({
+  assertWithAI: import_zod.z.string().min(1)
+}).strict();
 var copyTextStepSchema = import_zod.z.object({
   copyText: import_zod.z.object({
     selector: import_zod.z.string().min(1),
@@ -2755,6 +3594,7 @@ var stepSchema = import_zod.z.union([
   evalScriptStepSchema,
   runScriptStepSchema,
   assertScreenshotStepSchema,
+  assertWithAiStepSchema,
   copyTextStepSchema,
   waitForDownloadStepSchema
 ]);
@@ -2835,12 +3675,12 @@ function findConfigPath(startDir) {
   let current = startDir;
   while (current) {
     for (const dir of [CONFIG_DIR, LEGACY_CONFIG_DIR]) {
-      const candidate = import_node_path6.default.join(current, dir, "config.yml");
-      if (import_node_fs6.default.existsSync(candidate)) {
+      const candidate = import_node_path8.default.join(current, dir, "config.yml");
+      if (import_node_fs7.default.existsSync(candidate)) {
         return candidate;
       }
     }
-    const parent = import_node_path6.default.dirname(current);
+    const parent = import_node_path8.default.dirname(current);
     if (parent === current) {
       break;
     }
@@ -2947,19 +3787,19 @@ function ensureAllowedDomain(allowed, urlValue) {
   return allowed;
 }
 function loadConfig(configPath) {
-  const resolvedPath = configPath ? import_node_path6.default.resolve(configPath) : findConfigPath(process.cwd());
+  const resolvedPath = configPath ? import_node_path8.default.resolve(configPath) : findConfigPath(process.cwd());
   if (!resolvedPath) {
     throw new Error("Could not find .prowl/config.yml. Run `prowl init` first.");
   }
-  if (!import_node_fs6.default.existsSync(resolvedPath)) {
+  if (!import_node_fs7.default.existsSync(resolvedPath)) {
     throw new Error(`Config file not found at ${resolvedPath}`);
   }
-  const configDir = import_node_path6.default.dirname(resolvedPath);
-  if (import_node_path6.default.basename(configDir) === LEGACY_CONFIG_DIR) {
+  const configDir = import_node_path8.default.dirname(resolvedPath);
+  if (import_node_path8.default.basename(configDir) === LEGACY_CONFIG_DIR) {
     warnLegacyConfigDir();
   }
-  import_dotenv.default.config({ path: import_node_path6.default.join(configDir, ".env"), override: false });
-  const raw = import_node_fs6.default.readFileSync(resolvedPath, "utf-8");
+  import_dotenv.default.config({ path: import_node_path8.default.join(configDir, ".env"), override: false });
+  const raw = import_node_fs7.default.readFileSync(resolvedPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   const validated = configSchema.parse(parsed);
   const config = mergeConfig(validated);
@@ -2973,32 +3813,32 @@ function loadConfig(configPath) {
 }
 function loadHunt(huntName, configDir) {
   assertValidHuntName(huntName);
-  const huntPath = import_node_path6.default.join(configDir, "hunts", `${huntName}.yml`);
-  if (!import_node_fs6.default.existsSync(huntPath)) {
+  const huntPath = import_node_path8.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs7.default.existsSync(huntPath)) {
     throw new Error(`Hunt file not found: ${huntPath}`);
   }
-  const raw = import_node_fs6.default.readFileSync(huntPath, "utf-8");
+  const raw = import_node_fs7.default.readFileSync(huntPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   const validated = huntSchema.parse(parsed);
   return validated;
 }
 function loadHuntTags(huntName, configDir) {
   assertValidHuntName(huntName);
-  const huntPath = import_node_path6.default.join(configDir, "hunts", `${huntName}.yml`);
-  if (!import_node_fs6.default.existsSync(huntPath)) {
+  const huntPath = import_node_path8.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs7.default.existsSync(huntPath)) {
     return [];
   }
-  const raw = import_node_fs6.default.readFileSync(huntPath, "utf-8");
+  const raw = import_node_fs7.default.readFileSync(huntPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   return Array.isArray(parsed.tags) ? parsed.tags : [];
 }
 function loadHuntMeta(huntName, configDir) {
   assertValidHuntName(huntName);
-  const huntPath = import_node_path6.default.join(configDir, "hunts", `${huntName}.yml`);
-  if (!import_node_fs6.default.existsSync(huntPath)) {
+  const huntPath = import_node_path8.default.join(configDir, "hunts", `${huntName}.yml`);
+  if (!import_node_fs7.default.existsSync(huntPath)) {
     return { tags: [] };
   }
-  const raw = import_node_fs6.default.readFileSync(huntPath, "utf-8");
+  const raw = import_node_fs7.default.readFileSync(huntPath, "utf-8");
   const parsed = import_yaml.default.parse(raw) ?? {};
   return {
     description: typeof parsed.description === "string" ? parsed.description : void 0,
@@ -3006,24 +3846,24 @@ function loadHuntMeta(huntName, configDir) {
   };
 }
 function listHunts(configDir) {
-  const huntsDir = import_node_path6.default.join(configDir, "hunts");
-  if (!import_node_fs6.default.existsSync(huntsDir)) {
+  const huntsDir = import_node_path8.default.join(configDir, "hunts");
+  if (!import_node_fs7.default.existsSync(huntsDir)) {
     return [];
   }
-  const stats = import_node_fs6.default.statSync(huntsDir);
+  const stats = import_node_fs7.default.statSync(huntsDir);
   if (!stats.isDirectory()) {
     throw new Error(`Hunts path is not a directory: ${huntsDir}`);
   }
   const results = [];
   function scanDir(dir) {
-    const entries = import_node_fs6.default.readdirSync(dir, { withFileTypes: true });
+    const entries = import_node_fs7.default.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isFile() && entry.name.endsWith(".yml")) {
-        const fullPath = import_node_path6.default.join(dir, entry.name);
-        const relative = import_node_path6.default.relative(huntsDir, fullPath);
+        const fullPath = import_node_path8.default.join(dir, entry.name);
+        const relative = import_node_path8.default.relative(huntsDir, fullPath);
         results.push(relative.replace(/\.yml$/, ""));
       } else if (entry.isDirectory()) {
-        scanDir(import_node_path6.default.join(dir, entry.name));
+        scanDir(import_node_path8.default.join(dir, entry.name));
       }
     }
   }
@@ -3032,7 +3872,7 @@ function listHunts(configDir) {
 }
 
 // src/config/interpolate.ts
-var import_node_crypto = __toESM(require("crypto"), 1);
+var import_node_crypto2 = __toESM(require("crypto"), 1);
 var VAR_PATTERN = /\{\{([A-Z0-9_]+)\}\}/g;
 function collectInterpolatedValues(input, vars, values) {
   if (typeof input === "string") {
@@ -3071,8 +3911,8 @@ var RANDOM_FIRST_NAMES = ["Alex", "Jordan", "Morgan", "Taylor", "Casey", "Riley"
 var RANDOM_LAST_NAMES = ["Smith", "Johnson", "Brown", "Davis", "Wilson", "Clark", "Hall", "Young"];
 function generateRandomVars(randomSource) {
   const random = randomSource?.random ?? Math.random;
-  const randomBytes = randomSource?.randomBytes ?? import_node_crypto.default.randomBytes;
-  const randomUUID = randomSource?.randomUUID ?? import_node_crypto.default.randomUUID;
+  const randomBytes = randomSource?.randomBytes ?? import_node_crypto2.default.randomBytes;
+  const randomUUID = randomSource?.randomUUID ?? import_node_crypto2.default.randomUUID;
   const hex = randomBytes(4).toString("hex");
   const firstIndex = Math.floor(random() * RANDOM_FIRST_NAMES.length);
   const lastIndex = Math.floor(random() * RANDOM_LAST_NAMES.length);
@@ -3325,6 +4165,11 @@ function interpolateStep(step, vars, stepPath2, redacted) {
       }
     };
   }
+  if ("assertWithAI" in step) {
+    return {
+      assertWithAI: interpolateString(step.assertWithAI, vars).value
+    };
+  }
   if ("copyText" in step) {
     return {
       copyText: {
@@ -3398,8 +4243,8 @@ function interpolateHunt(hunt, env, randomVars = generateRandomVars()) {
 }
 
 // src/browser/playwright-driver.ts
-var import_node_fs7 = __toESM(require("fs"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 var import_playwright = require("playwright");
 var ENGINES = { chromium: import_playwright.chromium, firefox: import_playwright.firefox, webkit: import_playwright.webkit };
 async function launchBrowser(options) {
@@ -3421,14 +4266,14 @@ async function launchBrowser(options) {
       contextOptions.viewport = options.viewport;
     }
     if (options.storageStatePath) {
-      if (import_node_fs7.default.existsSync(options.storageStatePath)) {
+      if (import_node_fs8.default.existsSync(options.storageStatePath)) {
         contextOptions.storageState = options.storageStatePath;
       } else {
         console.warn(`Auth state file not found: ${options.storageStatePath}. Run "prowl login" to create it.`);
       }
     }
     if (options.recordHar) {
-      contextOptions.recordHar = { path: import_node_path7.default.join(options.runDir, "network.har") };
+      contextOptions.recordHar = { path: import_node_path9.default.join(options.runDir, "network.har") };
     }
     const context = await browser.newContext(contextOptions);
     const page = await context.newPage();
@@ -3436,7 +4281,7 @@ async function launchBrowser(options) {
     page.setDefaultNavigationTimeout(options.timeout);
     let tracePath;
     if (options.trace) {
-      tracePath = import_node_path7.default.join(options.runDir, "trace.zip");
+      tracePath = import_node_path9.default.join(options.runDir, "trace.zip");
       await context.tracing.start({ screenshots: true, snapshots: true, sources: true });
     }
     return { browser, context, page, tracePath };
@@ -3611,8 +4456,8 @@ function createPlaywrightDriver(page) {
 }
 
 // src/runner/steps.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 
 // src/runner/healing.ts
 var INTERACTIVE_TAGS = ["button", "a", "input", "select", "textarea"];
@@ -3756,14 +4601,254 @@ function createRunPolicy(driver, options) {
     return { selector: healed.selector, healedFrom: healed.healedFrom };
   }
   return {
-    assertWithinMaxSteps,
-    ensureUrlAllowed,
-    ensureAppAllowed,
-    ensureLocationAllowed,
-    assertAllowedSelector,
-    resolveActionSelector
+    assertWithinMaxSteps,
+    ensureUrlAllowed,
+    ensureAppAllowed,
+    ensureLocationAllowed,
+    assertAllowedSelector,
+    resolveActionSelector
+  };
+}
+
+// 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) {
@@ -3793,6 +4878,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";
@@ -3852,6 +4938,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 } };
   }
@@ -4102,7 +5191,7 @@ async function runInlineAssert(driver, policy, assertion) {
   throw new Error("assert step is missing an assertion type");
 }
 function screenshotPath(screenshotsDir, fileName) {
-  return import_node_path9.default.join(screenshotsDir, fileName);
+  return import_node_path11.default.join(screenshotsDir, fileName);
 }
 function stepPath(prefix, index) {
   return prefix ? `${prefix}.${index}` : `${index}`;
@@ -4119,7 +5208,7 @@ 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_path9.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
+  if (safeFilename.length === 0 || safeFilename !== suggestedFilename || safeFilename !== import_node_path11.default.basename(safeFilename) || safeFilename.includes("..") || /[/\\]/.test(safeFilename) || hasControlCharacter || !allowedFilenamePattern.test(safeFilename)) {
     throw new Error(`Invalid download filename: "${suggestedFilename}"`);
   }
   return safeFilename;
@@ -4299,7 +5388,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_path9.default.isAbsolute(f) ? f : import_node_path9.default.join(h.context.configDir, f);
+      const resolveFile = (f) => import_node_path11.default.isAbsolute(f) ? f : import_node_path11.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);
@@ -4661,15 +5750,15 @@ var STEP_HANDLERS = {
         if (!responseFile) {
           throw new Error("mock.response must include either body or file");
         }
-        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);
+        const candidateFilePath = import_node_path11.default.isAbsolute(responseFile) ? responseFile : import_node_path11.default.join(h.context.configDir, responseFile);
+        const resolvedConfigDir = import_node_path11.default.resolve(h.context.configDir);
+        const resolvedFilePath = import_node_path11.default.resolve(candidateFilePath);
+        const relativePath = import_node_path11.default.relative(resolvedConfigDir, resolvedFilePath);
+        const isWithinConfigDir = relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${import_node_path11.default.sep}`) && !import_node_path11.default.isAbsolute(relativePath);
         if (!isWithinConfigDir) {
           throw new Error("mock.response.file must resolve within config directory");
         }
-        responseBody = await import_node_fs9.default.promises.readFile(resolvedFilePath, "utf-8");
+        responseBody = await import_node_fs10.default.promises.readFile(resolvedFilePath, "utf-8");
       }
       const contentType = mock.response.contentType ?? "application/json";
       const status = mock.response.status;
@@ -4732,8 +5821,8 @@ var STEP_HANDLERS = {
     capabilities: ["evaluate"],
     run: async (h) => {
       if (!("runScript" in h.step)) unknownStep();
-      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");
+      const filePath = import_node_path11.default.isAbsolute(h.step.runScript.file) ? h.step.runScript.file : import_node_path11.default.join(h.context.configDir, h.step.runScript.file);
+      const fileContents = import_node_fs10.default.readFileSync(filePath, "utf-8");
       await h.driver.evaluate(fileContents);
       return {
         kind: "result",
@@ -4754,19 +5843,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_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 });
+      const baselinePath = import_node_path11.default.join(baselineDir, `${name}.png`);
+      const currentScreenshotPath = import_node_path11.default.join(h.context.runDir, "screenshots", `${name}-current.png`);
+      import_node_fs10.default.mkdirSync(import_node_path11.default.dirname(currentScreenshotPath), { recursive: true });
       await h.driver.screenshot({ path: currentScreenshotPath, fullPage: true });
-      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);
+      h.screenshots.push(import_node_path11.default.join("screenshots", `${name}-current.png`));
+      if (!import_node_fs10.default.existsSync(baselinePath)) {
+        import_node_fs10.default.copyFileSync(currentScreenshotPath, baselinePath);
         return {
           kind: "result",
           result: { type: "assertScreenshot", status: "pass", durationMs: Date.now() - h.stepStart, value: "baseline created" }
         };
       }
-      const diffPath = import_node_path9.default.join(h.context.runDir, "screenshots", `${name}-diff.png`);
+      const diffPath = import_node_path11.default.join(h.context.runDir, "screenshots", `${name}-diff.png`);
       const comparison = await compareScreenshots2(baselinePath, currentScreenshotPath, diffPath, threshold);
       if (comparison.match) {
         return {
@@ -4779,12 +5868,54 @@ var STEP_HANDLERS = {
           }
         };
       }
-      h.screenshots.push(import_node_path9.default.join("screenshots", `${name}-diff.png`));
+      h.screenshots.push(import_node_path11.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_path11.default.join(h.context.runDir, relative);
+      const imageBase64 = import_node_fs10.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) => {
@@ -4821,7 +5952,7 @@ var STEP_HANDLERS = {
           `Download filename mismatch: expected "${opts.filename}", got "${suggestedFilename}"`
         );
       }
-      const savePath = import_node_path9.default.join(h.context.runDir, suggestedFilename);
+      const savePath = import_node_path11.default.join(h.context.runDir, suggestedFilename);
       await download.saveAs(savePath);
       return {
         kind: "result",
@@ -4850,8 +5981,8 @@ async function executeSteps(context) {
     maxSteps: context.maxSteps,
     selfHealing: context.selfHealing
   });
-  const screenshotsDir = import_node_path9.default.join(context.runDir, "screenshots");
-  import_node_fs9.default.mkdirSync(screenshotsDir, { recursive: true });
+  const screenshotsDir = import_node_path11.default.join(context.runDir, "screenshots");
+  import_node_fs10.default.mkdirSync(screenshotsDir, { recursive: true });
   const currentHuntName = context.huntStack?.[context.huntStack.length - 1];
   policy.assertWithinMaxSteps(context.steps.length, currentHuntName);
   const results = [];
@@ -4861,7 +5992,7 @@ async function executeSteps(context) {
   const addScreenshot = async (fileName) => {
     const fullPath = screenshotPath(screenshotsDir, fileName);
     await captureScreenshot2(driver, fullPath);
-    const relative = import_node_path9.default.join("screenshots", fileName);
+    const relative = import_node_path11.default.join("screenshots", fileName);
     screenshots.push(relative);
     return relative;
   };
@@ -4949,12 +6080,12 @@ async function executeSteps(context) {
   return { results, screenshots, failed: false };
 }
 async function captureFinalScreenshot(page, runDir) {
-  const screenshotsDir = import_node_path9.default.join(runDir, "screenshots");
-  import_node_fs9.default.mkdirSync(screenshotsDir, { recursive: true });
+  const screenshotsDir = import_node_path11.default.join(runDir, "screenshots");
+  import_node_fs10.default.mkdirSync(screenshotsDir, { recursive: true });
   const fileName = "final.png";
   const filePath = screenshotPath(screenshotsDir, fileName);
   await captureScreenshot2(page, filePath);
-  return import_node_path9.default.join("screenshots", fileName);
+  return import_node_path11.default.join("screenshots", fileName);
 }
 
 // src/runner/assertions.ts
@@ -5076,6 +6207,59 @@ async function evaluateAssertions(options) {
   }
   return results;
 }
+async function evaluateNativeAssertions(options) {
+  const assertions = mergeAssertions(options.config, options.huntAssertions);
+  const authoredTypes = new Set(
+    (options.huntAssertions ?? []).map((assertion) => Object.keys(assertion)[0])
+  );
+  const results = [];
+  const warnings = [];
+  for (const assertion of assertions) {
+    const type = Object.keys(assertion)[0] ?? "assertion";
+    try {
+      if ("selectorExists" in assertion) {
+        options.assertAllowedSelector?.(assertion.selectorExists);
+        const count = await options.driver.count(assertion.selectorExists);
+        results.push({
+          type: "selectorExists",
+          value: assertion.selectorExists,
+          status: count > 0 ? "pass" : "fail",
+          error: count > 0 ? void 0 : "Selector not found"
+        });
+        continue;
+      }
+      if ("selectorNotExists" in assertion) {
+        options.assertAllowedSelector?.(assertion.selectorNotExists);
+        const count = await options.driver.count(assertion.selectorNotExists);
+        results.push({
+          type: "selectorNotExists",
+          value: assertion.selectorNotExists,
+          status: count === 0 ? "pass" : "fail",
+          error: count === 0 ? void 0 : "Selector exists"
+        });
+        continue;
+      }
+      const rawValue = assertion[type];
+      results.push({
+        type,
+        value: rawValue,
+        status: "skipped",
+        error: `skipped (web-only): not supported on the ${options.targetLabel} target`
+      });
+      if (authoredTypes.has(type)) {
+        warnings.push(`${type} is web-only; skipped on ${options.targetLabel} target`);
+      }
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : "no error details";
+      results.push({
+        type,
+        status: "fail",
+        error: `Native assertion "${type}" failed: ${detail}`
+      });
+    }
+  }
+  return { results, warnings };
+}
 
 // src/runner/tracing.ts
 var DEFAULT_TRACE_HEADER = "traceparent";
@@ -5114,18 +6298,18 @@ function captureTraceCorrelation(response, headerName, sink, redactionValues = [
 }
 
 // src/reporter/result.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 function writeResult(runDir, result) {
   const fileName = "result.json";
-  const fullPath = import_node_path10.default.join(runDir, fileName);
-  import_node_fs10.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
+  const fullPath = import_node_path12.default.join(runDir, fileName);
+  import_node_fs11.default.writeFileSync(fullPath, JSON.stringify(result, null, 2));
   return fileName;
 }
 
 // src/reporter/summary.ts
-var import_node_fs11 = __toESM(require("fs"), 1);
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path13 = __toESM(require("path"), 1);
 function escapeMd(text) {
   return text.replace(/([|`*_{}[\]()#+\-!\\])/g, "\\$1");
 }
@@ -5203,28 +6387,29 @@ function writeSummary(runDir, result) {
     }
   }
   const fileName = "summary.md";
-  const fullPath = import_node_path11.default.join(runDir, fileName);
-  import_node_fs11.default.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = import_node_path13.default.join(runDir, fileName);
+  import_node_fs12.default.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
 
 // src/reporter/junit.ts
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path12 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
+var import_node_path14 = __toESM(require("path"), 1);
 function escapeXml(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 function writeJunit(runDir, result) {
   const totalTests = result.steps.length + result.assertions.length;
   const failures = result.steps.filter((s) => s.status === "fail").length + result.assertions.filter((a) => a.status === "fail").length;
+  const skipped = result.assertions.filter((a) => a.status === "skipped").length;
   const timeSeconds = (result.durationMs / 1e3).toFixed(3);
   const huntName = escapeXml(result.hunt);
   const lines = [];
   lines.push('<?xml version="1.0" encoding="UTF-8"?>');
   lines.push("<testsuites>");
   lines.push(
-    `  <testsuite name="${huntName}" tests="${totalTests}" failures="${failures}" errors="0" time="${timeSeconds}" timestamp="${escapeXml(result.startedAt)}">`
+    `  <testsuite name="${huntName}" tests="${totalTests}" failures="${failures}" errors="0" skipped="${skipped}" time="${timeSeconds}" timestamp="${escapeXml(result.startedAt)}">`
   );
   for (let i = 0; i < result.steps.length; i++) {
     const step = result.steps[i];
@@ -5248,6 +6433,11 @@ function writeJunit(runDir, result) {
       lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="0">`);
       lines.push(`      <failure message="${escapedFailureText}" type="assertion">${escapedFailureText}</failure>`);
       lines.push("    </testcase>");
+    } else if (assertion.status === "skipped") {
+      const skipText = escapeXml(assertion.error ?? "skipped");
+      lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="0">`);
+      lines.push(`      <skipped message="${skipText}"/>`);
+      lines.push("    </testcase>");
     } else {
       lines.push(`    <testcase name="${caseName}" classname="${huntName}" time="0"/>`);
     }
@@ -5255,8 +6445,8 @@ function writeJunit(runDir, result) {
   lines.push("  </testsuite>");
   lines.push("</testsuites>");
   const fileName = "junit.xml";
-  const fullPath = import_node_path12.default.join(runDir, fileName);
-  import_node_fs12.default.writeFileSync(fullPath, `${lines.join("\n")}
+  const fullPath = import_node_path14.default.join(runDir, fileName);
+  import_node_fs13.default.writeFileSync(fullPath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -5290,15 +6480,15 @@ function timestamp(prefix) {
 }
 
 // src/runner/history.ts
-var import_node_fs13 = __toESM(require("fs"), 1);
-var import_node_path13 = __toESM(require("path"), 1);
+var import_node_fs14 = __toESM(require("fs"), 1);
+var import_node_path15 = __toESM(require("path"), 1);
 var 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_path13.default.join(configDir, HISTORY_FILE);
+  return import_node_path15.default.join(configDir, HISTORY_FILE);
 }
 function isHistoryEntry(value) {
   if (!value || typeof value !== "object") {
@@ -5309,11 +6499,11 @@ function isHistoryEntry(value) {
 }
 function readHistory(configDir) {
   const filePath = historyPath(configDir);
-  if (!import_node_fs13.default.existsSync(filePath)) {
+  if (!import_node_fs14.default.existsSync(filePath)) {
     return { entries: [] };
   }
   try {
-    const raw = import_node_fs13.default.readFileSync(filePath, "utf-8");
+    const raw = import_node_fs14.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);
@@ -5352,12 +6542,12 @@ function sleepSync(ms) {
 function withHistoryLock(configDir, fn) {
   const filePath = historyPath(configDir);
   const lockPath = `${filePath}${LOCK_FILE_SUFFIX}`;
-  import_node_fs13.default.mkdirSync(import_node_path13.default.dirname(filePath), { recursive: true });
+  import_node_fs14.default.mkdirSync(import_node_path15.default.dirname(filePath), { recursive: true });
   const startedAt = Date.now();
   while (Date.now() - startedAt < LOCK_TIMEOUT_MS) {
     let fd;
     try {
-      fd = import_node_fs13.default.openSync(lockPath, "wx");
+      fd = import_node_fs14.default.openSync(lockPath, "wx");
     } catch (error) {
       if (error.code === "EEXIST") {
         sleepSync(LOCK_RETRY_MS);
@@ -5369,10 +6559,10 @@ function withHistoryLock(configDir, fn) {
       return fn();
     } finally {
       try {
-        import_node_fs13.default.closeSync(fd);
+        import_node_fs14.default.closeSync(fd);
       } catch {
       }
-      import_node_fs13.default.rmSync(lockPath, { force: true });
+      import_node_fs14.default.rmSync(lockPath, { force: true });
     }
   }
   throw new Error(
@@ -5385,9 +6575,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_fs13.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
+    import_node_fs14.default.writeFileSync(tempPath, `${JSON.stringify({ entries: next }, null, 2)}
 `);
-    import_node_fs13.default.renameSync(tempPath, filePath);
+    import_node_fs14.default.renameSync(tempPath, filePath);
   });
 }
 
@@ -5400,11 +6590,11 @@ function parseViewportFlag(value) {
   return value;
 }
 function resolvePath(configDir, inputPath) {
-  if (import_node_path14.default.isAbsolute(inputPath)) {
+  if (import_node_path16.default.isAbsolute(inputPath)) {
     return inputPath;
   }
-  const projectRoot = import_node_path14.default.dirname(configDir);
-  return import_node_path14.default.join(projectRoot, inputPath);
+  const projectRoot = import_node_path16.default.dirname(configDir);
+  return import_node_path16.default.join(projectRoot, inputPath);
 }
 function buildRunResult(options) {
   return {
@@ -5423,12 +6613,12 @@ function buildRunResult(options) {
 }
 function writeConsoleLog(runDir, entries) {
   const fileName = "console.log";
-  const filePath = import_node_path14.default.join(runDir, fileName);
+  const filePath = import_node_path16.default.join(runDir, fileName);
   const lines = entries.map((entry) => {
     const location = entry.location ? ` (${entry.location})` : "";
     return `[${entry.type}] ${entry.text}${location}`;
   });
-  import_node_fs14.default.writeFileSync(filePath, `${lines.join("\n")}
+  import_node_fs15.default.writeFileSync(filePath, `${lines.join("\n")}
 `);
   return fileName;
 }
@@ -5436,8 +6626,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_path14.default.join(configDir, "runs", timestamp());
-  import_node_fs14.default.mkdirSync(runDir, { recursive: true });
+  const runDir = import_node_path16.default.join(configDir, "runs", timestamp());
+  import_node_fs15.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;
@@ -5620,8 +6810,8 @@ async function runHunt(options) {
 }
 async function executeNativeHuntAttempt(options, config, configDir, interpolatedHunt, redactedFillSteps, randomVars, allowedApps, native) {
   const maxSteps = config.guardrails.maxSteps;
-  const runDir = import_node_path14.default.join(configDir, "runs", timestamp());
-  import_node_fs14.default.mkdirSync(runDir, { recursive: true });
+  const runDir = import_node_path16.default.join(configDir, "runs", timestamp());
+  import_node_fs15.default.mkdirSync(runDir, { recursive: true });
   const session = await native.launchSession();
   let result;
   try {
@@ -5629,6 +6819,13 @@ async function executeNativeHuntAttempt(options, config, configDir, interpolated
     const appIdentity = native.sessionAppIdentity(session);
     const targetLabel = `${native.targetType}:${appIdentity}`;
     const effectiveAllowedApps = [.../* @__PURE__ */ new Set([...allowedApps, native.targetApp, appIdentity])];
+    const assertionPolicy = createRunPolicy(driver, {
+      forbiddenSelectors: config.guardrails.forbiddenSelectors,
+      allowedDomains: [],
+      allowedApps: effectiveAllowedApps,
+      maxSteps,
+      selfHealing: config.guardrails.selfHealing
+    });
     const startedAt = (/* @__PURE__ */ new Date()).toISOString();
     const startTime = Date.now();
     let stepResults = [];
@@ -5668,8 +6865,19 @@ async function executeNativeHuntAttempt(options, config, configDir, interpolated
     } catch {
       finalScreenshot = void 0;
     }
+    const { results: assertionResults, warnings: assertionWarnings } = await evaluateNativeAssertions({
+      driver,
+      config,
+      huntAssertions: interpolatedHunt.assertions,
+      assertAllowedSelector: assertionPolicy.assertAllowedSelector,
+      targetLabel: nativeTargetLabel(native.targetType)
+    });
+    for (const warning of assertionWarnings) {
+      console.warn(warning);
+    }
     const durationMs = Date.now() - startTime;
-    const status = stepFailed ? "fail" : "pass";
+    const assertionsFailed = assertionResults.some((assertion) => assertion.status === "fail");
+    const status = stepFailed || assertionsFailed ? "fail" : "pass";
     const artifacts = {
       screenshots: finalScreenshot ? [...stepScreenshots, finalScreenshot] : stepScreenshots
     };
@@ -5680,7 +6888,7 @@ async function executeNativeHuntAttempt(options, config, configDir, interpolated
       hunt: options.huntName,
       targetUrl: targetLabel,
       steps: stepResults,
-      assertions: [],
+      assertions: assertionResults,
       artifacts
     });
     result = writeReports(runDir, runResult, { junit: options.junit ?? config.artifacts.junit });
@@ -5793,7 +7001,6 @@ 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, native.targetType);
-  assertHuntAssertionsSupportedByTarget(interpolatedHunt.assertions, native.targetType);
   native.assertAppAllowed(config.guardrails.allowedApps, target);
   const maxSteps = config.guardrails.maxSteps;
   if (interpolatedHunt.steps.length > maxSteps) {
@@ -5834,7 +7041,7 @@ async function runNativeHunt(options, config, configDir, target, native) {
 }
 function recordHistory(configDir, outcome, maxRuns) {
   try {
-    const relativeRunDir = import_node_path14.default.relative(configDir, outcome.runDir);
+    const relativeRunDir = import_node_path16.default.relative(configDir, outcome.runDir);
     appendEntry(
       configDir,
       {
@@ -5851,11 +7058,11 @@ function recordHistory(configDir, outcome, maxRuns) {
 }
 
 // src/runner/suite.ts
-var import_node_path17 = __toESM(require("path"), 1);
+var import_node_path19 = __toESM(require("path"), 1);
 
 // src/reporter/ci-summary.ts
-var import_node_fs15 = __toESM(require("fs"), 1);
-var import_node_path15 = __toESM(require("path"), 1);
+var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
 var import_chalk = __toESM(require("chalk"), 1);
 function countCiResults(results) {
   return {
@@ -5885,9 +7092,9 @@ function writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky = []
     ...flaky.length > 0 ? { flaky } : {},
     ...clusters.length > 0 ? { clusters } : {}
   };
-  import_node_fs15.default.mkdirSync(ciRunDir, { recursive: true });
-  const filePath = import_node_path15.default.join(ciRunDir, "ci-result.json");
-  import_node_fs15.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
+  import_node_fs16.default.mkdirSync(ciRunDir, { recursive: true });
+  const filePath = import_node_path17.default.join(ciRunDir, "ci-result.json");
+  import_node_fs16.default.writeFileSync(filePath, JSON.stringify(ciResult, null, 2) + "\n");
   return filePath;
 }
 
@@ -5954,7 +7161,7 @@ function rankFlaky(configDir, options = {}) {
 }
 
 // src/backlog/fingerprint.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 function normalizeError(error) {
   return error.toLowerCase().replace(/0x[0-9a-f]+/g, "").replace(/\b\d+(?:\.\d+)?\s*(?:ms|s|px)\b/g, "").replace(/\s+/g, " ").trim();
 }
@@ -5977,7 +7184,7 @@ function computeFingerprint(failure) {
     failure.selector ?? "",
     normalizeError(failure.error)
   ];
-  return (0, import_node_crypto2.createHash)("sha1").update(parts.join("|")).digest("hex").slice(0, 8);
+  return (0, import_node_crypto3.createHash)("sha1").update(parts.join("|")).digest("hex").slice(0, 8);
 }
 function buildMarker(failure, hash) {
   const hunt = sanitizeMarkerValue(failure.hunt);
@@ -6021,8 +7228,8 @@ function clusterFailures(failures) {
 }
 
 // src/backlog/index.ts
-var import_node_fs16 = __toESM(require("fs"), 1);
-var import_node_path16 = __toESM(require("path"), 1);
+var import_node_fs17 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
 
 // src/backlog/parse.ts
 var MARKER_FP = /<!--\s*prowl:fp=([0-9a-f]+)/;
@@ -6112,7 +7319,7 @@ ${after}`;
 // src/backlog/index.ts
 function readFileOrEmpty(filePath) {
   try {
-    return import_node_fs16.default.readFileSync(filePath, "utf-8");
+    return import_node_fs17.default.readFileSync(filePath, "utf-8");
   } catch (error) {
     const err = error;
     if (err.code === "ENOENT") return "";
@@ -6128,7 +7335,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_path18.default.join(hunt.runDir, "result.json"));
     if (!resultJson) return failure;
     run = JSON.parse(resultJson);
   } catch (error) {
@@ -6157,8 +7364,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_path18.default.join(projectRoot, "docs", "backlog.md");
+  const resolvedPath = options.resolvedPath ?? import_node_path18.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);
@@ -6190,8 +7397,8 @@ function updateBacklogFromSuite(suiteResult, options = {}) {
     }
   }
   if (ticketsToAdd.length > 0) {
-    import_node_fs16.default.mkdirSync(import_node_path16.default.dirname(backlogPath), { recursive: true });
-    import_node_fs16.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
+    import_node_fs17.default.mkdirSync(import_node_path18.default.dirname(backlogPath), { recursive: true });
+    import_node_fs17.default.writeFileSync(backlogPath, insertTickets(backlogContent, ticketsToAdd));
   }
   return summary;
 }
@@ -6352,7 +7559,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_path19.default.join(configDir, "runs", timestamp("ci"));
   const resultPath = writeCiResult(ciRunDir, results, startedAt, totalDurationMs, flaky, clusters);
   const { passed, failed, skipped } = countCiResults(results);
   return {
@@ -6615,6 +7822,273 @@ async function readStatusMenu(client, menuTimeoutSeconds) {
   }
 }
 
+// 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 androidNodeToNative(node) {
+  return {
+    ...node.resourceId !== void 0 ? { id: node.resourceId } : {},
+    ...node.contentDesc !== void 0 ? { label: node.contentDesc } : {},
+    ...node.className !== void 0 ? { role: node.className } : {},
+    textValues: node.text !== void 0 ? [node.text] : [],
+    ...node.focused !== void 0 ? { focused: node.focused } : {}
+  };
+}
+function matchAndroidSelector(xml, selector, options = {}) {
+  const parsedSelector = parseNativeSelector(selector);
+  const root = parseAndroidHierarchy(xml);
+  if (!root) {
+    return [];
+  }
+  return matchNativeTree(
+    ANDROID_MATCH_DIALECT,
+    parsedSelector,
+    root,
+    androidNodeToNative,
+    (node) => node.children,
+    options
+  );
+}
+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));
+    }
+    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
+  });
+}
+function iosNodeToNative(node) {
+  const textValues = [];
+  if (node.label !== void 0) {
+    textValues.push(node.label);
+  }
+  if (node.value !== void 0) {
+    textValues.push(node.value);
+  }
+  return {
+    ...node.name !== void 0 ? { id: node.name } : {},
+    ...node.label !== void 0 ? { label: node.label } : {},
+    ...node.type !== void 0 ? { role: node.type } : {},
+    textValues
+  };
+}
+function matchIosSelector(xml, selector) {
+  const parsedSelector = parseNativeSelector(selector);
+  const root = parseIosHierarchy(xml);
+  if (!root) {
+    return [];
+  }
+  return matchNativeTree(
+    IOS_MATCH_DIALECT,
+    parsedSelector,
+    root,
+    iosNodeToNative,
+    (node) => node.children
+  );
+}
+function toElement3(node) {
+  return {
+    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/generator/index.ts
 var import_yaml2 = __toESM(require("yaml"), 1);
 
@@ -6675,6 +8149,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...] }
@@ -6716,81 +8191,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
 function parseViewportFlag2(value) {
   const match = /^(\d+)x(\d+)$/i.exec(value);
@@ -6835,27 +8235,43 @@ async function generateHunt(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ANDROID_INTERACTIVE_CLASSES,
   ANDROID_KEYCODES,
+  ANDROID_MATCH_DIALECT,
   DEFAULT_AGENT_REQUEST_TIMEOUT_MS,
   DEFAULT_ANALYZE_TREE_DEPTH,
   DEFAULT_FLAKY_THRESHOLD,
   DEFAULT_REQUEST_TIMEOUT_MS,
   DEFAULT_SIMULATOR_LOCK_ROOT,
   DEFAULT_WDA_REQUEST_TIMEOUT_MS,
+  HELPER_BINARY,
   INTERACTIVE_ROLES,
+  IOS_INTERACTIVE_TYPES,
+  IOS_MATCH_DIALECT,
   IOS_PRESS_KEYS,
+  IOS_WINDOW_TYPE,
+  MACDRIVER_REPO,
+  MACDRIVER_SIGNING_AUTHORITY_PREFIX,
+  MACDRIVER_SIGNING_IDENTIFIER,
+  MACDRIVER_VERSION,
+  MACDRIVER_VERSION_PATTERN,
+  MACOS_MATCH_DIALECT,
+  NATIVE_ATTRIBUTE_MAP,
   SpawnMacHelperClient,
   UIA2_REMOTE_PORT,
   Uia2HttpError,
   Uia2Transport,
-  WDA_RUNNER_APP_NAME,
   WDA_RUNNER_BUNDLE_ID,
+  WDA_USE_PORT_ENV,
   WEB_ONLY_STEP_TYPES,
   WdaHttpError,
   WdaTransport,
+  analyzeAndroidApp,
+  analyzeIosApp,
   analyzeMacApp,
   analyzePage,
   androidAppAllowedIdentities,
+  androidNodeToNative,
   androidQueryToLocator,
   assertAndroidAppAllowed,
   assertIosAppAllowed,
@@ -6868,6 +8284,8 @@ async function generateHunt(options) {
   closeIosSession,
   closeMacSession,
   clusterFailures,
+  codesignVerifier,
+  collectMacdriverStatus,
   computeFlakeScore,
   configSchema,
   createAndroidDriver,
@@ -6877,8 +8295,12 @@ async function generateHunt(options) {
   createUia2Session,
   createWdaAgentClient,
   createWdaSession,
+  decodeXmlEntities,
   defaultAgentConnector,
   defaultIosAgentConnector,
+  defaultWdaTestRunPreparer,
+  dittoExtractor,
+  downloadAndVerify,
   escapePredicateArg,
   escapeUiSelectorArg,
   extractElementId,
@@ -6888,9 +8310,14 @@ async function generateHunt(options) {
   generateHunt,
   healSelector,
   huntSchema,
+  injectUsePortIntoXctestrun,
+  installMacdriver,
   interpolateHunt,
   iosAppAllowedIdentities,
+  iosNodeToNative,
   iosQueryToLocator,
+  isAndroidInteractive,
+  isIosInteractive,
   launchAndroidSession,
   launchIosSession,
   launchMacSession,
@@ -6901,18 +8328,41 @@ async function generateHunt(options) {
   loadHunt,
   loadHuntMeta,
   loadHuntTags,
+  macdriverAssetName,
+  macdriverAssetUrl,
   macdriverBuildInstructions,
+  macdriverChecksumName,
+  macdriverInstallRoot,
+  macdriverInstalledBinary,
+  macdriverReleaseTag,
+  macdriverVersionDir,
+  matchAndroidSelector,
+  matchIosSelector,
+  matchNativeTree,
+  nodeMatchesSelector,
   normalizeXcuiClassName,
   parseAaptPackage,
   parseAdbDevices,
+  parseAndroidHierarchy,
   parseAndroidSelector,
+  parseChecksumFile,
+  parseCodesignDetails,
   parseForwardPort,
+  parseIosHierarchy,
   parseIosSelector,
   parseMacSelector,
+  parseNativeSelector,
   parseSimctlDevices,
+  parseSnapshot,
   parseXcodeVersion,
+  parseXml,
+  qualifyResourceId,
+  quoteSelectorValue,
+  rankAndroidSelectors,
   rankFlaky,
+  rankIosSelectors,
   rankMacSelectors,
+  rankNativeSelectors,
   readHistory,
   readHuntHistory,
   readIosBundleIdentifier,
@@ -6920,18 +8370,29 @@ async function generateHunt(options) {
   resolveAgentApks,
   resolveHelperBinary,
   resolveWdaProject,
-  resolveWdaRunner,
+  resolveWdaTestRun,
   runHunt,
   runSuite,
+  runVersionProbe,
   selectDeviceSerial,
   selectSimulatorUdid,
+  sha256Hex,
+  shortIosType,
   stepSchema,
+  tccGuidance,
+  unquoteSelectorValue,
   unwrapAndroidTextSelector,
   unwrapIosTextSelector,
+  unwrapNativeTextSelector,
   updateBacklogFromSuite,
+  validateMacdriverArchiveEntries,
+  validateMacdriverVersion,
+  verifyMacdriverSignature,
   waitForAgentReady,
   waitForWdaReady,
   wdaCacheDir,
-  webOnlyReason
+  wdaTestRunArgs,
+  webOnlyReason,
+  zipinfoArchiveLister
 });
 //# sourceMappingURL=lib.cjs.map