@validate.qa/runner 1.0.16 → 1.0.17

package/dist/cli.mjs

@@ -1861,6 +1861,102 @@ var init_mobile_test_generation = __esm({
   }
 });
 
+// ../shared/dist/mobile-cross-platform.js
+function isMobilePlatform(value) {
+  return value === "IOS" || value === "ANDROID";
+}
+function mediumForMobilePlatform(platform3) {
+  return platform3 === "IOS" ? "IOS_NATIVE" : "ANDROID_NATIVE";
+}
+function mobilePlatformFromMedium(medium) {
+  if (medium === "IOS_NATIVE")
+    return "IOS";
+  if (medium === "ANDROID_NATIVE")
+    return "ANDROID";
+  return null;
+}
+function otherMobilePlatform(platform3) {
+  return platform3 === "IOS" ? "ANDROID" : "IOS";
+}
+function platformTag(platform3) {
+  return platform3 === "IOS" ? "@ios" : "@android";
+}
+function resolvePlatformLocatorBundle(target, platform3) {
+  if (!target)
+    return void 0;
+  if (platform3) {
+    const overlay = target.platformLocators?.[platform3];
+    if (overlay)
+      return overlay;
+  }
+  return target.locatorBundle;
+}
+function hasPlatformLocator(target, platform3) {
+  return Boolean(target?.platformLocators?.[platform3]);
+}
+function hasCrossPlatformIdentity(bundle) {
+  if (!bundle)
+    return false;
+  return Boolean(bundle.text?.trim() || bundle.contentDesc?.trim() || bundle.accessibilityId?.trim());
+}
+function stepIsDivergentForPlatform(step, platform3) {
+  return Array.isArray(step.crossPlatformDivergent) && step.crossPlatformDivergent.includes(platform3);
+}
+function stepAppliesToPlatform(step, platform3) {
+  const platforms = step.platforms;
+  if (!platforms || platforms.length === 0)
+    return true;
+  if (!platform3)
+    return true;
+  return platforms.includes(platform3);
+}
+function stepsMissingPlatformLocators(steps, platform3) {
+  return steps.filter((step) => {
+    if (!LOCATOR_REQUIRING_ACTIONS.has(step.action))
+      return false;
+    if (!stepAppliesToPlatform(step, platform3))
+      return false;
+    if (hasPlatformLocator(step.target, platform3))
+      return false;
+    if (stepIsDivergentForPlatform(step, platform3))
+      return false;
+    return hasCrossPlatformIdentity(step.target?.locatorBundle);
+  });
+}
+function stepsNeedingReviewForPlatform(steps, platform3) {
+  return steps.filter((step) => {
+    if (!LOCATOR_REQUIRING_ACTIONS.has(step.action))
+      return false;
+    if (!stepAppliesToPlatform(step, platform3))
+      return false;
+    if (hasPlatformLocator(step.target, platform3))
+      return false;
+    if (stepIsDivergentForPlatform(step, platform3))
+      return true;
+    return !hasCrossPlatformIdentity(step.target?.locatorBundle);
+  });
+}
+function isTestReadyForPlatform(steps, authoringPlatform, runPlatform) {
+  if (runPlatform === authoringPlatform)
+    return true;
+  return stepsMissingPlatformLocators(steps, runPlatform).length === 0 && stepsNeedingReviewForPlatform(steps, runPlatform).length === 0;
+}
+var MOBILE_PLATFORMS, LOCATOR_REQUIRING_ACTIONS;
+var init_mobile_cross_platform = __esm({
+  "../shared/dist/mobile-cross-platform.js"() {
+    "use strict";
+    MOBILE_PLATFORMS = ["IOS", "ANDROID"];
+    LOCATOR_REQUIRING_ACTIONS = /* @__PURE__ */ new Set([
+      "tap",
+      "type",
+      "clear",
+      "waitForElement",
+      "assertVisible",
+      "assertText"
+    ]);
+  }
+});
+
 // ../shared/dist/mobile-deeplink.js
 function isSafeDeepLink(value) {
   if (typeof value !== "string")
@@ -3539,6 +3635,7 @@ __export(dist_exports, {
   MOBILE_DEFAULT_SWIPE_DISTANCE: () => MOBILE_DEFAULT_SWIPE_DISTANCE,
   MOBILE_FOCUS_SETTLE_MS: () => MOBILE_FOCUS_SETTLE_MS,
   MOBILE_MAX_SWIPE_DISTANCE: () => MOBILE_MAX_SWIPE_DISTANCE,
+  MOBILE_PLATFORMS: () => MOBILE_PLATFORMS,
   MOBILE_SCREENSHOT_INTERVAL_MS: () => MOBILE_SCREENSHOT_INTERVAL_MS,
   MOBILE_SNAPSHOT_MAX_SIZE_BYTES: () => MOBILE_SNAPSHOT_MAX_SIZE_BYTES,
   MOBILE_STEP_TYPES: () => MOBILE_STEP_TYPES,
@@ -3592,6 +3689,8 @@ __export(dist_exports, {
   getPlanDefinition: () => getPlanDefinition,
   getPlanLabel: () => getPlanLabel,
   getTrialDaysRemaining: () => getTrialDaysRemaining,
+  hasCrossPlatformIdentity: () => hasCrossPlatformIdentity,
+  hasPlatformLocator: () => hasPlatformLocator,
   hostOfOrigin: () => hostOfOrigin,
   isAddonType: () => isAddonType,
   isApiTest: () => isApiTest,
@@ -3601,23 +3700,34 @@ __export(dist_exports, {
   isCreditPackAmountCents: () => isCreditPackAmountCents,
   isDbPricingPlan: () => isDbPricingPlan,
   isEnvironmentalError: () => isEnvironmentalError,
+  isMobilePlatform: () => isMobilePlatform,
   isPricingPlan: () => isPricingPlan,
   isRunnableStep: () => isRunnableStep,
   isSafeDeepLink: () => isSafeDeepLink,
   isSameRegistrableDomainHost: () => isSameRegistrableDomainHost,
+  isTestReadyForPlatform: () => isTestReadyForPlatform,
   isTrialExpired: () => isTrialExpired,
   isUIVariant: () => isUIVariant,
   isValidMobileAppId: () => isValidMobileAppId,
+  mediumForMobilePlatform: () => mediumForMobilePlatform,
+  mobilePlatformFromMedium: () => mobilePlatformFromMedium,
   normalizeControlName: () => normalizeControlName,
+  otherMobilePlatform: () => otherMobilePlatform,
   parenDepthDelta: () => parenDepthDelta,
   planHasBillingPortal: () => planHasBillingPortal,
   planRequiresCheckout: () => planRequiresCheckout,
+  platformTag: () => platformTag,
   registrableDomain: () => registrableDomain,
   resolveCrossOriginConfigOverride: () => resolveCrossOriginConfigOverride,
+  resolvePlatformLocatorBundle: () => resolvePlatformLocatorBundle,
   safeOrigin: () => safeOrigin,
   sanitizeTestVariables: () => sanitizeTestVariables,
   selectorCandidatesForStep: () => selectorCandidatesForStep,
   selectorForValue: () => selectorForValue,
+  stepAppliesToPlatform: () => stepAppliesToPlatform,
+  stepIsDivergentForPlatform: () => stepIsDivergentForPlatform,
+  stepsMissingPlatformLocators: () => stepsMissingPlatformLocators,
+  stepsNeedingReviewForPlatform: () => stepsNeedingReviewForPlatform,
   stripEnvironmentalPrefix: () => stripEnvironmentalPrefix,
   stripLoginScaffolding: () => stripLoginScaffolding,
   summarizeHealth: () => summarizeHealth,
@@ -3631,6 +3741,7 @@ var init_dist = __esm({
     init_types();
     init_constants();
     init_mobile_test_generation();
+    init_mobile_cross_platform();
     init_mobile_deeplink();
     init_plans();
     init_audit_pricing();
@@ -66885,9 +66996,9 @@ ${statePacket}` },
       if (claimedVerified && !verified) {
         log2("  downgraded verified -> false: model claimed verified but called zero assert tools.");
       }
-      const platformTag = platform3 === "IOS" ? "@ios" : "@android";
+      const platformTag2 = platform3 === "IOS" ? "@ios" : "@android";
       const reviewTag = verified ? "@verified" : "@needs-review";
-      const tags = ["@discovered", "@mobile", platformTag, reviewTag];
+      const tags = ["@discovered", "@mobile", platformTag2, reviewTag];
       const test = {
         name: compiled.name,
         description: recording.finish?.description ?? compiled.description,
@@ -328123,7 +328234,7 @@ var require_package4 = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.16",
+      version: "1.0.17",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -329667,6 +329778,7 @@ async function startMobileNetworkCapture(options) {
 
 // src/services/appium-executor.ts
 var DEFAULT_STEP_TIMEOUT_MS = 1e4;
+var VERIFICATION_ACTIONS = /* @__PURE__ */ new Set(["assertVisible", "assertText", "waitForElement"]);
 var WD_SESSION_CREATE_TIMEOUT_MS = 12e4;
 var WD_ACTION_TIMEOUT_MS = 3e4;
 var MAX_SESSION_CREATE_ATTEMPTS = 3;
@@ -329995,6 +330107,11 @@ function boundsFromStep(step) {
   }
   return null;
 }
+function boundsForRun(step, platform3, isCrossPlatform) {
+  if (isCrossPlatform) return null;
+  if (platform3 && hasPlatformLocator(step.target, platform3)) return null;
+  return boundsFromStep(step);
+}
 function locatorStrategyForValue(value) {
   const trimmed = value?.trim();
   if (!trimmed) {
@@ -330014,19 +330131,21 @@ function locatorStrategyForValue(value) {
     { using: "id", value: trimmed }
   ];
 }
-function buildLocatorStrategies(target) {
+function buildLocatorStrategies(target, platform3) {
   if (!target) return [];
   const strategies = [];
-  const bundle = target.locatorBundle;
+  const bundle = resolvePlatformLocatorBundle(target, platform3);
   if (bundle) {
     if (bundle.accessibilityId) strategies.push({ using: "accessibility id", value: bundle.accessibilityId });
     if (bundle.resourceId) strategies.push({ using: "id", value: bundle.resourceId });
     if (bundle.xpath) strategies.push({ using: "xpath", value: bundle.xpath });
     if (bundle.className) strategies.push({ using: "class name", value: bundle.className });
   }
-  strategies.push(...locatorStrategyForValue(target.primary));
-  for (const fallback of target.fallbacks ?? []) {
-    strategies.push(...locatorStrategyForValue(fallback));
+  if (!(platform3 && hasPlatformLocator(target, platform3))) {
+    strategies.push(...locatorStrategyForValue(target.primary));
+    for (const fallback of target.fallbacks ?? []) {
+      strategies.push(...locatorStrategyForValue(fallback));
+    }
   }
   return strategies.filter(
     (strategy, index, list) => list.findIndex((candidate) => candidate.using === strategy.using && candidate.value === strategy.value) === index
@@ -330052,10 +330171,10 @@ function isIdentityStrategy(strategy) {
   if (strategy.using === "xpath") return strategy.value.includes("@");
   return false;
 }
-function buildIdentityLocatorStrategies(target) {
+function buildIdentityLocatorStrategies(target, platform3) {
   if (!target) return [];
   const strategies = [];
-  const bundle = target.locatorBundle;
+  const bundle = resolvePlatformLocatorBundle(target, platform3);
   if (bundle) {
     if (bundle.accessibilityId) strategies.push({ using: "accessibility id", value: bundle.accessibilityId });
     if (bundle.resourceId) strategies.push({ using: "id", value: bundle.resourceId });
@@ -330065,9 +330184,11 @@ function buildIdentityLocatorStrategies(target) {
     }
     if (bundle.xpath && bundle.xpath.includes("@")) strategies.push({ using: "xpath", value: bundle.xpath });
   }
-  for (const value of [target.primary, ...target.fallbacks ?? []]) {
-    for (const strategy of locatorStrategyForValue(value)) {
-      if (isIdentityStrategy(strategy)) strategies.push(strategy);
+  if (!(platform3 && hasPlatformLocator(target, platform3))) {
+    for (const value of [target.primary, ...target.fallbacks ?? []]) {
+      for (const strategy of locatorStrategyForValue(value)) {
+        if (isIdentityStrategy(strategy)) strategies.push(strategy);
+      }
     }
   }
   return dedupeStrategies(strategies);
@@ -330080,7 +330201,7 @@ function readStepTimeout(step) {
   return void 0;
 }
 async function findElement(sessionId, target, timeoutMs = DEFAULT_STEP_TIMEOUT_MS, opts) {
-  const strategies = opts?.identityOnly ? buildIdentityLocatorStrategies(target) : buildLocatorStrategies(target);
+  const strategies = opts?.identityOnly ? buildIdentityLocatorStrategies(target, opts?.platform) : buildLocatorStrategies(target, opts?.platform);
   if (strategies.length === 0) {
     throw new Error(
       opts?.identityOnly ? "No identity locator (accessibility id / resource id / text) available for this step \u2014 cannot verify the screen" : "No locator strategies available for this step"
@@ -330182,18 +330303,18 @@ function shouldAbortAfterStepFailure(action) {
       return false;
   }
 }
-async function executeTap(sessionId, step) {
-  const bounds = boundsFromStep(step);
+async function executeTap(sessionId, step, platform3, isCrossPlatform = false) {
+  const bounds = boundsForRun(step, platform3, isCrossPlatform);
   if (step.target) {
     try {
-      const elementId = await findElement(sessionId, step.target, readStepTimeout(step));
+      const elementId = await findElement(sessionId, step.target, readStepTimeout(step), { platform: platform3 });
       await wdRequest(`/session/${sessionId}/element/${elementId}/click`, {
         method: "POST",
         body: "{}"
       });
       return;
     } catch (error2) {
-      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target).length > 0) throw error2;
+      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target, platform3).length > 0) throw error2;
     }
   }
   if (!bounds) {
@@ -330204,7 +330325,7 @@ async function executeTap(sessionId, step) {
 async function executeType(sessionId, step, context) {
   if (step.value === void 0 || step.value === null || step.value === "") return;
   const value = String(step.value);
-  const bounds = boundsFromStep(step);
+  const bounds = boundsForRun(step, context.platform, context.isCrossPlatform ?? false);
   let elementId = null;
   let lastInputError = null;
   let tappedBounds = false;
@@ -330221,12 +330342,12 @@ async function executeType(sessionId, step, context) {
   }
   if (step.target) {
     try {
-      elementId = await findElement(sessionId, step.target, readStepTimeout(step));
+      elementId = await findElement(sessionId, step.target, readStepTimeout(step), { platform: context.platform });
       lastInputError = await trySendElementValue(sessionId, elementId, value);
       if (!lastInputError) return;
       elementId = null;
     } catch (error2) {
-      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target).length > 0) throw error2;
+      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target, context.platform).length > 0) throw error2;
       lastInputError = error2;
     }
   }
@@ -330274,14 +330395,14 @@ async function executeType(sessionId, step, context) {
   }
   throw new Error(`TYPE step could not send text to the focused target${lastInputError instanceof Error ? `: ${lastInputError.message}` : ""}`);
 }
-async function executeClear(sessionId, step) {
-  const bounds = boundsFromStep(step);
+async function executeClear(sessionId, step, platform3, isCrossPlatform = false) {
+  const bounds = boundsForRun(step, platform3, isCrossPlatform);
   let elementId = null;
   if (step.target) {
     try {
-      elementId = await findElement(sessionId, step.target, readStepTimeout(step));
+      elementId = await findElement(sessionId, step.target, readStepTimeout(step), { platform: platform3 });
     } catch (error2) {
-      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target).length > 0) throw error2;
+      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target, platform3).length > 0) throw error2;
     }
   }
   if (!elementId && bounds) {
@@ -330350,20 +330471,20 @@ async function executeHome(sessionId, platform3) {
     body: JSON.stringify({ keycode: 3 })
   });
 }
-async function executeWaitForElement(sessionId, step) {
+async function executeWaitForElement(sessionId, step, platform3) {
   const timeout = readStepTimeout(step) ?? DEFAULT_STEP_TIMEOUT_MS;
-  await findElement(sessionId, step.target, timeout, { identityOnly: true });
+  await findElement(sessionId, step.target, timeout, { identityOnly: true, platform: platform3 });
 }
-async function executeAssertVisible(sessionId, step) {
-  const elementId = await findElement(sessionId, step.target, readStepTimeout(step), { identityOnly: true });
+async function executeAssertVisible(sessionId, step, platform3) {
+  const elementId = await findElement(sessionId, step.target, readStepTimeout(step), { identityOnly: true, platform: platform3 });
   const result = await wdRequest(`/session/${sessionId}/element/${elementId}/displayed`);
   if (!result?.value) {
     throw new Error(`Element found but not visible: ${step.target?.primary ?? "unknown"}`);
   }
 }
-async function executeAssertText(sessionId, step) {
+async function executeAssertText(sessionId, step, platform3) {
   if (!step.assertion) throw new Error("assertText step requires an assertion value");
-  const elementId = await findElement(sessionId, step.target, readStepTimeout(step), { identityOnly: true });
+  const elementId = await findElement(sessionId, step.target, readStepTimeout(step), { identityOnly: true, platform: platform3 });
   const result = await wdRequest(`/session/${sessionId}/element/${elementId}/text`);
   const actualText = typeof result?.value === "string" ? result.value : "";
   const textCandidates = await readElementTextCandidates(sessionId, elementId, actualText);
@@ -330529,12 +330650,14 @@ async function executeMobileTest(options) {
     }
     await restoreTargetAppIfExternal(sessionId, options.target, log2, "session start", false);
     let entryDrift = false;
+    const runPlatform = options.target.platform;
+    const isCrossPlatform = options.target.authoringPlatform != null && options.target.authoringPlatform !== runPlatform;
     const entryStep = options.steps.find(
-      (s) => s.action !== "launchApp" && buildIdentityLocatorStrategies(s.target).length > 0
+      (s) => s.action !== "launchApp" && stepAppliesToPlatform(s, runPlatform) && buildIdentityLocatorStrategies(s.target, runPlatform).length > 0
     );
     if (entryStep) {
       try {
-        await findElement(sessionId, entryStep.target, DEFAULT_STEP_TIMEOUT_MS, { identityOnly: true });
+        await findElement(sessionId, entryStep.target, DEFAULT_STEP_TIMEOUT_MS, { identityOnly: true, platform: runPlatform });
       } catch (err) {
         if (isTransportError(err)) throw err;
         entryDrift = true;
@@ -330548,6 +330671,12 @@ async function executeMobileTest(options) {
     let environmental = null;
     for (const step of options.steps) {
       if (entryDrift) break;
+      if (!stepAppliesToPlatform(step, runPlatform)) {
+        log2(`Step ${step.order}: ${step.action} \u2014 skipped (not applicable to ${runPlatform})`);
+        stepResults.push({ stepOrder: step.order, status: "skipped", duration: 0 });
+        screenshots.push("");
+        continue;
+      }
       const stepStart = Date.now();
       log2(`Step ${step.order}: ${step.action} - ${step.description}`);
       let status = "passed";
@@ -330559,17 +330688,18 @@ async function executeMobileTest(options) {
             log2("  App launched (handled by session creation)");
             break;
           case "tap":
-            await executeTap(sessionId, step);
+            await executeTap(sessionId, step, runPlatform, isCrossPlatform);
             break;
           case "type":
             await executeType(sessionId, step, {
-              platform: options.target.platform,
+              platform: runPlatform,
               deviceId: selectedDevice.id,
-              log: log2
+              log: log2,
+              isCrossPlatform
             });
             break;
           case "clear":
-            await executeClear(sessionId, step);
+            await executeClear(sessionId, step, runPlatform, isCrossPlatform);
             break;
           case "swipe":
           case "scroll":
@@ -330579,16 +330709,16 @@ async function executeMobileTest(options) {
             await executeBack(sessionId);
             break;
           case "home":
-            await executeHome(sessionId, options.target.platform);
+            await executeHome(sessionId, runPlatform);
             break;
           case "waitForElement":
-            await executeWaitForElement(sessionId, step);
+            await executeWaitForElement(sessionId, step, runPlatform);
             break;
           case "assertVisible":
-            await executeAssertVisible(sessionId, step);
+            await executeAssertVisible(sessionId, step, runPlatform);
             break;
           case "assertText":
-            await executeAssertText(sessionId, step);
+            await executeAssertText(sessionId, step, runPlatform);
             break;
           default: {
             const _exhaustive = step.action;
@@ -330625,8 +330755,14 @@ async function executeMobileTest(options) {
         break;
       }
     }
-    const allPassed = !environmental && stepResults.length > 0 && stepResults.every((r) => r.status === "passed" || r.status === "skipped");
-    const firstError = environmental ?? (stepResults.find((r) => r.status === "failed")?.error ?? null);
+    const executedResults = stepResults.filter((r) => r.status !== "skipped");
+    const verifyOrders = new Set(
+      options.steps.filter((s) => VERIFICATION_ACTIONS.has(s.action)).map((s) => s.order)
+    );
+    const anyVerificationPassed = stepResults.some((r) => r.status === "passed" && verifyOrders.has(r.stepOrder));
+    const crossPlatformUnverified = isCrossPlatform && verifyOrders.size > 0 && !anyVerificationPassed;
+    const allPassed = !environmental && executedResults.length > 0 && !crossPlatformUnverified && stepResults.every((r) => r.status === "passed" || r.status === "skipped");
+    const firstError = environmental ?? (stepResults.find((r) => r.status === "failed")?.error ?? null) ?? (crossPlatformUnverified ? `Cross-platform run on ${runPlatform} verified no outcome \u2014 every assertion/wait step was skipped or unresolved. Author a ${runPlatform} assertion or resolve the divergence.` : null);
     await stopCapture();
     await stopRecording();
     return {
@@ -330760,6 +330896,184 @@ async function createMobileDiscoverySession(target, options) {
     }
   };
 }
+async function readElementAttribute(sessionId, elementId, name) {
+  try {
+    const result = await wdRequest(`/session/${sessionId}/element/${elementId}/attribute/${encodeURIComponent(name)}`);
+    const value = result?.value;
+    if (typeof value !== "string") return void 0;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch (err) {
+    if (isTransportError(err)) throw err;
+    return void 0;
+  }
+}
+function harvestFallbackXpath(platform3, attrs) {
+  if (platform3 === "IOS") {
+    if (attrs.name) return `//*[@name=${xpathLiteral(attrs.name)}]`;
+    const text = attrs.label ?? attrs.value;
+    if (text) return identityTextXpath(text);
+    return "//*";
+  }
+  if (attrs.resourceId) return `//*[@resource-id=${xpathLiteral(attrs.resourceId)}]`;
+  if (attrs.text) return identityTextXpath(attrs.text);
+  if (attrs.contentDesc) return `//*[@content-desc=${xpathLiteral(attrs.contentDesc)}]`;
+  return "//*";
+}
+async function readNativeElementBundle(sessionId, elementId, platform3) {
+  const className = await readElementAttribute(sessionId, elementId, platform3 === "IOS" ? "type" : "class") ?? "";
+  if (platform3 === "IOS") {
+    const name = await readElementAttribute(sessionId, elementId, "name");
+    const label = await readElementAttribute(sessionId, elementId, "label");
+    const value = await readElementAttribute(sessionId, elementId, "value");
+    const text2 = label ?? value;
+    if (!name && !text2) return null;
+    const bundle2 = {
+      xpath: harvestFallbackXpath("IOS", { name, label, value }),
+      className
+    };
+    if (name) bundle2.accessibilityId = name;
+    if (text2) bundle2.text = text2;
+    return bundle2;
+  }
+  const resourceId = await readElementAttribute(sessionId, elementId, "resource-id");
+  const contentDesc = await readElementAttribute(sessionId, elementId, "content-desc") ?? await readElementAttribute(sessionId, elementId, "contentDescription");
+  const text = await readElementAttribute(sessionId, elementId, "text");
+  if (!resourceId && !contentDesc && !text) return null;
+  const bundle = {
+    xpath: harvestFallbackXpath("ANDROID", { text, contentDesc, resourceId }),
+    className
+  };
+  if (contentDesc) bundle.accessibilityId = contentDesc;
+  if (resourceId) bundle.resourceId = resourceId;
+  if (text) bundle.text = text;
+  if (contentDesc) bundle.contentDesc = contentDesc;
+  return bundle;
+}
+function isStateAdvancingAction(action) {
+  return action === "tap" || action === "type" || action === "clear" || action === "swipe" || action === "scroll" || action === "back" || action === "home";
+}
+function stepNeedsLocator(action) {
+  return action === "tap" || action === "type" || action === "clear" || action === "waitForElement" || action === "assertVisible" || action === "assertText";
+}
+async function driveHarvestStep(sessionId, step, elementId, platform3) {
+  switch (step.action) {
+    case "tap":
+      if (!elementId) return false;
+      await wdRequest(`/session/${sessionId}/element/${elementId}/click`, { method: "POST", body: "{}" });
+      return true;
+    case "type": {
+      if (step.value === void 0 || step.value === null || step.value === "") return true;
+      if (!elementId) return false;
+      await wdRequest(`/session/${sessionId}/element/${elementId}/click`, { method: "POST", body: "{}" });
+      await new Promise((resolve) => setTimeout(resolve, MOBILE_FOCUS_SETTLE_MS));
+      const err = await trySendElementValue(sessionId, elementId, String(step.value));
+      return !err;
+    }
+    case "clear":
+      if (!elementId) return false;
+      await wdRequest(`/session/${sessionId}/element/${elementId}/clear`, { method: "POST", body: "{}" });
+      return true;
+    case "swipe":
+    case "scroll":
+      await executeSwipe(sessionId, step);
+      return true;
+    case "back":
+      await executeBack(sessionId);
+      return true;
+    case "home":
+      await executeHome(sessionId, platform3);
+      return true;
+    case "launchApp":
+    case "waitForElement":
+    case "assertVisible":
+    case "assertText":
+      return true;
+  }
+}
+async function harvestPlatformLocators(options) {
+  const platform3 = options.target.platform;
+  const logLines = [];
+  const log2 = (msg) => {
+    logLines.push(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}`);
+  };
+  const bundles = {};
+  const divergentOrders = [];
+  let reachedOrder = null;
+  let environmentalError;
+  log2(`Cross-platform locator discovery \u2014 resolving ${platform3} locators for ${options.steps.length} steps`);
+  const session = await createMobileDiscoverySession({
+    appId: options.target.appId,
+    platform: platform3,
+    platformVersion: options.target.platformVersion,
+    recordedDeviceId: options.target.recordedDeviceId,
+    assignedDeviceId: options.target.assignedDeviceId,
+    launchMode: "LAUNCH_APP"
+  });
+  options.onSessionReady?.(session.sessionId, session.deviceId, platform3);
+  try {
+    await freshLaunchTargetApp(session.sessionId, platform3, options.target.appId, log2);
+    if (options.target.launchMode === "DEEP_LINK" && options.target.deeplink) {
+      try {
+        await openDeepLink(session.sessionId, platform3, options.target.deeplink, options.target.appId);
+      } catch (err) {
+        log2(`  Deep link failed (continuing): ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    await restoreTargetAppIfExternal(session.sessionId, { appId: options.target.appId, platform: platform3 }, log2, "harvest start", false);
+    for (const step of options.steps) {
+      if (step.action === "launchApp") continue;
+      if (!stepAppliesToPlatform(step, platform3)) continue;
+      let elementId = null;
+      const identityStrategies = buildIdentityLocatorStrategies(step.target);
+      if (identityStrategies.length > 0 && step.target) {
+        try {
+          elementId = await findElement(session.sessionId, step.target, DEFAULT_STEP_TIMEOUT_MS, { identityOnly: true });
+        } catch (err) {
+          if (isTransportError(err)) throw err;
+          elementId = null;
+        }
+      }
+      if (elementId) {
+        const bundle = await readNativeElementBundle(session.sessionId, elementId, platform3);
+        if (bundle) {
+          bundles[step.order] = bundle;
+          log2(`  \u2713 Step ${step.order} (${step.action}) resolved on ${platform3}`);
+        } else {
+          divergentOrders.push(step.order);
+          log2(`  \u26A0 Step ${step.order} (${step.action}) resolved but has no durable identity \u2014 flagged divergent`);
+        }
+      } else if (stepNeedsLocator(step.action)) {
+        divergentOrders.push(step.order);
+        log2(`  \u26A0 Step ${step.order} (${step.action}) could not be resolved on ${platform3} \u2014 needs manual authoring`);
+      }
+      const advanced = await driveHarvestStep(session.sessionId, step, elementId, platform3);
+      if (!advanced && isStateAdvancingAction(step.action)) {
+        log2(`  \u2717 Could not advance step ${step.order} (${step.action}) on ${platform3}; stopping harvest early`);
+        break;
+      }
+      reachedOrder = step.order;
+      await restoreTargetAppIfExternal(session.sessionId, { appId: options.target.appId, platform: platform3 }, log2, `harvest step ${step.order}`, false);
+    }
+  } catch (err) {
+    environmentalError = err instanceof Error ? err.message : String(err);
+    log2(`  \u2717 Harvest aborted: ${environmentalError}`);
+  } finally {
+    options.onSessionEnding?.(session.deviceId);
+    await session.stop().catch(() => {
+    });
+  }
+  return {
+    platform: platform3,
+    bundles,
+    divergentOrders,
+    reachedOrder,
+    deviceId: session.deviceId,
+    deviceName: session.deviceName,
+    logs: logLines.join("\n"),
+    ...environmentalError ? { environmentalError } : {}
+  };
+}
 
 // src/mobile-device-queue.ts
 function isNativeMobileDiscoveryContext(ctx) {
@@ -334017,6 +334331,102 @@ ${finalVerifyResult.logs ?? ""}`;
         log.fail("ERROR - No discovery context");
         return;
       }
+      const locatorCtx = ctx;
+      if (locatorCtx.mode === "locator-discovery") {
+        const harvestTarget = locatorCtx.target;
+        const targetTestCaseId = locatorCtx.targetTestCaseId;
+        const platform3 = locatorCtx.platform ?? harvestTarget?.platform;
+        if (!platform3 || !harvestTarget?.appId || !targetTestCaseId) {
+          await postResult(opts.serverUrl, headers, run2.runId, {
+            status: "ERROR",
+            error: "CONFIG_ISSUE: locator-discovery run is missing platform/appId/targetTestCaseId."
+          });
+          log.fail("ERROR - malformed locator-discovery context");
+          return;
+        }
+        if (getBridgeState().hasActiveSession) {
+          await postResult(opts.serverUrl, headers, run2.runId, {
+            status: "ERROR",
+            error: "CONFIG_ISSUE: the shared mobile device is busy with an active recording session; retry once it ends."
+          });
+          log.fail("ERROR - device busy (recording) for locator discovery");
+          return;
+        }
+        const leasedName = assignedDeviceId ? getCachedDeviceSnapshot().find((d) => d.id === assignedDeviceId)?.name : void 0;
+        liveBrowserHandle.patch({
+          mode: "discovery",
+          testName: "Cross-platform locator discovery",
+          note: `${platform3} locator discovery`,
+          surface: "mobile",
+          mobilePlatform: platform3,
+          ...assignedDeviceId ? { deviceId: assignedDeviceId } : {},
+          ...leasedName ? { deviceName: leasedName } : {}
+        });
+        requestLiveBrowserHeartbeat(true);
+        log.info(`Cross-platform locator discovery \u2014 ${platform3} / ${harvestTarget.appId} for test ${targetTestCaseId}`);
+        setExecutorBusy(true);
+        try {
+          const harvest = await harvestPlatformLocators({
+            steps: locatorCtx.sourceSteps ?? [],
+            target: {
+              appId: harvestTarget.appId,
+              platform: platform3,
+              platformVersion: harvestTarget.platformVersion,
+              recordedDeviceId: harvestTarget.recordedDeviceId,
+              assignedDeviceId,
+              launchMode: harvestTarget.launchMode,
+              deeplink: harvestTarget.deeplink
+            },
+            onSessionReady: (sessionId, deviceId, sessionPlatform) => {
+              attachMirrorSession(sessionId, sessionPlatform, deviceId);
+              const name = getCachedDeviceSnapshot().find((d) => d.id === deviceId)?.name;
+              liveBrowserHandle.patch({ deviceId, ...name ? { deviceName: name } : {} });
+              requestLiveBrowserHeartbeat(true);
+            },
+            onSessionEnding: (deviceId) => {
+              detachMirrorSession(deviceId);
+            }
+          });
+          let queuedRunId = null;
+          let resultPosted = false;
+          try {
+            const res = await fetch(`${opts.serverUrl}/api/runner/runs/${run2.runId}/locator-discovery-result`, {
+              method: "POST",
+              headers: { ...headers, "Content-Type": "application/json" },
+              body: JSON.stringify({
+                bundles: harvest.bundles,
+                divergentOrders: harvest.divergentOrders,
+                reachedOrder: harvest.reachedOrder,
+                logs: harvest.logs,
+                ...harvest.environmentalError ? { environmentalError: harvest.environmentalError } : {}
+              }),
+              signal: AbortSignal.timeout(3e4)
+            });
+            if (res.ok) {
+              resultPosted = true;
+              const data = await res.json().catch(() => null);
+              queuedRunId = data?.queuedRunId ?? null;
+            } else {
+              log.warn(`[locator-discovery] result POST returned ${res.status}`);
+            }
+          } catch (postErr) {
+            log.warn(`[locator-discovery] result POST failed: ${postErr instanceof Error ? postErr.message : String(postErr)}`);
+          }
+          const passed = resultPosted && !harvest.environmentalError && harvest.reachedOrder != null;
+          await postResult(opts.serverUrl, headers, run2.runId, {
+            status: passed ? "PASSED" : "ERROR",
+            error: !resultPosted ? "CONFIG_ISSUE: failed to persist harvested cross-platform locators (result POST did not succeed); retriable." : harvest.environmentalError ? `CONFIG_ISSUE: ${harvest.environmentalError}` : harvest.reachedOrder == null ? "CONFIG_ISSUE: locator discovery could not reach any step on the target platform." : void 0,
+            logs: harvest.logs,
+            duration: Date.now() - startTime
+          });
+          log[passed ? "ok" : "fail"](
+            `Locator discovery ${passed ? "complete" : "ended"} \u2014 ${Object.keys(harvest.bundles).length} overlays, ${harvest.divergentOrders.length} divergent${queuedRunId ? ` (queued run ${queuedRunId})` : ""}`
+          );
+        } finally {
+          setExecutorBusy(false);
+        }
+        return;
+      }
       log.info(`Discovery (${ctx.mode}) on ${ctx.baseUrl}`);
       const { push: pushAudit, drain: drainAudit } = createAuditFlusher(
         `${opts.serverUrl}/api/runner/runs/${run2.runId}/ai-audit-batch`,
@@ -334730,7 +335140,11 @@ ${finalVerifyResult.logs ?? ""}`;
               recordedDeviceId: target.recordedDeviceId,
               assignedDeviceId,
               launchMode: target.launchMode,
-              deeplink: target.deeplink
+              deeplink: target.deeplink,
+              // Authoring platform (test's session medium). When it differs from
+              // target.platform this is a cross-platform run: no blind coordinate
+              // taps on foreign geometry, and the run must verify an outcome.
+              authoringPlatform: mobilePlatformFromMedium(run2.authoringMedium) ?? void 0
             },
             // Stream this run to its OWN per-device dashboard tile (keyed by the
             // leased device id) so N parallel Appium runs each show a live mirror.