@vosjs/render-core 0.7.0 → 0.9.0

package/dist/record/index.js

@@ -29,6 +29,7 @@ var SETTLE_MS = {
   click: 150,
   type: 150,
   press: 150,
+  paste: 150,
   scroll: 200,
   drag: 80
 };
@@ -112,6 +113,8 @@ function askedMs(step) {
       return (step.text?.length ?? 0) * (step.delayMs ?? 40);
     case "press":
       return step.ms ?? SETTLE_MS.press;
+    case "paste":
+      return step.ms ?? SETTLE_MS.paste;
     default:
       return 0;
   }
@@ -372,6 +375,113 @@ var EXPOSURE_MATCHERS_SRC = `(() => {
   }
   return { kindsIn }
 })()`;
+var NOTICE_SRC = String.raw`const notices = () => {
+    // A label made only of these words is the control's, never a person's:
+    // "Account menu", "Open user menu", "Profile settings".
+    const UI_WORDS = new Set(['account', 'accounts', 'profile', 'profiles', 'menu', 'user', 'users', 'settings', 'setting', 'avatar', 'open', 'close', 'toggle', 'show', 'hide', 'the', 'my', 'your', 'me', 'you', 'home', 'guest', 'admin', 'team', 'workspace', 'dashboard', 'sign', 'signed', 'in', 'out', 'log', 'logged', 'logout', 'login', 'help', 'search', 'notification', 'notifications', 'more', 'options', 'option', 'button', 'dropdown', 'picture', 'image', 'photo', 'main', 'navigation', 'nav', 'preferences', 'switch', 'manage'])
+    const nameLike = (v) => {
+      if (!v) return null
+      const t = v.replace(/\s+/g, ' ').trim().replace(/[!.,:]+$/, '')
+      if (t.length < 2 || t.length > 40 || /[@\d<>/|]/.test(t)) return null
+      if (!/^\p{Lu}[\p{L}'’.-]*(?: \p{L}[\p{L}'’.-]*){0,3}$/u.test(t)) return null
+      if (t.toLowerCase().split(' ').every((w) => UI_WORDS.has(w))) return null
+      return t
+    }
+    const GREETING = /^(?:signed in as|logged in as|welcome back,?|welcome,|hi,|hello,|hey,)\s+(.+)$/i
+    const LABELS = [
+      /^(?:account|user|profile)(?: menu)?(?: for|:|,| -)\s*(.+)$/i,
+      /^open (?:the )?(?:user|account|profile) menu(?: for|,|:)?\s*(.+)$/i,
+      /^(.+?)[’']s? (?:account|profile|avatar)$/i,
+    ]
+    const avatarish = (el) => el.tagName === 'IMG' || !!el.querySelector('img, svg') || /avatar/i.test(String(el.className || '') + ' ' + (el.getAttribute('data-testid') || ''))
+    let sure = false
+    const texts = document.createTreeWalker(document.body || document.documentElement, NodeFilter.SHOW_TEXT)
+    for (let n; !acct && (n = texts.nextNode()); ) {
+      const el = n.parentElement
+      if (!el || /^(SCRIPT|STYLE|NOSCRIPT|TEMPLATE)$/.test(el.tagName)) continue
+      const line = (el.textContent || '').replace(/\s+/g, ' ').trim()
+      if (line.length > 80) continue
+      const m = GREETING.exec(line)
+      const who = m && nameLike(m[1])
+      if (who && seen(el)) { acct = who; sure = true }
+    }
+    let maybe = null
+    if (!acct) {
+      for (const el of document.querySelectorAll('[aria-label], img[alt], [title]')) {
+        const label = el.getAttribute('aria-label') || el.getAttribute('alt') || el.getAttribute('title') || ''
+        const box = el.closest('button, a, [role="button"], [aria-haspopup]') || el
+        if (!seen(el) && !seen(box)) continue
+        let hit = null
+        for (const rx of LABELS) { const m = rx.exec(label.trim()); if (m && (hit = nameLike(m[1]))) break }
+        if (hit) { acct = hit; sure = true; break }
+        if (!maybe && (avatarish(el) || avatarish(box)) && box !== el.ownerDocument.body) maybe = nameLike(label)
+      }
+    }
+    // The account menu's TRIGGER, whose own words are the name: a control
+    // that opens a menu and holds the avatar, or one labelled as the
+    // account's. The name-like line among its words (an address there is
+    // an exposure already, and never a name).
+    if (!acct) {
+      const TRIGGER_LABEL = /(account|user|profile|avatar)/i
+      for (const el of document.querySelectorAll('button, a, [role="button"], [aria-haspopup]')) {
+        const label = (el.getAttribute('aria-label') || '') + ' ' + (el.getAttribute('title') || '')
+        const trigger = (el.hasAttribute('aria-haspopup') && avatarish(el)) || TRIGGER_LABEL.test(label)
+        if (!trigger || !seen(el)) continue
+        const words = document.createTreeWalker(el, NodeFilter.SHOW_TEXT)
+        for (let n; !acct && (n = words.nextNode()); ) {
+          const who = nameLike(n.nodeValue)
+          if (who && n.parentElement && seen(n.parentElement)) { acct = who; sure = true }
+        }
+        if (acct) break
+      }
+    }
+    if (!acct && maybe) acct = maybe
+    const found = []
+    if (acct) {
+      const places = [], at = new Set()
+      const walk = document.createTreeWalker(document.body || document.documentElement, NodeFilter.SHOW_TEXT)
+      for (let n; (n = walk.nextNode()) && places.length < 20; ) {
+        const el = n.parentElement
+        if (!el || /^(SCRIPT|STYLE|NOSCRIPT|TEMPLATE)$/.test(el.tagName)) continue
+        if (!(n.nodeValue || '').includes(acct)) continue
+        const r = seen(el)
+        if (!r) continue
+        const selector = name(el)
+        if (at.has(selector)) continue
+        at.add(selector)
+        places.push({ selector, rect: { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) } })
+      }
+      if (places.length) found.push({ kind: 'account-name', sure, places })
+    }
+    const RECENT = /^(recents?|recently (?:viewed|opened|visited|edited)|history|recent (?:files|projects|documents|items|pages|boards|chats|conversations|searches))$/i
+    const ITEMS = 'a[href], [role="link"], [role="menuitem"], [role="treeitem"], [role="option"]'
+    const listed = new Set()
+    for (const el of document.querySelectorAll('h1, h2, h3, h4, h5, h6, [role="heading"], summary, div, span, p, li, label, strong, button, a')) {
+      if (el.children.length > 2) continue
+      const word = (el.textContent || '').replace(/\s+/g, ' ').trim()
+      if (word.length > 40 || !RECENT.test(word)) continue
+      // A nav link that happens to say History is a page, not a list.
+      if (/^(A|BUTTON)$/.test(el.tagName) && !el.hasAttribute('aria-expanded')) continue
+      if (!seen(el)) continue
+      for (const c of [el.nextElementSibling, el.parentElement && el.parentElement.nextElementSibling, el.parentElement]) {
+        if (!c || c === document.body) continue
+        const items = [...c.querySelectorAll(ITEMS)].filter((x) => x !== el && !x.contains(el) && seen(x))
+        if (items.length < 3) continue
+        const r = seen(c)
+        if (!r) continue
+        const selector = name(c)
+        if (!listed.has(selector)) {
+          listed.add(selector)
+          found.push({ kind: 'personal-list', heading: word, selector, items: items.length, rect: { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) } })
+        }
+        break
+      }
+      if (listed.size >= 5) break
+    }
+    return found
+  }
+  // Read before any selector is made, so none of them quotes the name.
+  const noticeList = notices()`;
 var EXPOSURE_PROBE = `(() => {
   const { kindsIn } = ${EXPOSURE_MATCHERS_SRC}
   const vw = innerWidth, vh = innerHeight
@@ -383,7 +493,10 @@ var EXPOSURE_PROBE = `(() => {
   // layout's, and they come last. A value that itself holds what the scan
   // looks for is never used: the selector would quote it.
   const attr = (v) => '"' + v.replace(/\\\\/g, '\\\\\\\\').replace(/"/g, '\\\\"') + '"'
-  const quiet = (v) => !!v && v.length <= 80 && !kindsIn(v).length
+  // The signed-in account's own name, once the notices have read it: a
+  // selector never quotes it either.
+  let acct = null
+  const quiet = (v) => !!v && v.length <= 80 && !kindsIn(v).length && !(acct && v.toLowerCase().includes(acct.toLowerCase()))
   const segment = (el) => {
     const tag = el.tagName.toLowerCase()
     if (el.id && /^[A-Za-z_][\\w-]*$/.test(el.id) && !/\\d{2,}/.test(el.id) && quiet(el.id)) return tag + '#' + el.id
@@ -425,6 +538,7 @@ var EXPOSURE_PROBE = `(() => {
     if (s.visibility === 'hidden' || s.display === 'none' || +s.opacity === 0) return null
     return r
   }
+  ${NOTICE_SRC}
   const out = [], keys = new Set()
   const add = (el, text) => {
     const kinds = kindsIn(text)
@@ -451,7 +565,7 @@ var EXPOSURE_PROBE = `(() => {
   }
   const hits = {}
   for (const [sel, n] of Object.entries(window.__vosMaskHits || {})) hits[sel] = n
-  return { exposures: out, maskHits: hits }
+  return { exposures: out, maskHits: hits, notices: noticeList }
 })()`;
 function maskInitScript(masks) {
   const rules = masks.map((m) => ({
@@ -536,6 +650,43 @@ function exposureLine(e) {
   return `${KIND_WORDS[e.kind]} in ${e.selector} (${when}, ${e.rect.x},${e.rect.y} ${e.rect.w}\xD7${e.rect.h})`;
 }
 var EXPOSURE_ADVICE = 'The recording shows these. Record from a demo account, or hide them before the camera rolls with "mask" in actions.json: { "selector": "\u2026", "as": "text", "text": "demo@acme.test" } swaps the words, "as": "blur" blurs. Then re-record.';
+var NoticeLog = class {
+  byKey = /* @__PURE__ */ new Map();
+  add(step, notices) {
+    for (const n of notices ?? []) {
+      const key = n.kind === "account-name" ? n.kind : `${n.kind}|${n.selector ?? ""}`;
+      const had = this.byKey.get(key);
+      if (!had) {
+        this.byKey.set(key, { step, ...n, seen: 1 });
+        continue;
+      }
+      had.seen += 1;
+      if (n.kind !== "account-name") continue;
+      if (n.sure) had.sure = true;
+      const places = had.places ?? [];
+      for (const p of n.places ?? [])
+        if (places.length < 20 && !places.some((q) => q.selector === p.selector))
+          places.push(p);
+      had.places = places;
+    }
+  }
+  notices() {
+    return [...this.byKey.values()];
+  }
+};
+function noticeLine(n) {
+  const when = n.step < 0 ? "as the page opened" : `from step #${n.step}`;
+  if (n.kind === "account-name") {
+    const places = n.places ?? [];
+    return `${n.sure ? "" : "what may be "}the account's name (${places.length} ${places.length === 1 ? "place" : "places"}, ${when}): ${places.map((p) => p.selector).join("; ")}`;
+  }
+  const mask = JSON.stringify({ selector: n.selector, as: "blur" });
+  return `a "${n.heading}" list of the account's own items (${n.items} items, ${when}) in ${n.selector}; to hide it, add to "mask": ${mask}`;
+}
+function noticeAdvice(notices) {
+  const name = notices.some((n) => n.kind === "account-name");
+  return `These are the signed-in account's own: fine for a demo account, worth a mask on a real one.${name ? ' The name reads better swapped than blurred: { "selector": "\u2026", "as": "text", "text": "Jane Doe" }.' : ""}`;
+}
 
 // src/record/setup.ts
 var VERBS = /* @__PURE__ */ new Set(["wait", "click", "type", "press", "goto"]);
@@ -620,7 +771,10 @@ async function runSetup(page, steps, opts) {
           lines.push(`setup #${i} wait ${step.ms}ms`);
           break;
         case "goto":
-          await page.goto(step.url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => null);
+          await (opts.goto ? opts.goto(step.url) : page.goto(step.url, {
+            waitUntil: "networkidle",
+            timeout: 45e3
+          })).catch(() => null);
           lines.push(`setup #${i} goto ${step.url}`);
           break;
         case "press":
@@ -689,6 +843,291 @@ function parseHeaders(given) {
   return out;
 }
 
+// src/record/stepBound.ts
+var STEP_MARGIN_MS = 3e4;
+var WAIT_MARGIN_MS = 5e3;
+var IDLE_CALL_MS = 6e4;
+function stepBoundMs(step, plannedMs, defaults) {
+  if (step.do === "expect")
+    return (step.timeout ?? defaults.expectS) * 1e3 + WAIT_MARGIN_MS;
+  if (step.do === "await")
+    return (step.timeout ?? defaults.awaitS) * 1e3 + STEP_MARGIN_MS;
+  if (step.do === "download") return defaults.downloadS * 1e3 + STEP_MARGIN_MS;
+  return plannedMs + STEP_MARGIN_MS;
+}
+var StepBound = class {
+  constructor(now = Date.now, idleMs = IDLE_CALL_MS) {
+    this.now = now;
+    this.idleMs = idleMs;
+  }
+  now;
+  idleMs;
+  deadline = null;
+  started = 0;
+  hung = false;
+  /** A step begins: calls into the page answer within `boundMs` from now. */
+  start(boundMs) {
+    this.started = this.now();
+    this.deadline = this.started + boundMs;
+    this.hung = false;
+  }
+  /** The step ends: whether it ran into its bound, and how long it really took. */
+  end() {
+    const out = {
+      hung: this.hung,
+      ms: this.now() - this.started,
+      boundMs: (this.deadline ?? this.started) - this.started
+    };
+    this.deadline = null;
+    this.hung = false;
+    return out;
+  }
+  /** The pending call, or `undefined` once the bound has passed. */
+  race(p) {
+    const left = this.deadline === null ? this.idleMs : this.deadline - this.now();
+    if (left <= 0) {
+      this.hung = true;
+      p.catch(() => {
+      });
+      return Promise.resolve(void 0);
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.hung = true;
+        resolve(void 0);
+      }, left);
+      p.then(
+        (v) => {
+          clearTimeout(timer);
+          resolve(v);
+        },
+        (e) => {
+          clearTimeout(timer);
+          reject(e);
+        }
+      );
+    });
+  }
+};
+function bounded(target, bound) {
+  const cache = /* @__PURE__ */ new WeakMap();
+  const wrap = (obj) => {
+    const had = cache.get(obj);
+    if (had) return had;
+    const proxy = new Proxy(obj, {
+      get(t, prop) {
+        const value = Reflect.get(t, prop, t);
+        if (typeof value === "function")
+          return (...args) => {
+            const out = value.apply(
+              t,
+              args
+            );
+            if (out && typeof out.then === "function")
+              return bound.race(out);
+            if (out && typeof out === "object" && out !== t) return wrap(out);
+            return out;
+          };
+        if (value && typeof value === "object") return wrap(value);
+        return value;
+      }
+    });
+    cache.set(obj, proxy);
+    return proxy;
+  };
+  return wrap(target);
+}
+
+// src/record/pageSound.ts
+var MAX_ELEMENTS = 50;
+var MAX_NOTES = 2e3;
+var MIN_HEARD_S = 0.05;
+var MEDIA_WATCH_SCRIPT = `(() => {
+  let host
+  try { host = window.top; void host.document.title } catch { return }
+  if (window.__vosMediaWatch) return
+  window.__vosMediaWatch = true
+  if (!host.__vosMedia) {
+    const M = { log: [], seq: 0, els: new Set(), doc: Math.random().toString(36).slice(2) }
+    M.fields = (el, kind) => ({
+      id: el.__vosMediaId,
+      tag: el.tagName === 'VIDEO' ? 'video' : 'audio',
+      src: el.currentSrc || el.src || '',
+      kind,
+      wall: Date.now(),
+      t: el.currentTime,
+      rate: el.playbackRate || 1,
+      paused: el.paused || el.ended,
+      audible: !el.muted && el.volume > 0,
+      volume: el.volume,
+      duration: isFinite(el.duration) ? el.duration : null,
+      ab: typeof el.webkitAudioDecodedByteCount === 'number' ? el.webkitAudioDecodedByteCount : null,
+    })
+    host.__vosMedia = M
+  }
+  const M = host.__vosMedia
+  const EVENTS = ['playing', 'pause', 'ended', 'seeking', 'seeked', 'volumechange', 'ratechange', 'emptied']
+  const note = (e) => {
+    const el = e.target
+    if (!el || typeof el.currentTime !== 'number' || !/^(VIDEO|AUDIO)$/.test(el.tagName || '')) return
+    if (e.__vosNoted) return
+    e.__vosNoted = true
+    if (!el.__vosMediaId) {
+      if (M.els.size >= ${MAX_ELEMENTS}) return
+      el.__vosMediaId = ++M.seq
+      M.els.add(el)
+    }
+    if (M.log.length < ${MAX_NOTES}) M.log.push(M.fields(el, e.type))
+  }
+  for (const type of EVENTS) document.addEventListener(type, note, true)
+  const proto = window.HTMLMediaElement && window.HTMLMediaElement.prototype
+  if (proto && proto.play) {
+    const play = proto.play
+    proto.play = function () {
+      if (!this.__vosListening && !this.isConnected) {
+        this.__vosListening = true
+        for (const type of EVENTS) this.addEventListener(type, note)
+      }
+      return play.apply(this, arguments)
+    }
+  }
+})()`;
+var MEDIA_DRAIN_PROBE = `(() => {
+  const M = window.__vosMedia
+  if (!M) return { now: Date.now(), doc: null, notes: [] }
+  const notes = M.log.splice(0)
+  M.els.forEach((el) => notes.push(M.fields(el, 'tick')))
+  return { now: Date.now(), doc: M.doc, notes }
+})()`;
+function soundSrcForMeta(src) {
+  if (/^blob:/i.test(src)) return "blob:";
+  if (/^data:/i.test(src)) return src.slice(0, src.search(/[;,]/) + 1 || 5);
+  try {
+    const u = new URL(src);
+    return `${u.origin}${u.pathname}`;
+  } catch {
+    return "";
+  }
+}
+var PageSoundLog = class {
+  byKey = /* @__PURE__ */ new Map();
+  openKeyOf = /* @__PURE__ */ new Map();
+  doc = null;
+  lastWall = 0;
+  add(drain, nodeNow, step) {
+    if (!drain) return;
+    const skew = nodeNow - drain.now;
+    if (drain.doc !== this.doc) {
+      if (this.doc !== null) this.closeAll(this.lastWall);
+      this.openKeyOf.clear();
+      this.doc = drain.doc;
+    }
+    const notes = [...drain.notes].sort((a, b) => a.wall - b.wall);
+    for (const n of notes) this.note(n, n.wall + skew, step);
+    this.lastWall = nodeNow;
+  }
+  note(n, wall, step) {
+    const key = `${this.doc}|${n.id}|${n.src}`;
+    const prevKey = this.openKeyOf.get(n.id);
+    if (prevKey && prevKey !== key) {
+      const prev = this.byKey.get(prevKey);
+      if (prev) this.close(prev, wall);
+    }
+    let f = this.byKey.get(key);
+    if (!f) {
+      if (!n.src) return;
+      f = {
+        tag: n.tag,
+        src: n.src,
+        played: false,
+        audioBytes: null,
+        open: null,
+        stretches: []
+      };
+      this.byKey.set(key, f);
+    }
+    this.openKeyOf.set(n.id, key);
+    if (n.duration !== null) f.duration = n.duration;
+    if (n.ab !== null) f.audioBytes = Math.max(f.audioBytes ?? 0, n.ab);
+    if (!n.paused) f.played = true;
+    const stops = ["pause", "ended", "seeking", "emptied"].includes(n.kind);
+    const heard = !n.paused && n.audible && !stops;
+    const resync = ["playing", "seeked", "ratechange"].includes(n.kind);
+    if (f.open && (!heard || resync))
+      this.close(
+        f,
+        wall,
+        n.kind === "ended" ? n.duration ?? void 0 : void 0
+      );
+    if (!f.open && heard) {
+      f.open = { wall, t: n.t, rate: n.rate > 0 ? n.rate : 1 };
+      f.volume = n.volume;
+      if (f.step === void 0 && step !== void 0 && step >= 0) f.step = step;
+    }
+  }
+  close(f, wall, endT) {
+    if (!f.open) return;
+    const { wall: from, t, rate } = f.open;
+    f.open = null;
+    if (wall <= from) return;
+    const to = endT ?? t + (wall - from) / 1e3 * rate;
+    f.stretches.push({
+      fromWall: from,
+      toWall: from + (to - t) / rate * 1e3,
+      t0: t,
+      rate
+    });
+  }
+  closeAll(wall) {
+    for (const f of this.byKey.values()) this.close(f, wall);
+  }
+  /**
+   * Every element the page played, each heard stretch as footage seconds
+   * `at` with media seconds `from`..`to`, none past `endMs` of footage.
+   * A video whose decoder never decoded a byte of sound played none.
+   */
+  heard(clock, endWall, endMs) {
+    this.closeAll(endWall);
+    const out = [];
+    for (const f of this.byKey.values()) {
+      if (!f.played) continue;
+      const silentVideo = f.tag === "video" && f.audioBytes === 0;
+      const intervals = [];
+      if (!silentVideo)
+        for (const s of f.stretches)
+          for (const c of clock.onCamera(s.fromWall, s.toWall)) {
+            const at = c.atMs / 1e3;
+            let from = s.t0 + (c.wallMs - s.fromWall) / 1e3 * s.rate;
+            let to = from + c.ms / 1e3 * s.rate;
+            if (f.duration !== void 0) to = Math.min(to, f.duration);
+            const room = (endMs - c.atMs) / 1e3;
+            if (room <= 0) continue;
+            to = Math.min(to, from + room * s.rate);
+            from = Math.max(0, from);
+            if (to - from < MIN_HEARD_S) continue;
+            intervals.push({
+              at: +at.toFixed(3),
+              from: +from.toFixed(3),
+              to: +to.toFixed(3)
+            });
+          }
+      out.push({
+        src: f.src,
+        meta: {
+          ...f.step !== void 0 ? { step: f.step } : {},
+          src: soundSrcForMeta(f.src),
+          tag: f.tag,
+          ...f.duration !== void 0 ? { duration: +f.duration.toFixed(3) } : {},
+          ...intervals.length && f.volume !== void 0 ? { volume: +f.volume.toFixed(3) } : {},
+          intervals,
+          ...intervals.length ? {} : { muted: true }
+        }
+      });
+    }
+    return out;
+  }
+};
+
 // src/record/takeClock.ts
 var TakeClock = class {
   constructor(t0) {
@@ -719,6 +1158,32 @@ var TakeClock = class {
     open.to = Math.max(open.from, wallMs);
     return open.to - open.from;
   }
+  /**
+   * The parts of a wall-clock stretch the camera saw: each sub-stretch
+   * outside every off-camera wait, as its wall start (`wallMs`), its
+   * footage start (`atMs`) and its length. A stretch an `await` cut in two
+   * comes back as two; one wholly off camera as none.
+   */
+  onCamera(fromWall, toWall) {
+    const out = [];
+    let cur = Math.max(fromWall, this.t0);
+    for (const p of this.pauses) {
+      const pTo = p.to ?? Infinity;
+      if (pTo <= cur) continue;
+      if (p.from >= toWall) break;
+      if (p.from > cur)
+        out.push({
+          wallMs: cur,
+          atMs: this.footageMs(cur),
+          ms: p.from - cur
+        });
+      cur = Math.max(cur, pTo);
+      if (cur >= toWall) return out;
+    }
+    if (toWall > cur)
+      out.push({ wallMs: cur, atMs: this.footageMs(cur), ms: toWall - cur });
+    return out;
+  }
   /**
    * A captured frame's footage ms, or null when it is not later than the
    * last frame kept (the frame is dropped; see the module comment).
@@ -764,141 +1229,1343 @@ var PageErrorLog = class {
   }
 };
 
-// src/record/actions.ts
-var STEP_GUARDS = ["spend"];
-var GUARDABLE = /* @__PURE__ */ new Set(["click", "press", "type"]);
-var EXPECT_TIMEOUT_S = 5;
-var AWAIT_TIMEOUT_S = 600;
-var AWAIT_POLL_S = 2;
-var DOWNLOAD_TIMEOUT_S = 30;
-var VERBS2 = /* @__PURE__ */ new Set([
-  "wait",
-  "hover",
-  "click",
-  "type",
-  "press",
-  "scroll",
-  "move",
-  "drag",
-  "expect",
-  "await",
-  "download"
-]);
-var PRESS_KEYS = [
-  "Escape",
-  "Enter",
-  "Tab",
-  "Backspace",
-  "Delete",
-  "ArrowUp",
-  "ArrowDown",
-  "ArrowLeft",
-  "ArrowRight",
-  "Home",
-  "End",
-  "PageUp",
-  "PageDown",
-  "Space"
-];
-function validateActions(value) {
-  const errors = [];
-  if (typeof value !== "object" || value === null)
-    return ["actions file must be a JSON object"];
-  const obj = value;
-  if (obj.url !== void 0) {
-    if (typeof obj.url !== "string") errors.push("url must be a string");
-    else {
-      const problem = urlSchemeProblem(obj.url);
-      if (problem) errors.push(`url ${problem}`);
+// src/record/surfaceFit.ts
+async function surfaceSize(cdp, dpr) {
+  const shot = await cdp.send("Page.captureScreenshot", {
+    format: "jpeg",
+    quality: 1
+  });
+  const dims = shot.data ? jpegDims(base64Bytes(shot.data)) : null;
+  if (!dims) return null;
+  return { width: Math.round(dims.w / dpr), height: Math.round(dims.h / dpr) };
+}
+async function fitSurfaceToViewport(cdp, width, height) {
+  try {
+    const ratio = await cdp.send("Runtime.evaluate", {
+      expression: "devicePixelRatio",
+      returnByValue: true
+    });
+    const value = ratio.result?.value;
+    const dpr = typeof value === "number" && value > 0 ? value : 1;
+    const before = await surfaceSize(cdp, dpr);
+    if (!before) return null;
+    let after = before;
+    for (let tries = 0; tries < 2; tries++) {
+      if (after.width === width && after.height === height) break;
+      const win = await cdp.send("Browser.getWindowForTarget");
+      const { width: ww, height: wh } = win.bounds;
+      if (ww === void 0 || wh === void 0) break;
+      await cdp.send("Browser.setWindowBounds", {
+        windowId: win.windowId,
+        bounds: {
+          width: ww + (width - after.width),
+          height: wh + (height - after.height)
+        }
+      });
+      after = await surfaceSize(cdp, dpr) ?? after;
     }
+    return { before, after };
+  } catch {
+    return null;
   }
-  if (obj.viewport !== void 0) {
-    const v = obj.viewport;
-    if (typeof v !== "object" || v === null) {
-      errors.push("viewport must be { width, height }");
-    } else {
-      const vp = v;
-      if (typeof vp.width !== "number" || typeof vp.height !== "number") {
-        errors.push("viewport must be { width, height }");
-      }
-    }
+}
+
+// src/record/waits.ts
+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]));
   }
-  if (obj.setup !== void 0) errors.push(...validateSetup(obj.setup));
-  if (obj.mask !== void 0) {
-    if (!Array.isArray(obj.mask)) {
-      errors.push("mask must be an array of { selector, as?, text? }");
-    } else {
-      obj.mask.forEach((raw, i) => {
-        const at = `mask[${i}]`;
-        const m = raw ?? {};
-        if (typeof m.selector !== "string" || !m.selector.trim())
-          errors.push(`${at}: needs a selector`);
-        if (m.as !== void 0 && m.as !== "blur" && m.as !== "text")
-          errors.push(`${at}: as must be "blur" or "text"`);
-        if (m.as === "text" && (typeof m.text !== "string" || !m.text))
-          errors.push(`${at}: as "text" needs the text to show instead`);
-        if (m.as !== "text" && m.text !== void 0)
-          errors.push(`${at}: text is only read with as "text"`);
-      });
-    }
+  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;
   }
-  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
-    errors.push("steps must be a non-empty array");
-    return errors;
+  let got;
+  try {
+    got = JSON.parse(raw);
+  } catch {
+    return { holds: false };
   }
-  const seenIds = /* @__PURE__ */ new Set();
-  obj.steps.forEach((raw, i) => {
-    const at = `steps[${i}]`;
-    if (typeof raw !== "object" || raw === null) {
-      errors.push(`${at}: must be an object`);
-      return;
+  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 s = raw;
-    if (s.read !== void 0 && (typeof s.read !== "string" || !s.read.trim()))
-      errors.push(`${at}: read must be a selector`);
-    if (typeof s.do !== "string" || !VERBS2.has(s.do)) {
-      errors.push(`${at}: "do" must be one of ${[...VERBS2].join(", ")}`);
-      return;
+  }
+  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)
+      return { holds: !await page.locator(c.gone).first().isVisible() };
+    if (c.selector !== void 0) {
+      const loc = page.locator(c.selector).first();
+      const visible = await loc.isVisible();
+      if (!visible) return { holds: false, visible };
+      if (c.enabled === void 0) return { holds: true, visible };
+      const enabled = await loc.isEnabled({ timeout: 1e3 });
+      return { holds: enabled === c.enabled, visible };
     }
-    if (s.id !== void 0) {
-      if (typeof s.id !== "string" || !s.id.trim()) {
-        errors.push(`${at}: id must be a non-empty string`);
-      } else if (seenIds.has(s.id)) {
-        errors.push(
-          `${at}: duplicate id "${s.id}" \u2014 an anchor could not tell the two steps apart`
-        );
-      } else {
-        seenIds.add(s.id);
-      }
+  } catch {
+  }
+  return { holds: false };
+}
+async function pollCondition(page, c, opts) {
+  const now = opts.now ?? Date.now;
+  const start = now();
+  const reads = Math.max(1, opts.confirm?.reads ?? 1);
+  for (let first = true; ; first = false) {
+    if (!first && opts.between) await opts.between();
+    let last = await readCondition(page, c);
+    for (let n = 1; last.holds && n < reads; n++) {
+      await opts.sleep(opts.confirm?.gapMs ?? 0);
+      last = await readCondition(page, c);
     }
-    const needSelector = s.do === "hover" || s.do === "click" || s.do === "type";
-    if (needSelector && typeof s.selector !== "string")
-      errors.push(`${at}: ${s.do} needs a selector`);
-    if (s.do === "wait" && typeof s.ms !== "number")
-      errors.push(`${at}: wait needs ms`);
-    if (s.ms !== void 0 && (typeof s.ms !== "number" || !Number.isFinite(s.ms) || s.ms < 0))
-      errors.push(`${at}: ms must be a number of milliseconds \u2265 0`);
-    if (s.do === "type" && typeof s.text !== "string")
-      errors.push(`${at}: type needs text`);
-    if (s.do === "type" && s.focus !== void 0 && typeof s.focus !== "boolean")
-      errors.push(`${at}: type focus must be true or false`);
-    if (s.do === "type" && s.replace !== void 0 && typeof s.replace !== "boolean")
-      errors.push(`${at}: type replace must be true or false`);
-    if (s.do === "type" && s.at !== void 0 && s.at !== "end" && s.at !== "start")
-      errors.push(`${at}: type at must be "end" or "start"`);
-    if (s.do === "press") {
-      if (typeof s.key !== "string" || !PRESS_KEYS.includes(s.key))
+    const ms = now() - start;
+    if (last.holds) return { ok: true, ms, last };
+    const left = opts.timeoutMs - ms;
+    if (left <= 0) return { ok: false, ms, last };
+    await opts.sleep(Math.min(opts.everyMs, left));
+  }
+}
+var DOM_QUIET_MS = 800;
+var DOM_SETTLE_CAP_MS = 5e3;
+var DOM_CHANGE_PROBE = `(() => {
+  if (!window.__vosDomChanges) {
+    window.__vosDomChanges = { n: 0 };
+    new MutationObserver((list) => { window.__vosDomChanges.n += list.length })
+      .observe(document, { subtree: true, childList: true, attributes: true, characterData: true });
+  }
+  return window.__vosDomChanges.n;
+})()`;
+async function domSettled(page, opts) {
+  const now = opts.now ?? Date.now;
+  const quiet = opts.quietMs ?? DOM_QUIET_MS;
+  const cap = opts.capMs ?? DOM_SETTLE_CAP_MS;
+  const start = now();
+  let seen = await page.evaluate(DOM_CHANGE_PROBE).catch(() => -1);
+  let since = start;
+  for (; ; ) {
+    const t = now();
+    if (t - since >= quiet) return { settled: true, ms: t - start };
+    if (t - start >= cap) return { settled: false, ms: t - start };
+    await opts.sleep(opts.tickMs ?? 100);
+    const n = await page.evaluate(DOM_CHANGE_PROBE).catch(() => -1);
+    if (n !== seen) {
+      seen = n;
+      since = now();
+    }
+  }
+}
+function sayDuration(ms) {
+  const s = Math.round(ms / 100) / 10;
+  if (s < 60) return `${s} s`;
+  const m = Math.floor(s / 60);
+  const rest = Math.round(s - m * 60);
+  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`;
+  if (c.enabled === false) return `'${c.selector}' to be disabled`;
+  return `'${c.selector}' to appear`;
+}
+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}`;
+  if (last.visible && c.enabled === true)
+    return `'${c.selector}' stayed disabled for ${t}`;
+  if (last.visible && c.enabled === false)
+    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"];
+var DEFAULT_READY = "dom";
+var NAV_TIMEOUT_MS = 45e3;
+var READY_SETTLE_CAP_MS = 8e3;
+var NETWORKIDLE_HYDRATION_MS = 800;
+function readyProblem(v) {
+  if (v === void 0) return null;
+  return typeof v === "string" && READY_MODES.includes(v) ? null : `ready must be ${READY_MODES.map((m) => `"${m}"`).join(" or ")}`;
+}
+async function untilReady(page, mode, navigate, opts) {
+  const now = opts.now ?? Date.now;
+  const start = now();
+  const timeout = opts.timeoutMs ?? NAV_TIMEOUT_MS;
+  if (mode === "networkidle") {
+    let idle = true;
+    const response2 = await navigate({
+      waitUntil: "networkidle",
+      timeout
+    }).catch(() => {
+      idle = false;
+      return null;
+    });
+    await opts.sleep(NETWORKIDLE_HYDRATION_MS);
+    return {
+      response: response2,
+      ready: { mode, ms: Math.round(now() - start), capped: !idle }
+    };
+  }
+  const response = await navigate({ waitUntil: "load", timeout }).catch(
+    () => null
+  );
+  const settled = await domSettled(page, {
+    sleep: opts.sleep,
+    now,
+    quietMs: DOM_QUIET_MS,
+    capMs: opts.capMs ?? READY_SETTLE_CAP_MS
+  });
+  return {
+    response,
+    ready: { mode, ms: Math.round(now() - start), capped: !settled.settled }
+  };
+}
+async function reloadUntilReady(page, mode, timeoutMs, opts = {}) {
+  const nav = {
+    waitUntil: mode === "networkidle" ? "networkidle" : "load",
+    timeout: Math.min(NAV_TIMEOUT_MS, timeoutMs)
+  };
+  await (page.reload ? page.reload(nav) : page.goto(page.url(), nav)).catch(
+    () => null
+  );
+  await domSettled(page, { sleep: opts.sleep ?? realSleep });
+}
+function readyLine(r) {
+  const s = (r.ms / 1e3).toFixed(1);
+  if (r.mode === "networkidle")
+    return r.capped ? `(networkidle timeout after ${s} s, continuing)` : `(network idle after ${s} s)`;
+  return r.capped ? `(the page was still changing after ${s} s, starting anyway)` : `(the page settled after ${s} s)`;
+}
+
+// src/record/gestures.ts
+var MODIFIERS = [
+  "Shift",
+  "Control",
+  "Alt",
+  "Meta",
+  "Mod",
+  "ControlOrMeta"
+];
+var DRAG_MODIFIERS = [
+  "Alt",
+  "Shift",
+  "Meta",
+  "Control",
+  "Mod"
+];
+var NAMED_KEYS = /* @__PURE__ */ new Set([
+  "Escape",
+  "Enter",
+  "Tab",
+  "Backspace",
+  "Delete",
+  "Insert",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "Space",
+  "CapsLock",
+  "ContextMenu",
+  "Backquote",
+  "Minus",
+  "Equal",
+  "BracketLeft",
+  "BracketRight",
+  "Backslash",
+  "Semicolon",
+  "Quote",
+  "Comma",
+  "Period",
+  "Slash",
+  "NumpadAdd",
+  "NumpadSubtract",
+  "NumpadMultiply",
+  "NumpadDivide",
+  "NumpadDecimal",
+  "NumpadEnter"
+]);
+var isModifier = (s) => MODIFIERS.includes(s);
+function isKeyName(k) {
+  if ([...k].length === 1) return k.trim().length === 1 || k === " ";
+  if (NAMED_KEYS.has(k)) return true;
+  return /^Key[A-Z]$/.test(k) || /^Digit[0-9]$/.test(k) || /^Numpad[0-9]$/.test(k) || /^F([1-9]|1[0-9]|2[0-4])$/.test(k);
+}
+function splitChord(chord) {
+  if (chord === "+") return { mods: [], key: "+" };
+  const plusKey = chord.endsWith("++");
+  const parts = (plusKey ? chord.slice(0, -2) : chord).split("+");
+  if (plusKey) return { mods: parts, key: "+" };
+  const key = parts.pop() ?? "";
+  return { mods: parts, key };
+}
+function chordProblem(chord) {
+  if (typeof chord !== "string" || !chord)
+    return 'must be a key name or a chord like "Shift+D"';
+  const { mods, key } = splitChord(chord);
+  for (const m of mods) {
+    if (!isModifier(m))
+      return `"${chord}": "${m}" is not a modifier (one of ${MODIFIERS.join(", ")})`;
+  }
+  if (new Set(mods).size !== mods.length)
+    return `"${chord}" names a modifier twice`;
+  if (!key) return `"${chord}" ends without a key`;
+  if (isModifier(key)) {
+    if (mods.length) return `"${chord}" ends on a modifier, not a key`;
+    return null;
+  }
+  if (!isKeyName(key))
+    return `"${chord}": "${key}" is not a key (a single character, a named key like Escape or ArrowLeft, F1 to F24, or a code like KeyA or Digit1)`;
+  return null;
+}
+function resolveChord(chord) {
+  const { mods, key } = splitChord(chord);
+  const k = key === "Mod" ? "ControlOrMeta" : key;
+  return [...mods.map((m) => m === "Mod" ? "ControlOrMeta" : m), k].join("+");
+}
+function pressSequence(step) {
+  if (step.keys !== void 0)
+    return typeof step.keys === "string" ? [step.keys] : step.keys;
+  return step.key ? [step.key] : [];
+}
+var KEY_SEQUENCE_GAP_MS = 150;
+var KEY_ROUNDTRIP_MS = 50;
+var keySequencePlanMs = (keys) => Math.max(0, keys - 1) * KEY_SEQUENCE_GAP_MS + keys * KEY_ROUNDTRIP_MS;
+var DRAG_HOLD_MS = 400;
+var MAX_KEYS = 50;
+function resolveModifier(m) {
+  return m === "Mod" ? "ControlOrMeta" : m;
+}
+function modifierBits(mods, platform) {
+  let bits = 0;
+  for (const m of mods) {
+    const k = m === "Mod" ? platform === "mac" ? "Meta" : "Control" : m;
+    bits |= k === "Alt" ? 1 : k === "Control" ? 2 : k === "Meta" ? 4 : 8;
+  }
+  return bits;
+}
+var CLICK_BUTTONS = ["left", "right", "middle"];
+var buttonNumber = (b) => b === "right" ? 2 : b === "middle" ? 1 : 0;
+var MULTI_CLICK_GAP_MS = 90;
+var MAX_PATH_POINTS = 2e4;
+var PATH_DEFAULT_MS = 700;
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+function readPoint(raw) {
+  if (Array.isArray(raw)) {
+    if (raw.length < 2 || raw.length > 4)
+      return "must be [x, y], [x, y, tMs] or [x, y, tMs, pressure]";
+    const [x, y, t, pressure] = raw;
+    if (!finite(x) || !finite(y)) return "x and y must be numbers (CSS px)";
+    if (t !== void 0 && !finite(t)) return "its time must be a number of ms";
+    if (pressure !== void 0 && !finite(pressure))
+      return "its pressure must be a number from 0 to 1";
+    return {
+      x,
+      y,
+      ...t !== void 0 ? { t } : {},
+      ...pressure !== void 0 ? { pressure } : {}
+    };
+  }
+  if (typeof raw === "object" && raw !== null) {
+    const o = raw;
+    const extra = Object.keys(o).filter(
+      (k) => !["x", "y", "t", "pressure"].includes(k)
+    );
+    if (extra.length)
+      return `takes x, y, t and pressure, not ${extra.join(", ")}`;
+    if (!finite(o.x) || !finite(o.y)) return "x and y must be numbers (CSS px)";
+    if (o.t !== void 0 && !finite(o.t)) return "its t must be a number of ms";
+    if (o.pressure !== void 0 && !finite(o.pressure))
+      return "its pressure must be a number from 0 to 1";
+    return {
+      x: o.x,
+      y: o.y,
+      ...o.t !== void 0 ? { t: o.t } : {},
+      ...o.pressure !== void 0 ? { pressure: o.pressure } : {}
+    };
+  }
+  return "must be [x, y] or { x, y }";
+}
+function readPath(raw) {
+  const list = typeof raw === "object" && raw !== null && !Array.isArray(raw) && Array.isArray(raw.points) ? raw.points : raw;
+  if (!Array.isArray(list))
+    return { problems: ['must be an array of points, or { "points": [...] }'] };
+  if (list.length < 2) return { problems: ["needs at least two points"] };
+  if (list.length > MAX_PATH_POINTS)
+    return { problems: [`holds more than ${MAX_PATH_POINTS} points`] };
+  const problems = [];
+  const read = [];
+  list.forEach((p, i) => {
+    const r = readPoint(p);
+    if (typeof r === "string") problems.push(`point ${i} ${r}`);
+    else {
+      if (r.x < 0 || r.y < 0)
+        problems.push(`point ${i} is off the viewport (x and y are \u2265 0)`);
+      if (r.pressure !== void 0 && (r.pressure < 0 || r.pressure > 1))
+        problems.push(`point ${i} pressure must be from 0 to 1`);
+      read.push(r);
+    }
+  });
+  if (problems.length) return { problems: problems.slice(0, 5) };
+  const timedCount = read.filter((p) => p.t !== void 0).length;
+  if (timedCount !== 0 && timedCount !== read.length)
+    return {
+      problems: [
+        "every point carries a time or none does: a path is replayed by its own timing, or evenly over ms"
+      ]
+    };
+  const timed = timedCount > 0;
+  if (timed) {
+    for (let i = 1; i < read.length; i++)
+      if (read[i].t < read[i - 1].t)
+        return {
+          problems: [`point ${i}'s time runs backwards (times never decrease)`]
+        };
+  }
+  const t0 = timed ? read[0].t : 0;
+  return {
+    timed,
+    points: read.map((p) => ({
+      x: p.x,
+      y: p.y,
+      at: timed ? p.t - t0 : 0,
+      ...p.pressure !== void 0 ? { pressure: p.pressure } : {}
+    }))
+  };
+}
+function schedulePath(path, ms) {
+  if (path.timed) return path.points;
+  const dur = ms ?? PATH_DEFAULT_MS;
+  const n = path.points.length;
+  return path.points.map((p, i) => ({
+    ...p,
+    at: n > 1 ? Math.round(dur * i / (n - 1)) : 0
+  }));
+}
+var pathDurationMs = (s) => s.length ? s[s.length - 1].at : 0;
+var OVERRUN_SHARE = 0.2;
+var OVERRUN_MIN_PLANNED_MS = 100;
+var OVERRUN_MIN_MS = 100;
+function overrunOf(plannedMs, tookMs) {
+  if (!(plannedMs >= OVERRUN_MIN_PLANNED_MS)) return null;
+  if (tookMs <= plannedMs * (1 + OVERRUN_SHARE)) return null;
+  if (tookMs - plannedMs < OVERRUN_MIN_MS) return null;
+  return Math.round(tookMs - plannedMs);
+}
+function overrunLine(overruns) {
+  if (!overruns.length) return null;
+  const planned = overruns.reduce((a, o) => a + o.plannedMs, 0);
+  const took = overruns.reduce((a, o) => a + o.tookMs, 0);
+  const ratio = planned > 0 ? took / planned : 0;
+  const n = overruns.length;
+  const which = overruns.map((o) => `#${o.step}${o.id ? ` (${o.id})` : ""} ${o.do}`).join(", ");
+  return `${n} step${n === 1 ? "" : "s"} ran ${ratio.toFixed(1)}\xD7 slower than scripted (${which}): the page could not keep up; add settle or raise ms`;
+}
+
+// src/record/paste.ts
+var PASTE_READ_WINDOW_MS = 300;
+var PASTE_UNREAD_MS = 3e3;
+var PASTE_MAX_BYTES = 10 * 1024 * 1024;
+var PASTE_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain",
+  ".md": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".json": "text/plain",
+  ".csv": "text/plain"
+};
+function pasteTypeOf(name) {
+  const dot = name.lastIndexOf(".");
+  if (dot < 0) return null;
+  return PASTE_TYPES[name.slice(dot).toLowerCase()] ?? null;
+}
+var BUILD = (item) => `
+  const item = ${JSON.stringify(item)};
+  const bytes = item.b64 ? Uint8Array.from(atob(item.b64), (c) => c.charCodeAt(0)) : null;
+  const asText = bytes ? new TextDecoder().decode(bytes) : null;
+  async function blobs() {
+    if (item.text !== undefined) return { 'text/plain': new Blob([item.text], { type: 'text/plain' }) };
+    const type = item.type;
+    if (type === 'text/plain') return { 'text/plain': new Blob([asText], { type }) };
+    if (type === 'text/html') return { 'text/html': new Blob([asText], { type }), 'text/plain': new Blob([asText], { type: 'text/plain' }) };
+    if (type === 'image/svg+xml') return { 'image/svg+xml': new Blob([bytes], { type }), 'text/plain': new Blob([asText], { type: 'text/plain' }) };
+    if (type === 'image/png') return { 'image/png': new Blob([bytes], { type }) };
+    const bmp = await createImageBitmap(new Blob([bytes], { type }));
+    const c = document.createElement('canvas');
+    c.width = bmp.width; c.height = bmp.height;
+    c.getContext('2d').drawImage(bmp, 0, 0);
+    const png = await new Promise((r) => c.toBlob(r, 'image/png'));
+    return { 'image/png': png };
+  }
+`;
+function stageClipboardScript(item) {
+  return `(async () => {
+  ${BUILD(item)}
+  try {
+    if (!navigator.clipboard || typeof ClipboardItem === 'undefined') return 'refused: this page has no clipboard';
+    const b = await blobs();
+    try {
+      await navigator.clipboard.write([new ClipboardItem(b)]);
+    } catch (e) {
+      if (!b['text/plain'] || Object.keys(b).length === 1) throw e;
+      await navigator.clipboard.write([new ClipboardItem({ 'text/plain': b['text/plain'] })]);
+    }
+    return 'ok';
+  } catch (e) {
+    return 'refused: ' + (e && e.message ? e.message : String(e));
+  }
+})()`;
+}
+function syntheticPasteScript(item, opts = {}) {
+  return `(async () => {
+  ${BUILD(item)}
+  try {
+    // With original, an image file is handed over as its own bytes and type
+    // (an SVG also as its markup), never redrawn.
+    const b = ${opts.original ? `item.type === 'image/svg+xml' ? { 'image/svg+xml': new Blob([bytes], { type: item.type }), 'text/plain': new Blob([asText], { type: 'text/plain' }) } : { [item.type]: new Blob([bytes], { type: item.type }) }` : "await blobs()"};
+    const dt = new DataTransfer();
+    let file = null;
+    for (const [type, blob] of Object.entries(b)) {
+      if (type.startsWith('image/')) {
+        file = new File([blob], item.name || 'image.png', { type: blob.type || type });
+        dt.items.add(file);
+      } else dt.setData(type, await blob.text());
+    }
+    try {
+      // The async reads answer the item for THIS paste only: shortly after
+      // the first read (an app may read text and items in turn), or after a
+      // few seconds when nothing reads, the browser's own reads come back,
+      // so a later paste through the clipboard is the clipboard's.
+      const staged = [new ClipboardItem(b)];
+      const clip = navigator.clipboard;
+      const own = { read: Object.prototype.hasOwnProperty.call(clip, 'read'), readText: Object.prototype.hasOwnProperty.call(clip, 'readText') };
+      const was = { read: clip.read, readText: clip.readText };
+      let restored = false;
+      const restore = () => {
+        if (restored) return;
+        restored = true;
+        for (const k of ['read', 'readText']) {
+          if (own[k]) clip[k] = was[k];
+          else delete clip[k];
+        }
+      };
+      let soon = null;
+      const readOnce = () => { if (!soon) soon = setTimeout(restore, ${PASTE_READ_WINDOW_MS}) };
+      clip.read = async () => { readOnce(); return staged };
+      clip.readText = async () => { readOnce(); return b['text/plain'] ? b['text/plain'].text() : '' };
+      setTimeout(restore, ${PASTE_UNREAD_MS});
+    } catch {}
+    const target = document.activeElement || document.body;
+    const ev = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true, composed: true });
+    const taken = !target.dispatchEvent(ev);
+    const words = dt.getData('text/plain');
+    if (!taken && words && (target.isContentEditable || /^(INPUT|TEXTAREA)$/.test(target.tagName)))
+      document.execCommand('insertText', false, words);
+    return 'ok';
+  } catch (e) {
+    return 'failed: ' + (e && e.message ? e.message : String(e));
+  }
+})()`;
+}
+
+// src/record/settle.ts
+var APP_QUIET_MS = 300;
+var APP_SETTLE_CAP_MS = 4e3;
+var SETTLE_VERBS = /* @__PURE__ */ new Set([
+  "hover",
+  "click",
+  "type",
+  "press",
+  "scroll",
+  "move",
+  "drag",
+  "paste"
+]);
+var CHANGE_AGE_PROBE = `(() => {
+  const w = window;
+  if (!w.__vosChangeAt) {
+    w.__vosChangeAt = { at: Date.now() };
+    new MutationObserver(() => { w.__vosChangeAt.at = Date.now() })
+      .observe(document, { subtree: true, childList: true, attributes: true, characterData: true });
+    return -1;
+  }
+  return Date.now() - w.__vosChangeAt.at;
+})()`;
+function settleOn(step, scriptDefault) {
+  if (!SETTLE_VERBS.has(step.do)) return false;
+  return step.settle ?? scriptDefault ?? false;
+}
+async function appSettled(page, frames, opts) {
+  const quiet = opts.quietMs ?? APP_QUIET_MS;
+  const age = await page.evaluate(CHANGE_AGE_PROBE).catch(() => -1);
+  const frameAge = opts.sinceFrame?.() ?? null;
+  if (typeof age === "number" && age >= quiet && (frameAge === null || frameAge >= quiet))
+    return { settled: true, ms: 0 };
+  const counted = {
+    evaluate: async (script) => {
+      const n = await page.evaluate(script).catch(() => 0);
+      return (typeof n === "number" && n > 0 ? n : 0) + frames();
+    }
+  };
+  return domSettled(counted, {
+    sleep: opts.sleep,
+    ...opts.now ? { now: opts.now } : {},
+    quietMs: quiet,
+    capMs: opts.capMs ?? APP_SETTLE_CAP_MS,
+    tickMs: 50
+  });
+}
+
+// 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_S2 = 5;
+var AWAIT_TIMEOUT_S = 600;
+var AWAIT_POLL_S = 2;
+var DOWNLOAD_TIMEOUT_S = 30;
+var VERBS2 = /* @__PURE__ */ new Set([
+  "wait",
+  "hover",
+  "click",
+  "type",
+  "press",
+  "scroll",
+  "move",
+  "drag",
+  "expect",
+  "await",
+  "download",
+  "paste"
+]);
+var PRESS_KEYS = [
+  "Escape",
+  "Enter",
+  "Tab",
+  "Backspace",
+  "Delete",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "Space"
+];
+function validateActions(value) {
+  const errors = [];
+  if (typeof value !== "object" || value === null)
+    return ["actions file must be a JSON object"];
+  const obj = value;
+  if (obj.url !== void 0) {
+    if (typeof obj.url !== "string") errors.push("url must be a string");
+    else {
+      const problem = urlSchemeProblem(obj.url);
+      if (problem) errors.push(`url ${problem}`);
+    }
+  }
+  if (obj.viewport !== void 0) {
+    const v = obj.viewport;
+    if (typeof v !== "object" || v === null) {
+      errors.push("viewport must be { width, height }");
+    } else {
+      const vp = v;
+      if (typeof vp.width !== "number" || typeof vp.height !== "number") {
+        errors.push("viewport must be { width, height }");
+      }
+    }
+  }
+  if (obj.setup !== void 0) errors.push(...validateSetup(obj.setup));
+  const ready = readyProblem(obj.ready);
+  if (ready) errors.push(ready);
+  if (obj.settle !== void 0 && typeof obj.settle !== "boolean")
+    errors.push("settle must be true or false");
+  if (obj.mask !== void 0) {
+    if (!Array.isArray(obj.mask)) {
+      errors.push("mask must be an array of { selector, as?, text? }");
+    } else {
+      obj.mask.forEach((raw, i) => {
+        const at = `mask[${i}]`;
+        const m = raw ?? {};
+        if (typeof m.selector !== "string" || !m.selector.trim())
+          errors.push(`${at}: needs a selector`);
+        if (m.as !== void 0 && m.as !== "blur" && m.as !== "text")
+          errors.push(`${at}: as must be "blur" or "text"`);
+        if (m.as === "text" && (typeof m.text !== "string" || !m.text))
+          errors.push(`${at}: as "text" needs the text to show instead`);
+        if (m.as !== "text" && m.text !== void 0)
+          errors.push(`${at}: text is only read with as "text"`);
+      });
+    }
+  }
+  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+    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}]`;
+    if (typeof raw !== "object" || raw === null) {
+      errors.push(`${at}: must be an object`);
+      return;
+    }
+    const s = raw;
+    if (s.read !== void 0 && (typeof s.read !== "string" || !s.read.trim()))
+      errors.push(`${at}: read must be a selector`);
+    if (typeof s.do !== "string" || !VERBS2.has(s.do)) {
+      errors.push(`${at}: "do" must be one of ${[...VERBS2].join(", ")}`);
+      return;
+    }
+    if (s.id !== void 0) {
+      if (typeof s.id !== "string" || !s.id.trim()) {
+        errors.push(`${at}: id must be a non-empty string`);
+      } else if (seenIds.has(s.id)) {
+        errors.push(
+          `${at}: duplicate id "${s.id}" \u2014 an anchor could not tell the two steps apart`
+        );
+      } else {
+        seenIds.add(s.id);
+      }
+    }
+    if (s.do === "type" && typeof s.selector !== "string")
+      errors.push(`${at}: type needs a selector`);
+    if (s.do === "hover" || s.do === "click") {
+      const point = s.x !== void 0 || s.y !== void 0;
+      if (point && s.selector !== void 0)
+        errors.push(
+          `${at}: ${s.do} takes a selector or x and y (a viewport point), not both`
+        );
+      else if (point) {
+        if (!isCoord(s.x) || !isCoord(s.y))
+          errors.push(
+            `${at}: ${s.do} x and y must both be numbers of CSS px, 0 or more`
+          );
+      } else if (typeof s.selector !== "string")
+        errors.push(
+          `${at}: ${s.do} needs a selector, or x and y (a viewport point)`
+        );
+    }
+    if (s.do === "wait" && typeof s.ms !== "number")
+      errors.push(`${at}: wait needs ms`);
+    if (s.ms !== void 0 && (typeof s.ms !== "number" || !Number.isFinite(s.ms) || s.ms < 0))
+      errors.push(`${at}: ms must be a number of milliseconds \u2265 0`);
+    if (s.do === "type" && typeof s.text !== "string")
+      errors.push(`${at}: type needs text`);
+    if (s.do === "type" && s.focus !== void 0 && typeof s.focus !== "boolean")
+      errors.push(`${at}: type focus must be true or false`);
+    if (s.do === "type" && s.replace !== void 0 && typeof s.replace !== "boolean")
+      errors.push(`${at}: type replace must be true or false`);
+    if (s.do === "type" && s.at !== void 0 && s.at !== "end" && s.at !== "start")
+      errors.push(`${at}: type at must be "end" or "start"`);
+    if (s.do === "press") {
+      if (s.key !== void 0 && s.keys !== void 0)
+        errors.push(
+          `${at}: press takes key or keys, not both (keys says everything key does)`
+        );
+      else if (s.keys !== void 0) {
+        const list = Array.isArray(s.keys) ? s.keys : [s.keys];
+        if (!list.length)
+          errors.push(`${at}: press keys must name at least one key`);
+        else if (list.length > MAX_KEYS)
+          errors.push(`${at}: press keys names more than ${MAX_KEYS} keys`);
+        list.forEach((k, j) => {
+          const problem = chordProblem(k);
+          if (problem)
+            errors.push(
+              `${at}: press keys${Array.isArray(s.keys) ? `[${j}]` : ""} ${problem}`
+            );
+        });
+      } else if (typeof s.key !== "string" || !PRESS_KEYS.includes(s.key))
         errors.push(
-          `${at}: press needs a key, one of ${PRESS_KEYS.join(", ")}; words are typed with type`
+          `${at}: press needs a key, one of ${PRESS_KEYS.join(", ")}, or keys (a chord like "Shift+D", a plain key like "r", or a sequence); words are typed with type`
         );
       if (s.selector !== void 0 && typeof s.selector !== "string")
         errors.push(`${at}: press selector must be a string`);
     }
+    if (s.do === "click") {
+      errors.push(...modifiersProblem(at, "click", s.modifiers));
+      if (s.count !== void 0 && s.count !== 1 && s.count !== 2 && s.count !== 3)
+        errors.push(
+          `${at}: click count must be 1, 2 (a double click) or 3 (a triple click)`
+        );
+      if (s.button !== void 0 && !CLICK_BUTTONS.includes(s.button))
+        errors.push(`${at}: click button must be "left", "right" or "middle"`);
+    }
+    if (s.settle !== void 0) {
+      if (typeof s.settle !== "boolean")
+        errors.push(`${at}: settle must be true or false`);
+      else if (!SETTLE_VERBS.has(s.do))
+        errors.push(
+          `${at}: settle follows a gesture (hover, click, type, press, scroll, move, drag, paste); a ${s.do} sends the page nothing to catch up on`
+        );
+    }
+    if (s.do === "paste") {
+      const given = ["text", "file"].filter(
+        (k) => s[k] !== void 0
+      );
+      if (given.length !== 1)
+        errors.push(
+          `${at}: paste needs exactly one of text (words) or file (an image, an SVG or a text file beside the actions file)`
+        );
+      if (s.text !== void 0 && typeof s.text !== "string")
+        errors.push(`${at}: paste text must be a string`);
+      if (s.file !== void 0) {
+        const problem = typeof s.file === "string" ? fileNameProblem(s.file) ?? (pasteTypeOf(s.file) ? null : `"${s.file}" is not a type a paste takes (.png, .jpg, .webp, .gif, .svg, .txt, .md, .html, .json, .csv)`) : "is not a string";
+        if (problem) errors.push(`${at}: paste file ${problem}`);
+      }
+      if (s.selector !== void 0 && !isFilled(s.selector))
+        errors.push(`${at}: paste selector must be a non-empty string`);
+    }
     if (s.do === "scroll" && typeof s.dy !== "number")
       errors.push(`${at}: scroll needs dy`);
     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(
@@ -914,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`);
@@ -938,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));
@@ -985,18 +2654,74 @@ function validateActions(value) {
       }
     }
     if (s.do === "drag") {
-      if (typeof s.tx !== "number" || typeof s.ty !== "number") {
-        errors.push(`${at}: drag needs tx and ty (CSS px)`);
-      }
-      const hasStart = typeof s.selector === "string" || typeof s.x === "number" && typeof s.y === "number";
-      if (!hasStart)
-        errors.push(
-          `${at}: drag needs a selector OR x and y as the start point`
+      if (s.path !== void 0) {
+        const clash = ["selector", "x", "y", "tx", "ty"].filter(
+          (k) => s[k] !== void 0
         );
+        if (clash.length)
+          errors.push(
+            `${at}: a drag with a path starts at its first point and ends at its last, so it takes no ${clash.join(", ")}`
+          );
+        if (typeof s.path === "string") {
+          const problem = fileNameProblem(s.path);
+          if (problem)
+            errors.push(
+              `${at}: drag path ${problem} (a file beside the actions file)`
+            );
+        } else {
+          const read = readPath(s.path);
+          if ("problems" in read)
+            for (const p of read.problems) errors.push(`${at}: drag path ${p}`);
+        }
+      } else {
+        if (typeof s.tx !== "number" || typeof s.ty !== "number") {
+          errors.push(`${at}: drag needs tx and ty (CSS px), or a path`);
+        }
+        const hasStart = typeof s.selector === "string" || typeof s.x === "number" && typeof s.y === "number";
+        if (!hasStart)
+          errors.push(
+            `${at}: drag needs a selector OR x and y as the start point`
+          );
+      }
+      errors.push(...modifiersProblem(at, "drag", s.modifiers));
     }
   });
   return errors;
 }
+var isCoord = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+function modifiersProblem(at, verb, v) {
+  if (v === void 0) return [];
+  if (!Array.isArray(v) || v.some((m) => !DRAG_MODIFIERS.includes(m)))
+    return [
+      `${at}: ${verb} modifiers must be a list of ${DRAG_MODIFIERS.map((m) => `"${m}"`).join(", ")} (Mod is Meta on macOS, Control elsewhere)`
+    ];
+  if (new Set(v).size !== v.length)
+    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 [];
@@ -1049,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}`
@@ -1058,103 +2785,141 @@ function hostedRefusals(actions) {
       out.push(
         `steps[${i}] is a download, which a hosted take does not keep: record it on this machine, where the file lands in the take's outputs/`
       );
-  });
-  return out;
-}
-
-// src/record/waits.ts
-function visibleTextScript(text) {
-  return `(() => { const b = document.body; return !!b && (b.innerText || '').includes(${JSON.stringify(text)}) })()`;
-}
-async function readCondition(page, c) {
-  try {
-    if (c.text !== void 0)
-      return { holds: await page.evaluate(visibleTextScript(c.text)) };
-    if (c.gone !== void 0)
-      return { holds: !await page.locator(c.gone).first().isVisible() };
-    if (c.selector !== void 0) {
-      const loc = page.locator(c.selector).first();
-      const visible = await loc.isVisible();
-      if (!visible) return { holds: false, visible };
-      if (c.enabled === void 0) return { holds: true, visible };
-      const enabled = await loc.isEnabled({ timeout: 1e3 });
-      return { holds: enabled === c.enabled, visible };
-    }
-  } catch {
-  }
-  return { holds: false };
+    if (s.do === "paste")
+      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`
+      );
+  });
+  return out;
 }
-async function pollCondition(page, c, opts) {
-  const now = opts.now ?? Date.now;
-  const start = now();
-  const reads = Math.max(1, opts.confirm?.reads ?? 1);
-  for (let first = true; ; first = false) {
-    if (!first && opts.between) await opts.between();
-    let last = await readCondition(page, c);
-    for (let n = 1; last.holds && n < reads; n++) {
-      await opts.sleep(opts.confirm?.gapMs ?? 0);
-      last = await readCondition(page, c);
-    }
-    const ms = now() - start;
-    if (last.holds) return { ok: true, ms, last };
-    const left = opts.timeoutMs - ms;
-    if (left <= 0) return { ok: false, ms, last };
-    await opts.sleep(Math.min(opts.everyMs, left));
-  }
+function scriptFiles(actions) {
+  const out = [];
+  actions.steps.forEach((s, i) => {
+    if (s.do === "drag" && typeof s.path === "string")
+      out.push({ step: i, name: s.path, as: "path" });
+    if (s.do === "paste" && typeof s.file === "string")
+      out.push({ step: i, name: s.file, as: "paste" });
+  });
+  return out;
 }
-var DOM_QUIET_MS = 800;
-var DOM_SETTLE_CAP_MS = 5e3;
-var DOM_CHANGE_PROBE = `(() => {
-  if (!window.__vosDomChanges) {
-    window.__vosDomChanges = { n: 0 };
-    new MutationObserver((list) => { window.__vosDomChanges.n += list.length })
-      .observe(document, { subtree: true, childList: true, attributes: true, characterData: true });
+
+// src/record/scriptFiles.ts
+async function loadScriptFiles(actions, source) {
+  const loaded = { paths: /* @__PURE__ */ new Map(), pastes: /* @__PURE__ */ new Map() };
+  const named = scriptFiles(actions);
+  if (!named.length) return loaded;
+  if (!source) {
+    const f = named[0];
+    return {
+      problem: `steps[${f.step}] names the file "${f.name}", and this recorder has no actions directory to read it from${f.as === "path" ? ": write the points inline as path" : ""}. Nothing was recorded.`
+    };
   }
-  return window.__vosDomChanges.n;
-})()`;
-async function domSettled(page, opts) {
-  const now = opts.now ?? Date.now;
-  const quiet = opts.quietMs ?? DOM_QUIET_MS;
-  const cap = opts.capMs ?? DOM_SETTLE_CAP_MS;
-  const start = now();
-  let seen = await page.evaluate(DOM_CHANGE_PROBE).catch(() => -1);
-  let since = start;
-  for (; ; ) {
-    const t = now();
-    if (t - since >= quiet) return { settled: true, ms: t - start };
-    if (t - start >= cap) return { settled: false, ms: t - start };
-    await opts.sleep(opts.tickMs ?? 100);
-    const n = await page.evaluate(DOM_CHANGE_PROBE).catch(() => -1);
-    if (n !== seen) {
-      seen = n;
-      since = now();
+  for (const f of named) {
+    const at = `steps[${f.step}]`;
+    const bad = fileNameProblem(f.name);
+    if (bad) return { problem: `${at}: ${bad}. Nothing was recorded.` };
+    let bytes;
+    try {
+      bytes = await source.read(f.name);
+    } 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 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") {
+      let raw;
+      try {
+        raw = JSON.parse(new TextDecoder().decode(bytes));
+      } catch {
+        return {
+          problem: `${at}: the path file "${f.name}" is not JSON (an array of [x, y] or [x, y, tMs] points). Nothing was recorded.`
+        };
+      }
+      const path = readPath(raw);
+      if ("problems" in path)
+        return {
+          problem: `${at}: the path file "${f.name}" ${path.problems.join("; ")}. Nothing was recorded.`
+        };
+      loaded.paths.set(f.step, path);
+    } else {
+      if (bytes.length > PASTE_MAX_BYTES)
+        return {
+          problem: `${at}: "${f.name}" is larger than ${PASTE_MAX_BYTES / 1024 / 1024} MB, more than a paste carries. Nothing was recorded.`
+        };
+      loaded.pastes.set(f.step, {
+        bytes,
+        type: pasteTypeOf(f.name) ?? "application/octet-stream",
+        name: f.name
+      });
     }
   }
+  return loaded;
 }
-function sayDuration(ms) {
-  const s = Math.round(ms / 100) / 10;
-  if (s < 60) return `${s} s`;
-  const m = Math.floor(s / 60);
-  const rest = Math.round(s - m * 60);
-  return rest ? `${m} min ${rest} s` : `${m} min`;
+function inlinePoints(path) {
+  return path.points.map((p) => {
+    if (path.timed)
+      return p.pressure !== void 0 ? [p.x, p.y, p.at, p.pressure] : [p.x, p.y, p.at];
+    return p.pressure !== void 0 ? { x: p.x, y: p.y, pressure: p.pressure } : [p.x, p.y];
+  });
 }
-function sayCondition(c) {
-  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`;
-  if (c.enabled === false) return `'${c.selector}' to be disabled`;
-  return `'${c.selector}' to appear`;
+function inlineScript(actions, files) {
+  if (!files.paths.size) return actions;
+  return {
+    ...actions,
+    steps: actions.steps.map((s, i) => {
+      const read = files.paths.get(i);
+      if (s.do !== "drag" || typeof s.path !== "string" || !read) return s;
+      return { ...s, path: inlinePoints(read) };
+    })
+  };
 }
-function conditionMiss(c, last, ms) {
-  const t = sayDuration(ms);
-  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}`;
-  if (last.visible && c.enabled === true)
-    return `'${c.selector}' stayed disabled for ${t}`;
-  if (last.visible && c.enabled === false)
-    return `'${c.selector}' stayed enabled for ${t}`;
-  return `'${c.selector}' never appeared in ${t}`;
+
+// src/record/pasteStep.ts
+function toBase64(bytes) {
+  let bin = "";
+  for (let i = 0; i < bytes.length; i += 32768)
+    bin += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return btoa(bin);
+}
+function pasteItemOf(step, stepIdx, files) {
+  if (step.text !== void 0) return { text: step.text };
+  const f = files.pastes.get(stepIdx);
+  if (!f) return null;
+  return { b64: toBase64(f.bytes), type: f.type, name: f.name };
+}
+async function runPaste(page, context, item, press) {
+  if (item.b64 !== void 0 && item.type?.startsWith("image/")) {
+    const done2 = await page.evaluate(syntheticPasteScript(item, { original: true })).catch((e) => `failed: ${e instanceof Error ? e.message : e}`);
+    return done2 === "ok" ? { via: "file" } : { failed: `the page's paste failed (${done2.replace(/^failed: /, "")})` };
+  }
+  let origin;
+  try {
+    origin = new URL(page.url()).origin;
+  } catch {
+    origin = void 0;
+  }
+  if (context.grantPermissions && origin && origin !== "null")
+    await context.grantPermissions(["clipboard-read", "clipboard-write"], { origin }).catch(() => void 0);
+  const staged = await page.evaluate(stageClipboardScript(item)).catch((e) => `refused: ${e instanceof Error ? e.message : e}`);
+  if (staged === "ok") {
+    await press("ControlOrMeta+v");
+    return { via: "clipboard" };
+  }
+  const why = staged.replace(/^refused: /, "");
+  const done = await page.evaluate(syntheticPasteScript(item)).catch((e) => `failed: ${e instanceof Error ? e.message : e}`);
+  if (done === "ok") return { via: "page", why };
+  return {
+    failed: `this browser has no clipboard to paste from (${why}), and the page's own paste failed too (${done.replace(/^failed: /, "")})`
+  };
 }
 
 // src/record/outputs.ts
@@ -1228,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;
@@ -1318,6 +3083,25 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         `steps[${download}] is a download, and this recorder has nowhere to keep a file. Nothing was recorded.`
       );
   }
+  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({
@@ -1329,11 +3113,17 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     await applyHeaders(context, opts.headers, url, log);
   const masks = actions.mask ?? [];
   if (masks.length) await context.addInitScript(maskInitScript(masks));
+  await context.addInitScript(MEDIA_WATCH_SCRIPT);
+  const soundLog = new PageSoundLog();
   const exposureLog = new ExposureLog(masks);
-  const page = await context.newPage();
+  const noticeLog = new NoticeLog();
+  const rawPage = await context.newPage();
+  const pageBound = new StepBound();
+  const page = bounded(rawPage, pageBound);
   const scanExposures = async (step) => {
     const scan = await page.evaluate(EXPOSURE_PROBE).catch(() => null);
     exposureLog.add(step, scan);
+    noticeLog.add(step, scan?.notices);
   };
   const pageErrors = new PageErrorLog(opts.verbose === true);
   page.on("console", (m) => {
@@ -1341,20 +3131,23 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     const line = pageErrors.add(m.text());
     if (line) log(line);
   });
-  log(`goto ${url}`);
-  let navTimeout = false;
-  let response = await page.goto(url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => {
-    navTimeout = true;
-    log("   (networkidle timeout \u2014 continuing)");
-    return null;
+  const readyMode = actions.ready ?? DEFAULT_READY;
+  const open = (target) => untilReady(page, readyMode, (o) => page.goto(target, o), {
+    sleep: realSleep
   });
-  await sleep(800);
+  log(`goto ${url}`);
+  const opened = await open(url);
+  let response = opened.response;
+  const ready = opened.ready;
+  log(`   ${readyLine(ready)}`);
+  const navTimeout = ready.mode === "networkidle" && ready.capped;
   const setup = actions.setup ?? [];
   if (setup.length) {
     log(`setup: ${setup.length} step(s), off camera`);
     const result = await runSetup(page, setup, {
       sleep: realSleep,
-      env: opts.env ?? {}
+      env: opts.env ?? {},
+      goto: (target) => open(target)
     });
     for (const line of result.lines) log(`   ${line}`);
     if (result.failed) {
@@ -1363,8 +3156,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       throw new SetupError(result.failed);
     }
     log(`goto ${url} (after setup)`);
-    response = await page.goto(url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => null);
-    await sleep(800);
+    response = (await open(url)).response;
   }
   let wall = null;
   if (opts.onArrival) {
@@ -1385,7 +3177,64 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     }
   }
   await scanExposures(-1);
-  const cdp = await context.newCDPSession(page);
+  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 = [];
   let frameIdx = 0;
   let t0 = 0;
@@ -1430,6 +3279,10 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     return { out, at, ms };
   };
   const emit = (e) => events.push({ t: now(), ...e });
+  const drainSound = async (step) => {
+    const drain = await page.evaluate(MEDIA_DRAIN_PROBE).catch(() => null);
+    soundLog.add(drain, Date.now(), step);
+  };
   await page.mouse.move(cur.x, cur.y);
   emit({ x: cur.x, y: cur.y, type: "move" });
   const clock = { now: () => Date.now(), sleep };
@@ -1521,27 +3374,58 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       ...type ? { contentType: type } : {}
     };
   };
-  const clickAt = async (rect) => {
-    await moveTo(rect.x + rect.w / 2, rect.y + rect.h / 2);
-    await sleep(PRESS_LEAD_MS);
-    emit({
-      x: Math.round(cur.x),
-      y: Math.round(cur.y),
-      type: "down",
-      button: 0,
-      rect
-    });
-    await page.mouse.down();
-    await sleep(PRESS_HOLD_MS);
-    await page.mouse.up();
-    emit({
-      x: Math.round(cur.x),
-      y: Math.round(cur.y),
-      type: "up",
-      button: 0,
-      rect
-    });
+  const clickAt = async (at, how = {}) => {
+    const rect = "w" in at ? at : void 0;
+    await moveTo(
+      rect ? rect.x + rect.w / 2 : at.x,
+      rect ? rect.y + rect.h / 2 : at.y
+    );
+    const held = [];
+    try {
+      for (const m of how.modifiers ?? []) {
+        const key = resolveModifier(m);
+        await page.keyboard.down(key);
+        held.push(key);
+      }
+      await sleep(PRESS_LEAD_MS);
+      const count = how.count ?? 1;
+      const button = buttonNumber(how.button);
+      for (let n = 1; n <= count; n++) {
+        if (n > 1) await sleep(MULTI_CLICK_GAP_MS);
+        const press = {
+          ...how.button && how.button !== "left" ? { button: how.button } : {},
+          ...n > 1 ? { clickCount: n } : {}
+        };
+        const hasOpts = Object.keys(press).length > 0;
+        emit({
+          x: Math.round(cur.x),
+          y: Math.round(cur.y),
+          type: "down",
+          button,
+          ...rect ? { rect } : {}
+        });
+        await (hasOpts ? page.mouse.down(press) : page.mouse.down());
+        await sleep(n < count ? PRESS_HOLD_MS / 2 : PRESS_HOLD_MS);
+        await (hasOpts ? page.mouse.up(press) : page.mouse.up());
+        emit({
+          x: Math.round(cur.x),
+          y: Math.round(cur.y),
+          type: "up",
+          button,
+          ...rect ? { rect } : {}
+        });
+      }
+    } finally {
+      for (const key of held.reverse())
+        await page.keyboard.up(key).catch(() => void 0);
+    }
   };
+  const keyPing = (rect) => emit({
+    x: Math.round(rect ? rect.x + rect.w / 2 : cur.x),
+    y: Math.round(rect ? rect.y + rect.h / 2 : cur.y),
+    type: "key",
+    ...rect ? { rect } : {}
+  });
   const waitSettled = async () => {
     if (dry) return null;
     const pressAt = now();
@@ -1563,9 +3447,27 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const skips = [];
   const outputs = [];
   const outputNames = /* @__PURE__ */ new Set();
+  const overruns = [];
   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;
@@ -1580,6 +3482,16 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       return out;
     };
     const skippedBefore = skipped.length;
+    const paced = {
+      v: null
+    };
+    const timed = async (plannedMs, fn) => {
+      const t = Date.now();
+      const out = await fn();
+      paced.v = { plannedMs, tookMs: Date.now() - t };
+      return out;
+    };
+    let askedOverride = null;
     const urlBefore = page.url();
     let stepRect = null;
     const extra = {};
@@ -1595,7 +3507,13 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       if (reason) extra.reason = reason;
     };
     if (step.guard) extra.guard = step.guard;
-    const rehearseGuard = async (sel) => {
+    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;
       stepRect = rect;
@@ -1603,8 +3521,9 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       else {
         if (rect)
           await gesture(() => moveTo(rect.x + rect.w / 2, rect.y + rect.h / 2));
+        else if (point) await gesture(() => moveTo(point.x, point.y));
         log(
-          `${tag}: guarded (${step.guard}), ${rect ? "hovered" : "left alone"}, not pressed`
+          `${tag}: guarded (${step.guard}), ${rect || point ? "hovered" : "left alone"}, not pressed`
         );
       }
       unpressedGuard = stepIdx;
@@ -1618,14 +3537,41 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       );
       return true;
     };
+    const boundMs = stepBoundMs(
+      step,
+      askedMs(step),
+      {
+        expectS: EXPECT_TIMEOUT_S2,
+        awaitS: AWAIT_TIMEOUT_S,
+        downloadS: DOWNLOAD_TIMEOUT_S
+      }
+    );
+    opts.onEvent?.({
+      event: "step",
+      phase: "start",
+      i: stepIdx,
+      ...step.id ? { id: step.id } : {},
+      do: step.do
+    });
+    signals.start(step.id);
+    const stepWall = Date.now();
+    pageBound.start(boundMs);
     switch (step.do) {
       case "wait":
         await sleep(clampWait(step.ms, now(), maxSeconds));
         break;
       case "move":
-        await moveTo(step.x, step.y);
+        await gesture(() => moveTo(step.x, step.y));
         break;
       case "hover": {
+        if (step.selector === void 0) {
+          const px = step.x ?? cur.x;
+          const py = step.y ?? cur.y;
+          await gesture(() => moveTo(px, py));
+          log(`hover ${Math.round(px)},${Math.round(py)}`);
+          await sleep(step.ms ?? 700);
+          break;
+        }
         const rect = await boxOf(step.selector);
         stepRect = rect;
         if (rect) {
@@ -1637,6 +3583,21 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "click": {
+        const how = {
+          count: step.count,
+          button: step.button,
+          modifiers: step.modifiers
+        };
+        const said = `${step.count === 3 ? "triple-click" : step.count === 2 ? "double-click" : "click"}${step.button && step.button !== "left" ? ` (${step.button})` : ""}${step.modifiers?.length ? ` holding ${step.modifiers.join("+")}` : ""}`;
+        if (step.selector === void 0) {
+          const point = { x: step.x ?? cur.x, y: step.y ?? cur.y };
+          if (await rehearseGuard(void 0, point)) break;
+          await gesture(() => clickAt(point, how));
+          log(`${said} at ${Math.round(point.x)},${Math.round(point.y)}`);
+          const sinceChange = await gesture(() => waitSettled());
+          await sleep(holdLeftMs(settleMs(step), sinceChange));
+          break;
+        }
         if (await rehearseGuard(step.selector)) break;
         const rect = await boxOf(step.selector);
         stepRect = rect;
@@ -1652,8 +3613,8 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
               `   (${tag} click: ${step.selector} is disabled; pressed anyway)`
             );
           }
-          await gesture(() => clickAt(rect));
-          log(`click ${step.selector}`);
+          await gesture(() => clickAt(rect, how));
+          log(`${said} ${step.selector}`);
           const sinceChange = await gesture(() => waitSettled());
           await sleep(holdLeftMs(settleMs(step), sinceChange));
         } else
@@ -1677,17 +3638,21 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
             rect
           });
           let lastPing = -Infinity;
-          await clockTyping(
-            [...step.text],
-            delay,
-            async (ch) => {
-              if (now() - lastPing >= 350) {
-                lastPing = now();
-                ping();
-              }
-              await page.keyboard.type(ch);
-            },
-            clock
+          const chars = [...step.text];
+          await timed(
+            Math.max(0, chars.length - 1) * delay,
+            () => clockTyping(
+              chars,
+              delay,
+              async (ch) => {
+                if (now() - lastPing >= 350) {
+                  lastPing = now();
+                  ping();
+                }
+                await page.keyboard.type(ch);
+              },
+              clock
+            )
           );
           ping();
           log(`type ${step.text.length} chars into ${step.selector}`);
@@ -1711,14 +3676,18 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
             break;
           }
         }
-        emit({
-          x: Math.round(rect ? rect.x + rect.w / 2 : cur.x),
-          y: Math.round(rect ? rect.y + rect.h / 2 : cur.y),
-          type: "key",
-          ...rect ? { rect } : {}
+        const seq = pressSequence(step);
+        const chords = step.keys !== void 0 ? seq.map(resolveChord) : seq;
+        const plan = keySequencePlanMs(chords.length);
+        if (chords.length > 1) askedOverride = plan + settleMs(step);
+        await timed(plan, async () => {
+          for (const [i, chord] of chords.entries()) {
+            if (i > 0) await sleep(KEY_SEQUENCE_GAP_MS);
+            keyPing(rect);
+            await page.keyboard.press(chord);
+          }
         });
-        await page.keyboard.press(step.key);
-        log(`press ${step.key}`);
+        log(`press ${seq.join(", ")}`);
         const sinceChange = await gesture(() => waitSettled());
         await sleep(holdLeftMs(settleMs(step), sinceChange));
         break;
@@ -1749,9 +3718,19 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "drag": {
+        let path = null;
+        if (typeof step.path === "string") {
+          const read2 = files.paths.get(stepIdx);
+          if (read2) path = schedulePath(read2, step.ms);
+        } else if (step.path !== void 0) {
+          const read2 = readPath(step.path);
+          if (!("problems" in read2)) path = schedulePath(read2, step.ms);
+        }
         let start = null;
         let rect;
-        if (step.selector) {
+        if (path) {
+          start = { x: path[0].x, y: path[0].y };
+        } else if (step.selector) {
           const box = await boxOf(step.selector);
           stepRect = box;
           if (box) {
@@ -1769,53 +3748,160 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
           start = { x: step.x, y: step.y };
         }
         if (!start) break;
-        await gesture(() => moveTo(start.x, start.y));
-        await gesture(() => sleep(PRESS_LEAD_MS));
-        emit({
-          x: Math.round(cur.x),
-          y: Math.round(cur.y),
-          type: "down",
-          button: 0,
-          rect
-        });
-        await page.mouse.down();
-        await gesture(() => sleep(PRESS_HOLD_MS));
-        const dur = step.ms ?? 700;
-        const from = { ...cur };
-        await clockMotion(
-          dur,
-          async (u) => {
-            cur.x = from.x + (step.tx - from.x) * u;
-            cur.y = from.y + (step.ty - from.y) * u;
-            await page.mouse.move(cur.x, cur.y);
-            emit({ x: Math.round(cur.x), y: Math.round(cur.y), type: "move" });
-          },
-          clock
+        const from0 = start;
+        await gesture(() => moveTo(from0.x, from0.y));
+        const mods = step.modifiers ?? [];
+        const held = [];
+        try {
+          for (const m of mods) {
+            const key = resolveModifier(m);
+            await page.keyboard.down(key);
+            held.push(key);
+          }
+          await gesture(() => sleep(PRESS_LEAD_MS));
+          const bits = modifierBits(mods, opts.platform);
+          const penAt = (type, p) => cdp.send("Input.dispatchMouseEvent", {
+            type,
+            x: p.x,
+            y: p.y,
+            button: "left",
+            buttons: type === "mouseReleased" ? 0 : 1,
+            ...type === "mouseMoved" ? {} : { clickCount: 1 },
+            pointerType: "pen",
+            force: type === "mouseReleased" ? 0 : p.pressure ?? 0.5,
+            modifiers: bits
+          });
+          let pen = path?.some((p) => p.pressure !== void 0) ?? false;
+          if (pen && path) {
+            try {
+              await penAt("mousePressed", path[0]);
+            } catch {
+              pen = false;
+              log(
+                `   (${tag} drag: this browser takes no pen input; the path is drawn with the mouse and its pressure dropped)`
+              );
+            }
+          }
+          emit({
+            x: Math.round(cur.x),
+            y: Math.round(cur.y),
+            type: "down",
+            button: 0,
+            rect
+          });
+          if (!pen) await page.mouse.down();
+          await gesture(() => sleep(PRESS_HOLD_MS));
+          if (path) {
+            const pts = path;
+            const total = pathDurationMs(pts);
+            askedOverride = total;
+            await timed(total, async () => {
+              const from = Date.now();
+              for (let i = 1; i < pts.length; i++) {
+                const p = pts[i];
+                if (!dry) {
+                  const wait = from + p.at - Date.now();
+                  if (wait > 0) await realSleep(wait);
+                }
+                if (pen) await penAt("mouseMoved", p);
+                else await page.mouse.move(p.x, p.y);
+                cur.x = p.x;
+                cur.y = p.y;
+                emit({ x: Math.round(p.x), y: Math.round(p.y), type: "move" });
+              }
+            });
+          } else {
+            const dur = step.ms ?? 700;
+            const from = { ...cur };
+            const tx = step.tx ?? from.x;
+            const ty = step.ty ?? from.y;
+            await timed(
+              dur,
+              () => clockMotion(
+                dur,
+                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);
+                  emit({
+                    x: Math.round(cur.x),
+                    y: Math.round(cur.y),
+                    type: "move"
+                  });
+                },
+                clock
+              )
+            );
+          }
+          await gesture(() => sleep(settleMs({ do: "drag" })));
+          if (pen) await penAt("mouseReleased", { x: cur.x, y: cur.y });
+          else await page.mouse.up();
+          emit({
+            x: Math.round(cur.x),
+            y: Math.round(cur.y),
+            type: "up",
+            button: 0,
+            rect
+          });
+        } finally {
+          for (const key of held.reverse())
+            await page.keyboard.up(key).catch(() => void 0);
+        }
+        const holding = mods.length ? ` holding ${mods.join("+")}` : "";
+        log(
+          path ? `drag a path of ${path.length} points from ${Math.round(start.x)},${Math.round(start.y)}${holding}` : `drag ${step.selector ?? `${start.x},${start.y}`} \u2192 ${step.tx},${step.ty}${holding}`
         );
-        await gesture(() => sleep(settleMs({ do: "drag" })));
-        await page.mouse.up();
-        emit({
-          x: Math.round(cur.x),
-          y: Math.round(cur.y),
-          type: "up",
-          button: 0,
-          rect
+        await gesture(() => sleep(DRAG_HOLD_MS));
+        break;
+      }
+      case "paste": {
+        const item = pasteItemOf(step, stepIdx, files);
+        if (!item) {
+          skip(step.file ?? "", `"${step.file}" was not read`);
+          break;
+        }
+        let rect = null;
+        if (step.selector) {
+          rect = await boxOf(step.selector);
+          stepRect = rect;
+          if (!rect) {
+            skip(step.selector);
+            break;
+          }
+          const at = rect;
+          await gesture(() => clickAt(at));
+        }
+        const ping = { done: false };
+        const outcome = await runPaste(page, context, item, async (chord) => {
+          keyPing(rect);
+          ping.done = true;
+          await page.keyboard.press(chord);
         });
+        if ("failed" in outcome) {
+          skip(step.selector ?? step.file ?? "paste", outcome.failed);
+          log(`   (${tag} paste: ${outcome.failed})`);
+          break;
+        }
+        if (!ping.done) keyPing(rect);
+        const what = step.text !== void 0 ? `${[...step.text].length} chars` : `the file ${step.file}`;
+        const into = step.selector ? ` into ${step.selector}` : "";
         log(
-          `drag ${step.selector ?? `${start.x},${start.y}`} \u2192 ${step.tx},${step.ty}`
+          outcome.via === "file" ? `paste ${what}${into}, dispatched in the page with the file's own bytes (the browser's clipboard re-encodes an image and drops what it carries, its density among it); its events are untrusted` : outcome.via === "page" ? `paste ${what}${into}, dispatched in the page (the browser's clipboard refused it: ${outcome.why}); its events are untrusted` : `paste ${what}${into}`
         );
-        await sleep(400);
+        const sinceChange = await gesture(() => waitSettled());
+        await sleep(holdLeftMs(settleMs(step), sinceChange));
         break;
       }
       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);
@@ -1828,14 +3914,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         if (notWaited()) break;
         const cond = step.until;
         const timeoutMs = (step.timeout ?? AWAIT_TIMEOUT_S) * 1e3;
-        const reload = step.reload ? async () => {
-          const opts2 = {
-            waitUntil: "networkidle",
-            timeout: Math.min(45e3, timeoutMs)
-          };
-          await (page.reload ? page.reload(opts2) : page.goto(page.url(), opts2)).catch(() => null);
-          await domSettled(page, { sleep: realSleep });
-        } : void 0;
+        const reload = step.reload ? () => reloadUntilReady(page, readyMode, timeoutMs) : void 0;
         log(`await ${sayCondition(cond)} (off camera)\u2026`);
         const awaitEvent = {
           event: "await",
@@ -1867,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;
@@ -1965,6 +4045,50 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
     }
+    if (settleOn(step, actions.settle) && skipped.length === skippedBefore && !stopped) {
+      const res = await gesture(
+        () => appSettled(page, () => frames.length, {
+          sleep: realSleep,
+          sinceFrame: () => frames.length ? now() - frames[frames.length - 1].tMs : null
+        })
+      );
+      extra.settleMs = res.ms;
+      if (!res.settled)
+        log(
+          `   (${tag} settle: the page was still changing after ${sayDuration(res.ms)}; going on)`
+        );
+    }
+    if (paced.v && !dry) {
+      const over = overrunOf(paced.v.plannedMs, paced.v.tookMs);
+      if (over !== null) {
+        overruns.push({
+          step: stepIdx,
+          ...step.id ? { id: step.id } : {},
+          do: step.do,
+          plannedMs: Math.round(paced.v.plannedMs),
+          tookMs: Math.round(paced.v.tookMs),
+          overrunMs: over
+        });
+        extra.overrunMs = over;
+      }
+    }
+    const hang = pageBound.end();
+    if (hang.hung) {
+      const reason = hangReason(step.do, hang.ms, hang.boundMs);
+      const said = skipped.length > skippedBefore ? skipped.at(-1) : void 0;
+      if (said) {
+        said.reason = reason;
+        extra.reason = reason;
+      } else skip(step.selector ?? "", reason);
+      log(`   (${tag} ${step.do}: ${reason})`);
+      if (opts.stopOnHang && !stopped)
+        stopped = {
+          step: stepIdx,
+          ...step.id ? { id: step.id } : {},
+          reason: `${tag} ${step.do}: ${reason}, so the take stopped there`
+        };
+    }
+    pageBound.start(POST_STEP_READ_MS);
     if (step.guard && !dry && skipped.length === skippedBefore) {
       confirmed.push(step.id ?? String(stepIdx));
       extra.confirmed = true;
@@ -1999,25 +4123,67 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     paces.push({
       step: stepIdx,
       do: step.do,
-      askedMs: askedMs(step),
+      askedMs: askedOverride ?? askedMs(step),
       gestureMs,
       wallMs: now() - stepStart
     });
     await scanExposures(stepIdx);
+    await drainSound(stepIdx);
+    pageBound.end();
+    const stepSpan = stepSpans[stepSpans.length - 1];
+    signals.end(step.id);
+    opts.onEvent?.({
+      event: "step",
+      phase: "end",
+      i: stepIdx,
+      ...step.id ? { id: step.id } : {},
+      do: step.do,
+      ms: Date.now() - stepWall,
+      ...stepSpan?.skipped ? { skipped: true } : {},
+      ...hang.hung ? { hung: true } : {}
+    });
     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;
     log(`   ${cappedLine(maxSeconds)}`);
   }
+  pageBound.start(POST_STEP_READ_MS * 2);
+  await drainSound();
+  const endWall = Date.now();
   const durationMs = capped ? Math.min(now(), maxSeconds * 1e3) : now();
+  const heard = soundLog.heard(takeClock, endWall, durationMs);
   await cdp.send("Page.stopScreencast").catch(() => {
   });
+  const media = await keepPageSound(
+    heard,
+    dry ? void 0 : opts.sounds,
+    fetchSource,
+    log
+  );
   await sleep(200);
-  const pageTitle = await page.title().catch(() => "");
+  const pageTitle = await page.title().catch(() => "") ?? "";
   for (const line of pageErrors.repeats()) log(line);
-  await context.close();
+  pageBound.end();
+  pageBound.start(CLOSE_BOUND_MS);
+  await pageBound.race(context.close().catch(() => {
+  }));
+  pageBound.end();
+  await closePeers();
   await sinkChain;
   const meta = {
     dpr: 1,
@@ -2040,9 +4206,18 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     steps: stepSpans,
     ...wall ? { wall: { kind: wall.kind, asked: wall.asked, landed: wall.landed } } : {},
     ...exposureLog.exposures().length ? { exposures: exposureLog.exposures() } : {},
+    ...noticeLog.notices().length ? { notices: noticeLog.notices() } : {},
     ...masks.length ? { masks: exposureLog.masks(masks) } : {},
     ...skips.length ? { skips } : {},
-    ...outputs.length ? { outputs } : {}
+    ...outputs.length ? { outputs } : {},
+    ...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++) {
@@ -2058,9 +4233,11 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const frozenMs = freezes.reduce((sum, f) => sum + f.ms, 0);
   const freezePct = durationMs > 0 ? Math.round(frozenMs / durationMs * 100) : 0;
   const dead = deadTime(stepSpans, frames, events, durationMs);
-  if (deadWarns(dead)) log(`   WARNING: ${deadLine(dead)}`);
+  if (!dry && deadWarns(dead)) log(`   WARNING: ${deadLine(dead)}`);
   const pace = paceReport(paces);
   if (!dry) log(`   ${paceLine(pace)}`);
+  const overrun = overrunLine(overruns);
+  if (overrun) log(`   WARNING: ${overrun}`);
   return {
     events,
     frames,
@@ -2068,8 +4245,10 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     pace,
     skipped,
     navTimeout,
+    ready,
     wall,
     exposures: exposureLog.exposures(),
+    notices: noticeLog.notices(),
     masks: exposureLog.masks(masks),
     freezes,
     freezePct,
@@ -2079,11 +4258,51 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     confirmed,
     skips,
     outputs,
+    media,
     stopped,
     pageErrors: pageErrors.entries(),
-    actions: { ...actions, url }
+    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 },
+    peers: peerRuns
   };
 }
+async function keepPageSound(heard, sink, fetchSource, log) {
+  const kept = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const h of heard) {
+    if (!h.meta.intervals.length) continue;
+    const stretches = h.meta.intervals.length;
+    log(
+      `   page sound: ${h.meta.src || "a media element"} heard ${stretches === 1 ? "once" : `${stretches} times`}`
+    );
+    if (!sink || kept.has(h.src)) continue;
+    try {
+      const got = await fetchSource(h.src);
+      const name = outputName(
+        void 0,
+        got.suggested,
+        `sound-${kept.size + 1}${extForType(got.contentType)}`,
+        used
+      );
+      used.add(name);
+      kept.set(h.src, {
+        file: await sink.save(name, got.bytes, got.contentType)
+      });
+    } catch (e) {
+      const why = e instanceof Error ? e.message : String(e);
+      kept.set(h.src, { fetchError: why });
+      log(`   (page sound not kept: ${why})`);
+    }
+  }
+  return heard.map((h) => ({ ...h.meta, ...kept.get(h.src) ?? {} }));
+}
+var POST_STEP_READ_MS = 5e3;
+var CLOSE_BOUND_MS = 1e4;
+function hangReason(verb, ms, boundMs) {
+  return `the page stopped answering: this ${verb} ran ${sayDuration(ms)}, past its bound of ${sayDuration(boundMs)}`;
+}
 var EXT_FOR_TYPE = {
   "video/mp4": ".mp4",
   "video/webm": ".webm",
@@ -2145,7 +4364,15 @@ try {
       fi = next
       const blob = await (await fetch(${JSON.stringify(o.framesBaseUrl)} + frames[fi].file + ${JSON.stringify(q)})).blob()
       const bmp = await createImageBitmap(blob)
-      c2.drawImage(bmp, 0, 0, W, H)
+      // A frame is drawn at its own size, never stretched to the take's: a
+      // frame of another size means the surface moved mid-take, and a
+      // picture scaled to fit would be a distorted take nobody was told of.
+      if (bmp.width !== W || bmp.height !== H) {
+        const size = bmp.width + 'x' + bmp.height
+        bmp.close()
+        throw new Error('frame ' + frames[fi].file + ' is ' + size + ', the take is ' + W + 'x' + H + ' (meta.captureWidth/captureHeight): frames are never resized, so the recorded surface changed size mid-take. Re-record it')
+      }
+      c2.drawImage(bmp, 0, 0)
       bmp.close()
     }
     await src.add(t, 1 / FPS)
@@ -2169,9 +4396,12 @@ try {
 // src/record/plan.ts
 import {
   DEFAULT_FRAME_STYLE,
+  EXPORT_RESOLUTION_OPTIONS,
   planAutoSpeed,
   planAutoZoom,
   projectFromArtifact,
+  ratedSegments,
+  recommendedExportResolution,
   withBackdrop
 } from "@vosjs/studio-core";
 function planFreshTake(artifact, recordingName, opts = {}) {
@@ -2190,6 +4420,66 @@ function planFreshTake(artifact, recordingName, opts = {}) {
     params: doc.speedParams,
     activity: opts.activity
   });
+  return withFittingExport(withPageSound(doc, artifact.meta.media));
+}
+function withFittingExport(doc) {
+  if (!doc.export) return doc;
+  const fits = recommendedExportResolution(doc);
+  const order = EXPORT_RESOLUTION_OPTIONS;
+  if (order.indexOf(fits) < order.indexOf(doc.export.resolution))
+    doc.export = { ...doc.export, resolution: fits };
+  return doc;
+}
+function sourceToOutput(pieces, s) {
+  let acc = 0;
+  for (const p of pieces) {
+    const rate = p.rate && p.rate > 0 ? p.rate : 1;
+    if (p.media) {
+      acc += Math.max(0, p.out - p.in) / rate;
+      continue;
+    }
+    if (s < p.in) return acc;
+    if (s <= p.out) return acc + (s - p.in) / rate;
+    acc += Math.max(0, p.out - p.in) / rate;
+  }
+  return acc;
+}
+function withPageSound(doc, media) {
+  const kept = (doc.audio ?? []).filter((a) => a.source !== "page");
+  const heard = (media ?? []).filter((m) => m.file && m.intervals.length);
+  if (!heard.length) {
+    doc.audio = kept;
+    return doc;
+  }
+  const spans = heard.flatMap(
+    (m) => m.intervals.map((iv) => ({ in: iv.at, out: iv.at + (iv.to - iv.from) }))
+  );
+  doc.speed = (doc.speed ?? []).filter(
+    (sp) => sp.source !== "auto" || !!sp.media || !spans.some((h) => sp.in < h.out && h.in < sp.out)
+  );
+  const pieces = ratedSegments(doc);
+  const clips = [];
+  heard.forEach((m, i) => {
+    const file = m.file;
+    const name = file.split("/").pop() || file;
+    const length = Math.max(m.duration ?? 0, ...m.intervals.map((iv) => iv.to));
+    m.intervals.forEach((iv, j) => {
+      clips.push({
+        id: `page-${i + 1}-${j + 1}`,
+        key: file,
+        name,
+        start: +sourceToOutput(pieces, iv.at).toFixed(3),
+        in: iv.from,
+        out: iv.to,
+        duration: +length.toFixed(3),
+        gain: m.volume ?? 1,
+        fadeIn: 0,
+        fadeOut: 0,
+        source: "page"
+      });
+    });
+  });
+  doc.audio = [...kept, ...clips];
   return doc;
 }
 function splitSegmentsAtSkips(segments, skips) {
@@ -2223,24 +4513,58 @@ function splitSegmentsAtSkips(segments, skips) {
   return out;
 }
 export {
+  APP_QUIET_MS,
+  APP_SETTLE_CAP_MS,
   AWAIT_HEARTBEAT_MS,
   AWAIT_POLL_S,
   AWAIT_TIMEOUT_S,
+  CHANGE_AGE_PROBE,
+  CLICK_BUTTONS,
   DEAD_SHARE_WARN_PCT,
   DEAD_STRETCH_WARN_MS,
+  DEFAULT_READY,
   DOM_CHANGE_PROBE,
   DOM_QUIET_MS,
   DOM_SETTLE_CAP_MS,
   DOWNLOAD_TIMEOUT_S,
-  EXPECT_TIMEOUT_S,
+  DRAG_HOLD_MS,
+  DRAG_MODIFIERS,
+  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,
+  MODIFIERS,
   MOTION_TICK_MS,
+  MULTI_CLICK_GAP_MS,
+  NAV_TIMEOUT_MS,
+  NETWORKIDLE_HYDRATION_MS,
+  NOTICE_SRC,
+  NoticeLog,
   OUTPUT_MAX_BYTES,
+  OVERRUN_MIN_MS,
+  OVERRUN_MIN_PLANNED_MS,
+  OVERRUN_SHARE,
   PAGE_ERROR_LINE_CHARS,
+  PASTE_MAX_BYTES,
+  PASTE_READ_WINDOW_MS,
+  PASTE_TYPES,
+  PASTE_UNREAD_MS,
+  PATH_DEFAULT_MS,
+  PEER_VALUE_MAX,
+  PEER_VERBS,
   POINTER_MAX_MS,
   POINTER_MIN_MS,
   POINTER_MS_PER_PX,
@@ -2248,7 +4572,10 @@ export {
   PRESS_KEYS,
   PRESS_LEAD_MS,
   PageErrorLog,
+  PageSoundLog,
   QUIET_MS,
+  READY_MODES,
+  READY_SETTLE_CAP_MS,
   READ_BEAT_MS,
   RESPONSE_MS,
   RecordRefusedError,
@@ -2258,18 +4585,28 @@ export {
   SCROLL_SETTLE_MS,
   SETTLE_CAP_MS,
   SETTLE_MS,
+  SETTLE_VERBS,
   STEP_GUARDS,
+  STEP_MARGIN_MS,
   SetupEnvError,
   SetupError,
+  StepBound,
+  StepSignals,
   TRAILING_HOLD_MS,
   TakeClock,
+  WAIT_MARGIN_MS,
   WALL_PROBE,
   WallError,
+  ZOOM_MARK_VERBS,
+  appSettled,
   askedMs,
   base64Bytes,
+  bounded,
   buildEncodePage,
+  buttonNumber,
   capReached,
   cappedLine,
+  chordProblem,
   clampWait,
   clockMotion,
   clockTyping,
@@ -2283,48 +4620,89 @@ export {
   extForType,
   fetchInPageScript,
   fileNameProblem,
+  fitSurfaceToViewport,
   formatDurationCap,
   guardVerdict,
   guardedSteps,
+  hangReason,
   headersFor,
   holdLeftMs,
   hostedRefusals,
+  inlinePoints,
+  inlineScript,
   isIdpHost,
+  isKeyName,
   isSignInPath,
   jpegDims,
+  jsConditionScript,
+  keptValue,
+  keySequencePlanMs,
+  loadScriptFiles,
   maskInitScript,
+  modifierBits,
   nameFromUrl,
+  noticeAdvice,
+  noticeLine,
   outputName,
+  overrunLine,
+  overrunOf,
   paceLine,
   paceReport,
   pageErrorLine,
   parseHeaders,
+  pasteTypeOf,
+  pathDurationMs,
+  peerValue,
+  peersHostedRefusal,
   plainName,
   planFreshTake,
   pointerTravelMs,
   pollCondition,
+  pressSequence,
   publicUrl,
   readAllBytes,
   readCondition,
   readMediaSource,
+  readPath,
+  readyLine,
+  readyProblem,
   realSleep,
   recordTake,
   redirectedAway,
+  reloadUntilReady,
+  resolveChord,
+  resolveModifier,
   resolveSetupText,
+  runPeer,
   runSetup,
+  sameJson,
   sayCondition,
   sayDuration,
+  sayJs,
+  sayValue,
+  schedulePath,
+  scriptFiles,
   scrollByScript,
   scrollTravelMs,
   settleMs,
+  settleOn,
   settleVerdict,
   setupEnvNames,
+  soundSrcForMeta,
+  splitChord,
   splitSegmentsAtSkips,
+  stageClipboardScript,
+  stepBoundMs,
+  syntheticPasteScript,
   typeOfName,
+  untilReady,
   urlSchemeProblem,
   validateActions,
+  validatePeers,
   validateSetup,
   visibleTextScript,
-  wallVerdict
+  wallVerdict,
+  withFittingExport,
+  withPageSound
 };
 //# sourceMappingURL=index.js.map