@vosjs/render-core 0.8.0 → 0.9.0

package/dist/record/index.js

@@ -1274,8 +1274,79 @@ async function fitSurfaceToViewport(cdp, width, height) {
 function visibleTextScript(text) {
   return `(() => { const b = document.body; return !!b && (b.innerText || '').includes(${JSON.stringify(text)}) })()`;
 }
+var JS_SAID_MAX = 120;
+var JS_VALUE_MAX = 2048;
+function jsConditionScript(expr) {
+  return `(async () => {
+  let v;
+  try { v = await (${expr}
+  ); } catch (e) { return JSON.stringify({ threw: String(e && e.message ? e.message : e) }) }
+  const out = { truthy: !!v };
+  try { const j = JSON.stringify(v); if (j !== undefined) out.json = j } catch (e) {}
+  try { out.said = typeof v === 'string' ? JSON.stringify(v) : String(v) } catch (e) { out.said = typeof v }
+  if (out.json !== undefined && typeof v !== 'string') out.said = out.json
+  return JSON.stringify(out);
+})()`;
+}
+function sameJson(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b || a === null || b === null) return false;
+  if (typeof a !== "object") return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const bb = b;
+    return a.length === bb.length && a.every((v, i) => sameJson(v, bb[i]));
+  }
+  const ao = a;
+  const bo = b;
+  const keys = Object.keys(ao);
+  if (keys.length !== Object.keys(bo).length) return false;
+  return keys.every(
+    (k) => Object.prototype.hasOwnProperty.call(bo, k) && sameJson(ao[k], bo[k])
+  );
+}
+async function readJs(page, c) {
+  let raw;
+  try {
+    raw = await page.evaluate(jsConditionScript(c.js));
+  } catch (e) {
+    const why = e instanceof Error ? e.message : String(e);
+    if (/SyntaxError/.test(why) || e instanceof Error && e.name === "SyntaxError")
+      return { holds: false, threw: `it does not parse: ${why.split("\n")[0]}` };
+    throw e;
+  }
+  let got;
+  try {
+    got = JSON.parse(raw);
+  } catch {
+    return { holds: false };
+  }
+  if (got.threw !== void 0) return { holds: false, threw: got.threw };
+  let value;
+  let hasValue = false;
+  if (got.json !== void 0) {
+    try {
+      value = JSON.parse(got.json);
+      hasValue = true;
+    } catch {
+    }
+  }
+  const holds = c.equals !== void 0 ? hasValue && sameJson(value, c.equals) : got.truthy === true;
+  return {
+    holds,
+    ...hasValue ? { value } : {},
+    said: clip(got.said ?? "undefined", JS_SAID_MAX)
+  };
+}
+var clip = (s, max) => s.length > max ? `${s.slice(0, max - 1)}\u2026` : s;
+function keptValue(value) {
+  const json = JSON.stringify(value);
+  if (json === void 0) return void 0;
+  return json.length <= JS_VALUE_MAX ? value : clip(json, JS_VALUE_MAX);
+}
 async function readCondition(page, c) {
   try {
+    if (c.js !== void 0) return await readJs(page, { ...c, js: c.js });
     if (c.text !== void 0)
       return { holds: await page.evaluate(visibleTextScript(c.text)) };
     if (c.gone !== void 0)
@@ -1347,6 +1418,8 @@ function sayDuration(ms) {
   return rest ? `${m} min ${rest} s` : `${m} min`;
 }
 function sayCondition(c) {
+  if (c.js !== void 0)
+    return c.equals !== void 0 ? `${sayJs(c.js)} to equal ${clip(JSON.stringify(c.equals) ?? "undefined", JS_SAID_MAX)}` : `${sayJs(c.js)} to hold`;
   if (c.text !== void 0) return `text "${c.text}" to show`;
   if (c.gone !== void 0) return `'${c.gone}' to go`;
   if (c.enabled === true) return `'${c.selector}' to be enabled`;
@@ -1355,6 +1428,12 @@ function sayCondition(c) {
 }
 function conditionMiss(c, last, ms) {
   const t = sayDuration(ms);
+  if (c.js !== void 0) {
+    if (last.threw !== void 0)
+      return `${sayJs(c.js)} threw for ${t} (${clip(last.threw, JS_SAID_MAX)})`;
+    const was = last.said ?? "never answered";
+    return c.equals !== void 0 ? `${sayJs(c.js)} was ${was}, not ${clip(JSON.stringify(c.equals) ?? "undefined", JS_SAID_MAX)}, for ${t}` : `${sayJs(c.js)} was ${was} for ${t}`;
+  }
   if (c.text !== void 0)
     return `no visible text contained "${c.text}" for ${t}`;
   if (c.gone !== void 0) return `'${c.gone}' was still there after ${t}`;
@@ -1364,6 +1443,12 @@ function conditionMiss(c, last, ms) {
     return `'${c.selector}' stayed enabled for ${t}`;
   return `'${c.selector}' never appeared in ${t}`;
 }
+function sayJs(expr) {
+  return `js \`${clip(expr.replace(/\s+/g, " ").trim(), 80)}\``;
+}
+function sayValue(value) {
+  return clip(JSON.stringify(value) ?? "undefined", JS_SAID_MAX);
+}
 
 // src/record/ready.ts
 var READY_MODES = ["dom", "networkidle"];
@@ -1814,10 +1899,455 @@ async function appSettled(page, frames, opts) {
   });
 }
 
+// src/record/peers.ts
+var PEER_VERBS = [
+  "wait",
+  "move",
+  "hover",
+  "click",
+  "type",
+  "press",
+  "scroll",
+  "drag",
+  "expect"
+];
+var MAX_PEERS = 4;
+var MAX_PEER_STEPS = 200;
+var TAKE_ONLY = {
+  guard: "a guard is pressed only on the filmed page, under --confirm",
+  read: "read keeps words from the filmed page",
+  caption: "a caption is a beat of the film, which is the take\u2019s",
+  settle: "settle reads the filmed page\u2019s frames",
+  zoom: "a zoom mark picks a moment on the cursor track, and a peer is never on it"
+};
+var PEER_ID = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+function validatePeers(value, takeSteps, validate) {
+  if (!Array.isArray(value))
+    return [
+      "peers must be an array of { id, url?, viewport?, storageState?, steps }"
+    ];
+  const errors = [];
+  if (value.length > MAX_PEERS)
+    errors.push(
+      `peers names ${value.length} peers; a take holds at most ${MAX_PEERS} (each is a whole browser)`
+    );
+  const takeIds = new Set(
+    (Array.isArray(takeSteps) ? takeSteps : []).map((s) => s?.id).filter((id) => typeof id === "string")
+  );
+  const seen = /* @__PURE__ */ new Set();
+  value.forEach((raw, i) => {
+    const at = `peers[${i}]`;
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+      errors.push(`${at}: must be an object`);
+      return;
+    }
+    const p = raw;
+    if (typeof p.id !== "string" || !PEER_ID.test(p.id))
+      errors.push(
+        `${at}: id must be a short word (letters, digits, - and _, at most 32), which lines and meta.peers name the peer by`
+      );
+    else if (seen.has(p.id)) errors.push(`${at}: duplicate peer id "${p.id}"`);
+    else seen.add(p.id);
+    if (p.url !== void 0) {
+      if (typeof p.url !== "string") errors.push(`${at}: url must be a string`);
+      else {
+        const problem = urlSchemeProblem(p.url);
+        if (problem) errors.push(`${at}: url ${problem}`);
+      }
+    }
+    if (p.viewport !== void 0) {
+      const v = p.viewport;
+      if (typeof v !== "object" || v === null || typeof v.width !== "number" || typeof v.height !== "number")
+        errors.push(`${at}: viewport must be { width, height }`);
+    }
+    if (p.storageState !== void 0 && (typeof p.storageState !== "string" || !p.storageState.trim()))
+      errors.push(
+        `${at}: storageState must name a Playwright storage state file (the second person's sign-in)`
+      );
+    for (const k of Object.keys(p))
+      if (!["id", "url", "viewport", "storageState", "steps"].includes(k))
+        errors.push(
+          `${at}: a peer takes id, url, viewport, storageState and steps, not ${k}`
+        );
+    if (!Array.isArray(p.steps) || p.steps.length === 0) {
+      errors.push(`${at}: steps must be a non-empty array`);
+      return;
+    }
+    if (p.steps.length > MAX_PEER_STEPS)
+      errors.push(
+        `${at}: steps holds ${p.steps.length} steps; a peer takes at most ${MAX_PEER_STEPS}`
+      );
+    const steps = p.steps;
+    steps.forEach((rawStep, j) => {
+      const sat = `${at}.steps[${j}]`;
+      if (typeof rawStep !== "object" || rawStep === null) return;
+      const s = rawStep;
+      if (typeof s.do === "string" && !PEER_VERBS.includes(s.do))
+        errors.push(
+          `${sat}: a peer step is one of ${PEER_VERBS.join(", ")}; ${/^[aeiou]/.test(s.do) ? "an" : "a"} ${s.do} belongs to the filmed page${s.do === "await" ? " (wait for what the peer did with the take\u2019s own await or expect)" : ""}`
+        );
+      for (const [k, why] of Object.entries(TAKE_ONLY))
+        if (s[k] !== void 0)
+          errors.push(`${sat}: no ${k} on a peer step: ${why}`);
+      if (s.do === "drag" && typeof s.path === "string")
+        errors.push(
+          `${sat}: a peer draws its path inline (an array of points), never from a file`
+        );
+      if (s.with !== void 0 && s.after !== void 0)
+        errors.push(
+          `${sat}: with or after, not both (with starts as the take's step starts, after once it ends)`
+        );
+      for (const k of ["with", "after"]) {
+        const v = s[k];
+        if (v === void 0) continue;
+        if (typeof v !== "string" || !v.trim())
+          errors.push(`${sat}: ${k} must name a take step by its id`);
+        else if (!takeIds.has(v))
+          errors.push(
+            `${sat}: ${k} "${v}" names no take step (the take's steps with ids: ${takeIds.size ? [...takeIds].join(", ") : "none"}); give the take step an id`
+          );
+      }
+    });
+    for (const e of validate(steps))
+      errors.push(e.replace(/^steps\[/, `${at}.steps[`));
+  });
+  return errors;
+}
+function peersHostedRefusal(peers) {
+  if (!Array.isArray(peers) || !peers.length) return null;
+  return "the script has peers (more browsers on the page, off camera), and a hosted take runs one browser: record it on this machine";
+}
+var StepSignals = class {
+  started = /* @__PURE__ */ new Map();
+  ended = /* @__PURE__ */ new Map();
+  began = deferred();
+  closed = false;
+  constructor(ids) {
+    for (const id of ids) {
+      this.started.set(id, deferred());
+      this.ended.set(id, deferred());
+    }
+  }
+  begin() {
+    this.began.resolve(true);
+  }
+  start(id) {
+    if (id) this.started.get(id)?.resolve(true);
+  }
+  end(id) {
+    if (id) this.ended.get(id)?.resolve(true);
+  }
+  close() {
+    this.closed = true;
+    this.began.resolve(false);
+    for (const d of [...this.started.values(), ...this.ended.values()])
+      d.resolve(false);
+  }
+  get isClosed() {
+    return this.closed;
+  }
+  /** When a step with this trigger may start: true, or false for never. */
+  when(trigger) {
+    const d = trigger.with ? this.started.get(trigger.with) : trigger.after ? this.ended.get(trigger.after) : this.began;
+    if (!d) return { ready: Promise.resolve(false), already: false };
+    return { ready: d.promise, already: d.settled };
+  }
+};
+function deferred() {
+  let resolve = () => {
+  };
+  const d = {
+    promise: new Promise((r) => {
+      resolve = r;
+    }),
+    resolve: (v) => {
+      if (d.settled) return;
+      d.settled = true;
+      resolve(v);
+    },
+    settled: false
+  };
+  return d;
+}
+var PEER_VALUE_MAX = 2048;
+function peerValue(last) {
+  if (!("value" in last)) return void 0;
+  const value = last.value;
+  const json = JSON.stringify(value);
+  if (json === void 0) return void 0;
+  return json.length <= PEER_VALUE_MAX ? value : `${json.slice(0, PEER_VALUE_MAX - 1)}\u2026`;
+}
+var EXPECT_TIMEOUT_S = 5;
+var EXPECT_EVERY_MS = 150;
+async function runPeer(peer, rawPage, signals, opts) {
+  const bound = new StepBound();
+  const page = bounded(rawPage, bound);
+  const { clock, log } = opts;
+  const run = { id: peer.id, steps: [], notRun: [] };
+  const cur = { x: 24, y: 24 };
+  const moveTo = async (tx, ty) => {
+    const from = { ...cur };
+    const dist = Math.hypot(tx - from.x, ty - from.y);
+    await clockMotion(
+      opts.dry ? 0 : pointerTravelMs(dist),
+      async (u) => {
+        cur.x = from.x + (tx - from.x) * u;
+        cur.y = from.y + (ty - from.y) * u;
+        await page.mouse.move(cur.x, cur.y);
+      },
+      clock
+    );
+  };
+  const spotOf = async (s) => {
+    if (s.selector === void 0) return { x: s.x ?? cur.x, y: s.y ?? cur.y };
+    const loc = page.locator(s.selector).first();
+    try {
+      await loc.waitFor({ state: "visible", timeout: 8e3 });
+      await loc.scrollIntoViewIfNeeded();
+      const bb = await loc.boundingBox();
+      return bb ? { x: bb.x + bb.width / 2, y: bb.y + bb.height / 2 } : null;
+    } catch {
+      return null;
+    }
+  };
+  const press = async (how) => {
+    const held = [];
+    try {
+      for (const m of how.modifiers ?? []) {
+        const key = resolveModifier(m);
+        await page.keyboard.down(key);
+        held.push(key);
+      }
+      await clock.sleep(PRESS_LEAD_MS);
+      const count = how.count ?? 1;
+      for (let n = 1; n <= count; n++) {
+        if (n > 1) await clock.sleep(MULTI_CLICK_GAP_MS);
+        const o = {
+          ...how.button && how.button !== "left" ? { button: how.button } : {},
+          ...n > 1 ? { clickCount: n } : {}
+        };
+        const has = Object.keys(o).length > 0;
+        await (has ? page.mouse.down(o) : page.mouse.down());
+        await clock.sleep(PRESS_HOLD_MS);
+        await (has ? page.mouse.up(o) : page.mouse.up());
+      }
+    } finally {
+      for (const key of held.reverse())
+        await page.keyboard.up(key).catch(() => void 0);
+    }
+  };
+  for (const [i, step] of peer.steps.entries()) {
+    const tag = `peer ${peer.id} #${i}${step.id ? ` ${step.id}` : ""}`;
+    const trigger = signals.when(step);
+    const go = await trigger.ready;
+    if (!go) {
+      run.notRun = peer.steps.slice(i).map((_, k) => i + k);
+      log(
+        `   (${tag} ${step.do}: not run: ${step.with ? `the take's step ${step.with} never started` : step.after ? `the take's step ${step.after} never ended` : "the take ended first"})`
+      );
+      break;
+    }
+    const late = (step.with !== void 0 || step.after !== void 0) && trigger.already;
+    const tStart = opts.footageMs();
+    let selector;
+    let reason = null;
+    let value;
+    bound.start(
+      stepBoundMs(
+        step,
+        askedMs(step),
+        { expectS: EXPECT_TIMEOUT_S, awaitS: 0, downloadS: 0 }
+      )
+    );
+    try {
+      switch (step.do) {
+        case "wait":
+          await clock.sleep(step.ms);
+          break;
+        case "move":
+          await moveTo(step.x, step.y);
+          break;
+        case "hover": {
+          selector = step.selector;
+          const spot = await spotOf(step);
+          if (!spot) reason = `'${step.selector}' never appeared`;
+          else {
+            await moveTo(spot.x, spot.y);
+            await clock.sleep(step.ms ?? 700);
+          }
+          break;
+        }
+        case "click": {
+          selector = step.selector;
+          const spot = await spotOf(step);
+          if (!spot) {
+            reason = `'${step.selector}' never appeared`;
+            break;
+          }
+          await moveTo(spot.x, spot.y);
+          await press(step);
+          await clock.sleep(step.ms ?? SETTLE_MS.click);
+          break;
+        }
+        case "type": {
+          selector = step.selector;
+          if (step.focus !== false) {
+            const spot = await spotOf(step);
+            if (!spot) {
+              reason = `'${step.selector}' never appeared`;
+              break;
+            }
+            await moveTo(spot.x, spot.y);
+            await press({});
+          }
+          if (step.at === "end") await page.keyboard.press("End");
+          else if (step.at === "start") await page.keyboard.press("Home");
+          if (step.replace) await page.keyboard.press("ControlOrMeta+a");
+          await clockTyping(
+            [...step.text],
+            opts.dry ? 0 : step.delayMs ?? 40,
+            (ch) => page.keyboard.type(ch),
+            clock
+          );
+          await clock.sleep(step.ms ?? SETTLE_MS.type);
+          break;
+        }
+        case "press": {
+          selector = step.selector;
+          if (step.selector !== void 0) {
+            const spot = await spotOf(step);
+            if (!spot) {
+              reason = `'${step.selector}' never appeared`;
+              break;
+            }
+          }
+          const keys = pressSequence(step);
+          for (const [k, key] of keys.entries()) {
+            if (k > 0) await clock.sleep(KEY_SEQUENCE_GAP_MS);
+            await page.keyboard.press(resolveChord(key));
+          }
+          await clock.sleep(step.ms ?? SETTLE_MS.press);
+          break;
+        }
+        case "scroll":
+          await page.mouse.wheel(0, step.dy);
+          await clock.sleep(step.ms ?? 200);
+          break;
+        case "drag": {
+          selector = step.selector;
+          const read = step.path !== void 0 ? readPath(step.path) : null;
+          if (read && "problems" in read) {
+            reason = `its path ${read.problems.join("; ")}`;
+            break;
+          }
+          const held = [];
+          try {
+            if (read) {
+              const sched = schedulePath(read, step.ms);
+              await moveTo(sched[0].x, sched[0].y);
+              for (const m of step.modifiers ?? []) {
+                const key = resolveModifier(m);
+                await page.keyboard.down(key);
+                held.push(key);
+              }
+              await page.mouse.down();
+              const t0 = clock.now();
+              for (const p of sched.slice(1)) {
+                const wait = t0 + (opts.dry ? 0 : p.at) - clock.now();
+                if (wait > 0) await clock.sleep(wait);
+                cur.x = p.x;
+                cur.y = p.y;
+                await page.mouse.move(p.x, p.y);
+              }
+            } else {
+              const start = await spotOf(step);
+              if (!start) {
+                reason = `'${step.selector}' never appeared`;
+                break;
+              }
+              await moveTo(start.x, start.y);
+              for (const m of step.modifiers ?? []) {
+                const key = resolveModifier(m);
+                await page.keyboard.down(key);
+                held.push(key);
+              }
+              await page.mouse.down();
+              const from = { ...cur };
+              const tx = step.tx;
+              const ty = step.ty;
+              await clockMotion(
+                opts.dry ? 0 : step.ms ?? 700,
+                async (u) => {
+                  cur.x = from.x + (tx - from.x) * u;
+                  cur.y = from.y + (ty - from.y) * u;
+                  await page.mouse.move(cur.x, cur.y);
+                },
+                clock
+              );
+            }
+            await page.mouse.up();
+          } finally {
+            for (const key of held.reverse())
+              await page.keyboard.up(key).catch(() => void 0);
+          }
+          await clock.sleep(DRAG_HOLD_MS);
+          break;
+        }
+        case "expect": {
+          const cond = step;
+          selector = step.selector ?? step.gone;
+          const timeoutMs = (step.timeout ?? EXPECT_TIMEOUT_S) * 1e3;
+          const res = await pollCondition(page, cond, {
+            timeoutMs,
+            everyMs: EXPECT_EVERY_MS,
+            sleep: clock.sleep
+          });
+          value = peerValue(res.last);
+          if (!res.ok) reason = conditionMiss(cond, res.last, timeoutMs);
+          else log(`   ${tag} expect ${sayCondition(cond)}: holds`);
+          break;
+        }
+        default:
+          reason = `a peer does not ${step.do}`;
+      }
+    } catch (e) {
+      reason = e instanceof Error ? e.message.split("\n")[0] : String(e);
+    }
+    const hang = bound.end();
+    if (hang.hung)
+      reason = `the page stopped answering: this ${step.do} ran past its bound`;
+    if (reason) log(`   (${tag} ${step.do}: ${reason})`);
+    else if (step.do !== "expect")
+      log(`   ${tag} ${step.do}${selector ? ` ${selector}` : ""}`);
+    run.steps.push({
+      step: i,
+      ...step.id ? { id: step.id } : {},
+      do: step.do,
+      ...step.with ? { with: step.with } : {},
+      ...step.after ? { after: step.after } : {},
+      ...selector ? { selector } : {},
+      tStart: +(tStart / 1e3).toFixed(3),
+      tEnd: +(opts.footageMs() / 1e3).toFixed(3),
+      ...reason ? { skipped: true, reason } : {},
+      ...late ? { late: true } : {},
+      ...value !== void 0 ? { value } : {}
+    });
+  }
+  return run;
+}
+
 // src/record/actions.ts
 var STEP_GUARDS = ["spend"];
+var ZOOM_MARK_VERBS = [
+  "click",
+  "drag",
+  "type",
+  "paste",
+  "press",
+  "hover"
+];
 var GUARDABLE = /* @__PURE__ */ new Set(["click", "press", "type"]);
-var EXPECT_TIMEOUT_S = 5;
+var EXPECT_TIMEOUT_S2 = 5;
 var AWAIT_TIMEOUT_S = 600;
 var AWAIT_POLL_S = 2;
 var DOWNLOAD_TIMEOUT_S = 30;
@@ -1901,6 +2431,14 @@ function validateActions(value) {
     errors.push("steps must be a non-empty array");
     return errors;
   }
+  if (obj.peers !== void 0)
+    errors.push(
+      ...validatePeers(
+        obj.peers,
+        obj.steps,
+        (steps) => validateActions({ steps })
+      )
+    );
   const seenIds = /* @__PURE__ */ new Set();
   obj.steps.forEach((raw, i) => {
     const at = `steps[${i}]`;
@@ -2020,6 +2558,14 @@ function validateActions(value) {
     if (s.do === "move" && (typeof s.x !== "number" || typeof s.y !== "number")) {
       errors.push(`${at}: move needs x and y (CSS px)`);
     }
+    if (s.zoom !== void 0) {
+      if (typeof s.zoom !== "boolean")
+        errors.push(`${at}: zoom must be true or false`);
+      else if (!ZOOM_MARK_VERBS.includes(s.do))
+        errors.push(
+          `${at}: zoom marks a gesture (${ZOOM_MARK_VERBS.join(", ")}); a ${s.do} shows nothing to zoom on`
+        );
+    }
     if (s.guard !== void 0) {
       if (!STEP_GUARDS.includes(s.guard))
         errors.push(
@@ -2035,16 +2581,17 @@ function validateActions(value) {
         );
     }
     if (s.do === "expect") {
-      const given = ["selector", "text", "gone"].filter(
+      const given = ["selector", "text", "gone", "js"].filter(
         (k) => s[k] !== void 0
       );
       if (given.length !== 1)
         errors.push(
-          `${at}: expect needs exactly one of selector, text or gone${given.length ? ` (it has ${given.join(" and ")})` : ""}`
+          `${at}: expect needs exactly one of selector, text, gone or js${given.length ? ` (it has ${given.join(" and ")})` : ""}`
         );
       for (const k of given)
         if (!isFilled(s[k]))
           errors.push(`${at}: expect ${k} must be a non-empty string`);
+      errors.push(...equalsProblem(`${at}: expect`, s));
       if (s.enabled !== void 0) {
         if (typeof s.enabled !== "boolean")
           errors.push(`${at}: expect enabled must be true or false`);
@@ -2059,28 +2606,29 @@ function validateActions(value) {
       const u = s.until;
       if (typeof u !== "object" || u === null || Array.isArray(u)) {
         errors.push(
-          `${at}: await needs until, one of { "selector" }, { "text" } or { "gone" }`
+          `${at}: await needs until, one of { "selector" }, { "text" }, { "gone" } or { "js" }`
         );
       } else {
         const until = u;
         const keys = Object.keys(until);
         const known = keys.filter(
-          (k) => k === "selector" || k === "text" || k === "gone"
+          (k) => k === "selector" || k === "text" || k === "gone" || k === "js"
         );
-        const unknown = keys.filter((k) => !known.includes(k));
+        const unknown = keys.filter((k) => !known.includes(k) && k !== "equals");
         if (unknown.length)
           errors.push(
-            `${at}: await until takes selector, text or gone, not ${unknown.join(", ")}`
+            `${at}: await until takes selector, text, gone or js (with equals), not ${unknown.join(", ")}`
           );
         if (known.length !== 1)
           errors.push(
-            `${at}: await until needs exactly one of selector, text or gone${known.length ? ` (it has ${known.join(" and ")})` : ""}`
+            `${at}: await until needs exactly one of selector, text, gone or js${known.length ? ` (it has ${known.join(" and ")})` : ""}`
           );
         for (const k of known) {
           const v = until[k];
           if (typeof v !== "string" || !v.trim())
             errors.push(`${at}: await until.${k} must be a non-empty string`);
         }
+        errors.push(...equalsProblem(`${at}: await until`, until));
       }
       errors.push(...secondsProblem(at, "await timeout", s.timeout));
       errors.push(...secondsProblem(at, "await poll", s.poll));
@@ -2151,6 +2699,29 @@ function modifiersProblem(at, verb, v) {
     return [`${at}: ${verb} modifiers names a modifier twice`];
   return [];
 }
+function equalsProblem(at, s) {
+  if (s.equals === void 0) return [];
+  if (s.js === void 0)
+    return [
+      `${at} equals is the value a js expression must answer, so it needs js`
+    ];
+  if (!isJsonValue(s.equals, 0))
+    return [
+      `${at} equals must be a JSON value (a number, a string, true, false, null, a list or an object of them)`
+    ];
+  return [];
+}
+function isJsonValue(v, depth) {
+  if (depth > 32) return false;
+  if (v === null || typeof v === "string" || typeof v === "boolean") return true;
+  if (typeof v === "number") return Number.isFinite(v);
+  if (Array.isArray(v)) return v.every((x) => isJsonValue(x, depth + 1));
+  if (typeof v === "object")
+    return Object.values(v).every(
+      (x) => isJsonValue(x, depth + 1)
+    );
+  return false;
+}
 var isFilled = (v) => typeof v === "string" && v.trim().length > 0;
 function secondsProblem(at, what, v) {
   if (v === void 0) return [];
@@ -2203,6 +2774,8 @@ function guardVerdict(actions, confirm) {
 }
 function hostedRefusals(actions) {
   const out = [];
+  const peers = peersHostedRefusal(actions.peers);
+  if (peers) out.push(peers);
   for (const g of guardedSteps(actions))
     out.push(
       `steps[${g.step}] (${g.id}) is guarded (${g.guard}), and a hosted take has no way to confirm it: record it on this machine with --confirm ${g.id}`
@@ -2216,6 +2789,10 @@ function hostedRefusals(actions) {
       out.push(
         `steps[${i}] is a paste, and a hosted browser has no clipboard to paste from: record it on this machine`
       );
+    if (s.do === "expect" && s.js !== void 0 || s.do === "await" && s.until.js !== void 0)
+      out.push(
+        `steps[${i}] ${s.do === "expect" ? "checks" : "waits on"} a js expression, which runs as code in the page, and a hosted browser runs no script it was handed: record it on this machine, or check what the page shows (selector, text or gone)`
+      );
     if (s.do === "drag" && typeof s.path === "string")
       out.push(
         `steps[${i}] draws a path from the file "${s.path}", and a hosted take carries the script alone: write the points inline as path`
@@ -2255,7 +2832,7 @@ async function loadScriptFiles(actions, source) {
     } catch (e) {
       const why = e instanceof Error ? e.message : String(e);
       return {
-        problem: f.as === "paste" ? `${at} pastes the file "${f.name}", which could not be read beside the actions file (${why}): a file paste needs its file beside the script, so put ${f.name} next to it (a take fetched from vos.so carries its paths and its words, never a pasted file). Nothing was recorded.` : `${at} names "${f.name}", which could not be read beside the actions file (${why}). Nothing was recorded.`
+        problem: f.as === "paste" ? `${at} pastes the file "${f.name}", which could not be read beside the actions file (${why}): a file paste needs its file beside the script, so put ${f.name} next to it (a take fetched with its media brings its pasted files home beside its script; one pushed before they travelled with it does not). Nothing was recorded.` : `${at} names "${f.name}", which could not be read beside the actions file (${why}). Nothing was recorded.`
       };
     }
     if (f.as === "path") {
@@ -2416,7 +2993,7 @@ function fetchInPageScript(url) {
 }
 
 // src/record/recorder.ts
-var EXPECT_EVERY_MS = 100;
+var EXPECT_EVERY_MS2 = 100;
 var SRC_WAIT_MS = 8e3;
 var AWAIT_HEARTBEAT_MS = 3e4;
 var MIN_SKIP_MS = 250;
@@ -2509,6 +3086,22 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const read = await loadScriptFiles(actions, opts.files);
   if ("problem" in read) throw new RecordRefusedError(read.problem);
   const files = read;
+  const peers = actions.peers ?? [];
+  const peerStates = /* @__PURE__ */ new Map();
+  for (const p of peers) {
+    if (p.storageState === void 0) continue;
+    if (!opts.peerStorageState)
+      throw new RecordRefusedError(
+        `peer ${p.id} signs in from the storage state "${p.storageState}", and this recorder has nowhere to read one from. Nothing was recorded.`
+      );
+    try {
+      peerStates.set(p.id, await opts.peerStorageState(p.storageState));
+    } catch (e) {
+      throw new RecordRefusedError(
+        `peer ${p.id}'s storage state "${p.storageState}" could not be read (${e instanceof Error ? e.message : String(e)}). Nothing was recorded.`
+      );
+    }
+  }
   const vw = actions.viewport?.width ?? 1280;
   const vh = actions.viewport?.height ?? 720;
   const context = opts.context ?? await browser.newContext({
@@ -2587,6 +3180,59 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   await page.evaluate(MEDIA_DRAIN_PROBE).catch(() => null);
   if (actions.steps.some((s) => settleOn(s, actions.settle)))
     await page.evaluate(CHANGE_AGE_PROBE).catch(() => void 0);
+  const peerPages = [];
+  const closePeers = async () => {
+    const bound = new StepBound();
+    bound.start(CLOSE_BOUND_MS);
+    await Promise.all(
+      peerPages.map((p) => bound.race(p.context.close().catch(() => {
+      })))
+    );
+    bound.end();
+  };
+  for (const peer of peers) {
+    const peerUrl = peer.url ?? url;
+    const pctx = await browser.newContext({
+      viewport: peer.viewport ?? { width: vw, height: vh },
+      deviceScaleFactor: 1,
+      ...peerStates.has(peer.id) ? { storageState: peerStates.get(peer.id) } : {}
+    });
+    if (opts.headers && Object.keys(opts.headers).length)
+      await applyHeaders(pctx, opts.headers, peerUrl, log);
+    const ppage = await pctx.newPage();
+    peerPages.push({ peer, context: pctx, page: ppage });
+    const peerErrors = new PageErrorLog(opts.verbose === true);
+    ppage.on("console", (m) => {
+      if (m.type() !== "error") return;
+      const line = peerErrors.add(m.text());
+      if (line) log(`   peer ${peer.id}: ${line.trim()}`);
+    });
+    log(`peer ${peer.id}: goto ${peerUrl} (off camera)`);
+    const popened = await untilReady(
+      ppage,
+      readyMode,
+      (o) => ppage.goto(peerUrl, o),
+      { sleep: realSleep }
+    );
+    const seen = await ppage.evaluate(WALL_PROBE).catch(() => null);
+    const peerWall = wallVerdict({
+      askedUrl: peerUrl,
+      landedUrl: ppage.url(),
+      ...popened.response ? { status: popened.response.status() } : {},
+      passwordFields: seen?.passwordFields ?? 0,
+      newPasswordField: seen?.newPasswordField ?? false,
+      oneTimeCodeField: seen?.oneTimeCodeField ?? false
+    });
+    if (peerWall?.level === "hard") {
+      await closePeers();
+      await context.close().catch(() => {
+      });
+      throw new RecordRefusedError(
+        `peer ${peer.id} landed on ${peerWall.landed}, not ${peerWall.asked} (${peerWall.kind}): a peer acts as someone signed in, so give it a storageState of the second person's sign-in (beside actions.json). Nothing was recorded.`
+      );
+    }
+    log(`   peer ${peer.id}: ${readyLine(popened.ready)}`);
+  }
   const cdp = await context.newCDPSession(rawPage);
   if (!dry) await fitSurfaceToViewport(cdp, vw, vh);
   const frames = [];
@@ -2805,6 +3451,23 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   let stopped = null;
   let unpressedGuard = null;
   let capped = false;
+  const signals = new StepSignals(
+    actions.steps.map((s) => s.id).filter((id) => !!id)
+  );
+  const lanes = peerPages.map(
+    ({ peer, page: ppage }) => runPeer(peer, ppage, signals, {
+      clock: { now: () => Date.now(), sleep },
+      footageMs: () => now(),
+      log,
+      dry
+    }).catch((e) => {
+      log(
+        `   (peer ${peer.id}: stopped: ${e instanceof Error ? e.message : String(e)})`
+      );
+      return { id: peer.id, steps: [], notRun: [] };
+    })
+  );
+  signals.begin();
   for (const [stepIdx, step] of actions.steps.entries()) {
     if (capReached(now(), maxSeconds)) {
       capped = true;
@@ -2844,6 +3507,12 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       if (reason) extra.reason = reason;
     };
     if (step.guard) extra.guard = step.guard;
+    if (typeof step.zoom === "boolean") extra.zoom = step.zoom;
+    const keepValue = (last) => {
+      if (!("value" in last)) return;
+      const kept = keptValue(last.value);
+      if (kept !== void 0) extra.value = kept;
+    };
     const rehearseGuard = async (sel, point) => {
       if (!step.guard || !dry) return false;
       const rect = sel ? await boxOf(sel) : null;
@@ -2872,7 +3541,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       step,
       askedMs(step),
       {
-        expectS: EXPECT_TIMEOUT_S,
+        expectS: EXPECT_TIMEOUT_S2,
         awaitS: AWAIT_TIMEOUT_S,
         downloadS: DOWNLOAD_TIMEOUT_S
       }
@@ -2884,6 +3553,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       ...step.id ? { id: step.id } : {},
       do: step.do
     });
+    signals.start(step.id);
     const stepWall = Date.now();
     pageBound.start(boundMs);
     switch (step.do) {
@@ -3225,12 +3895,13 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       case "expect": {
         if (notWaited()) break;
         const cond = step;
-        const timeoutMs = (step.timeout ?? EXPECT_TIMEOUT_S) * 1e3;
+        const timeoutMs = (step.timeout ?? EXPECT_TIMEOUT_S2) * 1e3;
         const res = await pollCondition(page, cond, {
           timeoutMs,
-          everyMs: EXPECT_EVERY_MS,
+          everyMs: EXPECT_EVERY_MS2,
           sleep: realSleep
         });
+        keepValue(res.last);
         if (res.ok) log(`expect ${sayCondition(cond)}: holds`);
         else {
           const reason = conditionMiss(cond, res.last, timeoutMs);
@@ -3275,6 +3946,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
           clearInterval(beat);
         }
         const { out, at, ms } = waited;
+        keepValue(out.last);
         opts.onEvent?.({ ...awaitEvent, phase: "end", ms, held: out.ok });
         extra.offCameraMs = ms;
         if (!out.ok) extra.timedOut = true;
@@ -3459,6 +4131,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     await drainSound(stepIdx);
     pageBound.end();
     const stepSpan = stepSpans[stepSpans.length - 1];
+    signals.end(step.id);
     opts.onEvent?.({
       event: "step",
       phase: "end",
@@ -3471,6 +4144,19 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     });
     if (stopped) break;
   }
+  signals.close();
+  const peerRuns = await Promise.all(lanes);
+  for (const pr of peerRuns)
+    for (const ps of pr.steps)
+      if (ps.skipped)
+        skipped.push({
+          step: ps.step,
+          ...ps.id ? { id: ps.id } : {},
+          do: ps.do,
+          selector: ps.selector ?? "",
+          ...ps.reason ? { reason: ps.reason } : {},
+          peer: pr.id
+        });
   if (!capped && !stopped) await sleep(TRAILING_HOLD_MS);
   if (capped || capReached(now(), maxSeconds)) {
     capped = true;
@@ -3497,6 +4183,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   await pageBound.race(context.close().catch(() => {
   }));
   pageBound.end();
+  await closePeers();
   await sinkChain;
   const meta = {
     dpr: 1,
@@ -3523,7 +4210,14 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     ...masks.length ? { masks: exposureLog.masks(masks) } : {},
     ...skips.length ? { skips } : {},
     ...outputs.length ? { outputs } : {},
-    ...media.length ? { media } : {}
+    ...media.length ? { media } : {},
+    ...peerRuns.length ? {
+      peers: peerRuns.map((pr) => ({
+        id: pr.id,
+        steps: pr.steps,
+        ...pr.notRun.length ? { notRun: pr.notRun } : {}
+      }))
+    } : {}
   };
   const freezes = [];
   for (let i = 1; i < frames.length; i++) {
@@ -3570,7 +4264,8 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     overruns,
     // Self-contained: a path a file held is inline, so the take re-records
     // from its own script with the file gone.
-    actions: { ...inlineScript(actions, files), url }
+    actions: { ...inlineScript(actions, files), url },
+    peers: peerRuns
   };
 }
 async function keepPageSound(heard, sink, fetchSource, log) {
@@ -3834,16 +4529,20 @@ export {
   DOWNLOAD_TIMEOUT_S,
   DRAG_HOLD_MS,
   DRAG_MODIFIERS,
-  EXPECT_TIMEOUT_S,
+  EXPECT_TIMEOUT_S2 as EXPECT_TIMEOUT_S,
   EXPOSURE_ADVICE,
   EXPOSURE_MATCHERS_SRC,
   EXPOSURE_PROBE,
   ExposureLog,
   IDLE_CALL_MS,
+  JS_SAID_MAX,
+  JS_VALUE_MAX,
   KEY_ROUNDTRIP_MS,
   KEY_SEQUENCE_GAP_MS,
   MAX_KEYS,
   MAX_PATH_POINTS,
+  MAX_PEERS,
+  MAX_PEER_STEPS,
   MEDIA_DRAIN_PROBE,
   MEDIA_WATCH_SCRIPT,
   MIN_SKIP_MS,
@@ -3864,6 +4563,8 @@ export {
   PASTE_TYPES,
   PASTE_UNREAD_MS,
   PATH_DEFAULT_MS,
+  PEER_VALUE_MAX,
+  PEER_VERBS,
   POINTER_MAX_MS,
   POINTER_MIN_MS,
   POINTER_MS_PER_PX,
@@ -3890,11 +4591,13 @@ export {
   SetupEnvError,
   SetupError,
   StepBound,
+  StepSignals,
   TRAILING_HOLD_MS,
   TakeClock,
   WAIT_MARGIN_MS,
   WALL_PROBE,
   WallError,
+  ZOOM_MARK_VERBS,
   appSettled,
   askedMs,
   base64Bytes,
@@ -3931,6 +4634,8 @@ export {
   isKeyName,
   isSignInPath,
   jpegDims,
+  jsConditionScript,
+  keptValue,
   keySequencePlanMs,
   loadScriptFiles,
   maskInitScript,
@@ -3947,6 +4652,8 @@ export {
   parseHeaders,
   pasteTypeOf,
   pathDurationMs,
+  peerValue,
+  peersHostedRefusal,
   plainName,
   planFreshTake,
   pointerTravelMs,
@@ -3966,9 +4673,13 @@ export {
   resolveChord,
   resolveModifier,
   resolveSetupText,
+  runPeer,
   runSetup,
+  sameJson,
   sayCondition,
   sayDuration,
+  sayJs,
+  sayValue,
   schedulePath,
   scriptFiles,
   scrollByScript,
@@ -3987,6 +4698,7 @@ export {
   untilReady,
   urlSchemeProblem,
   validateActions,
+  validatePeers,
   validateSetup,
   visibleTextScript,
   wallVerdict,