@validate.qa/runner 1.0.87 → 1.0.89

package/dist/cli.mjs

@@ -1798,7 +1798,11 @@ var init_constants = __esm({
       "home",
       "waitForElement",
       "assertVisible",
-      "assertText"
+      "assertText",
+      /** Capture list labels / badge counts into run-local state bag (Phase 1 oracles). */
+      "captureState",
+      /** Assert a prior captureState delta (removed id, count change, etc.). */
+      "assertStateDelta"
     ];
     BLOCKED_ENV_VARS = /* @__PURE__ */ new Set([
       // Execution / code-injection vectors
@@ -2233,7 +2237,10 @@ function readMobileMetadata(value) {
     webCss: typeof value.webCss === "string" && value.webCss.trim() ? value.webCss.trim() : void 0,
     webviewContext: typeof value.webviewContext === "string" && /^WEBVIEW/i.test(value.webviewContext.trim()) ? value.webviewContext.trim() : void 0,
     matchIndex: hasValidMatchPair ? rawMatchIndex : void 0,
-    expectedMatchCount: hasValidMatchPair ? rawExpectedMatchCount : void 0
+    expectedMatchCount: hasValidMatchPair ? rawExpectedMatchCount : void 0,
+    stateKey: typeof value.stateKey === "string" && value.stateKey.trim() ? value.stateKey.trim() : void 0,
+    stateKind: typeof value.stateKind === "string" && value.stateKind.trim() ? value.stateKind.trim() : void 0,
+    expect: typeof value.expect === "string" && value.expect.trim() ? value.expect.trim() : void 0
   };
 }
 function nonEmpty(value) {
@@ -2316,6 +2323,10 @@ function descriptionForStep(action, stepAction, metadata) {
       return `Assert ${label} is visible`;
     case "assertText":
       return `Assert ${label} shows "${action.value ?? action.innerText ?? ""}"`;
+    case "captureState":
+      return `Capture UI state "${metadata.stateKey ?? label}" (${metadata.stateKind ?? "list_ids"})`;
+    case "assertStateDelta":
+      return `Assert state delta "${metadata.stateKey ?? label}" expect=${metadata.expect ?? action.value ?? "changed"}`;
     default:
       return `Execute ${stepAction}`;
   }
@@ -2361,6 +2372,8 @@ function buildMobileStep(action, order) {
     step.assertion = `${labelForAction(action, metadata)} should be visible`;
   } else if (stepAction === "assertText") {
     step.assertion = action.value ?? action.innerText ?? void 0;
+  } else if (stepAction === "assertStateDelta") {
+    step.assertion = metadata.expect ?? action.value ?? "changed";
   }
   if ((stepAction === "swipe" || stepAction === "scroll") && (metadata.direction || metadata.distance)) {
     const stepMetadata = ensureMetadata(step);
@@ -2369,6 +2382,24 @@ function buildMobileStep(action, order) {
     if (metadata.distance)
       stepMetadata.distance = metadata.distance;
   }
+  if (stepAction === "captureState" || stepAction === "assertStateDelta") {
+    const stepMetadata = ensureMetadata(step);
+    const stateKey = nonEmpty(metadata.stateKey) ?? nonEmpty(action.selector) ?? nonEmpty(metadata.targetLabel) ?? `state-${order}`;
+    stepMetadata.stateKey = stateKey;
+    if (stepAction === "captureState") {
+      stepMetadata.stateKind = nonEmpty(metadata.stateKind) ?? "list_ids";
+    }
+    if (stepAction === "assertStateDelta") {
+      stepMetadata.expect = nonEmpty(metadata.expect) ?? nonEmpty(action.value) ?? "changed";
+    }
+    if (!step.target) {
+      step.target = {
+        primary: stateKey,
+        fallbacks: [],
+        screenName: metadata.screenName || "UnknownScreen"
+      };
+    }
+  }
   return step;
 }
 function buildLaunchStep(target, medium, appResetOnLaunch = false) {
@@ -2580,6 +2611,9 @@ function buildAppiumCode(testName, target, steps) {
           used.find = true;
         }
         break;
+      case "captureState":
+      case "assertStateDelta":
+        break;
       default:
         break;
     }
@@ -2698,6 +2732,8 @@ function buildAppiumCode(testName, target, steps) {
       const expectedLiteral = toJsStringLiteral(step.assertion ?? "");
       const replayExpected = step.assertion?.includes("{{") ? `resolveValue(${expectedLiteral})` : expectedLiteral;
       pushAction(`await expectText(driver, ${sel}, ${replayExpected});`);
+    } else if (step.action === "captureState" || step.action === "assertStateDelta") {
+      lines.push(`    // ${step.action}: ${step.description.replace(/\n/g, " ").slice(0, 120)}`);
     } else if (step.action === "back") {
       lines.push(`    await driver.back();`);
     } else if (step.action === "home") {
@@ -3040,7 +3076,9 @@ var init_mobile_test_generation = __esm({
       HOME: "home",
       WAIT_FOR_ELEMENT: "waitForElement",
       ASSERT_VISIBLE: "assertVisible",
-      ASSERT_TEXT: "assertText"
+      ASSERT_TEXT: "assertText",
+      CAPTURE_STATE: "captureState",
+      ASSERT_STATE_DELTA: "assertStateDelta"
     };
     MOBILE_VALUE_PLACEHOLDER_RE = /\{\{([A-Za-z0-9_]+)\}\}/g;
   }
@@ -3271,7 +3309,9 @@ var init_mobile_step_healer = __esm({
       "home",
       "waitForElement",
       "assertVisible",
-      "assertText"
+      "assertText",
+      "captureState",
+      "assertStateDelta"
     ]);
     FOREIGN_PACKAGE_RE = /\b[a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*){2,}\b/gi;
     ANDROID_RESOURCE_OWNER_RE = /([a-z][a-z0-9_]*(?:\.[a-z][a-z0-9_]*)+):id\//gi;
@@ -80310,6 +80350,306 @@ ${JSON.stringify(gatePlan)}`;
   }
 });
 
+// ../runner-core/dist/services/mobile/scenario-taxonomy.js
+var require_scenario_taxonomy = __commonJS({
+  "../runner-core/dist/services/mobile/scenario-taxonomy.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ALL_SCENARIO_KINDS = void 0;
+    exports.extractUiSignals = extractUiSignals;
+    exports.requiredScenarioKinds = requiredScenarioKinds;
+    exports.coverageGaps = coverageGaps;
+    exports.inferScenarioKind = inferScenarioKind;
+    exports.inferScenarioKinds = inferScenarioKinds;
+    exports.isStrongOracleKind = isStrongOracleKind;
+    exports.formatRequiredScenarioKindsPrompt = formatRequiredScenarioKindsPrompt;
+    exports.formatCoverageGapLog = formatCoverageGapLog;
+    exports.ALL_SCENARIO_KINDS = [
+      "smoke_nav",
+      "happy_submit",
+      "negative_validation",
+      "crud_identity",
+      "count_delta",
+      "persistence_roundtrip",
+      "auth_session",
+      "navigation_integrity",
+      "permission_system",
+      "double_submit"
+    ];
+    var DELETE_RE = /\b(delete|remove|archive|trash)\b/i;
+    var EMAIL_RE = /\b(e-?mail|email address)\b/i;
+    var PASSWORD_RE = /\b(password|passcode|pin)\b/i;
+    var SIGN_OUT_RE = /\b(sign\s*out|log\s*out|logout)\b/i;
+    var TOGGLE_RE = /\b(toggle|switch|enable|disable|on\/off)\b/i;
+    var SUBMIT_RE = /\b(submit|save|send|create|confirm|apply|done|update|post)\b/i;
+    var BADGE_OR_COUNT_RE = /\b(\d+)\s*(item|items|open|unread|invoice|message|result|pending|new)\b/i;
+    var BADGE_LABEL_RE = /\b(badge|count|open invoices|unread|notifications?)\b/i;
+    var PERMISSION_RE = /\b(camera|microphone|location|photos?|permission|allow access|not now)\b/i;
+    var SETTINGS_RE = /\b(settings|preferences|profile|account)\b/i;
+    var TAB_RE = /\b(tab|home|catalog|forms|edges|inbox|feed|dashboard)\b/i;
+    function elementText(el) {
+      return [
+        el.label ?? "",
+        el.text ?? "",
+        el.accessibilityId ?? "",
+        el.resourceId ?? "",
+        el.role ?? ""
+      ].join(" ");
+    }
+    function isEditable(el) {
+      const role = el.role ?? "";
+      return /EditText|TextField|SecureTextField|SearchField|AutoComplete|textbox|searchbox/i.test(role) || el.role === "textbox" || el.role === "searchbox";
+    }
+    function isToggle(el) {
+      const role = el.role ?? "";
+      return /Switch|CheckBox|Toggle|RadioButton/i.test(role) || TOGGLE_RE.test(elementText(el));
+    }
+    function isRowAction(el) {
+      const t = elementText(el);
+      return DELETE_RE.test(t) && el.actionable !== false;
+    }
+    function extractUiSignals(graph, appId) {
+      const screens = [...graph.screens.values()].filter((s) => {
+        if (!appId)
+          return true;
+        return s.screenId === appId || s.screenId.startsWith(`${appId}#`) || s.screenId.startsWith(`${appId}.`);
+      });
+      let hasListWithRowActions = false;
+      let hasFormFields = false;
+      let hasEmailField = false;
+      let hasNumericBadge = false;
+      let hasSettingsToggles = false;
+      let hasSignOut = false;
+      let hasDestructiveConfirm = false;
+      let hasPrimarySubmit = false;
+      let hasTabOrDrawerNav = false;
+      let hasPermissionCopy = false;
+      for (const state2 of screens) {
+        const labels = state2.elements.map(elementText);
+        const blob = [state2.screenName ?? "", state2.screenType ?? "", ...state2.observations ?? [], ...labels].join(" ");
+        if (PASSWORD_RE.test(blob) || state2.elements.some(isEditable))
+          hasFormFields = true;
+        if (labels.some((t) => EMAIL_RE.test(t)) || state2.elements.some((el) => isEditable(el) && EMAIL_RE.test(elementText(el)))) {
+          hasEmailField = true;
+          hasFormFields = true;
+        }
+        if (state2.elements.some(isRowAction))
+          hasListWithRowActions = true;
+        if (!hasListWithRowActions && state2.elements.filter((el) => el.actionable).length >= 6 && DELETE_RE.test(blob)) {
+          hasListWithRowActions = true;
+        }
+        if (BADGE_OR_COUNT_RE.test(blob) || BADGE_LABEL_RE.test(blob))
+          hasNumericBadge = true;
+        if (state2.elements.some(isToggle) || SETTINGS_RE.test(blob) && TOGGLE_RE.test(blob)) {
+          hasSettingsToggles = true;
+        }
+        if (SIGN_OUT_RE.test(blob))
+          hasSignOut = true;
+        if (DELETE_RE.test(blob) && /\b(confirm|are you sure|permanently)\b/i.test(blob)) {
+          hasDestructiveConfirm = true;
+        }
+        if (labels.some((t) => SUBMIT_RE.test(t)))
+          hasPrimarySubmit = true;
+        if (TAB_RE.test(blob) || state2.screenType === "TAB" || /\btab\b/i.test(state2.screenName ?? "")) {
+          hasTabOrDrawerNav = true;
+        }
+        if (PERMISSION_RE.test(blob) || state2.screenType === "PERMISSION")
+          hasPermissionCopy = true;
+      }
+      return {
+        hasListWithRowActions,
+        hasFormFields,
+        hasEmailField,
+        hasNumericBadge,
+        hasSettingsToggles,
+        hasSignOut,
+        hasDestructiveConfirm,
+        hasPrimarySubmit,
+        hasTabOrDrawerNav,
+        hasPermissionCopy
+      };
+    }
+    function requiredScenarioKinds(signals) {
+      const kinds = /* @__PURE__ */ new Set(["smoke_nav"]);
+      if (signals.hasFormFields || signals.hasPrimarySubmit) {
+        kinds.add("happy_submit");
+      }
+      if (signals.hasFormFields || signals.hasEmailField) {
+        kinds.add("negative_validation");
+      }
+      if (signals.hasListWithRowActions) {
+        kinds.add("crud_identity");
+      }
+      if (signals.hasNumericBadge) {
+        kinds.add("count_delta");
+      }
+      if (signals.hasSettingsToggles) {
+        kinds.add("persistence_roundtrip");
+      }
+      if (signals.hasSignOut) {
+        kinds.add("auth_session");
+      }
+      if (signals.hasTabOrDrawerNav) {
+        kinds.add("navigation_integrity");
+      }
+      if (signals.hasPermissionCopy) {
+        kinds.add("permission_system");
+      }
+      if (signals.hasPrimarySubmit && signals.hasFormFields) {
+        kinds.add("double_submit");
+      }
+      return exports.ALL_SCENARIO_KINDS.filter((k) => kinds.has(k));
+    }
+    function coverageGaps(signals, plannedKinds) {
+      const planned = new Set(plannedKinds);
+      return requiredScenarioKinds(signals).filter((k) => !planned.has(k));
+    }
+    function inferScenarioKind(scenario) {
+      const text = `${scenario.name} ${scenario.goal} ${scenario.variant ?? ""} ${scenario.type}`.toLowerCase();
+      if (/\b(invalid|empty|required|validation|too short|malformed|reject|error message)\b/.test(text) || scenario.variant === "validation" || scenario.type === "EDGE_CASE" && /\b(empty|invalid|required)\b/.test(text)) {
+        return "negative_validation";
+      }
+      if (/\b(delete|remove|wrong row|entity|archive)\b/.test(text) && /\b(list|row|item|record)\b/.test(text)) {
+        return "crud_identity";
+      }
+      if (/\b(badge|count|unread|open invoices|\+\d|increment|decrement)\b/.test(text)) {
+        return "count_delta";
+      }
+      if (/\b(persist|revisit|return|leave|settings|toggle|favorite|remember)\b/.test(text)) {
+        return "persistence_roundtrip";
+      }
+      if (/\b(sign\s*out|log\s*out|session|sign\s*in|remember me|auth)\b/.test(text) || scenario.type === "HAPPY_PATH" && /\b(login|sign in)\b/.test(text)) {
+        return "auth_session";
+      }
+      if (/\b(tab|navigate|navigation|back|deep link|empty.?state)\b/.test(text)) {
+        return "navigation_integrity";
+      }
+      if (/\b(permission|camera|microphone|location|allow)\b/.test(text)) {
+        return "permission_system";
+      }
+      if (/\b(double|twice|duplicate submit|double.?tap)\b/.test(text)) {
+        return "double_submit";
+      }
+      if (scenario.type === "HAPPY_PATH" || scenario.variant === "happy") {
+        return "happy_submit";
+      }
+      if (scenario.type === "USER_JOURNEY" || scenario.type === "REGRESSION") {
+        return "navigation_integrity";
+      }
+      return "smoke_nav";
+    }
+    function inferScenarioKinds(scenarios) {
+      return [...new Set(scenarios.map(inferScenarioKind))];
+    }
+    function isStrongOracleKind(kind) {
+      return kind !== "smoke_nav" && kind !== "navigation_integrity";
+    }
+    function formatRequiredScenarioKindsPrompt(signals) {
+      const required = requiredScenarioKinds(signals);
+      if (required.length === 0)
+        return "";
+      const lines = required.map((kind) => {
+        switch (kind) {
+          case "smoke_nav":
+            return '- smoke_nav: reach a primary destination and prove it with a durable product signal (not only "tab visible")';
+          case "happy_submit":
+            return "- happy_submit: complete a form/primary action and assert the durable result (new row, saved state, success that outlives a toast)";
+          case "negative_validation":
+            return "- negative_validation: submit empty/invalid input (e.g. empty required, malformed email-like field) and assert error OR blocked submit \u2014 never invent success copy";
+          case "crud_identity":
+            return '- crud_identity: create or note an entity id/label, perform delete/edit on THAT entity, assert identity set changed correctly (not "list still visible")';
+          case "count_delta":
+            return "- count_delta: capture a numeric badge/count, perform an action, assert the number changed as expected";
+          case "persistence_roundtrip":
+            return "- persistence_roundtrip: change a setting/toggle, leave the screen (or relaunch if policy allows), return, assert value persisted";
+          case "auth_session":
+            return "- auth_session: prove sign-in session (profile/sign-out) and/or sign-out leaves only logged-out chrome";
+          case "navigation_integrity":
+            return "- navigation_integrity: tab/drawer/back reaches the intended screen family";
+          case "permission_system":
+            return "- permission_system: permission prompt or settings path behaves honestly (allow/deny/settings)";
+          case "double_submit":
+            return "- double_submit: single user intent must not double-create (assert count +1 not +2, or single confirmation)";
+          default:
+            return `- ${kind}`;
+        }
+      });
+      return "## Required scenario kinds (from observed UI \u2014 fill each or explain impossibility in reasoning)\nThese kinds are derived ONLY from controls/screens the explorer saw. Plan at least one scenario per kind when evidence supports it.\n" + lines.join("\n");
+    }
+    function formatCoverageGapLog(gaps) {
+      if (gaps.length === 0)
+        return "Scenario taxonomy: all required kinds covered by plan";
+      return `Scenario taxonomy coverage gaps (required but not planned): ${gaps.join(", ")}`;
+    }
+  }
+});
+
+// ../runner-core/dist/services/mobile/coverage-map.js
+var require_coverage_map = __commonJS({
+  "../runner-core/dist/services/mobile/coverage-map.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.buildMobileCoverageMap = buildMobileCoverageMap;
+    var scenario_taxonomy_js_1 = require_scenario_taxonomy();
+    function strongLookup(name, map2) {
+      if (!map2)
+        return false;
+      if (map2 instanceof Map)
+        return map2.get(name) === true;
+      return Object.prototype.hasOwnProperty.call(map2, name) && map2[name] === true;
+    }
+    function buildMobileCoverageMap(input) {
+      const signals = (0, scenario_taxonomy_js_1.extractUiSignals)(input.graph, input.appId);
+      const required = (0, scenario_taxonomy_js_1.requiredScenarioKinds)(signals);
+      const planned = input.plannedScenarios ?? [];
+      const plannedKinds = planned.map(scenario_taxonomy_js_1.inferScenarioKind);
+      const plannedSet = new Set(plannedKinds);
+      const gaps = (0, scenario_taxonomy_js_1.coverageGaps)(signals, plannedKinds);
+      const kindsWithStrong = /* @__PURE__ */ new Set();
+      for (const s of planned) {
+        const kind = (0, scenario_taxonomy_js_1.inferScenarioKind)(s);
+        const isStrong = (0, scenario_taxonomy_js_1.isStrongOracleKind)(kind) || strongLookup(s.name, input.strongByScenarioName);
+        if (isStrong)
+          kindsWithStrong.add(kind);
+      }
+      const warnings = [];
+      const entries = required.map((kind) => {
+        const isPlanned = plannedSet.has(kind);
+        const strongPlanned = kindsWithStrong.has(kind);
+        let warning;
+        if (!isPlanned) {
+          warning = `Required kind "${kind}" has no planned scenario`;
+          warnings.push(warning);
+        } else if (!strongPlanned && (0, scenario_taxonomy_js_1.isStrongOracleKind)(kind)) {
+          warning = `Kind "${kind}" is planned but has no strong-oracle scenario (smoke-only coverage)`;
+          warnings.push(warning);
+        }
+        return {
+          kind,
+          required: true,
+          planned: isPlanned,
+          strongPlanned,
+          warning
+        };
+      });
+      if (planned.length > 0 && plannedKinds.every((k) => k === "smoke_nav" || k === "navigation_integrity")) {
+        const w = "All planned scenarios are smoke/nav \u2014 no strong product oracles";
+        if (!warnings.includes(w))
+          warnings.push(w);
+      }
+      const summary = warnings.length === 0 ? `Coverage map: ${required.length} required kinds, all covered with strong scenarios where needed` : `Coverage map: ${warnings.length} warning(s); ${(0, scenario_taxonomy_js_1.formatCoverageGapLog)(gaps)}`;
+      return {
+        signals,
+        requiredKinds: required,
+        gaps,
+        entries,
+        warnings,
+        summary
+      };
+    }
+  }
+});
+
 // ../runner-core/dist/services/mobile/mobile-discovery-prompts.js
 var require_mobile_discovery_prompts = __commonJS({
   "../runner-core/dist/services/mobile/mobile-discovery-prompts.js"(exports) {
@@ -80327,6 +80667,8 @@ var require_mobile_discovery_prompts = __commonJS({
     var ai_provider_js_1 = require_ai_provider();
     var discover_ai_planner_js_1 = require_discover_ai_planner();
     var mobile_observation_js_1 = require_mobile_observation();
+    var scenario_taxonomy_js_1 = require_scenario_taxonomy();
+    var coverage_map_js_1 = require_coverage_map();
     function isTargetAppScreenId(screenId, appId) {
       if (!appId)
         return true;
@@ -80408,7 +80750,7 @@ Return ONLY one valid JSON object matching the schema below. Do NOT include <thi
 9. **No duplicates** - check existing test names before adding
 10. **All tests start from the app launch entry** - every generated test starts by launching the target app. The runner clears app data when the device/reset policy safely supports it; otherwise it performs a terminate + activate relaunch, which can preserve app session data. Therefore scenarios MUST navigate through the app's own UI from whatever launch state is valid, and MUST NOT rely on mutable data from a prior scenario disappearing. Steps must reflect this: say "Launch the app and tap Sign In" not "deep-link to the login screen". Do NOT navigate by deep-link; the app's launch + tab/drawer navigation is the only entry path. \`targetPages\` lists the screen-ids involved in the flow.
 11. **targetPages must be copied CHARACTER-FOR-CHARACTER from the screen-ids in the evidence** (they look like \`com.example.app.MainActivity#ab12cd34\`). NEVER invent, prettify, or abbreviate them \u2014 no "Landing", "AUTH", "Home Screen", or any name that is not literally in the provided screens. A scenario whose targetPages contains even ONE id not present in the evidence is REJECTED WHOLESALE by the validator, so a single made-up route silently destroys the entire scenario. If you are unsure which screen-id a step touches, use the screen-id of the screen where the flow STARTS.
-12. **Happy paths must verify the DURABLE OUTCOME, not just the trigger.** A HAPPY_PATH is NOT complete until it verifies the feature's real output. "Button tapped" / "Sheet opened" / "Spinner appeared" / "Settings screen opened" is NOT a happy path - that is a UI interaction test. Form-mutation happy paths (change password, create/edit/save a record, send a message, checkout, etc.) MUST include typing into the relevant fields AND committing the form (submit/save/send or keyboard Enter/Done) \u2014 navigating to the form screen alone is insufficient. Apply this to any feature where an action produces a result the user then sees or uses: CRUD creates, photo/file uploads, searches that return results, imports, exports, payments, messages sent, AI/ML outputs, generated documents, sync runs, analysis runs, conversion, data processing. The scenario MUST include:
+12. **Happy paths must verify the DURABLE OUTCOME, not just the trigger.** A HAPPY_PATH is NOT complete until it verifies the feature's real output. "Button tapped" / "Sheet opened" / "Spinner appeared" / "Settings screen opened" is NOT a happy path - that is a UI interaction test. When the explorer observed list rows with delete/remove, plan at least one scenario that captures entity identity before the action and asserts that identity is gone or changed afterward (not merely that the list screen is still visible). When numeric badges/counts were observed, plan a before/after count check. Form-mutation happy paths (change password, create/edit/save a record, send a message, checkout, etc.) MUST include typing into the relevant fields AND committing the form (submit/save/send or keyboard Enter/Done) \u2014 navigating to the form screen alone is insufficient. Apply this to any feature where an action produces a result the user then sees or uses: CRUD creates, photo/file uploads, searches that return results, imports, exports, payments, messages sent, AI/ML outputs, generated documents, sync runs, analysis runs, conversion, data processing. The scenario MUST include:
     - The trigger step (Tap Submit / Generate / Send / Upload / Run / Analyze / Save / Pay / etc.)
     - A wait step for the operation to complete. Phrase it by SIGNAL, not wall-clock ("Wait for the result to appear - up to 60 seconds"). Prefer signals the app actually uses: spinner disappears, status badge flips to a success state, a new row appears, an item count increments, a success toast/snackbar shows, the screen transitions to a result screen.
     - A verification step on the DURABLE RESULT - the thing that outlives the transient UI: a new list row, a persisted record, a received message, a committed state change, visible output text. Do NOT assert on the spinner disappearing alone; assert on what replaced it.
@@ -80808,6 +81150,14 @@ SCOPE: this is a feature-focused deep run. Plan scenarios ONLY for the "${contex
         sections.push(`## Operator notes
 ${context.userNotes.trim()}`);
       }
+      if (context.mode === "deep" || context.mode === "full") {
+        const signals = (0, scenario_taxonomy_js_1.extractUiSignals)(graph, context.appId);
+        const requiredBlock = (0, scenario_taxonomy_js_1.formatRequiredScenarioKindsPrompt)(signals);
+        if (requiredBlock) {
+          sections.push(requiredBlock);
+          sections.push('## Scenario kind coverage rules\n1. Prefer scenarios whose expectedOutcomes prove durable product results (state deltas, validation errors, persistence), not only "control X is visible".\n2. For negative_validation: empty required field and/or malformed email-like input when an email field was observed.\n3. For crud_identity: assert the specific entity identity is gone/changed \u2014 never only that the list screen is still visible.\n4. For count_delta: mention the before/after numeric expectation in expectedOutcomes.\n5. If a required kind is impossible given evidence, say so in "reasoning" \u2014 do not invent unobserved screens.');
+        }
+      }
       const orderedScreens = plannableTargetAppScreens(graph, context.appId).sort((a, b) => a.firstSeenIteration - b.firstSeenIteration || a.screenId.localeCompare(b.screenId));
       const includedScreenIds = new Set(orderedScreens.map((state2) => state2.screenId));
       const maxElementsPerScreen = context.mode === "survey" ? SURVEY_MAX_ELEMENTS_PER_SCREEN : MAX_ELEMENTS_PER_SCREEN;
@@ -81531,6 +81881,43 @@ ${constraints.join("\n")}`);
         mobileAdaptationLogs.push(`Dropped ${guestWallFilter.dropped} guest-wall scenario(s) \u2014 explore session was authenticated; re-exec would not see sign-in gates`);
       }
       const plannedScenarios = guestWallFilter.scenarios;
+      let taxonomyGapLogs = [];
+      let taxonomyCoverageGaps = result.coverageGaps ?? [];
+      if (input.mode !== "survey" && plannedScenarios.length > 0) {
+        const signals = (0, scenario_taxonomy_js_1.extractUiSignals)(input.graph, input.appId);
+        const plannedKinds = (0, scenario_taxonomy_js_1.inferScenarioKinds)(plannedScenarios);
+        const gaps = (0, scenario_taxonomy_js_1.coverageGaps)(signals, plannedKinds);
+        const coverageMap = (0, coverage_map_js_1.buildMobileCoverageMap)({
+          graph: input.graph,
+          appId: input.appId,
+          plannedScenarios
+        });
+        taxonomyGapLogs = [(0, scenario_taxonomy_js_1.formatCoverageGapLog)(gaps), coverageMap.summary];
+        if (coverageMap.warnings.length > 0) {
+          taxonomyGapLogs.push(...coverageMap.warnings.slice(0, 12));
+        }
+        if (gaps.length > 0) {
+          taxonomyGapLogs.push(`UI signals: listRowActions=${signals.hasListWithRowActions} forms=${signals.hasFormFields} email=${signals.hasEmailField} badge=${signals.hasNumericBadge} toggles=${signals.hasSettingsToggles} signOut=${signals.hasSignOut} tabs=${signals.hasTabOrDrawerNav}`);
+          const detectedAt = (/* @__PURE__ */ new Date()).toISOString();
+          taxonomyCoverageGaps = [
+            ...taxonomyCoverageGaps,
+            ...gaps.map((kind) => ({
+              scenarioName: `[taxonomy] ${kind}`,
+              reason: `Required scenario kind "${kind}" not represented in the planned set`,
+              suggestion: `Add a ${kind} scenario backed by observed controls, or document impossibility`,
+              unmetPrerequisites: [],
+              detectedAt
+            })),
+            ...coverageMap.warnings.filter((w) => /smoke-only|no strong-oracle/i.test(w)).map((w) => ({
+              scenarioName: "[coverage-map] strong-oracle gap",
+              reason: w,
+              suggestion: "Author durable assertStateDelta/assertText outcomes for this kind",
+              unmetPrerequisites: [],
+              detectedAt
+            }))
+          ];
+        }
+      }
       if (input.mode !== "survey" && plannedScenarios.length === 0 && input.graph.screens.size > 0) {
         const fallbackScenarios = buildMobileFallbackScenarios(input);
         if (fallbackScenarios.length > 0) {
@@ -81589,7 +81976,8 @@ ${constraints.join("\n")}`);
         ...result,
         scenarios: plannedScenarios,
         featureGroups: mobileFeatureGroups,
-        logs: [...result.logs, ...mobileAdaptationLogs]
+        coverageGaps: taxonomyCoverageGaps.length > 0 ? taxonomyCoverageGaps : result.coverageGaps,
+        logs: [...result.logs, ...mobileAdaptationLogs, ...taxonomyGapLogs]
       };
     }
   }
@@ -81668,6 +82056,7 @@ var require_mobile_generator = __commonJS({
     var ai_retry_js_1 = require_ai_retry();
     var mobile_session_keepalive_js_1 = require_mobile_session_keepalive();
     var discovery_lint_flags_js_1 = require_discovery_lint_flags();
+    var scenario_taxonomy_js_1 = require_scenario_taxonomy();
     var mobile_source_parser_js_1 = require_mobile_source_parser();
     var mobile_source_parser_js_2 = require_mobile_source_parser();
     var mobile_observation_js_1 = require_mobile_observation();
@@ -81809,6 +82198,50 @@ var require_mobile_generator = __commonJS({
         }
       }
     };
+    var MOBILE_CAPTURE_STATE_TOOL = {
+      type: "function",
+      function: {
+        name: "mobile_capture_state",
+        description: 'Capture list labels or numeric badge counts into a named state key BEFORE a mutating action (delete/create/toggle). Pair with mobile_assert_state_delta afterward to prove durable identity/count outcomes \u2014 stronger than "list still visible".',
+        parameters: {
+          type: "object",
+          properties: {
+            stateKey: {
+              type: "string",
+              description: 'Short key for this bag entry (e.g. "invoice_list", "open_count"). Reuse the same key in mobile_assert_state_delta.'
+            },
+            kind: {
+              type: "string",
+              enum: ["list_ids", "badge_count"],
+              description: "list_ids = unique visible labels; badge_count = numeric count tokens. Default list_ids."
+            }
+          },
+          required: ["stateKey"]
+        }
+      }
+    };
+    var MOBILE_ASSERT_STATE_DELTA_TOOL = {
+      type: "function",
+      function: {
+        name: "mobile_assert_state_delta",
+        description: "Compare the current screen to a prior mobile_capture_state. Verifies LIVE then records assertStateDelta. Use after delete/create/count-changing actions. expect: changed | entity_removed | count_decreased | count_increased | unchanged | persisted.",
+        parameters: {
+          type: "object",
+          properties: {
+            stateKey: {
+              type: "string",
+              description: "Must match a prior mobile_capture_state stateKey in this scenario."
+            },
+            expect: {
+              type: "string",
+              enum: ["changed", "entity_removed", "count_decreased", "count_increased", "unchanged", "persisted"],
+              description: "What must differ (or persist) vs the prior capture. Default: changed."
+            }
+          },
+          required: ["stateKey"]
+        }
+      }
+    };
     var MOBILE_FILL_CREDENTIAL_TOOL = {
       type: "function",
       function: {
@@ -81831,7 +82264,7 @@ var require_mobile_generator = __commonJS({
       type: "function",
       function: {
         name: "finish_generate",
-        description: "Call when the scenario is fully exercised and its outcome is asserted. verified:true requires you to have called at least one assert tool (mobile_assert_visible / mobile_assert_text) \u2014 claiming verified without any assert is auto-downgraded.",
+        description: "Call when the scenario is fully exercised and its outcome is asserted. verified:true requires you to have called at least one assert tool (mobile_assert_visible / mobile_assert_text / mobile_assert_state_delta) \u2014 claiming verified without any assert is auto-downgraded.",
         parameters: {
           type: "object",
           properties: {
@@ -81863,6 +82296,8 @@ var require_mobile_generator = __commonJS({
       MOBILE_RELAUNCH_TOOL,
       MOBILE_ASSERT_VISIBLE_TOOL,
       MOBILE_ASSERT_TEXT_TOOL,
+      MOBILE_CAPTURE_STATE_TOOL,
+      MOBILE_ASSERT_STATE_DELTA_TOOL,
       FINISH_GENERATE_TOOL
     ];
     var STRUCTURAL_KEY_MAX_ELEMENTS = 16;
@@ -82129,6 +82564,7 @@ The scenario name + goal + steps describe ONE product behavior from survey/disco
    - 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})
+   - For list delete/create or count changes: mobile_capture_state({stateKey, kind}) BEFORE the mutation, then mobile_assert_state_delta({stateKey, expect}) AFTER \u2014 proves identity/count change, not only "list screen still visible".
    - 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.
@@ -82242,6 +82678,7 @@ Start by calling mobile_snapshot, then execute ONLY the steps needed for this go
       const { scenario, driver, platform: platform3, maxIterations, agentModel, provider, aiClient, auditGroupId, onAICall, onScreenshot, targetAppId, credentials, redactionCredentials, log: emitLog, allowRelaunch } = args;
       const log2 = (line) => emitLog(redactCredentialValues(line, redactionCredentials));
       const actions = [];
+      const stateBag = /* @__PURE__ */ new Map();
       let assertCount = 0;
       let finish = null;
       let finishIntentRejections = 0;
@@ -82711,7 +83148,9 @@ ${statePacket}`, redactionCredentials) },
         const screenDependentTools = /* @__PURE__ */ new Set([
           ...screenMutatingTools,
           "mobile_assert_visible",
-          "mobile_assert_text"
+          "mobile_assert_text",
+          "mobile_capture_state",
+          "mobile_assert_state_delta"
         ]);
         for (const toolCall of assistantMessage.tool_calls) {
           const toolName = toolCall.function.name;
@@ -82755,7 +83194,7 @@ ${statePacket}`, redactionCredentials) },
               if (intentReason)
                 reasons.push(intentReason);
               if (verifiedWithoutAssert) {
-                reasons.push("claimed verified:true but never called mobile_assert_visible / mobile_assert_text");
+                reasons.push("claimed verified:true but never called mobile_assert_visible / mobile_assert_text / mobile_assert_state_delta");
               }
               if (strengthRejectReason !== null) {
                 reasons.push(`assertion strength: ${strengthRejectReason} \u2014 your only live proof re-checks a control you already used. Assert the scenario OUTCOME instead: an element on the resulting screen, the created/updated row, or the success/error message.`);
@@ -82826,10 +83265,12 @@ ${statePacket}`, redactionCredentials) },
                   }
                 } : action;
                 actions.push((0, shared_1.placeholderizeRecordedMobileAction)(finalizeAction(stamped), credentials));
-                if (action.type === "ASSERT_VISIBLE" || action.type === "ASSERT_TEXT")
+                if (action.type === "ASSERT_VISIBLE" || action.type === "ASSERT_TEXT" || action.type === "ASSERT_STATE_DELTA") {
                   assertCount++;
+                }
               },
               recordedActions: actions,
+              stateBag,
               log: log2
             });
             if (screenMutatingTools.has(toolName))
@@ -82848,7 +83289,7 @@ ${statePacket}`, redactionCredentials) },
       return { actions, assertCount, finish, lastSnapshot: lastTargetSnapshot, lastScreenName: lastTargetScreenName };
     }
     async function dispatchGenerateTool(args) {
-      const { toolName, toolArgs, driver, platform: platform3, targetAppId, latest, absorbObservation, resolveRef, resolveHybridRef, maybeEnrichHybridWeb, setLatest, credentials, screenName, allowRelaunch, recordAction, recordedActions, log: log2 } = args;
+      const { toolName, toolArgs, driver, platform: platform3, targetAppId, latest, absorbObservation, resolveRef, resolveHybridRef, maybeEnrichHybridWeb, setLatest, credentials, screenName, allowRelaunch, recordAction, recordedActions, stateBag, log: log2 } = args;
       const unknownRef = (ref) => ({
         ok: false,
         error: `Unknown element ref "${String(ref)}". Call mobile_snapshot first; refs are only valid for the latest snapshot.`
@@ -83393,10 +83834,170 @@ ${statePacket}`, redactionCredentials) },
             target: metadata.targetLabel
           };
         }
+        case "mobile_capture_state": {
+          const stateKey = nonEmpty3(typeof toolArgs.stateKey === "string" ? toolArgs.stateKey : "");
+          if (!stateKey) {
+            return { ok: false, error: "mobile_capture_state requires a non-empty stateKey." };
+          }
+          const kindRaw = typeof toolArgs.kind === "string" ? toolArgs.kind.trim() : "list_ids";
+          const kind = kindRaw === "badge_count" ? "badge_count" : "list_ids";
+          const snap = latest();
+          if (!snap) {
+            return { ok: false, error: "No snapshot yet \u2014 call mobile_snapshot before mobile_capture_state." };
+          }
+          const values = captureValuesFromElements(snap.screen.elements, kind);
+          stateBag.set(stateKey, { kind, values });
+          recordAction({
+            type: "CAPTURE_STATE",
+            selector: stateKey,
+            metadata: {
+              screenName: screenName(),
+              targetLabel: stateKey,
+              stateKey,
+              stateKind: kind
+            }
+          });
+          log2(`  capture_state: key=${stateKey} kind=${kind} n=${values.length}`);
+          return {
+            ok: true,
+            captured: true,
+            stateKey,
+            kind,
+            sample: values.slice(0, 8),
+            count: values.length
+          };
+        }
+        case "mobile_assert_state_delta": {
+          const stateKey = nonEmpty3(typeof toolArgs.stateKey === "string" ? toolArgs.stateKey : "");
+          if (!stateKey) {
+            return { ok: false, error: "mobile_assert_state_delta requires a non-empty stateKey." };
+          }
+          const prior = stateBag.get(stateKey);
+          if (!prior) {
+            return {
+              ok: false,
+              error: `No prior mobile_capture_state for key "${stateKey}". Capture before the mutating action, then assert.`
+            };
+          }
+          const expectRaw = typeof toolArgs.expect === "string" ? toolArgs.expect.trim() : "changed";
+          const expect = expectRaw || "changed";
+          const snap = latest();
+          if (!snap) {
+            return { ok: false, error: "No snapshot yet \u2014 call mobile_snapshot after the action, then assert_state_delta." };
+          }
+          const current = captureValuesFromElements(snap.screen.elements, prior.kind);
+          const liveError = liveAssertStateDelta(prior.values, current, expect, stateKey);
+          if (liveError) {
+            return {
+              ok: false,
+              error: liveError,
+              beforeSample: prior.values.slice(0, 8),
+              afterSample: current.slice(0, 8)
+            };
+          }
+          recordAction({
+            type: "ASSERT_STATE_DELTA",
+            value: expect,
+            selector: stateKey,
+            metadata: {
+              screenName: screenName(),
+              targetLabel: stateKey,
+              stateKey,
+              stateKind: prior.kind,
+              expect
+            }
+          });
+          log2(`  assert_state_delta: key=${stateKey} expect=${expect}`);
+          return {
+            ok: true,
+            asserted: "state_delta",
+            stateKey,
+            expect,
+            beforeCount: prior.values.length,
+            afterCount: current.length
+          };
+        }
         default:
           return { ok: false, error: `Unknown tool: ${toolName}` };
       }
     }
+    function captureValuesFromElements(elements, kind) {
+      if (kind === "badge_count") {
+        const nums = /* @__PURE__ */ new Set();
+        const preferred = /* @__PURE__ */ new Set();
+        for (const el of elements) {
+          const t = [el.label, el.text, el.accessibilityId].filter(Boolean).join(" ");
+          for (const m of t.matchAll(/\b(\d{1,6})\b/g))
+            nums.add(m[1]);
+          if (/(?:count|badge|open|unread|item|invoice|result|pending)/i.test(t)) {
+            for (const m of t.matchAll(/\b(\d{1,6})\b/g))
+              preferred.add(m[1]);
+          }
+        }
+        return preferred.size > 0 ? [...preferred] : [...nums].slice(0, 20);
+      }
+      const labels = /* @__PURE__ */ new Set();
+      for (const el of elements) {
+        for (const raw of [el.label, el.text, el.accessibilityId]) {
+          const t = raw?.trim() ?? "";
+          if (t.length < 2 || t.length > 80)
+            continue;
+          if (/^(true|false|null|OK|Cancel)$/i.test(t))
+            continue;
+          labels.add(t);
+        }
+      }
+      return [...labels].slice(0, 80);
+    }
+    function liveAssertStateDelta(before, after, expect, key) {
+      const beforeSet = new Set(before);
+      const afterSet = new Set(after);
+      const removed = before.filter((v) => !afterSet.has(v));
+      const added = after.filter((v) => !beforeSet.has(v));
+      const exp = expect.toLowerCase().trim();
+      if (exp === "changed" || exp === "any_change") {
+        if (removed.length === 0 && added.length === 0) {
+          return `assertStateDelta(${key}): expected change, captures identical (${before.length} values)`;
+        }
+        return null;
+      }
+      if (exp === "removed" || exp === "entity_removed" || exp.startsWith("removed:")) {
+        if (removed.length === 0) {
+          return `assertStateDelta(${key}): expected at least one entity removed`;
+        }
+        return null;
+      }
+      if (exp === "count_decreased" || exp === "count-1") {
+        const b = before.map(Number).filter((n) => Number.isFinite(n));
+        const a = after.map(Number).filter((n) => Number.isFinite(n));
+        const bMax = b.length ? Math.max(...b) : NaN;
+        const aMax = a.length ? Math.max(...a) : NaN;
+        if (!Number.isFinite(bMax) || !Number.isFinite(aMax) || aMax >= bMax) {
+          return `assertStateDelta(${key}): expected count decrease (before max=${bMax}, after max=${aMax})`;
+        }
+        return null;
+      }
+      if (exp === "count_increased" || exp === "count+1") {
+        const b = before.map(Number).filter((n) => Number.isFinite(n));
+        const a = after.map(Number).filter((n) => Number.isFinite(n));
+        const bMax = b.length ? Math.max(...b) : NaN;
+        const aMax = a.length ? Math.max(...a) : NaN;
+        if (!Number.isFinite(bMax) || !Number.isFinite(aMax) || aMax <= bMax) {
+          return `assertStateDelta(${key}): expected count increase (before max=${bMax}, after max=${aMax})`;
+        }
+        return null;
+      }
+      if (exp === "unchanged" || exp === "persisted") {
+        if (removed.length > 0 || added.length > 0) {
+          return `assertStateDelta(${key}): expected persistence/unchanged but set changed`;
+        }
+        return null;
+      }
+      if (removed.length === 0 && added.length === 0) {
+        return `assertStateDelta(${key}): expected change (expect=${expect}), state identical`;
+      }
+      return null;
+    }
     function recordAssertVisible(toolArgs, ctx) {
       const { resolveRef, latest, screenName, platform: platform3, recordAction } = ctx;
       const element = resolveRef(toolArgs.ref);
@@ -84376,6 +84977,14 @@ ${statePacket}`, redactionCredentials) },
             lines.push(`  await expect(page.getByText('${expected}')).toBeVisible();`);
             break;
           }
+          case "CAPTURE_STATE":
+            lines.push(`  // captureState ${escape((action.metadata.stateKey ?? label).slice(0, 40))}`);
+            break;
+          case "ASSERT_STATE_DELTA": {
+            const expect = escape((action.metadata.expect ?? action.value ?? "changed").slice(0, 40));
+            lines.push(`  await expect(page.getByText('state:${expect}')).toBeVisible();`);
+            break;
+          }
           case "CLEAR":
             lines.push(`  await page.getByLabel('${label}').fill('');`);
             break;
@@ -84419,6 +85028,22 @@ ${statePacket}`, redactionCredentials) },
       return [action.selector, action.value, action.innerText, action.metadata?.targetLabel].filter((v) => typeof v === "string" && v.trim().length > 0).join(" ");
     }
     function evaluateMobileAssertionStrength(actions) {
+      if (actions.some((a) => a.type === "ASSERT_STATE_DELTA")) {
+        return {
+          ok: true,
+          severity: "none",
+          reason: "state-delta oracle proves a durable product change (identity/count/persistence)",
+          signals: {
+            apiTest: false,
+            interacted: actions.some((a) => a.type === "TAP" || a.type === "TYPE" || a.type === "CLEAR"),
+            mutated: actions.some((a) => a.type === "TYPE" || a.type === "CLEAR" || a.type === "TAP"),
+            navOnly: false,
+            hasOutcomeProof: true,
+            errorBanner: false,
+            terminal: null
+          }
+        };
+      }
       const modelAsserts = actions.filter((a) => a.type === "ASSERT_VISIBLE" || a.type === "ASSERT_TEXT");
       if (modelAsserts.length === 0) {
         return {
@@ -84588,6 +85213,16 @@ ${statePacket}`, redactionCredentials) },
       if (coldResetUnavailable)
         tags.push("@warm-state");
       const strengthBlocked = !strengthVerdict.ok || strengthVerdict.severity === "block" || strengthVerdict.severity === "route-bug" || !verified || coldResetUnavailable;
+      {
+        const kind = (0, scenario_taxonomy_js_1.inferScenarioKind)(scenario);
+        const hasStateOracle = compiled.steps.some((s) => s.action === "assertStateDelta" || s.action === "assertText" || s.action === "captureState");
+        const strong = verified && !strengthBlocked && strengthVerdict.severity === "none" && ((0, scenario_taxonomy_js_1.isStrongOracleKind)(kind) || hasStateOracle);
+        if (strong)
+          tags.push("@strong-oracle");
+        else if (!tags.includes("@smoke") && (kind === "smoke_nav" || kind === "navigation_integrity")) {
+          tags.push("@smoke");
+        }
+      }
       const strengthReason = coldResetUnavailable ? `Cold app-data reset unavailable${coldResetReason ? ` (${coldResetReason})` : ""} \u2014 generation may not match cold-boot replay. ${strengthVerdict.reason}` : !verified && recording.assertCount === 0 ? "Mobile scenario finished unverified \u2014 the agent never proved the scenario outcome live, so the recording may not demonstrate the goal (e.g. a happy path that never completed). Review before promotion." : strengthVerdict.reason;
       const test = {
         name: compiled.name,
@@ -84835,6 +85470,344 @@ Mobile generate phase complete: ${tests.length}/${scenarios.length} test(s) gene
   }
 });
 
+// ../runner-core/dist/services/mobile/failure-triage.js
+var require_failure_triage = __commonJS({
+  "../runner-core/dist/services/mobile/failure-triage.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.hasStrongMobileOracle = hasStrongMobileOracle;
+    exports.isStrongOracleStep = isStrongOracleStep;
+    exports.listStrongOracleKinds = listStrongOracleKinds;
+    exports.triageMobileFailure = triageMobileFailure;
+    exports.triageToHealTerminal = triageToHealTerminal;
+    var STRONG_ACTIONS = /* @__PURE__ */ new Set(["assertStateDelta", "assertText", "captureState"]);
+    var CHROME_VISIBLE_RE = /\b(tab|home|settings|back|menu|navigation|nav bar|bottom nav|status bar)\b/i;
+    function hasStrongMobileOracle(steps) {
+      return steps.some(isStrongOracleStep);
+    }
+    function isStrongOracleStep(step) {
+      if (STRONG_ACTIONS.has(step.action))
+        return true;
+      if (step.action !== "assertVisible")
+        return false;
+      const blob = [
+        step.assertion ?? "",
+        step.description ?? "",
+        step.target?.primary ?? "",
+        ...step.target?.fallbacks ?? []
+      ].join(" ");
+      if (/\b(error|invalid|required|must|cannot|failed|denied|blocked|empty|missing|deleted|removed|saved|success|created|updated)\b/i.test(blob)) {
+        return true;
+      }
+      if (CHROME_VISIBLE_RE.test(blob) && blob.length < 80)
+        return false;
+      return false;
+    }
+    function listStrongOracleKinds(steps) {
+      const kinds = /* @__PURE__ */ new Set();
+      for (const step of steps) {
+        if (step.action === "assertStateDelta")
+          kinds.add("assertStateDelta");
+        else if (step.action === "assertText")
+          kinds.add("assertText");
+        else if (step.action === "captureState")
+          kinds.add("captureState");
+        else if (isStrongOracleStep(step))
+          kinds.add(step.action);
+      }
+      return [...kinds];
+    }
+    function errorText(error2, logs2) {
+      return `${error2 ?? ""}
+${logs2 ?? ""}`.trim();
+    }
+    function leadingPrefix(error2) {
+      if (!error2)
+        return null;
+      const m = error2.match(/^(CONFIG_ISSUE|APP_BUG|RATE_LIMIT_BLOCKED|PREREQ_UNMET|HEAL_SECRET_LEAK)\s*:/i);
+      return m ? m[1].toUpperCase() : null;
+    }
+    function looksLikeConfig(text) {
+      if (/CONFIG_ISSUE\s*:/i.test(text))
+        return true;
+      if (/RATE_LIMIT_BLOCKED\s*:/i.test(text))
+        return true;
+      if (/Missing mobile test variable/i.test(text))
+        return true;
+      if (/\b(quota|rate.?limit|429|lockout)\b/i.test(text))
+        return true;
+      if (/\b(device (?:offline|disconnected|not found)|session (?:not started|terminated|deleted))\b/i.test(text)) {
+        return true;
+      }
+      if (/\b(Appium|adbExec|UiAutomator2|XCUITest)\b/i.test(text) && /\b(ECONNREFUSED|timeout|not available|could not start|driver)\b/i.test(text)) {
+        return true;
+      }
+      return false;
+    }
+    function looksLikePrereq(text) {
+      return /PREREQ_UNMET\s*:/i.test(text) || /\b(prerequisite|fixture missing|no test data|account (?:missing|not provisioned)|required entity)\b/i.test(text);
+    }
+    function looksLikeFlake(text) {
+      return /\b(stale element|animation|transition|intermittent|flaky|race condition)\b/i.test(text) || /\b(element (?:is )?not interactable|obscured|covered by)\b/i.test(text);
+    }
+    function looksLikeLocatorMiss(text) {
+      return /not found|no such element|No identity locator|unable to locate/i.test(text);
+    }
+    function looksLikeOracleFailure(text) {
+      return /assertStateDelta/i.test(text) || /expected state/i.test(text) || /expected (?:["'].+["'] )?(?:to be |text|visible|removed|count)/i.test(text) || /assertion failed|Assert .+ (?:visible|shows|contains)/i.test(text);
+    }
+    function triageMobileFailure(input) {
+      const failureCount = Math.max(1, input.failureCount ?? 1);
+      const tags = input.tags ?? [];
+      const text = errorText(input.error, input.logs);
+      const prefix = leadingPrefix(input.error);
+      const strongKinds = listStrongOracleKinds(input.steps);
+      const hasStrong = strongKinds.length > 0 || tags.some((t) => t === "@strong-oracle" || t === "strong-oracle");
+      const evidence = {
+        hasStrongOracle: hasStrong,
+        strongOracleKinds: strongKinds,
+        failureCount,
+        errorPrefix: prefix
+      };
+      if (prefix === "CONFIG_ISSUE" || prefix === "RATE_LIMIT_BLOCKED") {
+        return {
+          verdict: "config_issue",
+          reason: `Environment/config prefix on error (${prefix})`,
+          shouldHeal: false,
+          healVerdict: "config_issue",
+          evidence
+        };
+      }
+      if (prefix === "APP_BUG") {
+        return {
+          verdict: "app_bug_candidate",
+          reason: "Error already classified APP_BUG",
+          shouldHeal: false,
+          healVerdict: "app_bug",
+          evidence
+        };
+      }
+      if (prefix === "PREREQ_UNMET") {
+        return {
+          verdict: "prereq_unmet",
+          reason: "Error already classified PREREQ_UNMET",
+          shouldHeal: false,
+          healVerdict: "prereq_unmet",
+          evidence
+        };
+      }
+      if (looksLikeConfig(text)) {
+        return {
+          verdict: "config_issue",
+          reason: "Failure matches environment/config/device patterns",
+          shouldHeal: false,
+          healVerdict: "config_issue",
+          evidence
+        };
+      }
+      if (looksLikePrereq(text)) {
+        return {
+          verdict: "prereq_unmet",
+          reason: "Failure matches missing prerequisite / fixture patterns",
+          shouldHeal: false,
+          healVerdict: "prereq_unmet",
+          evidence
+        };
+      }
+      if (input.uiSuccessWithFailedWriteApi && hasStrong) {
+        return {
+          verdict: "app_bug_candidate",
+          reason: "UI path completed but a write API failed (network secondary oracle)",
+          shouldHeal: false,
+          healVerdict: "app_bug",
+          evidence
+        };
+      }
+      if (hasStrong && failureCount >= 2 && (looksLikeOracleFailure(text) || !looksLikeLocatorMiss(text))) {
+        if (looksLikeLocatorMiss(text) && failureCount < 3) {
+          return {
+            verdict: "needs_heal",
+            reason: "Strong oracle present but error looks like a locator miss \u2014 attempt heal",
+            shouldHeal: true,
+            evidence
+          };
+        }
+        return {
+          verdict: "app_bug_candidate",
+          reason: `Strong oracle (${strongKinds.join(", ") || "tagged"}) failed ${failureCount}\xD7 with product-shaped error`,
+          shouldHeal: false,
+          healVerdict: "app_bug",
+          evidence
+        };
+      }
+      if (looksLikeFlake(text) && failureCount === 1 && !hasStrong) {
+        return {
+          verdict: "flake_candidate",
+          reason: "Transient interactability / race signals on a weak-oracle test",
+          shouldHeal: true,
+          // still allow heal, but tag flaky path
+          extraTags: ["@flaky"],
+          evidence
+        };
+      }
+      if (tags.includes("@smoke") && !hasStrong && looksLikeLocatorMiss(text)) {
+        return {
+          verdict: "needs_heal",
+          reason: "Smoke/nav locator failure \u2014 heal allowed",
+          shouldHeal: true,
+          evidence
+        };
+      }
+      return {
+        verdict: "needs_heal",
+        reason: hasStrong ? "Strong oracle first failure \u2014 allow heal once before APP_BUG escalation" : "Default: attempt script/live heal",
+        shouldHeal: true,
+        evidence
+      };
+    }
+    function triageToHealTerminal(triage) {
+      if (triage.shouldHeal || !triage.healVerdict)
+        return null;
+      return {
+        verdict: triage.healVerdict,
+        healReason: triage.reason,
+        extraTags: triage.extraTags
+      };
+    }
+  }
+});
+
+// ../runner-core/dist/services/mobile/oracle-protection.js
+var require_oracle_protection = __commonJS({
+  "../runner-core/dist/services/mobile/oracle-protection.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fingerprintOracles = fingerprintOracles;
+    exports.rejectOracleWeakeningPatch = rejectOracleWeakeningPatch;
+    exports.oraclesPreserved = oraclesPreserved;
+    var failure_triage_js_1 = require_failure_triage();
+    var EXPECT_STRENGTH = {
+      entity_removed: 5,
+      removed: 5,
+      count_decreased: 4,
+      "count-1": 4,
+      count_increased: 4,
+      "count+1": 4,
+      persisted: 3,
+      unchanged: 3,
+      changed: 2,
+      any_change: 2
+    };
+    function normalizeText(value) {
+      return (value ?? "").trim().toLowerCase().replace(/\s+/g, " ");
+    }
+    function stateKeyOf(step) {
+      const meta = step.metadata;
+      const key = typeof meta?.stateKey === "string" ? meta.stateKey.trim() : "";
+      return key || normalizeText(step.target?.primary) || normalizeText(step.description) || `order-${step.order}`;
+    }
+    function expectOf(step) {
+      const meta = step.metadata;
+      const fromMeta = typeof meta?.expect === "string" ? meta.expect : "";
+      return normalizeText(fromMeta || step.assertion || step.value || "changed");
+    }
+    function fingerprintOracles(steps) {
+      const assertTexts = [];
+      const stateExpects = {};
+      let stateDeltas = 0;
+      let captures = 0;
+      let strongVisible = 0;
+      for (const step of steps) {
+        if (step.action === "assertStateDelta") {
+          stateDeltas += 1;
+          stateExpects[stateKeyOf(step)] = expectOf(step);
+        } else if (step.action === "captureState")
+          captures += 1;
+        else if (step.action === "assertText") {
+          const t = normalizeText(step.assertion ?? step.value ?? step.description);
+          if (t)
+            assertTexts.push(t);
+        } else if (step.action === "assertVisible" && (0, failure_triage_js_1.isStrongOracleStep)(step)) {
+          strongVisible += 1;
+        }
+      }
+      return {
+        stateDeltas,
+        captures,
+        assertTexts,
+        stateExpects,
+        strongVisible,
+        strongTotal: stateDeltas + captures + assertTexts.length + strongVisible
+      };
+    }
+    function expectStrength(expect) {
+      const e = expect.toLowerCase().trim();
+      if (e.startsWith("removed:"))
+        return 5;
+      return EXPECT_STRENGTH[e] ?? 1;
+    }
+    function rejectOracleWeakeningPatch(original, patched) {
+      if (!Array.isArray(patched) || patched.length === 0) {
+        return "healed steps missing \u2014 refusing empty patch that would drop oracles";
+      }
+      const before = fingerprintOracles(original);
+      const after = fingerprintOracles(patched);
+      if (before.stateDeltas > 0 && after.stateDeltas < before.stateDeltas) {
+        return `heal patch removed assertStateDelta oracle(s) (${before.stateDeltas} \u2192 ${after.stateDeltas}) \u2014 refusing to go green by dropping state proof`;
+      }
+      for (const [key, beforeExpect] of Object.entries(before.stateExpects)) {
+        const afterExpect = after.stateExpects[key];
+        if (!afterExpect) {
+          return `heal patch removed assertStateDelta for key "${key}" (expect was ${beforeExpect})`;
+        }
+        if (expectStrength(afterExpect) < expectStrength(beforeExpect)) {
+          return `heal patch softened assertStateDelta expect for "${key}" (${beforeExpect} \u2192 ${afterExpect})`;
+        }
+      }
+      if (before.captures > 0 && after.captures < before.captures && after.stateDeltas === 0) {
+        return `heal patch removed captureState without keeping assertStateDelta (${before.captures} \u2192 ${after.captures})`;
+      }
+      if (before.assertTexts.length > 0) {
+        const afterSet = new Set(after.assertTexts);
+        const lost = before.assertTexts.filter((t) => !afterSet.has(t));
+        if (after.assertTexts.length < before.assertTexts.length) {
+          return `heal patch dropped assertText outcome proof (${before.assertTexts.length} \u2192 ${after.assertTexts.length})`;
+        }
+        if (lost.length > 0) {
+          const softKept = lost.every((t) => after.assertTexts.some((a) => a.includes(t) || t.includes(a)));
+          if (!softKept) {
+            return `heal patch replaced assertText expectations (${lost.slice(0, 2).join("; ")}) \u2014 outcome must stay`;
+          }
+        }
+      }
+      if (before.strongVisible > 0 && after.strongVisible + after.assertTexts.length + after.stateDeltas < before.strongVisible) {
+        return `heal patch weakened strong assertVisible validation oracles (${before.strongVisible} \u2192 ${after.strongVisible})`;
+      }
+      if (before.strongTotal > 0 && after.strongTotal === 0) {
+        return "heal patch removed all strong oracles \u2014 refusing visibility-only green path";
+      }
+      for (const orig of original) {
+        if (orig.action !== "assertStateDelta" && orig.action !== "assertText")
+          continue;
+        const key = normalizeText(orig.description ?? orig.assertion ?? "");
+        if (!key)
+          continue;
+        const stillStrong = patched.some((p) => (p.action === "assertStateDelta" || p.action === "assertText") && normalizeText(p.description ?? p.assertion ?? "") === key);
+        if (stillStrong)
+          continue;
+        const onlyVisible = patched.some((p) => p.action === "assertVisible" && normalizeText(p.description ?? p.assertion ?? "") === key);
+        if (onlyVisible) {
+          return `heal patch downgraded strong oracle "${key.slice(0, 60)}" to assertVisible`;
+        }
+      }
+      return null;
+    }
+    function oraclesPreserved(original, patched) {
+      return rejectOracleWeakeningPatch(original, patched) === null;
+    }
+  }
+});
+
 // ../runner-core/dist/services/mobile/mobile-heal-postprocess.js
 var require_mobile_heal_postprocess = __commonJS({
   "../runner-core/dist/services/mobile/mobile-heal-postprocess.js"(exports) {
@@ -84843,6 +85816,7 @@ var require_mobile_heal_postprocess = __commonJS({
     exports.redactMobileSecretsFromText = redactMobileSecretsFromText;
     exports.detectMobileStepSecretLeak = detectMobileStepSecretLeak;
     exports.computeMobileHealOutcome = computeMobileHealOutcome2;
+    var oracle_protection_js_1 = require_oracle_protection();
     var REDACT_KEY_RE = /email|username|user|phone|password|secret|token|api[_-]?key|access[_-]?key|\bpass\b|credential|bearer|\bpat\b|session|cookie|jwt|otp|pin/i;
     var DETECT_KEY_RE = /password|secret|token|api[_]?key|\bpass\b|credential|bearer|\bpat\b/i;
     var MIN_REDACT_LEN = 4;
@@ -84908,18 +85882,27 @@ var require_mobile_heal_postprocess = __commonJS({
     function computeMobileHealOutcome2(args) {
       const { heal } = args;
       const hasFix = Array.isArray(heal.healedSteps) && heal.healedSteps.length > 0;
-      const isVerifiedFix = heal.passed === true && heal.verdict === "fix" && hasFix;
+      let isVerifiedFix = heal.passed === true && heal.verdict === "fix" && hasFix;
       const secretLeak = isVerifiedFix ? detectMobileStepSecretLeak(heal.healedSteps, args.testVariables) : null;
+      const oracleWeakening = isVerifiedFix && args.originalSteps ? (0, oracle_protection_js_1.rejectOracleWeakeningPatch)(args.originalSteps, heal.healedSteps ?? []) : null;
+      if (oracleWeakening)
+        isVerifiedFix = false;
       const isConfigIssue = heal.verdict === "config_issue";
-      const isAppBug = heal.verdict === "app_bug";
+      const isAppBug = heal.verdict === "app_bug" || Boolean(oracleWeakening && heal.passed);
       const extraTags = new Set((heal.extraTags ?? []).filter((t) => typeof t === "string" && t.length > 0));
       if (secretLeak)
         extraTags.add("@needs-review");
+      if (oracleWeakening) {
+        extraTags.add("@needs-review");
+        extraTags.add("@bug-found");
+      }
       if (!heal.passed && NEEDS_REVIEW_VERDICTS.has(heal.verdict))
         extraTags.add("@needs-review");
       let status;
       if (secretLeak)
         status = "FAILED";
+      else if (oracleWeakening)
+        status = "FAILED";
       else if (isVerifiedFix)
         status = "PASSED";
       else if (isConfigIssue)
@@ -84931,6 +85914,8 @@ var require_mobile_heal_postprocess = __commonJS({
         error2 = void 0;
       } else if (secretLeak) {
         error2 = `HEAL_SECRET_LEAK: healed steps contained a literal secret (${secretLeak}); patch dropped, tagged @needs-review`;
+      } else if (oracleWeakening) {
+        error2 = `APP_BUG: heal attempted to drop strong oracle (${oracleWeakening}); patch refused`;
       } else if (isConfigIssue) {
         error2 = `CONFIG_ISSUE: ${heal.healReason ?? args.finalError ?? args.reproduceError ?? "environment/rate-limit blocker"}`;
       } else if (isAppBug) {
@@ -84947,13 +85932,64 @@ var require_mobile_heal_postprocess = __commonJS({
         error: error2,
         extraTags: extraTags.size > 0 ? [...extraTags] : void 0,
         removeTags: heal.removeTags,
-        shouldPatch: isVerifiedFix && !secretLeak,
+        shouldPatch: isVerifiedFix && !secretLeak && !oracleWeakening,
         secretLeak
       };
     }
   }
 });
 
+// ../runner-core/dist/services/mobile/network-oracle.js
+var require_network_oracle = __commonJS({
+  "../runner-core/dist/services/mobile/network-oracle.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.evaluateNetworkSecondaryOracle = evaluateNetworkSecondaryOracle;
+    exports.uiSuccessWithFailedWriteApi = uiSuccessWithFailedWriteApi;
+    var WRITE_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
+    function isWrite(method) {
+      return WRITE_METHODS.has(method.toUpperCase());
+    }
+    function isServerOrClientError(status) {
+      return status >= 400 && status < 600;
+    }
+    function isNoiseUrl(url) {
+      return /\b(analytics|telemetry|sentry|bugsnag|crashlytics|facebook\.com\/tr|google-analytics|doubleclick|hotjar|segment\.io|amplitude|mixpanel)\b/i.test(url);
+    }
+    function evaluateNetworkSecondaryOracle(input) {
+      const calls = input.apiCalls;
+      if (!calls || calls.length === 0)
+        return null;
+      if (input.uiPathSucceeded === false)
+        return null;
+      for (const call of calls) {
+        const method = String(call.method ?? "GET");
+        const url = String(call.url ?? "");
+        const status = typeof call.status === "number" ? call.status : 0;
+        if (!isWrite(method))
+          continue;
+        if (!isServerOrClientError(status))
+          continue;
+        if (!url || isNoiseUrl(url))
+          continue;
+        if (status === 401 || status === 403)
+          continue;
+        return {
+          kind: "write_api_failed",
+          method: method.toUpperCase(),
+          url: url.slice(0, 200),
+          status,
+          reason: `Write API ${method.toUpperCase()} ${url.slice(0, 120)} returned ${status} while UI path appeared successful`
+        };
+      }
+      return null;
+    }
+    function uiSuccessWithFailedWriteApi(input) {
+      return evaluateNetworkSecondaryOracle(input) !== null;
+    }
+  }
+});
+
 // ../runner-core/dist/services/selector-registry-context.js
 var require_selector_registry_context = __commonJS({
   "../runner-core/dist/services/selector-registry-context.js"(exports) {
@@ -85321,6 +86357,9 @@ var require_mobile_heal_loop = __commonJS({
     var ai_retry_js_1 = require_ai_retry();
     var mobile_source_parser_js_1 = require_mobile_source_parser();
     var mobile_heal_postprocess_js_1 = require_mobile_heal_postprocess();
+    var failure_triage_js_1 = require_failure_triage();
+    var oracle_protection_js_1 = require_oracle_protection();
+    var network_oracle_js_1 = require_network_oracle();
     var mobile_observation_js_1 = require_mobile_observation();
     var selector_registry_context_js_1 = require_selector_registry_context();
     var mobile_session_keepalive_js_1 = require_mobile_session_keepalive();
@@ -85343,7 +86382,12 @@ Reason over steps + error + tree + registry and return working healed steps. Do
 {"verdict":"state_stale","reason":"leftover data blocks a baseline assertion"}
 {"verdict":"test_invalid","reason":"scenario cannot be made to pass"}
 {"verdict":"unhealable_dynamic","reason":"asserted value is inherently volatile (timestamps, counters, feeds) \u2014 no durable locator can exist; needs human review"}
-For a fix, return the COMPLETE steps array (not a diff).`;
+For a fix, return the COMPLETE steps array (not a diff).
+## Strong oracle protection (non-negotiable)
+- NEVER remove or downgrade assertStateDelta, captureState, or assertText outcome proof to go green.
+- NEVER replace a durable outcome assert with mere assertVisible of a tab/header.
+- You MAY fix locators, waits, and navigation around those oracles.
+- If the app truly violates the oracle, return verdict "app_bug" instead of stripping the assert.`;
     var DEFAULT_SCRIPT_MAX_ATTEMPTS = 6;
     var RECOVERABLE_MAX = 3;
     var MAX_CONSECUTIVE_INVALID_VERDICTS = 3;
@@ -85373,7 +86417,9 @@ For a fix, return the COMPLETE steps array (not a diff).`;
       "home",
       "waitForElement",
       "assertVisible",
-      "assertText"
+      "assertText",
+      "captureState",
+      "assertStateDelta"
     ]);
     var MAX_HEALED_STEPS = 300;
     var TERMINAL_VERDICTS = /* @__PURE__ */ new Set([
@@ -85400,6 +86446,28 @@ For a fix, return the COMPLETE steps array (not a diff).`;
     function isMobileHealVerdict(value) {
       return MOBILE_HEAL_VERDICTS.includes(value);
     }
+    function normalizeMobileHealVerdict(raw) {
+      const v = raw.trim().toLowerCase().replace(/[\s-]+/g, "_");
+      if (isMobileHealVerdict(v))
+        return v;
+      if (v === "appbug" || v === "application_bug" || v === "bug_found")
+        return "app_bug";
+      if (v === "config" || v === "configuration_issue" || v === "env" || v === "environment")
+        return "config_issue";
+      if (v === "prereq" || v === "prerequisite" || v === "prereq_missing")
+        return "prereq_unmet";
+      if (v === "stale" || v === "stale_state")
+        return "state_stale";
+      if (v === "invalid_test" || v === "bad_test")
+        return "test_invalid";
+      if (v === "unhealable" || v === "dynamic")
+        return "unhealable_dynamic";
+      if (v === "need_device" || v === "needs_appium" || v === "needs_live")
+        return "needs_device";
+      if (v === "healed" || v === "ok" || v === "pass" || v === "passed")
+        return "fix";
+      return null;
+    }
     function isLocatorNotFound(error2) {
       return /not found|no such element/i.test(error2 ?? "");
     }
@@ -85681,15 +86749,43 @@ For a fix, return the COMPLETE steps array (not a diff).`;
         const sub = extractBracesSubstring(cleaned);
         obj = sub ? safeJsonParse(sub) : void 0;
       }
-      if (!isRecord(obj))
+      if (!isRecord(obj)) {
+        const line = cleaned.match(/\bverdict\s*[:=]\s*["']?([a-zA-Z_ -]+)["']?/i);
+        if (line) {
+          const verdict2 = normalizeMobileHealVerdict(line[1]);
+          if (verdict2) {
+            return {
+              verdict: verdict2,
+              reason: cleaned.slice(0, 2e3)
+            };
+          }
+        }
+        const prefix = cleaned.match(/^\s*(APP_BUG|CONFIG_ISSUE|PREREQ_UNMET|TEST_INVALID|STATE_STALE)\s*:\s*(.*)$/im);
+        if (prefix) {
+          const map2 = {
+            APP_BUG: "app_bug",
+            CONFIG_ISSUE: "config_issue",
+            PREREQ_UNMET: "prereq_unmet",
+            TEST_INVALID: "test_invalid",
+            STATE_STALE: "state_stale"
+          };
+          const verdict2 = map2[prefix[1].toUpperCase()];
+          if (verdict2) {
+            return { verdict: verdict2, reason: (prefix[2] || cleaned).slice(0, 2e3) };
+          }
+        }
+        return null;
+      }
+      const rawVerdict = obj.verdict ?? obj.Verdict ?? obj.status;
+      if (typeof rawVerdict !== "string")
         return null;
-      const rawVerdict = obj.verdict;
-      if (typeof rawVerdict !== "string" || !isMobileHealVerdict(rawVerdict))
+      const verdict = normalizeMobileHealVerdict(rawVerdict);
+      if (!verdict)
         return null;
       return {
-        verdict: rawVerdict,
+        verdict,
         steps: coerceSteps(obj.steps),
-        reason: typeof obj.reason === "string" ? obj.reason : void 0,
+        reason: typeof obj.reason === "string" ? obj.reason : typeof obj.rationale === "string" ? obj.rationale : typeof obj.message === "string" ? obj.message : void 0,
         confidence: typeof obj.confidence === "number" ? obj.confidence : void 0
       };
     }
@@ -86038,7 +87134,7 @@ ${args.directive}`);
             };
           }
           markRecoverableTurn();
-          pendingDirective = "Your last response was not valid JSON matching the verdict schema. Return exactly one JSON verdict object \u2014 no prose, no markdown fences.";
+          pendingDirective = 'SCHEMA REPAIR: Your last response was not a valid heal verdict. Reply with ONLY one JSON object (no markdown fences, no prose) of the form:\n{"verdict":"<one of: fix|app_bug|config_issue|needs_device|prereq_unmet|state_stale|test_invalid|unhealable_dynamic>","reason":"<short string>","steps":[/* optional MobileTestStep[] when verdict is fix */],"confidence":0.0}\nUse lowercase snake_case for verdict. Do not invent other verdict values.';
           continue;
         }
         consecutiveInvalidVerdicts = 0;
@@ -86067,6 +87163,13 @@ ${args.directive}`);
           pendingDirective = 'You returned verdict "fix" but no usable steps array. Return the COMPLETE healed MobileTestStep array.';
           continue;
         }
+        const oracleRejection = (0, oracle_protection_js_1.rejectOracleWeakeningPatch)(steps, healedSteps);
+        if (oracleRejection) {
+          markRecoverableTurn();
+          lastVerdict = "fix";
+          pendingDirective = `ORACLE PROTECTION: ${oracleRejection}. Keep all assertStateDelta/assertText/captureState outcome proof; fix locators/navigation only. If the app violates the oracle, return verdict "app_bug".`;
+          continue;
+        }
         if (activeFailingSource && isLocatorNotFound(activeError) && !isDrift(activeError)) {
           const failingSourceSnapshot = activeFailingSource;
           const missing = timedSync("device-op", `phase1-attempt-${attempt}-static-verify`, options.onProgress, () => {
@@ -86210,6 +87313,28 @@ ${args.directive}`);
       if (invalidAuthSetup) {
         return { passed: false, verdict: "test_invalid", healReason: invalidAuthSetup };
       }
+      const networkBug = (0, network_oracle_js_1.uiSuccessWithFailedWriteApi)({
+        apiCalls: ctx.apiCalls,
+        uiPathSucceeded: ctx.uiPathSucceeded
+      });
+      const triage = (0, failure_triage_js_1.triageMobileFailure)({
+        steps,
+        error: ctx.error,
+        logs: ctx.logs,
+        tags: ctx.tags,
+        failureCount: ctx.failureCount,
+        uiSuccessWithFailedWriteApi: networkBug
+      });
+      options.onProgress?.(`Pre-heal triage: ${triage.verdict} \u2014 ${triage.reason}`);
+      const terminal = (0, failure_triage_js_1.triageToHealTerminal)(triage);
+      if (terminal) {
+        return {
+          passed: false,
+          verdict: terminal.verdict,
+          healReason: terminal.healReason,
+          extraTags: terminal.extraTags
+        };
+      }
       const preflight = await tryRegistryPreflight(steps, target, ctx, options);
       if (preflight)
         return preflight;
@@ -86459,6 +87584,11 @@ For a fix, return the COMPLETE steps array (not a diff). Use "observe" only to r
         if (parsed.verdict !== "fix" || !parsed.steps)
           continue;
         const healedSteps = parsed.steps;
+        const liveOracleRejection = (0, oracle_protection_js_1.rejectOracleWeakeningPatch)(args.steps, healedSteps);
+        if (liveOracleRejection) {
+          options.onProgress?.(`ORACLE PROTECTION (live): ${liveOracleRejection}`);
+          continue;
+        }
         let verify;
         try {
           verify = await timed("reexec", `phase2-pass-${pass}-verify`, options.onProgress, () => runNativeTest({ steps: healedSteps, target, testVariables }));
@@ -87749,6 +88879,7 @@ var require_auth_recipe = __commonJS({
     var START_MARKER = `// >>> VALIDATE_QA_AUTH ${exports.AUTH_MARKER_VERSION} \u2014 generated, do not edit >>>`;
     var END_MARKER = `// <<< VALIDATE_QA_AUTH ${exports.AUTH_MARKER_VERSION} <<<`;
     var SHARED_AUTH_RUNTIME_ENABLED = `!/^false$/i.test((process.env.SHARED_AUTH_INJECT ?? '').trim())`;
+    var WARM_PROOF_SETTLE_MS = 8e3;
     var AUTH_REGION_RE = /\/\/ >>> VALIDATE_QA_AUTH[^\n]*\r?\n[\s\S]*?\/\/ <<< VALIDATE_QA_AUTH[^\n]*\r?\n?/g;
     function computeRecipeHash(input) {
       const canonical = JSON.stringify({
@@ -87884,12 +89015,20 @@ ${tabs}`);
           const pred = urlProofPredicateExpr(recipe.authProof.route, recipe.authProof.exact);
           lines.push(`    await page.waitForURL((u) => !(${pred})(u), { timeout: 2000 }).catch(() => {});`);
           lines.push(`    if ((${pred})(new URL(page.url())) && !(await page.locator('input[type="password"]').first().isVisible().catch(() => false))) return;`);
-        } else if (loginRoute) {
-          lines.push(`    if (await ${authProofLocator(recipe.authProof)}.isVisible().catch(() => false) && new URL(page.url()).pathname !== new URL(${JSON.stringify(loginRoute)}, page.url()).pathname) return;`);
         } else {
-          lines.push(`    if (await ${authProofLocator(recipe.authProof)}.isVisible().catch(() => false)) return;`);
+          const proofSettle = `await ${authProofLocator(recipe.authProof)}.waitFor({ state: 'visible', timeout: ${WARM_PROOF_SETTLE_MS} }).then(() => true).catch(() => false)`;
+          if (loginRoute) {
+            lines.push(`    if (new URL(page.url()).pathname !== new URL(${JSON.stringify(loginRoute)}, page.url()).pathname && ${proofSettle}) return;`);
+          } else {
+            lines.push(`    if (${proofSettle}) return;`);
+          }
         }
         lines.push(`  }`);
+        lines.push(`  if (${SHARED_AUTH_RUNTIME_ENABLED}) {`);
+        lines.push(`    await page.context().clearCookies().catch(() => {});`);
+        lines.push(`    await page.goto(${JSON.stringify(recipe.preNavRoute)}, { waitUntil: 'domcontentloaded' }).catch(() => {});`);
+        lines.push(`    await page.evaluate(() => { try { localStorage.clear(); sessionStorage.clear(); } catch {} }).catch(() => {});`);
+        lines.push(`  }`);
       }
       lines.push(`  await page.goto(${JSON.stringify(recipe.preNavRoute)}, { waitUntil: 'domcontentloaded' });`);
       for (const cmd of recipe.preNavCmds)
@@ -95842,6 +96981,32 @@ var require_agentic_discovery_prompts = __commonJS({
       lines.push("For a pure navigation or page-load scenario (no in-page mutation), URL + one");
       lines.push("structural heading is sufficient.");
       lines.push("");
+      lines.push("**Stop at the gate for expensive or irreversible actions.** Some controls");
+      lines.push("start work that costs the account real money (an AI generation, a paid");
+      lines.push("third-party call, a checkout), takes minutes to finish, or cannot be undone");
+      lines.push("(delete, publish, cancel a subscription). Do NOT press them. The regression");
+      lines.push("risk lives in the wiring, and the wiring is fully provable for free:");
+      lines.push("- Assert the control is present and correctly ENABLED/DISABLED by its inputs.");
+      lines.push("- If it opens a dialog, assert the dialog, its fields and its confirm button,");
+      lines.push("  then press Cancel and assert nothing changed.");
+      lines.push("- Assert the auth / quota wall fires for a caller who should be refused.");
+      lines.push("A test that waits minutes for generated output cannot finish inside the run");
+      lines.push("budget, bills the account on every run, and leaves permanent rows behind. If");
+      lines.push("the ONLY way to prove a scenario is to trigger such an action, drop it as a");
+      lines.push("gap rather than emitting a test that does.");
+      lines.push("");
+      lines.push("**Never sign up a new account.** Use the injected credentials. Registering a");
+      lines.push("`testuser-<timestamp>` account to get past a login wall leaves a permanent,");
+      lines.push("unowned user in the target database on every single run. Registration is in");
+      lines.push("scope ONLY when the scenario under test IS registration, in which case use");
+      lines.push("the provided inbox helper so the account is tracked and reaped.");
+      lines.push("");
+      lines.push("**Write the assertion so the BUG fails it.** When a scenario documents broken");
+      lines.push("behaviour, still assert the CORRECT outcome. A test that passes because the");
+      lines.push("error message / console error / not-found page is present inverts the suite:");
+      lines.push("fixing the bug turns the test red and the fix is reported as a regression.");
+      lines.push("State the intended behaviour, let it fail, and flag it as a bug.");
+      lines.push("");
       lines.push("## Tools");
       lines.push("");
       lines.push("Browser MCP: `browser_navigate`, `browser_snapshot`, `browser_click`,");
@@ -96651,7 +97816,7 @@ var require_discover_generator = __commonJS({
   "../runner-core/dist/services/discover-generator.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.MIN_BUG_DESCRIPTION_LENGTH = exports.VALID_PLAYWRIGHT_GETBY_METHODS = exports.BLOCKED_MCP_TOOLS_SCENARIO_GEN = void 0;
+    exports.MIN_BUG_DESCRIPTION_LENGTH = exports.NAME_PROHIBITED_ROLES = exports.VALID_PLAYWRIGHT_GETBY_METHODS = exports.BLOCKED_MCP_TOOLS_SCENARIO_GEN = void 0;
     exports.scenarioLooksLikeRegistration = scenarioLooksLikeRegistration;
     exports.signupFeatureTestingAllowed = signupFeatureTestingAllowed;
     exports.scenarioTouchesSignupAuthSurface = scenarioTouchesSignupAuthSurface;
@@ -96681,6 +97846,7 @@ var require_discover_generator = __commonJS({
     exports.scanFragileStructuralLocators = scanFragileStructuralLocators;
     exports.bannedRoleTokensInSelector = bannedRoleTokensInSelector;
     exports.scanInvalidRoleTagLocators = scanInvalidRoleTagLocators;
+    exports.scanNameProhibitedRoleLocators = scanNameProhibitedRoleLocators;
     exports.scanHealedRoleTagLocators = scanHealedRoleTagLocators;
     exports.validateFinalActionFidelity = validateFinalActionFidelity;
     exports.resolveSuspectedBugVerdict = resolveSuspectedBugVerdict;
@@ -99748,10 +100914,55 @@ ${testOpen}`;
       }
       return findings;
     }
+    exports.NAME_PROHIBITED_ROLES = /* @__PURE__ */ new Set([
+      "caption",
+      "code",
+      "deletion",
+      "emphasis",
+      "generic",
+      "insertion",
+      "mark",
+      "none",
+      "paragraph",
+      "presentation",
+      "strong",
+      "subscript",
+      "superscript",
+      "term",
+      "time"
+    ]);
+    function scanNameProhibitedRoleLocators(code) {
+      const findings = [];
+      const seen = /* @__PURE__ */ new Set();
+      const scanCode = code.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "));
+      const RE = /getByRole\(\s*(['"`])([a-zA-Z]+)\1\s*,\s*\{[^}]*\bname\s*:/g;
+      for (const rawLine of scanCode.split("\n")) {
+        const line = rawLine.replace(/\/\/.*$/, "");
+        if (line.indexOf("getByRole(") === -1)
+          continue;
+        RE.lastIndex = 0;
+        let m;
+        while ((m = RE.exec(line)) !== null) {
+          const role = m[2].toLowerCase();
+          if (!exports.NAME_PROHIBITED_ROLES.has(role))
+            continue;
+          const key = `${rawLine.trim()} ${role}`;
+          if (seen.has(key))
+            continue;
+          seen.add(key);
+          findings.push({
+            line: rawLine.trim().slice(0, 200),
+            role,
+            reason: `ARIA prohibits an accessible name on role "${role}", so no element ever exposes one \u2014 getByRole('${role}', { name: \u2026 }) matches ZERO nodes and the assertion hangs to its timeout. Match the text instead: page.getByText('\u2026', { exact: true }), optionally scoped (e.g. page.getByRole('main').getByText('\u2026')). If you need the element itself, select a nameable ancestor (region/listitem/link/button) and assert its text.`
+          });
+        }
+      }
+      return findings;
+    }
     function scanHealedRoleTagLocators(code, opts) {
       const inboxStripped = (0, inbox_stamp_js_1.stripInboxRegions)(code);
       const scanned = opts?.stripAuth === false ? inboxStripped : (0, auth_recipe_js_1.stripAuthRegions)(inboxStripped);
-      return scanInvalidRoleTagLocators(scanned);
+      return [...scanInvalidRoleTagLocators(scanned), ...scanNameProhibitedRoleLocators(scanned)];
     }
     function validateFinalActionFidelity(playwrightCode, actionLedger, credentials, opts) {
       const ledgerSigs = [];
@@ -100472,7 +101683,7 @@ Do NOT add steps you did not execute. Do NOT skip steps from the recording.${led
                   continue;
                 }
                 const roleTagMode = (0, discovery_lint_flags_js_1.roleTagLocatorLintMode)();
-                const roleTagFindings = roleTagMode !== "off" ? scanInvalidRoleTagLocators((0, auth_recipe_js_1.stripAuthRegions)((0, inbox_stamp_js_1.stripInboxRegions)(validated[0].playwrightCode))) : [];
+                const roleTagFindings = roleTagMode !== "off" ? scanHealedRoleTagLocators(validated[0].playwrightCode) : [];
                 if (roleTagMode === "warn" && roleTagFindings.length > 0) {
                   logs2.push(`    Role-tag locator gate [warn]: ${roleTagFindings.length} role-as-CSS-tag locator(s) \u2014 ${roleTagFindings.map((f) => sanitizeLedgerText(f.line)).join(" | ").slice(0, 300)}`);
                 }
@@ -100485,12 +101696,10 @@ Do NOT add steps you did not execute. Do NOT skip steps from the recording.${led
                     valid: false,
                     revisionRequired: true,
                     reason: "invalid_role_tag_locator",
-                    instruction: targeted ? `One or more locators below use an ARIA ROLE as a CSS tag selector, e.g. page.locator('textbox[name^="code"]'). There is no <textbox>/<checkbox>/<heading> HTML element, so page.locator() matches ZERO nodes and the action hangs until the test times out.
-For EACH flagged locator, rewrite it as a real Playwright locator:
-1. Prefer page.getByRole('<role>', { name: '<accessible name>' }) \u2014 the role is the token you wrongly put in the CSS.
-2. Or page.getByLabel('<label>'), or a type-scoped CSS like page.locator('input[type="text"]') / input[type="email"].
-3. For a verification-code field, prefer the injected helper: await __vqaEnterVerificationCode(page, code).
-Keep every other line exactly as-is. Submit the COMPLETE corrected test and call finish_generate again.` : `Your resubmission STILL contains a locator that uses an ARIA role as a CSS tag selector (page.locator('<role>[\u2026]')). This can only ever match nothing. Replace EVERY such locator with page.getByRole('<role>', { name: '\u2026' }) / getByLabel / input[type="\u2026"], or use await __vqaEnterVerificationCode(page, code) for the code field, and resubmit the COMPLETE test.`,
+                    instruction: targeted ? `Every locator listed below matches ZERO nodes, so the step hangs until the test times out. Read the \`reason\` on each one \u2014 there are two distinct mistakes:
+(a) An ARIA ROLE used as a CSS tag selector, e.g. page.locator('textbox[name^="code"]'). There is no <textbox>/<checkbox>/<heading> element. Rewrite as page.getByRole('<role>', { name: '<accessible name>' }), or page.getByLabel('<label>'), or a type-scoped CSS like page.locator('input[type="email"]'). For a verification-code field prefer the injected helper: await __vqaEnterVerificationCode(page, code).
+(b) A { name: \u2026 } filter on a role whose accessible name ARIA PROHIBITS (paragraph, generic, code, emphasis, strong, term, time, mark, caption, presentation/none, insertion, deletion, sub/superscript). No element with those roles ever exposes a name. Match the text instead: page.getByText('\u2026', { exact: true }), scoped if needed (page.getByRole('main').getByText('\u2026')), or target a nameable ancestor such as region/listitem/link/button.
+Fix EVERY flagged locator, keep every other line exactly as-is, then submit the COMPLETE corrected test and call finish_generate again.` : `Your resubmission STILL contains a locator that can only ever match nothing \u2014 either an ARIA role used as a CSS tag selector (page.locator('<role>[\u2026]')) or a { name: \u2026 } filter on a name-prohibited role (paragraph/generic/code/emphasis/strong/term/time/\u2026). Replace EVERY one: use getByRole('<role>', { name: '\u2026' }) / getByLabel / input[type="\u2026"] for the first, and getByText('\u2026', { exact: true }) for the second. Resubmit the COMPLETE test.`,
                     offendingLocators: roleTagFindings.map((f) => ({
                       line: sanitizeLedgerText(f.line),
                       reason: f.reason
@@ -101536,6 +102745,2285 @@ 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"(exports) {
+    "use strict";
+    var intToCharMap = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+    exports.encode = function(number) {
+      if (0 <= number && number < intToCharMap.length) {
+        return intToCharMap[number];
+      }
+      throw new TypeError("Must be between 0 and 63: " + number);
+    };
+    exports.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"(exports) {
+    "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;
+    }
+    exports.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;
+    };
+    exports.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"(exports) {
+    "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.');
+      }
+    }
+    exports.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]
+      };
+    }
+    exports.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;
+    }
+    exports.urlGenerate = urlGenerate;
+    function normalize(aPath) {
+      var path = aPath;
+      var url = urlParse(aPath);
+      if (url) {
+        if (!url.path) {
+          return aPath;
+        }
+        path = url.path;
+      }
+      var isAbsolute2 = exports.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;
+    }
+    exports.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;
+    }
+    exports.join = join8;
+    exports.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);
+    }
+    exports.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;
+    }
+    exports.toSetString = supportsNullProto ? identity : toSetString;
+    function fromSetString(aStr) {
+      if (isProtoString(aStr)) {
+        return aStr.slice(1);
+      }
+      return aStr;
+    }
+    exports.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);
+    }
+    exports.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);
+    }
+    exports.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);
+    }
+    exports.compareByGeneratedPositionsInflated = compareByGeneratedPositionsInflated;
+    function parseSourceMapInput(str) {
+      return JSON.parse(str.replace(/^\)]}'[^\n]*\n/, ""));
+    }
+    exports.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);
+    }
+    exports.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"(exports) {
+    "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();
+    };
+    exports.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"(exports) {
+    "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;
+    };
+    exports.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"(exports) {
+    "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());
+    };
+    exports.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"(exports) {
+    "use strict";
+    exports.GREATEST_LOWER_BOUND = 1;
+    exports.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 == exports.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 == exports.LEAST_UPPER_BOUND) {
+          return mid;
+        } else {
+          return aLow < 0 ? -1 : aLow;
+        }
+      }
+    }
+    exports.search = function search(aNeedle, aHaystack, aCompare, aBias) {
+      if (aHaystack.length === 0) {
+        return -1;
+      }
+      var index = recursiveSearch(
+        -1,
+        aHaystack.length,
+        aNeedle,
+        aHaystack,
+        aCompare,
+        aBias || exports.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"(exports) {
+    "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);
+      }
+    }
+    exports.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"(exports) {
+    "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;
+    };
+    exports.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
+      };
+    };
+    exports.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);
+    };
+    exports.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"(exports) {
+    "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 };
+    };
+    exports.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"(exports) {
+    "use strict";
+    exports.SourceMapGenerator = require_source_map_generator().SourceMapGenerator;
+    exports.SourceMapConsumer = require_source_map_consumer().SourceMapConsumer;
+    exports.SourceNode = require_source_node().SourceNode;
+  }
+});
+
+// ../../node_modules/buffer-from/index.js
+var require_buffer_from = __commonJS({
+  "../../node_modules/buffer-from/index.js"(exports, module) {
+    "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);
+    }
+    module.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"(exports, module) {
+    "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);
+    exports.wrapCallSite = wrapCallSite;
+    exports.getErrorSource = getErrorSource;
+    exports.mapSourcePosition = mapSourcePosition;
+    exports.retrieveSourceMap = retrieveSourceMap;
+    exports.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(module, "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(module, "worker_threads");
+          if (worker_threads.isMainThread === false) {
+            installHandler = false;
+          }
+        } catch (e) {
+        }
+        if (installHandler && hasGlobalProcessEventEmitter()) {
+          uncaughtShimInstalled = true;
+          shimEmitUncaughtException();
+        }
+      }
+    };
+    exports.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"(exports, module) {
@@ -110192,7 +113680,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 {
               }
             },
@@ -338727,7 +342215,7 @@ var require_decoder = __commonJS({
 });
 
 // ../../node_modules/adm-zip/util/index.js
-var require_util4 = __commonJS({
+var require_util5 = __commonJS({
   "../../node_modules/adm-zip/util/index.js"(exports, module) {
     "use strict";
     module.exports = require_utils2();
@@ -338742,7 +342230,7 @@ var require_util4 = __commonJS({
 var require_entryHeader = __commonJS({
   "../../node_modules/adm-zip/headers/entryHeader.js"(exports, module) {
     "use strict";
-    var Utils = require_util4();
+    var Utils = require_util5();
     var Constants = Utils.Constants;
     module.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;
@@ -339013,7 +342501,7 @@ var require_entryHeader = __commonJS({
 var require_mainHeader = __commonJS({
   "../../node_modules/adm-zip/headers/mainHeader.js"(exports, module) {
     "use strict";
-    var Utils = require_util4();
+    var Utils = require_util5();
     var Constants = Utils.Constants;
     module.exports = function() {
       var _volumeEntries = 0, _totalEntries = 0, _size = 0, _offset = 0, _commentLength = 0;
@@ -339311,7 +342799,7 @@ var require_methods = __commonJS({
 var require_zipEntry = __commonJS({
   "../../node_modules/adm-zip/zipEntry.js"(exports, module) {
     "use strict";
-    var Utils = require_util4();
+    var Utils = require_util5();
     var Headers = require_headers3();
     var Constants = Utils.Constants;
     var Methods = require_methods();
@@ -339645,7 +343133,7 @@ var require_zipFile = __commonJS({
     "use strict";
     var ZipEntry = require_zipEntry();
     var Headers = require_headers3();
-    var Utils = require_util4();
+    var Utils = require_util5();
     module.exports = function(inBuffer, options) {
       var entryList = [], entryTable = {}, _comment = Buffer.alloc(0), mainHeader = new Headers.MainHeader(), loadedEntries = false;
       var password = null;
@@ -339990,7 +343478,7 @@ var require_zipFile = __commonJS({
 var require_adm_zip = __commonJS({
   "../../node_modules/adm-zip/adm-zip.js"(exports, module) {
     "use strict";
-    var Utils = require_util4();
+    var Utils = require_util5();
     var pth = __require("path");
     var ZipEntry = require_zipEntry();
     var ZipFile = require_zipFile();
@@ -351623,7 +355111,7 @@ var require_package4 = __commonJS({
   "package.json"(exports, module) {
     module.exports = {
       name: "@validate.qa/runner",
-      version: "1.0.87",
+      version: "1.0.89",
       description: "validate local test runner - execute Playwright tests on your machine, connected to validate.qa cloud.",
       bin: {
         "validate-runner": "dist/cli.js"
@@ -352484,6 +355972,68 @@ async function waitForUiSettle(sessionPath, opts = {}) {
   }
   return { settled: false, lastFingerprint, frames };
 }
+var SYSTEM_UI_DISMISS_LABELS = [
+  "OK",
+  "Got it",
+  "GOT IT",
+  "Continue",
+  "Close",
+  "Dismiss",
+  "I understand",
+  "Accept",
+  // Android 15+ / 16 KB page-size compatibility dialog primary action.
+  "OK, got it"
+];
+function extractElementId(value) {
+  if (!value || typeof value !== "object") return null;
+  const v = value;
+  const elementId = v.ELEMENT ?? v["element-6066-11e4-a52e-4f735466cecf"] ?? null;
+  if (typeof elementId !== "string" || !ELEMENT_ID_PATTERN.test(elementId)) return null;
+  return elementId;
+}
+async function dismissBlockingSystemUi(sessionPath, platform3, opts = {}) {
+  const maxDismisses = Math.max(1, Math.min(5, opts.maxDismisses ?? 3));
+  const dismissed = [];
+  for (let i = 0; i < maxDismisses; i++) {
+    let tapped = false;
+    for (const label of SYSTEM_UI_DISMISS_LABELS) {
+      try {
+        const strategies = platform3 === "ANDROID" ? [
+          { using: "-android uiautomator", value: `new UiSelector().text("${label.replace(/"/g, '\\"')}")` },
+          { using: "accessibility id", value: label }
+        ] : [
+          { using: "accessibility id", value: label },
+          { using: "-ios predicate string", value: `label == "${label.replace(/"/g, '\\"')}" OR name == "${label.replace(/"/g, '\\"')}"` }
+        ];
+        for (const strategy of strategies) {
+          try {
+            const elResult = await appiumRequest(`${sessionPath}/element`, {
+              method: "POST",
+              body: JSON.stringify(strategy)
+            });
+            const elementId = extractElementId(readValue(elResult));
+            if (!elementId) continue;
+            await appiumRequest(`${sessionPath}/element/${elementId}/click`, {
+              method: "POST",
+              body: "{}"
+            });
+            dismissed.push(label);
+            tapped = true;
+            await waitForUiSettle(sessionPath, { timeoutMs: 1200, pollMs: 200, minStableFrames: 1 });
+            break;
+          } catch (err) {
+            if (isAppiumDriverDeadError(err)) throw err;
+          }
+        }
+        if (tapped) break;
+      } catch (err) {
+        if (isAppiumDriverDeadError(err)) throw err;
+      }
+    }
+    if (!tapped) break;
+  }
+  return { dismissed, ok: dismissed.length > 0 };
+}
 async function waitForColdBootSettle(sessionPath) {
   await waitForUiSettle(sessionPath, {
     timeoutMs: MOBILE_COLD_BOOT_SETTLE_MS,
@@ -355224,6 +358774,107 @@ async function waitForColdBootContent(sessionId, log2, timeoutMs = 2e4) {
   }
   log2(`  Cold-boot wait timed out after ${timeoutMs}ms (last tree had ${lastCount} node(s)) \u2014 proceeding anyway.`);
 }
+async function dismissSystemUiAfterColdBoot(sessionId, platform3, log2) {
+  try {
+    const result = await dismissBlockingSystemUi(`/session/${sessionId}`, platform3);
+    if (result.dismissed.length > 0) {
+      log2(`  Dismissed system UI: ${result.dismissed.join(" \u2192 ")}`);
+    }
+  } catch (err) {
+    log2(`  System UI dismiss skipped (${err instanceof Error ? err.message : String(err)})`);
+  }
+}
+async function captureMobileStateValues(sessionId, kind) {
+  const res = await wdRequest(`/session/${sessionId}/source`);
+  const xml = typeof res?.value === "string" ? res.value : "";
+  if (kind === "badge_count") {
+    const nums = /* @__PURE__ */ new Set();
+    for (const m of xml.matchAll(/\b(\d{1,6})\b/g)) {
+      nums.add(m[1]);
+    }
+    const preferred = /* @__PURE__ */ new Set();
+    for (const m of xml.matchAll(/(?:count|badge|open|unread|item|invoice|result|pending)[^>]{0,80}?\b(\d{1,6})\b/gi)) {
+      preferred.add(m[1]);
+    }
+    for (const m of xml.matchAll(/\b(\d{1,6})\b[^>]{0,80}?(?:count|badge|open|unread|items?)/gi)) {
+      preferred.add(m[1]);
+    }
+    return preferred.size > 0 ? [...preferred] : [...nums].slice(0, 20);
+  }
+  const labels = /* @__PURE__ */ new Set();
+  const attrRe = /(?:text|content-desc|name|label)="([^"]{2,80})"/gi;
+  for (const m of xml.matchAll(attrRe)) {
+    const t = m[1].trim();
+    if (t.length < 2 || t.length > 80) continue;
+    if (/^(true|false|null|OK|Cancel)$/i.test(t)) continue;
+    labels.add(t);
+  }
+  return [...labels].slice(0, 80);
+}
+function assertMobileStateDelta(before, after, expect, key, log2) {
+  const beforeSet = new Set(before);
+  const afterSet = new Set(after);
+  const removed = before.filter((v) => !afterSet.has(v));
+  const added = after.filter((v) => !beforeSet.has(v));
+  log2(`  assertStateDelta key=${key} expect=${expect} removed=${removed.length} added=${added.length}`);
+  const exp = expect.toLowerCase().trim();
+  if (exp === "changed" || exp === "any_change") {
+    if (removed.length === 0 && added.length === 0) {
+      throw new Error(`assertStateDelta(${key}): expected state to change, but capture is identical (${before.length} values)`);
+    }
+    return;
+  }
+  if (exp === "removed" || exp === "entity_removed" || exp.startsWith("removed:")) {
+    const target = exp.startsWith("removed:") ? expect.slice("removed:".length).trim() : "";
+    if (target) {
+      if (!removed.includes(target) && afterSet.has(target)) {
+        throw new Error(`assertStateDelta(${key}): expected "${target}" removed, but it is still present`);
+      }
+      if (!beforeSet.has(target)) {
+        throw new Error(`assertStateDelta(${key}): expected "${target}" to have been in the prior capture`);
+      }
+      if (afterSet.has(target)) {
+        throw new Error(`assertStateDelta(${key}): "${target}" was not removed`);
+      }
+      return;
+    }
+    if (removed.length === 0) {
+      throw new Error(`assertStateDelta(${key}): expected at least one entity removed`);
+    }
+    return;
+  }
+  if (exp === "count_decreased" || exp === "count-1") {
+    const b = before.map(Number).filter((n) => Number.isFinite(n));
+    const a = after.map(Number).filter((n) => Number.isFinite(n));
+    const bMax = b.length ? Math.max(...b) : NaN;
+    const aMax = a.length ? Math.max(...a) : NaN;
+    if (!Number.isFinite(bMax) || !Number.isFinite(aMax) || aMax >= bMax) {
+      throw new Error(`assertStateDelta(${key}): expected count decrease (before max=${bMax}, after max=${aMax})`);
+    }
+    return;
+  }
+  if (exp === "count_increased" || exp === "count+1") {
+    const b = before.map(Number).filter((n) => Number.isFinite(n));
+    const a = after.map(Number).filter((n) => Number.isFinite(n));
+    const bMax = b.length ? Math.max(...b) : NaN;
+    const aMax = a.length ? Math.max(...a) : NaN;
+    if (!Number.isFinite(bMax) || !Number.isFinite(aMax) || aMax <= bMax) {
+      throw new Error(`assertStateDelta(${key}): expected count increase (before max=${bMax}, after max=${aMax})`);
+    }
+    return;
+  }
+  if (exp === "unchanged" || exp === "persisted") {
+    if (removed.length > 0 || added.length > 0) {
+      throw new Error(
+        `assertStateDelta(${key}): expected persistence/unchanged, but removed=[${removed.slice(0, 5).join(", ")}] added=[${added.slice(0, 5).join(", ")}]`
+      );
+    }
+    return;
+  }
+  if (removed.length === 0 && added.length === 0) {
+    throw new Error(`assertStateDelta(${key}): expected change (expect=${expect}), state identical`);
+  }
+}
 async function restoreTargetAppIfExternal(sessionId, target, log2, source, failOnExternal) {
   let boundary = null;
   try {
@@ -356369,6 +360020,7 @@ async function executeMobileTest(options) {
   }
   const stepResults = [];
   const screenshots = [];
+  const stateBag = /* @__PURE__ */ new Map();
   let apiCalls = [];
   let sessionId = null;
   let selectedDevice;
@@ -356579,6 +360231,9 @@ async function executeMobileTest(options) {
     if (clearedAppDataBeforeLaunch) {
       await waitForColdBootContent(sessionId, log2);
     }
+    if (options.target.launchMode !== "RESUME") {
+      await dismissSystemUiAfterColdBoot(sessionId, options.target.platform, log2);
+    }
     if (options.target.launchMode === "DEEP_LINK" && options.target.deeplink) {
       try {
         log2(`Opening deep link: ${options.target.deeplink}`);
@@ -356673,6 +360328,25 @@ async function executeMobileTest(options) {
           case "assertText":
             await executeAssertText(sessionId, step, runPlatform, isCrossPlatform);
             break;
+          case "captureState": {
+            const key = String(step.metadata?.stateKey ?? step.target?.primary ?? `state-${step.order}`);
+            const kind = String(step.metadata?.stateKind ?? "list_ids");
+            const values = await captureMobileStateValues(sessionId, kind);
+            stateBag.set(key, { kind, values, capturedAt: Date.now() });
+            log2(`  captureState key=${key} kind=${kind} n=${values.length}`);
+            break;
+          }
+          case "assertStateDelta": {
+            const key = String(step.metadata?.stateKey ?? step.target?.primary ?? "");
+            const expect = String(step.metadata?.expect ?? step.assertion ?? "changed");
+            const prior = stateBag.get(key);
+            if (!prior) {
+              throw new Error(`assertStateDelta: no prior captureState for key "${key}"`);
+            }
+            const current = await captureMobileStateValues(sessionId, prior.kind);
+            assertMobileStateDelta(prior.values, current, expect, key, log2);
+            break;
+          }
           default: {
             const _exhaustive = step.action;
             status = "failed";
@@ -356851,6 +360525,10 @@ async function createMobileDiscoverySession(target, options) {
       );
     }
   }
+  try {
+    await dismissBlockingSystemUi(`/session/${sessionId}`, target.platform);
+  } catch {
+  }
   let stopped = false;
   return {
     sessionId,
@@ -356988,6 +360666,8 @@ async function driveHarvestStep(sessionId, step, elementId, platform3) {
     case "waitForElement":
     case "assertVisible":
     case "assertText":
+    case "captureState":
+    case "assertStateDelta":
       return true;
   }
 }
@@ -357021,6 +360701,7 @@ async function harvestPlatformLocators(options) {
   try {
     options.onSessionReady?.(session.sessionId, session.deviceId, platform3);
     await freshLaunchTargetApp(session.sessionId, platform3, options.target.appId, log2);
+    await dismissSystemUiAfterColdBoot(session.sessionId, platform3, log2);
     if (options.target.launchMode === "DEEP_LINK" && options.target.deeplink) {
       await openDeepLink(session.sessionId, platform3, options.target.deeplink, options.target.appId);
     }
@@ -357296,7 +360977,9 @@ function decideMobileDeviceGate(input) {
     }
   }
   const isHealForHeldTest = runMode === "heal" && !!testCaseId && healHoldTestCaseIds.has(testCaseId);
-  const reservedForHeals = isHealForHeldTest ? Math.max(0, healHoldTestCaseIds.size - 1) : healHoldTestCaseIds.size;
+  const rawReservedForHeals = isHealForHeldTest ? Math.max(0, healHoldTestCaseIds.size - 1) : healHoldTestCaseIds.size;
+  const maxHealReserve = capacity <= 1 ? capacity : Math.max(1, capacity - 1);
+  const reservedForHeals = Math.min(rawReservedForHeals, maxHealReserve);
   if (activeMobileOps + reservedForHeals >= capacity) {
     const reason = reservedForHeals > 0 ? `capacity reserved for pending auto-heal: ${activeMobileOps}+${reservedForHeals}/${capacity}` : `mobile capacity reached: ${activeMobileOps}/${capacity} in use`;
     return { claim: false, disposition: "defer", reason };
@@ -359132,6 +362815,11 @@ var MobileBridgeDriver = class {
       } catch (err) {
         if (isRecoverableAppiumSessionFailure(err)) throw err;
       }
+      try {
+        await dismissBlockingSystemUi(this.sessionPath, this.platform);
+      } catch (err) {
+        if (isRecoverableAppiumSessionFailure(err) || isAppiumDriverDeadError(err)) throw err;
+      }
     });
   }
   /**
@@ -359169,6 +362857,11 @@ var MobileBridgeDriver = class {
         } catch (err) {
           if (isRecoverableAppiumSessionFailure(err)) throw err;
         }
+        try {
+          await dismissBlockingSystemUi(this.sessionPath, this.platform);
+        } catch (err) {
+          if (isRecoverableAppiumSessionFailure(err) || isAppiumDriverDeadError(err)) throw err;
+        }
         return true;
       } catch (err) {
         if (isRecoverableAppiumSessionFailure(err)) throw err;
@@ -362528,6 +366221,17 @@ ${finalVerifyResult.logs ?? ""}`;
             }
           };
           log.info("\u{1FA7A} Mobile AI heal \u2014 Phase 1 (script) \u2192 Phase 2 (live device, lazy)...");
+          const tagList = Array.isArray(run2.tags) ? run2.tags : [];
+          const failureCount = Math.max(
+            1,
+            typeof run2.consecutiveFails === "number" && run2.consecutiveFails > 0 ? run2.consecutiveFails : tagList.includes("@bug-found") ? 2 : 1
+          );
+          const reproduceApiCalls = Array.isArray(nativeVerify.last?.apiCalls) ? nativeVerify.last.apiCalls.map((c) => ({
+            method: typeof c.method === "string" ? c.method : void 0,
+            url: typeof c.url === "string" ? c.url : void 0,
+            status: typeof c.status === "number" ? c.status : void 0
+          })) : void 0;
+          const uiPathSucceeded = Array.isArray(reproduce.stepResults) && reproduce.stepResults.filter((s) => s.status === "passed").length >= Math.max(1, reproduce.stepResults.length - 1);
           const heal = await (0, import_runner_core14.executeMobileTestWithHealing)(
             mobileSteps,
             healTarget,
@@ -362536,7 +366240,11 @@ ${finalVerifyResult.logs ?? ""}`;
               logs: reproduce.logs,
               failingSource: reproduce.failingSource,
               testVariables: run2.testVariables,
-              testName: run2.testName
+              testName: run2.testName,
+              tags: tagList,
+              failureCount,
+              apiCalls: reproduceApiCalls,
+              uiPathSucceeded
             },
             healerOptions
           );
@@ -362545,7 +366253,8 @@ ${finalVerifyResult.logs ?? ""}`;
             heal,
             finalError: finalRes?.error ?? null,
             reproduceError,
-            testVariables: run2.testVariables
+            testVariables: run2.testVariables,
+            originalSteps: mobileSteps
           });
           await postResult(opts.serverUrl, headers, run2.runId, {
             status: outcome.status,