@validate.qa/runner 1.0.85 → 1.0.87

package/dist/cli.js

@@ -975,10 +975,11 @@ var require_mobile_source_parser = __commonJS({
     function extractIOS(attrs) {
       const role = nonEmpty3(attrs.type) ?? "XCUIElementTypeOther";
       const name = nonEmpty3(attrs.name);
+      const identifier = nonEmpty3(attrs.identifier) ?? nonEmpty3(attrs.accessibilityIdentifier);
       const labelAttr = nonEmpty3(attrs.label);
       const value = nonEmpty3(attrs.value);
       const label = name ?? labelAttr ?? value;
-      const accessibilityId = name;
+      const accessibilityId = identifier ?? name;
       const text = labelAttr ?? (isStateValueRole(role) ? void 0 : value);
       const bounds = parseIOSBounds(attrs);
       const enabled = attrBoolDefaultTrue(attrs.enabled);
@@ -75942,6 +75943,34 @@ ${existingScreens.slice(0, 100).map((s) => `- ${s.screenId}${s.name ? ` "${s.nam
         latest = boundaryResolved;
         lastSnapshotIteration = iterationForObservation;
         if (boundary.kind === "transient_external") {
+          const isHostHomeShell = /springboard|systemui/i.test(boundary.owner);
+          if (isHostHomeShell) {
+            log2(`   Host shell detected from ${source}: ${boundary.owner}; activating ${boundary.targetAppId} so exploration can continue.`);
+            try {
+              await driver.launchApp();
+              const snap = await driver.snapshot();
+              const recovered = buildResolved(snap.xml, snap.windowSize, snap.screenSignal);
+              if (recovered) {
+                const recoveredBoundary = (0, mobile_boundary_js_1.classifyMobileScreenBoundary)(recovered.signal, targetAppId, platform3);
+                if (recoveredBoundary.kind === "target" || recoveredBoundary.kind === "unknown") {
+                  const enriched = await enrichResolvedSnapshotWithHybridWeb(recovered, driver, credentialValuesForRedaction, log2, platform3, targetAppId, hybridContextCache, true, source !== "seed snapshot" && source !== "mobile_snapshot");
+                  latest = enriched;
+                  lastSnapshotIteration = iterationForObservation;
+                  const screenId = ingestSnapshot(enriched, iterationForObservation);
+                  captureScreenshot(enriched.replacementScreenshot ?? snap.screenshot, screenId);
+                  return {
+                    observation: enriched.observation,
+                    screenId,
+                    transientExternal: true,
+                    externalOwner: boundary.owner
+                  };
+                }
+              }
+            } catch (err) {
+              (0, mobile_driver_errors_js_1.rethrowIfTerminalMobileDriverError)(err);
+              log2(`   Failed to recover from host shell ${boundary.owner}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+          }
           log2(`   System overlay detected from ${source}: ${boundary.owner}; not adding it to target-app survey evidence.`);
           return {
             observation: `${boundaryResolved.observation}${(0, mobile_boundary_js_1.mobileBoundaryNote)(boundary)}`,
@@ -76159,6 +76188,7 @@ ${existingScreens.slice(0, 100).map((s) => `- ${s.screenId}${s.name ? ` "${s.nam
       let summary = "";
       let truncated = false;
       let truncatedReason;
+      const emptyUiTreeStreak = { count: 0 };
       let finishRedirects = 0;
       let lastFinishBreadthRemainingItems = null;
       let lastFinishBreadthProgressMark = null;
@@ -76497,10 +76527,17 @@ Exploration complete: ${summary}`);
                 redactionCredentials: credentialValuesForRedaction,
                 authTracker,
                 inbox: inboxEnabled && inboxState && inboxReader ? { state: inboxState, reader: inboxReader } : null,
-                allowRelaunch: !preserveAppDataForTools
+                allowRelaunch: !preserveAppDataForTools,
+                emptyUiTreeStreak
               });
               pushResult(handled);
               const handledRecord = handled && typeof handled === "object" ? handled : null;
+              if (handledRecord?.permanent === true && handledRecord?.emptyUiTreeStreak) {
+                explorationComplete = true;
+                summary = typeof handledRecord.reason === "string" && handledRecord.reason.trim() ? handledRecord.reason : "Accessibility tree remained empty after repeated Appium observations; exploration stopped early.";
+                log2(`
+Stopping Phase 1 early: empty UI tree thrash (streak=${handledRecord.emptyUiTreeStreak}).`);
+              }
               const navigationWasAttempted = handledRecord?.ok !== false || Object.prototype.hasOwnProperty.call(handledRecord ?? {}, "screenId") || Object.prototype.hasOwnProperty.call(handledRecord ?? {}, "observation");
               if (DEVICE_MUTATION_BARRIER_TOOLS.has(toolName) && navigationWasAttempted) {
                 navigationBarrierTool = toolName;
@@ -76589,14 +76626,24 @@ Exploration complete: ${summary}`);
       }
       return result;
     }
+    var MAX_EMPTY_UI_TREE_STREAK = 3;
     async function dispatchMobileTool(args) {
-      const { toolName, toolArgs, iteration, driver, state: state2, enableRecordJourney, latest, buildResolved, absorbResolvedObservation, resolveRef, resolveHybridRef, currentBoundary, collectedTransitions, counters, journeys, log: log2, credentials, redactionCredentials, authTracker, inbox, allowRelaunch } = args;
+      const { toolName, toolArgs, iteration, driver, state: state2, enableRecordJourney, latest, buildResolved, absorbResolvedObservation, resolveRef, resolveHybridRef, currentBoundary, collectedTransitions, counters, journeys, log: log2, credentials, redactionCredentials, authTracker, inbox, allowRelaunch, emptyUiTreeStreak } = args;
+      const noteEmptyUiTree = () => {
+        emptyUiTreeStreak.count += 1;
+        return emptyUiTreeStreak.count;
+      };
+      const clearEmptyUiTreeStreak = () => {
+        emptyUiTreeStreak.count = 0;
+      };
       const absorbActionResult = (actionResult, source, preferCredentialSecondary = false) => {
         (0, mobile_driver_errors_js_1.throwIfTerminalMobileActionFailure)(actionResult, source);
         const resolved = buildResolved(actionResult.source, latest()?.screen.windowSize ?? null, actionResult.screenSignal);
         if (!resolved) {
+          noteEmptyUiTree();
           return Promise.resolve({ observation: "(no UI tree returned)", screenId: null });
         }
+        clearEmptyUiTreeStreak();
         return absorbResolvedObservation(resolved, actionResult.screenshot, iteration, source, preferCredentialSecondary);
       };
       const currentAuthSurface = () => {
@@ -76626,8 +76673,17 @@ Exploration complete: ${summary}`);
           const snap = await driver.snapshot();
           const resolved = buildResolved(snap.xml, snap.windowSize, snap.screenSignal);
           if (!resolved) {
-            return { ok: false, error: "snapshot returned no UI tree" };
+            const streak = noteEmptyUiTree();
+            log2(`   Snapshot returned no UI tree (empty streak ${streak}/${MAX_EMPTY_UI_TREE_STREAK}).`);
+            return {
+              ok: false,
+              error: "snapshot returned no UI tree",
+              emptyUiTreeStreak: streak,
+              permanent: streak >= MAX_EMPTY_UI_TREE_STREAK,
+              reason: streak >= MAX_EMPTY_UI_TREE_STREAK ? "Appium repeatedly returned an empty accessibility tree after settle/activate. Stop relaunch thrash \u2014 call finish_exploration with evidence you have, or abort. This is almost always a session/device/app-start failure, not missing product screens." : "No accessibility tree yet. Prefer one mobile_snapshot after a short wait over repeated relaunches."
+            };
           }
+          clearEmptyUiTreeStreak();
           const absorbed = await absorbResolvedObservation(resolved, snap.screenshot, iteration, "mobile_snapshot");
           if (absorbed.screenId) {
             const elementCount = state2.getScreen(absorbed.screenId)?.elements.length ?? resolved.screen.elements.length;
@@ -77000,14 +77056,30 @@ Exploration complete: ${summary}`);
               note: "Relaunch refused under preserve policy."
             };
           }
+          if (emptyUiTreeStreak.count >= MAX_EMPTY_UI_TREE_STREAK) {
+            return {
+              ok: false,
+              error: `mobile_relaunch refused: accessibility tree has been empty for ${emptyUiTreeStreak.count} consecutive observations. Call finish_exploration or stop \u2014 further relaunches will not recover a dead session/app paint.`,
+              permanent: true,
+              emptyUiTreeStreak: emptyUiTreeStreak.count
+            };
+          }
           authTracker?.noteInterveningMutation(iteration);
           await driver.relaunch();
           log2("   Relaunched app for hermetic reset.");
           const snap = await driver.snapshot();
           const resolved = buildResolved(snap.xml, snap.windowSize, snap.screenSignal);
           if (!resolved) {
-            return { ok: true, note: "relaunched; no UI tree returned \u2014 call mobile_snapshot." };
+            const streak = noteEmptyUiTree();
+            log2(`   Relaunch yielded no UI tree (empty streak ${streak}/${MAX_EMPTY_UI_TREE_STREAK}).`);
+            return {
+              ok: true,
+              note: "relaunched; no UI tree returned \u2014 call mobile_snapshot.",
+              emptyUiTreeStreak: streak,
+              permanent: streak >= MAX_EMPTY_UI_TREE_STREAK
+            };
           }
+          clearEmptyUiTreeStreak();
           const absorbed = await absorbResolvedObservation(resolved, snap.screenshot, iteration, "mobile_relaunch");
           return {
             ok: true,
@@ -80239,6 +80311,10 @@ var require_mobile_discovery_prompts = __commonJS({
     "use strict";
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.MOBILE_SCENARIO_SYSTEM_PROMPT = exports2.MOBILE_SURVEY_SYSTEM_PROMPT = void 0;
+    exports2.isScrubbedPlaceholderName = isScrubbedPlaceholderName;
+    exports2.isOpaqueMobileScreenName = isOpaqueMobileScreenName;
+    exports2.isPackageLeafAppCatchAll = isPackageLeafAppCatchAll;
+    exports2.isLowValueMobileAutoDeepFeature = isLowValueMobileAutoDeepFeature;
     exports2.formatMobileEvidenceForPlanner = formatMobileEvidenceForPlanner;
     exports2.transitionSourceLabel = transitionSourceLabel;
     exports2.buildMobileSiteMap = buildMobileSiteMap;
@@ -80519,6 +80595,32 @@ Each entry is exactly one of:
       }
       return /^[a-z][\w$]*(?:\.[a-z][\w$]*)+(?:#[a-z0-9_. -]+)?$/i.test(trimmed);
     }
+    function isPackageLeafAppCatchAll(name, appId) {
+      const trimmed = name.trim();
+      if (!trimmed || !appId?.trim())
+        return false;
+      const match = trimmed.match(/^(.+?)\s+app$/i);
+      if (!match)
+        return false;
+      const brand = match[1].trim();
+      if (!brand || /\s/.test(brand))
+        return false;
+      const leaf = appId.split(".").map((p) => p.trim()).filter(Boolean).pop();
+      if (!leaf)
+        return false;
+      const normalize = (s) => s.replace(/[^a-z0-9]/gi, "").toLowerCase();
+      return normalize(brand) === normalize(leaf);
+    }
+    function isLowValueMobileAutoDeepFeature(name, appId) {
+      const trimmed = name.trim();
+      if (!trimmed)
+        return true;
+      if (isScrubbedPlaceholderName(trimmed) || isOpaqueMobileScreenName(trimmed, appId))
+        return true;
+      if (isPackageLeafAppCatchAll(trimmed, appId))
+        return true;
+      return false;
+    }
     function humanizeToken(token) {
       const spaced = token.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim();
       if (!spaced)
@@ -81550,6 +81652,7 @@ var require_mobile_generator = __commonJS({
     exports2.coalesceRepeatedTaps = coalesceRepeatedTaps;
     exports2.elideNoOpDetours = elideNoOpDetours;
     exports2.mobileActionsToPseudoPlaywright = mobileActionsToPseudoPlaywright;
+    exports2.isEphemeralContentAssertText = isEphemeralContentAssertText;
     exports2.evaluateMobileAssertionStrength = evaluateMobileAssertionStrength;
     exports2.prepareMobileScenarioAppState = prepareMobileScenarioAppState;
     exports2.runMobileGeneratePhase = runMobileGeneratePhase;
@@ -82010,15 +82113,20 @@ ${hybridSkeleton.join("\n")}`;
 - Every element is addressed by a ref like e1, e2. Refs are ONLY valid for the most recent mobile_snapshot. Re-snapshot after every action that changes the screen, then use the NEW refs.
 - mobile_tap/mobile_type/mobile_clear take a ref; the loop resolves it to coordinates AND records the durable locator for replay \u2014 you never pass coordinates.
 
-## Your job
+## Your job \u2014 feature fidelity (non-negotiable)
+The scenario name + goal + steps describe ONE product behavior from survey/discovery. The generated test MUST implement that behavior on THIS app \u2014 not a random walk through tabs.
+
 1. mobile_snapshot the current screen.
-2. Execute the scenario's steps using the real UI: tap buttons, fill fields (mobile_type), submit, navigate.
-3. COMPLETE THE ACTION the scenario is about \u2014 do not stop half-way. If the scenario submits a form (sign in, sign up, search, create, change password, edit profile), you MUST commit it \u2014 tap the submit/primary button OR call mobile_submit_keyboard on the last field when no button is visible. Filling fields alone is NOT the behavior under test. Navigating to a form screen without changing its fields is also NOT enough for mutation scenarios (change/create/update/edit). If it navigates, you MUST land on the destination. A "happy path" that fills a form but never commits \u2014 or only opens the form without typing \u2014 is WRONG.
-4. When you reach the target screen / complete the flow, PROVE the outcome with an assert tool:
-   - mobile_assert_visible({ref}) \u2014 the target screen's stable element is on screen.
-   - mobile_assert_text({ref, expected}) \u2014 an element contains expected text (only durable when the element has a stable accessibility-id / resource-id).
-   - Assert the REAL post-action outcome: after a sign-in, assert a signed-in signal (dashboard/feed content, account tab, "Sign out"); after an invalid submit, assert the error message; after navigation, assert an element unique to the destination screen. Do NOT assert an opaque internal id ("step-1", "step-2") as the outcome \u2014 pick a human-meaningful element.
-5. Call finish_generate with verified:true ONLY if you asserted the outcome with an assert tool.
+2. Execute the scenario's steps using the real UI: tap the controls that perform the goal, fill fields (mobile_type), submit, navigate to the destination named in the goal.
+3. COMPLETE THE ACTION the scenario is about \u2014 do not stop half-way:
+   - Form scenarios (sign in, sign up, search, create, change password, edit profile): you MUST commit \u2014 tap submit/primary OR mobile_submit_keyboard. Filling alone is NOT enough. Opening a form without typing is NOT enough for mutation goals.
+   - Content actions (like, share, follow, bookmark, download, \u2026): you MUST tap the control that performs that action \u2014 tab thrash / swipes alone are WRONG.
+   - Navigation scenarios: you MUST land on the destination and assert something unique to it.
+4. PROVE the outcome with an assert tool that matches the scenario \u2014 not ambient chrome:
+   - mobile_assert_visible({ref}) / mobile_assert_text({ref, expected})
+   - After sign-in \u2192 signed-in product signal; after like \u2192 liked/unlike control or durable like state; after open Settings \u2192 a settings-specific control.
+   - Do NOT assert bottom-nav tab labels alone, notification badge counts ("N unread"), or one-time empty-state CTAs as the scenario outcome.
+5. Call finish_generate with verified:true ONLY if you completed the goal AND asserted a matching durable outcome. If the app cannot complete the goal, finish with verified:false and explain \u2014 never invent a green path from unrelated screens.
 
 ## Rules
 - Re-snapshot before every assertion so the ref is fresh.
@@ -82069,7 +82177,7 @@ ${stepLines || "  (no explicit steps \u2014 explore the goal directly)"}
 Expected outcomes to PROVE with assert tools:
 ${outcomeLines || "  - The target screen is reached and a stable element is visible."}
 
-Start by calling mobile_snapshot, then execute the steps above \u2014 the minimum actions needed to reach the goal, without repeating, reverting, or exploring beyond them. Finish with at least one mobile_assert_visible / mobile_assert_text proving the outcome, then finish_generate.`;
+Start by calling mobile_snapshot, then execute ONLY the steps needed for this goal \u2014 no tab thrash, no unrelated screens. Every recorded action becomes a permanent test step. Finish with at least one assert that proves THIS goal's outcome (from Expected outcomes), then finish_generate. If you cannot perform the goal on this app build, finish_generate with verified:false rather than a fake green path.`;
     }
     function buildStatePacket(input) {
       const { scenario, iteration, maxIterations, latestObservation, assertCount, actionCount } = input;
@@ -83536,6 +83644,84 @@ ${statePacket}`, redactionCredentials) },
       "element-hidden",
       "screen-visible"
     ]);
+    var CONTENT_ACTION_VERB_RE = /\b(like|unlike|favorite|favourite|unfavorite|unfavourite|heart|unheart|follow|unfollow|share|repost|retweet|bookmark|unbookmark|save\s+to|download|subscribe|unsubscribe|block|report|unpin|pin\s+(?:post|item|message|tweet)|mute|unmute|react|upvote|downvote|clap|boost)\b/i;
+    var NAV_CHROME_TAP_RE = /\b(home|you|profile|search|settings|notifications?|inbox|messages?|explore|library|more|menu|tab|bottom\s*nav|videos?|create|feed)\b/i;
+    var VOLATILE_BADGE_ASSERT_RE = /\b\d+\s*(unread|notifications?|messages?|likes?|followers?|comments?|views?)\b|\bunread\b.*\b\d+\b/i;
+    function isContentActionScenario(scenario) {
+      const text = scenarioText(scenario);
+      if (!CONTENT_ACTION_VERB_RE.test(text))
+        return false;
+      if (/\b(view|see|show|open|browse|list|count)\s+(the\s+)?(likes?|followers?|shares?|bookmarks?)\b/i.test(text)) {
+        return false;
+      }
+      return true;
+    }
+    function isContentActionTap(action) {
+      if (action.type !== "TAP")
+        return false;
+      const textForAction = actionText(action);
+      if (NAV_CHROME_TAP_RE.test(textForAction) && !CONTENT_ACTION_VERB_RE.test(textForAction)) {
+        return false;
+      }
+      return CONTENT_ACTION_VERB_RE.test(textForAction);
+    }
+    function isProductiveScenarioAction(action, scenarioTextLower = "") {
+      if (action.type === "TYPE" || action.type === "CLEAR")
+        return true;
+      if (action.type === "TAP") {
+        const t = actionText(action);
+        if (CONTENT_ACTION_VERB_RE.test(t) || isFormCommitAction(action) || isCredentialSubmitTap(action)) {
+          return true;
+        }
+        if (NAV_CHROME_TAP_RE.test(t)) {
+          if (!scenarioTextLower)
+            return false;
+          const chromeWords = t.match(/\b(home|you|profile|search|settings|notifications?|inbox|messages?|explore|library|more|menu|videos?|create|feed)\b/gi) ?? [];
+          return chromeWords.some((w) => scenarioTextLower.includes(w.toLowerCase()));
+        }
+        return true;
+      }
+      return false;
+    }
+    function isNavChromeThrashTrace(actions) {
+      const meaningful = actions.filter((a) => a.type !== "WAIT_FOR_ELEMENT");
+      if (meaningful.length === 0)
+        return false;
+      const hasNavOrGesture = meaningful.some((a) => a.type === "TAP" || a.type === "SWIPE" || a.type === "BACK" || a.type === "HOME");
+      if (!hasNavOrGesture)
+        return false;
+      return meaningful.every((a) => {
+        if (a.type === "SWIPE" || a.type === "BACK" || a.type === "HOME")
+          return true;
+        if (a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT") {
+          const t = actionText(a);
+          return NAV_CHROME_TAP_RE.test(t) || VOLATILE_BADGE_ASSERT_RE.test(t) || isStructuralOnlyAssert(a);
+        }
+        if (a.type === "TAP") {
+          return NAV_CHROME_TAP_RE.test(actionText(a)) && !CONTENT_ACTION_VERB_RE.test(actionText(a));
+        }
+        return false;
+      });
+    }
+    function isHarnessOrVisibilityScenario(scenario) {
+      const text = scenarioText(scenario);
+      return /\b(avoid|recover|guard|remain|stay\s+in|does\s+not\s+record|external|outside\s+the\s+app|inspect|visibility\s+proof|landing\s+screen|smoke|structural\s+assert|skip\s+link|global\s+navigation\s+anchors?)\b/i.test(text);
+    }
+    function requiresFeatureProgress(scenario) {
+      if (isNavigationFocusedScenario(scenario))
+        return false;
+      if (isCancelDiscardScenario(scenario))
+        return false;
+      if (isContentActionScenario(scenario))
+        return true;
+      if (isHarnessOrVisibilityScenario(scenario))
+        return false;
+      const text = scenarioText(scenario);
+      const behaviorClaim = scenario.type === "HAPPY_PATH" || scenario.type === "USER_JOURNEY" || /\b(happy\s*path|successful|success|complete|user\s+can|should\s+be\s+able)\b/i.test(text);
+      if (!behaviorClaim)
+        return false;
+      return /\b(like|unlike|share|follow|bookmark|download|subscribe|create|save|send|submit|edit|delete|remove|add|play|search|type|fill|login|sign\s*in|log\s*in|register|checkout|update|change|open|view|browse|filter|sort|upload|invite|join)\b/i.test(text);
+    }
     function isInspectionOnlyScenario(scenario, actions) {
       if (actions.length === 0 || scenario.expectedOutcomes.length === 0)
         return false;
@@ -83545,16 +83731,28 @@ ${statePacket}`, redactionCredentials) },
       if (actions.some((a) => a.type === "TYPE" || a.type === "CLEAR")) {
         return false;
       }
+      if (isContentActionScenario(scenario)) {
+        return false;
+      }
+      if (isFormValidationScenario(scenario)) {
+        return false;
+      }
       const text = scenarioText(scenario);
-      const visibilityOnlyGoal = (/\b(entry\s+points?|providers?|options?|provider\s+buttons?)\b/.test(text) || /\b(show|display)\s+(all|the)?\s*(provider|option|button|link|entry)/.test(text) || /\b(all\s+(three\s+)?providers?)\b/.test(text)) && !/\b(change|update|create|save|send|register|edit|with\s+valid|successful\s+(sign|log)|complete\s+(the\s+)?(login|sign[- ]?in)|submit\s+(the\s+)?(form|credentials)|enter\s+(an?\s+)?(email|password))\b/.test(text);
+      const visibilityOnlyGoal = (/\b(entry\s+points?|providers?|provider\s+buttons?|sign[- ]?in\s+options|auth(?:entication)?\s+options|available\s+options)\b/.test(text) || /\b(show|display)\s+(all\s+)?(the\s+)?(providers?|options|buttons?|links?|entry\s+points?)\b/.test(text) || /\b(all\s+(three\s+)?providers?)\b/.test(text)) && !/\b(change|update|create|save|send|register|edit|with\s+valid|successful\s+(sign|log)|complete\s+(the\s+)?(login|sign[- ]?in)|submit\s+(the\s+)?(form|credentials)|enter\s+(an?\s+)?(email|password))\b/.test(text);
       if (visibilityOnlyGoal) {
         const assertCount2 = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT").length;
         return assertCount2 > 0;
       }
-      const completionIntent = scenario.type === "HAPPY_PATH" || /\b(happy\s*path|successful|with\s+valid|complete\s+(the\s+)?(login|sign[- ]?in|registration|checkout|purchase))\b/.test(text);
+      const completionIntent = scenario.type === "HAPPY_PATH" || scenario.type === "USER_JOURNEY" || /\b(happy\s*path|successful|with\s+valid|complete\s+(the\s+)?(login|sign[- ]?in|registration|checkout|purchase)|user\s+can|should\s+be\s+able)\b/.test(text);
       const formIntent = /\b(sign\s*in|log\s*in|login|authenticate|register|sign\s*up|checkout|create|save|submit|send|change|update|edit)\b/.test(text);
       if (completionIntent && formIntent)
         return false;
+      if (completionIntent && /\b(like|unlike|share|follow|bookmark|download|subscribe|create|save|send|post|delete|remove|add|play|pause)\b/i.test(text)) {
+        return false;
+      }
+      if (completionIntent) {
+        return false;
+      }
       const assertCount = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT").length;
       return assertCount > 0;
     }
@@ -83564,7 +83762,18 @@ ${statePacket}`, redactionCredentials) },
       const completesFlow = /\b(happy\s*path|successful|complete\s+(the\s+)?(login|sign[- ]?in|registration|checkout)|with\s+valid)\b/.test(text);
       return navigates && !completesFlow;
     }
+    function isCancelDiscardScenario(scenario) {
+      const text = scenarioText(scenario);
+      if (/\bcancel\s+(?:the|my|a|an|this|your|their)?\s*(subscription|order|booking|trip|reservation|membership|plan|purchase|payment|appointment|ticket|flight|ride)\b/i.test(text)) {
+        return false;
+      }
+      const cancelEditPhrase = /\b(cancel|discard|revert|undo)\s+(?:(?:the|my|a|an|this|your|their|all)\s+)?(?:unsaved\s+)?(change|changes|edit|edits|update|updates|draft|input|inputs)\b/i.test(text) || /\b(change|changes|edit|edits|update|updates|draft)\s+(?:are\s+)?(cancelled|canceled|discarded|reverted|undone)\b/i.test(text) || /\breject\s+(?:(?:the|my|a|an|this|your|their|all)\s+)?(change|changes|edit|edits|update|updates|draft)\b/i.test(text);
+      const discardWithoutSave = /\b(without\s+saving|do\s+not\s+save|don't\s+save)\b/i.test(text) && /\b(cancel|discard|revert|undo|leave|exit|back|dismiss)\b/i.test(text);
+      return cancelEditPhrase || discardWithoutSave;
+    }
     function isFormValidationScenario(scenario) {
+      if (isCancelDiscardScenario(scenario))
+        return false;
       if (scenario.variant === "validation")
         return true;
       if (scenario.type !== "EDGE_CASE")
@@ -83575,6 +83784,8 @@ ${statePacket}`, redactionCredentials) },
     function isFormMutationHappyPath(scenario) {
       if (isNavigationFocusedScenario(scenario))
         return false;
+      if (isCancelDiscardScenario(scenario))
+        return false;
       if (isFormValidationScenario(scenario))
         return false;
       const text = scenarioText(scenario);
@@ -83587,9 +83798,14 @@ ${statePacket}`, redactionCredentials) },
       if (/\b(show|display|visible|options?|providers?|links?)\b/.test(text) && !/\b(change|update|create|save|send|register|edit|post|write|compose|delete|add|set)\b/.test(text)) {
         return false;
       }
-      const mutates = /\b(change|update|create|save|send|register|sign\s*up|checkout|edit|post|write|compose|set|add|delete|remove)\b/.test(text);
-      const hasObject = /\b(password|email|profile|message|post|item|record|form|settings|account|name|title|description|comment|bio|phone|address|payment|card|user|note|task|entry)\b/.test(text);
-      return mutates && hasObject;
+      if (/\b(play|pause|resume|playback|seek|volume|mute|unmute|shuffle|repeat|now\s+playing|mini\s*player)\b/.test(text) && !/\b(playlist\s+name|edit\s+(track|song|clip)|upload|caption|comment|description|save\s+to|add\s+to\s+(a\s+)?playlist|create\s+(a\s+)?playlist|rename)\b/.test(text)) {
+        return false;
+      }
+      const formObject = "password|email|profile|message|post|item|record|form|settings|account|name|title|description|comment|bio|phone|address|payment|card|user|note|task|entry";
+      const mutationVerb = "change|update|create|save|send|register|sign\\s*up|checkout|edit|post|write|compose|set|add|delete|remove";
+      const determiner = "(?:(?:the|a|an|my|your|their|this|that)\\s+)?(?:new\\s+)?";
+      const mutatesFormObject = new RegExp(`\\b(?:${mutationVerb})\\s+${determiner}(?:${formObject})\\b`).test(text) || new RegExp(`\\b(?:${formObject})\\s+(?:${mutationVerb})\\b`).test(text);
+      return mutatesFormObject;
     }
     function isNavigationChromeTap(action) {
       if (action.type !== "TAP")
@@ -83678,24 +83894,61 @@ ${statePacket}`, redactionCredentials) },
     }
     function scenarioIntentMismatchReason(scenario, actions) {
       const text = scenarioText(scenario);
+      if (isContentActionScenario(scenario)) {
+        const hasActionTap = actions.some((a) => isContentActionTap(a));
+        if (!hasActionTap) {
+          return "content-action scenario (like/share/follow/\u2026) did not record a tap on a matching control";
+        }
+        if (isNavChromeThrashTrace(actions)) {
+          return "content-action scenario only recorded tab thrash / swipes \u2014 no product action";
+        }
+        const asserts2 = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT");
+        if (asserts2.length > 0 && asserts2.every((a) => VOLATILE_BADGE_ASSERT_RE.test(actionText(a)) || NAV_CHROME_TAP_RE.test(actionText(a)) && !CONTENT_ACTION_VERB_RE.test(actionText(a)))) {
+          return "content-action scenario only asserted tab chrome or a volatile badge count \u2014 assert the action outcome instead";
+        }
+        return null;
+      }
       if (isInspectionOnlyScenario(scenario, actions)) {
         return null;
       }
       if (isNavigationFocusedScenario(scenario)) {
         return null;
       }
+      if (isCancelDiscardScenario(scenario)) {
+        const hasCancelTap = actions.some((a) => {
+          if (a.type !== "TAP")
+            return false;
+          return /\b(cancel|discard|close|dismiss|revert|undo|not\s+now)\b/.test(actionText(a));
+        });
+        const lastNavIdx = (() => {
+          for (let i = actions.length - 1; i >= 0; i--) {
+            const t = actions[i].type;
+            if (t === "TAP" || t === "BACK" || t === "TYPE" || t === "CLEAR")
+              return i;
+          }
+          return -1;
+        })();
+        const backAsDismiss = lastNavIdx >= 0 && actions[lastNavIdx].type === "BACK" && /\b(back|leave|exit|dismiss)\b/i.test(text) && /\b(without\s+saving|do\s+not\s+save|don't\s+save|discard|cancel)\b/i.test(text);
+        if (!hasCancelTap && !backAsDismiss) {
+          return "cancel/discard scenario did not record a cancel/dismiss action";
+        }
+        return null;
+      }
       if (isFormValidationScenario(scenario)) {
         const typedFields = actions.some((a) => a.type === "TYPE");
         const hasCommit = actions.some((a) => isFormCommitAction(a));
         const hasValidationAssert = actions.some((a) => {
           if (a.type !== "ASSERT_VISIBLE" && a.type !== "ASSERT_TEXT")
             return false;
-          return /\b(error|required|invalid|empty|missing|incorrect|wrong|try again|mismatch|does not match|must match)\b/.test(actionText(a));
+          return /\b(error|required|invalid|empty|missing|incorrect|wrong|try again|mismatch|does not match|must match|cannot be empty|please enter|fill out|is required)\b/.test(actionText(a));
         });
         const emptyFieldIntent = /\b(empty|required|missing|blank)\b/.test(text);
         const invalidValueIntent = /\b(wrong|incorrect|invalid|mismatch|reject)\b/.test(text);
+        if (!hasValidationAssert) {
+          return "validation scenario did not assert a validation/error outcome (commit alone is not proof)";
+        }
         if (emptyFieldIntent && !invalidValueIntent) {
-          if (!hasCommit && !hasValidationAssert) {
+          if (!hasCommit) {
             return "validation scenario did not record a form commit or validation outcome";
           }
           return null;
@@ -83703,7 +83956,7 @@ ${statePacket}`, redactionCredentials) },
         if (typedFields && !hasCommit) {
           return "validation scenario filled fields but never committed the form";
         }
-        if (!hasCommit && !hasValidationAssert) {
+        if (!hasCommit) {
           return "validation scenario did not record a form commit or validation outcome";
         }
         return null;
@@ -83717,6 +83970,10 @@ ${statePacket}`, redactionCredentials) },
         if (!hasCommit) {
           return "form-mutation happy path did not record a form commit";
         }
+        const asserts2 = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT");
+        if (asserts2.length > 0 && asserts2.every((a) => NAV_CHROME_TAP_RE.test(actionText(a)) || VOLATILE_BADGE_ASSERT_RE.test(actionText(a)) || isStructuralOnlyAssert(a) || isEphemeralContentAssertText(assertIdentityText(a)))) {
+          return "form-mutation happy path only asserted tab chrome or ephemeral content \u2014 assert the saved/updated product outcome";
+        }
       }
       const isCredentialSignIn = /\b(sign\s*in|log\s*in|login|authenticate|auth)\b/.test(text) && /\b(email|e-mail|password|credential|valid credentials?)\b/.test(text) && !/\b(reset|forgot|recover|logout|log\s*out|sign\s*out|change\s+password|update\s+password)\b/.test(text);
       const typedEmailIndexes = [];
@@ -83777,33 +84034,102 @@ ${statePacket}`, redactionCredentials) },
         }
       }
       const isHappyPath = /\b(happy\s*path|successful|success|create|save|submit|complete|checkout|send|post)\b/.test(text) || scenario.type === "HAPPY_PATH";
-      if (!isHappyPath)
-        return null;
-      let lastTypeIndex = -1;
-      let lastAssertIndex = -1;
-      actions.forEach((action, index) => {
-        if (action.type === "TYPE")
-          lastTypeIndex = index;
-        if (action.type === "ASSERT_VISIBLE" || action.type === "ASSERT_TEXT")
-          lastAssertIndex = index;
-      });
-      if (lastTypeIndex < 0 || lastAssertIndex <= lastTypeIndex)
-        return null;
-      const typeScreen = actions[lastTypeIndex]?.metadata?.screenName?.trim() ?? "";
-      const assertScreen = actions[lastAssertIndex]?.metadata?.screenName?.trim() ?? "";
-      const screensDiffer = typeScreen !== "" && assertScreen !== "" && typeScreen !== assertScreen;
-      const lastTypeAction = actions[lastTypeIndex];
-      const keyboardCommitOnLastType = lastTypeAction != null && isKeyboardFormCommit(lastTypeAction);
-      const commitAfterType = keyboardCommitOnLastType || actions.some((action, index) => {
-        if (index <= lastTypeIndex || index >= lastAssertIndex)
-          return false;
-        return isFormCommitAction(action);
-      });
-      if (screensDiffer && !commitAfterType) {
-        return "form fields were filled then a success assert was recorded without a commit/submit tap between them";
+      if (isHappyPath) {
+        let lastTypeIndex = -1;
+        let lastAssertIndex = -1;
+        actions.forEach((action, index) => {
+          if (action.type === "TYPE")
+            lastTypeIndex = index;
+          if (action.type === "ASSERT_VISIBLE" || action.type === "ASSERT_TEXT")
+            lastAssertIndex = index;
+        });
+        if (lastTypeIndex >= 0 && lastAssertIndex > lastTypeIndex) {
+          const typeScreen = actions[lastTypeIndex]?.metadata?.screenName?.trim() ?? "";
+          const assertScreen = actions[lastAssertIndex]?.metadata?.screenName?.trim() ?? "";
+          const screensDiffer = typeScreen !== "" && assertScreen !== "" && typeScreen !== assertScreen;
+          const lastTypeAction = actions[lastTypeIndex];
+          const keyboardCommitOnLastType = lastTypeAction != null && isKeyboardFormCommit(lastTypeAction);
+          const commitAfterType = keyboardCommitOnLastType || actions.some((action, index) => {
+            if (index <= lastTypeIndex || index >= lastAssertIndex)
+              return false;
+            return isFormCommitAction(action);
+          });
+          if (screensDiffer && !commitAfterType) {
+            return "form fields were filled then a success assert was recorded without a commit/submit tap between them";
+          }
+        }
+      }
+      if (isNavChromeThrashTrace(actions) && !isNavigationFocusedScenario(scenario) && !isFormMutationHappyPath(scenario) && !isFormValidationScenario(scenario) && !isCredentialSignIn && !isAuthLikeScenario && !isHarnessOrVisibilityScenario(scenario)) {
+        return "recording is only bottom-nav thrash and swipes \u2014 does not execute the scenario goal";
+      }
+      if (requiresFeatureProgress(scenario) && !isFormValidationScenario(scenario) && !isCredentialSignIn && !isAuthLikeScenario) {
+        if (!actions.some((a) => isProductiveScenarioAction(a, text))) {
+          return "happy-path / user-journey scenario did not record a productive product action (only chrome, gestures, or empty work)";
+        }
+        const asserts2 = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT");
+        if (asserts2.length > 0 && asserts2.every((a) => VOLATILE_BADGE_ASSERT_RE.test(actionText(a)) || isStructuralOnlyAssert(a))) {
+          return "happy-path / user-journey scenario only asserted volatile badges or structural roots \u2014 assert a durable feature outcome";
+        }
+      }
+      const goalFidelity = scenarioGoalActionFidelityReason(text, actions);
+      if (goalFidelity)
+        return goalFidelity;
+      if (actions.some((a) => isBareHierarchyFieldAction(a))) {
+        return "typed or tapped a bare hierarchy/container target with no accessible label \u2014 use a labeled field/control";
+      }
+      const asserts = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT");
+      if (asserts.length > 0 && asserts.every((a) => isEphemeralContentAssertText(assertIdentityText(a)))) {
+        return "only asserted ephemeral feed/catalog content (session-specific titles/ids) \u2014 assert durable product chrome or stable outcome";
+      }
+      return null;
+    }
+    function scenarioGoalActionFidelityReason(scenarioTextLower, actions) {
+      const actionBlob = actions.map((a) => actionText(a)).join(" ").toLowerCase();
+      if (/\b(pick|choose|select)\b.*\b(library|gallery|photos?|camera\s*roll|device)\b|\bfrom\s+(the\s+)?(library|gallery|photos?)\b/.test(scenarioTextLower)) {
+        if (!/\b(library|gallery|photos?|camera\s*roll|pick\s+a\s+video|choose\s+(a\s+)?(video|photo|file)|from\s+library|document\s*picker|media\s*picker)\b/i.test(actionBlob)) {
+          return "scenario claims pick-from-library but recording never tapped a library/gallery/picker control";
+        }
+      }
+      if (/\b(style|styles)\b/.test(scenarioTextLower) && /\b(format|aspect|ratio|quality|reels?|9:16|16:9)\b/.test(scenarioTextLower)) {
+        const pickedStyle = /\b(style|cinematic|anime|realistic|no\s*style|cartoon|oil\s*paint)\b/i.test(actionBlob);
+        const pickedFormat = /\b(9:16|16:9|1:1|reels?|aspect|quality|format|720|1080)\b/i.test(actionBlob);
+        if (!pickedStyle || !pickedFormat) {
+          return "scenario claims style+format selection but recording did not select both a style and a format/aspect control";
+        }
+      }
+      if (/\b(open|launch|start)\b.*\b(camera|recording)\b|\brecord\s+a\s+video\b/.test(scenarioTextLower)) {
+        if (!/\b(camera|record|recording|flash|flip\s+camera|capture|shutter)\b/i.test(actionBlob)) {
+          return "scenario claims open/record camera but recording never reached camera controls";
+        }
       }
       return null;
     }
+    function isBareHierarchyFieldAction(action) {
+      if (action.type !== "TYPE" && action.type !== "CLEAR")
+        return false;
+      const sel = (action.selector ?? "").trim();
+      if (!/^\/hierarchy/i.test(sel))
+        return false;
+      const bundle = action.metadata.locatorBundle;
+      const label = (action.metadata.targetLabel ?? "").trim();
+      if (label && !/^element$/i.test(label))
+        return false;
+      const inner = nonEmpty3(action.innerText);
+      if (inner && !/^element$/i.test(inner))
+        return false;
+      if (nonEmpty3(bundle?.text) || nonEmpty3(bundle?.contentDesc) || nonEmpty3(bundle?.accessibilityId)) {
+        return false;
+      }
+      if (nonEmpty3(bundle?.resourceId) && !isStructuralAssertionIdentity(bundle?.resourceId)) {
+        return false;
+      }
+      if (action.type === "TYPE") {
+        const v = (action.value ?? "").replace(/\s+/g, "");
+        if (v.length > 0)
+          return false;
+      }
+      return true;
+    }
     function actionCycleKey(action) {
       return `${action.type}|${action.selector}|${action.value ?? ""}`;
     }
@@ -84055,6 +84381,38 @@ ${statePacket}`, redactionCredentials) },
       lines.push("});");
       return lines.join("\n");
     }
+    function isEphemeralContentAssertText(text) {
+      const t = text.trim();
+      if (!t)
+        return false;
+      if (/\b\d+\s*(s|sec|secs|second|seconds|m|min|mins|minute|minutes|h|hr|hrs|hour|hours|d|day|days|w|wk|wks|week|weeks|mo|mos|month|months|y|yr|yrs|year|years)\s+ago\b/i.test(t)) {
+        return true;
+      }
+      if (/\b(just\s+now|moments?\s+ago|yesterday)\b/i.test(t))
+        return true;
+      if (/\btoday\s+at\s+\d{1,2}:\d{2}\b/i.test(t))
+        return true;
+      const feedish = /\b(followed|liked|commented|replied|mentioned|shared|posted|unread|notification|message from|new follower)\b/i.test(t) || /\b\d+\s*(s|m|h|d|w)\s+ago\b/i.test(t);
+      if (feedish && t.length >= 70 && /[.!?].+\s/.test(t) && t.split(/\s+/).length >= 10) {
+        return true;
+      }
+      if (t.length >= 40 && /\b(error\s+\d{3,}|generation failed|rate limit|quota exceeded)\b/i.test(t)) {
+        return true;
+      }
+      if (/\b(harness|seed|fixture|demo\s*data|test\s*artist|qa\s*published)\b/i.test(t) && /\d{6,}/.test(t)) {
+        return true;
+      }
+      if (/\bplay\b.+\bby\b.+/i.test(t) && (t.length >= 40 || /\d{6,}/.test(t))) {
+        return true;
+      }
+      if (/^play\s+/i.test(t) && t.length >= 35 && !/\b(home|search|settings|profile|library|playlist|sign\s*in|log\s*in)\b/i.test(t)) {
+        return true;
+      }
+      return false;
+    }
+    function assertIdentityText(action) {
+      return [action.selector, action.value, action.innerText, action.metadata?.targetLabel].filter((v) => typeof v === "string" && v.trim().length > 0).join(" ");
+    }
     function evaluateMobileAssertionStrength(actions) {
       const modelAsserts = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT");
       if (modelAsserts.length === 0) {
@@ -84090,6 +84448,24 @@ ${statePacket}`, redactionCredentials) },
           }
         };
       }
+      const ephemeral = modelAsserts.filter((a) => isEphemeralContentAssertText(assertIdentityText(a)));
+      const durable = modelAsserts.filter((a) => !isEphemeralContentAssertText(assertIdentityText(a)));
+      if (ephemeral.length > 0 && durable.length === 0) {
+        return {
+          ok: false,
+          severity: "block",
+          reason: "only ephemeral content assertions (relative times, long feed/notification copy, or backend error strings) \u2014 assert durable chrome or run-scoped data instead",
+          signals: {
+            apiTest: false,
+            interacted: true,
+            mutated: actions.some((a) => a.type === "TYPE"),
+            navOnly: false,
+            hasOutcomeProof: false,
+            errorBanner: false,
+            terminal: null
+          }
+        };
+      }
       const code = mobileActionsToPseudoPlaywright(actions);
       const interacted = actions.some((a) => a.type === "TAP" || a.type === "TYPE" || a.type === "CLEAR");
       return (0, shared_1.validateAssertionStrength)(code, { interactionPerformed: interacted });
@@ -84965,6 +85341,7 @@ Reason over steps + error + tree + registry and return working healed steps. Do
 For a fix, return the COMPLETE steps array (not a diff).`;
     var DEFAULT_SCRIPT_MAX_ATTEMPTS = 6;
     var RECOVERABLE_MAX = 3;
+    var MAX_CONSECUTIVE_INVALID_VERDICTS = 3;
     var BONUS_ATTEMPTS_CEIL = 4;
     var DEFAULT_BONUS_ATTEMPTS = 2;
     var MAX_LOG_CHARS = 4096;
@@ -85570,6 +85947,7 @@ ${args.directive}`);
       const triedLocators = [];
       let sameErrorCount = 0;
       let lastErrorSignature = null;
+      let consecutiveInvalidVerdicts = 0;
       const markRecoverableTurn = () => {
         if (recoverableUsed < RECOVERABLE_MAX) {
           attemptCap += 1;
@@ -85643,11 +86021,22 @@ ${args.directive}`);
         aiResponseCount += 1;
         const parsed = parseHealVerdict(content);
         if (!parsed) {
-          options.onProgress?.(`Phase 1 attempt ${attempt}: response was not a valid verdict (${content.length} chars, finish=${finishReason ?? "unknown"}) \u2014 granting a recovery turn`);
+          consecutiveInvalidVerdicts += 1;
+          options.onProgress?.(`Phase 1 attempt ${attempt}: response was not a valid verdict (${content.length} chars, finish=${finishReason ?? "unknown"}) \u2014 granting a recovery turn (${consecutiveInvalidVerdicts}/${MAX_CONSECUTIVE_INVALID_VERDICTS} consecutive)`);
+          if (consecutiveInvalidVerdicts >= MAX_CONSECUTIVE_INVALID_VERDICTS) {
+            options.onProgress?.(`Phase 1 aborted: ${consecutiveInvalidVerdicts} consecutive invalid verdicts \u2014 freeing device`);
+            return {
+              passed: false,
+              verdict: "config_issue",
+              healReason: `heal model returned ${consecutiveInvalidVerdicts} consecutive non-verdict responses (last ${content.length} chars, finish=${finishReason ?? "unknown"}) \u2014 aborting to free the device`,
+              attemptsUsed: attempt
+            };
+          }
           markRecoverableTurn();
-          pendingDirective = "Your last response was not valid JSON matching the verdict schema. Return exactly one JSON verdict object.";
+          pendingDirective = "Your last response was not valid JSON matching the verdict schema. Return exactly one JSON verdict object \u2014 no prose, no markdown fences.";
           continue;
         }
+        consecutiveInvalidVerdicts = 0;
         if (TERMINAL_VERDICTS.has(parsed.verdict)) {
           return { passed: false, verdict: parsed.verdict, healReason: parsed.reason, attemptsUsed: attempt };
         }
@@ -101142,2285 +101531,6 @@ var require_rate_limit_detector = __commonJS({
   }
 });
 
-// ../../node_modules/source-map-support/node_modules/source-map/lib/base64.js
-var require_base64 = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/base64.js"(exports2) {
-    "use strict";
-    var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
-    exports2.encode = function(number) {
-      if (0 <= number && number < intToCharMap.length) {
-        return intToCharMap[number];
-      }
-      throw new TypeError("Must be between 0 and 63: " + number);
-    };
-    exports2.decode = function(charCode) {
-      var bigA = 65;
-      var bigZ = 90;
-      var littleA = 97;
-      var littleZ = 122;
-      var zero = 48;
-      var nine = 57;
-      var plus = 43;
-      var slash = 47;
-      var littleOffset = 26;
-      var numberOffset = 52;
-      if (bigA <= charCode && charCode <= bigZ) {
-        return charCode - bigA;
-      }
-      if (littleA <= charCode && charCode <= littleZ) {
-        return charCode - littleA + littleOffset;
-      }
-      if (zero <= charCode && charCode <= nine) {
-        return charCode - zero + numberOffset;
-      }
-      if (charCode == plus) {
-        return 62;
-      }
-      if (charCode == slash) {
-        return 63;
-      }
-      return -1;
-    };
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/base64-vlq.js
-var require_base64_vlq = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/base64-vlq.js"(exports2) {
-    "use strict";
-    var base64 = require_base64();
-    var VLQ_BASE_SHIFT = 5;
-    var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
-    var VLQ_BASE_MASK = VLQ_BASE - 1;
-    var VLQ_CONTINUATION_BIT = VLQ_BASE;
-    function toVLQSigned(aValue) {
-      return aValue < 0 ? (-aValue << 1) + 1 : (aValue << 1) + 0;
-    }
-    function fromVLQSigned(aValue) {
-      var isNegative = (aValue & 1) === 1;
-      var shifted = aValue >> 1;
-      return isNegative ? -shifted : shifted;
-    }
-    exports2.encode = function base64VLQ_encode(aValue) {
-      var encoded = "";
-      var digit;
-      var vlq = toVLQSigned(aValue);
-      do {
-        digit = vlq & VLQ_BASE_MASK;
-        vlq >>>= VLQ_BASE_SHIFT;
-        if (vlq > 0) {
-          digit |= VLQ_CONTINUATION_BIT;
-        }
-        encoded += base64.encode(digit);
-      } while (vlq > 0);
-      return encoded;
-    };
-    exports2.decode = function base64VLQ_decode(aStr, aIndex, aOutParam) {
-      var strLen = aStr.length;
-      var result = 0;
-      var shift = 0;
-      var continuation, digit;
-      do {
-        if (aIndex >= strLen) {
-          throw new Error("Expected more digits in base 64 VLQ value.");
-        }
-        digit = base64.decode(aStr.charCodeAt(aIndex++));
-        if (digit === -1) {
-          throw new Error("Invalid base64 digit: " + aStr.charAt(aIndex - 1));
-        }
-        continuation = !!(digit & VLQ_CONTINUATION_BIT);
-        digit &= VLQ_BASE_MASK;
-        result = result + (digit << shift);
-        shift += VLQ_BASE_SHIFT;
-      } while (continuation);
-      aOutParam.value = fromVLQSigned(result);
-      aOutParam.rest = aIndex;
-    };
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/util.js
-var require_util4 = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/util.js"(exports2) {
-    "use strict";
-    function getArg(aArgs, aName, aDefaultValue) {
-      if (aName in aArgs) {
-        return aArgs[aName];
-      } else if (arguments.length === 3) {
-        return aDefaultValue;
-      } else {
-        throw new Error('"' + aName + '" is a required argument.');
-      }
-    }
-    exports2.getArg = getArg;
-    var urlRegexp = /^(?:([\w+\-.]+):)?\/\/(?:(\w+:\w+)@)?([\w.-]*)(?::(\d+))?(.*)$/;
-    var dataUrlRegexp = /^data:.+\,.+$/;
-    function urlParse(aUrl) {
-      var match = aUrl.match(urlRegexp);
-      if (!match) {
-        return null;
-      }
-      return {
-        scheme: match[1],
-        auth: match[2],
-        host: match[3],
-        port: match[4],
-        path: match[5]
-      };
-    }
-    exports2.urlParse = urlParse;
-    function urlGenerate(aParsedUrl) {
-      var url = "";
-      if (aParsedUrl.scheme) {
-        url += aParsedUrl.scheme + ":";
-      }
-      url += "//";
-      if (aParsedUrl.auth) {
-        url += aParsedUrl.auth + "@";
-      }
-      if (aParsedUrl.host) {
-        url += aParsedUrl.host;
-      }
-      if (aParsedUrl.port) {
-        url += ":" + aParsedUrl.port;
-      }
-      if (aParsedUrl.path) {
-        url += aParsedUrl.path;
-      }
-      return url;
-    }
-    exports2.urlGenerate = urlGenerate;
-    function normalize(aPath) {
-      var path = aPath;
-      var url = urlParse(aPath);
-      if (url) {
-        if (!url.path) {
-          return aPath;
-        }
-        path = url.path;
-      }
-      var isAbsolute2 = exports2.isAbsolute(path);
-      var parts = path.split(/\/+/);
-      for (var part, up = 0, i = parts.length - 1; i >= 0; i--) {
-        part = parts[i];
-        if (part === ".") {
-          parts.splice(i, 1);
-        } else if (part === "..") {
-          up++;
-        } else if (up > 0) {
-          if (part === "") {
-            parts.splice(i + 1, up);
-            up = 0;
-          } else {
-            parts.splice(i, 2);
-            up--;
-          }
-        }
-      }
-      path = parts.join("/");
-      if (path === "") {
-        path = isAbsolute2 ? "/" : ".";
-      }
-      if (url) {
-        url.path = path;
-        return urlGenerate(url);
-      }
-      return path;
-    }
-    exports2.normalize = normalize;
-    function join8(aRoot, aPath) {
-      if (aRoot === "") {
-        aRoot = ".";
-      }
-      if (aPath === "") {
-        aPath = ".";
-      }
-      var aPathUrl = urlParse(aPath);
-      var aRootUrl = urlParse(aRoot);
-      if (aRootUrl) {
-        aRoot = aRootUrl.path || "/";
-      }
-      if (aPathUrl && !aPathUrl.scheme) {
-        if (aRootUrl) {
-          aPathUrl.scheme = aRootUrl.scheme;
-        }
-        return urlGenerate(aPathUrl);
-      }
-      if (aPathUrl || aPath.match(dataUrlRegexp)) {
-        return aPath;
-      }
-      if (aRootUrl && !aRootUrl.host && !aRootUrl.path) {
-        aRootUrl.host = aPath;
-        return urlGenerate(aRootUrl);
-      }
-      var joined = aPath.charAt(0) === "/" ? aPath : normalize(aRoot.replace(/\/+$/, "") + "/" + aPath);
-      if (aRootUrl) {
-        aRootUrl.path = joined;
-        return urlGenerate(aRootUrl);
-      }
-      return joined;
-    }
-    exports2.join = join8;
-    exports2.isAbsolute = function(aPath) {
-      return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
-    };
-    function relative(aRoot, aPath) {
-      if (aRoot === "") {
-        aRoot = ".";
-      }
-      aRoot = aRoot.replace(/\/$/, "");
-      var level = 0;
-      while (aPath.indexOf(aRoot + "/") !== 0) {
-        var index = aRoot.lastIndexOf("/");
-        if (index < 0) {
-          return aPath;
-        }
-        aRoot = aRoot.slice(0, index);
-        if (aRoot.match(/^([^\/]+:\/)?\/*$/)) {
-          return aPath;
-        }
-        ++level;
-      }
-      return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
-    }
-    exports2.relative = relative;
-    var supportsNullProto = (function() {
-      var obj = /* @__PURE__ */ Object.create(null);
-      return !("__proto__" in obj);
-    })();
-    function identity(s) {
-      return s;
-    }
-    function toSetString(aStr) {
-      if (isProtoString(aStr)) {
-        return "$" + aStr;
-      }
-      return aStr;
-    }
-    exports2.toSetString = supportsNullProto ? identity : toSetString;
-    function fromSetString(aStr) {
-      if (isProtoString(aStr)) {
-        return aStr.slice(1);
-      }
-      return aStr;
-    }
-    exports2.fromSetString = supportsNullProto ? identity : fromSetString;
-    function isProtoString(s) {
-      if (!s) {
-        return false;
-      }
-      var length = s.length;
-      if (length < 9) {
-        return false;
-      }
-      if (s.charCodeAt(length - 1) !== 95 || s.charCodeAt(length - 2) !== 95 || s.charCodeAt(length - 3) !== 111 || s.charCodeAt(length - 4) !== 116 || s.charCodeAt(length - 5) !== 111 || s.charCodeAt(length - 6) !== 114 || s.charCodeAt(length - 7) !== 112 || s.charCodeAt(length - 8) !== 95 || s.charCodeAt(length - 9) !== 95) {
-        return false;
-      }
-      for (var i = length - 10; i >= 0; i--) {
-        if (s.charCodeAt(i) !== 36) {
-          return false;
-        }
-      }
-      return true;
-    }
-    function compareByOriginalPositions(mappingA, mappingB, onlyCompareOriginal) {
-      var cmp = strcmp(mappingA.source, mappingB.source);
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.originalLine - mappingB.originalLine;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.originalColumn - mappingB.originalColumn;
-      if (cmp !== 0 || onlyCompareOriginal) {
-        return cmp;
-      }
-      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.generatedLine - mappingB.generatedLine;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      return strcmp(mappingA.name, mappingB.name);
-    }
-    exports2.compareByOriginalPositions = compareByOriginalPositions;
-    function compareByGeneratedPositionsDeflated(mappingA, mappingB, onlyCompareGenerated) {
-      var cmp = mappingA.generatedLine - mappingB.generatedLine;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-      if (cmp !== 0 || onlyCompareGenerated) {
-        return cmp;
-      }
-      cmp = strcmp(mappingA.source, mappingB.source);
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.originalLine - mappingB.originalLine;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.originalColumn - mappingB.originalColumn;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      return strcmp(mappingA.name, mappingB.name);
-    }
-    exports2.compareByGeneratedPositionsDeflated = compareByGeneratedPositionsDeflated;
-    function strcmp(aStr1, aStr2) {
-      if (aStr1 === aStr2) {
-        return 0;
-      }
-      if (aStr1 === null) {
-        return 1;
-      }
-      if (aStr2 === null) {
-        return -1;
-      }
-      if (aStr1 > aStr2) {
-        return 1;
-      }
-      return -1;
-    }
-    function compareByGeneratedPositionsInflated(mappingA, mappingB) {
-      var cmp = mappingA.generatedLine - mappingB.generatedLine;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.generatedColumn - mappingB.generatedColumn;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = strcmp(mappingA.source, mappingB.source);
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.originalLine - mappingB.originalLine;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      cmp = mappingA.originalColumn - mappingB.originalColumn;
-      if (cmp !== 0) {
-        return cmp;
-      }
-      return strcmp(mappingA.name, mappingB.name);
-    }
-    exports2.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
-    function parseSourceMapInput(str) {
-      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
-    }
-    exports2.parseSourceMapInput = parseSourceMapInput;
-    function computeSourceURL(sourceRoot, sourceURL, sourceMapURL) {
-      sourceURL = sourceURL || "";
-      if (sourceRoot) {
-        if (sourceRoot[sourceRoot.length - 1] !== "/" && sourceURL[0] !== "/") {
-          sourceRoot += "/";
-        }
-        sourceURL = sourceRoot + sourceURL;
-      }
-      if (sourceMapURL) {
-        var parsed = urlParse(sourceMapURL);
-        if (!parsed) {
-          throw new Error("sourceMapURL could not be parsed");
-        }
-        if (parsed.path) {
-          var index = parsed.path.lastIndexOf("/");
-          if (index >= 0) {
-            parsed.path = parsed.path.substring(0, index + 1);
-          }
-        }
-        sourceURL = join8(urlGenerate(parsed), sourceURL);
-      }
-      return normalize(sourceURL);
-    }
-    exports2.computeSourceURL = computeSourceURL;
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/array-set.js
-var require_array_set = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/array-set.js"(exports2) {
-    "use strict";
-    var util = require_util4();
-    var has = Object.prototype.hasOwnProperty;
-    var hasNativeMap = typeof Map !== "undefined";
-    function ArraySet() {
-      this._array = [];
-      this._set = hasNativeMap ? /* @__PURE__ */ new Map() : /* @__PURE__ */ Object.create(null);
-    }
-    ArraySet.fromArray = function ArraySet_fromArray(aArray, aAllowDuplicates) {
-      var set = new ArraySet();
-      for (var i = 0, len = aArray.length; i < len; i++) {
-        set.add(aArray[i], aAllowDuplicates);
-      }
-      return set;
-    };
-    ArraySet.prototype.size = function ArraySet_size() {
-      return hasNativeMap ? this._set.size : Object.getOwnPropertyNames(this._set).length;
-    };
-    ArraySet.prototype.add = function ArraySet_add(aStr, aAllowDuplicates) {
-      var sStr = hasNativeMap ? aStr : util.toSetString(aStr);
-      var isDuplicate = hasNativeMap ? this.has(aStr) : has.call(this._set, sStr);
-      var idx = this._array.length;
-      if (!isDuplicate || aAllowDuplicates) {
-        this._array.push(aStr);
-      }
-      if (!isDuplicate) {
-        if (hasNativeMap) {
-          this._set.set(aStr, idx);
-        } else {
-          this._set[sStr] = idx;
-        }
-      }
-    };
-    ArraySet.prototype.has = function ArraySet_has(aStr) {
-      if (hasNativeMap) {
-        return this._set.has(aStr);
-      } else {
-        var sStr = util.toSetString(aStr);
-        return has.call(this._set, sStr);
-      }
-    };
-    ArraySet.prototype.indexOf = function ArraySet_indexOf(aStr) {
-      if (hasNativeMap) {
-        var idx = this._set.get(aStr);
-        if (idx >= 0) {
-          return idx;
-        }
-      } else {
-        var sStr = util.toSetString(aStr);
-        if (has.call(this._set, sStr)) {
-          return this._set[sStr];
-        }
-      }
-      throw new Error('"' + aStr + '" is not in the set.');
-    };
-    ArraySet.prototype.at = function ArraySet_at(aIdx) {
-      if (aIdx >= 0 && aIdx < this._array.length) {
-        return this._array[aIdx];
-      }
-      throw new Error("No element indexed by " + aIdx);
-    };
-    ArraySet.prototype.toArray = function ArraySet_toArray() {
-      return this._array.slice();
-    };
-    exports2.ArraySet = ArraySet;
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/mapping-list.js
-var require_mapping_list = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/mapping-list.js"(exports2) {
-    "use strict";
-    var util = require_util4();
-    function generatedPositionAfter(mappingA, mappingB) {
-      var lineA = mappingA.generatedLine;
-      var lineB = mappingB.generatedLine;
-      var columnA = mappingA.generatedColumn;
-      var columnB = mappingB.generatedColumn;
-      return lineB > lineA || lineB == lineA && columnB >= columnA || util.compareByGeneratedPositionsInflated(mappingA, mappingB) <= 0;
-    }
-    function MappingList() {
-      this._array = [];
-      this._sorted = true;
-      this._last = { generatedLine: -1, generatedColumn: 0 };
-    }
-    MappingList.prototype.unsortedForEach = function MappingList_forEach(aCallback, aThisArg) {
-      this._array.forEach(aCallback, aThisArg);
-    };
-    MappingList.prototype.add = function MappingList_add(aMapping) {
-      if (generatedPositionAfter(this._last, aMapping)) {
-        this._last = aMapping;
-        this._array.push(aMapping);
-      } else {
-        this._sorted = false;
-        this._array.push(aMapping);
-      }
-    };
-    MappingList.prototype.toArray = function MappingList_toArray() {
-      if (!this._sorted) {
-        this._array.sort(util.compareByGeneratedPositionsInflated);
-        this._sorted = true;
-      }
-      return this._array;
-    };
-    exports2.MappingList = MappingList;
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/source-map-generator.js
-var require_source_map_generator = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/source-map-generator.js"(exports2) {
-    "use strict";
-    var base64VLQ = require_base64_vlq();
-    var util = require_util4();
-    var ArraySet = require_array_set().ArraySet;
-    var MappingList = require_mapping_list().MappingList;
-    function SourceMapGenerator(aArgs) {
-      if (!aArgs) {
-        aArgs = {};
-      }
-      this._file = util.getArg(aArgs, "file", null);
-      this._sourceRoot = util.getArg(aArgs, "sourceRoot", null);
-      this._skipValidation = util.getArg(aArgs, "skipValidation", false);
-      this._sources = new ArraySet();
-      this._names = new ArraySet();
-      this._mappings = new MappingList();
-      this._sourcesContents = null;
-    }
-    SourceMapGenerator.prototype._version = 3;
-    SourceMapGenerator.fromSourceMap = function SourceMapGenerator_fromSourceMap(aSourceMapConsumer) {
-      var sourceRoot = aSourceMapConsumer.sourceRoot;
-      var generator = new SourceMapGenerator({
-        file: aSourceMapConsumer.file,
-        sourceRoot
-      });
-      aSourceMapConsumer.eachMapping(function(mapping) {
-        var newMapping = {
-          generated: {
-            line: mapping.generatedLine,
-            column: mapping.generatedColumn
-          }
-        };
-        if (mapping.source != null) {
-          newMapping.source = mapping.source;
-          if (sourceRoot != null) {
-            newMapping.source = util.relative(sourceRoot, newMapping.source);
-          }
-          newMapping.original = {
-            line: mapping.originalLine,
-            column: mapping.originalColumn
-          };
-          if (mapping.name != null) {
-            newMapping.name = mapping.name;
-          }
-        }
-        generator.addMapping(newMapping);
-      });
-      aSourceMapConsumer.sources.forEach(function(sourceFile) {
-        var sourceRelative = sourceFile;
-        if (sourceRoot !== null) {
-          sourceRelative = util.relative(sourceRoot, sourceFile);
-        }
-        if (!generator._sources.has(sourceRelative)) {
-          generator._sources.add(sourceRelative);
-        }
-        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
-        if (content != null) {
-          generator.setSourceContent(sourceFile, content);
-        }
-      });
-      return generator;
-    };
-    SourceMapGenerator.prototype.addMapping = function SourceMapGenerator_addMapping(aArgs) {
-      var generated = util.getArg(aArgs, "generated");
-      var original = util.getArg(aArgs, "original", null);
-      var source = util.getArg(aArgs, "source", null);
-      var name = util.getArg(aArgs, "name", null);
-      if (!this._skipValidation) {
-        this._validateMapping(generated, original, source, name);
-      }
-      if (source != null) {
-        source = String(source);
-        if (!this._sources.has(source)) {
-          this._sources.add(source);
-        }
-      }
-      if (name != null) {
-        name = String(name);
-        if (!this._names.has(name)) {
-          this._names.add(name);
-        }
-      }
-      this._mappings.add({
-        generatedLine: generated.line,
-        generatedColumn: generated.column,
-        originalLine: original != null && original.line,
-        originalColumn: original != null && original.column,
-        source,
-        name
-      });
-    };
-    SourceMapGenerator.prototype.setSourceContent = function SourceMapGenerator_setSourceContent(aSourceFile, aSourceContent) {
-      var source = aSourceFile;
-      if (this._sourceRoot != null) {
-        source = util.relative(this._sourceRoot, source);
-      }
-      if (aSourceContent != null) {
-        if (!this._sourcesContents) {
-          this._sourcesContents = /* @__PURE__ */ Object.create(null);
-        }
-        this._sourcesContents[util.toSetString(source)] = aSourceContent;
-      } else if (this._sourcesContents) {
-        delete this._sourcesContents[util.toSetString(source)];
-        if (Object.keys(this._sourcesContents).length === 0) {
-          this._sourcesContents = null;
-        }
-      }
-    };
-    SourceMapGenerator.prototype.applySourceMap = function SourceMapGenerator_applySourceMap(aSourceMapConsumer, aSourceFile, aSourceMapPath) {
-      var sourceFile = aSourceFile;
-      if (aSourceFile == null) {
-        if (aSourceMapConsumer.file == null) {
-          throw new Error(
-            `SourceMapGenerator.prototype.applySourceMap requires either an explicit source file, or the source map's "file" property. Both were omitted.`
-          );
-        }
-        sourceFile = aSourceMapConsumer.file;
-      }
-      var sourceRoot = this._sourceRoot;
-      if (sourceRoot != null) {
-        sourceFile = util.relative(sourceRoot, sourceFile);
-      }
-      var newSources = new ArraySet();
-      var newNames = new ArraySet();
-      this._mappings.unsortedForEach(function(mapping) {
-        if (mapping.source === sourceFile && mapping.originalLine != null) {
-          var original = aSourceMapConsumer.originalPositionFor({
-            line: mapping.originalLine,
-            column: mapping.originalColumn
-          });
-          if (original.source != null) {
-            mapping.source = original.source;
-            if (aSourceMapPath != null) {
-              mapping.source = util.join(aSourceMapPath, mapping.source);
-            }
-            if (sourceRoot != null) {
-              mapping.source = util.relative(sourceRoot, mapping.source);
-            }
-            mapping.originalLine = original.line;
-            mapping.originalColumn = original.column;
-            if (original.name != null) {
-              mapping.name = original.name;
-            }
-          }
-        }
-        var source = mapping.source;
-        if (source != null && !newSources.has(source)) {
-          newSources.add(source);
-        }
-        var name = mapping.name;
-        if (name != null && !newNames.has(name)) {
-          newNames.add(name);
-        }
-      }, this);
-      this._sources = newSources;
-      this._names = newNames;
-      aSourceMapConsumer.sources.forEach(function(sourceFile2) {
-        var content = aSourceMapConsumer.sourceContentFor(sourceFile2);
-        if (content != null) {
-          if (aSourceMapPath != null) {
-            sourceFile2 = util.join(aSourceMapPath, sourceFile2);
-          }
-          if (sourceRoot != null) {
-            sourceFile2 = util.relative(sourceRoot, sourceFile2);
-          }
-          this.setSourceContent(sourceFile2, content);
-        }
-      }, this);
-    };
-    SourceMapGenerator.prototype._validateMapping = function SourceMapGenerator_validateMapping(aGenerated, aOriginal, aSource, aName) {
-      if (aOriginal && typeof aOriginal.line !== "number" && typeof aOriginal.column !== "number") {
-        throw new Error(
-          "original.line and original.column are not numbers -- you probably meant to omit the original mapping entirely and only map the generated position. If so, pass null for the original mapping instead of an object with empty or null values."
-        );
-      }
-      if (aGenerated && "line" in aGenerated && "column" in aGenerated && aGenerated.line > 0 && aGenerated.column >= 0 && !aOriginal && !aSource && !aName) {
-        return;
-      } else if (aGenerated && "line" in aGenerated && "column" in aGenerated && aOriginal && "line" in aOriginal && "column" in aOriginal && aGenerated.line > 0 && aGenerated.column >= 0 && aOriginal.line > 0 && aOriginal.column >= 0 && aSource) {
-        return;
-      } else {
-        throw new Error("Invalid mapping: " + JSON.stringify({
-          generated: aGenerated,
-          source: aSource,
-          original: aOriginal,
-          name: aName
-        }));
-      }
-    };
-    SourceMapGenerator.prototype._serializeMappings = function SourceMapGenerator_serializeMappings() {
-      var previousGeneratedColumn = 0;
-      var previousGeneratedLine = 1;
-      var previousOriginalColumn = 0;
-      var previousOriginalLine = 0;
-      var previousName = 0;
-      var previousSource = 0;
-      var result = "";
-      var next;
-      var mapping;
-      var nameIdx;
-      var sourceIdx;
-      var mappings = this._mappings.toArray();
-      for (var i = 0, len = mappings.length; i < len; i++) {
-        mapping = mappings[i];
-        next = "";
-        if (mapping.generatedLine !== previousGeneratedLine) {
-          previousGeneratedColumn = 0;
-          while (mapping.generatedLine !== previousGeneratedLine) {
-            next += ";";
-            previousGeneratedLine++;
-          }
-        } else {
-          if (i > 0) {
-            if (!util.compareByGeneratedPositionsInflated(mapping, mappings[i - 1])) {
-              continue;
-            }
-            next += ",";
-          }
-        }
-        next += base64VLQ.encode(mapping.generatedColumn - previousGeneratedColumn);
-        previousGeneratedColumn = mapping.generatedColumn;
-        if (mapping.source != null) {
-          sourceIdx = this._sources.indexOf(mapping.source);
-          next += base64VLQ.encode(sourceIdx - previousSource);
-          previousSource = sourceIdx;
-          next += base64VLQ.encode(mapping.originalLine - 1 - previousOriginalLine);
-          previousOriginalLine = mapping.originalLine - 1;
-          next += base64VLQ.encode(mapping.originalColumn - previousOriginalColumn);
-          previousOriginalColumn = mapping.originalColumn;
-          if (mapping.name != null) {
-            nameIdx = this._names.indexOf(mapping.name);
-            next += base64VLQ.encode(nameIdx - previousName);
-            previousName = nameIdx;
-          }
-        }
-        result += next;
-      }
-      return result;
-    };
-    SourceMapGenerator.prototype._generateSourcesContent = function SourceMapGenerator_generateSourcesContent(aSources, aSourceRoot) {
-      return aSources.map(function(source) {
-        if (!this._sourcesContents) {
-          return null;
-        }
-        if (aSourceRoot != null) {
-          source = util.relative(aSourceRoot, source);
-        }
-        var key = util.toSetString(source);
-        return Object.prototype.hasOwnProperty.call(this._sourcesContents, key) ? this._sourcesContents[key] : null;
-      }, this);
-    };
-    SourceMapGenerator.prototype.toJSON = function SourceMapGenerator_toJSON() {
-      var map2 = {
-        version: this._version,
-        sources: this._sources.toArray(),
-        names: this._names.toArray(),
-        mappings: this._serializeMappings()
-      };
-      if (this._file != null) {
-        map2.file = this._file;
-      }
-      if (this._sourceRoot != null) {
-        map2.sourceRoot = this._sourceRoot;
-      }
-      if (this._sourcesContents) {
-        map2.sourcesContent = this._generateSourcesContent(map2.sources, map2.sourceRoot);
-      }
-      return map2;
-    };
-    SourceMapGenerator.prototype.toString = function SourceMapGenerator_toString() {
-      return JSON.stringify(this.toJSON());
-    };
-    exports2.SourceMapGenerator = SourceMapGenerator;
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/binary-search.js
-var require_binary_search = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/binary-search.js"(exports2) {
-    "use strict";
-    exports2.GREATEST_LOWER_BOUND = 1;
-    exports2.LEAST_UPPER_BOUND = 2;
-    function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare, aBias) {
-      var mid = Math.floor((aHigh - aLow) / 2) + aLow;
-      var cmp = aCompare(aNeedle, aHaystack[mid], true);
-      if (cmp === 0) {
-        return mid;
-      } else if (cmp > 0) {
-        if (aHigh - mid > 1) {
-          return recursiveSearch(mid, aHigh, aNeedle, aHaystack, aCompare, aBias);
-        }
-        if (aBias == exports2.LEAST_UPPER_BOUND) {
-          return aHigh < aHaystack.length ? aHigh : -1;
-        } else {
-          return mid;
-        }
-      } else {
-        if (mid - aLow > 1) {
-          return recursiveSearch(aLow, mid, aNeedle, aHaystack, aCompare, aBias);
-        }
-        if (aBias == exports2.LEAST_UPPER_BOUND) {
-          return mid;
-        } else {
-          return aLow < 0 ? -1 : aLow;
-        }
-      }
-    }
-    exports2.search = function search(aNeedle, aHaystack, aCompare, aBias) {
-      if (aHaystack.length === 0) {
-        return -1;
-      }
-      var index = recursiveSearch(
-        -1,
-        aHaystack.length,
-        aNeedle,
-        aHaystack,
-        aCompare,
-        aBias || exports2.GREATEST_LOWER_BOUND
-      );
-      if (index < 0) {
-        return -1;
-      }
-      while (index - 1 >= 0) {
-        if (aCompare(aHaystack[index], aHaystack[index - 1], true) !== 0) {
-          break;
-        }
-        --index;
-      }
-      return index;
-    };
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/quick-sort.js
-var require_quick_sort = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/quick-sort.js"(exports2) {
-    "use strict";
-    function swap(ary, x, y) {
-      var temp = ary[x];
-      ary[x] = ary[y];
-      ary[y] = temp;
-    }
-    function randomIntInRange(low, high) {
-      return Math.round(low + Math.random() * (high - low));
-    }
-    function doQuickSort(ary, comparator, p, r) {
-      if (p < r) {
-        var pivotIndex = randomIntInRange(p, r);
-        var i = p - 1;
-        swap(ary, pivotIndex, r);
-        var pivot = ary[r];
-        for (var j = p; j < r; j++) {
-          if (comparator(ary[j], pivot) <= 0) {
-            i += 1;
-            swap(ary, i, j);
-          }
-        }
-        swap(ary, i + 1, j);
-        var q = i + 1;
-        doQuickSort(ary, comparator, p, q - 1);
-        doQuickSort(ary, comparator, q + 1, r);
-      }
-    }
-    exports2.quickSort = function(ary, comparator) {
-      doQuickSort(ary, comparator, 0, ary.length - 1);
-    };
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/source-map-consumer.js
-var require_source_map_consumer = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/source-map-consumer.js"(exports2) {
-    "use strict";
-    var util = require_util4();
-    var binarySearch = require_binary_search();
-    var ArraySet = require_array_set().ArraySet;
-    var base64VLQ = require_base64_vlq();
-    var quickSort = require_quick_sort().quickSort;
-    function SourceMapConsumer(aSourceMap, aSourceMapURL) {
-      var sourceMap = aSourceMap;
-      if (typeof aSourceMap === "string") {
-        sourceMap = util.parseSourceMapInput(aSourceMap);
-      }
-      return sourceMap.sections != null ? new IndexedSourceMapConsumer(sourceMap, aSourceMapURL) : new BasicSourceMapConsumer(sourceMap, aSourceMapURL);
-    }
-    SourceMapConsumer.fromSourceMap = function(aSourceMap, aSourceMapURL) {
-      return BasicSourceMapConsumer.fromSourceMap(aSourceMap, aSourceMapURL);
-    };
-    SourceMapConsumer.prototype._version = 3;
-    SourceMapConsumer.prototype.__generatedMappings = null;
-    Object.defineProperty(SourceMapConsumer.prototype, "_generatedMappings", {
-      configurable: true,
-      enumerable: true,
-      get: function() {
-        if (!this.__generatedMappings) {
-          this._parseMappings(this._mappings, this.sourceRoot);
-        }
-        return this.__generatedMappings;
-      }
-    });
-    SourceMapConsumer.prototype.__originalMappings = null;
-    Object.defineProperty(SourceMapConsumer.prototype, "_originalMappings", {
-      configurable: true,
-      enumerable: true,
-      get: function() {
-        if (!this.__originalMappings) {
-          this._parseMappings(this._mappings, this.sourceRoot);
-        }
-        return this.__originalMappings;
-      }
-    });
-    SourceMapConsumer.prototype._charIsMappingSeparator = function SourceMapConsumer_charIsMappingSeparator(aStr, index) {
-      var c = aStr.charAt(index);
-      return c === ";" || c === ",";
-    };
-    SourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
-      throw new Error("Subclasses must implement _parseMappings");
-    };
-    SourceMapConsumer.GENERATED_ORDER = 1;
-    SourceMapConsumer.ORIGINAL_ORDER = 2;
-    SourceMapConsumer.GREATEST_LOWER_BOUND = 1;
-    SourceMapConsumer.LEAST_UPPER_BOUND = 2;
-    SourceMapConsumer.prototype.eachMapping = function SourceMapConsumer_eachMapping(aCallback, aContext, aOrder) {
-      var context = aContext || null;
-      var order = aOrder || SourceMapConsumer.GENERATED_ORDER;
-      var mappings;
-      switch (order) {
-        case SourceMapConsumer.GENERATED_ORDER:
-          mappings = this._generatedMappings;
-          break;
-        case SourceMapConsumer.ORIGINAL_ORDER:
-          mappings = this._originalMappings;
-          break;
-        default:
-          throw new Error("Unknown order of iteration.");
-      }
-      var sourceRoot = this.sourceRoot;
-      mappings.map(function(mapping) {
-        var source = mapping.source === null ? null : this._sources.at(mapping.source);
-        source = util.computeSourceURL(sourceRoot, source, this._sourceMapURL);
-        return {
-          source,
-          generatedLine: mapping.generatedLine,
-          generatedColumn: mapping.generatedColumn,
-          originalLine: mapping.originalLine,
-          originalColumn: mapping.originalColumn,
-          name: mapping.name === null ? null : this._names.at(mapping.name)
-        };
-      }, this).forEach(aCallback, context);
-    };
-    SourceMapConsumer.prototype.allGeneratedPositionsFor = function SourceMapConsumer_allGeneratedPositionsFor(aArgs) {
-      var line = util.getArg(aArgs, "line");
-      var needle = {
-        source: util.getArg(aArgs, "source"),
-        originalLine: line,
-        originalColumn: util.getArg(aArgs, "column", 0)
-      };
-      needle.source = this._findSourceIndex(needle.source);
-      if (needle.source < 0) {
-        return [];
-      }
-      var mappings = [];
-      var index = this._findMapping(
-        needle,
-        this._originalMappings,
-        "originalLine",
-        "originalColumn",
-        util.compareByOriginalPositions,
-        binarySearch.LEAST_UPPER_BOUND
-      );
-      if (index >= 0) {
-        var mapping = this._originalMappings[index];
-        if (aArgs.column === void 0) {
-          var originalLine = mapping.originalLine;
-          while (mapping && mapping.originalLine === originalLine) {
-            mappings.push({
-              line: util.getArg(mapping, "generatedLine", null),
-              column: util.getArg(mapping, "generatedColumn", null),
-              lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
-            });
-            mapping = this._originalMappings[++index];
-          }
-        } else {
-          var originalColumn = mapping.originalColumn;
-          while (mapping && mapping.originalLine === line && mapping.originalColumn == originalColumn) {
-            mappings.push({
-              line: util.getArg(mapping, "generatedLine", null),
-              column: util.getArg(mapping, "generatedColumn", null),
-              lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
-            });
-            mapping = this._originalMappings[++index];
-          }
-        }
-      }
-      return mappings;
-    };
-    exports2.SourceMapConsumer = SourceMapConsumer;
-    function BasicSourceMapConsumer(aSourceMap, aSourceMapURL) {
-      var sourceMap = aSourceMap;
-      if (typeof aSourceMap === "string") {
-        sourceMap = util.parseSourceMapInput(aSourceMap);
-      }
-      var version = util.getArg(sourceMap, "version");
-      var sources = util.getArg(sourceMap, "sources");
-      var names = util.getArg(sourceMap, "names", []);
-      var sourceRoot = util.getArg(sourceMap, "sourceRoot", null);
-      var sourcesContent = util.getArg(sourceMap, "sourcesContent", null);
-      var mappings = util.getArg(sourceMap, "mappings");
-      var file = util.getArg(sourceMap, "file", null);
-      if (version != this._version) {
-        throw new Error("Unsupported version: " + version);
-      }
-      if (sourceRoot) {
-        sourceRoot = util.normalize(sourceRoot);
-      }
-      sources = sources.map(String).map(util.normalize).map(function(source) {
-        return sourceRoot && util.isAbsolute(sourceRoot) && util.isAbsolute(source) ? util.relative(sourceRoot, source) : source;
-      });
-      this._names = ArraySet.fromArray(names.map(String), true);
-      this._sources = ArraySet.fromArray(sources, true);
-      this._absoluteSources = this._sources.toArray().map(function(s) {
-        return util.computeSourceURL(sourceRoot, s, aSourceMapURL);
-      });
-      this.sourceRoot = sourceRoot;
-      this.sourcesContent = sourcesContent;
-      this._mappings = mappings;
-      this._sourceMapURL = aSourceMapURL;
-      this.file = file;
-    }
-    BasicSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
-    BasicSourceMapConsumer.prototype.consumer = SourceMapConsumer;
-    BasicSourceMapConsumer.prototype._findSourceIndex = function(aSource) {
-      var relativeSource = aSource;
-      if (this.sourceRoot != null) {
-        relativeSource = util.relative(this.sourceRoot, relativeSource);
-      }
-      if (this._sources.has(relativeSource)) {
-        return this._sources.indexOf(relativeSource);
-      }
-      var i;
-      for (i = 0; i < this._absoluteSources.length; ++i) {
-        if (this._absoluteSources[i] == aSource) {
-          return i;
-        }
-      }
-      return -1;
-    };
-    BasicSourceMapConsumer.fromSourceMap = function SourceMapConsumer_fromSourceMap(aSourceMap, aSourceMapURL) {
-      var smc = Object.create(BasicSourceMapConsumer.prototype);
-      var names = smc._names = ArraySet.fromArray(aSourceMap._names.toArray(), true);
-      var sources = smc._sources = ArraySet.fromArray(aSourceMap._sources.toArray(), true);
-      smc.sourceRoot = aSourceMap._sourceRoot;
-      smc.sourcesContent = aSourceMap._generateSourcesContent(
-        smc._sources.toArray(),
-        smc.sourceRoot
-      );
-      smc.file = aSourceMap._file;
-      smc._sourceMapURL = aSourceMapURL;
-      smc._absoluteSources = smc._sources.toArray().map(function(s) {
-        return util.computeSourceURL(smc.sourceRoot, s, aSourceMapURL);
-      });
-      var generatedMappings = aSourceMap._mappings.toArray().slice();
-      var destGeneratedMappings = smc.__generatedMappings = [];
-      var destOriginalMappings = smc.__originalMappings = [];
-      for (var i = 0, length = generatedMappings.length; i < length; i++) {
-        var srcMapping = generatedMappings[i];
-        var destMapping = new Mapping();
-        destMapping.generatedLine = srcMapping.generatedLine;
-        destMapping.generatedColumn = srcMapping.generatedColumn;
-        if (srcMapping.source) {
-          destMapping.source = sources.indexOf(srcMapping.source);
-          destMapping.originalLine = srcMapping.originalLine;
-          destMapping.originalColumn = srcMapping.originalColumn;
-          if (srcMapping.name) {
-            destMapping.name = names.indexOf(srcMapping.name);
-          }
-          destOriginalMappings.push(destMapping);
-        }
-        destGeneratedMappings.push(destMapping);
-      }
-      quickSort(smc.__originalMappings, util.compareByOriginalPositions);
-      return smc;
-    };
-    BasicSourceMapConsumer.prototype._version = 3;
-    Object.defineProperty(BasicSourceMapConsumer.prototype, "sources", {
-      get: function() {
-        return this._absoluteSources.slice();
-      }
-    });
-    function Mapping() {
-      this.generatedLine = 0;
-      this.generatedColumn = 0;
-      this.source = null;
-      this.originalLine = null;
-      this.originalColumn = null;
-      this.name = null;
-    }
-    BasicSourceMapConsumer.prototype._parseMappings = function SourceMapConsumer_parseMappings(aStr, aSourceRoot) {
-      var generatedLine = 1;
-      var previousGeneratedColumn = 0;
-      var previousOriginalLine = 0;
-      var previousOriginalColumn = 0;
-      var previousSource = 0;
-      var previousName = 0;
-      var length = aStr.length;
-      var index = 0;
-      var cachedSegments = {};
-      var temp = {};
-      var originalMappings = [];
-      var generatedMappings = [];
-      var mapping, str, segment, end, value;
-      while (index < length) {
-        if (aStr.charAt(index) === ";") {
-          generatedLine++;
-          index++;
-          previousGeneratedColumn = 0;
-        } else if (aStr.charAt(index) === ",") {
-          index++;
-        } else {
-          mapping = new Mapping();
-          mapping.generatedLine = generatedLine;
-          for (end = index; end < length; end++) {
-            if (this._charIsMappingSeparator(aStr, end)) {
-              break;
-            }
-          }
-          str = aStr.slice(index, end);
-          segment = cachedSegments[str];
-          if (segment) {
-            index += str.length;
-          } else {
-            segment = [];
-            while (index < end) {
-              base64VLQ.decode(aStr, index, temp);
-              value = temp.value;
-              index = temp.rest;
-              segment.push(value);
-            }
-            if (segment.length === 2) {
-              throw new Error("Found a source, but no line and column");
-            }
-            if (segment.length === 3) {
-              throw new Error("Found a source and line, but no column");
-            }
-            cachedSegments[str] = segment;
-          }
-          mapping.generatedColumn = previousGeneratedColumn + segment[0];
-          previousGeneratedColumn = mapping.generatedColumn;
-          if (segment.length > 1) {
-            mapping.source = previousSource + segment[1];
-            previousSource += segment[1];
-            mapping.originalLine = previousOriginalLine + segment[2];
-            previousOriginalLine = mapping.originalLine;
-            mapping.originalLine += 1;
-            mapping.originalColumn = previousOriginalColumn + segment[3];
-            previousOriginalColumn = mapping.originalColumn;
-            if (segment.length > 4) {
-              mapping.name = previousName + segment[4];
-              previousName += segment[4];
-            }
-          }
-          generatedMappings.push(mapping);
-          if (typeof mapping.originalLine === "number") {
-            originalMappings.push(mapping);
-          }
-        }
-      }
-      quickSort(generatedMappings, util.compareByGeneratedPositionsDeflated);
-      this.__generatedMappings = generatedMappings;
-      quickSort(originalMappings, util.compareByOriginalPositions);
-      this.__originalMappings = originalMappings;
-    };
-    BasicSourceMapConsumer.prototype._findMapping = function SourceMapConsumer_findMapping(aNeedle, aMappings, aLineName, aColumnName, aComparator, aBias) {
-      if (aNeedle[aLineName] <= 0) {
-        throw new TypeError("Line must be greater than or equal to 1, got " + aNeedle[aLineName]);
-      }
-      if (aNeedle[aColumnName] < 0) {
-        throw new TypeError("Column must be greater than or equal to 0, got " + aNeedle[aColumnName]);
-      }
-      return binarySearch.search(aNeedle, aMappings, aComparator, aBias);
-    };
-    BasicSourceMapConsumer.prototype.computeColumnSpans = function SourceMapConsumer_computeColumnSpans() {
-      for (var index = 0; index < this._generatedMappings.length; ++index) {
-        var mapping = this._generatedMappings[index];
-        if (index + 1 < this._generatedMappings.length) {
-          var nextMapping = this._generatedMappings[index + 1];
-          if (mapping.generatedLine === nextMapping.generatedLine) {
-            mapping.lastGeneratedColumn = nextMapping.generatedColumn - 1;
-            continue;
-          }
-        }
-        mapping.lastGeneratedColumn = Infinity;
-      }
-    };
-    BasicSourceMapConsumer.prototype.originalPositionFor = function SourceMapConsumer_originalPositionFor(aArgs) {
-      var needle = {
-        generatedLine: util.getArg(aArgs, "line"),
-        generatedColumn: util.getArg(aArgs, "column")
-      };
-      var index = this._findMapping(
-        needle,
-        this._generatedMappings,
-        "generatedLine",
-        "generatedColumn",
-        util.compareByGeneratedPositionsDeflated,
-        util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
-      );
-      if (index >= 0) {
-        var mapping = this._generatedMappings[index];
-        if (mapping.generatedLine === needle.generatedLine) {
-          var source = util.getArg(mapping, "source", null);
-          if (source !== null) {
-            source = this._sources.at(source);
-            source = util.computeSourceURL(this.sourceRoot, source, this._sourceMapURL);
-          }
-          var name = util.getArg(mapping, "name", null);
-          if (name !== null) {
-            name = this._names.at(name);
-          }
-          return {
-            source,
-            line: util.getArg(mapping, "originalLine", null),
-            column: util.getArg(mapping, "originalColumn", null),
-            name
-          };
-        }
-      }
-      return {
-        source: null,
-        line: null,
-        column: null,
-        name: null
-      };
-    };
-    BasicSourceMapConsumer.prototype.hasContentsOfAllSources = function BasicSourceMapConsumer_hasContentsOfAllSources() {
-      if (!this.sourcesContent) {
-        return false;
-      }
-      return this.sourcesContent.length >= this._sources.size() && !this.sourcesContent.some(function(sc) {
-        return sc == null;
-      });
-    };
-    BasicSourceMapConsumer.prototype.sourceContentFor = function SourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
-      if (!this.sourcesContent) {
-        return null;
-      }
-      var index = this._findSourceIndex(aSource);
-      if (index >= 0) {
-        return this.sourcesContent[index];
-      }
-      var relativeSource = aSource;
-      if (this.sourceRoot != null) {
-        relativeSource = util.relative(this.sourceRoot, relativeSource);
-      }
-      var url;
-      if (this.sourceRoot != null && (url = util.urlParse(this.sourceRoot))) {
-        var fileUriAbsPath = relativeSource.replace(/^file:\/\//, "");
-        if (url.scheme == "file" && this._sources.has(fileUriAbsPath)) {
-          return this.sourcesContent[this._sources.indexOf(fileUriAbsPath)];
-        }
-        if ((!url.path || url.path == "/") && this._sources.has("/" + relativeSource)) {
-          return this.sourcesContent[this._sources.indexOf("/" + relativeSource)];
-        }
-      }
-      if (nullOnMissing) {
-        return null;
-      } else {
-        throw new Error('"' + relativeSource + '" is not in the SourceMap.');
-      }
-    };
-    BasicSourceMapConsumer.prototype.generatedPositionFor = function SourceMapConsumer_generatedPositionFor(aArgs) {
-      var source = util.getArg(aArgs, "source");
-      source = this._findSourceIndex(source);
-      if (source < 0) {
-        return {
-          line: null,
-          column: null,
-          lastColumn: null
-        };
-      }
-      var needle = {
-        source,
-        originalLine: util.getArg(aArgs, "line"),
-        originalColumn: util.getArg(aArgs, "column")
-      };
-      var index = this._findMapping(
-        needle,
-        this._originalMappings,
-        "originalLine",
-        "originalColumn",
-        util.compareByOriginalPositions,
-        util.getArg(aArgs, "bias", SourceMapConsumer.GREATEST_LOWER_BOUND)
-      );
-      if (index >= 0) {
-        var mapping = this._originalMappings[index];
-        if (mapping.source === needle.source) {
-          return {
-            line: util.getArg(mapping, "generatedLine", null),
-            column: util.getArg(mapping, "generatedColumn", null),
-            lastColumn: util.getArg(mapping, "lastGeneratedColumn", null)
-          };
-        }
-      }
-      return {
-        line: null,
-        column: null,
-        lastColumn: null
-      };
-    };
-    exports2.BasicSourceMapConsumer = BasicSourceMapConsumer;
-    function IndexedSourceMapConsumer(aSourceMap, aSourceMapURL) {
-      var sourceMap = aSourceMap;
-      if (typeof aSourceMap === "string") {
-        sourceMap = util.parseSourceMapInput(aSourceMap);
-      }
-      var version = util.getArg(sourceMap, "version");
-      var sections = util.getArg(sourceMap, "sections");
-      if (version != this._version) {
-        throw new Error("Unsupported version: " + version);
-      }
-      this._sources = new ArraySet();
-      this._names = new ArraySet();
-      var lastOffset = {
-        line: -1,
-        column: 0
-      };
-      this._sections = sections.map(function(s) {
-        if (s.url) {
-          throw new Error("Support for url field in sections not implemented.");
-        }
-        var offset = util.getArg(s, "offset");
-        var offsetLine = util.getArg(offset, "line");
-        var offsetColumn = util.getArg(offset, "column");
-        if (offsetLine < lastOffset.line || offsetLine === lastOffset.line && offsetColumn < lastOffset.column) {
-          throw new Error("Section offsets must be ordered and non-overlapping.");
-        }
-        lastOffset = offset;
-        return {
-          generatedOffset: {
-            // The offset fields are 0-based, but we use 1-based indices when
-            // encoding/decoding from VLQ.
-            generatedLine: offsetLine + 1,
-            generatedColumn: offsetColumn + 1
-          },
-          consumer: new SourceMapConsumer(util.getArg(s, "map"), aSourceMapURL)
-        };
-      });
-    }
-    IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
-    IndexedSourceMapConsumer.prototype.constructor = SourceMapConsumer;
-    IndexedSourceMapConsumer.prototype._version = 3;
-    Object.defineProperty(IndexedSourceMapConsumer.prototype, "sources", {
-      get: function() {
-        var sources = [];
-        for (var i = 0; i < this._sections.length; i++) {
-          for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
-            sources.push(this._sections[i].consumer.sources[j]);
-          }
-        }
-        return sources;
-      }
-    });
-    IndexedSourceMapConsumer.prototype.originalPositionFor = function IndexedSourceMapConsumer_originalPositionFor(aArgs) {
-      var needle = {
-        generatedLine: util.getArg(aArgs, "line"),
-        generatedColumn: util.getArg(aArgs, "column")
-      };
-      var sectionIndex = binarySearch.search(
-        needle,
-        this._sections,
-        function(needle2, section2) {
-          var cmp = needle2.generatedLine - section2.generatedOffset.generatedLine;
-          if (cmp) {
-            return cmp;
-          }
-          return needle2.generatedColumn - section2.generatedOffset.generatedColumn;
-        }
-      );
-      var section = this._sections[sectionIndex];
-      if (!section) {
-        return {
-          source: null,
-          line: null,
-          column: null,
-          name: null
-        };
-      }
-      return section.consumer.originalPositionFor({
-        line: needle.generatedLine - (section.generatedOffset.generatedLine - 1),
-        column: needle.generatedColumn - (section.generatedOffset.generatedLine === needle.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
-        bias: aArgs.bias
-      });
-    };
-    IndexedSourceMapConsumer.prototype.hasContentsOfAllSources = function IndexedSourceMapConsumer_hasContentsOfAllSources() {
-      return this._sections.every(function(s) {
-        return s.consumer.hasContentsOfAllSources();
-      });
-    };
-    IndexedSourceMapConsumer.prototype.sourceContentFor = function IndexedSourceMapConsumer_sourceContentFor(aSource, nullOnMissing) {
-      for (var i = 0; i < this._sections.length; i++) {
-        var section = this._sections[i];
-        var content = section.consumer.sourceContentFor(aSource, true);
-        if (content) {
-          return content;
-        }
-      }
-      if (nullOnMissing) {
-        return null;
-      } else {
-        throw new Error('"' + aSource + '" is not in the SourceMap.');
-      }
-    };
-    IndexedSourceMapConsumer.prototype.generatedPositionFor = function IndexedSourceMapConsumer_generatedPositionFor(aArgs) {
-      for (var i = 0; i < this._sections.length; i++) {
-        var section = this._sections[i];
-        if (section.consumer._findSourceIndex(util.getArg(aArgs, "source")) === -1) {
-          continue;
-        }
-        var generatedPosition = section.consumer.generatedPositionFor(aArgs);
-        if (generatedPosition) {
-          var ret = {
-            line: generatedPosition.line + (section.generatedOffset.generatedLine - 1),
-            column: generatedPosition.column + (section.generatedOffset.generatedLine === generatedPosition.line ? section.generatedOffset.generatedColumn - 1 : 0)
-          };
-          return ret;
-        }
-      }
-      return {
-        line: null,
-        column: null
-      };
-    };
-    IndexedSourceMapConsumer.prototype._parseMappings = function IndexedSourceMapConsumer_parseMappings(aStr, aSourceRoot) {
-      this.__generatedMappings = [];
-      this.__originalMappings = [];
-      for (var i = 0; i < this._sections.length; i++) {
-        var section = this._sections[i];
-        var sectionMappings = section.consumer._generatedMappings;
-        for (var j = 0; j < sectionMappings.length; j++) {
-          var mapping = sectionMappings[j];
-          var source = section.consumer._sources.at(mapping.source);
-          source = util.computeSourceURL(section.consumer.sourceRoot, source, this._sourceMapURL);
-          this._sources.add(source);
-          source = this._sources.indexOf(source);
-          var name = null;
-          if (mapping.name) {
-            name = section.consumer._names.at(mapping.name);
-            this._names.add(name);
-            name = this._names.indexOf(name);
-          }
-          var adjustedMapping = {
-            source,
-            generatedLine: mapping.generatedLine + (section.generatedOffset.generatedLine - 1),
-            generatedColumn: mapping.generatedColumn + (section.generatedOffset.generatedLine === mapping.generatedLine ? section.generatedOffset.generatedColumn - 1 : 0),
-            originalLine: mapping.originalLine,
-            originalColumn: mapping.originalColumn,
-            name
-          };
-          this.__generatedMappings.push(adjustedMapping);
-          if (typeof adjustedMapping.originalLine === "number") {
-            this.__originalMappings.push(adjustedMapping);
-          }
-        }
-      }
-      quickSort(this.__generatedMappings, util.compareByGeneratedPositionsDeflated);
-      quickSort(this.__originalMappings, util.compareByOriginalPositions);
-    };
-    exports2.IndexedSourceMapConsumer = IndexedSourceMapConsumer;
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/lib/source-node.js
-var require_source_node = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/lib/source-node.js"(exports2) {
-    "use strict";
-    var SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
-    var util = require_util4();
-    var REGEX_NEWLINE = /(\r?\n)/;
-    var NEWLINE_CODE = 10;
-    var isSourceNode = "$$$isSourceNode$$$";
-    function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
-      this.children = [];
-      this.sourceContents = {};
-      this.line = aLine == null ? null : aLine;
-      this.column = aColumn == null ? null : aColumn;
-      this.source = aSource == null ? null : aSource;
-      this.name = aName == null ? null : aName;
-      this[isSourceNode] = true;
-      if (aChunks != null) this.add(aChunks);
-    }
-    SourceNode.fromStringWithSourceMap = function SourceNode_fromStringWithSourceMap(aGeneratedCode, aSourceMapConsumer, aRelativePath) {
-      var node = new SourceNode();
-      var remainingLines = aGeneratedCode.split(REGEX_NEWLINE);
-      var remainingLinesIndex = 0;
-      var shiftNextLine = function() {
-        var lineContents = getNextLine();
-        var newLine = getNextLine() || "";
-        return lineContents + newLine;
-        function getNextLine() {
-          return remainingLinesIndex < remainingLines.length ? remainingLines[remainingLinesIndex++] : void 0;
-        }
-      };
-      var lastGeneratedLine = 1, lastGeneratedColumn = 0;
-      var lastMapping = null;
-      aSourceMapConsumer.eachMapping(function(mapping) {
-        if (lastMapping !== null) {
-          if (lastGeneratedLine < mapping.generatedLine) {
-            addMappingWithCode(lastMapping, shiftNextLine());
-            lastGeneratedLine++;
-            lastGeneratedColumn = 0;
-          } else {
-            var nextLine = remainingLines[remainingLinesIndex] || "";
-            var code = nextLine.substr(0, mapping.generatedColumn - lastGeneratedColumn);
-            remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn - lastGeneratedColumn);
-            lastGeneratedColumn = mapping.generatedColumn;
-            addMappingWithCode(lastMapping, code);
-            lastMapping = mapping;
-            return;
-          }
-        }
-        while (lastGeneratedLine < mapping.generatedLine) {
-          node.add(shiftNextLine());
-          lastGeneratedLine++;
-        }
-        if (lastGeneratedColumn < mapping.generatedColumn) {
-          var nextLine = remainingLines[remainingLinesIndex] || "";
-          node.add(nextLine.substr(0, mapping.generatedColumn));
-          remainingLines[remainingLinesIndex] = nextLine.substr(mapping.generatedColumn);
-          lastGeneratedColumn = mapping.generatedColumn;
-        }
-        lastMapping = mapping;
-      }, this);
-      if (remainingLinesIndex < remainingLines.length) {
-        if (lastMapping) {
-          addMappingWithCode(lastMapping, shiftNextLine());
-        }
-        node.add(remainingLines.splice(remainingLinesIndex).join(""));
-      }
-      aSourceMapConsumer.sources.forEach(function(sourceFile) {
-        var content = aSourceMapConsumer.sourceContentFor(sourceFile);
-        if (content != null) {
-          if (aRelativePath != null) {
-            sourceFile = util.join(aRelativePath, sourceFile);
-          }
-          node.setSourceContent(sourceFile, content);
-        }
-      });
-      return node;
-      function addMappingWithCode(mapping, code) {
-        if (mapping === null || mapping.source === void 0) {
-          node.add(code);
-        } else {
-          var source = aRelativePath ? util.join(aRelativePath, mapping.source) : mapping.source;
-          node.add(new SourceNode(
-            mapping.originalLine,
-            mapping.originalColumn,
-            source,
-            code,
-            mapping.name
-          ));
-        }
-      }
-    };
-    SourceNode.prototype.add = function SourceNode_add(aChunk) {
-      if (Array.isArray(aChunk)) {
-        aChunk.forEach(function(chunk) {
-          this.add(chunk);
-        }, this);
-      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
-        if (aChunk) {
-          this.children.push(aChunk);
-        }
-      } else {
-        throw new TypeError(
-          "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
-        );
-      }
-      return this;
-    };
-    SourceNode.prototype.prepend = function SourceNode_prepend(aChunk) {
-      if (Array.isArray(aChunk)) {
-        for (var i = aChunk.length - 1; i >= 0; i--) {
-          this.prepend(aChunk[i]);
-        }
-      } else if (aChunk[isSourceNode] || typeof aChunk === "string") {
-        this.children.unshift(aChunk);
-      } else {
-        throw new TypeError(
-          "Expected a SourceNode, string, or an array of SourceNodes and strings. Got " + aChunk
-        );
-      }
-      return this;
-    };
-    SourceNode.prototype.walk = function SourceNode_walk(aFn) {
-      var chunk;
-      for (var i = 0, len = this.children.length; i < len; i++) {
-        chunk = this.children[i];
-        if (chunk[isSourceNode]) {
-          chunk.walk(aFn);
-        } else {
-          if (chunk !== "") {
-            aFn(chunk, {
-              source: this.source,
-              line: this.line,
-              column: this.column,
-              name: this.name
-            });
-          }
-        }
-      }
-    };
-    SourceNode.prototype.join = function SourceNode_join(aSep) {
-      var newChildren;
-      var i;
-      var len = this.children.length;
-      if (len > 0) {
-        newChildren = [];
-        for (i = 0; i < len - 1; i++) {
-          newChildren.push(this.children[i]);
-          newChildren.push(aSep);
-        }
-        newChildren.push(this.children[i]);
-        this.children = newChildren;
-      }
-      return this;
-    };
-    SourceNode.prototype.replaceRight = function SourceNode_replaceRight(aPattern, aReplacement) {
-      var lastChild = this.children[this.children.length - 1];
-      if (lastChild[isSourceNode]) {
-        lastChild.replaceRight(aPattern, aReplacement);
-      } else if (typeof lastChild === "string") {
-        this.children[this.children.length - 1] = lastChild.replace(aPattern, aReplacement);
-      } else {
-        this.children.push("".replace(aPattern, aReplacement));
-      }
-      return this;
-    };
-    SourceNode.prototype.setSourceContent = function SourceNode_setSourceContent(aSourceFile, aSourceContent) {
-      this.sourceContents[util.toSetString(aSourceFile)] = aSourceContent;
-    };
-    SourceNode.prototype.walkSourceContents = function SourceNode_walkSourceContents(aFn) {
-      for (var i = 0, len = this.children.length; i < len; i++) {
-        if (this.children[i][isSourceNode]) {
-          this.children[i].walkSourceContents(aFn);
-        }
-      }
-      var sources = Object.keys(this.sourceContents);
-      for (var i = 0, len = sources.length; i < len; i++) {
-        aFn(util.fromSetString(sources[i]), this.sourceContents[sources[i]]);
-      }
-    };
-    SourceNode.prototype.toString = function SourceNode_toString() {
-      var str = "";
-      this.walk(function(chunk) {
-        str += chunk;
-      });
-      return str;
-    };
-    SourceNode.prototype.toStringWithSourceMap = function SourceNode_toStringWithSourceMap(aArgs) {
-      var generated = {
-        code: "",
-        line: 1,
-        column: 0
-      };
-      var map2 = new SourceMapGenerator(aArgs);
-      var sourceMappingActive = false;
-      var lastOriginalSource = null;
-      var lastOriginalLine = null;
-      var lastOriginalColumn = null;
-      var lastOriginalName = null;
-      this.walk(function(chunk, original) {
-        generated.code += chunk;
-        if (original.source !== null && original.line !== null && original.column !== null) {
-          if (lastOriginalSource !== original.source || lastOriginalLine !== original.line || lastOriginalColumn !== original.column || lastOriginalName !== original.name) {
-            map2.addMapping({
-              source: original.source,
-              original: {
-                line: original.line,
-                column: original.column
-              },
-              generated: {
-                line: generated.line,
-                column: generated.column
-              },
-              name: original.name
-            });
-          }
-          lastOriginalSource = original.source;
-          lastOriginalLine = original.line;
-          lastOriginalColumn = original.column;
-          lastOriginalName = original.name;
-          sourceMappingActive = true;
-        } else if (sourceMappingActive) {
-          map2.addMapping({
-            generated: {
-              line: generated.line,
-              column: generated.column
-            }
-          });
-          lastOriginalSource = null;
-          sourceMappingActive = false;
-        }
-        for (var idx = 0, length = chunk.length; idx < length; idx++) {
-          if (chunk.charCodeAt(idx) === NEWLINE_CODE) {
-            generated.line++;
-            generated.column = 0;
-            if (idx + 1 === length) {
-              lastOriginalSource = null;
-              sourceMappingActive = false;
-            } else if (sourceMappingActive) {
-              map2.addMapping({
-                source: original.source,
-                original: {
-                  line: original.line,
-                  column: original.column
-                },
-                generated: {
-                  line: generated.line,
-                  column: generated.column
-                },
-                name: original.name
-              });
-            }
-          } else {
-            generated.column++;
-          }
-        }
-      });
-      this.walkSourceContents(function(sourceFile, sourceContent) {
-        map2.setSourceContent(sourceFile, sourceContent);
-      });
-      return { code: generated.code, map: map2 };
-    };
-    exports2.SourceNode = SourceNode;
-  }
-});
-
-// ../../node_modules/source-map-support/node_modules/source-map/source-map.js
-var require_source_map = __commonJS({
-  "../../node_modules/source-map-support/node_modules/source-map/source-map.js"(exports2) {
-    "use strict";
-    exports2.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
-    exports2.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
-    exports2.SourceNode = require_source_node().SourceNode;
-  }
-});
-
-// ../../node_modules/buffer-from/index.js
-var require_buffer_from = __commonJS({
-  "../../node_modules/buffer-from/index.js"(exports2, module2) {
-    "use strict";
-    var toString = Object.prototype.toString;
-    var isModern = typeof Buffer !== "undefined" && typeof Buffer.alloc === "function" && typeof Buffer.allocUnsafe === "function" && typeof Buffer.from === "function";
-    function isArrayBuffer(input) {
-      return toString.call(input).slice(8, -1) === "ArrayBuffer";
-    }
-    function fromArrayBuffer(obj, byteOffset, length) {
-      byteOffset >>>= 0;
-      var maxLength = obj.byteLength - byteOffset;
-      if (maxLength < 0) {
-        throw new RangeError("'offset' is out of bounds");
-      }
-      if (length === void 0) {
-        length = maxLength;
-      } else {
-        length >>>= 0;
-        if (length > maxLength) {
-          throw new RangeError("'length' is out of bounds");
-        }
-      }
-      return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
-    }
-    function fromString(string, encoding) {
-      if (typeof encoding !== "string" || encoding === "") {
-        encoding = "utf8";
-      }
-      if (!Buffer.isEncoding(encoding)) {
-        throw new TypeError('"encoding" must be a valid string encoding');
-      }
-      return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
-    }
-    function bufferFrom(value, encodingOrOffset, length) {
-      if (typeof value === "number") {
-        throw new TypeError('"value" argument must not be a number');
-      }
-      if (isArrayBuffer(value)) {
-        return fromArrayBuffer(value, encodingOrOffset, length);
-      }
-      if (typeof value === "string") {
-        return fromString(value, encodingOrOffset);
-      }
-      return isModern ? Buffer.from(value) : new Buffer(value);
-    }
-    module2.exports = bufferFrom;
-  }
-});
-
-// ../../node_modules/source-map-support/source-map-support.js
-var require_source_map_support = __commonJS({
-  "../../node_modules/source-map-support/source-map-support.js"(exports2, module2) {
-    "use strict";
-    var SourceMapConsumer = require_source_map().SourceMapConsumer;
-    var path = require("path");
-    var fs;
-    try {
-      fs = require("fs");
-      if (!fs.existsSync || !fs.readFileSync) {
-        fs = null;
-      }
-    } catch (err) {
-    }
-    var bufferFrom = require_buffer_from();
-    function dynamicRequire(mod, request) {
-      return mod.require(request);
-    }
-    var errorFormatterInstalled = false;
-    var uncaughtShimInstalled = false;
-    var emptyCacheBetweenOperations = false;
-    var environment = "auto";
-    var fileContentsCache = {};
-    var sourceMapCache = {};
-    var reSourceMap = /^data:application\/json[^,]+base64,/;
-    var retrieveFileHandlers = [];
-    var retrieveMapHandlers = [];
-    function isInBrowser() {
-      if (environment === "browser")
-        return true;
-      if (environment === "node")
-        return false;
-      return typeof window !== "undefined" && typeof XMLHttpRequest === "function" && !(window.require && window.module && window.process && window.process.type === "renderer");
-    }
-    function hasGlobalProcessEventEmitter() {
-      return typeof process === "object" && process !== null && typeof process.on === "function";
-    }
-    function globalProcessVersion() {
-      if (typeof process === "object" && process !== null) {
-        return process.version;
-      } else {
-        return "";
-      }
-    }
-    function globalProcessStderr() {
-      if (typeof process === "object" && process !== null) {
-        return process.stderr;
-      }
-    }
-    function globalProcessExit(code) {
-      if (typeof process === "object" && process !== null && typeof process.exit === "function") {
-        return process.exit(code);
-      }
-    }
-    function handlerExec(list) {
-      return function(arg) {
-        for (var i = 0; i < list.length; i++) {
-          var ret = list[i](arg);
-          if (ret) {
-            return ret;
-          }
-        }
-        return null;
-      };
-    }
-    var retrieveFile = handlerExec(retrieveFileHandlers);
-    retrieveFileHandlers.push(function(path2) {
-      path2 = path2.trim();
-      if (/^file:/.test(path2)) {
-        path2 = path2.replace(/file:\/\/\/(\w:)?/, function(protocol, drive) {
-          return drive ? "" : (
-            // file:///C:/dir/file -> C:/dir/file
-            "/"
-          );
-        });
-      }
-      if (path2 in fileContentsCache) {
-        return fileContentsCache[path2];
-      }
-      var contents = "";
-      try {
-        if (!fs) {
-          var xhr = new XMLHttpRequest();
-          xhr.open(
-            "GET",
-            path2,
-            /** async */
-            false
-          );
-          xhr.send(null);
-          if (xhr.readyState === 4 && xhr.status === 200) {
-            contents = xhr.responseText;
-          }
-        } else if (fs.existsSync(path2)) {
-          contents = fs.readFileSync(path2, "utf8");
-        }
-      } catch (er) {
-      }
-      return fileContentsCache[path2] = contents;
-    });
-    function supportRelativeURL(file, url) {
-      if (!file) return url;
-      var dir = path.dirname(file);
-      var match = /^\w+:\/\/[^\/]*/.exec(dir);
-      var protocol = match ? match[0] : "";
-      var startPath = dir.slice(protocol.length);
-      if (protocol && /^\/\w\:/.test(startPath)) {
-        protocol += "/";
-        return protocol + path.resolve(dir.slice(protocol.length), url).replace(/\\/g, "/");
-      }
-      return protocol + path.resolve(dir.slice(protocol.length), url);
-    }
-    function retrieveSourceMapURL(source) {
-      var fileData;
-      if (isInBrowser()) {
-        try {
-          var xhr = new XMLHttpRequest();
-          xhr.open("GET", source, false);
-          xhr.send(null);
-          fileData = xhr.readyState === 4 ? xhr.responseText : null;
-          var sourceMapHeader = xhr.getResponseHeader("SourceMap") || xhr.getResponseHeader("X-SourceMap");
-          if (sourceMapHeader) {
-            return sourceMapHeader;
-          }
-        } catch (e) {
-        }
-      }
-      fileData = retrieveFile(source);
-      var re = /(?:\/\/[@#][\s]*sourceMappingURL=([^\s'"]+)[\s]*$)|(?:\/\*[@#][\s]*sourceMappingURL=([^\s*'"]+)[\s]*(?:\*\/)[\s]*$)/mg;
-      var lastMatch, match;
-      while (match = re.exec(fileData)) lastMatch = match;
-      if (!lastMatch) return null;
-      return lastMatch[1];
-    }
-    var retrieveSourceMap = handlerExec(retrieveMapHandlers);
-    retrieveMapHandlers.push(function(source) {
-      var sourceMappingURL = retrieveSourceMapURL(source);
-      if (!sourceMappingURL) return null;
-      var sourceMapData;
-      if (reSourceMap.test(sourceMappingURL)) {
-        var rawData = sourceMappingURL.slice(sourceMappingURL.indexOf(",") + 1);
-        sourceMapData = bufferFrom(rawData, "base64").toString();
-        sourceMappingURL = source;
-      } else {
-        sourceMappingURL = supportRelativeURL(source, sourceMappingURL);
-        sourceMapData = retrieveFile(sourceMappingURL);
-      }
-      if (!sourceMapData) {
-        return null;
-      }
-      return {
-        url: sourceMappingURL,
-        map: sourceMapData
-      };
-    });
-    function mapSourcePosition(position) {
-      var sourceMap = sourceMapCache[position.source];
-      if (!sourceMap) {
-        var urlAndMap = retrieveSourceMap(position.source);
-        if (urlAndMap) {
-          sourceMap = sourceMapCache[position.source] = {
-            url: urlAndMap.url,
-            map: new SourceMapConsumer(urlAndMap.map)
-          };
-          if (sourceMap.map.sourcesContent) {
-            sourceMap.map.sources.forEach(function(source, i) {
-              var contents = sourceMap.map.sourcesContent[i];
-              if (contents) {
-                var url = supportRelativeURL(sourceMap.url, source);
-                fileContentsCache[url] = contents;
-              }
-            });
-          }
-        } else {
-          sourceMap = sourceMapCache[position.source] = {
-            url: null,
-            map: null
-          };
-        }
-      }
-      if (sourceMap && sourceMap.map && typeof sourceMap.map.originalPositionFor === "function") {
-        var originalPosition = sourceMap.map.originalPositionFor(position);
-        if (originalPosition.source !== null) {
-          originalPosition.source = supportRelativeURL(
-            sourceMap.url,
-            originalPosition.source
-          );
-          return originalPosition;
-        }
-      }
-      return position;
-    }
-    function mapEvalOrigin(origin) {
-      var match = /^eval at ([^(]+) \((.+):(\d+):(\d+)\)$/.exec(origin);
-      if (match) {
-        var position = mapSourcePosition({
-          source: match[2],
-          line: +match[3],
-          column: match[4] - 1
-        });
-        return "eval at " + match[1] + " (" + position.source + ":" + position.line + ":" + (position.column + 1) + ")";
-      }
-      match = /^eval at ([^(]+) \((.+)\)$/.exec(origin);
-      if (match) {
-        return "eval at " + match[1] + " (" + mapEvalOrigin(match[2]) + ")";
-      }
-      return origin;
-    }
-    function CallSiteToString() {
-      var fileName;
-      var fileLocation = "";
-      if (this.isNative()) {
-        fileLocation = "native";
-      } else {
-        fileName = this.getScriptNameOrSourceURL();
-        if (!fileName && this.isEval()) {
-          fileLocation = this.getEvalOrigin();
-          fileLocation += ", ";
-        }
-        if (fileName) {
-          fileLocation += fileName;
-        } else {
-          fileLocation += "<anonymous>";
-        }
-        var lineNumber = this.getLineNumber();
-        if (lineNumber != null) {
-          fileLocation += ":" + lineNumber;
-          var columnNumber = this.getColumnNumber();
-          if (columnNumber) {
-            fileLocation += ":" + columnNumber;
-          }
-        }
-      }
-      var line = "";
-      var functionName = this.getFunctionName();
-      var addSuffix = true;
-      var isConstructor = this.isConstructor();
-      var isMethodCall = !(this.isToplevel() || isConstructor);
-      if (isMethodCall) {
-        var typeName = this.getTypeName();
-        if (typeName === "[object Object]") {
-          typeName = "null";
-        }
-        var methodName = this.getMethodName();
-        if (functionName) {
-          if (typeName && functionName.indexOf(typeName) != 0) {
-            line += typeName + ".";
-          }
-          line += functionName;
-          if (methodName && functionName.indexOf("." + methodName) != functionName.length - methodName.length - 1) {
-            line += " [as " + methodName + "]";
-          }
-        } else {
-          line += typeName + "." + (methodName || "<anonymous>");
-        }
-      } else if (isConstructor) {
-        line += "new " + (functionName || "<anonymous>");
-      } else if (functionName) {
-        line += functionName;
-      } else {
-        line += fileLocation;
-        addSuffix = false;
-      }
-      if (addSuffix) {
-        line += " (" + fileLocation + ")";
-      }
-      return line;
-    }
-    function cloneCallSite(frame) {
-      var object = {};
-      Object.getOwnPropertyNames(Object.getPrototypeOf(frame)).forEach(function(name) {
-        object[name] = /^(?:is|get)/.test(name) ? function() {
-          return frame[name].call(frame);
-        } : frame[name];
-      });
-      object.toString = CallSiteToString;
-      return object;
-    }
-    function wrapCallSite(frame, state2) {
-      if (state2 === void 0) {
-        state2 = { nextPosition: null, curPosition: null };
-      }
-      if (frame.isNative()) {
-        state2.curPosition = null;
-        return frame;
-      }
-      var source = frame.getFileName() || frame.getScriptNameOrSourceURL();
-      if (source) {
-        var line = frame.getLineNumber();
-        var column = frame.getColumnNumber() - 1;
-        var noHeader = /^v(10\.1[6-9]|10\.[2-9][0-9]|10\.[0-9]{3,}|1[2-9]\d*|[2-9]\d|\d{3,}|11\.11)/;
-        var headerLength = noHeader.test(globalProcessVersion()) ? 0 : 62;
-        if (line === 1 && column > headerLength && !isInBrowser() && !frame.isEval()) {
-          column -= headerLength;
-        }
-        var position = mapSourcePosition({
-          source,
-          line,
-          column
-        });
-        state2.curPosition = position;
-        frame = cloneCallSite(frame);
-        var originalFunctionName = frame.getFunctionName;
-        frame.getFunctionName = function() {
-          if (state2.nextPosition == null) {
-            return originalFunctionName();
-          }
-          return state2.nextPosition.name || originalFunctionName();
-        };
-        frame.getFileName = function() {
-          return position.source;
-        };
-        frame.getLineNumber = function() {
-          return position.line;
-        };
-        frame.getColumnNumber = function() {
-          return position.column + 1;
-        };
-        frame.getScriptNameOrSourceURL = function() {
-          return position.source;
-        };
-        return frame;
-      }
-      var origin = frame.isEval() && frame.getEvalOrigin();
-      if (origin) {
-        origin = mapEvalOrigin(origin);
-        frame = cloneCallSite(frame);
-        frame.getEvalOrigin = function() {
-          return origin;
-        };
-        return frame;
-      }
-      return frame;
-    }
-    function prepareStackTrace(error2, stack) {
-      if (emptyCacheBetweenOperations) {
-        fileContentsCache = {};
-        sourceMapCache = {};
-      }
-      var name = error2.name || "Error";
-      var message = error2.message || "";
-      var errorString = name + ": " + message;
-      var state2 = { nextPosition: null, curPosition: null };
-      var processedStack = [];
-      for (var i = stack.length - 1; i >= 0; i--) {
-        processedStack.push("\n    at " + wrapCallSite(stack[i], state2));
-        state2.nextPosition = state2.curPosition;
-      }
-      state2.curPosition = state2.nextPosition = null;
-      return errorString + processedStack.reverse().join("");
-    }
-    function getErrorSource(error2) {
-      var match = /\n    at [^(]+ \((.*):(\d+):(\d+)\)/.exec(error2.stack);
-      if (match) {
-        var source = match[1];
-        var line = +match[2];
-        var column = +match[3];
-        var contents = fileContentsCache[source];
-        if (!contents && fs && fs.existsSync(source)) {
-          try {
-            contents = fs.readFileSync(source, "utf8");
-          } catch (er) {
-            contents = "";
-          }
-        }
-        if (contents) {
-          var code = contents.split(/(?:\r\n|\r|\n)/)[line - 1];
-          if (code) {
-            return source + ":" + line + "\n" + code + "\n" + new Array(column).join(" ") + "^";
-          }
-        }
-      }
-      return null;
-    }
-    function printErrorAndExit(error2) {
-      var source = getErrorSource(error2);
-      var stderr = globalProcessStderr();
-      if (stderr && stderr._handle && stderr._handle.setBlocking) {
-        stderr._handle.setBlocking(true);
-      }
-      if (source) {
-        console.error();
-        console.error(source);
-      }
-      console.error(error2.stack);
-      globalProcessExit(1);
-    }
-    function shimEmitUncaughtException() {
-      var origEmit = process.emit;
-      process.emit = function(type) {
-        if (type === "uncaughtException") {
-          var hasStack = arguments[1] && arguments[1].stack;
-          var hasListeners = this.listeners(type).length > 0;
-          if (hasStack && !hasListeners) {
-            return printErrorAndExit(arguments[1]);
-          }
-        }
-        return origEmit.apply(this, arguments);
-      };
-    }
-    var originalRetrieveFileHandlers = retrieveFileHandlers.slice(0);
-    var originalRetrieveMapHandlers = retrieveMapHandlers.slice(0);
-    exports2.wrapCallSite = wrapCallSite;
-    exports2.getErrorSource = getErrorSource;
-    exports2.mapSourcePosition = mapSourcePosition;
-    exports2.retrieveSourceMap = retrieveSourceMap;
-    exports2.install = function(options) {
-      options = options || {};
-      if (options.environment) {
-        environment = options.environment;
-        if (["node", "browser", "auto"].indexOf(environment) === -1) {
-          throw new Error("environment " + environment + " was unknown. Available options are {auto, browser, node}");
-        }
-      }
-      if (options.retrieveFile) {
-        if (options.overrideRetrieveFile) {
-          retrieveFileHandlers.length = 0;
-        }
-        retrieveFileHandlers.unshift(options.retrieveFile);
-      }
-      if (options.retrieveSourceMap) {
-        if (options.overrideRetrieveSourceMap) {
-          retrieveMapHandlers.length = 0;
-        }
-        retrieveMapHandlers.unshift(options.retrieveSourceMap);
-      }
-      if (options.hookRequire && !isInBrowser()) {
-        var Module = dynamicRequire(module2, "module");
-        var $compile = Module.prototype._compile;
-        if (!$compile.__sourceMapSupport) {
-          Module.prototype._compile = function(content, filename) {
-            fileContentsCache[filename] = content;
-            sourceMapCache[filename] = void 0;
-            return $compile.call(this, content, filename);
-          };
-          Module.prototype._compile.__sourceMapSupport = true;
-        }
-      }
-      if (!emptyCacheBetweenOperations) {
-        emptyCacheBetweenOperations = "emptyCacheBetweenOperations" in options ? options.emptyCacheBetweenOperations : false;
-      }
-      if (!errorFormatterInstalled) {
-        errorFormatterInstalled = true;
-        Error.prepareStackTrace = prepareStackTrace;
-      }
-      if (!uncaughtShimInstalled) {
-        var installHandler = "handleUncaughtExceptions" in options ? options.handleUncaughtExceptions : true;
-        try {
-          var worker_threads = dynamicRequire(module2, "worker_threads");
-          if (worker_threads.isMainThread === false) {
-            installHandler = false;
-          }
-        } catch (e) {
-        }
-        if (installHandler && hasGlobalProcessEventEmitter()) {
-          uncaughtShimInstalled = true;
-          shimEmitUncaughtException();
-        }
-      }
-    };
-    exports2.resetRetrieveHandlers = function() {
-      retrieveFileHandlers.length = 0;
-      retrieveMapHandlers.length = 0;
-      retrieveFileHandlers = originalRetrieveFileHandlers.slice(0);
-      retrieveMapHandlers = originalRetrieveMapHandlers.slice(0);
-      retrieveSourceMap = handlerExec(retrieveMapHandlers);
-      retrieveFile = handlerExec(retrieveFileHandlers);
-    };
-  }
-});
-
 // ../../node_modules/typescript/lib/typescript.js
 var require_typescript = __commonJS({
   "../../node_modules/typescript/lib/typescript.js"(exports2, module2) {
@@ -112077,7 +110187,7 @@ ${lanes.join("\n")}
             debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || some(process.execArgv, (arg) => /^--(?:inspect|debug)(?:-brk)?(?:=\d+)?$/i.test(arg)) || !!process.recordreplay,
             tryEnableSourceMapsForHost() {
               try {
-                require_source_map_support().install();
+                require("source-map-support").install();
               } catch {
               }
             },
@@ -340612,7 +338722,7 @@ var require_decoder = __commonJS({
 });
 
 // ../../node_modules/adm-zip/util/index.js
-var require_util5 = __commonJS({
+var require_util4 = __commonJS({
   "../../node_modules/adm-zip/util/index.js"(exports2, module2) {
     "use strict";
     module2.exports = require_utils2();
@@ -340627,7 +338737,7 @@ var require_util5 = __commonJS({
 var require_entryHeader = __commonJS({
   "../../node_modules/adm-zip/headers/entryHeader.js"(exports2, module2) {
     "use strict";
-    var Utils = require_util5();
+    var Utils = require_util4();
     var Constants = Utils.Constants;
     module2.exports = function() {
       var _verMade = 20, _version = 10, _flags = 0, _method = 0, _time = 0, _crc = 0, _compressedSize = 0, _size = 0, _fnameLen = 0, _extraLen = 0, _comLen = 0, _diskStart = 0, _inattr = 0, _attr = 0, _offset = 0;
@@ -340898,7 +339008,7 @@ var require_entryHeader = __commonJS({
 var require_mainHeader = __commonJS({
   "../../node_modules/adm-zip/headers/mainHeader.js"(exports2, module2) {
     "use strict";
-    var Utils = require_util5();
+    var Utils = require_util4();
     var Constants = Utils.Constants;
     module2.exports = function() {
       var _volumeEntries = 0, _totalEntries = 0, _size = 0, _offset = 0, _commentLength = 0;
@@ -341196,7 +339306,7 @@ var require_methods = __commonJS({
 var require_zipEntry = __commonJS({
   "../../node_modules/adm-zip/zipEntry.js"(exports2, module2) {
     "use strict";
-    var Utils = require_util5();
+    var Utils = require_util4();
     var Headers = require_headers3();
     var Constants = Utils.Constants;
     var Methods = require_methods();
@@ -341530,7 +339640,7 @@ var require_zipFile = __commonJS({
     "use strict";
     var ZipEntry = require_zipEntry();
     var Headers = require_headers3();
-    var Utils = require_util5();
+    var Utils = require_util4();
     module2.exports = function(inBuffer, options) {
       var entryList = [], entryTable = {}, _comment = Buffer.alloc(0), mainHeader = new Headers.MainHeader(), loadedEntries = false;
       var password = null;
@@ -341875,7 +339985,7 @@ var require_zipFile = __commonJS({
 var require_adm_zip = __commonJS({
   "../../node_modules/adm-zip/adm-zip.js"(exports2, module2) {
     "use strict";
-    var Utils = require_util5();
+    var Utils = require_util4();
     var pth = require("path");
     var ZipEntry = require_zipEntry();
     var ZipFile = require_zipFile();
@@ -353034,9 +351144,9 @@ var require_dist2 = __commonJS({
       for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p)) __createBinding(exports3, m, p);
     };
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolveRefFromSnapshot = exports2.replayAuthRecipeIntoBrowser = exports2.runRegisterCaptureRun = exports2.runLoginCaptureRun = exports2.filterLoginCaptureCredentials = exports2.buildLoginCaptureCredentials = exports2.isReservedRunnerEnvVar = exports2.RESERVED_RUNNER_ENV_VARS = exports2.AUTH_MARKER_VERSION = exports2.buildHealAuthStamp = exports2.extractAuthRegion = exports2.upsertAuthBlock = exports2.buildAuthRecipe = exports2.commandToReplayStep = exports2.buildReplayPlan = exports2.absoluteRoute = exports2.renderReplaySettleArrow = exports2.renderReplayClickArrow = exports2.renderAuthFn = exports2.filterFeatureGroupsToPathScope = exports2.isAuthFlowRoute = exports2.deriveSurveyPathScope = exports2.canonicalizeRoute = exports2.codeUsesInboxHelper = exports2.codeUsesTestInboxIdentity = exports2.codeSelfProvisionsRegistration = exports2.executeGrokPerBatchHeal = exports2.executeGrokPerTestHeal = exports2.headerVal = exports2.classifyAuthType = exports2.isTextExcerptable = exports2.isStaticAssetByExt = exports2.isApiCall = exports2.buildApiCallSummary = exports2.computeMobileHealOutcome = exports2.detectMobileStepSecretLeak = exports2.redactMobileSecretsFromText = exports2.MOBILE_LIVE_HEAL_SYSTEM_PROMPT = exports2.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT = exports2.executeMobileLiveHeal = exports2.executeMobileTestWithHealing = exports2.executeMobileScriptDrivenHeal = exports2.prepareMobileScenarioAppState = exports2.runMobileGeneratePhase = exports2.runMobileAIPlanner = exports2.buildMobileSiteMap = exports2.formatMobileEvidenceForPlanner = exports2.MOBILE_SCENARIO_SYSTEM_PROMPT = exports2.MOBILE_SURVEY_SYSTEM_PROMPT = exports2.runMobileExplorePhase = void 0;
-    exports2.MAX_MANIFEST_FILES = exports2.toDiffSummary = exports2.isLikelyTestFile = exports2.sanitizeRepoRelPath = exports2.sha256Hex = exports2.hashFiles = exports2.enumerateTestFiles = exports2.buildNextManifest = exports2.detectRepoSwitch = exports2.classifyImportDiff = exports2.parseImportManifest = exports2.validateAuthoredMobileTest = exports2.buildMobileRepoAuthorSystemRules = exports2.buildMobileRepoAuthorKickoff = exports2.buildMobileRepoAuthorContractMd = exports2.REPO_ANALYSIS_SCHEMA_VERSION = exports2.validateSourceEndpoints = exports2.validateAuthoredTest = exports2.validateRepoMapFile = exports2.validateRepoMemoryFile = exports2.buildTestingStandardsSection = exports2.buildRepoAuthorSystemRules = exports2.buildRepoAuthorKickoff = exports2.buildRepoAuthorContractMd = exports2.buildRepoMapSystemRules = exports2.buildRepoMapKickoff = exports2.buildRepoMapContractMd = exports2.buildRepoMemorySystemRules = exports2.buildRepoMemoryKickoff = exports2.buildRepoMemoryContractMd = exports2.runRepoAnalysisOnRunner = exports2.MOBILE_IMPORT_SCHEMA_VERSION = exports2.validateImportedMobileTest = exports2.buildMobileImportSystemRules = exports2.buildMobileImportKickoff = exports2.buildMobileImportContractMd = exports2.IMPORT_SCHEMA_VERSION = exports2.validateImportResultFile = exports2.validateImportedTest = exports2.buildImportSystemRules = exports2.buildImportKickoff = exports2.buildImportContractMd = exports2.MAX_ARCHIVE_BYTES = exports2.isUnsafeEntryName = exports2.extractZipSafely = exports2.downloadArchiveCapped = exports2.detectArchiveKind = exports2.acquireRepoForImport = exports2.runFrameworkImportOnRunner = exports2.getAgenticEngine = void 0;
-    exports2.BrokeredInboxReader = exports2.applyPlusTag = exports2.deriveProjectInboxTag = exports2.deriveInboxTag = exports2.loadVerificationInboxConfig = exports2.VerificationInboxReader = exports2.UNSUPPORTED_RENDERER_PREFIX = exports2.UnsupportedRendererError = exports2.buildCanvasModeAuthoringAddendum = exports2.buildUnsupportedRendererMessage = exports2.modelSupportsVision = exports2.decideCanvasStrategy = exports2.decideAppRenderType = exports2.detectCanvasApp = exports2.detectRateLimitBlock = exports2.isSafeCanonicalRedirect = exports2.resolveBaseUrlPreflight = exports2.checkBaseUrlRedirect = exports2.truncateAtLine = exports2.neutralizeUntrustedBlock = exports2.renderUntrustedKnowledgeBlock = exports2.stripJsonFences = exports2.scrubCredentials = exports2.withAIRetry = exports2.snapshotMatchingChildren = exports2.findNewChromiumChildPid = exports2.killProcessTree = exports2.gracefulCloseWithTreeKill = exports2.liveBrowserRegistry = exports2.REPO_SWITCH_REMOVED_FRACTION = void 0;
+    exports2.filterLoginCaptureCredentials = exports2.buildLoginCaptureCredentials = exports2.isReservedRunnerEnvVar = exports2.RESERVED_RUNNER_ENV_VARS = exports2.AUTH_MARKER_VERSION = exports2.buildHealAuthStamp = exports2.extractAuthRegion = exports2.upsertAuthBlock = exports2.buildAuthRecipe = exports2.commandToReplayStep = exports2.buildReplayPlan = exports2.absoluteRoute = exports2.renderReplaySettleArrow = exports2.renderReplayClickArrow = exports2.renderAuthFn = exports2.filterFeatureGroupsToPathScope = exports2.isAuthFlowRoute = exports2.deriveSurveyPathScope = exports2.canonicalizeRoute = exports2.codeUsesInboxHelper = exports2.codeUsesTestInboxIdentity = exports2.codeSelfProvisionsRegistration = exports2.executeGrokPerBatchHeal = exports2.executeGrokPerTestHeal = exports2.headerVal = exports2.classifyAuthType = exports2.isTextExcerptable = exports2.isStaticAssetByExt = exports2.isApiCall = exports2.buildApiCallSummary = exports2.computeMobileHealOutcome = exports2.detectMobileStepSecretLeak = exports2.redactMobileSecretsFromText = exports2.MOBILE_LIVE_HEAL_SYSTEM_PROMPT = exports2.MOBILE_SCRIPT_HEAL_SYSTEM_PROMPT = exports2.executeMobileLiveHeal = exports2.executeMobileTestWithHealing = exports2.executeMobileScriptDrivenHeal = exports2.prepareMobileScenarioAppState = exports2.runMobileGeneratePhase = exports2.isLowValueMobileAutoDeepFeature = exports2.isPackageLeafAppCatchAll = exports2.isOpaqueMobileScreenName = exports2.isScrubbedPlaceholderName = exports2.runMobileAIPlanner = exports2.buildMobileSiteMap = exports2.formatMobileEvidenceForPlanner = exports2.MOBILE_SCENARIO_SYSTEM_PROMPT = exports2.MOBILE_SURVEY_SYSTEM_PROMPT = exports2.runMobileExplorePhase = void 0;
+    exports2.sha256Hex = exports2.hashFiles = exports2.enumerateTestFiles = exports2.buildNextManifest = exports2.detectRepoSwitch = exports2.classifyImportDiff = exports2.parseImportManifest = exports2.validateAuthoredMobileTest = exports2.buildMobileRepoAuthorSystemRules = exports2.buildMobileRepoAuthorKickoff = exports2.buildMobileRepoAuthorContractMd = exports2.REPO_ANALYSIS_SCHEMA_VERSION = exports2.validateSourceEndpoints = exports2.validateAuthoredTest = exports2.validateRepoMapFile = exports2.validateRepoMemoryFile = exports2.buildTestingStandardsSection = exports2.buildRepoAuthorSystemRules = exports2.buildRepoAuthorKickoff = exports2.buildRepoAuthorContractMd = exports2.buildRepoMapSystemRules = exports2.buildRepoMapKickoff = exports2.buildRepoMapContractMd = exports2.buildRepoMemorySystemRules = exports2.buildRepoMemoryKickoff = exports2.buildRepoMemoryContractMd = exports2.runRepoAnalysisOnRunner = exports2.MOBILE_IMPORT_SCHEMA_VERSION = exports2.validateImportedMobileTest = exports2.buildMobileImportSystemRules = exports2.buildMobileImportKickoff = exports2.buildMobileImportContractMd = exports2.IMPORT_SCHEMA_VERSION = exports2.validateImportResultFile = exports2.validateImportedTest = exports2.buildImportSystemRules = exports2.buildImportKickoff = exports2.buildImportContractMd = exports2.MAX_ARCHIVE_BYTES = exports2.isUnsafeEntryName = exports2.extractZipSafely = exports2.downloadArchiveCapped = exports2.detectArchiveKind = exports2.acquireRepoForImport = exports2.runFrameworkImportOnRunner = exports2.getAgenticEngine = exports2.resolveRefFromSnapshot = exports2.replayAuthRecipeIntoBrowser = exports2.runRegisterCaptureRun = exports2.runLoginCaptureRun = void 0;
+    exports2.BrokeredInboxReader = exports2.applyPlusTag = exports2.deriveProjectInboxTag = exports2.deriveInboxTag = exports2.loadVerificationInboxConfig = exports2.VerificationInboxReader = exports2.UNSUPPORTED_RENDERER_PREFIX = exports2.UnsupportedRendererError = exports2.buildCanvasModeAuthoringAddendum = exports2.buildUnsupportedRendererMessage = exports2.modelSupportsVision = exports2.decideCanvasStrategy = exports2.decideAppRenderType = exports2.detectCanvasApp = exports2.detectRateLimitBlock = exports2.isSafeCanonicalRedirect = exports2.resolveBaseUrlPreflight = exports2.checkBaseUrlRedirect = exports2.truncateAtLine = exports2.neutralizeUntrustedBlock = exports2.renderUntrustedKnowledgeBlock = exports2.stripJsonFences = exports2.scrubCredentials = exports2.withAIRetry = exports2.snapshotMatchingChildren = exports2.findNewChromiumChildPid = exports2.killProcessTree = exports2.gracefulCloseWithTreeKill = exports2.liveBrowserRegistry = exports2.REPO_SWITCH_REMOVED_FRACTION = exports2.MAX_MANIFEST_FILES = exports2.toDiffSummary = exports2.isLikelyTestFile = exports2.sanitizeRepoRelPath = void 0;
     __exportStar(require_ai_provider(), exports2);
     __exportStar(require_mobile_types(), exports2);
     __exportStar(require_mobile_source_parser(), exports2);
@@ -353061,6 +351171,18 @@ var require_dist2 = __commonJS({
     Object.defineProperty(exports2, "runMobileAIPlanner", { enumerable: true, get: function() {
       return mobile_discovery_prompts_js_1.runMobileAIPlanner;
     } });
+    Object.defineProperty(exports2, "isScrubbedPlaceholderName", { enumerable: true, get: function() {
+      return mobile_discovery_prompts_js_1.isScrubbedPlaceholderName;
+    } });
+    Object.defineProperty(exports2, "isOpaqueMobileScreenName", { enumerable: true, get: function() {
+      return mobile_discovery_prompts_js_1.isOpaqueMobileScreenName;
+    } });
+    Object.defineProperty(exports2, "isPackageLeafAppCatchAll", { enumerable: true, get: function() {
+      return mobile_discovery_prompts_js_1.isPackageLeafAppCatchAll;
+    } });
+    Object.defineProperty(exports2, "isLowValueMobileAutoDeepFeature", { enumerable: true, get: function() {
+      return mobile_discovery_prompts_js_1.isLowValueMobileAutoDeepFeature;
+    } });
     var mobile_generator_js_1 = require_mobile_generator();
     Object.defineProperty(exports2, "runMobileGeneratePhase", { enumerable: true, get: function() {
       return mobile_generator_js_1.runMobileGeneratePhase;
@@ -353496,7 +351618,7 @@ var require_package4 = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.85",
+      version: "1.0.87",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -355408,7 +353530,7 @@ async function pressHome(sessionPath, platform3) {
 // src/services/device-quarantine.ts
 var QUARANTINE_MAX_MS = (() => {
   const raw = Number(process.env.VALIDATEQA_DEVICE_QUARANTINE_MAX_MS);
-  return Number.isFinite(raw) && raw > 0 ? raw : 10 * 60 * 1e3;
+  return Number.isFinite(raw) && raw > 0 ? raw : 2 * 60 * 1e3;
 })();
 var quarantinedAt = /* @__PURE__ */ new Map();
 var nextQuarantineToken = 1;
@@ -356905,6 +355027,12 @@ async function createSession(target) {
     // Scoped to simulator UDIDs (a physical iOS device has no such step);
     // override with APPIUM_IOS_HEADLESS=false to force a visible Simulator run.
     ...isIosSimulatorUdid(target.deviceId) && process.env.APPIUM_IOS_HEADLESS !== "false" ? { "appium:isHeadless": true } : {},
+    // WDA cold-start is flaky under dual-sim load (xcodebuild 65/75, SIGTERM).
+    // Retry startup instead of failing the whole discovery session once.
+    "appium:wdaStartupRetries": 4,
+    "appium:wdaStartupRetryInterval": 2e3,
+    "appium:wdaLaunchTimeout": 12e4,
+    "appium:wdaConnectionTimeout": 12e4,
     ...parallelCaps,
     ...realCaps
   } : {
@@ -356916,6 +355044,12 @@ async function createSession(target) {
     "appium:noReset": true,
     // See the iOS branch: the 60s default kills AI-driven discovery sessions.
     "appium:newCommandTimeout": MOBILE_NEW_COMMAND_TIMEOUT_SECONDS,
+    // Default UIA2 server launch is 30s — under dual-emu / post-quarantine
+    // stress instrumentation often needs longer or the session never binds
+    // ("instrumentation process cannot be initialized within 30000ms").
+    "appium:uiautomator2ServerLaunchTimeout": 12e4,
+    "appium:uiautomator2ServerInstallTimeout": 12e4,
+    "appium:adbExecTimeout": 12e4,
     "appium:chromedriverExecutableDir": ensureWritableChromedriverExecutableDir(),
     ...parallelCaps,
     ...realCaps
@@ -359694,6 +357828,12 @@ async function startSession(validated, res) {
     // overrides. Verified live: without this, recorder/mirror sessions on iOS
     // die with "Simulator.app does not exist" while executor sessions work.
     ...isIosSimulatorUdid(deviceId) && process.env.APPIUM_IOS_HEADLESS !== "false" ? { "appium:isHeadless": true } : {},
+    // Match executor createSession: tolerate WDA cold-start flakes.
+    "appium:newCommandTimeout": Number(process.env.VALIDATEQA_MOBILE_NEW_COMMAND_TIMEOUT) > 0 ? Math.floor(Number(process.env.VALIDATEQA_MOBILE_NEW_COMMAND_TIMEOUT)) : 600,
+    "appium:wdaStartupRetries": 4,
+    "appium:wdaStartupRetryInterval": 2e3,
+    "appium:wdaLaunchTimeout": 12e4,
+    "appium:wdaConnectionTimeout": 12e4,
     ...realCaps
   } : {
     platformName: "Android",
@@ -359702,6 +357842,10 @@ async function startSession(validated, res) {
     ...deviceId ? { "appium:udid": deviceId } : {},
     ...platformVersion ? { "appium:platformVersion": platformVersion } : {},
     "appium:noReset": true,
+    "appium:newCommandTimeout": Number(process.env.VALIDATEQA_MOBILE_NEW_COMMAND_TIMEOUT) > 0 ? Math.floor(Number(process.env.VALIDATEQA_MOBILE_NEW_COMMAND_TIMEOUT)) : 600,
+    "appium:uiautomator2ServerLaunchTimeout": 12e4,
+    "appium:uiautomator2ServerInstallTimeout": 12e4,
+    "appium:adbExecTimeout": 12e4,
     "appium:chromedriverExecutableDir": ensureWritableChromedriverExecutableDir(),
     ...realCaps
   };
@@ -360793,11 +358937,33 @@ var MobileBridgeDriver = class {
    */
   async snapshot() {
     return this.withSessionRecovery("snapshot", async () => {
-      const [xml, screenshot, windowSize] = await Promise.all([
-        getPageSource(this.sessionPath),
-        getScreenshot(this.sessionPath),
-        getWindowSize(this.sessionPath)
-      ]);
+      let xml = await getPageSource(this.sessionPath);
+      let screenshot = await getScreenshot(this.sessionPath);
+      let windowSize = await getWindowSize(this.sessionPath);
+      if (!xml) {
+        try {
+          await waitForUiSettle(this.sessionPath, {
+            timeoutMs: 8e3,
+            minStableFrames: 2,
+            pollMs: 300,
+            minElements: 1
+          });
+        } catch (err) {
+          if (isRecoverableAppiumSessionFailure(err)) throw err;
+        }
+        xml = await getPageSource(this.sessionPath);
+      }
+      if (!xml) {
+        try {
+          await this.executeScript("mobile: activateApp", [this.appLifecycleArgs()]);
+          await waitForColdBootSettle(this.sessionPath);
+        } catch (err) {
+          if (isRecoverableAppiumSessionFailure(err)) throw err;
+        }
+        xml = await getPageSource(this.sessionPath);
+        if (!screenshot) screenshot = await getScreenshot(this.sessionPath);
+        if (!windowSize) windowSize = await getWindowSize(this.sessionPath);
+      }
       if (!xml && !screenshot && !windowSize) {
         await this.assertSessionReachable();
       }
@@ -361795,8 +359961,13 @@ var RunnerUpgradeRequiredError = class extends Error {
     this.latestVersion = latestVersion;
   }
 };
+var PENDING_POLL_TIMEOUT_MS = Math.max(15e3, envInt("VALIDATE_RUNNER_PENDING_TIMEOUT_MS", 9e4));
+var POLL_STUCK_RECYCLE_MS = Math.max(6e4, envInt("VALIDATE_RUNNER_POLL_STUCK_MS", 5 * 6e4));
 async function fetchPendingRuns(serverUrl, headers) {
-  const res = await fetch(`${serverUrl}/api/runner/pending`, { headers, signal: AbortSignal.timeout(3e4) });
+  const res = await fetch(`${serverUrl}/api/runner/pending`, {
+    headers,
+    signal: AbortSignal.timeout(PENDING_POLL_TIMEOUT_MS)
+  });
   if (!res.ok) {
     if (res.status === 401) throw new Error("Runner token is invalid or expired. Run: validate.qa-runner login");
     if (res.status === 426) {
@@ -363737,14 +361908,17 @@ ${finalVerifyResult.logs ?? ""}`;
               // Android default) — a personal physical device must never have
               // its app data wiped.
               allowAppReset: mobileTarget.resetPolicy !== "PRESERVE_APP_DATA" && shouldResetMobileAppData(platform3, session.deviceId),
-              maxSessionRecoveries: 1,
+              // Dual-device discovery + long AI turns can lose WDA/UIA2 more than
+              // once per run. One recovery was too tight — the next snapshot
+              // failed as "no UI tree" after a single WDA death.
+              maxSessionRecoveries: 3,
               recoverSession: async (cause) => {
                 if (discoveryTeardownStarted) {
                   throw new Error("discovery teardown already started \u2014 not recreating the Appium session");
                 }
                 const lost = session;
                 mobileOnLog(
-                  `[appium] discovery session lost (${cause.message}); recreating once on the leased device`
+                  `[appium] discovery session lost (${cause.message}); recreating on the leased device`
                 );
                 if (lost) {
                   detachMirrorSession(lost.deviceId);
@@ -365206,10 +363380,12 @@ async function startRunner(opts) {
     log.dim(line);
   };
   let lastPendingSummary = "";
+  let lastSuccessfulPollAt = Date.now();
   while (!shuttingDown) {
     try {
       if (activeRuns < MAX_CONCURRENT) {
         const pending = await fetchPendingRuns(serverUrl, headers);
+        lastSuccessfulPollAt = Date.now();
         {
           const pendingIds = new Set(pending.map((r) => r.runId));
           for (const id of [...deferralLogged.keys()]) {
@@ -365414,6 +363590,8 @@ async function startRunner(opts) {
           }
         }
         consecutivePollErrors = 0;
+      } else {
+        lastSuccessfulPollAt = Date.now();
       }
     } catch (err) {
       if (err instanceof RunnerUpgradeRequiredError) {
@@ -365422,6 +363600,13 @@ async function startRunner(opts) {
       }
       const message = err instanceof Error ? err.message : String(err);
       consecutivePollErrors++;
+      const stuckForMs = Date.now() - lastSuccessfulPollAt;
+      if (stuckForMs >= POLL_STUCK_RECYCLE_MS) {
+        log.warn(
+          `Poll stuck for ${Math.round(stuckForMs / 1e3)}s (>= ${Math.round(POLL_STUCK_RECYCLE_MS / 1e3)}s) after error: ${message}. Recycling runner process so the supervisor can restart with a clean loop; orphaned work is re-queued server-side.`
+        );
+        process.exit(78);
+      }
       const backoffMs = Math.min(pollIntervalMs * Math.pow(2, consecutivePollErrors - 1), MAX_BACKOFF_MS);
       if (consecutivePollErrors > 1) {
         log.warn(`Poll error #${consecutivePollErrors} (${message}) - backing off for ${(backoffMs / 1e3).toFixed(1)}s`);
@@ -365474,7 +363659,76 @@ program.command("login").description("Save runner credentials for future use").r
   console.log("");
   console.log("Run: validate-runner start");
 });
-program.command("start").description("Start the local test runner").option("--token <token>", "Runner token (overrides saved credentials)").option("--server <url>", "Server URL (overrides saved credentials)").option("--project <id>", "Project ID (overrides saved credentials)").option("--mode <mode>", "Runner mode: playwright-native (default)", "playwright-native").option("--poll-interval <ms>", "Poll interval in milliseconds", "2000").option("--mobile", "Enable mobile testing (Appium + mobile bridge server)").option("--tunnel", "Enable ngrok tunnel for mobile bridge (allows HTTPS dashboard to connect)").action(async (opts) => {
+async function superviseRunnerStart(argv) {
+  const { spawn: spawn2 } = await import("child_process");
+  const minBackoffMs = 2e3;
+  const maxBackoffMs = 6e4;
+  let backoffMs = minBackoffMs;
+  let restarts = 0;
+  const windowStart = Date.now();
+  const maxRestartsPerHour = Math.max(1, Number(process.env.VALIDATE_RUNNER_MAX_RESTARTS_PER_HOUR || 30));
+  const childEnv = { ...process.env, VALIDATE_RUNNER_SUPERVISED_CHILD: "1" };
+  const runOnce = () => new Promise((resolve2) => {
+    const child = spawn2(process.execPath, argv, {
+      stdio: "inherit",
+      env: childEnv
+    });
+    const onSignal = (sig) => {
+      try {
+        child.kill(sig);
+      } catch {
+      }
+    };
+    process.once("SIGINT", onSignal);
+    process.once("SIGTERM", onSignal);
+    child.on("exit", (code, signal) => {
+      process.removeListener("SIGINT", onSignal);
+      process.removeListener("SIGTERM", onSignal);
+      if (signal === "SIGINT" || signal === "SIGTERM") {
+        resolve2(0);
+        return;
+      }
+      resolve2(code ?? 1);
+    });
+  });
+  const childArgv = argv.filter((a) => a !== "--supervise" && a !== "--no-supervise");
+  console.log("\u{1F6E1}  Runner supervisor enabled \u2014 will auto-restart on crash/stuck exit");
+  console.log("   (disable with --no-supervise or VALIDATE_RUNNER_SUPERVISE=0)");
+  for (; ; ) {
+    const code = await runOnce();
+    if (code === 0) {
+      process.exit(0);
+    }
+    restarts += 1;
+    const elapsedH = (Date.now() - windowStart) / 36e5;
+    if (elapsedH < 1 && restarts > maxRestartsPerHour) {
+      console.error(
+        `\u2717  Supervisor: ${restarts} restarts in under 1h (cap ${maxRestartsPerHour}). Stopping to avoid a crash loop. Fix the underlying issue and re-run start.`
+      );
+      process.exit(1);
+    }
+    console.warn(
+      `\u26A0  Runner exited with code ${code} \u2014 restarting in ${(backoffMs / 1e3).toFixed(1)}s (restart #${restarts}). Server will re-queue orphaned work; pending jobs resume automatically.`
+    );
+    await new Promise((r) => setTimeout(r, backoffMs));
+    backoffMs = Math.min(maxBackoffMs, Math.round(backoffMs * 1.5));
+  }
+}
+function shouldSupervise(opts) {
+  if (opts.supervise === false) return false;
+  if (opts.supervise === true) return true;
+  if (process.env.VALIDATE_RUNNER_SUPERVISED_CHILD === "1") return false;
+  if (process.env.RUNNER_CLOUD === "true") return false;
+  const env = (process.env.VALIDATE_RUNNER_SUPERVISE ?? "1").trim().toLowerCase();
+  return env !== "0" && env !== "false" && env !== "off" && env !== "no";
+}
+program.command("start").description("Start the local test runner").option("--token <token>", "Runner token (overrides saved credentials)").option("--server <url>", "Server URL (overrides saved credentials)").option("--project <id>", "Project ID (overrides saved credentials)").option("--mode <mode>", "Runner mode: playwright-native (default)", "playwright-native").option("--poll-interval <ms>", "Poll interval in milliseconds", "2000").option("--mobile", "Enable mobile testing (Appium + mobile bridge server)").option("--tunnel", "Enable ngrok tunnel for mobile bridge (allows HTTPS dashboard to connect)").option("--supervise", "Auto-restart the runner if it crashes or self-recycles (default for local)").option("--no-supervise", "Disable auto-restart supervisor").action(async (opts) => {
+  if (shouldSupervise(opts)) {
+    const argv = [...process.argv.slice(1)];
+    if (!argv.includes("--no-supervise")) argv.push("--no-supervise");
+    await superviseRunnerStart(argv);
+    return;
+  }
   await requireLatestRunner();
   const saved = loadCredentials();
   const authToken = opts.token || process.env.AUTH_TOKEN || saved?.token;