@veolab/discoverylab 1.2.2 → 1.3.0

package/dist/chunk-N6JJ2RGV.js

@@ -0,0 +1,2680 @@
+import {
+  buildAppLabNetworkProfile,
+  inferAppLabExternalProxyHost
+} from "./chunk-LB3RNE3O.js";
+import {
+  attachESVPNetworkTrace,
+  clearESVPNetwork,
+  configureESVPNetwork,
+  createESVPSession,
+  finishESVPSession,
+  getESVPArtifactContent,
+  getESVPConnection,
+  getESVPReplayConsistency,
+  getESVPSessionNetwork,
+  inspectESVPSession,
+  replayESVPSession,
+  runESVPActions
+} from "./chunk-GAKEFJ5T.js";
+import {
+  redactSensitiveTestInput
+} from "./chunk-SLNJEF32.js";
+import {
+  recognizeText
+} from "./chunk-XFVDP332.js";
+
+// src/core/analyze/aiActionDetector.ts
+import Anthropic from "@anthropic-ai/sdk";
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+function buildAnalysisPrompt(screenshotCount) {
+  return `You are analyzing a sequence of ${screenshotCount} mobile app screenshots taken during a user testing session. Your task is to detect what actions the user performed between each screenshot.
+
+Analyze the visual changes between consecutive screenshots and identify:
+1. Taps on buttons, links, or UI elements
+2. Text input in fields
+3. Scroll/swipe gestures
+4. Navigation actions (back, etc.)
+5. App launches or screen transitions
+
+For each detected action, determine:
+- The type of action (tap, type, scroll, swipe, back, launch, wait)
+- A short human description of what happened
+- For tap actions, set "element" to the shortest exact visible label on screen when possible. Examples: "Looks", "View Plans", "Continue". Do not use descriptive phrases like "Looks tab in bottom navigation" unless that full phrase is literally visible.
+- The approximate screen coordinates if it's a tap (as percentage of screen, e.g., x: 50, y: 30 means center-top)
+- Any text that was typed
+- Scroll/swipe direction
+
+Respond in JSON format:
+{
+  "appName": "detected app name or null",
+  "actions": [
+    {
+      "type": "tap|type|scroll|swipe|back|launch|wait",
+      "description": "what the action does",
+      "element": "button text or element description",
+      "text": "typed text if type action",
+      "coordinates": {"x": 50, "y": 75},
+      "direction": "up|down|left|right for scroll/swipe",
+      "confidence": 0.0-1.0
+    }
+  ],
+  "summary": "brief summary of the user flow"
+}
+
+  Be conservative - only include actions you're confident about (confidence > 0.7).
+  Focus on meaningful interactions, not every tiny change.
+  Return ONLY valid JSON (no Markdown, no code fences, no extra commentary).`;
+}
+function buildVisibleActionSelectionPrompt(candidates) {
+  return `You are looking at a single mobile app screenshot.
+
+Choose which of the candidate UI actions is currently visible and tappable on screen right now.
+
+Rules:
+- Prefer exact visible button/link/tab labels.
+- If none of the candidates are clearly visible, return null.
+- Do not guess based on what might happen next.
+
+Respond in JSON only:
+{
+  "selectedLabel": "one of the candidate labels exactly as provided, or null",
+  "confidence": 0.0-1.0,
+  "reason": "brief explanation"
+}
+
+Candidates:
+${candidates.map((candidate, index) => `${index + 1}. ${candidate}`).join("\n")}`;
+}
+function normalizeWhitespace(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+function extractQuotedLabel(value) {
+  const text = normalizeWhitespace(value);
+  if (!text) return "";
+  const match = text.match(/["“”']([^"“”']{2,80})["“”']/);
+  return normalizeWhitespace(match?.[1]);
+}
+function normalizeTapElementLabel(value) {
+  const raw = normalizeWhitespace(value);
+  if (!raw) return "";
+  const quoted = extractQuotedLabel(raw);
+  if (quoted) return quoted;
+  const variants = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (candidate) => {
+    const normalized = normalizeWhitespace(candidate);
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    variants.push(normalized);
+  };
+  push(raw);
+  push(raw.replace(/\s+(?:in|inside|within|from|on)\s+.+$/i, ""));
+  push(raw.replace(/\s+(?:button|tab|icon|link|banner|card|item|field|input|modal|sheet|screen|section|row)$/i, ""));
+  push(
+    raw.split(/\s+/).filter((part) => !["my", "the", "a", "an", "to", "for", "of"].includes(part.toLowerCase())).join(" ")
+  );
+  return variants[variants.length - 1] || variants[0] || raw;
+}
+function normalizeDetectedAction(action) {
+  const normalized = {
+    ...action,
+    description: normalizeWhitespace(action.description),
+    element: normalizeWhitespace(action.element),
+    text: normalizeWhitespace(action.text)
+  };
+  if (normalized.type === "tap") {
+    const literalElement = normalizeTapElementLabel(normalized.element || normalized.description);
+    if (literalElement) {
+      normalized.element = literalElement;
+    }
+  }
+  return normalized;
+}
+function normalizeDetectedActions(actions) {
+  return (actions || []).map(normalizeDetectedAction);
+}
+function sanitizePreview(text, maxLength = 400) {
+  const normalized = String(text || "").replace(/\s+/g, " ").trim();
+  if (!normalized) return "(empty response)";
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength)}...` : normalized;
+}
+function extractCodeFenceCandidates(text) {
+  const candidates = [];
+  const fenceRegex = /```(?:json)?\s*([\s\S]*?)```/gi;
+  let match = null;
+  while ((match = fenceRegex.exec(text)) !== null) {
+    if (match[1]?.trim()) candidates.push(match[1].trim());
+  }
+  return candidates;
+}
+function extractBraceObjectCandidates(text) {
+  const candidates = [];
+  let depth = 0;
+  let start = -1;
+  let inString = false;
+  let escaped = false;
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\" && inString) {
+      escaped = true;
+      continue;
+    }
+    if (ch === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString) continue;
+    if (ch === "{") {
+      if (depth === 0) start = i;
+      depth += 1;
+      continue;
+    }
+    if (ch === "}") {
+      if (depth > 0) depth -= 1;
+      if (depth === 0 && start >= 0) {
+        const candidate = text.slice(start, i + 1).trim();
+        if (candidate) candidates.push(candidate);
+        start = -1;
+      }
+    }
+  }
+  return candidates;
+}
+function coerceAnalysisResult(parsed) {
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Parsed response is not an object");
+  }
+  const obj = parsed;
+  return {
+    actions: Array.isArray(obj.actions) ? obj.actions : [],
+    appName: typeof obj.appName === "string" ? obj.appName : void 0,
+    summary: typeof obj.summary === "string" ? obj.summary : "",
+    skipped: typeof obj.skipped === "boolean" ? obj.skipped : void 0
+  };
+}
+function parseAnalysisResponse(text) {
+  const raw = String(text || "").trim();
+  if (!raw) {
+    throw new Error("Could not parse JSON from response (empty response)");
+  }
+  const candidates = [raw, ...extractCodeFenceCandidates(raw), ...extractBraceObjectCandidates(raw)];
+  const seen = /* @__PURE__ */ new Set();
+  let lastError = null;
+  for (const candidate of candidates) {
+    const normalized = candidate.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    try {
+      return coerceAnalysisResult(JSON.parse(normalized));
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : "unknown parse error";
+  throw new Error(`Could not parse JSON from response (${detail}). Preview: ${sanitizePreview(raw)}`);
+}
+function parseVisibleActionSelectionResponse(text) {
+  const raw = String(text || "").trim();
+  if (!raw) {
+    throw new Error("Could not parse visible action selection (empty response)");
+  }
+  const candidates = [raw, ...extractCodeFenceCandidates(raw), ...extractBraceObjectCandidates(raw)];
+  const seen = /* @__PURE__ */ new Set();
+  let lastError = null;
+  for (const candidate of candidates) {
+    const normalized = candidate.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    try {
+      const parsed = JSON.parse(normalized);
+      return {
+        selectedLabel: typeof parsed.selectedLabel === "string" && parsed.selectedLabel.trim() ? parsed.selectedLabel.trim() : null,
+        confidence: typeof parsed.confidence === "number" ? parsed.confidence : void 0,
+        reason: typeof parsed.reason === "string" ? parsed.reason : void 0
+      };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  const detail = lastError instanceof Error ? lastError.message : "unknown parse error";
+  throw new Error(`Could not parse visible action selection (${detail}). Preview: ${sanitizePreview(raw)}`);
+}
+async function analyzeWithAnthropicVision(apiKey, screenshotPaths, prompt) {
+  const anthropic = new Anthropic({ apiKey });
+  const imageContents = screenshotPaths.map((imagePath) => {
+    const imageData = readFileSync(imagePath);
+    const base64 = imageData.toString("base64");
+    return {
+      type: "image",
+      source: {
+        type: "base64",
+        media_type: "image/png",
+        data: base64
+      }
+    };
+  });
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 4096,
+    messages: [
+      {
+        role: "user",
+        content: [
+          ...imageContents,
+          { type: "text", text: prompt }
+        ]
+      }
+    ]
+  });
+  const textContent = response.content.find((c) => c.type === "text");
+  if (!textContent || textContent.type !== "text") {
+    throw new Error("No text response from Claude");
+  }
+  return parseAnalysisResponse(textContent.text);
+}
+async function selectVisibleActionWithAnthropicVision(apiKey, screenshotPath, prompt) {
+  const anthropic = new Anthropic({ apiKey });
+  const imageData = readFileSync(screenshotPath);
+  const base64 = imageData.toString("base64");
+  const response = await anthropic.messages.create({
+    model: "claude-sonnet-4-20250514",
+    max_tokens: 1024,
+    messages: [
+      {
+        role: "user",
+        content: [
+          {
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: "image/png",
+              data: base64
+            }
+          },
+          { type: "text", text: prompt }
+        ]
+      }
+    ]
+  });
+  const textContent = response.content.find((content) => content.type === "text");
+  if (!textContent || textContent.type !== "text") {
+    throw new Error("No text response from Claude");
+  }
+  return parseVisibleActionSelectionResponse(textContent.text);
+}
+async function analyzeScreenshotsForActions(screenshotsDir, maxScreenshots = 20, provider) {
+  const files = readdirSync(screenshotsDir).filter((f) => f.endsWith(".png")).sort();
+  if (files.length < 2) {
+    return {
+      actions: [],
+      summary: "Not enough screenshots for action detection"
+    };
+  }
+  const selectedFiles = files.length > maxScreenshots ? sampleArray(files, maxScreenshots) : files;
+  const screenshotPaths = selectedFiles.map((file) => join(screenshotsDir, file));
+  const prompt = buildAnalysisPrompt(selectedFiles.length);
+  const providerCandidates = (Array.isArray(provider) ? provider : [provider]).filter(
+    (p) => !!p
+  );
+  console.log(`[AIActionDetector] Analyzing ${selectedFiles.length} screenshots...`);
+  const strategyErrors = [];
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (apiKey) {
+    try {
+      console.log("[AIActionDetector] Using Anthropic API vision (fast path)");
+      const result = await analyzeWithAnthropicVision(apiKey, screenshotPaths, prompt);
+      result.actions = normalizeDetectedActions(result.actions);
+      result.actionDetectionProvider = "anthropic-api vision (claude-sonnet-4-20250514)";
+      console.log(`[AIActionDetector] Detected ${result.actions.length} actions`);
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      strategyErrors.push(`anthropic-api vision: ${message}`);
+      console.warn(`[AIActionDetector] Anthropic vision failed: ${message}`);
+    }
+  }
+  for (const candidate of providerCandidates) {
+    if (!candidate.sendMessageWithImages) continue;
+    try {
+      console.log(`[AIActionDetector] Using provider: ${candidate.name} (image support)`);
+      const response = await candidate.sendMessageWithImages(prompt, screenshotPaths);
+      const result = parseAnalysisResponse(response);
+      result.actions = normalizeDetectedActions(result.actions);
+      result.actionDetectionProvider = candidate.name;
+      console.log(`[AIActionDetector] Detected ${result.actions.length} actions`);
+      return result;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      strategyErrors.push(`${candidate.name}: ${message}`);
+      console.warn(`[AIActionDetector] Provider failed (${candidate.name}): ${message}`);
+    }
+  }
+  if (strategyErrors.length > 0) {
+    const combined = strategyErrors.slice(0, 3).join(" | ");
+    console.error("[AIActionDetector] Analysis failed across all vision strategies:", combined);
+    return {
+      actions: [],
+      summary: `AI analysis failed: ${combined}`
+    };
+  }
+  console.warn("[AIActionDetector] \u26A0\uFE0F No vision-capable provider available");
+  console.warn("[AIActionDetector] Set ANTHROPIC_API_KEY, ensure Claude CLI is available, or configure a vision-capable Ollama model");
+  return {
+    actions: [],
+    summary: "No vision-capable AI provider available",
+    skipped: true
+  };
+}
+async function selectVisibleActionFromScreenshot(screenshotPath, candidateLabels, provider) {
+  const normalizedCandidates = Array.from(
+    new Set(
+      (candidateLabels || []).map((candidate) => normalizeWhitespace(candidate)).filter(Boolean)
+    )
+  );
+  if (normalizedCandidates.length === 0) {
+    return null;
+  }
+  const prompt = buildVisibleActionSelectionPrompt(normalizedCandidates);
+  const providerCandidates = (Array.isArray(provider) ? provider : [provider]).filter(
+    (p) => !!p
+  );
+  const strategyErrors = [];
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (apiKey) {
+    try {
+      const result = await selectVisibleActionWithAnthropicVision(apiKey, screenshotPath, prompt);
+      return {
+        ...result,
+        providerName: "anthropic-api vision (claude-sonnet-4-20250514)"
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      strategyErrors.push(`anthropic-api vision: ${message}`);
+    }
+  }
+  for (const candidate of providerCandidates) {
+    if (!candidate.sendMessageWithImages) continue;
+    try {
+      const response = await candidate.sendMessageWithImages(prompt, [screenshotPath]);
+      const result = parseVisibleActionSelectionResponse(response);
+      return {
+        ...result,
+        providerName: candidate.name
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      strategyErrors.push(`${candidate.name}: ${message}`);
+    }
+  }
+  if (strategyErrors.length > 0) {
+    console.warn("[AIActionDetector] Visible action selection failed:", strategyErrors.slice(0, 2).join(" | "));
+  }
+  return null;
+}
+function generateMaestroYaml(actions, appId, appName, actionDetectionProvider) {
+  const lines = [
+    `# Auto-generated Maestro test flow`,
+    `# Generated by DiscoveryLab AI Action Detector`,
+    `# ${(/* @__PURE__ */ new Date()).toISOString()}`,
+    ""
+  ];
+  if (actionDetectionProvider) {
+    lines.push(`# AI Action Detection Provider: ${actionDetectionProvider}`);
+    lines.push("");
+  }
+  lines.push("appId: " + (appId || "com.example.app # TODO: Set your app ID"));
+  lines.push("");
+  if (appName) {
+    lines.push(`# App: ${appName}`);
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  for (const action of actions) {
+    if (action.confidence < 0.7) continue;
+    let commentDescription = action.description;
+    switch (action.type) {
+      case "launch":
+        lines.push(`- launchApp`);
+        break;
+      case "tap":
+        if (action.element) {
+          const literalElement = normalizeTapElementLabel(action.element || commentDescription);
+          lines.push(`- tapOn:`);
+          lines.push(`    text: "${escapeYaml(literalElement)}"`);
+        } else if (action.coordinates) {
+          lines.push(`- tapOn:`);
+          lines.push(`    point: "${action.coordinates.x}%,${action.coordinates.y}%"`);
+        }
+        break;
+      case "type":
+        if (action.text) {
+          const safeInputText = redactSensitiveTestInput(action.text, {
+            actionType: "inputText",
+            description: action.description,
+            fieldHint: action.element
+          });
+          if (safeInputText !== action.text && commentDescription) {
+            commentDescription = commentDescription.split(action.text).join(safeInputText);
+          }
+          lines.push(`- inputText: "${escapeYaml(safeInputText)}"`);
+        }
+        break;
+      case "scroll":
+      case "swipe":
+        if (action.direction) {
+          const direction = action.direction === "up" ? "DOWN" : action.direction === "down" ? "UP" : action.direction === "left" ? "RIGHT" : "LEFT";
+          lines.push(`- scroll:`);
+          lines.push(`    direction: ${direction}`);
+        }
+        break;
+      case "back":
+        lines.push(`- pressKey: back`);
+        break;
+      case "wait":
+        lines.push(`- extendedWaitUntil:`);
+        lines.push(`    visible: ".*"`);
+        lines.push(`    timeout: 5000`);
+        break;
+    }
+    if (commentDescription) {
+      lines[lines.length - 1] += ` # ${commentDescription}`;
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function sampleArray(arr, count) {
+  if (arr.length <= count) return arr;
+  const result = [];
+  const step = (arr.length - 1) / (count - 1);
+  for (let i = 0; i < count; i++) {
+    const index = Math.round(i * step);
+    result.push(arr[index]);
+  }
+  return result;
+}
+function escapeYaml(str) {
+  return str.replace(/"/g, '\\"').replace(/\n/g, "\\n");
+}
+
+// src/core/integrations/local-network-proxy.ts
+import { networkInterfaces } from "os";
+
+// src/core/integrations/esvp-host-runtime.ts
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { createServer } from "net";
+import { homedir } from "os";
+import { dirname, join as join2, resolve } from "path";
+import { fileURLToPath } from "url";
+var MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+var PROJECT_ROOT = resolve(MODULE_DIR, "../../..");
+var runtimeState = null;
+var runtimeStartPromise = null;
+async function startHostRuntimeCaptureSession(input) {
+  const runtime = await ensureRuntimeProcess();
+  return runtimeRequest(runtime, "/sessions/start", {
+    method: "POST",
+    body: JSON.stringify({
+      sessionId: input.sessionId,
+      advertiseHost: input.advertiseHost,
+      bindHost: input.bindHost,
+      captureMode: input.captureMode || "external-proxy",
+      maxDurationMs: input.maxDurationMs ?? null,
+      maxBodyCaptureBytes: input.maxBodyCaptureBytes ?? 16384,
+      meta: input.meta || null
+    })
+  });
+}
+async function drainHostRuntimeCaptureSession(sessionId) {
+  const runtime = getRunningRuntimeProcess();
+  if (!runtime) {
+    throw new Error("ESVP host runtime is not running.");
+  }
+  return runtimeRequest(runtime, `/sessions/${encodeURIComponent(sessionId)}/drain`, {
+    method: "POST",
+    body: JSON.stringify({ reason: "manual-stop" })
+  });
+}
+async function panicStopHostRuntime(reason = "manual-emergency-stop") {
+  const runtime = getRunningRuntimeProcess();
+  if (!runtime) {
+    return {
+      stopped: 0,
+      sessions: []
+    };
+  }
+  return runtimeRequest(runtime, "/panic-stop", {
+    method: "POST",
+    body: JSON.stringify({ reason })
+  });
+}
+async function shutdownHostRuntime() {
+  const runtime = runtimeState;
+  runtimeState = null;
+  runtimeStartPromise = null;
+  if (!runtime) return;
+  try {
+    runtime.child.stdin?.end();
+  } catch {
+  }
+  try {
+    const exited = await waitForChildExit(runtime.child, 750);
+    if (exited) return;
+  } catch {
+  }
+  try {
+    runtime.child.kill("SIGTERM");
+  } catch {
+  }
+}
+async function ensureRuntimeProcess() {
+  if (isRuntimeProcessAlive(runtimeState)) {
+    return runtimeState;
+  }
+  if (runtimeStartPromise) return runtimeStartPromise;
+  runtimeStartPromise = startRuntimeProcess().finally(() => {
+    runtimeStartPromise = null;
+  });
+  runtimeState = await runtimeStartPromise;
+  return runtimeState;
+}
+async function startRuntimeProcess() {
+  const port = await findFreePort();
+  const token = randomToken();
+  const launch = resolveRuntimeLaunchCommand();
+  const args = [
+    ...launch.args,
+    "--host",
+    "127.0.0.1",
+    "--port",
+    String(port),
+    "--token",
+    token
+  ];
+  const child = spawn(launch.command, args, {
+    stdio: ["pipe", "pipe", "pipe"],
+    env: process.env
+  });
+  const state = {
+    child,
+    command: launch,
+    token,
+    baseUrl: `http://127.0.0.1:${port}`,
+    port
+  };
+  child.stdout?.on("data", (chunk) => {
+    const text = String(chunk || "").trim();
+    if (text) console.log(`[esvp-host-runtime] ${text}`);
+  });
+  child.stderr?.on("data", (chunk) => {
+    const text = String(chunk || "").trim();
+    if (text) console.error(`[esvp-host-runtime] ${text}`);
+  });
+  child.once("exit", () => {
+    if (runtimeState?.child === child) {
+      runtimeState = null;
+    }
+  });
+  child.once("error", () => {
+    if (runtimeState?.child === child) {
+      runtimeState = null;
+    }
+  });
+  try {
+    await waitForRuntimeHealth(state);
+  } catch (error) {
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    throw error;
+  }
+  return state;
+}
+function resolveRuntimeLaunchCommand() {
+  const binary = resolveBundledOrBuiltRuntimeBinary();
+  if (binary) {
+    return {
+      kind: "binary",
+      command: binary,
+      args: []
+    };
+  }
+  for (const root of resolveProjectRoots()) {
+    const manifestPath = join2(root, "runtime", "Cargo.toml");
+    if (existsSync(manifestPath)) {
+      return {
+        kind: "cargo",
+        command: "cargo",
+        args: ["run", "--quiet", "--release", "--manifest-path", manifestPath, "-p", "esvp-host-runtime", "--"]
+      };
+    }
+  }
+  throw new Error(
+    "ESVP host runtime was not found. Build the Rust runtime or set DISCOVERYLAB_ESVP_HOST_RUNTIME_BIN."
+  );
+}
+function resolveBundledOrBuiltRuntimeBinary() {
+  const explicit = normalizeOptionalString(process.env.DISCOVERYLAB_ESVP_HOST_RUNTIME_BIN);
+  if (explicit && existsSync(explicit)) return explicit;
+  const target = resolveTargetTriple();
+  const binaryName = process.platform === "win32" ? "esvp-host-runtime.exe" : "esvp-host-runtime";
+  const rustTarget = resolveRustTargetTriple(target);
+  const candidates = [
+    join2(homedir(), ".discoverylab", "runtime", "esvp-host-runtime", target, binaryName),
+    ...resolveProjectRoots().flatMap((root) => [
+      join2(root, "dist", "runtime", "esvp-host-runtime", target, binaryName),
+      join2(root, "runtime", "esvp-host-runtime", target, binaryName),
+      join2(root, "runtime", "target", rustTarget, "release", binaryName),
+      join2(root, "runtime", "target", "release", binaryName)
+    ])
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+function resolveTargetTriple() {
+  const platform = process.platform;
+  const arch = normalizeTargetArch(process.arch);
+  if (platform === "darwin" && arch === "arm64") return "darwin-arm64";
+  if (platform === "darwin" && arch === "x64") return "darwin-x64";
+  if (platform === "linux" && arch === "arm64") return "linux-arm64";
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "win32" && arch === "x64") return "win32-x64";
+  throw new Error(`Unsupported platform/arch for ESVP host runtime: ${platform}/${arch}`);
+}
+function resolveRustTargetTriple(target) {
+  const mapping = {
+    "darwin-arm64": "aarch64-apple-darwin",
+    "darwin-x64": "x86_64-apple-darwin",
+    "linux-arm64": "aarch64-unknown-linux-gnu",
+    "linux-x64": "x86_64-unknown-linux-gnu",
+    "win32-x64": "x86_64-pc-windows-msvc"
+  };
+  const resolved = mapping[target];
+  if (!resolved) {
+    throw new Error(`Unsupported Rust target for ESVP host runtime: ${target}`);
+  }
+  return resolved;
+}
+async function waitForRuntimeHealth(runtime) {
+  let lastError = null;
+  for (let attempt = 0; attempt < 60; attempt += 1) {
+    if (runtime.child.exitCode != null) {
+      throw new Error(`ESVP host runtime exited before becoming healthy (code ${runtime.child.exitCode}).`);
+    }
+    try {
+      await runtimeRequest(runtime, "/health", { method: "GET" }, 1500);
+      return;
+    } catch (error) {
+      lastError = error;
+      await sleep(250);
+    }
+  }
+  throw new Error(`ESVP host runtime failed health checks: ${safeErrorMessage(lastError)}`);
+}
+async function runtimeRequest(runtime, path, init, timeoutMs = 5e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(`${runtime.baseUrl}${path}`, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${runtime.token}`,
+        "Content-Type": "application/json",
+        ...init.headers || {}
+      },
+      signal: controller.signal
+    });
+    const text = await response.text();
+    const payload = text.trim() ? tryParseJson(text) : null;
+    if (!response.ok) {
+      const message = (payload && typeof payload === "object" && payload !== null ? payload.error || payload.message : null) || `Host runtime request failed (${response.status})`;
+      throw new Error(String(message));
+    }
+    return payload;
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "AbortError") {
+      throw new Error(`ESVP host runtime request timed out after ${timeoutMs}ms: ${path}`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function tryParseJson(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+async function findFreePort() {
+  return new Promise((resolve2, reject) => {
+    const server = createServer();
+    server.unref();
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      const port = address && typeof address === "object" ? Number(address.port) : NaN;
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        if (!Number.isFinite(port) || port <= 0) {
+          reject(new Error("Failed to allocate a free port for the ESVP host runtime."));
+          return;
+        }
+        resolve2(port);
+      });
+    });
+  });
+}
+function randomToken() {
+  return `rt_${Math.random().toString(36).slice(2)}${Math.random().toString(36).slice(2)}`;
+}
+function resolveProjectRoots() {
+  return [.../* @__PURE__ */ new Set([PROJECT_ROOT, process.cwd()])];
+}
+function normalizeTargetArch(arch) {
+  if (arch === "x64") return "x64";
+  return arch;
+}
+function getRunningRuntimeProcess() {
+  return isRuntimeProcessAlive(runtimeState) ? runtimeState : null;
+}
+function isRuntimeProcessAlive(runtime) {
+  return Boolean(runtime && runtime.child.exitCode == null && !runtime.child.killed);
+}
+function waitForChildExit(child, timeoutMs) {
+  return new Promise((resolve2) => {
+    const timeout = setTimeout(() => {
+      cleanup();
+      resolve2(false);
+    }, timeoutMs);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      child.off("exit", onExit);
+      child.off("error", onError);
+    };
+    const onExit = () => {
+      cleanup();
+      resolve2(true);
+    };
+    const onError = () => {
+      cleanup();
+      resolve2(true);
+    };
+    child.once("exit", onExit);
+    child.once("error", onError);
+  });
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed || null;
+}
+function safeErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/core/integrations/local-network-proxy.ts
+var activeProxies = /* @__PURE__ */ new Map();
+var finalizationsInFlight = /* @__PURE__ */ new Map();
+var cleanupRegistered = false;
+async function ensureLocalCaptureProxyProfile(input) {
+  const profile = cloneProfile(input.profile);
+  if (!profile) {
+    return {
+      profile,
+      captureProxy: null,
+      usesExternalProxy: false,
+      appLabOwnedProxy: false
+    };
+  }
+  const captureMode = String(profile.capture?.mode || "").trim().toLowerCase();
+  const usesExternalProxy = captureMode === "external-proxy";
+  if (!usesExternalProxy) {
+    return {
+      profile,
+      captureProxy: null,
+      usesExternalProxy,
+      appLabOwnedProxy: false
+    };
+  }
+  if (hasExplicitProxy(profile)) {
+    return {
+      profile,
+      captureProxy: null,
+      usesExternalProxy,
+      appLabOwnedProxy: false
+    };
+  }
+  if (input.allowAppLabOwnedProxy === false) {
+    throw new Error(
+      "App Lab proxy emergency lock is enabled. Unlock it in Settings or provide an explicit external proxy host/port."
+    );
+  }
+  const proxy = await startLocalCaptureProxy({
+    sessionId: input.sessionId,
+    platform: input.platform,
+    deviceId: input.deviceId,
+    captureMode: resolveAppLabCaptureMode(profile),
+    lifecycle: input.lifecycle || null
+  });
+  profile.proxy = {
+    host: proxy.host,
+    port: proxy.port,
+    protocol: "http"
+  };
+  return {
+    profile,
+    captureProxy: proxy,
+    usesExternalProxy,
+    appLabOwnedProxy: true
+  };
+}
+async function stopLocalCaptureProxy(sessionId) {
+  const existing = activeProxies.get(sessionId) || null;
+  if (!existing) {
+    return {
+      captureProxy: null,
+      trace: null
+    };
+  }
+  activeProxies.delete(sessionId);
+  const drained = await drainHostRuntimeCaptureSession(sessionId).catch(() => null);
+  return {
+    captureProxy: normalizeCaptureProxyState(drained?.captureProxy, existing.captureProxy, false),
+    trace: normalizeTracePayload(drained?.trace || null)
+  };
+}
+function listLocalCaptureProxyStates() {
+  return [...activeProxies.values()].map((record) => normalizeCaptureProxyState(record.captureProxy, null, true)).filter(Boolean);
+}
+async function finalizeAllLocalCaptureProxySessions(input = {}) {
+  const sessionIds = [...activeProxies.keys()];
+  const reason = normalizeOptionalString2(input.reason) || "manual-emergency-stop";
+  const results = await Promise.all(
+    sessionIds.map(async (sessionId) => {
+      try {
+        return {
+          sessionId,
+          result: await finalizeLocalCaptureProxySession({
+            sourceSessionId: sessionId,
+            ...activeProxies.get(sessionId)?.lifecycle || {},
+            clearNetwork: true,
+            cleanupMeta: {
+              ...activeProxies.get(sessionId)?.lifecycle?.cleanupMeta || {},
+              finalize_reason: reason
+            }
+          })
+        };
+      } catch (error) {
+        return {
+          sessionId,
+          result: {
+            captureProxy: normalizeCaptureProxyState(activeProxies.get(sessionId)?.captureProxy || null, null, false),
+            traceAttached: false,
+            cleanupSessionId: null,
+            clearResult: null,
+            clearedAt: null,
+            finishResult: null,
+            errors: [safeErrorMessage2(error)]
+          }
+        };
+      }
+    })
+  );
+  return {
+    total: sessionIds.length,
+    finalized: results.length,
+    results
+  };
+}
+async function finalizeLocalCaptureProxySession(input) {
+  const existing = finalizationsInFlight.get(input.sourceSessionId);
+  if (existing) return existing;
+  const promise = finalizeLocalCaptureProxySessionInternal(input).finally(() => {
+    finalizationsInFlight.delete(input.sourceSessionId);
+  });
+  finalizationsInFlight.set(input.sourceSessionId, promise);
+  return promise;
+}
+async function finalizeLocalCaptureProxySessionInternal(input) {
+  const errors = [];
+  let clearResult = null;
+  let cleanupSessionId = null;
+  let clearedAt = null;
+  if (input.clearNetwork !== false) {
+    try {
+      clearResult = await clearESVPNetwork(input.sourceSessionId, input.serverUrl);
+      clearedAt = (/* @__PURE__ */ new Date()).toISOString();
+    } catch (error) {
+      errors.push(safeErrorMessage2(error));
+      const cleanup = await runFallbackNetworkCleanupSession({
+        executor: input.executor,
+        deviceId: input.deviceId,
+        sourceSessionId: input.sourceSessionId,
+        serverUrl: input.serverUrl,
+        cleanupMeta: input.cleanupMeta
+      });
+      cleanupSessionId = cleanup.cleanupSessionId;
+      if (cleanup.clearResult) {
+        clearResult = cleanup.clearResult;
+        clearedAt = (/* @__PURE__ */ new Date()).toISOString();
+        errors.length = 0;
+      }
+      if (cleanup.errors.length > 0) {
+        errors.splice(0, errors.length, ...cleanup.errors);
+      }
+    }
+  }
+  const stopped = await stopLocalCaptureProxy(input.sourceSessionId).catch((error) => {
+    errors.push(safeErrorMessage2(error));
+    return {
+      captureProxy: null,
+      trace: null
+    };
+  });
+  let traceAttached = false;
+  if (stopped.trace) {
+    try {
+      await attachESVPNetworkTrace(input.sourceSessionId, stopped.trace, input.serverUrl);
+      traceAttached = true;
+    } catch (error) {
+      errors.push(safeErrorMessage2(error));
+    }
+  }
+  const finishResult = await finishESVPSession(
+    input.sourceSessionId,
+    {
+      captureLogcat: input.captureLogcat
+    },
+    input.serverUrl
+  ).catch((error) => {
+    errors.push(safeErrorMessage2(error));
+    return null;
+  });
+  return {
+    captureProxy: stopped.captureProxy,
+    traceAttached,
+    cleanupSessionId,
+    clearResult,
+    clearedAt,
+    finishResult: isObjectRecord(finishResult) ? finishResult : null,
+    errors
+  };
+}
+function cloneProfile(profile) {
+  if (!profile || typeof profile !== "object") return profile;
+  return JSON.parse(JSON.stringify(profile));
+}
+function hasExplicitProxy(profile) {
+  const proxy = profile.proxy;
+  if (!proxy || typeof proxy !== "object" || Array.isArray(proxy)) return false;
+  const normalizedProxy = proxy;
+  const host = typeof normalizedProxy.host === "string" ? normalizedProxy.host.trim() : "";
+  const port = Number(normalizedProxy.port);
+  return Boolean(host) && Number.isFinite(port) && port > 0;
+}
+async function startLocalCaptureProxy(input) {
+  const existing = activeProxies.get(input.sessionId);
+  if (existing) return existing.captureProxy;
+  const advertiseHost = resolveAdvertiseHost(input);
+  const bindHost = resolveBindHost(advertiseHost);
+  const maxDurationMs = input.lifecycle?.maxDurationMs ?? readProxyMaxDurationMs();
+  const started = await startHostRuntimeCaptureSession({
+    sessionId: input.sessionId,
+    advertiseHost,
+    bindHost,
+    captureMode: input.captureMode || "external-proxy",
+    maxDurationMs,
+    maxBodyCaptureBytes: 16384,
+    meta: {
+      platform: normalizeOptionalString2(input.platform) || null,
+      deviceId: normalizeOptionalString2(input.deviceId) || null,
+      source: "applab-discovery"
+    }
+  });
+  const captureProxy = normalizeCaptureProxyState(started.captureProxy, null, true);
+  if (!captureProxy) {
+    throw new Error("Host runtime did not return a capture proxy state.");
+  }
+  captureProxy.mitm = normalizeMitmState(started.mitm || null, null);
+  activeProxies.set(input.sessionId, {
+    sessionId: input.sessionId,
+    captureProxy,
+    lifecycle: input.lifecycle || null
+  });
+  registerCleanup();
+  return captureProxy;
+}
+function resolveAdvertiseHost(input) {
+  const explicit = normalizeOptionalString2(process.env.DISCOVERYLAB_NETWORK_PROXY_HOST);
+  if (explicit) return explicit;
+  const platform = String(input.platform || "").trim().toLowerCase();
+  if (platform === "ios") return "127.0.0.1";
+  if (platform === "android") {
+    const deviceId = String(input.deviceId || "").trim();
+    if (deviceId.startsWith("emulator-")) return "10.0.2.2";
+    return inferLanIpAddress() || "127.0.0.1";
+  }
+  return "127.0.0.1";
+}
+function resolveBindHost(advertiseHost) {
+  const explicit = normalizeOptionalString2(process.env.DISCOVERYLAB_NETWORK_PROXY_BIND_HOST);
+  if (explicit) return explicit;
+  if (advertiseHost === "127.0.0.1" || advertiseHost === "10.0.2.2") return "127.0.0.1";
+  return "0.0.0.0";
+}
+function inferLanIpAddress() {
+  const interfaces = networkInterfaces();
+  for (const entries of Object.values(interfaces)) {
+    for (const entry of entries || []) {
+      if (!entry || entry.internal) continue;
+      if (entry.family === "IPv4") return entry.address;
+    }
+  }
+  return null;
+}
+function registerCleanup() {
+  if (cleanupRegistered) return;
+  cleanupRegistered = true;
+  const cleanup = async (reason) => {
+    const sessionIds = [...activeProxies.keys()];
+    await Promise.allSettled(
+      sessionIds.map((sessionId) => {
+        const lifecycle = activeProxies.get(sessionId)?.lifecycle || null;
+        if (lifecycle) {
+          return finalizeLocalCaptureProxySession({
+            sourceSessionId: sessionId,
+            executor: lifecycle.executor,
+            deviceId: lifecycle.deviceId,
+            serverUrl: lifecycle.serverUrl,
+            captureLogcat: lifecycle.captureLogcat,
+            clearNetwork: true,
+            cleanupMeta: {
+              ...lifecycle.cleanupMeta || {},
+              finalize_reason: reason
+            }
+          });
+        }
+        return stopLocalCaptureProxy(sessionId).catch(() => null);
+      })
+    );
+    activeProxies.clear();
+    await panicStopHostRuntime(reason).catch(() => null);
+    await shutdownHostRuntime().catch(() => null);
+  };
+  process.once("beforeExit", () => {
+    void cleanup("process-exit");
+  });
+  process.once("SIGINT", () => {
+    void cleanup("sigint").finally(() => process.exit(0));
+  });
+  process.once("SIGTERM", () => {
+    void cleanup("sigterm").finally(() => process.exit(0));
+  });
+}
+function normalizeCaptureProxyState(value, fallback, active) {
+  const record = isObjectRecord(value) ? value : null;
+  const host = normalizeOptionalString2(record?.host) || fallback?.host || null;
+  const port = Number(record?.port ?? fallback?.port ?? NaN);
+  if (!host || !Number.isFinite(port) || port <= 0) {
+    return fallback ? {
+      ...fallback,
+      active,
+      port: Number.isFinite(fallback.port) ? fallback.port : null
+    } : null;
+  }
+  return {
+    id: normalizeOptionalString2(record?.id) || fallback?.id || `runtime-${Math.random().toString(36).slice(2, 10)}`,
+    sessionId: normalizeOptionalString2(record?.sessionId) || fallback?.sessionId || "",
+    active,
+    bindHost: normalizeOptionalString2(record?.bindHost) || fallback?.bindHost || host,
+    host,
+    port,
+    url: normalizeOptionalString2(record?.url) || fallback?.url || `http://${host}:${port}`,
+    startedAt: normalizeOptionalString2(record?.startedAt) || fallback?.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+    entryCount: clampInt(record?.entryCount ?? fallback?.entryCount ?? 0, 0, Number.MAX_SAFE_INTEGER, 0),
+    captureMode: normalizeOptionalString2(record?.captureMode) === "external-mitm" || fallback?.captureMode === "external-mitm" ? "external-mitm" : "external-proxy",
+    source: normalizeOptionalString2(record?.source) === "applab-external-mitm" || fallback?.source === "applab-external-mitm" ? "applab-external-mitm" : "applab-external-proxy",
+    mitm: normalizeMitmState(record?.mitm, fallback?.mitm || null)
+  };
+}
+function resolveAppLabCaptureMode(profile) {
+  const capture = profile.capture;
+  if (!capture || typeof capture !== "object" || Array.isArray(capture)) return "external-proxy";
+  const applabMode = String(capture.applabMode || "").trim().toLowerCase();
+  return applabMode === "external-mitm" ? "external-mitm" : "external-proxy";
+}
+function normalizeTracePayload(value) {
+  if (!isObjectRecord(value)) return null;
+  return value;
+}
+function normalizeMitmState(value, fallback) {
+  const record = isObjectRecord(value) ? value : null;
+  if (!record) return fallback || null;
+  return {
+    enabled: record.enabled === true || fallback?.enabled === true,
+    rootCertPath: normalizeOptionalString2(record.rootCertPath) || fallback?.rootCertPath || null,
+    platform: normalizeOptionalString2(record.platform) || fallback?.platform || null,
+    deviceId: normalizeOptionalString2(record.deviceId) || fallback?.deviceId || null,
+    certificateInstalled: typeof record.certificateInstalled === "boolean" ? record.certificateInstalled : fallback?.certificateInstalled,
+    certificateInstallMethod: normalizeOptionalString2(record.certificateInstallMethod) || fallback?.certificateInstallMethod || null,
+    warnings: Array.isArray(record.warnings) ? record.warnings.map((item) => String(item)).filter(Boolean) : fallback?.warnings || [],
+    errors: Array.isArray(record.errors) ? record.errors.map((item) => String(item)).filter(Boolean) : fallback?.errors || []
+  };
+}
+function normalizeOptionalString2(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed ? trimmed : null;
+}
+function clampInt(value, min, max, fallback) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.round(numeric)));
+}
+function readProxyMaxDurationMs() {
+  const raw = normalizeOptionalString2(process.env.DISCOVERYLAB_NETWORK_PROXY_MAX_DURATION_MS);
+  if (raw == null) return 15 * 60 * 1e3;
+  const durationMs = Number(raw);
+  if (!Number.isFinite(durationMs)) return 15 * 60 * 1e3;
+  if (durationMs <= 0) return null;
+  return clampInt(durationMs, 3e4, 24 * 60 * 60 * 1e3, 15 * 60 * 1e3);
+}
+async function runFallbackNetworkCleanupSession(input) {
+  const errors = [];
+  const deviceId = normalizeOptionalString2(input.deviceId);
+  const executor = normalizeOptionalExecutor(input.executor);
+  if (!deviceId || !executor) {
+    return {
+      cleanupSessionId: null,
+      clearResult: null,
+      errors
+    };
+  }
+  let cleanupSessionId = null;
+  try {
+    const created = await createESVPSession(
+      {
+        executor,
+        deviceId,
+        meta: {
+          source: "applab-discovery-network-cleanup",
+          cleanup_for_session_id: input.sourceSessionId,
+          ...input.cleanupMeta || {}
+        }
+      },
+      input.serverUrl
+    );
+    cleanupSessionId = normalizeOptionalString2(created?.session?.id || created?.id);
+    if (!cleanupSessionId) {
+      throw new Error("Failed to create a cleanup ESVP session.");
+    }
+    const cleared = await clearESVPNetwork(cleanupSessionId, input.serverUrl);
+    await finishESVPSession(cleanupSessionId, { captureLogcat: false }, input.serverUrl).catch(() => null);
+    return {
+      cleanupSessionId,
+      clearResult: isObjectRecord(cleared) ? cleared : null,
+      errors
+    };
+  } catch (error) {
+    errors.push(safeErrorMessage2(error));
+    if (cleanupSessionId) {
+      await finishESVPSession(cleanupSessionId, { captureLogcat: false }, input.serverUrl).catch(() => null);
+    }
+    return {
+      cleanupSessionId,
+      clearResult: null,
+      errors
+    };
+  }
+}
+function normalizeOptionalExecutor(value) {
+  const normalized = normalizeOptionalString2(value);
+  if (!normalized) return null;
+  if (normalized === "adb" || normalized === "ios-sim" || normalized === "maestro-ios" || normalized === "fake") {
+    return normalized;
+  }
+  return null;
+}
+function safeErrorMessage2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function isObjectRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/core/integrations/local-app-http-trace.ts
+import { randomBytes, randomUUID } from "crypto";
+var activeCollectorsBySession = /* @__PURE__ */ new Map();
+var activeCollectorsById = /* @__PURE__ */ new Map();
+function startLocalAppHttpTraceCollector(input) {
+  const existing = activeCollectorsBySession.get(input.sessionId);
+  if (existing) {
+    return existing.state;
+  }
+  const collectorId = randomUUID();
+  const host = inferAppLabExternalProxyHost({
+    platform: input.platform,
+    deviceId: input.deviceId,
+    explicitHost: null
+  }) || "127.0.0.1";
+  const ingestPath = `/api/testing/mobile/recordings/${encodeURIComponent(input.recordingId)}/esvp/app-http-trace/${encodeURIComponent(collectorId)}`;
+  const bootstrapPath = `/api/testing/mobile/app-http-trace/bootstrap?appId=${encodeURIComponent(String(input.appId || ""))}&recordingId=${encodeURIComponent(input.recordingId)}`;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const state = {
+    id: collectorId,
+    sessionId: input.sessionId,
+    recordingId: input.recordingId,
+    appId: normalizeOptionalString3(input.appId),
+    platform: normalizePlatform(input.platform),
+    deviceId: normalizeOptionalString3(input.deviceId),
+    active: true,
+    host,
+    port: input.serverPort,
+    bootstrapPath,
+    bootstrapUrl: `http://${host}:${input.serverPort}${bootstrapPath}`,
+    ingestPath,
+    ingestUrl: `http://${host}:${input.serverPort}${ingestPath}`,
+    startedAt,
+    entryCount: 0,
+    maxBodyCaptureBytes: normalizePositiveNumber(input.maxBodyCaptureBytes) || 16384,
+    source: "applab-local-app-http-trace",
+    traceKind: "app_http_trace"
+  };
+  activeCollectorsBySession.set(input.sessionId, {
+    state,
+    token: randomBytes(18).toString("hex"),
+    entries: [],
+    createdAt: Date.now()
+  });
+  activeCollectorsById.set(state.id, input.sessionId);
+  return state;
+}
+function resolveLocalAppHttpTraceCollectorById(collectorId) {
+  const sessionId = activeCollectorsById.get(collectorId);
+  if (!sessionId) return null;
+  return activeCollectorsBySession.get(sessionId)?.state || null;
+}
+function getLocalAppHttpTraceBootstrap(input) {
+  const appId = normalizeOptionalString3(input.appId);
+  const recordingId = normalizeOptionalString3(input.recordingId);
+  let bestMatch = null;
+  for (const record of activeCollectorsBySession.values()) {
+    if (!record.state.active) continue;
+    if (appId && record.state.appId === appId) {
+      if (!bestMatch || record.createdAt > bestMatch.createdAt) bestMatch = record;
+      continue;
+    }
+    if (!appId && recordingId && record.state.recordingId === recordingId) {
+      if (!bestMatch || record.createdAt > bestMatch.createdAt) bestMatch = record;
+    }
+  }
+  if (!bestMatch) return null;
+  return {
+    ...bestMatch.state,
+    bootstrap: buildBootstrapConfig(bestMatch)
+  };
+}
+function ingestLocalAppHttpTrace(input) {
+  const sessionId = activeCollectorsById.get(input.collectorId);
+  if (!sessionId) {
+    return {
+      collector: null,
+      accepted: 0
+    };
+  }
+  const record = activeCollectorsBySession.get(sessionId);
+  if (!record || !record.state.active) {
+    return {
+      collector: null,
+      accepted: 0
+    };
+  }
+  if (record.token !== String(input.authToken || "").trim()) {
+    return {
+      collector: null,
+      accepted: 0
+    };
+  }
+  const entries = extractEntries(input.payload);
+  if (entries.length > 0) {
+    record.entries.push(...entries);
+    record.state = {
+      ...record.state,
+      entryCount: record.entries.length
+    };
+  }
+  activeCollectorsBySession.set(sessionId, record);
+  return {
+    collector: record.state,
+    accepted: entries.length
+  };
+}
+async function finalizeLocalAppHttpTraceCollector(input) {
+  const record = activeCollectorsBySession.get(input.sourceSessionId);
+  if (!record) {
+    return {
+      collector: null,
+      traceAttached: false,
+      errors: []
+    };
+  }
+  activeCollectorsBySession.delete(input.sourceSessionId);
+  activeCollectorsById.delete(record.state.id);
+  const finalState = {
+    ...record.state,
+    active: false,
+    entryCount: record.entries.length
+  };
+  if (record.entries.length === 0) {
+    return {
+      collector: finalState,
+      traceAttached: false,
+      errors: []
+    };
+  }
+  try {
+    await attachESVPNetworkTrace(
+      input.sourceSessionId,
+      {
+        trace_kind: "app_http_trace",
+        label: "App Lab Local App HTTP Trace",
+        format: "json",
+        source: finalState.source,
+        payload: {
+          session_id: input.sourceSessionId,
+          collector_id: finalState.id,
+          generated_at: (/* @__PURE__ */ new Date()).toISOString(),
+          entries: record.entries
+        },
+        artifactMeta: {
+          trace_kind: "app_http_trace",
+          collector_id: finalState.id,
+          entry_count: record.entries.length,
+          source: finalState.source
+        }
+      },
+      input.serverUrl
+    );
+    return {
+      collector: finalState,
+      traceAttached: true,
+      errors: []
+    };
+  } catch (error) {
+    return {
+      collector: finalState,
+      traceAttached: false,
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+}
+function buildBootstrapConfig(record) {
+  return {
+    traceKind: "app_http_trace",
+    source: "applab-local-app-http-trace",
+    sessionId: record.state.sessionId,
+    recordingId: record.state.recordingId,
+    appId: record.state.appId,
+    ingestUrl: record.state.ingestUrl,
+    ingestPath: record.state.ingestPath,
+    authHeader: "x-applab-trace-token",
+    token: record.token,
+    maxBodyCaptureBytes: record.state.maxBodyCaptureBytes
+  };
+}
+function extractEntries(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter(isObject);
+  }
+  if (!isObject(payload)) {
+    return [];
+  }
+  const nestedCandidates = [
+    payload,
+    isObject(payload.payload) ? payload.payload : null,
+    isObject(payload.data) ? payload.data : null,
+    isObject(payload.trace) ? payload.trace : null,
+    isObject(payload.result) ? payload.result : null
+  ].filter(Boolean);
+  for (const candidate of nestedCandidates) {
+    for (const key of ["entries", "events", "requests", "items"]) {
+      if (Array.isArray(candidate[key])) {
+        return candidate[key].filter(isObject);
+      }
+    }
+  }
+  return [payload];
+}
+function normalizePositiveNumber(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) return null;
+  return Math.round(parsed);
+}
+function normalizeOptionalString3(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+function normalizePlatform(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (normalized === "ios" || normalized === "android") return normalized;
+  return null;
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/core/integrations/esvp-mobile.ts
+function createMobileNetworkCaptureMeta(input) {
+  const resourceTypes = Array.isArray(input?.resourceTypes) && input.resourceTypes.length > 0 ? input.resourceTypes.map((value) => String(value)) : ["mobile-http-trace"];
+  return {
+    truncated: input?.truncated === true,
+    maxEntries: Number.isFinite(input?.maxEntries) ? Number(input?.maxEntries) : 1200,
+    resourceTypes,
+    ...input
+  };
+}
+function diagnoseESVPNetworkState(opts) {
+  if (!opts.sourceSessionId) {
+    return {
+      status: "no_session",
+      message: "No ESVP session attached to this project."
+    };
+  }
+  if (opts.networkSupported === false) {
+    const executorLabel = opts.executor === "maestro-ios" ? "iOS (Maestro)" : opts.executor || "this executor";
+    return {
+      status: "not_supported",
+      message: `Network capture not supported for ${executorLabel}. Use external proxy or attach HAR manually.`
+    };
+  }
+  if (!opts.configuredAt) {
+    return {
+      status: "not_configured",
+      message: "Network profile was never configured for this session. Network capture requires configuring a profile before running actions."
+    };
+  }
+  const proxyEntryCount = opts.managedProxy?.entry_count ?? 0;
+  const traceCount = opts.traceCount ?? 0;
+  if ((proxyEntryCount > 0 || traceCount > 0) && (!opts.entryCount || opts.entryCount === 0)) {
+    const count = proxyEntryCount || traceCount;
+    return {
+      status: "has_traces_need_sync",
+      message: `ESVP session has ${count} captured request${count !== 1 ? "s" : ""}. Click 'Sync Network Trace' to pull them.`,
+      traceCount: count
+    };
+  }
+  if (proxyEntryCount === 0 && traceCount === 0 && (!opts.entryCount || opts.entryCount === 0)) {
+    return {
+      status: "proxy_no_traffic",
+      message: opts.captureMode === "external-proxy" ? "External proxy capture is configured but no network_trace has been attached yet." : "Managed proxy was active but captured zero requests. The device may not have routed traffic through the proxy.",
+      detail: opts.captureMode === "external-proxy" ? void 0 : opts.managedProxy ? `Proxy bound to ${opts.managedProxy.bind_host || "?"}:${opts.managedProxy.port || "?"}` : void 0
+    };
+  }
+  if (opts.entryCount && opts.entryCount > 0) {
+    return {
+      status: "synced",
+      message: `${opts.entryCount} network entries synced.`,
+      entryCount: opts.entryCount
+    };
+  }
+  return {
+    status: "unknown",
+    message: "Unable to determine network capture state."
+  };
+}
+async function collectESVPSessionNetworkData(sessionId, serverUrl) {
+  const inspection = await inspectESVPSession(
+    sessionId,
+    {
+      includeArtifacts: true,
+      includeTranscript: false
+    },
+    serverUrl
+  );
+  const artifacts = Array.isArray(inspection?.artifacts) ? inspection.artifacts : [];
+  const networkState = await getESVPSessionNetwork(sessionId, serverUrl).catch(() => null);
+  const publicNetworkState = isObject2(networkState?.network) ? networkState.network : null;
+  const normalized = await normalizeESVPNetworkArtifacts(sessionId, artifacts, serverUrl);
+  const traceKinds = Array.isArray(publicNetworkState?.trace_kinds) ? publicNetworkState.trace_kinds.map((value) => String(value)) : normalized.traceKinds;
+  const networkCapture = createMobileNetworkCaptureMeta({
+    ...normalized.networkCapture,
+    traceKinds,
+    source: "esvp-mobile",
+    sessionId,
+    managedProxy: publicNetworkState?.managed_proxy || null,
+    effectiveProfile: publicNetworkState?.effective_profile || null
+  });
+  return {
+    networkEntries: normalized.networkEntries,
+    networkCapture,
+    traceKinds,
+    networkState: publicNetworkState
+  };
+}
+async function validateMaestroRecordingWithESVP(recording, optionsOrServerUrl) {
+  const options = normalizeValidationOptions(optionsOrServerUrl);
+  const executor = recording.platform === "android" ? "adb" : "maestro-ios";
+  const connection = await getESVPConnection(options.serverUrl);
+  const normalizedAppId = normalizeRecordingAppId(recording.appId);
+  const bootstrap = await buildRecordingBootstrapActions(recording, {
+    appId: normalizedAppId,
+    screenshotPath: options.bootstrapScreenshotPath
+  });
+  const effectiveRecordingActions = [...bootstrap.actions, ...recording.actions || []];
+  const translated = translateMaestroActionsToESVP(effectiveRecordingActions, { appId: normalizedAppId });
+  const shouldCaptureLogcat = resolveCaptureLogcat(executor, options.captureLogcat);
+  const requestedNetworkProfile = normalizeRequestedNetworkProfile(options.network, {
+    platform: recording.platform,
+    deviceId: recording.deviceId
+  });
+  if (translated.actions.length === 0) {
+    return {
+      supported: false,
+      reason: "No actions compatible with the public ESVP contract were found in this Maestro recording.",
+      connectionMode: connection.mode,
+      serverUrl: connection.serverUrl,
+      executor,
+      translatedActions: translated.actions,
+      skippedActions: translated.skipped,
+      networkEntries: [],
+      networkCapture: createMobileNetworkCaptureMeta({
+        source: "esvp-mobile",
+        sessionId: null
+      }),
+      traceKinds: [],
+      bootstrap: bootstrap.summary,
+      recovery: null
+    };
+  }
+  let translatedActions = translated.actions;
+  let skippedActions = [...translated.skipped];
+  let recovery = null;
+  let execution = await runValidationSourceSession(
+    recording,
+    {
+      executor,
+      appId: normalizedAppId,
+      translatedActions,
+      requestedNetworkProfile,
+      captureLogcat: shouldCaptureLogcat,
+      serverUrl: options.serverUrl,
+      appTraceServerPort: options.appTraceServerPort,
+      metaSource: "applab-discovery-maestro-validation",
+      allowAppLabOwnedProxyAutostart: options.allowAppLabOwnedProxyAutostart
+    }
+  );
+  const initialSourceSessionId = execution.sourceSessionId;
+  if (executor === "maestro-ios" && didESVPRunFail(execution.run)) {
+    const recoveryPlan = await buildIOSVisibleTextRecoveryPlan(
+      execution.sourceSessionId,
+      translatedActions,
+      options.serverUrl,
+      options.recoveryVisionProvider
+    );
+    if (recoveryPlan) {
+      const retryExecution = await runValidationSourceSession(
+        recording,
+        {
+          executor,
+          appId: normalizedAppId,
+          translatedActions: recoveryPlan.prunedActions,
+          requestedNetworkProfile,
+          captureLogcat: shouldCaptureLogcat,
+          serverUrl: options.serverUrl,
+          appTraceServerPort: options.appTraceServerPort,
+          metaSource: "applab-discovery-maestro-validation-recovered",
+          extraMeta: {
+            recovery_strategy: recoveryPlan.strategy,
+            recovery_source_session_id: execution.sourceSessionId,
+            recovery_pruned_action_count: recoveryPlan.prunedSkipped.length
+          },
+          allowAppLabOwnedProxyAutostart: options.allowAppLabOwnedProxyAutostart
+        }
+      );
+      if (shouldPreferRecoveredExecution(execution.run, retryExecution.run)) {
+        execution = retryExecution;
+        translatedActions = recoveryPlan.prunedActions;
+        skippedActions = [...skippedActions, ...recoveryPlan.prunedSkipped];
+        recovery = {
+          applied: true,
+          strategy: recoveryPlan.strategy,
+          initialSourceSessionId,
+          finalSourceSessionId: retryExecution.sourceSessionId,
+          prunedActionCount: recoveryPlan.prunedSkipped.length,
+          resumedFromActionIndex: recoveryPlan.resumeFromIndex,
+          matchedActionIndex: recoveryPlan.matchedActionIndex,
+          matchedActionLabel: recoveryPlan.matchedActionLabel,
+          checkpointScreenshotPath: recoveryPlan.checkpointScreenshotPath,
+          visibleTextPreview: recoveryPlan.visibleTextPreview
+        };
+      }
+    }
+  }
+  const sourceSessionId = execution.sourceSessionId;
+  const replay = options.replay === false ? null : await replayESVPSession(
+    sourceSessionId,
+    {
+      executor,
+      deviceId: recording.deviceId,
+      captureLogcat: shouldCaptureLogcat,
+      meta: {
+        source: "applab-discovery-maestro-replay",
+        recording_id: recording.id,
+        ...recovery?.applied ? { recovery_strategy: recovery.strategy } : {}
+      }
+    },
+    options.serverUrl
+  );
+  const replaySessionId = replay?.replay_session?.id ? String(replay.replay_session.id) : null;
+  const replayConsistency = replaySessionId ? await getESVPReplayConsistency(replaySessionId, options.serverUrl).catch(() => null) : null;
+  const networkData = await collectESVPSessionNetworkData(sourceSessionId, options.serverUrl).catch(() => ({
+    networkEntries: [],
+    networkCapture: createMobileNetworkCaptureMeta({
+      source: "esvp-mobile",
+      sessionId: sourceSessionId
+    }),
+    traceKinds: [],
+    networkState: null
+  }));
+  const networkState = mergeNetworkState(
+    networkData.networkState,
+    extractNetworkStateFromConfig(execution.networkConfigResult)
+  );
+  if (networkState && execution.cleanupError && !networkState.last_error) {
+    networkState.last_error = execution.cleanupError;
+  }
+  if (networkState && execution.clearedAt && !networkState.cleared_at) {
+    networkState.cleared_at = execution.clearedAt;
+  }
+  return {
+    supported: true,
+    connectionMode: connection.mode,
+    serverUrl: connection.serverUrl,
+    executor,
+    translatedActions,
+    skippedActions,
+    sourceSessionId,
+    replaySessionId,
+    runSummary: execution.run,
+    checkpointComparison: replay?.checkpoint_comparison || null,
+    replayConsistency: replayConsistency?.replay_consistency || null,
+    networkEntries: networkData.networkEntries,
+    networkCapture: networkData.networkCapture,
+    traceKinds: networkData.traceKinds,
+    networkState,
+    managedProxy: networkState?.managed_proxy || null,
+    captureProxy: execution.captureProxy || null,
+    appTraceCollector: execution.appTraceCollector || null,
+    networkProfileApplied: isObject2(execution.networkConfigResult?.applied) ? execution.networkConfigResult?.applied : null,
+    bootstrap: bootstrap.summary,
+    recovery
+  };
+}
+async function runValidationSourceSession(recording, input) {
+  const created = await createESVPSession(
+    {
+      executor: input.executor,
+      deviceId: recording.deviceId,
+      meta: {
+        source: input.metaSource,
+        recording_id: recording.id,
+        recording_name: recording.name,
+        recording_platform: recording.platform,
+        recording_device_name: recording.deviceName || null,
+        ...input.appId ? { appId: input.appId, app_id: input.appId } : {},
+        ...input.extraMeta || {}
+      }
+    },
+    input.serverUrl
+  );
+  const sourceSessionId = String(created?.session?.id || created?.id || "");
+  if (!sourceSessionId) {
+    throw new Error("Failed to create an ESVP session for Maestro validation.");
+  }
+  const appTraceMode = getRequestedAppLabCaptureMode(input.requestedNetworkProfile) === "app-http-trace";
+  const preparedNetworkProfile = appTraceMode ? {
+    profile: input.requestedNetworkProfile,
+    captureProxy: null,
+    usesExternalProxy: false,
+    appLabOwnedProxy: false
+  } : await ensureLocalCaptureProxyProfile({
+    sessionId: sourceSessionId,
+    profile: input.requestedNetworkProfile,
+    platform: recording.platform,
+    deviceId: recording.deviceId,
+    allowAppLabOwnedProxy: input.allowAppLabOwnedProxyAutostart,
+    lifecycle: {
+      executor: input.executor,
+      deviceId: recording.deviceId,
+      serverUrl: input.serverUrl,
+      captureLogcat: input.captureLogcat,
+      cleanupMeta: {
+        recording_id: recording.id,
+        recording_name: recording.name,
+        recording_platform: recording.platform
+      }
+    }
+  });
+  const appTraceCollector = appTraceMode ? startLocalAppHttpTraceCollector({
+    sessionId: sourceSessionId,
+    recordingId: recording.id,
+    appId: input.appId || recording.appId,
+    platform: recording.platform,
+    deviceId: recording.deviceId,
+    serverPort: input.appTraceServerPort || 3847
+  }) : null;
+  let networkConfigResult = null;
+  if (preparedNetworkProfile.profile && !appTraceMode) {
+    networkConfigResult = await configureESVPNetwork(
+      sourceSessionId,
+      preparedNetworkProfile.profile,
+      input.serverUrl
+    );
+  }
+  let run = null;
+  let runError = null;
+  try {
+    run = await runESVPActions(
+      sourceSessionId,
+      {
+        actions: input.translatedActions,
+        finish: false,
+        captureLogcat: input.captureLogcat,
+        checkpointAfterEach: true
+      },
+      input.serverUrl
+    );
+  } catch (error) {
+    runError = error;
+  }
+  const finalization = appTraceMode ? await finalizeLocalAppHttpTraceCollector({
+    sourceSessionId,
+    serverUrl: input.serverUrl
+  }) : await finalizeLocalCaptureProxySession({
+    sourceSessionId,
+    executor: input.executor,
+    deviceId: recording.deviceId,
+    serverUrl: input.serverUrl,
+    captureLogcat: input.captureLogcat,
+    clearNetwork: Boolean(preparedNetworkProfile.profile),
+    cleanupMeta: {
+      recording_id: recording.id,
+      recording_name: recording.name,
+      recording_platform: recording.platform
+    }
+  });
+  const finalizationCollector = "collector" in finalization ? finalization.collector || null : null;
+  const finalizationClearedAt = "clearedAt" in finalization ? finalization.clearedAt : null;
+  if (runError) {
+    throw runError;
+  }
+  return {
+    sourceSessionId,
+    run,
+    networkConfigResult,
+    captureProxy: preparedNetworkProfile.captureProxy,
+    appTraceCollector: finalizationCollector || appTraceCollector,
+    cleanupError: finalization.errors[0] || null,
+    clearedAt: finalizationClearedAt
+  };
+}
+function didESVPRunFail(run) {
+  return Boolean(run?.failed || run?.session?.status === "failed");
+}
+function getESVPRunCheckpointCount(run) {
+  return Number.isFinite(run?.session?.checkpoint_count) ? Number(run.session.checkpoint_count) : 0;
+}
+function shouldPreferRecoveredExecution(initialRun, retryRun) {
+  if (!didESVPRunFail(retryRun)) return true;
+  return getESVPRunCheckpointCount(retryRun) > getESVPRunCheckpointCount(initialRun);
+}
+function getTranslatedActionId(action, index) {
+  if (typeof action?.checkpointLabel === "string" && action.checkpointLabel.trim()) {
+    return action.checkpointLabel.trim();
+  }
+  return `esvp_action_${String(index + 1).padStart(3, "0")}`;
+}
+function normalizeMatchText(value) {
+  return String(value || "").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").replace(/\s+/g, " ").trim();
+}
+function normalizeCandidateLabel(value) {
+  return String(value || "").replace(/\s+/g, " ").trim();
+}
+function isLikelyBootstrapAnchorLabel(value) {
+  const label = normalizeCandidateLabel(value);
+  if (!label) return false;
+  if (label.length > 24) return false;
+  if (/@|https?:\/\/|www\./i.test(label)) return false;
+  if (/\d/.test(label)) return false;
+  const words = label.split(/\s+/).filter(Boolean);
+  if (words.length === 0 || words.length > 3) return false;
+  const lowered = label.toLowerCase();
+  if (["preferred name", "phone number", "enable notifications", "tap to see subscription options"].includes(lowered)) {
+    return false;
+  }
+  return true;
+}
+async function inferBootstrapAnchorFromScreenshot(screenshotPath) {
+  const targetPath = normalizeCandidateLabel(screenshotPath);
+  if (!targetPath) return null;
+  const ocrResult = await recognizeText(targetPath, {
+    recognitionLevel: "accurate",
+    languages: ["en-US", "pt-BR"]
+  }).catch(() => null);
+  const text = typeof ocrResult?.text === "string" ? ocrResult.text : "";
+  if (!ocrResult?.success || !text.trim()) {
+    return null;
+  }
+  const lines = text.split(/\n+/).map((line) => normalizeCandidateLabel(line)).filter(Boolean);
+  const counts = /* @__PURE__ */ new Map();
+  const ordered = [];
+  for (const line of lines) {
+    if (!isLikelyBootstrapAnchorLabel(line)) continue;
+    const normalized = normalizeMatchText(line);
+    if (!normalized) continue;
+    counts.set(normalized, (counts.get(normalized) || 0) + 1);
+    if (!ordered.includes(normalized)) {
+      ordered.push(normalized);
+    }
+  }
+  for (const normalized of ordered) {
+    if ((counts.get(normalized) || 0) < 2) continue;
+    const original = lines.find((line) => normalizeMatchText(line) === normalized);
+    if (original) {
+      return original;
+    }
+  }
+  return null;
+}
+async function buildRecordingBootstrapActions(recording, options) {
+  const actions = [];
+  const launchAppId = normalizeRecordingAppId(options.appId || recording.appId);
+  const hasExplicitLaunch = (recording.actions || []).some((action) => action?.type === "launch");
+  if (launchAppId && !hasExplicitLaunch) {
+    actions.push({
+      id: "bootstrap_launch",
+      type: "launch",
+      timestamp: Date.now(),
+      description: `Launch ${launchAppId}`,
+      text: launchAppId,
+      appId: launchAppId
+    });
+  }
+  const initialAnchorLabel = await inferBootstrapAnchorFromScreenshot(options.screenshotPath);
+  const firstActionLabel = normalizeMatchText((recording.actions || [])[0]?.text);
+  if (initialAnchorLabel && normalizeMatchText(initialAnchorLabel) !== firstActionLabel) {
+    actions.push({
+      id: "bootstrap_anchor_001",
+      type: "tap",
+      timestamp: Date.now(),
+      description: `Return to ${initialAnchorLabel} screen`,
+      text: initialAnchorLabel
+    });
+  }
+  return {
+    actions,
+    summary: {
+      applied: actions.length > 0,
+      launchInserted: actions.some((action) => action.type === "launch"),
+      initialAnchorLabel: initialAnchorLabel || null,
+      actionCount: actions.length,
+      screenshotPath: options.screenshotPath || null
+    }
+  };
+}
+function previewVisibleText(value, maxLength = 220) {
+  const normalized = String(value || "").replace(/\s+/g, " ").trim();
+  if (!normalized) return "";
+  return normalized.length > maxLength ? `${normalized.slice(0, maxLength)}...` : normalized;
+}
+function getActionTextCandidates(action) {
+  const args = isObject2(action?.args) ? action.args : {};
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (value) => {
+    const normalized = String(value || "").trim();
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    candidates.push(normalized);
+  };
+  push(args.text);
+  push(args.selector);
+  if (Array.isArray(args.selectors)) {
+    for (const selector of args.selectors) {
+      if (!isObject2(selector)) continue;
+      push(selector.selector);
+      push(selector.label);
+    }
+  }
+  return candidates;
+}
+function scoreActionAgainstVisibleText(action, visibleText) {
+  const haystack = normalizeMatchText(visibleText);
+  if (!haystack) return 0;
+  let bestScore = 0;
+  for (const candidate of getActionTextCandidates(action)) {
+    const needle = normalizeMatchText(candidate);
+    if (!needle) continue;
+    if (haystack.includes(needle)) {
+      bestScore = Math.max(bestScore, 1);
+      continue;
+    }
+    const tokens = needle.split(" ").filter((part) => part.length > 1);
+    if (tokens.length === 0) continue;
+    const matchedTokens = tokens.filter((part) => haystack.includes(part)).length;
+    if (!matchedTokens) continue;
+    const score = matchedTokens / tokens.length * 0.45;
+    if (score > bestScore) {
+      bestScore = score;
+    }
+  }
+  return bestScore;
+}
+function getLatestScreenshotArtifactPath(artifacts) {
+  for (let index = artifacts.length - 1; index >= 0; index -= 1) {
+    const artifact = artifacts[index];
+    if (artifact?.kind !== "screenshot") continue;
+    if (typeof artifact.abs_path === "string" && artifact.abs_path.trim()) {
+      return artifact.abs_path.trim();
+    }
+  }
+  return null;
+}
+async function buildIOSVisibleTextRecoveryPlan(sourceSessionId, translatedActions, serverUrl, recoveryVisionProvider) {
+  const inspection = await inspectESVPSession(
+    sourceSessionId,
+    {
+      includeArtifacts: true,
+      includeTranscript: false
+    },
+    serverUrl
+  ).catch(() => null);
+  const completedCount = Number.isFinite(inspection?.session?.checkpoint_count) ? Number(inspection.session.checkpoint_count) : 0;
+  if (completedCount <= 0 || completedCount >= translatedActions.length) {
+    return null;
+  }
+  const artifacts = Array.isArray(inspection?.artifacts) ? inspection.artifacts : [];
+  const checkpointScreenshotPath = getLatestScreenshotArtifactPath(artifacts);
+  if (!checkpointScreenshotPath) {
+    return null;
+  }
+  const ocrResult = await recognizeText(checkpointScreenshotPath, {
+    recognitionLevel: "accurate",
+    languages: ["en-US", "pt-BR"]
+  }).catch(() => null);
+  const visibleText = typeof ocrResult?.text === "string" ? ocrResult.text : "";
+  if (!ocrResult?.success || !visibleText.trim()) {
+    return null;
+  }
+  const currentIndex = completedCount;
+  const currentScore = scoreActionAgainstVisibleText(translatedActions[currentIndex], visibleText);
+  if (currentScore >= 0.7) {
+    return null;
+  }
+  const maxLookahead = Math.min(translatedActions.length, currentIndex + 3);
+  let matchedActionIndex = -1;
+  let matchedActionScore = 0;
+  for (let index = currentIndex + 1; index < maxLookahead; index += 1) {
+    const score = scoreActionAgainstVisibleText(translatedActions[index], visibleText);
+    if (score > matchedActionScore) {
+      matchedActionScore = score;
+      matchedActionIndex = index;
+    }
+  }
+  if (matchedActionIndex <= currentIndex || matchedActionScore < 0.7) {
+    const visibleActionCandidates = translatedActions.slice(currentIndex, maxLookahead).map((action) => getActionTextCandidates(action)[0] || String(action?.name || "action")).filter(Boolean);
+    const visionSelection = await selectVisibleActionFromScreenshot(
+      checkpointScreenshotPath,
+      visibleActionCandidates,
+      recoveryVisionProvider
+    ).catch(() => null);
+    if (!visionSelection?.selectedLabel) {
+      return null;
+    }
+    const selectedNormalized = normalizeMatchText(visionSelection.selectedLabel);
+    matchedActionIndex = translatedActions.findIndex((action, index) => {
+      if (index < currentIndex || index >= maxLookahead) return false;
+      return getActionTextCandidates(action).some((candidate) => normalizeMatchText(candidate) === selectedNormalized);
+    });
+    if (matchedActionIndex <= currentIndex) {
+      return null;
+    }
+  }
+  const prunedActions = translatedActions.filter((_, index) => index < currentIndex || index >= matchedActionIndex);
+  if (prunedActions.length === translatedActions.length) {
+    return null;
+  }
+  const prunedSkipped = translatedActions.slice(currentIndex, matchedActionIndex).map((action, offset) => ({
+    actionId: getTranslatedActionId(action, currentIndex + offset),
+    type: String(action?.name || "action"),
+    reason: "pruned after checkpoint OCR matched a later visible UI action"
+  }));
+  return {
+    strategy: "ios-visible-text-reconciliation",
+    prunedActions,
+    prunedSkipped,
+    checkpointScreenshotPath,
+    visibleTextPreview: previewVisibleText(visibleText),
+    resumeFromIndex: currentIndex,
+    matchedActionIndex,
+    matchedActionLabel: getActionTextCandidates(translatedActions[matchedActionIndex])[0] || null
+  };
+}
+function normalizeValidationOptions(input) {
+  if (typeof input === "string") {
+    return {
+      serverUrl: input
+    };
+  }
+  return input || {};
+}
+function normalizeRecordingAppId(appId) {
+  const value = String(appId || "").trim();
+  if (!value) return void 0;
+  if (value === "com.example.app") return void 0;
+  if (value.includes("# TODO")) return void 0;
+  return value;
+}
+function buildTextQueryVariants(value) {
+  const raw = String(value || "").trim().replace(/\s+/g, " ");
+  if (!raw) return [];
+  const variants = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (candidate) => {
+    const normalized = String(candidate || "").trim().replace(/\s+/g, " ");
+    if (!normalized || seen.has(normalized)) return;
+    seen.add(normalized);
+    variants.push(normalized);
+  };
+  push(raw);
+  const withoutContext = raw.replace(/\s+(?:in|inside|within|from|on)\s+.+$/i, "").trim();
+  push(withoutContext);
+  const withoutUiNoun = withoutContext.replace(/\s+(?:button|tab|icon|link|banner|card|item|field|input|modal|sheet|screen|section|row)$/i, "").trim();
+  push(withoutUiNoun);
+  const withoutCommonWords = withoutUiNoun.split(/\s+/).filter((part) => !["my", "the", "a", "an", "to", "for", "of"].includes(part.toLowerCase())).join(" ");
+  push(withoutCommonWords);
+  const firstSegment = withoutUiNoun.split(/\s*[\/>|-]\s*/)[0]?.trim();
+  push(firstSegment);
+  return variants;
+}
+function choosePrimaryTextQuery(value) {
+  const variants = buildTextQueryVariants(value);
+  if (variants.length === 0) return "";
+  return variants[variants.length - 1] || variants[0] || "";
+}
+function resolveCaptureLogcat(executor, captureLogcat) {
+  if (typeof captureLogcat === "boolean") return captureLogcat;
+  return executor === "adb";
+}
+function normalizeRequestedNetworkProfile(input, context) {
+  return buildAppLabNetworkProfile(input, context);
+}
+function getRequestedAppLabCaptureMode(profile) {
+  if (!profile || !isObject2(profile.capture)) return "";
+  const capture = profile.capture;
+  const applabMode = typeof capture.applabMode === "string" ? capture.applabMode.trim().toLowerCase() : "";
+  if (applabMode) return applabMode;
+  return typeof capture.mode === "string" ? capture.mode.trim().toLowerCase() : "";
+}
+function extractNetworkStateFromConfig(config) {
+  if (!isObject2(config?.network)) return null;
+  return config.network;
+}
+function mergeNetworkState(primary, fallback) {
+  if (!primary) return fallback;
+  if (!fallback) return primary;
+  return {
+    ...fallback,
+    ...primary,
+    active_profile: primary.active_profile ?? fallback.active_profile ?? null,
+    effective_profile: primary.effective_profile ?? fallback.effective_profile ?? null,
+    configured_at: primary.configured_at ?? fallback.configured_at ?? null,
+    managed_proxy: primary.managed_proxy ?? fallback.managed_proxy ?? null
+  };
+}
+function translateMaestroActionsToESVP(actions, options = {}) {
+  const translated = [];
+  const skipped = [];
+  const pushTranslated = (action, source, reason) => {
+    if (action) {
+      translated.push(action);
+      return;
+    }
+    skipped.push({
+      actionId: source.id,
+      type: source.type,
+      reason: reason || "unsupported"
+    });
+  };
+  for (const action of actions || []) {
+    switch (action.type) {
+      case "launch": {
+        const appId = String(action.appId || action.text || options.appId || "").trim();
+        pushTranslated(
+          appId ? {
+            name: "launch",
+            args: { appId },
+            checkpointAfter: true,
+            checkpointLabel: `launch:${appId}`
+          } : null,
+          action,
+          "launch is missing an appId"
+        );
+        break;
+      }
+      case "tap": {
+        if (typeof action.x === "number" && typeof action.y === "number") {
+          pushTranslated(
+            {
+              name: "tap",
+              args: {
+                x: Math.round(action.x),
+                y: Math.round(action.y)
+              },
+              checkpointAfter: true,
+              checkpointLabel: action.id
+            },
+            action
+          );
+        } else if (typeof action.text === "string" && action.text.trim()) {
+          const selector = choosePrimaryTextQuery(action.text);
+          const selectorVariants = buildTextQueryVariants(action.text);
+          pushTranslated(
+            {
+              name: "tap",
+              args: {
+                text: selector,
+                selector,
+                selectors: selectorVariants.map((candidate) => ({
+                  selector: candidate,
+                  label: candidate
+                }))
+              },
+              checkpointAfter: true,
+              checkpointLabel: action.id
+            },
+            action
+          );
+        } else {
+          pushTranslated(null, action, "tap is missing coordinates or a selector that can be translated to ESVP");
+        }
+        break;
+      }
+      case "swipe":
+      case "scroll": {
+        if (typeof action.x === "number" && typeof action.y === "number" && typeof action.endX === "number" && typeof action.endY === "number") {
+          pushTranslated(
+            {
+              name: "swipe",
+              args: {
+                x1: Math.round(action.x),
+                y1: Math.round(action.y),
+                x2: Math.round(action.endX),
+                y2: Math.round(action.endY),
+                durationMs: Math.max(120, Math.round(action.duration || 280))
+              },
+              checkpointAfter: true,
+              checkpointLabel: action.id
+            },
+            action
+          );
+        } else if (action.direction) {
+          pushTranslated(
+            {
+              name: "swipe",
+              args: {
+                direction: String(action.direction).toLowerCase()
+              },
+              checkpointAfter: true,
+              checkpointLabel: action.id
+            },
+            action
+          );
+        } else {
+          pushTranslated(null, action, "swipe/scroll is missing coordinates or direction");
+        }
+        break;
+      }
+      case "input": {
+        const text = typeof action.text === "string" ? action.text : "";
+        pushTranslated(
+          text ? {
+            name: "type",
+            args: { text },
+            checkpointAfter: true,
+            checkpointLabel: action.id
+          } : null,
+          action,
+          "input is missing text"
+        );
+        break;
+      }
+      case "back":
+        pushTranslated(
+          {
+            name: "back",
+            checkpointAfter: true,
+            checkpointLabel: action.id
+          },
+          action
+        );
+        break;
+      case "home":
+        pushTranslated(
+          {
+            name: "home",
+            checkpointAfter: true,
+            checkpointLabel: action.id
+          },
+          action
+        );
+        break;
+      case "pressKey": {
+        const key = typeof action.text === "string" ? action.text : "";
+        pushTranslated(
+          key ? {
+            name: "keyevent",
+            args: { key },
+            checkpointAfter: true,
+            checkpointLabel: action.id
+          } : null,
+          action,
+          "pressKey is missing a key value"
+        );
+        break;
+      }
+      case "wait": {
+        const ms = typeof action.seconds === "number" ? Math.max(0, Math.round(action.seconds * 1e3)) : 1e3;
+        pushTranslated(
+          {
+            name: "wait",
+            args: { ms },
+            checkpointAfter: true,
+            checkpointLabel: action.id
+          },
+          action
+        );
+        break;
+      }
+      default:
+        pushTranslated(null, action, `action type "${action.type}" is not supported by the ESVP adapter yet`);
+        break;
+    }
+  }
+  return {
+    actions: translated,
+    skipped
+  };
+}
+async function normalizeESVPNetworkArtifacts(sessionId, artifacts, serverUrl) {
+  const networkArtifacts = (artifacts || []).filter((artifact) => artifact?.kind === "network_trace" && typeof artifact?.path === "string");
+  const traceKinds = Array.from(
+    new Set(
+      networkArtifacts.map((artifact) => artifact?.meta && typeof artifact.meta === "object" ? String(artifact.meta.trace_kind || "") : "").filter(Boolean)
+    )
+  );
+  const entries = [];
+  for (const artifact of networkArtifacts) {
+    const artifactPath = String(artifact.path || "");
+    if (!artifactPath) continue;
+    try {
+      const payload = await getESVPArtifactContent(sessionId, artifactPath, serverUrl);
+      const meta = artifact.meta && typeof artifact.meta === "object" ? artifact.meta : {};
+      const traceKind = typeof meta.trace_kind === "string" ? meta.trace_kind : null;
+      entries.push(...normalizeNetworkPayloadToEntries(payload, {
+        traceKind,
+        artifactPath,
+        artifactMeta: meta
+      }));
+    } catch {
+    }
+  }
+  return {
+    networkEntries: entries.sort((a, b) => (a.startedAt || 0) - (b.startedAt || 0)),
+    networkCapture: createMobileNetworkCaptureMeta({
+      source: "esvp-mobile",
+      truncated: false,
+      maxEntries: Math.max(entries.length, 1200),
+      resourceTypes: traceKinds.length > 0 ? traceKinds : ["mobile-http-trace"]
+    }),
+    traceKinds
+  };
+}
+function normalizeNetworkPayloadToEntries(payload, context) {
+  const payloadRecord = parseEmbeddedObject(payload);
+  const nestedPayloadRecord = payloadRecord ? parseEmbeddedObject(payloadRecord.payload) : null;
+  const payloadLog = payloadRecord ? parseEmbeddedObject(payloadRecord.log) : null;
+  const nestedPayloadLog = nestedPayloadRecord ? parseEmbeddedObject(nestedPayloadRecord.log) : null;
+  if (context.traceKind === "har") {
+    if (payloadLog && Array.isArray(payloadLog.entries)) {
+      return normalizeHarEntries(payloadLog.entries, context);
+    }
+    if (nestedPayloadLog && Array.isArray(nestedPayloadLog.entries)) {
+      return normalizeHarEntries(nestedPayloadLog.entries, context);
+    }
+  }
+  const candidates = extractTraceCandidates(payload);
+  const normalized = candidates.map((candidate, index) => normalizeHttpTraceCandidate(candidate, index, context)).filter((entry) => entry !== null);
+  return normalized;
+}
+function normalizeHarEntries(entries, context) {
+  const normalized = [];
+  for (const [index, entry] of (entries || []).entries()) {
+    const requestUrl = String(entry?.request?.url || "").trim();
+    if (!requestUrl) continue;
+    const parsed = parseRequestUrl(requestUrl);
+    const startedAt = Date.parse(String(entry?.startedDateTime || ""));
+    const durationMs = numberOrNull(entry?.time);
+    const finishedAt = Number.isFinite(startedAt) && durationMs != null ? startedAt + durationMs : null;
+    const responseSize = numberOrNull(entry?.response?.content?.size) ?? numberOrNull(entry?.response?.bodySize);
+    const requestHeaders = toHeaderMap(entry?.request?.headers);
+    const responseHeaders = toHeaderMap(entry?.response?.headers);
+    normalized.push({
+      id: `net_${sanitizeIdentifier(context.artifactPath)}_${String(index + 1).padStart(4, "0")}`,
+      url: parsed.url,
+      origin: parsed.origin,
+      hostname: parsed.hostname,
+      pathname: parsed.pathname,
+      routeKey: parsed.routeKey,
+      method: String(entry?.request?.method || "GET").toUpperCase(),
+      resourceType: "har",
+      startedAt: Number.isFinite(startedAt) ? startedAt : Date.now(),
+      finishedAt,
+      durationMs,
+      status: numberOrNull(entry?.response?.status),
+      ok: typeof entry?.response?.status === "number" ? entry.response.status < 400 : null,
+      queryKeys: parsed.queryKeys,
+      requestContentType: requestHeaders["content-type"] || null,
+      responseContentType: responseHeaders["content-type"] || null,
+      responseSize,
+      failureText: typeof entry?.response?._error === "string" ? entry.response._error : null,
+      requestHeaders,
+      responseHeaders,
+      requestBodyPreview: null,
+      responseBodyPreview: null,
+      requestBodyBytes: null,
+      responseBodyBytes: responseSize
+    });
+  }
+  return normalized;
+}
+function normalizeHttpTraceCandidate(candidate, index, context) {
+  if (!isObject2(candidate)) return null;
+  const request = isObject2(candidate.request) ? candidate.request : candidate;
+  const response = isObject2(candidate.response) ? candidate.response : null;
+  const url = firstString(
+    candidate.url,
+    request.url,
+    context.artifactMeta.url
+  );
+  if (!url) return null;
+  const parsed = parseRequestUrl(url);
+  const method = firstString(candidate.method, request.method, context.artifactMeta.method) || "GET";
+  const status = firstNumber(
+    candidate.status,
+    candidate.statusCode,
+    response?.status,
+    response?.statusCode,
+    context.artifactMeta.status_code
+  );
+  const durationMs = firstNumber(
+    candidate.durationMs,
+    candidate.duration_ms,
+    response?.durationMs,
+    response?.duration_ms,
+    response?.time_ms,
+    candidate.timeMs
+  );
+  const startedAt = firstTimestamp(
+    candidate.startedAt,
+    candidate.started_at,
+    candidate.timestamp,
+    candidate.ts,
+    request.startedAt,
+    request.timestamp,
+    request.ts
+  ) ?? Date.now();
+  const finishedAt = durationMs != null ? startedAt + durationMs : firstTimestamp(candidate.finishedAt, candidate.finished_at) ?? null;
+  const requestHeaders = mergeHeaderObjects(
+    candidate.requestHeaders,
+    candidate.request_headers,
+    request.headers
+  );
+  const responseHeaders = mergeHeaderObjects(
+    candidate.responseHeaders,
+    candidate.response_headers,
+    response?.headers
+  );
+  const requestBodyPreview = firstString(
+    candidate.requestBodyPreview,
+    candidate.request_body_preview,
+    request.bodyPreview,
+    request.body_preview
+  );
+  const responseBodyPreview = firstString(
+    candidate.responseBodyPreview,
+    candidate.response_body_preview,
+    response?.bodyPreview,
+    response?.body_preview
+  );
+  const requestBodyBytes = firstNumber(
+    candidate.requestBodyBytes,
+    candidate.request_body_bytes,
+    request.bodyBytes,
+    request.body_bytes
+  );
+  const responseSize = firstNumber(
+    candidate.responseBodyBytes,
+    candidate.response_body_bytes,
+    candidate.responseSize,
+    candidate.response_size,
+    response?.size,
+    response?.bodyBytes,
+    response?.body_bytes,
+    response?.contentLength,
+    responseHeaders["content-length"]
+  );
+  const failureText = firstString(
+    candidate.failureText,
+    candidate.error,
+    response?.error,
+    response?.failureText
+  );
+  return {
+    id: `net_${sanitizeIdentifier(context.artifactPath)}_${String(index + 1).padStart(4, "0")}`,
+    url: parsed.url,
+    origin: parsed.origin,
+    hostname: parsed.hostname,
+    pathname: parsed.pathname,
+    routeKey: parsed.routeKey,
+    method: String(method).toUpperCase(),
+    resourceType: firstString(candidate.resourceType, candidate.kind, context.traceKind) || "request",
+    startedAt,
+    finishedAt,
+    durationMs,
+    status,
+    ok: status != null ? status < 400 : null,
+    queryKeys: parsed.queryKeys,
+    requestContentType: firstString(
+      candidate.requestContentType,
+      request.contentType,
+      requestHeaders["content-type"]
+    ),
+    responseContentType: firstString(
+      candidate.responseContentType,
+      response?.contentType,
+      responseHeaders["content-type"]
+    ),
+    responseSize,
+    failureText,
+    requestHeaders,
+    responseHeaders,
+    requestBodyPreview,
+    responseBodyPreview,
+    requestBodyBytes,
+    responseBodyBytes: responseSize
+  };
+}
+function extractTraceCandidates(payload) {
+  if (Array.isArray(payload)) return payload;
+  const payloadRecord = parseEmbeddedObject(payload);
+  if (!payloadRecord) return [];
+  const nestedCandidates = [
+    payloadRecord,
+    parseEmbeddedObject(payloadRecord.payload),
+    parseEmbeddedObject(payloadRecord.data),
+    parseEmbeddedObject(payloadRecord.trace),
+    parseEmbeddedObject(payloadRecord.result)
+  ].filter(Boolean);
+  for (const candidate of nestedCandidates) {
+    if (Array.isArray(candidate.entries)) return candidate.entries;
+    if (Array.isArray(candidate.requests)) return candidate.requests;
+    if (Array.isArray(candidate.events)) return candidate.events;
+    if (Array.isArray(candidate.items)) return candidate.items;
+  }
+  return [payload];
+}
+function parseRequestUrl(rawUrl) {
+  try {
+    const parsed = new URL(rawUrl);
+    const pathname = parsed.pathname || "/";
+    const queryKeys = Array.from(new Set(Array.from(parsed.searchParams.keys()).filter(Boolean))).sort();
+    return {
+      url: buildDisplayUrl(parsed.origin, pathname),
+      origin: parsed.origin,
+      hostname: parsed.hostname,
+      pathname,
+      routeKey: `${parsed.hostname}${pathname}`,
+      queryKeys
+    };
+  } catch {
+    const [baseWithoutQuery] = String(rawUrl).split("?");
+    const [baseWithoutFragment] = String(baseWithoutQuery || rawUrl).split("#");
+    return {
+      url: baseWithoutFragment || rawUrl,
+      origin: "",
+      hostname: "unknown host",
+      pathname: "/",
+      routeKey: rawUrl,
+      queryKeys: []
+    };
+  }
+}
+function buildDisplayUrl(origin, pathname) {
+  if (origin) return `${origin}${pathname || "/"}`;
+  return pathname || "/";
+}
+function sanitizeIdentifier(value) {
+  return String(value || "").replace(/[^a-zA-Z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40) || "trace";
+}
+function toHeaderMap(entries) {
+  if (!Array.isArray(entries)) return {};
+  return entries.reduce((acc, item) => {
+    if (!isObject2(item)) return acc;
+    const key = firstString(item.name, item.key);
+    if (!key) return acc;
+    const value = firstString(item.value) || "";
+    acc[key.toLowerCase()] = value;
+    return acc;
+  }, {});
+}
+function headerObject(value) {
+  if (!value) return {};
+  if (Array.isArray(value)) return toHeaderMap(value);
+  if (!isObject2(value)) return {};
+  return Object.entries(value).reduce((acc, [key, entryValue]) => {
+    acc[String(key).toLowerCase()] = String(entryValue);
+    return acc;
+  }, {});
+}
+function mergeHeaderObjects(...values) {
+  return values.reduce((acc, value) => {
+    const headers = headerObject(value);
+    if (!headers || Object.keys(headers).length === 0) return acc;
+    return {
+      ...acc,
+      ...headers
+    };
+  }, {});
+}
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return null;
+}
+function firstNumber(...values) {
+  for (const value of values) {
+    const numeric = numberOrNull(value);
+    if (numeric != null) return numeric;
+  }
+  return null;
+}
+function firstTimestamp(...values) {
+  for (const value of values) {
+    if (typeof value === "number" && Number.isFinite(value)) return value;
+    if (typeof value === "string" && value.trim()) {
+      const direct = Number(value);
+      if (Number.isFinite(direct)) return direct;
+      const parsed = Date.parse(value);
+      if (Number.isFinite(parsed)) return parsed;
+    }
+  }
+  return null;
+}
+function numberOrNull(value) {
+  if (value == null || value === "") return null;
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+}
+function parseEmbeddedObject(value) {
+  if (isObject2(value)) return value;
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return isObject2(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export {
+  analyzeScreenshotsForActions,
+  generateMaestroYaml,
+  ensureLocalCaptureProxyProfile,
+  listLocalCaptureProxyStates,
+  finalizeAllLocalCaptureProxySessions,
+  finalizeLocalCaptureProxySession,
+  startLocalAppHttpTraceCollector,
+  resolveLocalAppHttpTraceCollectorById,
+  getLocalAppHttpTraceBootstrap,
+  ingestLocalAppHttpTrace,
+  finalizeLocalAppHttpTraceCollector,
+  createMobileNetworkCaptureMeta,
+  diagnoseESVPNetworkState,
+  collectESVPSessionNetworkData,
+  validateMaestroRecordingWithESVP,
+  translateMaestroActionsToESVP
+};