@validate.qa/runner 1.0.78 → 1.0.80

package/dist/cli.mjs

@@ -1893,6 +1893,57 @@ 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_IDLE_PUSH_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_IDLE_PUSH_INTERVAL_MS = readEnvInt("LIVE_FRAME_IDLE_PUSH_INTERVAL_MS", 5e3);
+    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);
@@ -6315,6 +6366,15 @@ __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_IDLE_PUSH_INTERVAL_MS: () => LIVE_FRAME_IDLE_PUSH_INTERVAL_MS,
+  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,
@@ -6326,6 +6386,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,
@@ -6438,6 +6501,7 @@ __export(dist_exports, {
   isTestReadyForPlatform: () => isTestReadyForPlatform,
   isTrialExpired: () => isTrialExpired,
   isUIVariant: () => isUIVariant,
+  isValidLiveFrame: () => isValidLiveFrame,
   isValidMobileAppId: () => isValidMobileAppId,
   isValidProjectKey: () => isValidProjectKey,
   isValidSttProvider: () => isValidSttProvider,
@@ -6500,6 +6564,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();
@@ -87962,6 +88027,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 = [];
@@ -88051,7 +88117,7 @@ test.beforeEach(async ({ page }, testInfo) => {
   await __qaLiveBrowserCapture();
   __qaLiveBrowserInterval = setInterval(() => {
     void __qaLiveBrowserCapture?.();
-  }, 500);
+  }, ${LIVE_BROWSER_STATE_POLL_INTERVAL_MS});
 });
 
 test.afterEach(async () => {
@@ -88468,7 +88534,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 () => {
@@ -320992,6 +321058,7 @@ var require_primary_action_ledger = __commonJS({
     exports.isLedgerActive = isLedgerActive;
     exports.isGateEnforcing = isGateEnforcing;
     exports.isSteeringActive = isSteeringActive;
+    exports.isPrimaryActionCoverageGapEnabled = isPrimaryActionCoverageGapEnabled;
     exports.leadingVerb = leadingVerb;
     exports.classifyPrimaryAction = classifyPrimaryAction;
     exports.containerScopeOf = containerScopeOf;
@@ -321006,6 +321073,8 @@ var require_primary_action_ledger = __commonJS({
     exports.classifyActionOutcome = classifyActionOutcome;
     exports.detectPrimaryActions = detectPrimaryActions;
     exports.summarizeLedger = summarizeLedger;
+    exports.summarizeUnexercisedPrimaries = summarizeUnexercisedPrimaries;
+    exports.buildUnexercisedPrimaryCoverageGaps = buildUnexercisedPrimaryCoverageGaps;
     var reveal_diff_js_1 = require_reveal_diff();
     var exploration_parser_js_1 = require_exploration_parser();
     function getPrimaryActionGateMode(env = process.env) {
@@ -321025,6 +321094,10 @@ var require_primary_action_ledger = __commonJS({
     function isSteeringActive(mode) {
       return mode === "advisory" || mode === "enforce";
     }
+    function isPrimaryActionCoverageGapEnabled(env = process.env) {
+      const raw = (env.DISCOVERY_PRIMARY_ACTION_COVERAGE_GAP ?? "").trim().toLowerCase();
+      return raw === "1" || raw === "true" || raw === "on" || raw === "enabled";
+    }
     exports.PRIMARY_ACTION_VERB_RE = /^(run|analyze|analyse|generate|regenerate|process|submit|save|create|send|upload|search|export|import|calculate|recalculate|compute|convert|start|scan|translate|transcribe|render|publish|sync|deploy|enrich|summar(?:ize|ise))\b/i;
     exports.AMBIGUOUS_ACTION_VERB_RE = /^(continue|next|apply|go|proceed|confirm|update|add|edit|ok|done|finish|complete|approve|enable|activate)\b/i;
     exports.DESTRUCTIVE_ACTION_VERB_RE = /^(delete|remove|archive|reset|disconnect|deactivate|destroy|purge|revoke|discard|drop|wipe|erase|unsubscribe|cancel|clear|trash)\b/i;
@@ -321288,6 +321361,47 @@ var require_primary_action_ledger = __commonJS({
       }
       return `actions=${c.total} primary{detected=${c.detected} attempted=${c.attempted} captured=${c.captured} blocked=${c.blocked} exempt=${c.exempt}} ambiguous=${c.ambiguous}`;
     }
+    function summarizeUnexercisedPrimaries(ledger, routeInScope, cap = 12) {
+      const out = [];
+      for (const e of getBlockingActionDebt(ledger, routeInScope)) {
+        if (e.status !== "DETECTED" && e.status !== "ATTEMPTED")
+          continue;
+        out.push({ label: e.label, route: e.route, containerScope: e.containerScope, status: e.status });
+        if (out.length >= cap)
+          break;
+      }
+      return out;
+    }
+    var REGEXP_META_RE = /[.*+?^${}()|[\]\\]/g;
+    function labelCoveredByPlan(normLabel, plannedLower) {
+      if (!normLabel.includes(" "))
+        return false;
+      const escaped = normLabel.replace(REGEXP_META_RE, "\\$&");
+      return new RegExp(`(^|\\W)${escaped}($|\\W)`).test(plannedLower);
+    }
+    function buildUnexercisedPrimaryCoverageGaps(unexercised, plannedScenarioText, nowIso) {
+      const gaps = [];
+      const seen = /* @__PURE__ */ new Set();
+      const planned = plannedScenarioText.toLowerCase();
+      for (const a of unexercised) {
+        const norm = normLabelKey(a.label);
+        const key = `${norm}|${a.route}`;
+        if (seen.has(key))
+          continue;
+        seen.add(key);
+        if (labelCoveredByPlan(norm, planned))
+          continue;
+        const clickedNote = a.status === "ATTEMPTED" ? "clicked, but no result state was captured" : "never clicked";
+        gaps.push({
+          scenarioName: `Exercise "${a.label}"`,
+          reason: `Primary action "${a.label}" was detected on ${a.route} but never exercised to an observed result (${clickedNote}).`,
+          suggestion: `Exercise "${a.label}" to a captured result \u2014 open its result modal/panel and capture it BEFORE closing \u2014 or schedule a deep run scoped to this action, so a real test can be authored.`,
+          unmetPrerequisites: [],
+          detectedAt: nowIso
+        });
+      }
+      return gaps;
+    }
   }
 });
 
@@ -322776,6 +322890,9 @@ var require_exploration_prompt_builder = __commonJS({
         "These are the feature's core actions \u2014 what it EXISTS to do. You are on a PROVISIONED TEST ACCOUNT, so exercising them is the point of this exploration. For each: click it, wait for it to finish (an async job can take 10-60s \u2014 keep waiting and capturing, do not give up early), then capture_page the result (a new panel, row, score, status, or route change).",
         `Spending in-app COMPUTE credits is expected and budgeted \u2014 running an Analyze / Generate / Run / Process ONCE to observe its output is exactly what you should do; an "N of M used" usage or AI-credit meter is NOT a reason to skip. These were auto-screened, but YOU are the final check: if you can see a specific listed action actually charges REAL money at a checkout (Buy / Upgrade / Subscribe), makes an irreversible or destructive change (Delete / Wipe / Deploy to production), or sends a message to real people (Send email / Invite), SKIP just that one \u2014 note it as blocked with the reason and move on. Don't finish until every other action below has produced an observed outcome:`
       ];
+      if ((0, primary_action_ledger_js_1.isPrimaryActionCoverageGapEnabled)()) {
+        out.push("If the result opens in a modal, dialog, or panel, call capture_page WHILE IT IS STILL OPEN \u2014 do not close or dismiss it first, or the result state is never recorded and the action does not count as covered. An action reachable only from inside this feature's own result modal is in-scope: exercise it to a captured result before closing, even if it generates content that belongs to another builder.");
+      }
       for (const e of debt.slice(0, 8)) {
         const note = e.status === "ATTEMPTED" ? " \u2014 clicked but no result captured yet" : "";
         out.push(`  - "${e.label}" on ${e.route}${note}`);
@@ -326596,6 +326713,7 @@ ${inbox_tools_js_1.EMAIL_VERIFICATION_UNAVAILABLE_OVERRIDE_BLOCK}` : ""}`;
       const primaryActionMode = (0, primary_action_ledger_js_1.getPrimaryActionGateMode)();
       const primaryActionLedgerActive = (0, primary_action_ledger_js_1.isLedgerActive)(primaryActionMode) && options?.mode === "deep";
       const primaryActionEnforcing = primaryActionLedgerActive && (0, primary_action_ledger_js_1.isGateEnforcing)(primaryActionMode);
+      const primaryActionCoverageGapEnabled = primaryActionLedgerActive && (0, primary_action_ledger_js_1.isPrimaryActionCoverageGapEnabled)();
       const prevRouteSignatures = /* @__PURE__ */ new Map();
       const prevInteractionCountsByRoute = /* @__PURE__ */ new Map();
       let previousCaptureRoute = null;
@@ -326606,6 +326724,16 @@ ${inbox_tools_js_1.EMAIL_VERIFICATION_UNAVAILABLE_OVERRIDE_BLOCK}` : ""}`;
       let finishBounce = (0, survey_link_frontier_js_1.initialFinishBounceState)();
       let lastLandedPageUrl = null;
       const state2 = (0, exploration_state_js_1.createExplorationState)();
+      const buildUnexercisedPrimarySummary = () => {
+        if (!primaryActionCoverageGapEnabled)
+          return void 0;
+        const fa = options?.focusAreas ?? [];
+        if (fa.length === 0)
+          return void 0;
+        const otherRoutes = options?.featureContext?.otherFeatures?.flatMap((f) => f.pages);
+        const summary2 = (0, primary_action_ledger_js_1.summarizeUnexercisedPrimaries)(state2.actionLedger, (r) => (0, exploration_parser_js_1.routeIsWithinFocusAreas)(r, fa, otherRoutes), 12);
+        return summary2.length > 0 ? summary2 : void 0;
+      };
       function ingestLinksFromText(rawText) {
         if (!linkFrontierEnabled || !rawText || !rawText.includes("- /url:"))
           return;
@@ -328836,6 +328964,7 @@ Exploration ended after ${iteration} iterations without calling finish_explorati
             summary: state2.summary || summary,
             collectedPages: state2.collectedPages,
             collectedTransitions: state2.collectedTransitions,
+            unexercisedPrimaryActions: buildUnexercisedPrimarySummary(),
             iterationTimeline: iterationTimeline.length > 0 ? iterationTimeline : void 0
           };
         }
@@ -328930,6 +329059,7 @@ Fatal error: ${msg}`);
             summary: `Fatal error: ${msg}`,
             collectedPages: state2.collectedPages,
             collectedTransitions: state2.collectedTransitions,
+            unexercisedPrimaryActions: buildUnexercisedPrimarySummary(),
             iterationTimeline: iterationTimeline.length > 0 ? iterationTimeline : void 0,
             truncated: true,
             truncatedReason,
@@ -337116,6 +337246,7 @@ var require_discover_agent = __commonJS({
     var discover_planner_js_1 = require_discover_planner();
     var discover_generator_js_1 = require_discover_generator();
     var discover_ai_planner_js_1 = require_discover_ai_planner();
+    var primary_action_ledger_js_1 = require_primary_action_ledger();
     var discovery_lint_flags_js_1 = require_discovery_lint_flags();
     var verification_inbox_js_1 = require_verification_inbox();
     var inbox_tools_js_1 = require_inbox_tools();
@@ -338418,6 +338549,16 @@ Plan: ${planResult.scenarios.length} scenarios (budget: ${featureTestBudget})`);
           checkpointFallbackReason = planResult.fallbackReason;
           plannerWarning = planResult.warning;
           plannerCoverageGaps = planResult.coverageGaps;
+          const unexercisedPrimaries = exploreResult.unexercisedPrimaryActions ?? [];
+          if (unexercisedPrimaries.length > 0) {
+            const plannedText = planResult.scenarios.map((s) => `${s.name} ${s.goal ?? ""} ${(s.targetPages ?? []).join(" ")}`).join(" ");
+            const ledgerGaps = (0, primary_action_ledger_js_1.buildUnexercisedPrimaryCoverageGaps)(unexercisedPrimaries, plannedText, (/* @__PURE__ */ new Date()).toISOString());
+            if (ledgerGaps.length > 0) {
+              plannerCoverageGaps = [...plannerCoverageGaps ?? [], ...ledgerGaps];
+            }
+            const suppressed = unexercisedPrimaries.length - ledgerGaps.length;
+            logs2.push(`  [primary-action-ledger] ${unexercisedPrimaries.length} in-scope primary action(s) un-exercised; surfaced ${ledgerGaps.length} as coverage gap(s)${suppressed > 0 ? ` (${suppressed} already covered by the plan / deduped)` : ""}`);
+          }
         }
         if (callbackOptions?.onPlanReady) {
           try {
@@ -352109,16 +352250,16 @@ var require_live_browser_registry = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.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) {
@@ -352132,7 +352273,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();
@@ -352145,19 +352289,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) {
@@ -352167,6 +352332,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) {
@@ -352178,7 +352456,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(() => {
@@ -352199,6 +352477,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)
@@ -352207,12 +352490,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();
       }
@@ -352255,9 +352536,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() {
@@ -352285,15 +352568,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);
           }
         }
       }
@@ -352334,6 +352615,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,
@@ -352341,17 +352627,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;
@@ -353065,7 +353342,7 @@ var require_package4 = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.78",
+      version: "1.0.80",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -353334,6 +353611,9 @@ async function enforceRunnerUpToDate(currentVersion, opts = {}) {
   return result;
 }
 
+// src/runner.ts
+init_dist();
+
 // src/services/appium-executor.ts
 init_dist();
 
@@ -353857,6 +354137,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`));
@@ -356368,7 +356666,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() || join5(tmpdir3(), "validateqa-wda");
@@ -357623,6 +357929,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) {
@@ -358567,8 +358882,103 @@ import { randomBytes, timingSafeEqual } from "crypto";
 import { homedir as homedir2 } from "os";
 import { join as join6, dirname } from "path";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, mkdirSync as mkdirSync3 } from "fs";
+
+// src/services/mobile/mjpeg-stream.ts
+init_dist();
+import { request as httpRequest } from "http";
+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 = httpRequest(
+      { 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 RELAY_DEMAND_POLL_MS = 2e3;
 var MAX_REQUEST_BODY_BYTES = 64 * 1024;
 var MAX_TEXT_INPUT_LENGTH = 4e3;
 var MAX_APP_ID_LENGTH = 255;
@@ -359080,6 +359490,18 @@ async function handleSessionStop(_req, res) {
   sendJSON(res, 200, { ok: true });
 }
 var runnerChannels = /* @__PURE__ */ new Map();
+var relayDemandTimer = null;
+function setMirrorRelay(deviceId, relay) {
+  const ch = runnerChannels.get(deviceId);
+  if (!ch) return;
+  ch.relay = relay;
+  if (relay) {
+    ensureRelayDemandSupervisor();
+    if (hasChannelDemand(ch)) ensureChannelPolling(ch);
+  } else {
+    stopChannelCaptureIfIdle(ch);
+  }
+}
 function readDeviceIdParam(req) {
   try {
     const url = new URL(req.url || "", "http://localhost");
@@ -359111,7 +359533,7 @@ function writeFrameToChannelClient(ch, client, frame) {
       } catch {
       }
       ch.clients.delete(client);
-      stopChannelPollingIfIdle(ch);
+      stopChannelCaptureIfIdle(ch);
       return;
     }
     client.write(`data: ${JSON.stringify(frame)}
@@ -359120,16 +359542,95 @@ function writeFrameToChannelClient(ch, client, frame) {
   } catch {
   }
 }
+function broadcastChannelFrame(ch, frame) {
+  ch.lastFrame = frame;
+  for (const client of ch.clients) writeFrameToChannelClient(ch, client, frame);
+  if (ch.relay && frame.screenshot) {
+    try {
+      ch.relay.onFrame(frame.screenshot, frame.mimeType ?? "image/png");
+    } catch {
+    }
+  }
+}
+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 && hasChannelDemand(ch)) ensureChannelPolling(ch);
+    }
+  });
+  const firstFrameDeadline = setTimeout(() => {
+    if (ch.mjpeg) return;
+    ch.mjpegStarting = false;
+    ch.mjpegUnavailable = true;
+    handle.stop();
+    if (hasChannelDemand(ch)) ensureChannelPolling(ch);
+  }, MOBILE_MJPEG_FIRST_FRAME_TIMEOUT_MS);
+  firstFrameDeadline.unref?.();
+}
+function hasChannelDemand(ch) {
+  if (ch.clients.size > 0) return true;
+  if (!ch.relay) return false;
+  try {
+    return ch.relay.wanted();
+  } catch {
+    return false;
+  }
+}
+function ensureRelayDemandSupervisor() {
+  if (relayDemandTimer) return;
+  relayDemandTimer = setInterval(() => {
+    for (const ch of [...runnerChannels.values()]) {
+      if (hasChannelDemand(ch)) ensureChannelPolling(ch);
+      else stopChannelCaptureIfIdle(ch);
+    }
+    if (runnerChannels.size === 0 && relayDemandTimer) {
+      clearInterval(relayDemandTimer);
+      relayDemandTimer = null;
+    }
+  }, RELAY_DEMAND_POLL_MS);
+  relayDemandTimer.unref?.();
+}
 async function pollRunnerChannel(ch) {
-  if (ch.clients.size === 0 || ch.polling) return;
+  if (!hasChannelDemand(ch) || 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);
@@ -359142,32 +359643,47 @@ 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;
+  if (!hasChannelDemand(ch)) 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) {
+function stopChannelCaptureIfIdle(ch) {
+  if (hasChannelDemand(ch)) 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;
+  }
+  ch.relay = null;
   for (const client of ch.clients) {
     try {
       client.end();
@@ -359176,7 +359692,7 @@ function closeRunnerChannel(ch) {
   }
   ch.clients.clear();
   ch.lastFrame = null;
-  runnerChannels.delete(ch.deviceId);
+  if (runnerChannels.get(ch.deviceId) === ch) runnerChannels.delete(ch.deviceId);
 }
 function closeAllRunnerChannels() {
   for (const ch of [...runnerChannels.values()]) closeRunnerChannel(ch);
@@ -359198,7 +359714,7 @@ async function serveRunnerMirror(req, res, ch) {
   }
   req.on("close", () => {
     ch.clients.delete(res);
-    stopChannelPollingIfIdle(ch);
+    stopChannelCaptureIfIdle(ch);
   });
 }
 async function handleMirror(req, res) {
@@ -359752,13 +360268,26 @@ function attachMirrorSession(sessionId, platform3, deviceId) {
       lastFrame: null,
       pollTimer: null,
       nullTicks: 0,
-      polling: false
+      polling: false,
+      mjpeg: null,
+      mjpegLastFrameAt: 0,
+      mjpegStarting: false,
+      mjpegUnavailable: false,
+      relay: null
     };
     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);
-    if (ch.clients.size > 0) {
+    void applyMjpegSettings(`/session/${sessionId}`, MOBILE_MJPEG_SETTINGS).catch(() => {
+    });
+    if (hasChannelDemand(ch)) {
       ensureChannelPolling(ch);
       void pollRunnerChannel(ch);
     }
@@ -360730,6 +361259,13 @@ function attachMobileDiscoveryNetworkContext(calls, result, appId) {
   }));
 }
 var runnerPackage = require_package4();
+var MIRROR_RELAY_FRESH_MS = 3e3;
+var liveFrameWatchedByProject = /* @__PURE__ */ new Map();
+var liveFrameIdleProbeAt = /* @__PURE__ */ new Map();
+var LIVE_FRAME_IDLE_PROBE_MAX_ENTRIES = 256;
+function isLiveFrameWatched(projectId) {
+  return !projectId || liveFrameWatchedByProject.get(projectId) !== false;
+}
 var SECRET_VAR_PATTERN = /password|secret|token|api[_]?key|pass\b|credential|bearer|pat\b/i;
 var IS_CLOUD = parseBoolFlag(process.env.RUNNER_CLOUD);
 var RUNNER_NAME = runnerPackage.name ?? "@validate.qa/runner";
@@ -361507,6 +362043,22 @@ async function executeRun(run2, opts, headers, requestLiveBrowserHeartbeat = ()
     testCaseId: run2.testCaseId ?? void 0
   });
   requestLiveBrowserHeartbeat(true);
+  let lastMirrorRelayFrameAt = 0;
+  const attachMirrorWithRelay = (sessionId, platform3, deviceId) => {
+    attachMirrorSession(sessionId, platform3, deviceId);
+    if (!deviceId) return;
+    setMirrorRelay(deviceId, {
+      onFrame: (base64, mimeType) => {
+        lastMirrorRelayFrameAt = Date.now();
+        liveBrowserHandle.updateSnapshot({
+          thumbnailJpegBase64: base64,
+          thumbnailCapturedAt: Date.now(),
+          mimeType
+        });
+      },
+      wanted: () => isLiveFrameWatched(run2.projectId)
+    });
+  };
   const liveBrowserHeartbeatInterval = setInterval(() => {
     liveBrowserHandle.patch({});
     requestLiveBrowserHeartbeat();
@@ -362410,7 +362962,7 @@ ${finalVerifyResult.logs ?? ""}`;
               deeplink: harvestTarget.deeplink
             },
             onSessionReady: (sessionId, deviceId, sessionPlatform) => {
-              attachMirrorSession(sessionId, sessionPlatform, deviceId);
+              attachMirrorWithRelay(sessionId, sessionPlatform, deviceId);
               const name = getCachedDeviceSnapshot().find((d) => d.id === deviceId)?.name;
               liveBrowserHandle.patch({ deviceId, ...name ? { deviceName: name } : {} });
               requestLiveBrowserHeartbeat(true);
@@ -362880,7 +363432,7 @@ ${finalVerifyResult.logs ?? ""}`;
               }
             );
             mobileOnLog(`Appium session created: ${session.sessionId} on device ${session.deviceId}`);
-            attachMirrorSession(session.sessionId, platform3, session.deviceId);
+            attachMirrorWithRelay(session.sessionId, platform3, session.deviceId);
             const driver = new MobileBridgeDriver({
               sessionId: session.sessionId,
               platform: platform3,
@@ -362917,7 +363469,7 @@ ${finalVerifyResult.logs ?? ""}`;
                   throw new Error("discovery teardown started during session recovery \u2014 replacement session closed");
                 }
                 session = replacement;
-                attachMirrorSession(replacement.sessionId, platform3, replacement.deviceId);
+                attachMirrorWithRelay(replacement.sessionId, platform3, replacement.deviceId);
                 liveBrowserHandle.patch({
                   deviceId: replacement.deviceId,
                   deviceName: replacement.deviceName
@@ -362938,10 +363490,16 @@ ${finalVerifyResult.logs ?? ""}`;
               // UI a reliable mobile fallback when the direct bridge SSE is
               // still opening or blocked by the user's network/tunnel.
               onScreenshot: (base64) => {
+                if (Date.now() - lastMirrorRelayFrameAt < MIRROR_RELAY_FRESH_MS) {
+                  liveBrowserHandle.updateSnapshot({ currentUrl: mobileTarget.appId });
+                  return;
+                }
                 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();
               },
@@ -363408,7 +363966,7 @@ ${finalVerifyResult.logs ?? ""}`;
                   deeplink: target.deeplink
                 });
                 liveSession = opened;
-                attachMirrorSession(opened.sessionId, target.platform, opened.deviceId);
+                attachMirrorWithRelay(opened.sessionId, target.platform, opened.deviceId);
                 bridgeDriver = new MobileBridgeDriver({
                   sessionId: opened.sessionId,
                   platform: target.platform,
@@ -363598,7 +364156,7 @@ ${finalVerifyResult.logs ?? ""}`;
             // 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);
+              attachMirrorWithRelay(sessionId, sessionPlatform, deviceId);
               requestLiveBrowserHeartbeat(true);
             },
             onSessionEnding: (deviceId) => {
@@ -364186,6 +364744,41 @@ async function startRunner(opts) {
     } catch {
     }
   };
+  const liveFramePushInFlight = /* @__PURE__ */ new Set();
+  const publishLiveFrame = (frame) => {
+    if (!frame.projectId) return;
+    if (liveFramePushInFlight.has(frame.sessionId)) return;
+    if (!isLiveFrameWatched(frame.projectId)) {
+      const lastProbeAt = liveFrameIdleProbeAt.get(frame.sessionId) ?? 0;
+      if (frame.capturedAt - lastProbeAt < LIVE_FRAME_IDLE_PUSH_INTERVAL_MS) return;
+      if (liveFrameIdleProbeAt.size >= LIVE_FRAME_IDLE_PROBE_MAX_ENTRIES) {
+        const expiredBefore = frame.capturedAt - LIVE_FRAME_IDLE_PUSH_INTERVAL_MS;
+        for (const [sessionId, probedAt] of liveFrameIdleProbeAt) {
+          if (probedAt >= expiredBefore) break;
+          liveFrameIdleProbeAt.delete(sessionId);
+        }
+      }
+      liveFrameIdleProbeAt.set(frame.sessionId, frame.capturedAt);
+    }
+    liveFramePushInFlight.add(frame.sessionId);
+    const frameProjectId = frame.projectId;
+    void fetch(`${serverUrl}/api/runner/live-frame`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(frame),
+      signal: AbortSignal.timeout(5e3)
+    }).then(async (res) => {
+      if (!res.ok) return;
+      const ack = await res.json().catch(() => null);
+      if (ack && typeof ack.watching === "boolean") {
+        liveFrameWatchedByProject.set(frameProjectId, ack.watching);
+      }
+    }).catch(() => {
+    }).finally(() => {
+      liveFramePushInFlight.delete(frame.sessionId);
+    });
+  };
+  import_runner_core11.liveBrowserRegistry.setFramePublisher(publishLiveFrame);
   let liveBrowserHeartbeatInFlight = false;
   let liveBrowserHeartbeatPending = false;
   let lastLiveBrowserHeartbeatAt = 0;