@validate.qa/runner 1.0.15 → 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();
@@ -66797,16 +66908,16 @@ ${statePacket}` },
       }
       const screen = screenName();
       if (accessibilityId) {
-        const bundle2 = { xpath: `//*[@content-desc=${xpathLiteral(accessibilityId)} or @name=${xpathLiteral(accessibilityId)}]`, className: "", accessibilityId };
+        const bundle2 = { xpath: `//*[@content-desc=${xpathLiteral2(accessibilityId)} or @name=${xpathLiteral2(accessibilityId)}]`, className: "", accessibilityId };
         recordAction({ type: "ASSERT_VISIBLE", selector: accessibilityId, metadata: { screenName: screen, targetLabel: accessibilityId, locatorBundle: bundle2 } });
         return { ok: true, label: accessibilityId };
       }
       const safeText = text;
-      const bundle = { xpath: `//*[@text=${xpathLiteral(safeText)} or @label=${xpathLiteral(safeText)}]`, className: "", text: safeText };
+      const bundle = { xpath: `//*[@text=${xpathLiteral2(safeText)} or @label=${xpathLiteral2(safeText)}]`, className: "", text: safeText };
       recordAction({ type: "ASSERT_VISIBLE", selector: bundle.xpath, metadata: { screenName: screen, targetLabel: safeText, locatorBundle: bundle } });
       return { ok: true, label: safeText };
     }
-    function xpathLiteral(value) {
+    function xpathLiteral2(value) {
       if (!value.includes("'"))
         return `'${value}'`;
       if (!value.includes('"'))
@@ -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.15",
+      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;
@@ -329731,7 +329843,7 @@ async function getWindowSize(sessionId, retries = 3) {
   }
   throw new Error("Failed to get window size: invalid dimensions returned");
 }
-function realDeviceCapabilities(platform3) {
+function realDeviceCapabilities(platform3, portOffset = 0) {
   const env = process.env;
   const caps = {};
   const num = (v) => {
@@ -329739,6 +329851,7 @@ function realDeviceCapabilities(platform3) {
     const n = Number.parseInt(v, 10);
     return Number.isFinite(n) ? n : void 0;
   };
+  const offset = Number.isFinite(portOffset) && portOffset > 0 ? Math.floor(portOffset) : 0;
   if (platform3 === "IOS") {
     if (env.APPIUM_XCODE_ORG_ID) {
       caps["appium:xcodeOrgId"] = env.APPIUM_XCODE_ORG_ID;
@@ -329748,15 +329861,15 @@ function realDeviceCapabilities(platform3) {
     }
     if (env.APPIUM_UPDATED_WDA_BUNDLE_ID) caps["appium:updatedWDABundleId"] = env.APPIUM_UPDATED_WDA_BUNDLE_ID;
     const wdaPort = num(env.APPIUM_WDA_LOCAL_PORT);
-    if (wdaPort !== void 0) caps["appium:wdaLocalPort"] = wdaPort;
+    if (wdaPort !== void 0) caps["appium:wdaLocalPort"] = wdaPort + offset;
   } else {
     const systemPort = num(env.APPIUM_SYSTEM_PORT);
-    if (systemPort !== void 0) caps["appium:systemPort"] = systemPort;
+    if (systemPort !== void 0) caps["appium:systemPort"] = systemPort + offset;
   }
   return caps;
 }
 async function createSession(target) {
-  const realCaps = target.isPhysical ? realDeviceCapabilities(target.platform) : {};
+  const realCaps = target.isPhysical ? realDeviceCapabilities(target.platform, target.portOffset) : {};
   const capabilities = target.platform === "IOS" ? {
     platformName: "iOS",
     "appium:automationName": "XCUITest",
@@ -329994,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) {
@@ -330013,24 +330131,68 @@ 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
   );
 }
+function dedupeStrategies(strategies) {
+  return strategies.filter(
+    (strategy, index, list) => list.findIndex((candidate) => candidate.using === strategy.using && candidate.value === strategy.value) === index
+  );
+}
+function xpathLiteral(value) {
+  if (!value.includes("'")) return `'${value}'`;
+  if (!value.includes('"')) return `"${value}"`;
+  const parts = value.split("'").map((p) => `'${p}'`);
+  return `concat(${parts.join(`, "'", `)})`;
+}
+function identityTextXpath(value) {
+  const lit = xpathLiteral(value);
+  return `//*[@text=${lit} or @content-desc=${lit} or @label=${lit} or @name=${lit} or @value=${lit}]`;
+}
+function isIdentityStrategy(strategy) {
+  if (strategy.using === "accessibility id" || strategy.using === "id") return true;
+  if (strategy.using === "xpath") return strategy.value.includes("@");
+  return false;
+}
+function buildIdentityLocatorStrategies(target, platform3) {
+  if (!target) return [];
+  const strategies = [];
+  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 });
+    for (const value of [bundle.text, bundle.contentDesc]) {
+      const trimmed = value?.trim();
+      if (trimmed) strategies.push({ using: "xpath", value: identityTextXpath(trimmed) });
+    }
+    if (bundle.xpath && bundle.xpath.includes("@")) strategies.push({ using: "xpath", value: bundle.xpath });
+  }
+  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);
+}
 function readStepTimeout(step) {
   const value = step.metadata?.timeout;
   if (typeof value === "number" && Number.isFinite(value) && value > 0) {
@@ -330038,10 +330200,12 @@ function readStepTimeout(step) {
   }
   return void 0;
 }
-async function findElement(sessionId, target, timeoutMs = DEFAULT_STEP_TIMEOUT_MS) {
-  const strategies = buildLocatorStrategies(target);
+async function findElement(sessionId, target, timeoutMs = DEFAULT_STEP_TIMEOUT_MS, opts) {
+  const strategies = opts?.identityOnly ? buildIdentityLocatorStrategies(target, opts?.platform) : buildLocatorStrategies(target, opts?.platform);
   if (strategies.length === 0) {
-    throw new Error("No locator strategies available for this step");
+    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"
+    );
   }
   const startTime = Date.now();
   let lastError = "";
@@ -330139,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 (!bounds) throw error2;
+      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target, platform3).length > 0) throw error2;
     }
   }
   if (!bounds) {
@@ -330161,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;
@@ -330178,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 (!bounds) throw error2;
+      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target, context.platform).length > 0) throw error2;
       lastInputError = error2;
     }
   }
@@ -330231,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 (!bounds) throw error2;
+      if (isTransportError(error2) || !bounds || buildLocatorStrategies(step.target, platform3).length > 0) throw error2;
     }
   }
   if (!elementId && bounds) {
@@ -330307,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);
+  await findElement(sessionId, step.target, timeout, { identityOnly: true, platform: platform3 });
 }
-async function executeAssertVisible(sessionId, step) {
-  const elementId = await findElement(sessionId, step.target, readStepTimeout(step));
+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));
+  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);
@@ -330355,6 +330519,7 @@ async function executeMobileTest(options) {
   const screenshots = [];
   let apiCalls = [];
   let sessionId = null;
+  let selectedDevice;
   let capture = null;
   let captureStopped = false;
   let recordingStarted = false;
@@ -330402,7 +330567,6 @@ async function executeMobileTest(options) {
         `No ${platformFilter} ${platformFilter === "IOS" ? "simulator" : "emulator"} booted. Start one via ${platformFilter === "IOS" ? "Simulator.app" : "Android Studio"} first.`
       );
     }
-    let selectedDevice;
     if (options.target.assignedDeviceId) {
       selectedDevice = matchingDevices.find((d) => d.id === options.target.assignedDeviceId);
       if (!selectedDevice) {
@@ -330443,13 +330607,15 @@ async function executeMobileTest(options) {
       log2(`Warning: Could not retrieve installed apps list. Proceeding with test execution.`);
     }
     log2(`Starting Appium session for ${options.target.appId} on ${selectedDevice.name}...`);
+    const leasedPortOffset = Math.max(0, matchingDevices.findIndex((d) => d.id === selectedDevice?.id));
     try {
       sessionId = await createSessionWithRetry({
         appId: options.target.appId,
         platform: options.target.platform,
         deviceId: selectedDevice.id,
         platformVersion: options.target.platformVersion ?? selectedDevice.platformVersion,
-        isPhysical: selectedDevice.isPhysical
+        isPhysical: selectedDevice.isPhysical,
+        portOffset: leasedPortOffset
       }, (msg) => log2(msg));
     } catch (err) {
       const base2 = err instanceof Error ? err.message : String(err);
@@ -330465,6 +330631,12 @@ async function executeMobileTest(options) {
       throw err;
     }
     log2(`Session created: ${sessionId}`);
+    if (selectedDevice.id) {
+      try {
+        options.onSessionReady?.(sessionId, selectedDevice.id, options.target.platform);
+      } catch {
+      }
+    }
     recordingStarted = await startScreenRecording(sessionId, options.target.platform, log2);
     log2("Opening a fresh app instance for the test...");
     await freshLaunchTargetApp(sessionId, options.target.platform, options.target.appId, log2);
@@ -330477,8 +330649,34 @@ 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" && stepAppliesToPlatform(s, runPlatform) && buildIdentityLocatorStrategies(s.target, runPlatform).length > 0
+    );
+    if (entryStep) {
+      try {
+        await findElement(sessionId, entryStep.target, DEFAULT_STEP_TIMEOUT_MS, { identityOnly: true, platform: runPlatform });
+      } catch (err) {
+        if (isTransportError(err)) throw err;
+        entryDrift = true;
+        const driftMsg = `App started on an unexpected screen \u2014 the recorded flow's first element ("${entryStep.target?.primary ?? entryStep.description}") is not present, so the replay was aborted before it could blind-tap stale coordinates (screen drift; the app may be on onboarding or a different screen than when the test was recorded).`;
+        log2(`  \u2717 Entry-screen drift: ${driftMsg}`);
+        stepResults.push({ stepOrder: entryStep.order, status: "failed", duration: 0, error: driftMsg });
+        const driftShot = await takeScreenshot(sessionId).catch(() => null);
+        screenshots.push(driftShot ?? "");
+      }
+    }
     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";
@@ -330490,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":
@@ -330510,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;
@@ -330556,8 +330755,14 @@ async function executeMobileTest(options) {
         break;
       }
     }
-    const allPassed = !environmental && 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 {
@@ -330569,6 +330774,8 @@ async function executeMobileTest(options) {
       logs: logLines.join("\n"),
       error: firstError,
       duration: Date.now() - startTime,
+      deviceId: selectedDevice?.id,
+      deviceName: selectedDevice?.name,
       environmental: environmental ?? void 0
     };
   } catch (err) {
@@ -330585,6 +330792,8 @@ async function executeMobileTest(options) {
       logs: logLines.join("\n"),
       error: errorMsg,
       duration: Date.now() - startTime,
+      deviceId: selectedDevice?.id,
+      deviceName: selectedDevice?.name,
       // A throw before/around the step loop is a setup/environment problem
       // (no device booted, app not installed, session could not be created,
       // Appium unreachable) — never a genuine test assertion failure.
@@ -330594,6 +330803,12 @@ async function executeMobileTest(options) {
     await stopCapture();
     await stopRecording();
     if (sessionId) {
+      if (selectedDevice?.id) {
+        try {
+          options.onSessionEnding?.(selectedDevice.id);
+        } catch {
+        }
+      }
       try {
         log2("Closing the app on the device...");
         await terminateTargetApp(sessionId, options.target.platform, options.target.appId);
@@ -330652,7 +330867,9 @@ async function createMobileDiscoverySession(target, options) {
     platform: target.platform,
     deviceId: selectedDevice.id,
     platformVersion: target.platformVersion ?? selectedDevice.platformVersion,
-    isPhysical: selectedDevice.isPhysical
+    isPhysical: selectedDevice.isPhysical,
+    // Distinct control port per concurrent physical device (no-op for emulators/sims).
+    portOffset: Math.max(0, matchingDevices.findIndex((d) => d.id === selectedDevice?.id))
   });
   if (target.launchMode === "DEEP_LINK" && target.deeplink) {
     try {
@@ -330664,6 +330881,7 @@ async function createMobileDiscoverySession(target, options) {
   return {
     sessionId,
     deviceId: selectedDevice.id,
+    deviceName: selectedDevice.name,
     isPhysical: selectedDevice.isPhysical === true,
     platform: target.platform,
     appId: target.appId,
@@ -330678,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) {
@@ -331389,7 +331785,146 @@ async function handleSessionStop(_req, res) {
   stopSessionReaper();
   sendJSON(res, 200, { ok: true });
 }
+var runnerChannels = /* @__PURE__ */ new Map();
+function readDeviceIdParam(req) {
+  try {
+    const url = new URL(req.url || "", "http://localhost");
+    const raw = url.searchParams.get("deviceId");
+    if (!raw) return null;
+    const trimmed = raw.trim();
+    if (!trimmed || trimmed.length > MAX_DEVICE_ID_LENGTH || !DEVICE_ID_PATTERN.test(trimmed)) return null;
+    return trimmed;
+  } catch {
+    return null;
+  }
+}
+async function isSessionAlive(sessionId) {
+  try {
+    validateSessionId(sessionId);
+    await appiumRequest2(`/session/${sessionId}/window/rect`);
+    return true;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return !/no such session|invalid session id|session is either terminated|deleted session/i.test(msg);
+  }
+}
+function writeFrameToChannelClient(ch, client, frame) {
+  try {
+    const buffered = typeof client.writableLength === "number" ? client.writableLength : typeof client.socket?.writableLength === "number" ? client.socket.writableLength : 0;
+    if (buffered > SSE_MAX_BUFFERED_BYTES) {
+      try {
+        client.end();
+      } catch {
+      }
+      ch.clients.delete(client);
+      stopChannelPollingIfIdle(ch);
+      return;
+    }
+    client.write(`data: ${JSON.stringify(frame)}
+
+`);
+  } catch {
+  }
+}
+async function pollRunnerChannel(ch) {
+  if (ch.clients.size === 0 || ch.polling) return;
+  ch.polling = true;
+  try {
+    validateSessionId(ch.sessionId);
+    const [screenshot, source] = await Promise.all([
+      getScreenshot(`/session/${ch.sessionId}`),
+      getPageSource(`/session/${ch.sessionId}`)
+    ]);
+    if (!screenshot && !source) {
+      ch.nullTicks++;
+      if (ch.nullTicks >= MIRROR_DEAD_SESSION_TICKS) {
+        const alive = await isSessionAlive(ch.sessionId);
+        if (!alive) {
+          closeRunnerChannel(ch);
+          return;
+        }
+        ch.nullTicks = 0;
+      }
+    } else {
+      ch.nullTicks = 0;
+    }
+    const frame = { timestamp: Date.now(), screenshot: screenshot ?? null, source: source ?? null };
+    ch.lastFrame = frame;
+    for (const client of ch.clients) writeFrameToChannelClient(ch, client, frame);
+  } catch {
+  } finally {
+    ch.polling = false;
+  }
+}
+function ensureChannelPolling(ch) {
+  if (ch.pollTimer) return;
+  ch.pollTimer = setInterval(() => {
+    void pollRunnerChannel(ch);
+  }, MOBILE_SCREENSHOT_INTERVAL_MS);
+  ch.pollTimer.unref?.();
+}
+function stopChannelPollingIfIdle(ch) {
+  if (ch.clients.size === 0 && ch.pollTimer) {
+    clearInterval(ch.pollTimer);
+    ch.pollTimer = null;
+  }
+}
+function closeRunnerChannel(ch) {
+  if (ch.pollTimer) {
+    clearInterval(ch.pollTimer);
+    ch.pollTimer = null;
+  }
+  for (const client of ch.clients) {
+    try {
+      client.end();
+    } catch {
+    }
+  }
+  ch.clients.clear();
+  ch.lastFrame = null;
+  runnerChannels.delete(ch.deviceId);
+}
+function closeAllRunnerChannels() {
+  for (const ch of [...runnerChannels.values()]) closeRunnerChannel(ch);
+}
+async function serveRunnerMirror(req, res, ch) {
+  res.writeHead(200, {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    "Connection": "keep-alive",
+    "Access-Control-Allow-Origin": getAllowedOrigin(req),
+    "X-Content-Type-Options": "nosniff"
+  });
+  ch.clients.add(res);
+  ensureChannelPolling(ch);
+  if (ch.lastFrame) {
+    writeFrameToChannelClient(ch, res, ch.lastFrame);
+  } else {
+    await pollRunnerChannel(ch);
+  }
+  req.on("close", () => {
+    ch.clients.delete(res);
+    stopChannelPollingIfIdle(ch);
+  });
+}
 async function handleMirror(req, res) {
+  const deviceId = readDeviceIdParam(req);
+  if (deviceId) {
+    const ch = runnerChannels.get(deviceId);
+    if (ch) {
+      await serveRunnerMirror(req, res, ch);
+      return;
+    }
+    sendJSON(res, 404, { error: `No live mirror for device ${deviceId}.` });
+    return;
+  }
+  if (!state.appiumSessionId && runnerChannels.size === 1) {
+    const soleChannel = runnerChannels.values().next().value;
+    if (soleChannel) {
+      await serveRunnerMirror(req, res, soleChannel);
+      return;
+    }
+  }
   if (!state.appiumSessionId) {
     sendJSON(res, 400, { error: "No active Appium session. Call /bridge/session/start first." });
     return;
@@ -331836,6 +332371,7 @@ async function startMobileBridge(options) {
 }
 async function stopMobileBridge() {
   stopAllMirrorClients();
+  closeAllRunnerChannels();
   stopSessionReaper();
   clearBridgePidFile();
   if (state.appiumSessionId) {
@@ -331884,8 +332420,31 @@ function getBridgeState() {
 function setExecutorBusy(busy) {
   executorBusyCount = busy ? executorBusyCount + 1 : Math.max(0, executorBusyCount - 1);
 }
-function attachMirrorSession(sessionId, platform3) {
+function attachMirrorSession(sessionId, platform3, deviceId) {
   validateSessionId(sessionId);
+  if (deviceId) {
+    const existing = runnerChannels.get(deviceId);
+    if (existing && existing.sessionId !== sessionId) closeRunnerChannel(existing);
+    const ch = runnerChannels.get(deviceId) ?? {
+      deviceId,
+      sessionId,
+      platform: platform3,
+      clients: /* @__PURE__ */ new Set(),
+      lastFrame: null,
+      pollTimer: null,
+      nullTicks: 0,
+      polling: false
+    };
+    ch.sessionId = sessionId;
+    ch.platform = platform3;
+    ch.nullTicks = 0;
+    runnerChannels.set(deviceId, ch);
+    if (ch.clients.size > 0) {
+      ensureChannelPolling(ch);
+      void pollRunnerChannel(ch);
+    }
+    return;
+  }
   if (state.appiumSessionId && state.appiumSessionId !== sessionId) {
     stopAllMirrorClients();
   }
@@ -331900,8 +332459,12 @@ function attachMirrorSession(sessionId, platform3) {
     void pollAndBroadcastFrame();
   }
 }
-function detachMirrorSession(sessionId) {
-  if (sessionId && state.appiumSessionId && state.appiumSessionId !== sessionId) return;
+function detachMirrorSession(deviceId) {
+  if (deviceId) {
+    const ch = runnerChannels.get(deviceId);
+    if (ch) closeRunnerChannel(ch);
+    return;
+  }
   state.appiumSessionId = null;
   state.platform = null;
   mirrorSessionOwner = null;
@@ -333768,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`,
@@ -334087,7 +334746,8 @@ ${finalVerifyResult.logs ?? ""}`;
             testName: ctx.featureName ?? "Mobile discovery",
             note: `${platform3} mobile discovery`,
             surface: "mobile",
-            mobilePlatform: platform3
+            mobilePlatform: platform3,
+            ...assignedDeviceId ? { deviceId: assignedDeviceId } : {}
           });
           requestLiveBrowserHeartbeat(true);
           mobileOnLog(`Mobile discovery (${ctx.mode}) \u2014 ${platform3} / ${mobileTarget.appId}`);
@@ -334105,6 +334765,7 @@ ${finalVerifyResult.logs ?? ""}`;
               deeplink: mobileTarget.deeplink
             }, {
               onDeviceSelected: async (device) => {
+                liveBrowserHandle.patch({ deviceId: device.deviceId, deviceName: device.name });
                 try {
                   capture = await startMobileNetworkCapture({
                     platform: platform3,
@@ -334123,7 +334784,7 @@ ${finalVerifyResult.logs ?? ""}`;
               }
             });
             mobileOnLog(`Appium session created: ${session.sessionId} on device ${session.deviceId}`);
-            attachMirrorSession(session.sessionId, platform3);
+            attachMirrorSession(session.sessionId, platform3, session.deviceId);
             const driver = new MobileBridgeDriver({
               sessionId: session.sessionId,
               platform: platform3,
@@ -334167,7 +334828,7 @@ ${finalVerifyResult.logs ?? ""}`;
               }
             }
             if (session) {
-              detachMirrorSession(session.sessionId);
+              detachMirrorSession(session.deviceId);
               try {
                 await session.stop();
               } catch {
@@ -334444,6 +335105,14 @@ ${finalVerifyResult.logs ?? ""}`;
         return;
       }
       log.info(`\u{1F4F1} Mobile test - ${target.platform} / ${target.appId}`);
+      const leasedDeviceName = assignedDeviceId ? getCachedDeviceSnapshot().find((d) => d.id === assignedDeviceId)?.name : void 0;
+      liveBrowserHandle.patch({
+        surface: "mobile",
+        mobilePlatform: target.platform,
+        ...assignedDeviceId ? { deviceId: assignedDeviceId } : {},
+        ...leasedDeviceName ? { deviceName: leasedDeviceName } : {}
+      });
+      requestLiveBrowserHeartbeat(true);
       const mobileSteps = run2.steps ?? [];
       if (mobileSteps.length === 0) {
         await postResult(opts.serverUrl, headers, run2.runId, {
@@ -334471,7 +335140,20 @@ ${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.
+            onSessionReady: (sessionId, deviceId, sessionPlatform) => {
+              attachMirrorSession(sessionId, sessionPlatform, deviceId);
+              requestLiveBrowserHeartbeat(true);
+            },
+            onSessionEnding: (deviceId) => {
+              detachMirrorSession(deviceId);
             }
           });
           attemptLogs.push(`--- Appium attempt ${attempt + 1}/${maxRetries + 1} ---
@@ -334487,6 +335169,12 @@ ${result2.logs}`);
       if (attemptLogs.length > 1) {
         result2 = { ...result2, logs: attemptLogs.join("\n\n") };
       }
+      if (result2.deviceId || result2.deviceName) {
+        liveBrowserHandle.patch({
+          ...result2.deviceId ? { deviceId: result2.deviceId } : {},
+          ...result2.deviceName ? { deviceName: result2.deviceName } : {}
+        });
+      }
       const duration2 = Date.now() - startTime;
       const status = result2.environmental ? "ERROR" : result2.passed ? "PASSED" : "FAILED";
       const reportedError = result2.environmental ? `CONFIG_ISSUE: ${result2.environmental}` : result2.error ?? void 0;