@keepsnappy/agent 0.0.0-stage → 0.1.0-alpha.11

package/dist/appium-driver.js

@@ -0,0 +1,1227 @@
+#!/usr/bin/env node
+
+// packages/appium-driver/src/load.ts
+import { isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+
+// packages/appium-driver/src/run.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+// packages/appium-driver/src/browserstack.ts
+import { openAsBlob } from "node:fs";
+import { basename } from "node:path";
+
+// packages/appium-driver/src/links.ts
+var ALERT_POLL_MS = 250;
+var RUN_DEFAULTS = { ttl: 3600, profile: 1, diag: 1 };
+var END_GC_DEFAULT = true;
+var route = (scheme) => `${scheme}devtools/perf-lab`;
+function parseSdkArgs(args) {
+  return args.split("&").filter(Boolean).map((kv) => {
+    const i = kv.indexOf("=");
+    return i < 0 ? [kv, "1"] : [kv.slice(0, i), kv.slice(i + 1)];
+  });
+}
+function linkArgs(args = "") {
+  const fields = new Map(Object.entries(RUN_DEFAULTS).map(([k, v]) => [k, String(v)]));
+  for (const [k, v] of parseSdkArgs(args))
+    if (k !== "activate" && k !== "runToken")
+      fields.set(k, v);
+  return [...fields].map(([k, v]) => `${k}=${v}`).join("&");
+}
+var activationLink = (scheme, token, args = "") => `${route(scheme)}?activate=1&${linkArgs(args)}&runToken=${token}`;
+var flushLink = (scheme) => `${route(scheme)}?flush=1&activate=0`;
+var gcLink = (scheme, n) => `${route(scheme)}?cmd=gc&n=${n}`;
+async function acceptAlert(driver, labels, waitMs) {
+  const deadline = driver.now() + waitMs;
+  for (;; ) {
+    let buttons = null;
+    try {
+      buttons = await driver.execute("mobile: alert", { action: "getButtons" });
+    } catch {
+      buttons = null;
+    }
+    const hit = Array.isArray(buttons) ? labels.find((l) => buttons.includes(l)) : undefined;
+    if (hit) {
+      await driver.execute("mobile: alert", { action: "accept", buttonLabel: hit });
+      return hit;
+    }
+    if (driver.now() > deadline)
+      return null;
+    await driver.sleep(ALERT_POLL_MS);
+  }
+}
+async function openLink(driver, url, state) {
+  if (state.linkMode !== "safari") {
+    try {
+      await driver.execute("mobile: deepLink", { url, bundleId: driver.bundleId });
+      state.linkMode = "deepLink";
+    } catch (e) {
+      if (state.linkMode === "deepLink")
+        throw e;
+      state.linkMode = "safari";
+      state.linkError = String(e.message);
+    }
+  }
+  if (state.linkMode === "safari") {
+    await driver.execute("mobile: launchApp", { bundleId: "com.apple.mobilesafari" });
+    const bar = await driver.find("accessibility id", "TabBarItemTitle") ?? await driver.find("accessibility id", "URL");
+    if (bar)
+      await driver.click(bar);
+    const field = await driver.find("-ios predicate string", 'type == "XCUIElementTypeTextField" AND name == "URL"');
+    if (!field)
+      throw new Error("Safari address bar not found");
+    await driver.cmd("POST", `/element/${field}/value`, { text: `${url}
+` });
+  }
+  return acceptAlert(driver, ["Open"], state.linkMode === "safari" ? 8000 : 0);
+}
+
+// packages/appium-driver/src/selectors.ts
+var toSelector = (s) => typeof s === "string" ? { id: s } : s;
+var id = (value) => ({ id: value });
+var REGEX_CHARS = /[\\()[\]*+?|^$]/;
+var quote = (s) => `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+var matches = (attr, re) => `${attr} MATCHES ${quote(`(?is)${re}`)}`;
+var textMatch = (re) => `(${matches("label", re)} OR ${matches("value", re)})`;
+function locator(sel) {
+  if (sel.id !== undefined && sel.text === undefined && !REGEX_CHARS.test(sel.id)) {
+    return { using: "accessibility id", value: sel.id };
+  }
+  const parts = [];
+  if (sel.id !== undefined)
+    parts.push(REGEX_CHARS.test(sel.id) ? matches("name", sel.id) : `name == ${quote(sel.id)}`);
+  if (sel.text !== undefined)
+    parts.push(textMatch(sel.text));
+  return { using: "-ios predicate string", value: parts.join(" AND ") };
+}
+var describeSelector = (sel) => [sel.id !== undefined ? `id=${sel.id}` : null, sel.text !== undefined ? `text=${sel.text}` : null, sel.childOf !== undefined ? `childOf=${sel.childOf}` : null].filter(Boolean).join(" ");
+var javaString = (s) => `"${s.replace(/"/g, "\\\"")}"`;
+var javaRegex = (re) => {
+  const trailing = /\\*$/.exec(re)[0].length;
+  if (trailing % 2 === 1)
+    throw new Error(`selector ${JSON.stringify(re)} ends in a lone backslash`);
+  return javaString(`(?is)${re}${trailing > 0 ? "(?:)" : ""}`);
+};
+function androidLocators(sel) {
+  const base = () => {
+    if (sel.id === undefined)
+      return [];
+    return [REGEX_CHARS.test(sel.id) ? `resourceIdMatches(${javaRegex(sel.id)})` : `resourceId(${javaString(sel.id)})`];
+  };
+  const using = "-android uiautomator";
+  const build = (extra) => ({ using, value: `new UiSelector()${[...base(), ...extra].map((c) => `.${c}`).join("")}` });
+  if (sel.text === undefined)
+    return [build([])];
+  return [build([`textMatches(${javaRegex(sel.text)})`]), build([`descriptionMatches(${javaRegex(sel.text)})`])];
+}
+var escapeRegex = (s) => s.replace(/[\\^$.|?*+()[\]{}]/g, "\\$&");
+function androidAnyOfIds(ids) {
+  const alternatives = ids.map((id) => `(?:${REGEX_CHARS.test(id) ? id : escapeRegex(id)})`).join("|");
+  return { using: "-android uiautomator", value: `new UiSelector().resourceIdMatches(${javaRegex(alternatives)})` };
+}
+
+// packages/appium-driver/src/snapshot.ts
+var ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+var unescapeXml = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|amp|lt|gt|quot|apos);/gi, (_, e) => e[0] === "#" ? String.fromCodePoint(e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10)) : ENTITIES[e.toLowerCase()]);
+var TAG = /<(\/?)([\w.$:-]+)((?:\s+[\w:.-]+=(?:"[^"]*"|'[^']*'))*)\s*(\/?)>/g;
+var ATTR = /([\w:.-]+)=(?:"([^"]*)"|'([^']*)')/g;
+var BOUNDS = /^\[(-?\d+),(-?\d+)\]\[(-?\d+),(-?\d+)\]$/;
+function parseAndroidSource(xml) {
+  const nodes = [];
+  const open = [];
+  for (const m of xml.matchAll(TAG)) {
+    if (m[1] === "/") {
+      open.pop();
+      continue;
+    }
+    const attrs = {};
+    for (const a of m[3].matchAll(ATTR))
+      attrs[a[1]] = unescapeXml(a[2] ?? a[3]);
+    const b = BOUNDS.exec(attrs.bounds ?? "");
+    const node = {
+      parent: open.length ? open[open.length - 1] : -1,
+      id: attrs["resource-id"] ?? "",
+      text: attrs.text ?? "",
+      desc: attrs["content-desc"] ?? "",
+      displayed: attrs.displayed === "true",
+      scrollable: attrs.scrollable === "true",
+      left: b ? +b[1] : 0,
+      top: b ? +b[2] : 0,
+      right: b ? +b[3] : 0,
+      bottom: b ? +b[4] : 0
+    };
+    nodes.push(node);
+    if (m[4] !== "/")
+      open.push(nodes.length - 1);
+  }
+  return nodes;
+}
+var inverted = (n) => n.bottom < n.top;
+function nodeShown(n, w, full = false) {
+  if (!n.displayed || inverted(n))
+    return false;
+  if (n.right - n.left <= 0 || n.bottom - n.top <= 0)
+    return false;
+  if (full)
+    return n.left >= 0 && n.top >= 0 && n.right <= w.width && n.bottom <= w.height;
+  return n.left < w.width && n.top < w.height && n.right > 0 && n.bottom > 0;
+}
+function wholeMatch(re) {
+  if (/\(\?[^:=!<]/.test(re) || /\\[AZzGhHRVXpPk]|\\Q|[*+?}]\+/.test(re))
+    return null;
+  try {
+    return new RegExp(`^(?:${re})$`, "is");
+  } catch {
+    return null;
+  }
+}
+function nodeMatcher(sel) {
+  let idTest = null;
+  if (sel.id !== undefined) {
+    if (REGEX_CHARS.test(sel.id)) {
+      const re = wholeMatch(sel.id);
+      if (!re)
+        return null;
+      idTest = (s) => re.test(s);
+    } else {
+      const want = sel.id;
+      idTest = (s) => s === want;
+    }
+  }
+  let textRe = null;
+  if (sel.text !== undefined) {
+    textRe = wholeMatch(sel.text);
+    if (!textRe)
+      return null;
+  }
+  return (n) => (idTest ? idTest(n.id) : true) && (textRe ? textRe.test(n.text) || textRe.test(n.desc) : true);
+}
+function idMatcher(id) {
+  const m = nodeMatcher({ id });
+  return m && ((resourceId) => m({ parent: -1, id: resourceId, text: "", desc: "", displayed: true, scrollable: false, left: 0, top: 0, right: 0, bottom: 0 }));
+}
+
+class Screen {
+  nodes;
+  window;
+  edges = new Map;
+  container;
+  constructor(nodes, window) {
+    this.nodes = nodes;
+    this.window = window;
+    this.container = nodes.map((_, i) => this.scrollAncestor(i));
+    const byContainer = new Map;
+    nodes.forEach((n, i) => {
+      const c = this.container[i];
+      if (c >= 0 && inverted(nodes[c]) && inverted(n))
+        (byContainer.get(c) ?? byContainer.set(c, []).get(c)).push(i);
+    });
+    for (const [c, members] of byContainer) {
+      const edge = this.clipEdge(members);
+      if (edge !== null)
+        this.edges.set(c, edge);
+    }
+  }
+  scrollAncestor(i) {
+    let p = this.nodes[i].parent;
+    while (p >= 0 && !this.nodes[p].scrollable)
+      p = this.nodes[p].parent;
+    return p;
+  }
+  clipEdge(members) {
+    const heads = new Map;
+    for (const i of members) {
+      const n = this.nodes[i];
+      const parent = this.nodes[n.parent];
+      if (parent && inverted(parent) && parent.bottom === n.bottom)
+        continue;
+      heads.set(n.bottom, (heads.get(n.bottom) ?? 0) + 1);
+    }
+    let edge = null;
+    let most = 1;
+    for (const [bottom, count] of heads) {
+      if (count > most || count === most && edge !== null && bottom > edge) {
+        edge = bottom;
+        most = count;
+      }
+    }
+    return edge;
+  }
+  nodeShown(i, full) {
+    const n = this.nodes[i];
+    if (!inverted(n))
+      return nodeShown(n, this.window, full);
+    const edge = this.edges.get(this.container[i]);
+    if (full || edge === undefined)
+      return false;
+    return n.bottom > edge && n.bottom <= this.window.height && n.right > n.left && n.left < this.window.width && n.right > 0;
+  }
+  shown(sel, full = false) {
+    let inside;
+    if (sel.childOf !== undefined) {
+      const parent = this.shown({ id: sel.childOf });
+      if (parent === null)
+        return null;
+      if (parent.length === 0)
+        return [];
+      inside = parent[0];
+    }
+    const match = nodeMatcher({ ...sel.id !== undefined ? { id: sel.id } : {}, ...sel.text !== undefined ? { text: sel.text } : {} });
+    if (!match)
+      return null;
+    const hits = [];
+    this.nodes.forEach((n, i) => {
+      if (!match(n) || !this.nodeShown(i, full))
+        return;
+      if (inside !== undefined && !this.within(i, inside))
+        return;
+      hits.push(i);
+    });
+    return hits;
+  }
+  within(i, ancestor) {
+    for (let p = this.nodes[i].parent;p >= 0; p = this.nodes[p].parent)
+      if (p === ancestor)
+        return true;
+    return false;
+  }
+}
+
+// packages/appium-driver/src/webdriver.ts
+var ELEMENT_KEY = "element-6066-11e4-a52e-4f735466cecf";
+var TAP_HOLD_MS = 100;
+var realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+class WdError extends Error {
+  wdError;
+  constructor(message, wdError) {
+    super(message);
+    this.wdError = wdError;
+  }
+}
+
+class Driver {
+  bundleId;
+  platform;
+  headers;
+  hub;
+  fetch;
+  log;
+  now;
+  sleep;
+  sessionId = null;
+  context = {};
+  viewport = null;
+  rects = new Map;
+  constructor(o) {
+    this.bundleId = o.bundleId;
+    this.platform = o.platform ?? IOS;
+    this.headers = o.headers ?? {};
+    this.hub = o.hub.replace(/\/+$/, "");
+    this.fetch = o.fetch ?? fetch;
+    this.log = o.log;
+    this.now = o.now ?? Date.now;
+    this.sleep = o.sleep ?? realSleep;
+  }
+  async cmd(method, path, body) {
+    const url = `${this.hub}${path.startsWith("/session") || !this.sessionId ? path : `/session/${this.sessionId}${path}`}`;
+    const t0 = this.now();
+    let res;
+    let json;
+    try {
+      res = await this.fetch(url, {
+        method,
+        headers: { "Content-Type": "application/json", ...this.headers },
+        ...body === undefined ? {} : { body: JSON.stringify(body) }
+      });
+      json = await res.json().catch(() => ({}));
+    } finally {
+      this.log.push({ ...this.context, cmd: `${method} ${path.replace(/\/element\/[^/]+/, "/element/:id")}`, t: t0, ms: this.now() - t0, status: res?.status ?? 0 });
+    }
+    const value = json?.value;
+    if (!res.ok || value && typeof value === "object" && value.error) {
+      throw new WdError(`${method} ${path}: ${value?.error ?? res.status} ${String(value?.message ?? "").slice(0, 300)}`.trim(), value?.error ?? String(res.status));
+    }
+    return value;
+  }
+  async start(capabilities) {
+    const value = await this.cmd("POST", "/session", { capabilities: { alwaysMatch: capabilities } });
+    this.sessionId = value.sessionId;
+    return value;
+  }
+  execute(script, arg) {
+    return this.cmd("POST", "/execute/sync", { script, args: arg === undefined ? [] : [arg] });
+  }
+  async find(using, value, parent) {
+    try {
+      const el = await this.cmd("POST", parent ? `/element/${parent}/element` : "/element", { using, value });
+      return el[ELEMENT_KEY] ?? Object.values(el)[0];
+    } catch (e) {
+      if (e instanceof WdError && e.wdError === "no such element")
+        return null;
+      throw e;
+    }
+  }
+  async findAll(using, value, parent) {
+    const path = parent ? `/element/${parent}/elements` : "/elements";
+    const list = await this.cmd("POST", path, { using, value });
+    return (list ?? []).map((el) => el[ELEMENT_KEY] ?? Object.values(el)[0]);
+  }
+  async screen() {
+    this.viewport ??= await this.cmd("GET", "/window/rect");
+    return this.viewport;
+  }
+  async onScreen(el, full = false) {
+    let r;
+    try {
+      r = await this.cmd("GET", `/element/${el}/rect`);
+    } catch (e) {
+      if (e instanceof WdError && e.wdError === "stale element reference")
+        return false;
+      throw e;
+    }
+    const w = await this.screen();
+    if (!r || r.width <= 0 || r.height <= 0)
+      return false;
+    this.rects.set(el, r);
+    if (full)
+      return r.x >= 0 && r.y >= 0 && r.x + r.width <= w.width && r.y + r.height <= w.height;
+    return r.x < w.width && r.y < w.height && r.x + r.width > 0 && r.y + r.height > 0;
+  }
+  async findShown(sel, full = false) {
+    let parent;
+    if (sel.childOf !== undefined) {
+      const p = await this.findShown(id(sel.childOf));
+      if (!p)
+        return null;
+      parent = p;
+    }
+    for (const { using, value } of this.platform.locators(sel)) {
+      if (this.platform.singleFindFirst) {
+        const first = await this.find(using, value, parent);
+        if (!first)
+          continue;
+        if (await this.onScreen(first, full))
+          return first;
+      }
+      for (const el of await this.findAll(using, value, parent)) {
+        if (await this.onScreen(el, full))
+          return el;
+      }
+    }
+    return null;
+  }
+  async shownMany(sels, group) {
+    const out = sels.map(() => false);
+    const tests = sels.map((s) => s.id !== undefined && s.text === undefined && s.childOf === undefined ? idMatcher(s.id) : null);
+    const grouped = group && this.platform.anyOfIds ? tests.flatMap((t, i) => t ? [i] : []) : [];
+    if (grouped.length >= 2) {
+      const { using, value } = this.platform.anyOfIds(grouped.map((i) => sels[i].id));
+      for (const el of await this.findAll(using, value)) {
+        const wanted = grouped.filter((i) => !out[i]);
+        if (wanted.length === 0)
+          break;
+        let resourceId;
+        try {
+          resourceId = String(await this.cmd("GET", `/element/${el}/attribute/resource-id`));
+        } catch (e) {
+          if (e instanceof WdError && e.wdError === "stale element reference")
+            continue;
+          throw e;
+        }
+        const hits = wanted.filter((i) => tests[i](resourceId));
+        if (hits.length > 0 && await this.onScreen(el))
+          for (const i of hits)
+            out[i] = true;
+      }
+    }
+    for (let i = 0;i < sels.length; i++)
+      if (!grouped.includes(i) || grouped.length < 2)
+        out[i] = Boolean(await this.findShown(sels[i]));
+    return out;
+  }
+  async click(el) {
+    await this.cmd("POST", `/element/${el}/click`, {});
+  }
+  async tapElement(el) {
+    const r = this.rects.get(el) ?? await this.cmd("GET", `/element/${el}/rect`);
+    const w = await this.screen();
+    const x = Math.round(Math.min(Math.max(r.x + r.width / 2, 1), w.width - 1));
+    const y = Math.round(Math.min(Math.max(r.y + r.height / 2, 1), w.height - 1));
+    await this.cmd("POST", "/actions", {
+      actions: [
+        {
+          type: "pointer",
+          id: "finger1",
+          parameters: { pointerType: "touch" },
+          actions: [
+            { type: "pointerMove", duration: 0, x, y },
+            { type: "pointerDown", button: 0 },
+            { type: "pause", duration: TAP_HOLD_MS },
+            { type: "pointerUp", button: 0 }
+          ]
+        }
+      ]
+    });
+    await this.cmd("DELETE", "/actions").catch(() => null);
+  }
+  async drag(from, to, durationMs) {
+    await this.cmd("POST", "/actions", {
+      actions: [
+        {
+          type: "pointer",
+          id: "finger1",
+          parameters: { pointerType: "touch" },
+          actions: [
+            { type: "pointerMove", duration: 0, x: from.x, y: from.y },
+            { type: "pointerDown", button: 0 },
+            { type: "pointerMove", duration: durationMs, x: to.x, y: to.y },
+            { type: "pointerUp", button: 0 }
+          ]
+        }
+      ]
+    });
+    await this.cmd("DELETE", "/actions").catch(() => null);
+  }
+  async relaunch(bundleId = this.bundleId) {
+    await this.execute("mobile: terminateApp", this.platform.appArg(bundleId));
+    await this.execute("mobile: activateApp", this.platform.appArg(bundleId));
+  }
+  activate(bundleId = this.bundleId) {
+    return this.execute("mobile: activateApp", this.platform.appArg(bundleId));
+  }
+  async end() {
+    if (!this.sessionId)
+      return;
+    await this.cmd("DELETE", `/session/${this.sessionId}`).catch(() => null);
+  }
+}
+
+// packages/appium-driver/src/platform.ts
+var modelOf = (device) => device.replace(/-[^-]*$/, "");
+var versionOf = (device) => device.replace(/^.*-/, "");
+var FLUSH_ID = "perflab.flushed";
+var ACK_ID = "perflab.ack";
+var GC_ANSWER_WAIT_MS = 1e4;
+var GC_POLL_MS = 100;
+function parseBroadcastAnswer(out, n) {
+  const data = /data="([^"]*)"/.exec(String(out ?? ""))?.[1];
+  return data !== undefined && data.startsWith(`gc:${n} `) ? data : null;
+}
+var NO_WAIT_MS = 0;
+var NEW_COMMAND_TIMEOUT_S = 300;
+var IOS = {
+  name: "ios",
+  defaultDevice: "iPhone 15 Pro-17",
+  caps: (device) => ({
+    platformName: "iOS",
+    "appium:automationName": "XCUITest",
+    "appium:deviceName": modelOf(device),
+    "appium:platformVersion": versionOf(device),
+    "appium:autoAcceptAlerts": true,
+    "appium:newCommandTimeout": NEW_COMMAND_TIMEOUT_S,
+    "appium:waitForIdleTimeout": NO_WAIT_MS
+  }),
+  settings: { animationCoolOffTimeout: NO_WAIT_MS, waitForIdleTimeout: NO_WAIT_MS, shouldUseCompactResponses: true },
+  locators: (sel) => [locator(sel)],
+  keyboardShown: async (driver) => Boolean(await driver.findShown(id("Return"))),
+  appArg: (bundleId) => ({ bundleId }),
+  openLink: (driver, url, state) => openLink(driver, url, state),
+  acceptAlert: (driver, labels, waitMs) => acceptAlert(driver, labels, waitMs),
+  flush: { lookup: { using: "accessibility id", value: FLUSH_ID }, statusAttribute: "label" },
+  uploadFields: { ios_keychain_support: "true" },
+  async gcCommand(driver, n, scheme, state) {
+    await openLink(driver, gcLink(scheme, n), state);
+    const want = `type == "XCUIElementTypeStaticText" AND name == "${ACK_ID}" AND label BEGINSWITH "gc:${n} "`;
+    const deadline = driver.now() + GC_ANSWER_WAIT_MS;
+    for (;; ) {
+      const el = await driver.find("-ios predicate string", want);
+      if (el)
+        return driver.cmd("GET", `/element/${el}/attribute/label`).then(String).catch(() => {
+          driver.log.push({ ...driver.context, cmd: "gc-ack-label", t: driver.now(), ms: 0, status: 1 });
+          return `gc:${n} ok`;
+        });
+      if (driver.now() > deadline)
+        return null;
+      await driver.sleep(GC_POLL_MS);
+    }
+  }
+};
+var ANDROID = {
+  name: "android",
+  defaultDevice: "Google Pixel 7-13.0",
+  caps: (device) => ({
+    platformName: "Android",
+    "appium:automationName": "UiAutomator2",
+    "appium:deviceName": modelOf(device),
+    "appium:platformVersion": versionOf(device),
+    "appium:autoGrantPermissions": true,
+    "appium:newCommandTimeout": NEW_COMMAND_TIMEOUT_S
+  }),
+  settings: { waitForIdleTimeout: NO_WAIT_MS, actionAcknowledgmentTimeout: NO_WAIT_MS, waitForSelectorTimeout: NO_WAIT_MS, enableMultiWindows: true, ignoreUnimportantViews: true },
+  locators: androidLocators,
+  appArg: (appId) => ({ appId }),
+  async openLink(driver, url) {
+    await driver.execute("mobile: deepLink", { url, package: driver.bundleId });
+    return null;
+  },
+  async acceptAlert(driver, _labels, waitMs) {
+    const deadline = driver.now() + waitMs;
+    for (;; ) {
+      try {
+        const alertText = await driver.cmd("GET", "/alert/text");
+        await driver.cmd("POST", "/alert/accept", {});
+        return String(alertText);
+      } catch (e) {
+        if (!(e instanceof WdError && e.wdError === "no such alert"))
+          throw e;
+      }
+      if (driver.now() > deadline)
+        return null;
+      await driver.sleep(ALERT_POLL_MS);
+    }
+  },
+  flush: {
+    lookup: { using: "-android uiautomator", value: `new UiSelector().description("${FLUSH_ID}")` },
+    statusAttribute: "text",
+    fallback: { lookup: { using: "xpath", value: `//*[@content-desc="${FLUSH_ID}"]` }, setting: "allowInvisibleElements" }
+  },
+  async readScreen(driver) {
+    await driver.cmd("POST", "/appium/settings", { settings: { allowInvisibleElements: true } });
+    let xml;
+    try {
+      xml = await driver.cmd("GET", "/source");
+    } finally {
+      await driver.cmd("POST", "/appium/settings", { settings: { allowInvisibleElements: false } }).catch(() => null);
+    }
+    return new Screen(parseAndroidSource(xml), await driver.screen());
+  },
+  keyboardShown: async (driver) => Boolean(await driver.execute("mobile: isKeyboardShown")),
+  singleFindFirst: true,
+  anyOfIds: androidAnyOfIds,
+  uploadFields: {},
+  async gcCommand(driver, n) {
+    const out = await driver.execute("mobile: broadcast", {
+      action: `${driver.bundleId}.perflab.COMMAND`,
+      package: driver.bundleId,
+      extras: [["s", "cmd", "gc"], ["i", "n", String(n)]],
+      flags: "0x10000000"
+    });
+    return parseBroadcastAnswer(out, n);
+  }
+};
+var PLATFORMS = { ios: IOS, android: ANDROID };
+function platformOf(name) {
+  if (!Object.hasOwn(PLATFORMS, name))
+    throw new Error(`--platform ${name}: the Appium driver drives ios and android`);
+  return PLATFORMS[name];
+}
+
+// packages/appium-driver/src/browserstack.ts
+var HUB = "https://hub-cloud.browserstack.com/wd/hub";
+var BS_API = "https://api-cloud.browserstack.com/app-automate";
+var basicAuth = (user, key) => `Basic ${Buffer.from(`${user}:${key}`).toString("base64")}`;
+async function resolveApp(app, customId, auth, fetchImpl, platform = IOS) {
+  if (app.startsWith("bs://"))
+    return app;
+  const headers = { Authorization: auth };
+  if (customId) {
+    const res = await fetchImpl(`${BS_API}/recent_apps/${encodeURIComponent(customId)}`, { headers });
+    const list = res.ok ? await res.json().catch(() => []) : [];
+    const url = Array.isArray(list) ? list[0]?.app_url : undefined;
+    if (url)
+      return url;
+  }
+  const form = new FormData;
+  form.append("file", await openAsBlob(app), basename(app));
+  if (customId)
+    form.append("custom_id", customId);
+  for (const [k, v] of Object.entries(platform.uploadFields))
+    form.append(k, v);
+  const res = await fetchImpl(`${BS_API}/upload`, { method: "POST", headers, body: form });
+  const body = await res.json().catch(() => ({}));
+  if (!body.app_url)
+    throw new Error(`app upload failed: HTTP ${res.status} ${JSON.stringify(body)}`);
+  return body.app_url;
+}
+function sessionCaps(i) {
+  const tunnel = i.localIdentifier ? { local: true, localIdentifier: i.localIdentifier } : {};
+  return {
+    ...(i.platform ?? IOS).caps(i.device),
+    "appium:app": i.appUrl,
+    "bstack:options": {
+      projectName: "perflab",
+      buildName: i.buildName,
+      sessionName: i.sessionName,
+      ...tunnel,
+      idleTimeout: 300,
+      appiumVersion: i.appiumVersion
+    }
+  };
+}
+async function sessionDetail(sessionId, auth, fetchImpl) {
+  const res = await fetchImpl(`${BS_API}/sessions/${sessionId}.json`, { headers: { Authorization: auth } }).catch(() => null);
+  if (!res?.ok)
+    return {};
+  return (await res.json()).automation_session ?? {};
+}
+
+// packages/appium-driver/src/session.ts
+var MARKERS_PER_REQUEST = 500;
+var MARKER_TRIES = 3;
+var HOST_CLOCK_TRIPS = 6;
+var RETRY_BASE_MS = 1000;
+var RETRY_AFTER_CAP_MS = 30000;
+async function post(fetchImpl, url, token, body, now) {
+  const t0 = now();
+  try {
+    const res = await fetchImpl(url, { method: "POST", headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` }, body: JSON.stringify(body) });
+    const t3 = now();
+    const after = Number(res.headers?.get?.("retry-after"));
+    const parsed = await res.json().catch(() => null);
+    const clock = parsed?.clock;
+    const trip = typeof clock?.recv_ms === "number" && typeof clock.send_ms === "number" ? { t0, t1: clock.recv_ms, t2: clock.send_ms, t3 } : null;
+    return { status: res.status, retryAfterMs: Number.isFinite(after) && after > 0 ? after * 1000 : null, body: parsed, trip };
+  } catch {
+    return null;
+  }
+}
+async function postWithRetry(fetchImpl, url, token, body, sleep, now) {
+  let answer = null;
+  for (let attempt = 0;attempt < MARKER_TRIES; attempt++) {
+    if (attempt > 0)
+      await sleep(Math.min(answer?.retryAfterMs ?? RETRY_BASE_MS * 2 ** (attempt - 1), RETRY_AFTER_CAP_MS));
+    answer = await post(fetchImpl, url, token, body, now);
+    if (answer && answer.status !== 429 && answer.status < 500)
+      return answer;
+  }
+  return answer;
+}
+var itemsArrived = (body) => {
+  const results = body?.results;
+  return Array.isArray(results) ? results.filter((r) => r?.ok === true).length : null;
+};
+async function sendMarkers(fetchImpl, api, markers, opts = {}) {
+  const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const now = opts.now ?? Date.now;
+  const byToken = new Map;
+  for (const m of markers.splice(0)) {
+    if (!m.token || !api)
+      continue;
+    const list = byToken.get(m.token) ?? [];
+    list.push(m);
+    byToken.set(m.token, list);
+  }
+  const base = api.replace(/\/+$/, "");
+  const url = `${base}/v1/markers`;
+  let sent = 0;
+  for (const [token, list] of byToken) {
+    const trips = [];
+    const withClock = (body) => {
+      const carried = trips.splice(0);
+      return carried.length ? { ...body, clock: carried } : body;
+    };
+    const send = async (body) => {
+      const answer = await postWithRetry(fetchImpl, url, token, withClock(body), sleep, now);
+      if (answer?.trip)
+        trips.push(answer.trip);
+      return answer;
+    };
+    for (let i = 0;i < list.length; i += MARKERS_PER_REQUEST) {
+      const chunk = list.slice(i, i + MARKERS_PER_REQUEST).map((m) => ({ step: m.step, phase: m.phase, t_host: m.t_host, ...m.gc_n !== undefined ? { gc_n: m.gc_n } : {} }));
+      const answer = await send({ markers: chunk });
+      const arrived = answer && answer.status < 300 ? itemsArrived(answer.body) : null;
+      if (arrived !== null) {
+        sent += arrived;
+        continue;
+      }
+      if (answer?.status !== 400 && answer?.status !== 413 || itemsArrived(answer.body) !== null)
+        continue;
+      for (const one of chunk) {
+        const single = await send(one);
+        if (single && single.status < 300)
+          sent++;
+      }
+    }
+    for (let i = 0;i < HOST_CLOCK_TRIPS && trips.length; i++) {
+      const answer = await post(fetchImpl, `${base}/v1/clock`, token, { source: "host", samples: trips.splice(0) }, now);
+      if (answer?.trip)
+        trips.push(answer.trip);
+    }
+    if (trips.length)
+      await post(fetchImpl, `${base}/v1/clock`, token, { source: "host", samples: trips.splice(0) }, now);
+  }
+  return sent;
+}
+var SDK_FLUSH_WORST_CASE_MS = 315000;
+var FLUSH_MARGIN_MS = 30000;
+var FLUSH_WAIT_MS = SDK_FLUSH_WORST_CASE_MS + FLUSH_MARGIN_MS;
+var FLUSH_POLL_MS = 500;
+var FLUSH_FALLBACK_EVERY = 10;
+var RESCUE_EVERY_MS = 3000;
+var noop = async () => {
+  return;
+};
+
+class Session {
+  driver;
+  scheme;
+  fetch;
+  api;
+  markers = [];
+  token = "";
+  linkState = {};
+  pendingReady = null;
+  readyWaits = [];
+  actionGc;
+  endGc;
+  gcN = 0;
+  stepDepth = 0;
+  constructor(o) {
+    this.driver = o.driver;
+    this.scheme = o.scheme;
+    this.fetch = o.fetch ?? fetch;
+    this.api = o.api ?? "";
+    this.actionGc = o.actionGc ? "step" : "off";
+    this.endGc = o.endGc ?? END_GC_DEFAULT;
+  }
+  async gc(atEnd = false) {
+    if (this.actionGc !== "step" && !(atEnd && this.endGc && this.actionGc === "off"))
+      return null;
+    if (this.linkState.linkMode === "safari") {
+      this.actionGc = "safari";
+      return null;
+    }
+    const n = ++this.gcN;
+    const start = this.now();
+    const answer = await this.driver.platform.gcCommand(this.driver, n, this.scheme, this.linkState).catch(() => null);
+    this.driver.log.push({ ...this.driver.context, cmd: "gc", t: this.now(), ms: this.now() - start, status: answer === `gc:${n} ok` ? 0 : 1, ...answer !== null ? { answer } : {} });
+    if (answer === `gc:${n} ok`)
+      return n;
+    this.actionGc = answer === `gc:${n} unavailable` ? "unavailable" : "unsupported";
+    return null;
+  }
+  now() {
+    return this.driver.now();
+  }
+  expectNext(sel, timeoutMs = 1e4) {
+    this.pendingReady = { sel, timeoutMs };
+  }
+  async ready() {
+    const p = this.pendingReady;
+    if (!p)
+      return 0;
+    this.pendingReady = null;
+    const start = this.now();
+    await this.waitVisible(p.sel, p.timeoutMs);
+    const took = this.now() - start;
+    this.readyWaits.push(took);
+    this.driver.log.push({ ...this.driver.context, cmd: "ready", t: this.now(), ms: took, status: 0 });
+    return took;
+  }
+  marker(step, phase, gcN = null) {
+    this.markers.push({ token: this.token, step, phase, t_host: this.now(), ...gcN !== null ? { gc_n: gcN } : {} });
+  }
+  async step(name, action, checks = noop, once = noop) {
+    await this.ready();
+    this.driver.context = { ...this.driver.context, step: name };
+    this.stepDepth++;
+    try {
+      const gcN = this.stepDepth === 1 ? await this.gc() : null;
+      this.marker(name, "start", gcN);
+      await action();
+      await checks();
+      await once();
+      this.marker(name, "end");
+      await checks();
+    } finally {
+      this.stepDepth--;
+      const { step: _done, ...rest } = this.driver.context;
+      this.driver.context = rest;
+    }
+  }
+  isVisible(sel) {
+    return this.driver.findShown(toSelector(sel)).then(Boolean);
+  }
+  async waitVisible(sel, timeoutMs = 1e4) {
+    const s = toSelector(sel);
+    const deadline = this.now() + timeoutMs;
+    for (;; ) {
+      const el = await this.driver.findShown(s);
+      if (el)
+        return el;
+      if (this.now() > deadline)
+        throw new Error(`${describeSelector(s)} not visible within ${timeoutMs} ms`);
+      await this.driver.sleep(200);
+    }
+  }
+  async waitGone(sel, timeoutMs = 1e4) {
+    const s = toSelector(sel);
+    const deadline = this.now() + timeoutMs;
+    for (;; ) {
+      if (!await this.driver.findShown(s))
+        return;
+      if (this.now() > deadline)
+        throw new Error(`${describeSelector(s)} still visible after ${timeoutMs} ms`);
+      await this.driver.sleep(200);
+    }
+  }
+  async waitKeyboard(want, timeoutMs = 1e4) {
+    const deadline = this.now() + timeoutMs;
+    while (await this.driver.platform.keyboardShown(this.driver) !== (want === "up")) {
+      if (this.now() > deadline)
+        throw new Error(`keyboard not ${want} within ${timeoutMs} ms`);
+      await this.driver.sleep(200);
+    }
+  }
+  async waitAll(conditions, timeoutMs = 1e4) {
+    const platform = this.driver.platform;
+    if (!platform.anyOfIds) {
+      for (const c of conditions) {
+        if ("shown" in c)
+          await this.waitVisible(c.shown, timeoutMs);
+        else if ("gone" in c)
+          await this.waitGone(c.gone, timeoutMs);
+        else
+          await this.waitKeyboard(c.keyboard, timeoutMs);
+      }
+      return;
+    }
+    const elements = conditions.flatMap((c, at) => ("keyboard" in c) ? [] : [{ at, want: "shown" in c, sel: toSelector("shown" in c ? c.shown : c.gone) }]);
+    const deadline = this.now() + timeoutMs;
+    let lastRescue = -Infinity;
+    const group = conditions.some((c) => ("gone" in c));
+    for (;; ) {
+      const found = await this.driver.shownMany(elements.map((e) => e.sel), group);
+      const met = (e, i) => found[i] === e.want;
+      let unmet = elements.flatMap((e, i) => met(e, i) ? [] : [conditions[e.at]]);
+      const missing = elements.flatMap((e, i) => e.want && !found[i] ? [i] : []);
+      if (missing.length > 0 && platform.readScreen && this.now() - lastRescue >= RESCUE_EVERY_MS && await platform.keyboardShown(this.driver)) {
+        try {
+          const screen = await platform.readScreen(this.driver);
+          for (const i of missing)
+            if (screen.shown(elements[i].sel)?.length)
+              found[i] = true;
+        } catch {} finally {
+          lastRescue = this.now();
+        }
+        unmet = elements.flatMap((e, i) => met(e, i) ? [] : [conditions[e.at]]);
+      }
+      for (const c of conditions)
+        if ("keyboard" in c && await platform.keyboardShown(this.driver) !== (c.keyboard === "up"))
+          unmet.push(c);
+      if (unmet.length === 0)
+        return;
+      if (this.now() > deadline) {
+        throw new Error(`${unmet.map((c) => ("shown" in c) ? `not visible: ${describeSelector(toSelector(c.shown))}` : ("gone" in c) ? `still visible: ${describeSelector(toSelector(c.gone))}` : `keyboard not ${c.keyboard}`).join("; ")} within ${timeoutMs} ms`);
+      }
+      await this.driver.sleep(200);
+    }
+  }
+  async tap(sel, timeoutMs = 1e4) {
+    await this.ready();
+    const el = await this.waitVisible(sel, timeoutMs);
+    await this.driver.tapElement(el);
+  }
+  async tapUntil(sel, target, timeoutMs = 15000, retapAfterMs = 2000) {
+    const s = toSelector(sel);
+    const deadline = this.now() + timeoutMs;
+    let retaps = 0;
+    await this.tap(s, timeoutMs);
+    let retapAt = this.now() + retapAfterMs;
+    for (;; ) {
+      if (await this.isVisible(target))
+        return retaps;
+      if (this.now() > deadline) {
+        throw new Error(`${describeSelector(toSelector(target))} not visible within ${timeoutMs} ms of tapping ${describeSelector(s)} (${retaps + 1} taps)`);
+      }
+      if (this.now() > retapAt) {
+        const el = await this.driver.findShown(s);
+        if (el) {
+          await this.ready();
+          await this.driver.tapElement(el);
+          retaps++;
+        }
+        retapAt = this.now() + retapAfterMs;
+      }
+      await this.driver.sleep(100);
+    }
+  }
+  async swipe(from, to, durationMs = 400, target) {
+    await this.ready();
+    if (target !== undefined)
+      await this.waitVisible(target);
+    const w = await this.driver.screen();
+    const pt = ([x, y]) => ({ x: Math.round(w.width * x / 100), y: Math.round(w.height * y / 100) });
+    await this.driver.drag(pt(from), pt(to), durationMs);
+  }
+  async swipeFrom(sel, direction, durationMs = 400) {
+    await this.ready();
+    const el = await this.waitVisible(sel);
+    const r = await this.driver.cmd("GET", `/element/${el}/rect`);
+    const w = await this.driver.screen();
+    const from = { x: Math.round(r.x + r.width / 2), y: Math.round(r.y + r.height / 2) };
+    const to = { x: from.x, y: Math.round(w.height * (direction === "down" ? 0.9 : 0.1)) };
+    await this.driver.drag(from, to, durationMs);
+  }
+  async swipeUntilVisible(sel, from, to, durationMs, times) {
+    for (let i = 0;i < times && !await this.isVisible(sel); i++)
+      await this.swipe(from, to, durationMs);
+  }
+  async swipeFromUntilVisible(from, direction, target, times, durationMs = 400) {
+    for (let i = 0;i < times; i++) {
+      if (await this.isVisible(target))
+        return;
+      await this.swipeFrom(from, direction, durationMs);
+    }
+    if (!await this.isVisible(target))
+      throw new Error(`${describeSelector(toSelector(target))} not visible after ${times} swipes from ${describeSelector(toSelector(from))}`);
+  }
+  async scrollUntil(sel, { direction = "down", timeoutMs = 15000, speed = 40 } = {}) {
+    const s = toSelector(sel);
+    const deadline = this.now() + timeoutMs;
+    const durationMs = Math.round(1000 * (100 - speed) / 100) + 1;
+    for (;; ) {
+      if (await this.driver.findShown(s, true))
+        return;
+      if (this.now() > deadline)
+        throw new Error(`${describeSelector(s)} not scrolled into view within ${timeoutMs} ms`);
+      await this.swipe([50, 50], direction === "down" ? [50, 10] : [50, 90], durationMs);
+    }
+  }
+  async type(sel, value) {
+    await this.ready();
+    const el = await this.waitVisible(sel);
+    await this.driver.cmd("POST", `/element/${el}/value`, { text: value });
+  }
+  acceptAlert(labels, waitMs) {
+    return this.driver.platform.acceptAlert(this.driver, labels, waitMs);
+  }
+  openLink(url) {
+    return this.driver.platform.openLink(this.driver, url, this.linkState);
+  }
+  relaunch() {
+    this.pendingReady = null;
+    return this.driver.relaunch();
+  }
+  activate() {
+    return this.driver.activate();
+  }
+  async beginRun({ token, args = "", home }) {
+    this.token = token;
+    this.pendingReady = null;
+    await this.relaunch();
+    await this.waitVisible(home, 30000);
+    return this.openLink(activationLink(this.scheme, token, args));
+  }
+  async endRun() {
+    if (this.markers.some((m) => m.phase === "start"))
+      await this.gc(true);
+    await sendMarkers(this.fetch, this.api, this.markers, { sleep: (ms) => this.driver.sleep(ms), now: () => this.now() });
+    await this.openLink(flushLink(this.scheme));
+    const flush = this.driver.platform.flush;
+    const deadline = this.now() + FLUSH_WAIT_MS;
+    for (let poll = 1;this.now() < deadline; poll++) {
+      let el = await this.driver.find(flush.lookup.using, flush.lookup.value);
+      if (!el && flush.fallback && poll % FLUSH_FALLBACK_EVERY === 0)
+        el = await this.findFallback(flush.fallback);
+      if (el) {
+        const label = await this.driver.cmd("GET", `/element/${el}/attribute/${flush.statusAttribute}`).catch(() => null);
+        return label ?? "shown";
+      }
+      await this.driver.sleep(FLUSH_POLL_MS);
+    }
+    return null;
+  }
+  async findFallback(f) {
+    await this.driver.cmd("POST", "/appium/settings", { settings: { [f.setting]: true } });
+    try {
+      return await this.driver.find(f.lookup.using, f.lookup.value);
+    } finally {
+      await this.driver.cmd("POST", "/appium/settings", { settings: { [f.setting]: false } }).catch(() => null);
+    }
+  }
+}
+
+// packages/appium-driver/src/tokens.ts
+function parseTokensJs(text) {
+  const pick = (name) => {
+    const m = text.match(new RegExp(`output\\.${name}\\s*=\\s*(.+);\\s*$`, "m"));
+    return m ? JSON.parse(m[1]) : undefined;
+  };
+  return { api: pick("perflabApi") ?? "", tokens: pick("perflabTokens") ?? {} };
+}
+function plan(journeys, repeat, tokens) {
+  const out = [];
+  for (let i = 0;i < repeat; i++) {
+    for (const journey of journeys)
+      out.push({ journey, iteration: i + 1, token: tokens[journey]?.[i] ?? "" });
+  }
+  return out;
+}
+
+// packages/appium-driver/src/run.ts
+var realRunDeps = () => ({
+  env: process.env,
+  fetch,
+  now: Date.now,
+  sleep: realSleep,
+  print: (l) => console.log(l),
+  error: (l) => console.error(l)
+});
+var DRIVER_OPTIONS = {
+  "journey-module": { type: "string" },
+  app: { type: "string" },
+  "app-custom-id": { type: "string", default: "" },
+  "tokens-js": { type: "string" },
+  journeys: { type: "string" },
+  repeat: { type: "string", default: "1" },
+  device: { type: "string" },
+  "local-identifier": { type: "string" },
+  "build-name": { type: "string", default: "perflab-appium" },
+  "appium-version": { type: "string", default: "2.19.0" },
+  out: { type: "string", default: "farm-run" },
+  platform: { type: "string", default: "ios" },
+  "action-gc": { type: "string", default: "off" },
+  "end-gc": { type: "string", default: END_GC_DEFAULT ? "on" : "off" }
+};
+function parseDriverArgs(argv, module) {
+  const values = parseArgs({ args: [...argv], options: { ...module.options ?? {}, ...DRIVER_OPTIONS } }).values;
+  values.device ??= platformOf(String(values.platform)).defaultDevice;
+  return values;
+}
+function journeyModulePath(argv) {
+  return parseArgs({ args: [...argv], options: { "journey-module": { type: "string" } }, strict: false }).values["journey-module"];
+}
+async function runDriver(argv, module, deps = realRunDeps()) {
+  const a = parseDriverArgs(argv, module);
+  const user = deps.env.BROWSERSTACK_USERNAME;
+  const key = deps.env.BROWSERSTACK_ACCESS_KEY;
+  if (!user || !key)
+    throw new Error("BROWSERSTACK_USERNAME / BROWSERSTACK_ACCESS_KEY are not set");
+  if (!a.app || !a["tokens-js"] || !a.journeys)
+    throw new Error("--app, --tokens-js and --journeys are required");
+  const platform = platformOf(String(a.platform));
+  const journeys = String(a.journeys).split(",").map((s) => s.trim()).filter(Boolean);
+  const unknown = journeys.filter((j) => !Object.hasOwn(module.journeys, j));
+  if (unknown.length)
+    throw new Error(`the journey module has no journey ${unknown.map((j) => `"${j}"`).join(", ")} (it has ${Object.keys(module.journeys).join(", ") || "none"})`);
+  const repeat = Number(a.repeat);
+  if (!Number.isInteger(repeat) || repeat < 1)
+    throw new Error("--repeat must be a whole number >= 1");
+  if (a["action-gc"] !== "on" && a["action-gc"] !== "off")
+    throw new Error("--action-gc must be on or off");
+  if (a["end-gc"] !== "on" && a["end-gc"] !== "off")
+    throw new Error("--end-gc must be on or off");
+  const out = String(a.out);
+  const auth = basicAuth(user, key);
+  mkdirSync(out, { recursive: true });
+  const { api, tokens } = parseTokensJs(readFileSync(String(a["tokens-js"]), "utf8"));
+  const appUrl = await resolveApp(String(a.app), String(a["app-custom-id"] ?? ""), auth, deps.fetch, platform);
+  deps.print(`app: ${appUrl}`);
+  const log = [];
+  const driver = new Driver({ hub: HUB, log, headers: { Authorization: auth }, bundleId: module.app.bundleId, platform, fetch: deps.fetch, now: deps.now, sleep: deps.sleep });
+  const t = new Session({ driver, scheme: module.app.scheme, fetch: deps.fetch, api, actionGc: a["action-gc"] === "on", endGc: a["end-gc"] === "on" });
+  const sessionName = module.sessionName ?? "perflab (appium)";
+  const device = String(a.device);
+  const ctx = { fetch: deps.fetch, tokens, journeys, repeat, args: a };
+  const caps = sessionCaps({ appUrl, device, buildName: String(a["build-name"]), sessionName, appiumVersion: String(a["appium-version"]), platform, localIdentifier: a["local-identifier"] });
+  const startedAt = deps.now();
+  let error = null;
+  const iterations = [];
+  try {
+    await driver.start(caps);
+    deps.print(`session ${driver.sessionId}`);
+    await driver.cmd("POST", "/appium/settings", { settings: platform.settings }).catch(() => null);
+    await module.setup?.(t, ctx);
+    await runIterations(t, module, ctx, iterations);
+  } catch (e) {
+    error = e instanceof Error ? e : new Error(String(e));
+    deps.error(`::error::${error.message}`);
+    if (driver.sessionId) {
+      const source = await driver.cmd("GET", "/source").catch(() => null);
+      if (typeof source === "string")
+        writeFileSync(join(out, "failure-source.xml"), source);
+      const png = await driver.cmd("GET", "/screenshot").catch(() => null);
+      if (typeof png === "string")
+        writeFileSync(join(out, "failure-screen.png"), Buffer.from(png, "base64"));
+    }
+  }
+  if (driver.sessionId) {
+    driver.context = { phase: "final-flush" };
+    await t.endRun().catch(() => null);
+    const reason = error ? error.message.slice(0, 250) : `${sessionName} done`;
+    await driver.execute(`browserstack_executor: ${JSON.stringify({ action: "setSessionStatus", arguments: { status: error ? "failed" : "passed", reason } })}`).catch(() => null);
+  }
+  const endedAt = deps.now();
+  await driver.end();
+  const detail = driver.sessionId ? await sessionDetail(driver.sessionId, auth, deps.fetch) : {};
+  const buildId = detail.build_hashed_id ?? null;
+  writeFileSync(join(out, `browserstack.${String(a.platform)}.json`), `${JSON.stringify({
+    driver: "appium",
+    status: error ? "failed" : "passed",
+    buildId,
+    dashboard: detail.public_url ?? detail.browser_url ?? null,
+    devices: [{ device, sessions: [{ id: driver.sessionId, ...error ? { error: { message: error.message } } : {} }] }]
+  }, null, 2)}
+`);
+  writeFileSync(join(out, "driver-log.json"), `${JSON.stringify({ driver: "appium", device, appUrl, session: driver.sessionId, buildId, linkMode: t.linkState.linkMode ?? null, actionGc: t.actionGc, endGc: t.endGc, linkError: t.linkState.linkError ?? null, startedAt, endedAt, total_ms: endedAt - startedAt, error: error?.message ?? null, iterations, commands: log }, null, 2)}
+`);
+  deps.print(`driver-log.json: ${log.length} commands, ${iterations.length} iterations, ${Math.round((endedAt - startedAt) / 1000)} s`);
+  for (const r of iterations)
+    deps.print(`  ${r.journey} #${r.iteration}: ${r.total_ms ?? "?"} ms, flushed=${r.flushed}`);
+  return error ? 1 : 0;
+}
+async function runIterations(t, module, ctx, iterations) {
+  const { driver } = t;
+  for (const it of plan(ctx.journeys, ctx.repeat, ctx.tokens)) {
+    const rec = { journey: it.journey, iteration: it.iteration, token: it.token !== "" };
+    iterations.push(rec);
+    driver.context = { journey: it.journey, iteration: it.iteration, phase: "begin" };
+    const t0 = t.now();
+    rec.alert = await t.beginRun({ token: it.token, home: module.home, ...module.sdkArgs ? { args: module.sdkArgs } : {} });
+    const t1 = t.now();
+    driver.context = { ...driver.context, phase: "journey" };
+    const waitsBefore = t.readyWaits.length;
+    await module.journeys[it.journey](t, { ...ctx, journey: it.journey, iteration: it.iteration });
+    await t.ready();
+    const t2 = t.now();
+    t.marker("run:complete", "end");
+    rec.steps = t.markers.filter((m) => m.phase === "start").length;
+    const waits = t.readyWaits.slice(waitsBefore);
+    rec.ready = { n: waits.length, ms: waits.reduce((x, y) => x + y, 0) };
+    driver.context = { ...driver.context, phase: "end" };
+    rec.flushed = await t.endRun();
+    const t3 = t.now();
+    Object.assign(rec, { t_start: t0, begin_ms: t1 - t0, journey_ms: t2 - t1, end_ms: t3 - t2, total_ms: t3 - t0 });
+  }
+}
+
+// packages/appium-driver/src/load.ts
+async function loadJourneyModule(path, cwd = process.cwd()) {
+  const file = isAbsolute(path) ? path : resolve(cwd, path);
+  const mod = await import(pathToFileURL(file).href);
+  const m = mod.default ?? mod;
+  if (!m.app?.bundleId || !m.app.scheme)
+    throw new Error(`${path}: the journey module must export app: { bundleId, scheme }`);
+  if (m.home === undefined)
+    throw new Error(`${path}: the journey module must export home (the selector visible after launch)`);
+  if (!m.journeys || Object.keys(m.journeys).length === 0)
+    throw new Error(`${path}: the journey module must export journeys: { <name>: async (t, ctx) => {...} }`);
+  return m;
+}
+async function main(argv) {
+  const path = journeyModulePath(argv);
+  if (!path)
+    throw new Error("--journey-module <file> is required");
+  return runDriver(argv, await loadJourneyModule(path));
+}
+
+// packages/appium-driver/src/cli.ts
+main(process.argv.slice(2)).then((code) => process.exit(code), (e) => {
+  console.error(`::error::${e instanceof Error ? e.message : String(e)}`);
+  process.exit(1);
+});