@keepsnappy/agent 0.1.0-alpha.18 → 0.1.0-alpha.20

package/README.md

@@ -70,7 +70,7 @@ Annotated example: `examples/keepsnappy.yml`. Every setting:
 
 Unknown settings and wrong types are errors, all listed together.
 
-Results and exit codes: results never change the exit code by default (ruling D9, no blocking PR checks): `0` also for "More work". `--fail-on-worse` (needs `--wait`) fails the job (exit `3`) only when the verdict computed on that run set is Worse and blocking. Closing a run set never computes its verdict (decision 0031: the operator computes verdicts on demand), so with no computed verdict `--fail-on-worse` checks nothing: the CLI prints `Verdict not computed yet (computed on demand): --fail-on-worse checked nothing` and exits `0`. The CLI exits `2` for a configuration problem (bad or missing `keepsnappy.yml`, unknown or misspelt flags, a glob matching nothing, `--wait` without a branch or key) and `1` for an infrastructure problem (cannot read the device log, an API request failing, an API URL that does not answer as the KeepSnappy API, `--upload` that sent no run: "Blocked"; results stay in the out dir). Failed runs are marked invalid in `runs.ndjson` / `metrics.csv` and ignored by the statistics. The ending summary reads like:
+Results and exit codes: results never change the exit code by default (ruling D9, no blocking PR checks): `0` also for "More work". `--fail-on-worse` (needs `--wait`) fails the job (exit `3`) only when the verdict computed on that run set is Worse and blocking. Closing a run set never computes its verdict (decision 0031: the operator computes verdicts on demand), so with no computed verdict `--fail-on-worse` checks nothing: the CLI prints `Verdict not computed yet (computed on demand): --fail-on-worse checked nothing` and exits `0`. The CLI exits `2` for a configuration problem (bad or missing `keepsnappy.yml`, unknown or misspelt flags, a glob matching nothing, `--wait` without a branch or key) and `1` for an infrastructure problem (cannot read the device log, an API request failing, an API URL that does not answer as the KeepSnappy API, `--upload` that sent no run: "Blocked", or a local run with no valid run; results stay in the out dir). For a local run with no valid run, it prints `No valid run was recorded` with the invalid reasons when known. Failed runs are marked invalid in `runs.ndjson` / `metrics.csv` and ignored by the statistics. The ending summary reads like:
 
 ```
 7/8 runs valid (dropped: 1 test-failed: exit 1)
@@ -105,7 +105,7 @@ keepsnappy farm close --state farm-run/keepsnappy-farm.json --bs-build farm-run/
 
 `keepsnappy farm run` does the whole night in one command (docs/plans/54a): resolve the app (`--app eas:<id>|file|bs://<id>|custom_id:<id>`), `farm open`, an optional BrowserStack Local tunnel (`--tunnel-for localhost:<port>`, repeatable), the device run (`--driver maestro` with `--suite-dir`/`--execute`, or `--driver appium --journey-module FILE` for the built-in Appium driver on iOS or Android, `@keepsnappy/appium-driver`, docs/plans/54b; `--driver-script FILE` still runs your own driver), `farm close`, and cleanup (tunnel stopped, tokens file reset) whatever happened. `--env KEY=VALUE` values may use `{tunnel:<port>}`, `{run_id}`, `{out}`, `{tokens_js}`, `{run_set_id}`. Pre-uploaded `bs://` and `custom_id:` app references pass through without a file upload. Appium uses `--timeout-minutes 80` by default: the driver receives SIGTERM at the timeout, then SIGKILL after `--kill-after-seconds 120` if it has not exited. A timeout is recorded in the failure message, including the terminating signal, and returns exit 1 even if the driver exits zero after SIGTERM. Exit codes as `farm close`; a failed device run is 1. `--dry-run` prints the plan with no request. Needs `KEEPSNAPPY_KEY`, `BROWSERSTACK_USERNAME`, `BROWSERSTACK_ACCESS_KEY` (and `EXPO_TOKEN` for `eas:`).
 
-Setup and completion (plan 51 stage 2): `--completion-marker` declares that the flow posts the step marker `run:complete` (end) at the end of every iteration, from the main flow and not from `onFlowComplete`; the API then marks a run without it invalid (`flow-incomplete`). `--driver-version`, `--app-build-id`, `--harness-version`, `--flag-set` go into every run's setup fingerprint; `farm close` adds the device farm's build id from `--bs-build`.
+Setup and completion (plan 51 stage 2): `--completion-marker` declares that the flow posts the step marker `run:complete` (end) at the end of every iteration, from the main flow and not from `onFlowComplete`; the API then marks a run without it invalid (`flow-incomplete`). `--driver-version`, `--app-build-id`, `--harness-version`, `--flag-set` go into every run's setup fingerprint; `farm close` adds the device farm's build id from `--bs-build`. `--plant JSON` records what the build plants against main (a truth runner's planted variant) as the run set's `meta.plant`: a list of `{ place, kind, factor, unit }`, `factor` > 0 in `unit` `budget` (multiples of the frame budget) or `MB`; the quality report shows it as the session's dose.
 
 The model a phone is stored under is the hardware code the OS reports (`SM-S911B`, `iPhone17,1`); the marketing name is only shown. With `--platform android|ios`, `--device-provider local|usb|customer|simulator|emulator` (the default `browserstack` needs an explicit model: a farm's phone is not on this machine) and no `--device-model`, `farm open` reads it from the device: Android `adb [-s <serial>] shell getprop ro.product.model`, an iPhone's machine id from `xcrun devicectl list devices`, a simulator's name from `xcrun simctl list devices` (kept with its "Simulator" word, so it never joins a real phone's row). With `--platform ios` and a `--device-id` that `xcrun simctl` lists as a simulator, `farm open` opens the run set as a simulator whatever provider and model were typed: provider `simulator`, the model with the "Simulator" word. It reads nothing it cannot pin to exactly one device (`--device-id` picks one); then `--device-model` is required. A typed `--device-model` is for a device this machine cannot ask (a farm's phone) and is sent as given.
 

package/dist/appium-driver.js

@@ -507,23 +507,29 @@ class Driver {
     });
     await this.cmd("DELETE", "/actions").catch(() => null);
   }
-  async drag(from, to, durationMs) {
+  async drag(from, to, durationMs, note) {
     to = { x: to.x, y: Math.min(to.y, await this.safeBottomY()) };
-    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 }
-          ]
-        }
-      ]
-    });
+    const logged = this.log.length;
+    try {
+      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 }
+            ]
+          }
+        ]
+      });
+    } finally {
+      if (note && this.log[logged])
+        Object.assign(this.log[logged], note);
+    }
     await this.cmd("DELETE", "/actions").catch(() => null);
   }
   async relaunch(bundleId = this.bundleId) {
@@ -720,13 +726,311 @@ async function sessionDetail(sessionId, auth, fetchImpl) {
   return (await res.json()).automation_session ?? {};
 }
 
+// packages/appium-driver/src/gestures.ts
+var FLING = {
+  end: [0.85, 0.25],
+  top: [0.3, 0.9],
+  minTravel: 250,
+  contactMs: 150,
+  startMargin: 0.1
+};
+function flingStroke(r, toward, unit, safeBottom, start) {
+  const [f, t] = FLING[toward];
+  const travel = Math.round(Math.max(Math.abs(t - f) * r.height, FLING.minTravel * unit));
+  const step = toward === "end" ? -travel : travel;
+  const clamp = (y) => Math.min(Math.max(y, 0), safeBottom);
+  let from = Math.round(start ?? r.y + r.height * f);
+  const below = Math.max(from, from + step) - safeBottom;
+  const above = -Math.min(from, from + step);
+  if (below > 0)
+    from = Math.max(from - below, Math.min(from, Math.round(r.y + r.height * FLING.startMargin)));
+  else if (above > 0)
+    from = Math.min(from + above, Math.max(from, Math.round(r.y + r.height * (1 - FLING.startMargin))));
+  from = clamp(from);
+  const to = clamp(from + step);
+  return { from, to, travel, clamped: Math.abs(to - from) < travel };
+}
+
+// packages/appium-driver/src/scroll.ts
+var COAST_POLL_MS = 300;
+var COAST_MAX_MS = 3000;
+var FLING_UNMOVED_MS = 4500;
+
+class GestureNotTaken extends Error {
+  name = "GestureNotTaken";
+}
+async function scrollList(t, spec, toward, { at, cache, hold, mustMove = false, coastMaxMs = COAST_MAX_MS } = {}) {
+  if (spec.screen) {
+    if (t.driver.platform.name === "ios" && spec.row !== undefined)
+      await drawnRowDrag(t, spec, toward);
+    else {
+      await t.ready();
+      await listGesture(t, (await t.frameOf(spec.list, await t.waitVisible(spec.list))).rect, toward);
+    }
+    return { outcome: "moved", retried: false, sentAt: t.now() };
+  }
+  if (at)
+    return { ...await listGesture(t, at, toward), retried: false };
+  const c = cache ?? {};
+  const checked = mustMove && spec.row !== undefined;
+  const ios = t.driver.platform.name === "ios";
+  const held = checked && ios ? hold ?? (c.hold ??= {}) : hold;
+  const send = async (first) => {
+    c.at = await t.frameOf(spec.list, c.at?.el ?? await t.waitVisible(spec.list));
+    if (first && held)
+      await holdBeforeScroll(t, spec.row, handle(spec, c), spec.field, held);
+    const before = checked && ios ? await heldFrame(t, held) : null;
+    const g = await listGesture(t, c.at.rect, toward);
+    const after = before ? await heldFrame(t, held) : null;
+    const suspect = ios ? before !== null && before === after : g.outcome === "unmoved";
+    return { ...g, suspect };
+  };
+  const first = await send(true);
+  if (!checked)
+    return { outcome: first.outcome, answer: first.answer, answerMs: first.answerMs, sentAt: first.sentAt, retried: false };
+  if (!first.suspect)
+    return { outcome: "moved", answer: first.answer, answerMs: first.answerMs, sentAt: first.sentAt, retried: false };
+  await waitCoasted(t, spec.row, handle(spec, c), spec.field, coastMaxMs, held);
+  const before = await rowsInList(t, spec, c);
+  if (!room(t, before, toward))
+    return { outcome: "at-edge", answer: first.answer, answerMs: first.answerMs, sentAt: first.sentAt, retried: false };
+  const label = listLabel(spec.list);
+  const defect = {
+    ...t.driver.context,
+    step: t.driver.context.step ?? null,
+    t: t.now(),
+    list: label,
+    toward,
+    reason: "unmoved",
+    before: before.ids,
+    after: null,
+    answer: ios ? null : first.answer,
+    answerMs: ios ? null : first.answerMs ?? null
+  };
+  t.defects.gestureRetry++;
+  t.defects.items.push(defect);
+  const again = await send(false);
+  await waitCoasted(t, spec.row, handle(spec, c), spec.field, coastMaxMs, held);
+  const after = await rowsInList(t, spec, c);
+  defect.after = after.ids;
+  if (after.ids.join(`
+`) === before.ids.join(`
+`))
+    throw new GestureNotTaken(`list ${label} did not move after 2 identical gestures (the device took no scroll)`);
+  return { outcome: "moved", answer: again.answer, answerMs: again.answerMs, sentAt: again.sentAt, retried: true };
+}
+var handle = (spec, c) => spec.scoped ?? true ? { sel: spec.list, el: c.at?.el } : undefined;
+var listLabel = (list) => {
+  const s = toSelector(list);
+  return s.id ?? s.text ?? describeSelector(s);
+};
+async function heldFrame(t, hold) {
+  if (!hold.el)
+    return null;
+  try {
+    const r = await t.driver.cmd("GET", `/element/${hold.el}/rect`);
+    return `${r.x},${r.y},${r.width},${r.height}`;
+  } catch {
+    hold.el = null;
+    return null;
+  }
+}
+async function rowsInList(t, spec, c) {
+  c.at = await t.frameOf(spec.list, c.at?.el ?? await t.waitVisible(spec.list));
+  const list = c.at.rect;
+  const { childOf: _list, ...sel } = toSelector(spec.row);
+  const all = t.driver.platform.locators(sel);
+  const android = t.driver.platform.name === "android";
+  const call = spec.field === "description" ? /descriptionMatches/ : /textMatches/;
+  const own = android && spec.field ? all.filter((l) => call.test(l.value)) : all;
+  const attr = sel.text !== undefined ? android ? spec.field === "description" ? "content-desc" : "text" : "label" : android ? "resource-id" : "name";
+  const frames = [];
+  const inside = [];
+  const parent = spec.scoped ?? true ? c.at.el : undefined;
+  for (const { using, value } of own.length ? own : all) {
+    for (const el of await t.driver.findAll(using, value, parent)) {
+      let r;
+      try {
+        r = await t.driver.cmd("GET", `/element/${el}/rect`);
+      } catch {
+        continue;
+      }
+      if (r.width <= 0 || r.height <= 0)
+        continue;
+      frames.push(r);
+      if (r.y < list.y + list.height && r.y + r.height > list.y)
+        inside.push({ y: r.y, el });
+    }
+    if (frames.length)
+      break;
+  }
+  const ids = [];
+  for (const { el } of inside.sort((a, b) => a.y - b.y))
+    ids.push(String(await t.driver.attribute(el, attr).catch(() => null) ?? ""));
+  return { ids, frames, list };
+}
+function room(t, { frames, list }, toward) {
+  if (frames.length === 0)
+    return false;
+  const android = t.driver.platform.name === "android";
+  const bottom = list.y + list.height;
+  if (toward === "end") {
+    const reach = Math.max(...frames.map((r) => r.y + r.height));
+    return android ? reach >= bottom - 1 : reach > bottom;
+  }
+  const reach = Math.min(...frames.map((r) => r.y));
+  return android ? reach <= list.y + 1 : reach < list.y;
+}
+async function listGesture(t, r, toward) {
+  await t.ready();
+  const android = t.driver.platform.name === "android";
+  const safe = await t.driver.safeBottomY();
+  const s = flingStroke(r, toward, android ? await t.driver.density() : 1, safe);
+  const note = s.clamped ? { clamped: true, travel: Math.abs(s.to - s.from) } : undefined;
+  if (android) {
+    const logged = t.driver.log.length;
+    const sent = t.now();
+    const answer = await t.driver.execute("mobile: flingGesture", {
+      left: r.x,
+      top: Math.min(s.from, s.to),
+      width: r.width,
+      height: Math.abs(s.to - s.from),
+      direction: toward === "end" ? "down" : "up",
+      speed: Math.round(1000 * Math.abs(s.to - s.from) / FLING.contactMs)
+    });
+    const answerMs = t.now() - sent;
+    if (note && t.driver.log[logged])
+      Object.assign(t.driver.log[logged], note);
+    return { outcome: answer === false && answerMs >= FLING_UNMOVED_MS ? "unmoved" : "moved", answer, answerMs, sentAt: t.now() };
+  }
+  await drag(t, Math.round(r.x + r.width / 2), s, note);
+  return { outcome: "moved", sentAt: t.now() };
+}
+var drag = (t, x, s, note) => t.driver.drag({ x, y: s.from }, { x, y: s.to }, FLING.contactMs, note);
+async function drawnRowDrag(t, { list, row, above, missingMessage = "no drawn row to scroll from" }, toward) {
+  await t.ready();
+  const { using, value } = t.driver.platform.locators(toSelector(row))[0];
+  let start = null;
+  const drawnAbove = [];
+  if (toward === "top") {
+    const limit = above ? (await t.driver.cmd("GET", `/element/${await t.waitVisible(toSelector(above))}/rect`)).y : Infinity;
+    let lowest = null;
+    for (const el of await t.driver.findAll(using, value)) {
+      if (await t.driver.cmd("GET", `/element/${el}/attribute/visible`) !== "true")
+        continue;
+      const r = await t.driver.cmd("GET", `/element/${el}/rect`);
+      if (!lowest || r.y > lowest.y)
+        lowest = r;
+      if (r.y + r.height > limit)
+        continue;
+      drawnAbove.push(r);
+      if (!start || r.y > start.y)
+        start = r;
+    }
+    start ??= lowest;
+  } else {
+    for (const el of await t.driver.findAll(using, `${value} AND visible == 1`)) {
+      const r = await t.driver.cmd("GET", `/element/${el}/rect`);
+      if (!start || r.y > start.y)
+        start = r;
+    }
+  }
+  if (!start)
+    throw new Error(missingMessage);
+  const x = Math.round(start.x + start.width / 2);
+  const listEl = await t.driver.findShown(toSelector(list));
+  const l = listEl ? await t.driver.cmd("GET", `/element/${listEl}/rect`) : await t.driver.screen();
+  let y = Math.round(start.y + start.height / 2);
+  if (toward === "end")
+    y = Math.min(Math.max(y, l.y + 1), l.y + l.height - 1);
+  const safe = await t.driver.safeBottomY();
+  let s = flingStroke(l, toward, 1, safe, y);
+  if (toward === "top" && s.from !== y && !(drawnAbove.some((r) => r.y <= s.from && s.from < r.y + r.height) && s.from > l.y && s.from < l.y + l.height)) {
+    s = { ...s, from: y, to: Math.min(y + s.travel, safe), clamped: true };
+  }
+  await drag(t, x, s, s.clamped ? { clamped: true, travel: Math.abs(s.to - s.from) } : undefined);
+}
+async function firstDrawn(t, row, listEl, field, scopedOrField) {
+  if (!scopedOrField) {
+    return t.driver.findShown(toSelector(row));
+  }
+  const { childOf: _list, ...inList } = toSelector(row);
+  const all = t.driver.platform.locators(inList);
+  const call = field === "text" ? /textMatches/ : /descriptionMatches/;
+  const own = t.driver.platform.name === "android" && field ? all.filter((l) => call.test(l.value)) : all;
+  for (const { using, value } of own.length ? own : all) {
+    const drawn = t.driver.platform.name === "ios" && using === "-ios predicate string" ? `${value} AND visible == 1` : value;
+    const found = await t.driver.find(using, drawn, listEl);
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+async function holdBeforeScroll(t, row, list, field, hold) {
+  if (!hold || hold.el) {
+    return;
+  }
+  try {
+    hold.el = await firstDrawn(t, row, list?.el, field, Boolean(list || field));
+  } catch {
+    hold.el = null;
+  }
+}
+async function waitCoasted(t, row, list, field, maxMs = COAST_MAX_MS, hold) {
+  const until = t.now() + maxMs;
+  let el = list?.el;
+  let refinds = 0;
+  const read = async () => {
+    if (hold?.el) {
+      try {
+        return await t.driver.cmd("GET", `/element/${hold.el}/rect`);
+      } catch {
+        hold.el = null;
+      }
+    }
+    const found = await firstDrawn(t, row, el, field, Boolean(list || field));
+    if (found && hold) {
+      hold.el = found;
+    }
+    return found ? t.driver.cmd("GET", `/element/${found}/rect`) : null;
+  };
+  let last = null;
+  let reads = 0;
+  for (;; ) {
+    let r = null;
+    reads++;
+    try {
+      r = await read();
+    } catch {
+      r = null;
+    }
+    if (r === null && list && refinds < 2) {
+      refinds++;
+      el = await t.waitVisible(list.sel);
+      continue;
+    }
+    const frame = r && `${r.x},${r.y},${r.width},${r.height}`;
+    if (frame && frame === last)
+      return true;
+    if (t.now() >= until && reads >= 2)
+      return false;
+    last = frame;
+    await t.driver.sleep(COAST_POLL_MS);
+  }
+}
+
+// packages/appium-driver/src/lists.ts
+var LOOK_MS = 1000;
+var LOOK_POLL_MS = 100;
+
 // packages/appium-driver/src/version.ts
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 var DRIVER_NAME = "appium";
 function driverVersion() {
-  const built = "0.1.0-alpha.18";
+  const built = "0.1.0-alpha.20";
   if (built)
     return built;
   let dir = dirname(fileURLToPath(import.meta.url));
@@ -748,9 +1052,6 @@ var MARKERS_PER_REQUEST = 500;
 var MARKER_TRIES = 3;
 var HOST_CLOCK_TRIPS = 6;
 var RETRY_BASE_MS = 1000;
-var FLING_MS = 80;
-var FLING_FROM = 0.8;
-var FLING_TO = 0.3;
 var FLING_TIMEOUT_MS = 30000;
 var STALE_REFINDS = 3;
 var FRAME_POLL_MS = 50;
@@ -800,7 +1101,10 @@ async function sendMarkers(fetchImpl, api, markers, opts = {}) {
   const url = `${base}/v1/markers`;
   const version = (opts.driverVersion ?? driverVersion)();
   const reported = opts.reported ?? new Set;
-  const driverField = { driver: { name: DRIVER_NAME, ...version ? { version } : {}, ...opts.deviceUnit ? { unit: opts.deviceUnit.slice(0, 200) } : {}, ...opts.capture ? { capture: opts.capture } : {} } };
+  const driverField = (token) => {
+    const defects = opts.defects?.(token);
+    return { driver: { name: DRIVER_NAME, ...version ? { version } : {}, ...opts.deviceUnit ? { unit: opts.deviceUnit.slice(0, 200) } : {}, ...opts.capture ? { capture: opts.capture } : {}, ...defects ? { defects } : {} } };
+  };
   let sent = 0;
   for (const [token, list] of byToken) {
     const trips = [];
@@ -809,7 +1113,7 @@ async function sendMarkers(fetchImpl, api, markers, opts = {}) {
       return carried.length ? { ...body, clock: carried } : body;
     };
     const send = async (body) => {
-      const answer = await postWithRetry(fetchImpl, url, token, { ...withClock(body), ...reported.has(token) ? {} : driverField }, sleep, now);
+      const answer = await postWithRetry(fetchImpl, url, token, { ...withClock(body), ...reported.has(token) ? {} : driverField(token) }, sleep, now);
       if (answer && answer.status < 300)
         reported.add(token);
       if (answer?.trip)
@@ -843,7 +1147,7 @@ async function sendMarkers(fetchImpl, api, markers, opts = {}) {
   for (const token of opts.tokens ?? []) {
     if (byToken.has(token) || reported.has(token) || !token || !api)
       continue;
-    const answer = await postWithRetry(fetchImpl, `${base}/v1/clock`, token, { source: "host", samples: [], ...driverField }, sleep, now);
+    const answer = await postWithRetry(fetchImpl, `${base}/v1/clock`, token, { source: "host", samples: [], ...driverField(token) }, sleep, now);
     reported.add(token);
     if (!answer || answer.status >= 300)
       opts.note?.(`driver report for a run not accepted (${answer?.status ?? "no answer"}); not tried again`);
@@ -889,6 +1193,14 @@ var RESCUE_EVERY_MS = 3000;
 var noop = async () => {
   return;
 };
+var RETRY_COMMAND = /-retry$/;
+function harnessDefects(commands, gestureRetries) {
+  const out = { gestureRetry: gestureRetries };
+  for (const c of commands)
+    if (RETRY_COMMAND.test(c.cmd))
+      out[c.cmd] = (out[c.cmd] ?? 0) + 1;
+  return out;
+}
 
 class Session {
   driver;
@@ -1136,16 +1448,21 @@ class Session {
     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 } = {}) {
+  async scrollUntil(sel, { direction = "down", timeoutMs = 15000 } = {}) {
     const s = toSelector(sel);
     const deadline = this.now() + timeoutMs;
-    const durationMs = Math.round(1000 * (100 - speed) / 100) + 1;
+    let lookUntil = 0;
     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);
+      if (this.now() < lookUntil) {
+        await this.driver.sleep(LOOK_POLL_MS);
+        continue;
+      }
+      await scrollList(this, {}, direction === "down" ? "end" : "top", { at: await this.driver.screen() });
+      lookUntil = this.now() + LOOK_MS;
     }
   }
   async frameOf(sel, el) {
@@ -1180,12 +1497,10 @@ class Session {
       at = now;
     }
   }
-  async flingIn(r, toward, durationMs) {
-    const [from, to] = toward === "end" ? [FLING_FROM, FLING_TO] : [FLING_TO, FLING_FROM];
-    const x = Math.round(r.x + r.width / 2);
-    await this.driver.drag({ x, y: Math.round(r.y + r.height * from) }, { x, y: Math.round(r.y + r.height * to) }, durationMs);
+  async flingIn(r, toward) {
+    await scrollList(this, {}, toward, { at: r });
   }
-  async flingTimes(list, times, toward, { durationMs = FLING_MS, timeoutMs = FLING_TIMEOUT_MS } = {}) {
+  async flingTimes(list, times, toward, { timeoutMs = FLING_TIMEOUT_MS } = {}) {
     if (!Number.isInteger(times) || times < 1)
       throw new Error(`flingTimes needs a whole number of flings >= 1, got ${times}`);
     await this.ready();
@@ -1196,13 +1511,13 @@ class Session {
     try {
       const { rect } = await this.settledFrame(list, timeoutMs);
       for (;flings < times; flings++)
-        await this.flingIn(rect, toward, durationMs);
+        await this.flingIn(rect, toward);
       status = 0;
     } finally {
       this.driver.log.push({ ...this.driver.context, cmd: `fling-${toward}-times`, t: this.now(), ms: this.now() - start, status, flings, refinds: this.refinds - refindsBefore });
     }
   }
-  async flingUntil(list, target, toward, { blind = 0, durationMs = FLING_MS, timeoutMs = FLING_TIMEOUT_MS } = {}) {
+  async flingUntil(list, target, toward, { blind = 0, timeoutMs = FLING_TIMEOUT_MS } = {}) {
     await this.ready();
     const start = this.now();
     const refindsBefore = this.refinds;
@@ -1214,7 +1529,7 @@ class Session {
       const fling = async () => {
         if (flings > 0)
           at = await this.frameOf(list, at.el);
-        await this.flingIn(at.rect, toward, durationMs);
+        await this.flingIn(at.rect, toward);
         flings++;
       };
       while (flings < blind)
@@ -1282,6 +1597,7 @@ class Session {
     this.token = token;
     if (token)
       this.opened.add(token);
+    this.runFrom = { commands: this.driver.log.length, gestureRetries: this.defects.gestureRetry };
     this.pendingReady = null;
     await this.relaunch();
     await this.waitVisible(home, 30000);
@@ -1291,12 +1607,17 @@ class Session {
   }
   opened = new Set;
   told = new Set;
+  runFrom = null;
+  runDefects = new Map;
   lastFlush = null;
   flushSeq = 0;
   async endRun() {
     if (this.markers.some((m) => m.phase === "start"))
       await this.memRead(await this.gc(true));
-    await sendMarkers(this.fetch, this.api, this.markers, { sleep: (ms) => this.driver.sleep(ms), now: () => this.now(), deviceUnit: this.driver.deviceUnit, capture: this.capture, tokens: [...this.opened], reported: this.told, note: (line) => this.driver.log.push({ ...this.driver.context, cmd: "driver-report", t: this.now(), ms: 0, status: 1, answer: line }) });
+    if (this.runFrom && this.token)
+      this.runDefects.set(this.token, harnessDefects(this.driver.log.slice(this.runFrom.commands), this.defects.gestureRetry - this.runFrom.gestureRetries));
+    this.runFrom = null;
+    await sendMarkers(this.fetch, this.api, this.markers, { sleep: (ms) => this.driver.sleep(ms), now: () => this.now(), deviceUnit: this.driver.deviceUnit, capture: this.capture, defects: (token) => this.runDefects.get(token), tokens: [...this.opened], reported: this.told, note: (line) => this.driver.log.push({ ...this.driver.context, cmd: "driver-report", t: this.now(), ms: 0, status: 1, answer: line }) });
     const evidence = { linkAt: this.now(), resentAt: null, ackAt: null, gaveUpAt: null };
     this.lastFlush = evidence;
     const acks = new Set;