@validate.qa/runner 1.0.78 → 1.0.79

package/dist/cli.js

@@ -1888,6 +1888,56 @@ var init_constants = __esm({
   }
 });
 
+// ../shared/dist/live-frame.js
+function isValidLiveFrame(frame) {
+  if (!frame || typeof frame !== "object")
+    return false;
+  const f = frame;
+  if (typeof f.sessionId !== "string" || f.sessionId.length === 0 || f.sessionId.length > 200)
+    return false;
+  if (typeof f.projectId !== "string" || f.projectId.length === 0 || f.projectId.length > 200)
+    return false;
+  if (typeof f.capturedAt !== "number" || !Number.isFinite(f.capturedAt))
+    return false;
+  if (f.mimeType !== "image/jpeg" && f.mimeType !== "image/png")
+    return false;
+  if (typeof f.base64 !== "string" || f.base64.length === 0)
+    return false;
+  if (f.base64.length > LIVE_FRAME_PUSH_MAX_BASE64_BYTES)
+    return false;
+  return true;
+}
+var readEnvInt, LIVE_FRAME_PUSH_MAX_BASE64_BYTES, LIVE_THUMBNAIL_MAX_BASE64_BYTES, LIVE_FRAME_MAX_DIMENSION, LIVE_FRAME_JPEG_QUALITY, LIVE_FRAME_MIN_PUSH_INTERVAL_MS, LIVE_FRAME_UNFOCUSED_INTERVAL_MS, LIVE_FRAME_STALE_MS, LIVE_FRAME_MAX_SESSIONS_PER_PROJECT, MOBILE_MJPEG_SETTINGS, MOBILE_MJPEG_FIRST_FRAME_TIMEOUT_MS, MOBILE_MJPEG_MAX_FRAME_BYTES;
+var init_live_frame = __esm({
+  "../shared/dist/live-frame.js"() {
+    "use strict";
+    readEnvInt = (name, fallback) => {
+      if (typeof process === "undefined")
+        return fallback;
+      const parsed = parseInt(process.env?.[name] ?? "", 10);
+      return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+    };
+    LIVE_FRAME_PUSH_MAX_BASE64_BYTES = readEnvInt("LIVE_FRAME_PUSH_MAX_BASE64_BYTES", 45e5);
+    LIVE_THUMBNAIL_MAX_BASE64_BYTES = readEnvInt("LIVE_THUMBNAIL_MAX_BASE64_BYTES", 4e5);
+    LIVE_FRAME_MAX_DIMENSION = readEnvInt("LIVE_FRAME_MAX_DIMENSION", 900);
+    LIVE_FRAME_JPEG_QUALITY = readEnvInt("LIVE_FRAME_JPEG_QUALITY", 55);
+    LIVE_FRAME_MIN_PUSH_INTERVAL_MS = readEnvInt("LIVE_FRAME_MIN_PUSH_INTERVAL_MS", 125);
+    LIVE_FRAME_UNFOCUSED_INTERVAL_MS = readEnvInt("LIVE_FRAME_UNFOCUSED_INTERVAL_MS", 2e3);
+    LIVE_FRAME_STALE_MS = readEnvInt("LIVE_FRAME_STALE_MS", 3e4);
+    LIVE_FRAME_MAX_SESSIONS_PER_PROJECT = readEnvInt("LIVE_FRAME_MAX_SESSIONS_PER_PROJECT", 32);
+    MOBILE_MJPEG_SETTINGS = {
+      /** Screenshots per second the broadcaster emits (both drivers: range 1-60). */
+      framerate: readEnvInt("MOBILE_MJPEG_FRAMERATE", 10),
+      /** Downscale percentage. UiAutomator2 defaults to 50, XCUITest to 100. */
+      scalingFactor: readEnvInt("MOBILE_MJPEG_SCALING_FACTOR", 50),
+      /** JPEG compression factor (both drivers: range 1-100). */
+      quality: readEnvInt("MOBILE_MJPEG_QUALITY", 50)
+    };
+    MOBILE_MJPEG_FIRST_FRAME_TIMEOUT_MS = readEnvInt("MOBILE_MJPEG_FIRST_FRAME_TIMEOUT_MS", 6e3);
+    MOBILE_MJPEG_MAX_FRAME_BYTES = readEnvInt("MOBILE_MJPEG_MAX_FRAME_BYTES", 8 * 1024 * 1024);
+  }
+});
+
 // ../shared/dist/project-key.js
 function isValidProjectKey(key) {
   return typeof key === "string" && PROJECT_KEY_PATTERN.test(key) && !RESERVED_PROJECT_KEYS.has(key);
@@ -6310,6 +6360,14 @@ __export(dist_exports, {
   GROUP_LABELS: () => GROUP_LABELS,
   LEGACY_TTS_MODEL_MAP: () => LEGACY_TTS_MODEL_MAP,
   LEGACY_TTS_VOICE_ID_MAP: () => LEGACY_TTS_VOICE_ID_MAP,
+  LIVE_FRAME_JPEG_QUALITY: () => LIVE_FRAME_JPEG_QUALITY,
+  LIVE_FRAME_MAX_DIMENSION: () => LIVE_FRAME_MAX_DIMENSION,
+  LIVE_FRAME_MAX_SESSIONS_PER_PROJECT: () => LIVE_FRAME_MAX_SESSIONS_PER_PROJECT,
+  LIVE_FRAME_MIN_PUSH_INTERVAL_MS: () => LIVE_FRAME_MIN_PUSH_INTERVAL_MS,
+  LIVE_FRAME_PUSH_MAX_BASE64_BYTES: () => LIVE_FRAME_PUSH_MAX_BASE64_BYTES,
+  LIVE_FRAME_STALE_MS: () => LIVE_FRAME_STALE_MS,
+  LIVE_FRAME_UNFOCUSED_INTERVAL_MS: () => LIVE_FRAME_UNFOCUSED_INTERVAL_MS,
+  LIVE_THUMBNAIL_MAX_BASE64_BYTES: () => LIVE_THUMBNAIL_MAX_BASE64_BYTES,
   MAX_CREDIT_TOPUP_CENTS: () => MAX_CREDIT_TOPUP_CENTS,
   MAX_DEEPLINK_LENGTH: () => MAX_DEEPLINK_LENGTH,
   MIN_CREDIT_TOPUP_CENTS: () => MIN_CREDIT_TOPUP_CENTS,
@@ -6321,6 +6379,9 @@ __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_MJPEG_FIRST_FRAME_TIMEOUT_MS: () => MOBILE_MJPEG_FIRST_FRAME_TIMEOUT_MS,
+  MOBILE_MJPEG_MAX_FRAME_BYTES: () => MOBILE_MJPEG_MAX_FRAME_BYTES,
+  MOBILE_MJPEG_SETTINGS: () => MOBILE_MJPEG_SETTINGS,
   MOBILE_PLATFORMS: () => MOBILE_PLATFORMS,
   MOBILE_POST_ACTION_SETTLE_MS: () => MOBILE_POST_ACTION_SETTLE_MS,
   MOBILE_SCREENSHOT_INTERVAL_MS: () => MOBILE_SCREENSHOT_INTERVAL_MS,
@@ -6433,6 +6494,7 @@ __export(dist_exports, {
   isTestReadyForPlatform: () => isTestReadyForPlatform,
   isTrialExpired: () => isTrialExpired,
   isUIVariant: () => isUIVariant,
+  isValidLiveFrame: () => isValidLiveFrame,
   isValidMobileAppId: () => isValidMobileAppId,
   isValidProjectKey: () => isValidProjectKey,
   isValidSttProvider: () => isValidSttProvider,
@@ -6495,6 +6557,7 @@ var init_dist = __esm({
     "use strict";
     init_types();
     init_constants();
+    init_live_frame();
     init_project_key();
     init_mobile_test_generation();
     init_mobile_step_healer();
@@ -87957,6 +88020,7 @@ var require_playwright_native = __commonJS({
     var PACKAGE_DIR = (0, path_1.resolve)(__dirname, "..", "..");
     var RUNS_DIR = process.env.RUNS_DIR || (0, path_1.join)(PACKAGE_DIR, ".qa-runs");
     var PW_CLI = require.resolve("@playwright/test/cli");
+    var LIVE_BROWSER_STATE_POLL_INTERVAL_MS = 500;
     async function executeTestViaNativePlaywright2(options) {
       const { playwrightCode, baseUrl, testName, testVariables, authStateCapturePath, storageStatePath, extraHttpHeaders, authStandingMode, validateContext, liveBrowserHandle, onLiveBrowserSnapshot } = options;
       const logs2 = [];
@@ -88046,7 +88110,7 @@ test.beforeEach(async ({ page }, testInfo) => {
   await __qaLiveBrowserCapture();
   __qaLiveBrowserInterval = setInterval(() => {
     void __qaLiveBrowserCapture?.();
-  }, 500);
+  }, ${LIVE_BROWSER_STATE_POLL_INTERVAL_MS});
 });
 
 test.afterEach(async () => {
@@ -88463,7 +88527,7 @@ ${passed ? "\u2705" : "\u274C"} Test ${passed ? "PASSED" : "FAILED"}${error2 ? `
       };
       const interval = setInterval(() => {
         void poll();
-      }, 1e3);
+      }, LIVE_BROWSER_STATE_POLL_INTERVAL_MS);
       interval.unref?.();
       void poll();
       return async () => {
@@ -352104,16 +352168,16 @@ var require_live_browser_registry = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.liveBrowserRegistry = void 0;
+    var shared_1 = (init_dist(), __toCommonJS(dist_exports));
     var THUMBNAIL_INTERVAL_MS = parseInt(process.env.LIVE_BROWSER_THUMBNAIL_INTERVAL_MS ?? "4000", 10) || 4e3;
     var THUMBNAIL_QUALITY = parseInt(process.env.LIVE_BROWSER_THUMBNAIL_QUALITY ?? "60", 10) || 60;
-    var BROWSER_THUMBNAIL_MAX_BASE64_BYTES = parseInt(process.env.LIVE_BROWSER_THUMBNAIL_MAX_BASE64_BYTES ?? "400000", 10) || 4e5;
-    var MOBILE_THUMBNAIL_MAX_BASE64_BYTES = parseInt(process.env.LIVE_MOBILE_THUMBNAIL_MAX_BASE64_BYTES ?? "4500000", 10) || 45e5;
     var STALE_SESSION_MS = parseInt(process.env.LIVE_BROWSER_STALE_MS ?? `${10 * 60 * 1e3}`, 10) || 10 * 60 * 1e3;
     var MAX_SESSIONS = parseInt(process.env.LIVE_BROWSER_MAX_SESSIONS ?? "32", 10) || 32;
     var LiveBrowserRegistry = class {
       entries = /* @__PURE__ */ new Map();
       snapshotTimer = null;
       capturing = false;
+      publisher = null;
       /** Register a new session. Returns a handle the caller must hold and
        *  ultimately call .unregister() on. */
       register(meta) {
@@ -352127,7 +352191,10 @@ var require_live_browser_registry = __commonJS({
           lastUpdatedAt: now,
           page: null,
           isCapturing: false,
-          pendingCapture: false
+          pendingCapture: false,
+          screencast: null,
+          screencastStarting: false,
+          lastPublishedAt: 0
         };
         this.entries.set(meta.sessionId, entry);
         this.ensureSnapshotLoop();
@@ -352140,19 +352207,40 @@ var require_live_browser_registry = __commonJS({
           unregister: () => this.unregister(meta.sessionId)
         };
       }
+      /**
+       * Install the real-time frame sink. Idempotent; the runner calls this once at
+       * startup, before any session registers.
+       */
+      setFramePublisher(publisher) {
+        this.publisher = publisher;
+      }
       unregister(sessionId) {
         const entry = this.entries.get(sessionId);
         if (!entry)
           return;
-        entry.page = null;
-        this.entries.delete(sessionId);
+        this.dropEntry(sessionId, entry);
         if (this.entries.size === 0)
           this.stopSnapshotLoop();
       }
+      /**
+       * The ONLY way an entry leaves `entries`. Centralised because a screencast
+       * outlives the map otherwise: its frame handler closes over the entry rather
+       * than looking it up, so an entry deleted without stopScreencast() leaves
+       * Chromium encoding and acking frames for a page nobody is watching, holding
+       * the CDP session and Page alive. Eviction and the staleness sweep both used
+       * to delete directly and leaked exactly that way.
+       */
+      dropEntry(sessionId, entry) {
+        void this.stopScreencast(entry);
+        entry.page = null;
+        this.entries.delete(sessionId);
+      }
       setPage(sessionId, page) {
         const entry = this.entries.get(sessionId);
         if (!entry)
           return;
+        if (entry.screencast && entry.screencast.page !== page)
+          void this.stopScreencast(entry);
         entry.page = page;
         entry.lastUpdatedAt = Date.now();
         if (page) {
@@ -352162,6 +352250,119 @@ var require_live_browser_registry = __commonJS({
               entry.currentUrl = url;
           } catch {
           }
+          void this.startScreencast(entry, page);
+        }
+      }
+      /**
+       * Begin a CDP screencast for this page. Chromium then pushes a JPEG on every
+       * paint, already downscaled to LIVE_FRAME_MAX_DIMENSION — which is the only
+       * way this runner can downscale at all, since it ships no image library.
+       *
+       * Best-effort by design: any failure leaves `screencast` null and the polling
+       * screenshot loop keeps serving the entry exactly as before.
+       */
+      async startScreencast(entry, page) {
+        if (!page || entry.screencast || entry.screencastStarting)
+          return;
+        if (page.isClosed?.())
+          return;
+        entry.screencastStarting = true;
+        try {
+          const client = await page.context().newCDPSession(page);
+          const binding = { client, page, stopped: false };
+          client.on("Page.screencastFrame", (params) => {
+            void client.send("Page.screencastFrameAck", { sessionId: params.sessionId }).catch(() => {
+            });
+            if (binding.stopped)
+              return;
+            if (this.entries.get(entry.meta.sessionId) !== entry)
+              return;
+            if (typeof params.data !== "string" || params.data.length === 0)
+              return;
+            const width = params.metadata?.deviceWidth;
+            const height = params.metadata?.deviceHeight;
+            this.acceptFrame(entry, params.data, "image/jpeg", width, height);
+          });
+          page.once("close", () => {
+            void this.stopScreencast(entry);
+          });
+          page.once("crash", () => {
+            void this.stopScreencast(entry);
+          });
+          await client.send("Page.enable");
+          await client.send("Page.startScreencast", {
+            format: "jpeg",
+            quality: shared_1.LIVE_FRAME_JPEG_QUALITY,
+            // Absolute bounds, aspect-preserving — Chromium does the resize.
+            maxWidth: shared_1.LIVE_FRAME_MAX_DIMENSION,
+            maxHeight: shared_1.LIVE_FRAME_MAX_DIMENSION,
+            everyNthFrame: 1
+          });
+          if (this.entries.get(entry.meta.sessionId) !== entry || entry.page !== page) {
+            binding.stopped = true;
+            await client.send("Page.stopScreencast").catch(() => {
+            });
+            await client.detach().catch(() => {
+            });
+            return;
+          }
+          entry.screencast = binding;
+        } catch {
+        } finally {
+          entry.screencastStarting = false;
+        }
+      }
+      async stopScreencast(entry) {
+        const binding = entry.screencast;
+        if (!binding || binding.stopped)
+          return;
+        binding.stopped = true;
+        entry.screencast = null;
+        try {
+          await binding.client.send("Page.stopScreencast");
+        } catch {
+        }
+        try {
+          await binding.client.detach();
+        } catch {
+        }
+      }
+      /**
+       * Record a freshly captured frame and forward it to the real-time publisher.
+       * The stored copy (used by the heartbeat fallback) is only replaced when it
+       * fits the heartbeat budget, but the publisher — which has a far larger budget
+       * of its own — always sees the frame.
+       */
+      acceptFrame(entry, base64, mimeType, width, height) {
+        const now = Date.now();
+        entry.lastUpdatedAt = now;
+        if (base64.length <= shared_1.LIVE_THUMBNAIL_MAX_BASE64_BYTES) {
+          entry.thumbnailJpegBase64 = base64;
+          entry.thumbnailCapturedAt = now;
+          if (width !== void 0)
+            entry.thumbnailWidth = width;
+          if (height !== void 0)
+            entry.thumbnailHeight = height;
+        }
+        const publisher = this.publisher;
+        if (!publisher)
+          return;
+        if (now - entry.lastPublishedAt < shared_1.LIVE_FRAME_MIN_PUSH_INTERVAL_MS)
+          return;
+        entry.lastPublishedAt = now;
+        try {
+          publisher({
+            sessionId: entry.meta.sessionId,
+            projectId: entry.meta.projectId,
+            runId: entry.meta.runId,
+            capturedAt: now,
+            mimeType,
+            width,
+            height,
+            surface: entry.meta.surface,
+            base64
+          });
+        } catch {
         }
       }
       setCurrentUrl(sessionId, url) {
@@ -352173,7 +352374,7 @@ var require_live_browser_registry = __commonJS({
         const previousUrl = entry.currentUrl;
         entry.currentUrl = url;
         entry.lastUpdatedAt = Date.now();
-        if (url && previousUrl && url !== previousUrl) {
+        if (url && previousUrl && url !== previousUrl && !entry.screencast) {
           entry.pendingCapture = true;
           const schedule = (delay) => {
             setTimeout(() => {
@@ -352194,6 +352395,11 @@ var require_live_browser_registry = __commonJS({
           schedule(100);
         }
       }
+      /**
+       * Ingest a frame captured outside this module — the mobile mirror and the
+       * spawned `playwright test` child (whose Page lives in another process, so no
+       * CDP screencast is reachable from here) both arrive this way.
+       */
       updateSnapshot(sessionId, snapshot) {
         const entry = this.entries.get(sessionId);
         if (!entry)
@@ -352202,12 +352408,10 @@ var require_live_browser_registry = __commonJS({
           entry.currentUrl = snapshot.currentUrl;
         }
         const thumbnail = snapshot.thumbnailJpegBase64;
-        const thumbnailLimit = entry.meta.surface === "mobile" ? MOBILE_THUMBNAIL_MAX_BASE64_BYTES : BROWSER_THUMBNAIL_MAX_BASE64_BYTES;
-        if (thumbnail && thumbnail.length <= thumbnailLimit) {
-          entry.thumbnailJpegBase64 = thumbnail;
-          entry.thumbnailCapturedAt = typeof snapshot.thumbnailCapturedAt === "number" && Number.isFinite(snapshot.thumbnailCapturedAt) ? snapshot.thumbnailCapturedAt : Date.now();
-          entry.thumbnailWidth = typeof snapshot.thumbnailWidth === "number" && Number.isFinite(snapshot.thumbnailWidth) ? snapshot.thumbnailWidth : void 0;
-          entry.thumbnailHeight = typeof snapshot.thumbnailHeight === "number" && Number.isFinite(snapshot.thumbnailHeight) ? snapshot.thumbnailHeight : void 0;
+        if (thumbnail) {
+          const width = typeof snapshot.thumbnailWidth === "number" && Number.isFinite(snapshot.thumbnailWidth) ? snapshot.thumbnailWidth : void 0;
+          const height = typeof snapshot.thumbnailHeight === "number" && Number.isFinite(snapshot.thumbnailHeight) ? snapshot.thumbnailHeight : void 0;
+          this.acceptFrame(entry, thumbnail, snapshot.mimeType ?? "image/jpeg", width, height);
         }
         entry.lastUpdatedAt = Date.now();
       }
@@ -352250,9 +352454,11 @@ var require_live_browser_registry = __commonJS({
       async captureAllNow() {
         await this.captureAll();
       }
-      /** Stop the snapshot loop and clear all entries. Idempotent. */
+      /** Stop the snapshot loop, tear down every screencast, and clear all entries. Idempotent. */
       shutdown() {
         this.stopSnapshotLoop();
+        for (const entry of this.entries.values())
+          void this.stopScreencast(entry);
         this.entries.clear();
       }
       ensureSnapshotLoop() {
@@ -352280,15 +352486,13 @@ var require_live_browser_registry = __commonJS({
           }
         }
         if (oldestKey) {
-          this.entries.get(oldestKey).page = null;
-          this.entries.delete(oldestKey);
+          this.dropEntry(oldestKey, this.entries.get(oldestKey));
         }
       }
       sweepStale(now) {
         for (const [key, entry] of this.entries) {
           if (now - entry.lastUpdatedAt > STALE_SESSION_MS) {
-            entry.page = null;
-            this.entries.delete(key);
+            this.dropEntry(key, entry);
           }
         }
       }
@@ -352329,6 +352533,11 @@ var require_live_browser_registry = __commonJS({
               entry.currentUrl = url;
           } catch {
           }
+          if (entry.screencast) {
+            if (entry.thumbnailJpegBase64)
+              entry.thumbnailCapturedAt = Date.now();
+            return;
+          }
           const buf = await page.screenshot({
             type: "jpeg",
             quality: THUMBNAIL_QUALITY,
@@ -352336,17 +352545,8 @@ var require_live_browser_registry = __commonJS({
             timeout: 3e3,
             scale: "css"
           });
-          const base64 = buf.toString("base64");
-          if (base64.length > BROWSER_THUMBNAIL_MAX_BASE64_BYTES) {
-            return;
-          }
-          entry.thumbnailJpegBase64 = base64;
-          entry.thumbnailCapturedAt = Date.now();
           const viewport = page.viewportSize?.();
-          if (viewport) {
-            entry.thumbnailWidth = viewport.width;
-            entry.thumbnailHeight = viewport.height;
-          }
+          this.acceptFrame(entry, buf.toString("base64"), "image/jpeg", viewport?.width, viewport?.height);
         } catch {
         } finally {
           entry.isCapturing = false;
@@ -353060,7 +353260,7 @@ var require_package4 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.78",
+      version: "1.0.79",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -353852,6 +354052,24 @@ async function getScreenshot(sessionPath) {
     return null;
   }
 }
+async function applyMjpegSettings(sessionPath, settings) {
+  try {
+    await appiumRequest(`${sessionPath}/appium/settings`, {
+      method: "POST",
+      body: JSON.stringify({
+        settings: {
+          mjpegServerFramerate: settings.framerate,
+          mjpegScalingFactor: settings.scalingFactor,
+          mjpegServerScreenshotQuality: settings.quality
+        }
+      })
+    });
+    return true;
+  } catch (err) {
+    if (isAppiumDriverDeadError(err)) throw err;
+    return false;
+  }
+}
 async function getPageSource(sessionPath) {
   try {
     const value = readValue(await appiumRequest(`${sessionPath}/source`));
@@ -356360,7 +356578,15 @@ function mobileParallelSessionCapabilities(platform3, portOffset = 0, deviceId =
     return (Number.isFinite(parsed) ? parsed : fallback) + offset;
   };
   if (platform3 === "ANDROID") {
-    return { "appium:systemPort": readPort("APPIUM_SYSTEM_PORT", 8200) };
+    return {
+      "appium:systemPort": readPort("APPIUM_SYSTEM_PORT", 8200),
+      // Host port that UiAutomator2 forwards the on-device MJPEG broadcaster
+      // (device port 7810) to. Without this the live mirror has to poll
+      // WebDriver /screenshot for full-resolution PNGs, which the runner cannot
+      // downscale itself. Base differs from iOS's 9100 so a concurrent
+      // Android+iOS pair can never collide on a shared slot offset.
+      "appium:mjpegServerPort": readPort("APPIUM_ANDROID_MJPEG_SERVER_PORT", 7810)
+    };
   }
   const safeDevice = deviceId.replace(/[^A-Za-z0-9._-]+/g, "-") || `device-${offset}`;
   const derivedDataRoot = env.APPIUM_DERIVED_DATA_PATH?.trim() || (0, import_node_path2.join)((0, import_node_os2.tmpdir)(), "validateqa-wda");
@@ -357615,6 +357841,15 @@ function acquireControlPortSlot(deviceId) {
 function releaseControlPortSlot(deviceId) {
   controlPortSlotsByDevice.delete(deviceId);
 }
+function getControlPortSlot(deviceId) {
+  return controlPortSlotsByDevice.get(deviceId);
+}
+function mobileMjpegPortForDevice(platform3, deviceId, env = process.env) {
+  const slot = getControlPortSlot(deviceId);
+  if (slot === void 0) return null;
+  const port = mobileParallelSessionCapabilities(platform3, slot, deviceId, env)["appium:mjpegServerPort"];
+  return typeof port === "number" && Number.isFinite(port) ? port : null;
+}
 var PINNED_DEVICE_SNAPSHOT_TTL_MS = 25 * 6e4;
 var pinnedDeviceSnapshot = null;
 async function executeMobileTest(options) {
@@ -358553,12 +358788,106 @@ function decideMobileDeviceGate(input) {
 }
 
 // src/services/mobile-bridge.ts
-var import_http = require("http");
+var import_http2 = require("http");
 var import_child_process4 = require("child_process");
 var import_crypto = require("crypto");
 var import_os4 = require("os");
 var import_path4 = require("path");
 var import_fs3 = require("fs");
+
+// src/services/mobile/mjpeg-stream.ts
+var import_http = require("http");
+init_dist();
+var JPEG_SOI = Buffer.from([255, 216]);
+var JPEG_EOI = Buffer.from([255, 217]);
+function startMjpegStream(options) {
+  const { port, host = "127.0.0.1", onFrame, onError } = options;
+  let stopped = false;
+  let req = null;
+  let response = null;
+  let buffer = Buffer.alloc(0);
+  const fail = (error2) => {
+    if (stopped) return;
+    stopped = true;
+    try {
+      req?.destroy();
+    } catch {
+    }
+    try {
+      response?.destroy();
+    } catch {
+    }
+    buffer = Buffer.alloc(0);
+    onError?.(error2);
+  };
+  const consume = (chunk) => {
+    if (stopped) return;
+    buffer = buffer.length === 0 ? chunk : Buffer.concat([buffer, chunk]);
+    for (; ; ) {
+      const start = buffer.indexOf(JPEG_SOI);
+      if (start < 0) {
+        if (buffer.length > 1) buffer = buffer.subarray(buffer.length - 1);
+        return;
+      }
+      const end = buffer.indexOf(JPEG_EOI, start + JPEG_SOI.length);
+      if (end < 0) {
+        if (start > 0) buffer = buffer.subarray(start);
+        if (buffer.length > MOBILE_MJPEG_MAX_FRAME_BYTES) buffer = Buffer.alloc(0);
+        return;
+      }
+      const frameEnd = end + JPEG_EOI.length;
+      const frame = buffer.subarray(start, frameEnd);
+      buffer = buffer.subarray(frameEnd);
+      try {
+        onFrame(frame);
+      } catch {
+      }
+    }
+  };
+  try {
+    req = (0, import_http.request)(
+      { host, port, path: "/", method: "GET", headers: { Connection: "keep-alive" } },
+      (res) => {
+        response = res;
+        if (stopped) {
+          res.destroy();
+          return;
+        }
+        if (res.statusCode && res.statusCode >= 400) {
+          fail(new Error(`MJPEG broadcaster returned HTTP ${res.statusCode}`));
+          res.destroy();
+          return;
+        }
+        res.on("data", (chunk) => consume(chunk));
+        res.on("end", () => fail(new Error("MJPEG stream ended")));
+        res.on("error", (err) => fail(err));
+      }
+    );
+    req.on("error", (err) => fail(err));
+    req.setTimeout(1e4, () => fail(new Error("MJPEG connect timeout")));
+    req.end();
+  } catch (err) {
+    fail(err instanceof Error ? err : new Error(String(err)));
+  }
+  return {
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      try {
+        req?.destroy();
+      } catch {
+      }
+      try {
+        response?.destroy();
+      } catch {
+      }
+      buffer = Buffer.alloc(0);
+    },
+    isActive: () => !stopped
+  };
+}
+
+// src/services/mobile-bridge.ts
 init_dist();
 var MOBILE_BRIDGE_PORT2 = 9515;
 var MAX_REQUEST_BODY_BYTES = 64 * 1024;
@@ -359112,16 +359441,66 @@ function writeFrameToChannelClient(ch, client, frame) {
   } catch {
   }
 }
+function broadcastChannelFrame(ch, frame) {
+  ch.lastFrame = frame;
+  for (const client of ch.clients) writeFrameToChannelClient(ch, client, frame);
+}
+function tryStartChannelMjpeg(ch) {
+  if (ch.mjpeg || ch.mjpegStarting || ch.mjpegUnavailable) return;
+  const port = mobileMjpegPortForDevice(ch.platform, ch.deviceId);
+  if (port === null) {
+    ch.mjpegUnavailable = true;
+    return;
+  }
+  ch.mjpegStarting = true;
+  const handle = startMjpegStream({
+    port,
+    onFrame: (jpeg) => {
+      const isOwned = ch.mjpeg === handle;
+      const isCandidate = ch.mjpeg === null && ch.mjpegStarting;
+      if (!isOwned && !isCandidate) return;
+      ch.mjpegLastFrameAt = Date.now();
+      ch.nullTicks = 0;
+      if (isCandidate) {
+        ch.mjpeg = handle;
+        ch.mjpegStarting = false;
+        if (ch.pollTimer) {
+          clearInterval(ch.pollTimer);
+          ch.pollTimer = null;
+        }
+      }
+      broadcastChannelFrame(ch, {
+        timestamp: ch.mjpegLastFrameAt,
+        screenshot: jpeg.toString("base64"),
+        source: null,
+        mimeType: "image/jpeg"
+      });
+    },
+    onError: () => {
+      const wasActive = ch.mjpeg === handle;
+      ch.mjpeg = null;
+      ch.mjpegStarting = false;
+      ch.mjpegUnavailable = true;
+      if (wasActive && ch.clients.size > 0) ensureChannelPolling(ch);
+    }
+  });
+  const firstFrameDeadline = setTimeout(() => {
+    if (ch.mjpeg) return;
+    ch.mjpegStarting = false;
+    ch.mjpegUnavailable = true;
+    handle.stop();
+    if (ch.clients.size > 0) ensureChannelPolling(ch);
+  }, MOBILE_MJPEG_FIRST_FRAME_TIMEOUT_MS);
+  firstFrameDeadline.unref?.();
+}
 async function pollRunnerChannel(ch) {
   if (ch.clients.size === 0 || ch.polling) return;
+  if (ch.mjpeg) 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) {
+    const screenshot = await getScreenshot(`/session/${ch.sessionId}`);
+    if (!screenshot) {
       ch.nullTicks++;
       if (ch.nullTicks >= MIRROR_DEAD_SESSION_TICKS) {
         const alive = await isSessionAlive(ch.sessionId);
@@ -359134,32 +359513,45 @@ async function pollRunnerChannel(ch) {
     } 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);
+    broadcastChannelFrame(ch, {
+      timestamp: Date.now(),
+      screenshot: screenshot ?? null,
+      source: null,
+      mimeType: "image/png"
+    });
   } catch {
   } finally {
     ch.polling = false;
   }
 }
 function ensureChannelPolling(ch) {
-  if (ch.pollTimer) return;
+  tryStartChannelMjpeg(ch);
+  if (ch.mjpeg || 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) {
+  if (ch.clients.size > 0) return;
+  if (ch.pollTimer) {
     clearInterval(ch.pollTimer);
     ch.pollTimer = null;
   }
+  if (ch.mjpeg) {
+    ch.mjpeg.stop();
+    ch.mjpeg = null;
+  }
 }
 function closeRunnerChannel(ch) {
   if (ch.pollTimer) {
     clearInterval(ch.pollTimer);
     ch.pollTimer = null;
   }
+  if (ch.mjpeg) {
+    ch.mjpeg.stop();
+    ch.mjpeg = null;
+  }
   for (const client of ch.clients) {
     try {
       client.end();
@@ -359556,7 +359948,7 @@ async function startMobileBridge(options) {
   }
   killStaleBridge();
   return new Promise((resolve2, reject) => {
-    server2 = (0, import_http.createServer)(route);
+    server2 = (0, import_http2.createServer)(route);
     server2.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
         reject(new Error(`Port ${port} already in use. Another bridge instance may be running.`));
@@ -359744,12 +360136,24 @@ function attachMirrorSession(sessionId, platform3, deviceId) {
       lastFrame: null,
       pollTimer: null,
       nullTicks: 0,
-      polling: false
+      polling: false,
+      mjpeg: null,
+      mjpegLastFrameAt: 0,
+      mjpegStarting: false,
+      mjpegUnavailable: false
     };
     ch.sessionId = sessionId;
     ch.platform = platform3;
     ch.nullTicks = 0;
+    if (ch.mjpeg) {
+      ch.mjpeg.stop();
+      ch.mjpeg = null;
+    }
+    ch.mjpegUnavailable = false;
+    ch.mjpegStarting = false;
     runnerChannels.set(deviceId, ch);
+    void applyMjpegSettings(`/session/${sessionId}`, MOBILE_MJPEG_SETTINGS).catch(() => {
+    });
     if (ch.clients.size > 0) {
       ensureChannelPolling(ch);
       void pollRunnerChannel(ch);
@@ -362933,7 +363337,9 @@ ${finalVerifyResult.logs ?? ""}`;
                 liveBrowserHandle.updateSnapshot({
                   currentUrl: mobileTarget.appId,
                   thumbnailJpegBase64: base64,
-                  thumbnailCapturedAt: Date.now()
+                  thumbnailCapturedAt: Date.now(),
+                  // Appium's screenshot endpoint returns PNG despite the field name.
+                  mimeType: "image/png"
                 });
                 requestLiveBrowserHeartbeat();
               },
@@ -364178,6 +364584,22 @@ async function startRunner(opts) {
     } catch {
     }
   };
+  const liveFramePushInFlight = /* @__PURE__ */ new Set();
+  const publishLiveFrame = (frame) => {
+    if (!frame.projectId) return;
+    if (liveFramePushInFlight.has(frame.sessionId)) return;
+    liveFramePushInFlight.add(frame.sessionId);
+    void fetch(`${serverUrl}/api/runner/live-frame`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(frame),
+      signal: AbortSignal.timeout(5e3)
+    }).catch(() => {
+    }).finally(() => {
+      liveFramePushInFlight.delete(frame.sessionId);
+    });
+  };
+  import_runner_core11.liveBrowserRegistry.setFramePublisher(publishLiveFrame);
   let liveBrowserHeartbeatInFlight = false;
   let liveBrowserHeartbeatPending = false;
   let lastLiveBrowserHeartbeatAt = 0;