@deeeed/metamask-harness 0.74.0 → 0.75.0

package/dist/recording-target.js

@@ -6,45 +6,10 @@ const IOS_SIMULATOR_RECORDING_TARGET_PREFIX = "ios-simulator:";
 function createMetaMaskRecordingTargetProvider(adapter) {
   return {
     async resolveRecordingTarget(context) {
-      if (adapter === "extension") {
-        const pid = resolveExtensionBrowserPid(
-          context.projectRoot,
-          context.artifactsDir,
-          context.env.CDP_PORT ?? context.env.RECIPE_CDP_PORT ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT
-        );
-        if (!pid) {
-          throw new Error(
-            "Could not resolve the extension browser PID for --record-video. Ensure the slot browser is running and CDP_PORT is set."
-          );
-        }
-        return { kind: "pid", pid };
-      }
-      if (adapter === "mobile") {
-        const platform = (context.env.PLATFORM ?? process.env.PLATFORM ?? "ios").trim().toLowerCase();
-        const androidSerial = resolveAndroidDeviceSerial(context.env);
-        if (platform === "android" || androidSerial) {
-          if (!androidSerial) {
-            throw new Error(
-              "Could not resolve an Android device for --record-video. Set ADB_SERIAL or pass --device to mm-harness run."
-            );
-          }
-          return {
-            kind: "android-device",
-            serial: androidSerial
-          };
-        }
-        const simulator = resolveMobileIosSimulatorName(context.env);
-        if (!simulator) {
-          throw new Error(
-            "Could not resolve an iOS simulator name for --record-video. Set IOS_SIMULATOR or pass --simulator to the recipe hook."
-          );
-        }
-        return {
-          kind: "window-id",
-          windowId: `${IOS_SIMULATOR_RECORDING_TARGET_PREFIX}${simulator}`
-        };
-      }
-      throw new Error(`--record-video is not implemented for the ${adapter} adapter.`);
+      const { getAdapterSurface } = await import("./adapters/surface.js");
+      const recording = getAdapterSurface(adapter).recording;
+      if (!recording) throw new Error(`--record-video is not implemented for the ${adapter} adapter.`);
+      return recording.target(context);
     }
   };
 }

package/dist/run-diagnostics.js

@@ -1,20 +1,10 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createHash } from "node:crypto";
-import { spawnSync } from "node:child_process";
 import { getAdapterSurface } from "./adapters/surface.js";
-import { recipeRuntimePath, runnerDir } from "./paths.js";
-import { ensureExtensionConsoleCapture, extensionCaptureFiles, extensionCdpPort } from "./adapters/extension/console-capture.js";
-import {
-  ensureTerminalConsoleCapture,
-  terminalCaptureFiles,
-  terminalCdpPort,
-  terminalRuntimeFile
-} from "./adapters/terminal/console-capture.js";
 import {
   collectorOwnerMarker,
-  collectorStatus,
-  verifyCapture
+  collectorStatus
 } from "../library/actions/shared/console-collector.mjs";
 import {
   allowlistMatch,
@@ -39,7 +29,7 @@ function readRunDiagnosticsDocument(diagnosticsPath) {
 }
 function formatRunDiagnosticsForHuman(diagnostics, adapter) {
   if (!diagnostics) {
-    return [adapter === "core" ? "N/A \u2014 Core is headless and has no application log source." : "UNAVAILABLE \u2014 application diagnostics could not be collected for this run."];
+    return [getAdapterSurface(adapter).headless ? `N/A \u2014 ${adapter.charAt(0).toUpperCase()}${adapter.slice(1)} is headless and has no application log source.` : "UNAVAILABLE \u2014 application diagnostics could not be collected for this run."];
   }
   const status = diagnostics.status === "clean" ? "CLEAN" : diagnostics.status === "review" ? "REVIEW" : "UNAVAILABLE";
   const lines = [`${status} \u2014 ${diagnostics.note}`];
@@ -52,25 +42,27 @@ function formatRunDiagnosticsForHuman(diagnostics, adapter) {
   return lines;
 }
 async function beginRunDiagnostics(adapter, projectRoot) {
-  const source = getAdapterSurface(adapter).appLogSource(projectRoot);
+  const surface = getAdapterSurface(adapter);
+  const source = surface.appLogSource(projectRoot);
   if (!source) return null;
-  const mobileIssueBuffer = adapter === "mobile" && process.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME !== "1" && armMobileIssueBuffer(projectRoot) ? { projectRoot } : void 0;
+  const diagnostics = surface.diagnostics;
+  const issueBuffer = diagnostics?.issueBuffer?.arm(projectRoot) ? { adapter, projectRoot } : void 0;
   let capture;
-  if (adapter === "extension" || adapter === "terminal") {
-    const start = adapter === "extension" ? ensureExtensionConsoleCapture : ensureTerminalConsoleCapture;
-    const startError = await start(projectRoot).then(() => void 0, (error) => error instanceof Error ? error.message : String(error));
-    const { extensionLog, pageLog, pidFile } = adapter === "extension" ? extensionCaptureFiles(projectRoot) : terminalCaptureFiles(projectRoot);
-    const cdpPort = adapter === "extension" ? extensionCdpPort() : terminalCdpPort();
+  if (diagnostics?.console) {
+    const collector = diagnostics.console;
+    const startError = await collector.start(projectRoot).then(() => void 0, (error) => error instanceof Error ? error.message : String(error));
+    const { extensionLog, pageLog, pidFile } = collector.files(projectRoot);
+    const cdpPort = collector.cdpPort();
     capture = { adapter, projectRoot, extensionLog, pageLog, pidFile, ...cdpPort ? { cdpPort } : {}, ...startError ? { startError } : {} };
   }
-  const walletLogPath = adapter === "terminal" ? terminalRuntimeFile(projectRoot, "wallet-requests.jsonl") : null;
+  const walletLogPath = diagnostics?.walletLog?.(projectRoot) ?? null;
   const walletStat = walletLogPath ? safeStat(walletLogPath) : null;
   const stat = safeStat(source.path);
   return {
     source,
     offset: stat?.size ?? 0,
     ...stat ? { inode: stat.ino } : {},
-    ...mobileIssueBuffer ? { mobileIssueBuffer } : {},
+    ...issueBuffer ? { issueBuffer } : {},
     ...capture ? { capture } : {},
     ...walletLogPath ? { walletLog: { path: walletLogPath, offset: walletStat?.size ?? 0, ...walletStat ? { inode: walletStat.ino } : {} } } : {}
   };
@@ -85,20 +77,13 @@ async function verifyConsoleCapture(capture) {
     cdpPort: capture.cdpPort
   });
   if (!status.ok) return { verified: false, detail: status.detail };
-  let control;
-  if (capture.adapter === "extension") {
-    let extensionId = null;
-    try {
-      extensionId = fs.readFileSync(recipeRuntimePath(capture.projectRoot, "extension.id"), "utf8").trim();
-    } catch {
-      extensionId = null;
-    }
-    control = await verifyCapture({ cdpPort: capture.cdpPort, log: capture.extensionLog, target: "extension", extensionId });
-  } else {
-    const browser = readJsonRecord(terminalRuntimeFile(capture.projectRoot, "browser.json"));
-    if (typeof browser?.appOrigin !== "string") return { verified: false, detail: "no slot browser state (browser.json) to verify the page console capture against" };
-    control = await verifyCapture({ cdpPort: capture.cdpPort, log: capture.pageLog, target: "page", appOrigin: browser.appOrigin });
-  }
+  const control = await getAdapterSurface(capture.adapter).diagnostics.console.verifyControl({
+    projectRoot: capture.projectRoot,
+    cdpPort: capture.cdpPort,
+    extensionLog: capture.extensionLog,
+    pageLog: capture.pageLog,
+    pidFile: capture.pidFile
+  });
   return { verified: control.ok, detail: control.ok ? `${status.detail}; ${control.detail}` : control.detail };
 }
 function isRunDiagnosticsDocument(value) {
@@ -109,7 +94,7 @@ function isRunDiagnosticsDocument(value) {
 async function finishRunDiagnostics(baseline, result) {
   if (!baseline) return result;
   try {
-    const bufferedIssues = baseline.mobileIssueBuffer ? collectMobileIssueBuffer(baseline.mobileIssueBuffer.projectRoot) : void 0;
+    const bufferedIssues = baseline.issueBuffer ? getAdapterSurface(baseline.issueBuffer.adapter).diagnostics?.issueBuffer?.collect(baseline.issueBuffer.projectRoot) : void 0;
     const allowlist = loadConsoleAllowlist(recipeLibraryRoots(result.summaryPath));
     const capture = baseline.capture ? await verifyConsoleCapture(baseline.capture) : void 0;
     const { diagnostics, rawAppLog } = collectRunDiagnosticsCapture(baseline, bufferedIssues, allowlist, capture);
@@ -271,30 +256,6 @@ function applyConsoleAllowlist(findings, allowlist) {
     finding.fingerprint = createHash("sha256").update(`${finding.fingerprint}|info|${match.file}#${match.index}`).digest("hex").slice(0, 12);
   }
 }
-function armMobileIssueBuffer(projectRoot) {
-  const armed = runMobileIssueCommand(projectRoot, "issues-arm");
-  if (!armed) return false;
-  return runMobileIssueCommand(projectRoot, "issues-collect") !== null;
-}
-function collectMobileIssueBuffer(projectRoot) {
-  const result = runMobileIssueCommand(projectRoot, "issues-collect");
-  return isRecord(result) && Array.isArray(result.entries) ? result.entries : null;
-}
-function runMobileIssueCommand(projectRoot, command) {
-  const bridge = path.join(runnerDir, "adapters", "mobile", "bridge-runtime", "cdp-bridge.cjs");
-  const result = spawnSync(process.execPath, [bridge, command], {
-    cwd: projectRoot,
-    env: { ...process.env, APP_ROOT: projectRoot, CDP_TIMEOUT: "5000" },
-    encoding: "utf8",
-    timeout: 1e4
-  });
-  if (result.status !== 0) return null;
-  try {
-    return JSON.parse(result.stdout.trim());
-  } catch {
-    return null;
-  }
-}
 function redactPreview(value) {
   return redactDiagnosticText(value).slice(0, MAX_PREVIEW_CHARS);
 }

package/dist/run-recording.js

@@ -2,10 +2,10 @@ import { spawn, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { optionalVideoTiming, readCaptureHelperTiming, writeRecordingTimeline } from "@farmslot/recipe-harness";
+import { getAdapterSurface } from "./adapters/surface.js";
 import {
   captureHelperSupportsRecordSessionSnapshots,
-  captureHelperSupportsCapability,
-  resolveExtensionBrowserPid
+  captureHelperSupportsCapability
 } from "./recording-target.js";
 const activeRecordingsByPid = /* @__PURE__ */ new Map();
 const ACTIVE_EXTENSION_RECORDING_PID = "METAMASK_RECIPE_EXTENSION_ACTIVE_RECORDING_PID";
@@ -17,7 +17,8 @@ async function startRecipeRecording(adapter, projectRoot, artifactsDir, options)
     );
     return void 0;
   }
-  if (adapter !== "extension") return void 0;
+  const framed = getAdapterSurface(adapter).recording?.framed;
+  if (!framed) return void 0;
   const cdpPort = options.cdpPort ?? process.env.CDP_PORT ?? process.env.RECIPE_CDP_PORT;
   if (!captureHelperSupportsRecordSessionSnapshots(projectRoot)) {
     console.error(
@@ -25,7 +26,7 @@ async function startRecipeRecording(adapter, projectRoot, artifactsDir, options)
     );
     return void 0;
   }
-  const pid = resolveExtensionBrowserPid(projectRoot, artifactsDir, cdpPort);
+  const pid = framed.browserPid(projectRoot, artifactsDir, cdpPort);
   if (!pid) {
     console.error(
       `WARN: framed extension recording could not resolve browser PID from CDP port ${cdpPort ?? "<unset>"}; falling back to harness --record-video.`

package/dist/runner.js

@@ -1,27 +1,10 @@
-import { execFileSync, execSync } from "node:child_process";
+import { execSync } from "node:child_process";
 import { OFFICIAL_RECIPE_ACTIONS } from "@farmslot/protocol";
-import { createAndroidMirrorVideoRecorder } from "@farmslot/recipe-harness";
 import { createMetaMaskAdapters, createMetaMaskUiTransport } from "./adapters.js";
-import {
-  bridgeCommand,
-  MOBILE_BRIDGE_ERROR_CODES
-} from "../library/actions/mobile/platform/bridge.mjs";
-import { resolveMobileToolPath } from "../library/actions/mobile/platform/tool-paths.mjs";
-import {
-  mobileSourceFingerprint,
-  recordMobileSourceBaseline
-} from "./adapters/mobile/source-freshness.js";
-import { readAndroidNativeRuntimeIdentity } from "./adapters/mobile/release-artifact.js";
-import { readMobileReleaseArtifactState } from "./adapters/mobile/release-artifact-state.js";
-import {
-  createAndroidVideoRecorder,
-  createIosSimulatorVideoRecorder
-} from "./adapters/mobile/video-recorder.js";
+import { getAdapterSurface } from "./adapters/surface.js";
 import {
   bindMetaMaskMobileLifecycleDeadline,
   createMetaMaskMobileLifecycleCommandRunner,
-  MOBILE_LIFECYCLE_DEADLINE_FIELD,
-  MOBILE_LIFECYCLE_PREPARED,
   resolveMetaMaskMobileLifecycleTarget
 } from "./app-lifecycle.js";
 import { loadMetaMaskExtensionActionManifest, loadMetaMaskMobileActionManifest } from "./manifest.js";
@@ -29,11 +12,7 @@ import { actionSourceIntegrity, metaMaskActionExecutionCapabilities } from "./re
 import {
   prepareLiveAdapterScript
 } from "./live-adapter-contract.js";
-import {
-  createMetaMaskRecordingTargetProvider,
-  resolveAndroidDeviceSerial,
-  resolveMobileIosSimulatorName
-} from "./recording-target.js";
+import { createMetaMaskRecordingTargetProvider } from "./recording-target.js";
 import {
   importMetaMaskNativeUiProvider,
   importRecipeHarness,
@@ -92,16 +71,15 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     }, preparedLiveAdapters, { hudPolicy: options.autoHud === true ? "show" : "auto" })
   });
   const existing = new Set([...core, ...ui].map((entry) => entry.action));
-  const lifecycle = mobileSourceAwareLifecycleAdapters(
-    adapter,
-    bindMetaMaskMobileLifecycleDeadline(
-      createAppLifecycleAdapters({
-        actions,
-        commandRunner: createMetaMaskMobileLifecycleCommandRunner(),
-        targetProvider: { resolveTarget: resolveMetaMaskMobileLifecycleTarget }
-      })
-    )
+  const surface = getAdapterSurface(adapter);
+  const lifecycleAdapters = bindMetaMaskMobileLifecycleDeadline(
+    createAppLifecycleAdapters({
+      actions,
+      commandRunner: createMetaMaskMobileLifecycleCommandRunner(),
+      targetProvider: { resolveTarget: resolveMetaMaskMobileLifecycleTarget }
+    })
   );
+  const lifecycle = surface.actions.lifecycle ? await surface.actions.lifecycle(lifecycleAdapters) : lifecycleAdapters;
   const custom = createMetaMaskAdapters(
     adapter,
     customActions,
@@ -117,31 +95,22 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     options.quietStdout ? new console.Console(process.stderr) : console,
     options.suppressLibraryResolutionLogs
   );
-  const androidRecordingSerial = adapter === "mobile" ? resolveAndroidDeviceSerial() : void 0;
-  const iosRecordingSimulator = adapter === "mobile" && !androidRecordingSerial ? resolveMobileIosSimulatorName() : void 0;
+  const videoRecorder = await surface.recording?.videoRecorder?.();
+  const secured = [...core, ...ui, ...lifecycle, ...custom].map((entry) => ({
+    ...entry,
+    ...adapterSecurity(entry.action, actionSources, options.trustTaskActions)
+  }));
+  const mutationBound = surface.actions.trustedMutation ? withTrustedMutationContext(secured, options.trustedMutation, externalMutationActions) : secured;
   return createRecipeRunner({
     actionManifest,
     adapters: withActionProgress(
-      withMobileNativeRuntimeIdentity(
-        adapter,
-        withTrustedMutationContext(
-          [...core, ...ui, ...lifecycle, ...custom].map((entry) => ({
-            ...entry,
-            ...adapterSecurity(entry.action, actionSources, options.trustTaskActions)
-          })),
-          options.trustedMutation,
-          externalMutationActions,
-          adapter
-        )
-      ),
+      surface.actions.wrap ? await surface.actions.wrap(mutationBound) : mutationBound,
       options.onActionEvent
     ),
     logger,
     recording: {
       targetProvider: createMetaMaskRecordingTargetProvider(adapter),
-      ...androidRecordingSerial ? { videoRecorder: createAndroidMirrorVideoRecorder({ serial: androidRecordingSerial, fallback: createAndroidVideoRecorder(androidRecordingSerial) }) } : iosRecordingSimulator ? {
-        videoRecorder: createIosSimulatorVideoRecorder(iosRecordingSimulator)
-      } : {}
+      ...videoRecorder ? { videoRecorder } : {}
     },
     runner: runnerProvenance(),
     defaultSource: {
@@ -161,38 +130,7 @@ async function createMetaMaskRunner(adapter, actionManifest, options = {}) {
     }
   });
 }
-function withMobileNativeRuntimeIdentity(adapter, adapters, identity = {
-  state: readMobileReleaseArtifactState,
-  read: readAndroidNativeRuntimeIdentity
-}) {
-  if (adapter !== "mobile") return adapters;
-  return adapters.map((entry) => ({
-    ...entry,
-    async execute(node, context) {
-      const state = identity.state(context.projectRoot);
-      if (!state) {
-        if (context.env.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1") {
-          throw new Error("Mobile release-artifact actions require current trusted runtime state. Next: rerun runtime-launch with the exact artifact.");
-        }
-        return entry.execute(node, context);
-      }
-      identity.read(state);
-      const result = await entry.execute(node, context);
-      const nativeRuntimeIdentity = identity.read(state);
-      const output = result.output && typeof result.output === "object" && !Array.isArray(result.output) ? result.output : { result: result.output };
-      return {
-        ...result,
-        output: {
-          ...output,
-          nativeRuntimeIdentity,
-          runtimeSessionId: nativeRuntimeIdentity.runtimeSessionId
-        }
-      };
-    }
-  }));
-}
-function withTrustedMutationContext(adapters, base, externalMutationActions, adapter = "extension") {
-  if (adapter !== "extension") return adapters;
+function withTrustedMutationContext(adapters, base, externalMutationActions) {
   let selectedIdentitySha256;
   const identityProofAction = "metamask.wallet.import";
   const identityInvalidatingActions = /* @__PURE__ */ new Set([
@@ -353,289 +291,6 @@ function isAutomaticHudProgress(action, node, nodeId) {
   const progress = payload.progress;
   return nodeId === "recipe-complete" && progress !== null && typeof progress === "object" && !Array.isArray(progress) && progress.complete === true;
 }
-function mobileSourceAwareLifecycleAdapters(adapter, lifecycle, readinessProbe = probeMobileLifecycleRuntime, sourceFreshness = {
-  fingerprint: mobileSourceFingerprint,
-  record: recordMobileSourceBaseline
-}, processIdentity = {
-  readIosPid: readIosAppPid,
-  readAndroidPid: readAndroidAppPid
-}, runtimeMarker = readMobileLifecycleRuntimeIdentity) {
-  if (adapter !== "mobile") return lifecycle;
-  return lifecycle.map((entry) => ({
-    ...entry,
-    async execute(node, context) {
-      const command = node.command ?? node.event ?? node.state;
-      const opaqueRuntime = context.env?.METAMASK_RECIPE_MOBILE_OPAQUE_RUNTIME === "1";
-      const requiresProcessContinuity = command !== "restart" && node.require_process_continuity === true;
-      if (opaqueRuntime && !requiresProcessContinuity) {
-        return entry.execute(node, context);
-      }
-      const reloadsSource = !opaqueRuntime && (command === "launch" || command === "foreground" || command === "restart");
-      const recordsSource = !opaqueRuntime && command === "restart";
-      const androidLifecycle = isAndroidLifecycle(node, context.env ?? {});
-      const checksIosContinuity = command === "foreground" && !androidLifecycle;
-      const checksRequiredContinuity = requiresProcessContinuity;
-      const recordsProcessIdentity = checksIosContinuity || checksRequiredContinuity;
-      const readProcessId = androidLifecycle ? processIdentity.readAndroidPid ?? readAndroidAppPid : processIdentity.readIosPid;
-      const processBefore = recordsProcessIdentity ? readProcessId(node, context) : void 0;
-      const fingerprint = recordsSource ? sourceFreshness.fingerprint(context.projectRoot) : void 0;
-      const previousRuntimeIdentity = recordsSource ? await runtimeMarker(node, context) : void 0;
-      const androidRestart = command === "restart" && androidLifecycle;
-      const initialResult = await entry.execute(node, context);
-      const readinessDeadline = reloadsSource ? mobileLifecycleReadinessDeadline(command, node) : void 0;
-      let result = initialResult;
-      let runtimeReady = false;
-      if (androidRestart) {
-        try {
-          const remainingMs = Math.max(
-            1,
-            (readinessDeadline ?? Date.now()) - Date.now()
-          );
-          const handoffDeadline = Math.min(
-            readinessDeadline ?? Number.POSITIVE_INFINITY,
-            Date.now() + Math.min(1e4, Math.max(1, remainingMs / 2))
-          );
-          await readinessProbe(
-            node,
-            context,
-            previousRuntimeIdentity,
-            handoffDeadline
-          );
-          runtimeReady = true;
-        } catch (error) {
-          if (readinessDeadline !== void 0 && Date.now() >= readinessDeadline) {
-            throw error;
-          }
-          const foregroundTimeoutMs = Math.max(
-            1,
-            (readinessDeadline ?? Date.now() + 1) - Date.now()
-          );
-          const foregroundResult = await entry.execute(
-            {
-              ...node,
-              command: "foreground",
-              settle_ms: 0,
-              timeout_ms: foregroundTimeoutMs,
-              [MOBILE_LIFECYCLE_DEADLINE_FIELD]: readinessDeadline,
-              [MOBILE_LIFECYCLE_PREPARED]: true
-            },
-            context
-          );
-          result = mergeAndroidRestartResults(initialResult, foregroundResult);
-        }
-      }
-      if (reloadsSource && !runtimeReady) {
-        if (readinessDeadline !== void 0 && Date.now() >= readinessDeadline) {
-          throw new Error(
-            `Mobile lifecycle ${String(command)} exhausted its runtime readiness deadline before recovery completed.`
-          );
-        }
-        await readinessProbe(
-          node,
-          context,
-          previousRuntimeIdentity,
-          readinessDeadline
-        );
-      }
-      if (recordsProcessIdentity) {
-        const processAfter = readProcessId(node, context);
-        const processPreserved = processBefore !== null && processBefore === processAfter;
-        const actualTransition = processPreserved ? command === "background" ? "background_same_process" : "foreground_resume" : processAfter !== null ? "cold_relaunch" : "unknown";
-        const processContinuity = processPreserved ? "preserved" : processAfter === null ? "unknown" : "changed";
-        const resultRecord = asRecord(result);
-        result = {
-          ...resultRecord,
-          output: {
-            ...asRecord(resultRecord.output),
-            actualTransition,
-            processContinuity,
-            processBefore,
-            processAfter
-          }
-        };
-        if (checksRequiredContinuity && !processPreserved) {
-          const platform = androidLifecycle ? "Android" : "iOS";
-          throw new Error(
-            `${platform} ${String(command)} did not prove app-process continuity (actualTransition=${actualTransition}, before=${String(processBefore)}, after=${String(processAfter)}); this lifecycle sample cannot be classified as a same-process reconnect.`
-          );
-        }
-      }
-      if (fingerprint !== void 0 && !sourceFreshness.record(context.projectRoot, fingerprint)) {
-        throw new Error(
-          "Mobile source changed while the app was reloading; the loaded-source baseline was not recorded. Next: retry app.lifecycle restart."
-        );
-      }
-      return result;
-    }
-  }));
-}
-function readAndroidAppPid(node, context) {
-  const env = context.env ?? {};
-  const device = node.adb_serial ?? node.android_device ?? node.device ?? env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? process.env.ADB_SERIAL ?? process.env.ANDROID_SERIAL;
-  const packageId = node.package_id ?? node.packageName ?? node.app_id ?? env.ANDROID_PACKAGE_ID ?? process.env.ANDROID_PACKAGE_ID ?? "io.metamask";
-  if (typeof device !== "string" || typeof packageId !== "string") return null;
-  try {
-    const adb = resolveMobileToolPath("adb", { required: true });
-    const output = execFileSync(
-      adb,
-      ["-s", device, "shell", "pidof", packageId],
-      { encoding: "utf8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }
-    );
-    const pid = Number.parseInt(output.trim().split(/\s+/u)[0] ?? "", 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
-}
-function readIosAppPid(node, context) {
-  const env = context.env ?? {};
-  const device = node.simulator ?? node.ios_simulator ?? env.SIM_UDID ?? env.IOS_SIMULATOR ?? process.env.SIM_UDID ?? process.env.IOS_SIMULATOR;
-  const bundleId = node.bundle_id ?? node.bundleId ?? env.IOS_BUNDLE_ID ?? process.env.IOS_BUNDLE_ID ?? "io.metamask.MetaMask";
-  if (typeof device !== "string" || typeof bundleId !== "string") return null;
-  try {
-    const output = execFileSync(
-      "xcrun",
-      ["simctl", "spawn", device, "launchctl", "list"],
-      { encoding: "utf8", timeout: 5e3 }
-    );
-    const labelPrefix = `UIKitApplication:${bundleId}[`;
-    const line = output.split("\n").find((candidate) => candidate.includes(labelPrefix));
-    if (!line) return null;
-    const pid = Number.parseInt(line.trim().split(/\s+/u)[0] ?? "", 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
-}
-function isAndroidLifecycle(node, env) {
-  const platform = node.platform ?? env.PLATFORM ?? process.env.PLATFORM;
-  if (platform === "android") return true;
-  if (platform === "ios") return false;
-  return Boolean(
-    node.adb_serial ?? node.android_device ?? env.ADB_SERIAL ?? env.ANDROID_SERIAL ?? process.env.ADB_SERIAL ?? process.env.ANDROID_SERIAL
-  );
-}
-function mergeAndroidRestartResults(initialResult, foregroundResult) {
-  const initial = asRecord(initialResult);
-  const foreground = asRecord(foregroundResult);
-  const initialOutput = asRecord(initial.output);
-  const foregroundOutput = asRecord(foreground.output);
-  return {
-    ...initial,
-    output: {
-      ...initialOutput,
-      command: "restart",
-      calls: [
-        ...Array.isArray(initialOutput.calls) ? initialOutput.calls : [],
-        ...Array.isArray(foregroundOutput.calls) ? foregroundOutput.calls : []
-      ],
-      settleMs: foregroundOutput.settleMs ?? initialOutput.settleMs ?? 0,
-      foregroundEnsured: true
-    }
-  };
-}
-async function probeMobileLifecycleRuntime(node, context, previousRuntimeIdentity, deadlineMs) {
-  const command = node.command ?? node.event ?? node.state;
-  const timeoutMs = resolveMobileLifecycleReadinessTimeout(
-    command,
-    node.runtime_ready_timeout_ms
-  );
-  const startedAt = Date.now();
-  const deadline = deadlineMs ?? startedAt + timeoutMs;
-  let lastError;
-  while (Date.now() < deadline) {
-    try {
-      const status = await bridgeCommand(
-        {
-          action: "app.lifecycle",
-          node: {
-            ...node,
-            cdp_timeout_ms: Math.min(8e3, Math.max(1, deadline - Date.now()))
-          },
-          context
-        },
-        ["status-selected"]
-      );
-      if (status?.agenticPresent === true && status.route && (!previousRuntimeIdentity || status.runtimeIdentity !== previousRuntimeIdentity)) {
-        return status;
-      }
-      lastError = new Error(
-        previousRuntimeIdentity && status?.runtimeIdentity === previousRuntimeIdentity ? "retiring Mobile runtime is still selected" : "selected Mobile runtime is not ready"
-      );
-    } catch (error) {
-      lastError = error;
-    }
-    const remainingMs = deadline - Date.now();
-    if (remainingMs > 0) {
-      await new Promise(
-        (resolve) => setTimeout(resolve, Math.min(1e3, remainingMs))
-      );
-    }
-  }
-  throw new Error(
-    `Mobile lifecycle ${String(command)} did not expose a usable pinned __AGENTIC__ runtime within ${Math.max(0, deadline - startedAt)}ms: ${lastError instanceof Error ? lastError.message : String(lastError)}`
-  );
-}
-async function readMobileLifecycleRuntimeIdentity(node, context) {
-  const deadline = Date.now() + 5e3;
-  let lastError;
-  do {
-    try {
-      const status = await bridgeCommand(
-        {
-          action: "app.lifecycle",
-          node: {
-            ...node,
-            cdp_timeout_ms: Math.min(1e3, Math.max(1, deadline - Date.now()))
-          },
-          context
-        },
-        ["target-identity-selected"]
-      );
-      if (typeof status?.runtimeIdentity === "string") {
-        return status.runtimeIdentity;
-      }
-      lastError = new Error("selected Mobile runtime has no stable identity");
-    } catch (error) {
-      if (error instanceof Error && "code" in error && error.code === MOBILE_BRIDGE_ERROR_CODES.NO_TARGET) {
-        return void 0;
-      }
-      lastError = error;
-    }
-    const remainingMs = deadline - Date.now();
-    if (remainingMs <= 0) {
-      break;
-    }
-    await new Promise(
-      (resolve) => setTimeout(resolve, Math.min(250, remainingMs))
-    );
-  } while (Date.now() < deadline);
-  throw new Error(
-    `Mobile lifecycle restart could not identify the retiring runtime: ${lastError instanceof Error ? lastError.message : String(lastError)}`
-  );
-}
-function mobileLifecycleReadinessDeadline(command, node) {
-  const timeoutMs = resolveMobileLifecycleReadinessTimeout(
-    command,
-    node.runtime_ready_timeout_ms
-  );
-  return Date.now() + timeoutMs;
-}
-function resolveMobileLifecycleReadinessTimeout(command, value) {
-  if (value === void 0) {
-    return command === "launch" || command === "restart" || command === "foreground" ? 6e4 : 3e4;
-  }
-  const timeout = Number(value);
-  if (!Number.isInteger(timeout) || timeout < 1e3 || timeout > 12e4) {
-    throw new Error(
-      "app.lifecycle.runtime_ready_timeout_ms must be an integer from 1000 through 120000."
-    );
-  }
-  return timeout;
-}
-function asRecord(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
 function runnerProvenance() {
   return {
     source: runnerDir,
@@ -659,8 +314,5 @@ export {
   createMetaMaskMobileRunner,
   createMetaMaskRunner,
   isAutomaticHudProgress,
-  mobileSourceAwareLifecycleAdapters,
-  resolveMobileLifecycleReadinessTimeout,
-  withMobileNativeRuntimeIdentity,
   withTrustedMutationContext
 };