@deeeed/metamask-harness 0.79.0 → 0.80.0

package/adapters/mobile/metro-config.cjs

@@ -1,98 +0,0 @@
-'use strict';
-
-const fs = require('node:fs');
-const { createRequire } = require('node:module');
-const path = require('node:path');
-const { pathToFileURL } = require('node:url');
-
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-function appendBlockList(blockList, pattern) {
-  if (Array.isArray(blockList)) return [...blockList, pattern];
-  return blockList instanceof RegExp ? [blockList, pattern] : [pattern];
-}
-
-function blockListFlags(blockList) {
-  const first = Array.isArray(blockList) ? blockList[0] : blockList;
-  return first instanceof RegExp && first.ignoreCase ? 'i' : '';
-}
-
-function resolveExpoConfigLoader(projectRoot) {
-  const requireFromProject = createRequire(path.join(projectRoot, 'package.json'));
-  let requireUtilsPath;
-  try {
-    requireUtilsPath = requireFromProject.resolve('@expo/require-utils');
-  } catch (error) {
-    if (error?.code !== 'MODULE_NOT_FOUND') throw error;
-    return null;
-  }
-  const { loadModuleSync } = requireFromProject(requireUtilsPath);
-  return typeof loadModuleSync === 'function' ? loadModuleSync : null;
-}
-
-async function loadProductConfig(configPath, baseConfig, projectRoot) {
-  let loaded;
-  const expoConfigLoader = resolveExpoConfigLoader(projectRoot);
-  if (expoConfigLoader) {
-    loaded = expoConfigLoader(configPath);
-  } else {
-    try {
-      loaded = require(configPath);
-    } catch (error) {
-      if (error?.code !== 'ERR_REQUIRE_ESM') throw error;
-      loaded = await import(pathToFileURL(configPath).href);
-    }
-  }
-
-  const moduleValue = await loaded;
-  const exported =
-    moduleValue?.__esModule || moduleValue?.[Symbol.toStringTag] === 'Module'
-      ? moduleValue.default
-      : moduleValue;
-  const config = await exported;
-  return typeof config === 'function' ? config(baseConfig) : config;
-}
-
-module.exports = async function harnessMetroConfig(baseConfig) {
-  const projectRoot = path.resolve(
-    process.env.MM_HARNESS_METRO_PROJECT_ROOT || process.cwd(),
-  );
-  const productConfigPath = path.resolve(
-    process.env.MM_HARNESS_METRO_BASE_CONFIG ||
-      path.join(projectRoot, 'metro.config.js'),
-  );
-  if (productConfigPath === __filename) {
-    throw new Error(
-      'MM_HARNESS_METRO_BASE_CONFIG must reference the product Metro config, not the harness wrapper.',
-    );
-  }
-  let productConfig = baseConfig;
-  if (fs.existsSync(productConfigPath)) {
-    productConfig = await loadProductConfig(
-      productConfigPath,
-      baseConfig,
-      projectRoot,
-    );
-  }
-
-  const tempRoot = path.join(projectRoot, 'temp');
-  const existingBlockList =
-    productConfig.resolver?.blockList ?? baseConfig.resolver?.blockList;
-  const tempPattern = new RegExp(
-    `^${escapeRegExp(tempRoot)}(?:${escapeRegExp(path.sep)}|$)`,
-    blockListFlags(existingBlockList),
-  );
-  // Inline environment values affect transformed JavaScript. Keep separate
-  // cache generations for those inputs instead of deleting the shared cache.
-  const envFingerprint = process.env.MM_HARNESS_METRO_ENV_FINGERPRINT;
-  return {
-    ...productConfig,
-    ...(envFingerprint ? { cacheVersion: `${productConfig.cacheVersion ?? ''}:mm-env:${envFingerprint}` } : {}),
-    resolver: {
-      ...productConfig.resolver,
-      blockList: appendBlockList(existingBlockList, tempPattern),
-    },
-  };
-};

package/adapters/mobile/metro-log-generation.cjs

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const crypto = require('node:crypto');
-const fs = require('node:fs');
-const path = require('node:path');
-
-const generationIdPattern = /^[A-Za-z0-9-]+$/u;
-
-function archiveGenerationId(name) {
-  if (!name.startsWith('metro.') || !name.endsWith('.log')) return null;
-  const generationId = name.slice('metro.'.length, -'.log'.length);
-  return generationIdPattern.test(generationId) ? generationId : null;
-}
-
-function positiveInteger(name, fallback) {
-  const raw = process.env[name];
-  if (raw === undefined || raw === '') return fallback;
-  if (!/^[1-9][0-9]*$/u.test(raw)) throw new Error(`${name} must be a positive integer`);
-  return Number(raw);
-}
-
-function main() {
-  const runtimeArg = process.argv[2];
-  const port = process.argv[3];
-  const reason = process.argv[4];
-  if (!runtimeArg || !/^[1-9][0-9]*$/u.test(port ?? '') || !reason) {
-    throw new Error('usage: metro-log-generation.cjs <runtime-dir> <port> <reason>');
-  }
-  const runtimeDir = fs.realpathSync(runtimeArg);
-  const activeLog = path.join(runtimeDir, 'metro.log');
-  const evidenceFile = path.join(runtimeDir, 'metro-generation.json');
-  const maxArchives = positiveInteger('MM_HARNESS_METRO_LOG_ARCHIVE_COUNT', 4);
-  const maxArchiveBytes = positiveInteger('MM_HARNESS_METRO_LOG_ARCHIVE_BYTES', 8 * 1024 * 1024);
-  const generationId = `${new Date().toISOString().replace(/[-:.]/gu, '')}-${port}-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
-  if (!generationIdPattern.test(generationId)) throw new Error('generated Metro log identity is invalid');
-  let rotatedLog = null;
-
-  rotatedLog = path.join(runtimeDir, `metro.${generationId}.log`);
-  try {
-    fs.renameSync(activeLog, rotatedLog);
-    const stat = fs.lstatSync(rotatedLog);
-    if (!stat.isFile()) {
-      fs.renameSync(rotatedLog, activeLog);
-      throw new Error('metro.log must be a regular file');
-    }
-  } catch (error) {
-    if (error && error.code === 'ENOENT') rotatedLog = null;
-    else throw error;
-  }
-  try {
-    fs.closeSync(fs.openSync(activeLog, 'wx', 0o600));
-  } catch (error) {
-    if (error && error.code === 'EEXIST') throw new Error('another Metro generation recreated metro.log; refusing to truncate it');
-    throw error;
-  }
-
-  const archives = fs.readdirSync(runtimeDir)
-    .filter((name) => archiveGenerationId(name) !== null)
-    .map((name) => {
-      const file = path.join(runtimeDir, name);
-      const stat = fs.lstatSync(file);
-      if (!stat.isFile()) return null;
-      return { file, size: stat.size, mtimeMs: stat.mtimeMs };
-    })
-    .filter(Boolean)
-    .sort((left, right) => right.mtimeMs - left.mtimeMs || right.file.localeCompare(left.file));
-
-  let retainedBytes = 0;
-  let retainedCount = 0;
-  const retained = [];
-  const removed = [];
-  for (const archive of archives) {
-    if (retainedCount < maxArchives && retainedBytes + archive.size <= maxArchiveBytes) {
-      retained.push(archive.file);
-      retainedCount += 1;
-      retainedBytes += archive.size;
-      continue;
-    }
-    fs.unlinkSync(archive.file);
-    removed.push({ path: archive.file, size: archive.size, reason: retainedCount >= maxArchives ? 'count-limit' : 'size-limit' });
-  }
-
-  const evidence = {
-    schemaVersion: 1,
-    generationId,
-    port: Number(port),
-    startedAt: new Date().toISOString(),
-    currentLog: activeLog,
-    rotatedLog: rotatedLog && fs.existsSync(rotatedLog) ? rotatedLog : null,
-    archivedLogs: retained,
-    rotationReason: reason,
-    retention: { maxArchives, maxArchiveBytes, retainedBytes, removed },
-  };
-  const temporary = `${evidenceFile}.${process.pid}.tmp`;
-  fs.writeFileSync(temporary, `${JSON.stringify(evidence, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
-  fs.renameSync(temporary, evidenceFile);
-  process.stdout.write(`${JSON.stringify(evidence)}\n`);
-}
-
-try {
-  main();
-} catch (error) {
-  console.error(`metro-log-generation: ${error instanceof Error ? error.message : String(error)}`);
-  process.exit(1);
-}

package/dist/adapters/mobile/frame-metrics.js

@@ -1,118 +0,0 @@
-const MIN_ACTIVE_INTERVALS = 5;
-function summarizeFrames(samples) {
-  const allValidSamples = samples.filter(
-    (sample) => Number.isFinite(sample.durationMs) && sample.durationMs > 0
-  );
-  const frameBudgetMs = commonFrameBudget(allValidSamples);
-  const cadenceSamples = allValidSamples.length > 0 && allValidSamples.every((sample) => sample.cadenceInterval === true);
-  const cadenceGaps = cadenceSamples && frameBudgetMs ? allValidSamples.filter(
-    (sample) => sample.durationMs > frameBudgetMs * 3.01
-  ) : [];
-  const validSamples = cadenceGaps.length > 0 ? allValidSamples.filter(
-    (sample) => sample.durationMs <= (frameBudgetMs ?? 0) * 3.01
-  ) : allValidSamples;
-  const durations = validSamples.map((sample) => sample.durationMs).sort((first, second) => first - second);
-  if (durations.length === 0) {
-    return {
-      fpsUnavailableReason: frameBudgetMs ? "insufficient_active_frames" : "refresh_rate_unavailable",
-      ...cadenceGaps.length > 0 ? {
-        cadenceGapCount: cadenceGaps.length,
-        longestCadenceGapMs: round(
-          Math.max(...cadenceGaps.map((sample) => sample.durationMs))
-        )
-      } : {},
-      ...frameBudgetMs ? {
-        frameBudgetMs: round(frameBudgetMs),
-        refreshRateHz: round(1e3 / frameBudgetMs)
-      } : {},
-      frameCount: 0
-    };
-  }
-  const frameBudgetOutcomes = validSamples.map((sample) => sample.overBudget).filter((value) => value !== void 0);
-  const missedFrameBudgetCount = frameBudgetOutcomes.filter(Boolean).length;
-  const activeIntervals = frameBudgetMs ? activeRenderingIntervals(validSamples, frameBudgetMs) : [];
-  const activeElapsedMs = activeIntervals.reduce(
-    (total, interval) => total + interval,
-    0
-  );
-  const hasActiveFps = cadenceGaps.length === 0 && activeIntervals.length >= MIN_ACTIVE_INTERVALS && activeElapsedMs > 0;
-  const refreshRateHz = frameBudgetMs ? 1e3 / frameBudgetMs : void 0;
-  return {
-    ...hasActiveFps ? {
-      activeFps: round(
-        Math.min(
-          refreshRateHz ?? Number.POSITIVE_INFINITY,
-          activeIntervals.length * 1e3 / activeElapsedMs
-        )
-      ),
-      fpsIntervalCount: activeIntervals.length
-    } : {
-      fpsUnavailableReason: frameBudgetMs ? cadenceGaps.length > 0 ? "unclassified_cadence_gap" : "insufficient_active_frames" : "refresh_rate_unavailable"
-    },
-    ...cadenceGaps.length > 0 ? {
-      cadenceGapCount: cadenceGaps.length,
-      longestCadenceGapMs: round(
-        Math.max(...cadenceGaps.map((sample) => sample.durationMs))
-      )
-    } : {},
-    ...frameBudgetMs ? {
-      frameBudgetMs: round(frameBudgetMs),
-      refreshRateHz: round(1e3 / frameBudgetMs)
-    } : {},
-    frameCount: durations.length,
-    ...frameBudgetOutcomes.length === validSamples.length ? {
-      overBudgetFrameCount: missedFrameBudgetCount,
-      overBudgetFramePercent: round(
-        missedFrameBudgetCount / validSamples.length * 100
-      )
-    } : {},
-    longestFrameMs: round(durations.at(-1) ?? 0),
-    p50FrameMs: round(percentile(durations, 0.5)),
-    p95FrameMs: round(percentile(durations, 0.95)),
-    p99FrameMs: round(percentile(durations, 0.99))
-  };
-}
-function commonFrameBudget(samples) {
-  const budgets = samples.map((sample) => sample.frameBudgetMs).filter(
-    (value) => value !== void 0 && Number.isFinite(value) && value > 0
-  ).sort((first, second) => first - second);
-  return budgets.length > 0 ? percentile(budgets, 0.5) : void 0;
-}
-function activeRenderingIntervals(samples, frameBudgetMs) {
-  if (samples.every((sample) => sample.cadenceInterval === true)) {
-    return samples.map((sample) => sample.durationMs).filter(
-      (durationMs) => Number.isFinite(durationMs) && durationMs > 0 && durationMs <= frameBudgetMs * 3.01
-    );
-  }
-  const ordered = [...samples].map((sample) => ({
-    ...sample,
-    startedAtEpochMs: sample.startedAtEpochMs ?? sample.completedAtEpochMs - sample.durationMs
-  })).sort((first, second) => first.startedAtEpochMs - second.startedAtEpochMs);
-  const intervals = [];
-  for (let index = 1; index < ordered.length; index += 1) {
-    const previous = ordered[index - 1];
-    const current = ordered[index];
-    if (!previous || !current) continue;
-    const interval = current.startedAtEpochMs - previous.startedAtEpochMs;
-    if (!Number.isFinite(interval) || interval <= 0) continue;
-    const continuous = interval <= frameBudgetMs * 3.01;
-    const explainedBySlowFrame = Math.max(previous.durationMs, current.durationMs) >= interval - frameBudgetMs * 1.01;
-    if (continuous || explainedBySlowFrame) intervals.push(interval);
-  }
-  return intervals;
-}
-function percentile(sorted, quantile) {
-  if (sorted.length === 1) return sorted[0] ?? 0;
-  const position = (sorted.length - 1) * quantile;
-  const lower = Math.floor(position);
-  const upper = Math.ceil(position);
-  const lowerValue = sorted[lower] ?? 0;
-  const upperValue = sorted[upper] ?? lowerValue;
-  return lowerValue + (upperValue - lowerValue) * (position - lower);
-}
-function round(value) {
-  return Math.round(value * 1e3) / 1e3;
-}
-export {
-  summarizeFrames
-};

package/dist/adapters/mobile/video-recorder.js

@@ -1,289 +0,0 @@
-import { spawn, spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-import { optionalVideoTiming } from "@farmslot/recipe-runner";
-import {
-  ANDROID_RECORDING_TARGET_PREFIX,
-  IOS_SIMULATOR_RECORDING_TARGET_PREFIX
-} from "../../recording-target.js";
-const RECORDING_START_TIMEOUT_MS = 5e3;
-const RECORDING_STOP_TIMEOUT_MS = 1e4;
-const RECORDING_TIME_LIMIT_SECONDS = 0;
-function androidScreenrecordArgs(remotePath) {
-  return [
-    "shell",
-    "screenrecord",
-    "--time-limit",
-    String(RECORDING_TIME_LIMIT_SECONDS),
-    remotePath
-  ];
-}
-function createAndroidVideoRecorder(serial) {
-  return {
-    name: "adb-screenrecord",
-    platform: "android",
-    doctor: async () => doctorAndroidRecorder(serial),
-    start: (request) => startAndroidRecording(serial, request)
-  };
-}
-function createIosSimulatorVideoRecorder(simulator) {
-  return {
-    name: "simctl-recordVideo",
-    platform: "ios",
-    doctor: async () => doctorIosSimulatorRecorder(simulator),
-    start: (request) => startIosSimulatorRecording(simulator, request)
-  };
-}
-function doctorIosSimulatorRecorder(simulator) {
-  const state = runSimctl(["getenv", simulator, "SIMULATOR_UDID"]);
-  if (state.status !== 0 || !state.stdout.trim()) {
-    return {
-      ok: false,
-      code: "ios_simulator_unavailable",
-      message: `iOS simulator ${simulator} is not booted: ${commandFailure(state)}`,
-      suggestedFix: `Boot ${simulator} and run xcrun simctl getenv ${simulator} SIMULATOR_UDID.`
-    };
-  }
-  return {
-    ok: true,
-    code: "ok",
-    message: `iOS simulator recording is ready on ${simulator}.`
-  };
-}
-async function startIosSimulatorRecording(simulator, request) {
-  const targetSimulator = iosTargetSimulator(request);
-  if (targetSimulator !== simulator) {
-    throw new Error(
-      `iOS recording target ${targetSimulator ?? "<missing>"} does not match selected simulator ${simulator}.`
-    );
-  }
-  fs.mkdirSync(path.dirname(request.outputPath), { recursive: true });
-  const child = spawn(
-    "xcrun",
-    [
-      "simctl",
-      "io",
-      simulator,
-      "recordVideo",
-      "--codec=h264",
-      "--force",
-      request.outputPath
-    ],
-    { stdio: ["ignore", "pipe", "pipe"] }
-  );
-  const output = [];
-  child.stdout?.setEncoding("utf8");
-  child.stderr?.setEncoding("utf8");
-  child.stdout?.on("data", (chunk) => output.push(String(chunk)));
-  child.stderr?.on("data", (chunk) => output.push(String(chunk)));
-  await waitForIosRecordingStart(child, output);
-  let stopped = false;
-  return {
-    async stop() {
-      if (stopped) {
-        throw new Error(
-          `iOS simulator recording on ${simulator} was already stopped.`
-        );
-      }
-      stopped = true;
-      child.kill("SIGINT");
-      await waitForChildExit(
-        child,
-        RECORDING_STOP_TIMEOUT_MS,
-        "iOS simulator recordVideo"
-      );
-      const recorded = fs.statSync(request.outputPath);
-      if (!recorded.isFile() || recorded.size <= 0) {
-        throw new Error(
-          `iOS simulator recording output is empty: ${request.outputPath}`
-        );
-      }
-      return {
-        recorder: {
-          name: "simctl-recordVideo",
-          platform: "ios",
-          target: { selector: "simulator", value: simulator }
-        }
-      };
-    }
-  };
-}
-function doctorAndroidRecorder(serial) {
-  const state = runAdb(serial, ["get-state"]);
-  if (state.status !== 0 || state.stdout.trim() !== "device") {
-    return {
-      ok: false,
-      code: "android_device_unavailable",
-      message: `Android device ${serial} is not ready: ${commandFailure(state)}`,
-      suggestedFix: `Run adb -s ${serial} get-state and reconnect or unlock the device.`
-    };
-  }
-  const screenrecord = runAdb(serial, ["shell", "screenrecord", "--help"]);
-  if (screenrecord.status !== 0) {
-    return {
-      ok: false,
-      code: "android_screenrecord_unavailable",
-      message: `Android screenrecord is unavailable on ${serial}: ${commandFailure(screenrecord)}`,
-      suggestedFix: `Run adb -s ${serial} shell screenrecord --help.`
-    };
-  }
-  return {
-    ok: true,
-    code: "ok",
-    message: `Android screen recording is ready on ${serial}.`
-  };
-}
-async function startAndroidRecording(serial, request) {
-  const targetSerial = androidTargetSerial(request);
-  if (targetSerial !== serial) {
-    throw new Error(
-      `Android recording target ${targetSerial ?? "<missing>"} does not match selected device ${serial}.`
-    );
-  }
-  const existingPid = screenrecordPid(serial);
-  if (existingPid) {
-    throw new Error(
-      `Android screenrecord is already running on ${serial} (pid ${existingPid}). Stop that recording before retrying.`
-    );
-  }
-  const remotePath = `/sdcard/Download/mm-harness-recipe-${Date.now()}-${process.pid}.mp4`;
-  const startedAtUnixMs = Date.now();
-  const child = spawn(
-    "adb",
-    ["-s", serial, ...androidScreenrecordArgs(remotePath)],
-    { stdio: ["ignore", "pipe", "pipe"] }
-  );
-  const stderr = [];
-  child.stderr?.setEncoding("utf8");
-  child.stderr?.on("data", (chunk) => stderr.push(String(chunk)));
-  child.stdout?.resume();
-  const recorderPid = await waitForScreenrecordStart(serial, child, stderr);
-  let stopped = false;
-  return {
-    async stop() {
-      if (stopped) {
-        throw new Error(`Android screen recording on ${serial} was already stopped.`);
-      }
-      stopped = true;
-      try {
-        stopRemoteScreenrecord(serial, recorderPid);
-        await waitForChildExit(
-          child,
-          RECORDING_STOP_TIMEOUT_MS,
-          "Android screenrecord"
-        );
-        const stoppedAtUnixMs = Date.now();
-        fs.mkdirSync(path.dirname(request.outputPath), { recursive: true });
-        const pull = runAdb(serial, ["pull", remotePath, request.outputPath]);
-        if (pull.status !== 0) {
-          throw new Error(
-            `Could not pull Android recording from ${serial}: ${commandFailure(pull)}`
-          );
-        }
-        const output = fs.statSync(request.outputPath);
-        if (!output.isFile() || output.size <= 0) {
-          throw new Error(`Android recording output is empty: ${request.outputPath}`);
-        }
-        return {
-          ...await optionalVideoTiming(request.outputPath, { startedAtUnixMs, stoppedAtUnixMs }),
-          recorder: {
-            name: "adb-screenrecord",
-            platform: "android",
-            target: { selector: "adb-serial", value: serial }
-          }
-        };
-      } finally {
-        runAdb(serial, ["shell", "rm", "-f", remotePath]);
-      }
-    }
-  };
-}
-function androidTargetSerial(request) {
-  if (request.target.kind === "android-device") return request.target.serial;
-  if (request.target.kind !== "window-id") return void 0;
-  if (!request.target.windowId.startsWith(ANDROID_RECORDING_TARGET_PREFIX)) return void 0;
-  return request.target.windowId.slice(ANDROID_RECORDING_TARGET_PREFIX.length) || void 0;
-}
-async function waitForScreenrecordStart(serial, child, stderr) {
-  const deadline = Date.now() + RECORDING_START_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null) {
-      throw new Error(
-        `Android screenrecord exited before capture started (exit ${child.exitCode}): ${stderr.join("").trim() || "no recorder output"}`
-      );
-    }
-    const pid = screenrecordPid(serial);
-    if (pid) return pid;
-    await sleep(100);
-  }
-  child.kill("SIGTERM");
-  throw new Error(
-    `Android screenrecord did not start on ${serial} within ${RECORDING_START_TIMEOUT_MS}ms.`
-  );
-}
-function stopRemoteScreenrecord(serial, pid) {
-  const stop = runAdb(serial, ["shell", "kill", "-2", pid]);
-  if (stop.status !== 0 && screenrecordPid(serial) === pid) {
-    throw new Error(`Could not stop Android screenrecord pid ${pid}: ${commandFailure(stop)}`);
-  }
-}
-async function waitForChildExit(child, timeoutMs, recorderName) {
-  if (child.exitCode !== null) return;
-  await new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      child.kill("SIGTERM");
-      reject(new Error(`${recorderName} did not stop within ${timeoutMs}ms.`));
-    }, timeoutMs);
-    child.once("exit", () => {
-      clearTimeout(timeout);
-      resolve();
-    });
-  });
-}
-async function waitForIosRecordingStart(child, output) {
-  const deadline = Date.now() + RECORDING_START_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (child.exitCode !== null) {
-      throw new Error(
-        `iOS simulator recordVideo exited before capture started (exit ${child.exitCode}): ${output.join("").trim() || "no recorder output"}`
-      );
-    }
-    if (output.join("").includes("Recording started")) return;
-    await sleep(100);
-  }
-  if (child.exitCode === null) return;
-  throw new Error(
-    `iOS simulator recordVideo did not start within ${RECORDING_START_TIMEOUT_MS}ms.`
-  );
-}
-function iosTargetSimulator(request) {
-  if (request.target.kind !== "window-id") return void 0;
-  if (!request.target.windowId.startsWith(
-    IOS_SIMULATOR_RECORDING_TARGET_PREFIX
-  )) {
-    return void 0;
-  }
-  return request.target.windowId.slice(IOS_SIMULATOR_RECORDING_TARGET_PREFIX.length) || void 0;
-}
-function screenrecordPid(serial) {
-  const result = runAdb(serial, ["shell", "pidof", "screenrecord"]);
-  if (result.status !== 0) return void 0;
-  return result.stdout.trim().split(/\s+/u).find(Boolean);
-}
-function runAdb(serial, args) {
-  return spawnSync("adb", ["-s", serial, ...args], { encoding: "utf8" });
-}
-function runSimctl(args) {
-  return spawnSync("xcrun", ["simctl", ...args], { encoding: "utf8" });
-}
-function commandFailure(result) {
-  return result.stderr.trim() || result.stdout.trim() || `exit ${result.status ?? "unknown"}`;
-}
-function sleep(durationMs) {
-  return new Promise((resolve) => setTimeout(resolve, durationMs));
-}
-export {
-  androidScreenrecordArgs,
-  createAndroidVideoRecorder,
-  createIosSimulatorVideoRecorder
-};