@vosjs/render-core 0.6.0 → 0.8.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;
   }
@@ -149,6 +152,7 @@ function deadTime(steps, frames, events, durationMs) {
   let ms = 0;
   let longestMs = 0;
   for (const s of steps) {
+    if (s.do === "expect" || s.do === "await" || s.do === "download") continue;
     const t0 = s.tStart * 1e3;
     const t1 = s.tEnd * 1e3;
     if (!(t1 > t0)) continue;
@@ -371,16 +375,141 @@ 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
   // A selector that reaches THIS element and no other, so it can be pasted
   // into "mask" as it is: climb until the path is unique, and say which
-  // sibling wherever a tag-and-class alone would match several.
+  // sibling wherever a tag-and-class alone would match several. What the
+  // page wrote for people and tests comes first (an id, a test id, an
+  // aria-label, a field's name or placeholder); utility classes are a
+  // 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, '\\\\"') + '"'
+  // 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
     const tid = el.getAttribute('data-testid')
-    if (tid) return el.tagName.toLowerCase() + '[data-testid="' + tid + '"]'
-    if (el.id && /^[A-Za-z_][\\w-]*$/.test(el.id)) return el.tagName.toLowerCase() + '#' + el.id
+    if (quiet(tid)) return tag + '[data-testid=' + attr(tid) + ']'
+    const label = el.getAttribute('aria-label')
+    if (quiet(label)) return tag + '[aria-label=' + attr(label) + ']'
+    if (/^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName)) {
+      const nm = el.getAttribute('name')
+      if (quiet(nm)) return tag + '[name=' + attr(nm) + ']'
+      const ph = el.getAttribute('placeholder')
+      if (quiet(ph)) return tag + '[placeholder=' + attr(ph) + ']'
+    }
     const cls = [...el.classList].filter((c) => /^[A-Za-z_-][\\w-]*$/.test(c)).slice(0, 2)
     let seg = el.tagName.toLowerCase() + (cls.length ? '.' + cls.join('.') : '')
     const p = el.parentElement
@@ -409,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)
@@ -435,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) => ({
@@ -520,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"]);
@@ -604,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":
@@ -673,173 +843,1800 @@ function parseHeaders(given) {
   return out;
 }
 
-// src/record/recorder.ts
-var READ_WAIT_MS = 1500;
-var READ_MAX_CHARS = 2048;
-function headersFor(requestUrl, entryUrl, headers) {
+// 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 {
-    return new URL(requestUrl).origin === new URL(entryUrl).origin ? headers : null;
+    const u = new URL(src);
+    return `${u.origin}${u.pathname}`;
   } catch {
-    return null;
+    return "";
   }
 }
-async function applyHeaders(context, headers, entryUrl, log) {
-  if (!context.route) {
-    await context.setExtraHTTPHeaders(headers);
-    log("   (this browser scopes no headers: they ride every request)");
-    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;
   }
-  await context.route("**/*", async (route) => {
-    const req = route.request();
-    const scoped = headersFor(req.url(), entryUrl, headers);
-    await route.continue(
-      scoped ? { headers: { ...req.headers(), ...scoped } } : void 0
-    );
+  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) {
+    this.t0 = t0;
+  }
+  t0;
+  pauses = [];
+  lastFrameMs = -1;
+  /** Footage ms at a wall-clock instant (`Date.now()` space). */
+  footageMs(wallMs) {
+    let off = 0;
+    for (const p of this.pauses) {
+      if (wallMs <= p.from) break;
+      off += Math.min(wallMs, p.to ?? Infinity) - p.from;
+    }
+    return wallMs - this.t0 - off;
+  }
+  /** The camera stops at this instant; returns the cut's footage ms. */
+  pause(wallMs) {
+    const at = this.footageMs(wallMs);
+    this.pauses.push({ from: wallMs, to: null });
+    return at;
+  }
+  /** The camera rolls again; returns the wall ms the stretch lasted. */
+  resume(wallMs) {
+    const open = this.pauses[this.pauses.length - 1];
+    if (!open || open.to !== null) return 0;
+    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).
+   */
+  placeFrame(captureWallMs) {
+    const t = Math.max(0, Math.round(this.footageMs(captureWallMs)));
+    if (t <= this.lastFrameMs) return null;
+    this.lastFrameMs = t;
+    return t;
+  }
+};
+
+// src/record/pageErrors.ts
+var PAGE_ERROR_LINE_CHARS = 160;
+function pageErrorLine(text) {
+  const one = text.replace(/\s+/g, " ").trim();
+  return one.length > PAGE_ERROR_LINE_CHARS ? `${one.slice(0, PAGE_ERROR_LINE_CHARS - 1)}\u2026` : one;
+}
+var PageErrorLog = class {
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  verbose;
+  seen = /* @__PURE__ */ new Map();
+  /** The line to log for this error now, or null when it repeats one already said. */
+  add(text) {
+    const known = this.seen.get(text);
+    if (known) {
+      known.count++;
+      return this.verbose ? `   [page error] ${text}` : null;
+    }
+    this.seen.set(text, { text, count: 1 });
+    return `   [page error] ${this.verbose ? text : pageErrorLine(text)}`;
+  }
+  /** Every distinct error with how often it came, in the order first seen. */
+  entries() {
+    return [...this.seen.values()].map((e) => ({ ...e }));
+  }
+  /** The closing lines: each error that repeated, with its count. */
+  repeats() {
+    if (this.verbose) return [];
+    return [...this.seen.values()].filter((e) => e.count > 1).map((e) => `   [page error \xD7${e.count}] ${pageErrorLine(e.text)}`);
+  }
+};
+
+// 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) };
 }
-function publicUrl(u) {
+async function fitSurfaceToViewport(cdp, width, height) {
   try {
-    const x = new URL(u);
-    return `${x.origin}${x.pathname}`;
+    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 "";
+    return null;
   }
 }
-var DRY_PAUSE_MS = 120;
-function scrollByScript(x, y, dy) {
-  return `(() => {
-  let el = document.elementFromPoint(${Math.round(x)}, ${Math.round(y)});
-  while (el && el !== document.body && el !== document.documentElement) {
-    const cs = getComputedStyle(el);
-    if (/(auto|scroll)/.test(cs.overflowY) && el.scrollHeight > el.clientHeight + 1) {
-      el.scrollBy(0, ${dy});
-      return 'el';
+
+// 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 };
     }
-    el = el.parentElement;
+  } catch {
   }
-  window.scrollBy(0, ${dy});
-  return 'window';
-})()`;
+  return { holds: false };
 }
-function jpegDims(buf) {
-  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-  let i = 2;
-  while (i < buf.length - 9) {
-    if (buf[i] !== 255) return null;
-    const marker = buf[i + 1];
-    const len = view.getUint16(i + 2);
-    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
-      return { h: view.getUint16(i + 5), w: view.getUint16(i + 7) };
+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);
     }
-    i += 2 + len;
+    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));
   }
-  return null;
 }
-function base64Bytes(data) {
-  const bin = atob(data);
-  const out = new Uint8Array(bin.length);
-  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
-  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 });
+  }
+  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();
+    }
+  }
 }
-async function recordTake(browser, url, actions, sink, log, opts = {}) {
-  const dry = opts.dryRun === true;
-  const sleep = dry ? (ms) => realSleep(Math.min(ms, DRY_PAUSE_MS)) : realSleep;
-  const maxSeconds = dry ? Infinity : opts.maxDurationSeconds ?? Infinity;
-  const vw = actions.viewport?.width ?? 1280;
-  const vh = actions.viewport?.height ?? 720;
-  const context = opts.context ?? await browser.newContext({
-    viewport: { width: vw, height: vh },
-    deviceScaleFactor: 1,
-    ...opts.storageState ? { storageState: opts.storageState } : {}
+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.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.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/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
   });
-  if (opts.headers && Object.keys(opts.headers).length)
-    await applyHeaders(context, opts.headers, url, log);
-  const masks = actions.mask ?? [];
-  if (masks.length) await context.addInitScript(maskInitScript(masks));
-  const exposureLog = new ExposureLog(masks);
-  const page = await context.newPage();
-  const scanExposures = async (step) => {
-    const scan = await page.evaluate(EXPOSURE_PROBE).catch(() => null);
-    exposureLog.add(step, scan);
+  return {
+    response,
+    ready: { mode, ms: Math.round(now() - start), capped: !settled.settled }
   };
-  page.on("console", (m) => {
-    if (m.type() === "error") log(`   [page error] ${m.text()}`);
-  });
-  log(`goto ${url}`);
-  let navTimeout = false;
-  let response = await page.goto(url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => {
-    navTimeout = true;
-    log("   (networkidle timeout \u2014 continuing)");
+}
+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;
-  });
-  await sleep(800);
-  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 ?? {}
-    });
-    for (const line of result.lines) log(`   ${line}`);
-    if (result.failed) {
-      await context.close().catch(() => {
-      });
-      throw new SetupError(result.failed);
-    }
-    log(`goto ${url} (after setup)`);
-    response = await page.goto(url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => null);
-    await sleep(800);
   }
-  let wall = null;
-  if (opts.onArrival) {
-    const seen = await page.evaluate(WALL_PROBE).catch(() => null);
-    try {
-      wall = await opts.onArrival({
-        askedUrl: url,
-        landedUrl: page.url(),
-        ...response ? { status: response.status() } : {},
-        passwordFields: seen?.passwordFields ?? 0,
-        newPasswordField: seen?.newPasswordField ?? false,
-        oneTimeCodeField: seen?.oneTimeCodeField ?? false
-      }) ?? null;
-    } catch (e) {
-      await context.close().catch(() => {
-      });
-      throw e;
-    }
+  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;
   }
-  await scanExposures(-1);
-  const cdp = await context.newCDPSession(page);
-  const frames = [];
-  let frameIdx = 0;
-  let t0 = 0;
-  const first = { dims: null };
-  let sinkChain = Promise.resolve();
-  if (!dry)
-    cdp.on("Page.screencastFrame", (ev) => {
+  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/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",
+  "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;
+  }
+  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(", ")}, 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.guard !== void 0) {
+      if (!STEP_GUARDS.includes(s.guard))
+        errors.push(
+          `${at}: guard must be ${STEP_GUARDS.map((g) => `"${g}"`).join(" or ")}`
+        );
+      else if (!GUARDABLE.has(s.do))
+        errors.push(
+          `${at}: guard sits on a click, a press or a type, the steps that commit something; a ${s.do} spends nothing`
+        );
+      else if (typeof s.id !== "string" || !s.id.trim())
+        errors.push(
+          `${at}: a guarded step needs an id, which is what --confirm <id> names`
+        );
+    }
+    if (s.do === "expect") {
+      const given = ["selector", "text", "gone"].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 ")})` : ""}`
+        );
+      for (const k of given)
+        if (!isFilled(s[k]))
+          errors.push(`${at}: expect ${k} must be a non-empty string`);
+      if (s.enabled !== void 0) {
+        if (typeof s.enabled !== "boolean")
+          errors.push(`${at}: expect enabled must be true or false`);
+        else if (s.selector === void 0)
+          errors.push(
+            `${at}: expect enabled is about the selector's element, so it needs a selector`
+          );
+      }
+      errors.push(...secondsProblem(at, "expect timeout", s.timeout));
+    }
+    if (s.do === "await") {
+      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" }`
+        );
+      } else {
+        const until = u;
+        const keys = Object.keys(until);
+        const known = keys.filter(
+          (k) => k === "selector" || k === "text" || k === "gone"
+        );
+        const unknown = keys.filter((k) => !known.includes(k));
+        if (unknown.length)
+          errors.push(
+            `${at}: await until takes selector, text or gone, 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 ")})` : ""}`
+          );
+        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(...secondsProblem(at, "await timeout", s.timeout));
+      errors.push(...secondsProblem(at, "await poll", s.poll));
+      if (s.reload !== void 0 && typeof s.reload !== "boolean")
+        errors.push(`${at}: await reload must be true or false`);
+      if (s.onTimeout !== void 0 && s.onTimeout !== "fail" && s.onTimeout !== "continue")
+        errors.push(`${at}: await onTimeout must be "fail" or "continue"`);
+    }
+    if (s.do === "download") {
+      const given = ["selector", "src"].filter(
+        (k) => s[k] !== void 0
+      );
+      if (given.length !== 1)
+        errors.push(
+          `${at}: download needs exactly one of selector (a control that downloads) or src (a video, audio or img element whose source is fetched)`
+        );
+      for (const k of given)
+        if (!isFilled(s[k]))
+          errors.push(`${at}: download ${k} must be a non-empty string`);
+      if (s.as !== void 0) {
+        const problem = typeof s.as === "string" ? fileNameProblem(s.as) : "is not a string";
+        if (problem) errors.push(`${at}: download as ${problem}`);
+      }
+    }
+    if (s.do === "drag") {
+      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 [];
+}
+var isFilled = (v) => typeof v === "string" && v.trim().length > 0;
+function secondsProblem(at, what, v) {
+  if (v === void 0) return [];
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0)
+    return [`${at}: ${what} must be a number of seconds above 0`];
+  return [];
+}
+function fileNameProblem(name) {
+  if (!name.trim()) return "must be a file name";
+  if (/[/\\]/.test(name))
+    return `"${name}" must be a plain file name, with no path separator`;
+  if (name.includes(".."))
+    return `"${name}" must be a plain file name, with no ".."`;
+  if (name.startsWith(".")) return `"${name}" must not be a hidden file`;
+  if (/[\u0000-\u001f\u007f]/.test(name))
+    return `"${name}" must not hold control characters`;
+  if (name.length > 200) return "must be at most 200 characters";
+  return null;
+}
+function guardedSteps(actions) {
+  const out = [];
+  actions.steps.forEach((s, i) => {
+    if (s.guard)
+      out.push({ step: i, id: s.id ?? String(i), do: s.do, guard: s.guard });
+  });
+  return out;
+}
+function guardVerdict(actions, confirm) {
+  const guarded = guardedSteps(actions);
+  const unconfirmed = guarded.filter((g) => !confirm.includes(g.id));
+  const unknown = confirm.filter((c) => !guarded.some((g) => g.id === c));
+  if (!unconfirmed.length && !unknown.length) return { ok: true };
+  const parts = [];
+  if (unconfirmed.length) {
+    const one = unconfirmed.length === 1;
+    parts.push(
+      `${unconfirmed.map((g) => `#${g.step} ${g.id} (${g.do})`).join(", ")} ${one ? "is" : "are"} guarded (${unconfirmed[0].guard}): ${one ? "it spends" : "they spend"} something real, so the recorder presses ${one ? "it" : "them"} only when the command says so. Add ${unconfirmed.map((g) => `--confirm ${g.id}`).join(" ")} to record ${one ? "it" : "them"}, or rehearse with --dry-run, which hovers and never presses`
+    );
+  }
+  if (unknown.length)
+    parts.push(
+      `${unknown.map((c) => `--confirm ${c}`).join(", ")} names no guarded step${guarded.length ? ` (the guarded ones: ${guarded.map((g) => g.id).join(", ")})` : ""}`
+    );
+  return {
+    ok: false,
+    unconfirmed: unconfirmed.map((g) => g.id),
+    unknown,
+    message: `${parts.join(". ")}. Nothing was recorded.`
+  };
+}
+function hostedRefusals(actions) {
+  const out = [];
+  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}`
+    );
+  actions.steps.forEach((s, i) => {
+    if (s.do === "download")
+      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/`
+      );
+    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 === "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;
+}
+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;
+}
+
+// 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.`
+    };
+  }
+  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 from vos.so carries its paths and its words, never a pasted file). Nothing was recorded.` : `${at} names "${f.name}", which could not be read beside the actions file (${why}). Nothing was recorded.`
+      };
+    }
+    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 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 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) };
+    })
+  };
+}
+
+// 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
+var OUTPUT_MAX_BYTES = 512 * 1024 * 1024;
+function plainName(suggested, fallback) {
+  const last = suggested.split(/[/\\]/).pop() ?? "";
+  const clean = last.replace(/[\u0000-\u001f\u007f]/g, "").replace(/\.\.+/g, ".").replace(/^\.+/, "").trim().slice(0, 200);
+  return clean && !fileNameProblem(clean) ? clean : fallback;
+}
+function nameFromUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.protocol === "blob:" || u.protocol === "data:") return "";
+    const seg = u.pathname.split("/").filter(Boolean).pop() ?? "";
+    return decodeURIComponent(seg);
+  } catch {
+    return "";
+  }
+}
+function outputName(asked, suggested, fallback, used) {
+  const base = asked ?? plainName(suggested, fallback);
+  if (!used.has(base)) return base;
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  const ext = dot > 0 ? base.slice(dot) : "";
+  for (let n = 2; ; n++) {
+    const next = `${stem}-${n}${ext}`;
+    if (!used.has(next)) return next;
+  }
+}
+function chunkBytes(c) {
+  if (c instanceof Uint8Array) return c;
+  if (typeof c === "string") return new TextEncoder().encode(c);
+  if (c instanceof ArrayBuffer) return new Uint8Array(c);
+  throw new Error("the download stream gave something that is not bytes");
+}
+async function readAllBytes(stream, max = OUTPUT_MAX_BYTES) {
+  const parts = [];
+  let n = 0;
+  for await (const c of stream) {
+    const u = chunkBytes(c);
+    n += u.length;
+    if (n > max)
+      throw new Error(
+        `the file is larger than ${Math.round(max / 1024 / 1024)} MB`
+      );
+    parts.push(u);
+  }
+  const out = new Uint8Array(n);
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+var readMediaSource = (el) => el.currentSrc || el.src || el.getAttribute("src") || "";
+function fetchInPageScript(url) {
+  return `(async () => {
+  try {
+    const res = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+    if (!res.ok) return { error: 'answered ' + res.status };
+    const buf = new Uint8Array(await res.arrayBuffer());
+    let bin = '';
+    for (let i = 0; i < buf.length; i += 0x8000) bin += String.fromCharCode.apply(null, buf.subarray(i, i + 0x8000));
+    return { b64: btoa(bin), type: res.headers.get('content-type') || '' };
+  } catch (e) {
+    return { error: String((e && e.message) || e) };
+  }
+})()`;
+}
+
+// src/record/recorder.ts
+var EXPECT_EVERY_MS = 100;
+var SRC_WAIT_MS = 8e3;
+var AWAIT_HEARTBEAT_MS = 3e4;
+var MIN_SKIP_MS = 250;
+var READ_WAIT_MS = 1500;
+var READ_MAX_CHARS = 2048;
+function headersFor(requestUrl, entryUrl, headers) {
+  try {
+    return new URL(requestUrl).origin === new URL(entryUrl).origin ? headers : null;
+  } catch {
+    return null;
+  }
+}
+async function applyHeaders(context, headers, entryUrl, log) {
+  if (!context.route) {
+    await context.setExtraHTTPHeaders(headers);
+    log("   (this browser scopes no headers: they ride every request)");
+    return;
+  }
+  await context.route("**/*", async (route) => {
+    const req = route.request();
+    const scoped = headersFor(req.url(), entryUrl, headers);
+    await route.continue(
+      scoped ? { headers: { ...req.headers(), ...scoped } } : void 0
+    );
+  });
+}
+function publicUrl(u) {
+  try {
+    const x = new URL(u);
+    return `${x.origin}${x.pathname}`;
+  } catch {
+    return "";
+  }
+}
+var RecordRefusedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RecordRefusedError";
+  }
+};
+var DRY_PAUSE_MS = 120;
+function scrollByScript(x, y, dy) {
+  return `(() => {
+  let el = document.elementFromPoint(${Math.round(x)}, ${Math.round(y)});
+  while (el && el !== document.body && el !== document.documentElement) {
+    const cs = getComputedStyle(el);
+    if (/(auto|scroll)/.test(cs.overflowY) && el.scrollHeight > el.clientHeight + 1) {
+      el.scrollBy(0, ${dy});
+      return 'el';
+    }
+    el = el.parentElement;
+  }
+  window.scrollBy(0, ${dy});
+  return 'window';
+})()`;
+}
+function jpegDims(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let i = 2;
+  while (i < buf.length - 9) {
+    if (buf[i] !== 255) return null;
+    const marker = buf[i + 1];
+    const len = view.getUint16(i + 2);
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+      return { h: view.getUint16(i + 5), w: view.getUint16(i + 7) };
+    }
+    i += 2 + len;
+  }
+  return null;
+}
+function base64Bytes(data) {
+  const bin = atob(data);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+async function recordTake(browser, url, actions, sink, log, opts = {}) {
+  const dry = opts.dryRun === true;
+  const sleep = dry ? (ms) => realSleep(Math.min(ms, DRY_PAUSE_MS)) : realSleep;
+  const maxSeconds = dry ? Infinity : opts.maxDurationSeconds ?? Infinity;
+  if (!dry) {
+    const guard = guardVerdict(actions, opts.confirm ?? []);
+    if (!guard.ok) throw new RecordRefusedError(guard.message);
+    const download = actions.steps.findIndex((s) => s.do === "download");
+    if (download >= 0 && !opts.outputs)
+      throw new RecordRefusedError(
+        `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 vw = actions.viewport?.width ?? 1280;
+  const vh = actions.viewport?.height ?? 720;
+  const context = opts.context ?? await browser.newContext({
+    viewport: { width: vw, height: vh },
+    deviceScaleFactor: 1,
+    ...opts.storageState ? { storageState: opts.storageState } : {}
+  });
+  if (opts.headers && Object.keys(opts.headers).length)
+    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 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) => {
+    if (m.type() !== "error") return;
+    const line = pageErrors.add(m.text());
+    if (line) log(line);
+  });
+  const readyMode = actions.ready ?? DEFAULT_READY;
+  const open = (target) => untilReady(page, readyMode, (o) => page.goto(target, o), {
+    sleep: realSleep
+  });
+  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 ?? {},
+      goto: (target) => open(target)
+    });
+    for (const line of result.lines) log(`   ${line}`);
+    if (result.failed) {
+      await context.close().catch(() => {
+      });
+      throw new SetupError(result.failed);
+    }
+    log(`goto ${url} (after setup)`);
+    response = (await open(url)).response;
+  }
+  let wall = null;
+  if (opts.onArrival) {
+    const seen = await page.evaluate(WALL_PROBE).catch(() => null);
+    try {
+      wall = await opts.onArrival({
+        askedUrl: url,
+        landedUrl: page.url(),
+        ...response ? { status: response.status() } : {},
+        passwordFields: seen?.passwordFields ?? 0,
+        newPasswordField: seen?.newPasswordField ?? false,
+        oneTimeCodeField: seen?.oneTimeCodeField ?? false
+      }) ?? null;
+    } catch (e) {
+      await context.close().catch(() => {
+      });
+      throw e;
+    }
+  }
+  await scanExposures(-1);
+  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 cdp = await context.newCDPSession(rawPage);
+  if (!dry) await fitSurfaceToViewport(cdp, vw, vh);
+  const frames = [];
+  let frameIdx = 0;
+  let t0 = 0;
+  let takeClock = new TakeClock(0);
+  const first = { dims: null };
+  let sinkChain = Promise.resolve();
+  if (!dry)
+    cdp.on("Page.screencastFrame", (ev) => {
+      cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
+      });
       const tsMs = ev.metadata.timestamp ? ev.metadata.timestamp * 1e3 : Date.now();
+      const tMs = takeClock.placeFrame(tsMs);
+      if (tMs === null) return;
       const file = `frame-${String(frameIdx++).padStart(5, "0")}.jpg`;
       const bytes = base64Bytes(ev.data);
       if (!first.dims) first.dims = jpegDims(bytes);
-      frames.push({ file, tMs: Math.max(0, Math.round(tsMs - t0)) });
+      frames.push({ file, tMs });
       sinkChain = sinkChain.then(() => sink.frame(file, bytes)).catch(() => {
       });
-      cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
-      });
     });
+  const screencast = {
+    format: "jpeg",
+    quality: 90,
+    maxWidth: vw,
+    maxHeight: vh,
+    everyNthFrame: 1
+  };
   t0 = Date.now();
-  if (!dry)
-    await cdp.send("Page.startScreencast", {
-      format: "jpeg",
-      quality: 90,
-      maxWidth: vw,
-      maxHeight: vh,
-      everyNthFrame: 1
-    });
+  takeClock = new TakeClock(t0);
+  if (!dry) await cdp.send("Page.startScreencast", screencast);
   const events = [];
   const cur = { x: 48, y: 48 };
-  const now = () => Date.now() - t0;
+  const now = () => takeClock.footageMs(Date.now());
+  const offCamera = async (fn) => {
+    const at = takeClock.pause(Date.now());
+    if (!dry) await cdp.send("Page.stopScreencast").catch(() => {
+    });
+    const out = await fn();
+    const ms = takeClock.resume(Date.now());
+    if (!dry) await cdp.send("Page.startScreencast", screencast).catch(() => {
+    });
+    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 };
@@ -886,27 +2683,103 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       return null;
     }
   };
-  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 srcOf = async (selector) => {
+    const deadline = Date.now() + SRC_WAIT_MS;
+    const loc = page.locator(selector).first();
+    try {
+      await loc.waitFor({ state: "attached", timeout: SRC_WAIT_MS });
+    } catch {
+      return null;
+    }
+    for (; ; ) {
+      const v = await loc.evaluate(readMediaSource).catch(() => "");
+      if (v || Date.now() >= deadline) return v;
+      await realSleep(200);
+    }
+  };
+  const fetchSource = async (src) => {
+    const abs = new URL(src, page.url()).href;
+    const suggested = nameFromUrl(abs);
+    if (page.request && /^https?:/i.test(abs)) {
+      const res = await page.request.get(abs, {
+        timeout: DOWNLOAD_TIMEOUT_S * 1e3
+      });
+      if (!res.ok())
+        throw new Error(
+          `fetching ${publicUrl(abs) || "the source"} answered ${res.status()}`
+        );
+      const bytes = await res.body();
+      if (bytes.length > OUTPUT_MAX_BYTES)
+        throw new Error(
+          `the file is larger than ${OUTPUT_MAX_BYTES / 1024 / 1024} MB`
+        );
+      const type2 = res.headers()["content-type"]?.split(";")[0].trim();
+      return { bytes, suggested, ...type2 ? { contentType: type2 } : {} };
+    }
+    const r = await page.evaluate(fetchInPageScript(abs));
+    if (!r || r.error || r.b64 === void 0)
+      throw new Error(
+        `fetching the source in the page failed: ${r?.error ?? "no answer"}`
+      );
+    const type = r.type?.split(";")[0].trim();
+    return {
+      bytes: base64Bytes(r.b64),
+      suggested,
+      ...type ? { contentType: type } : {}
+    };
   };
+  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();
@@ -923,6 +2796,14 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const skipped = [];
   const stepSpans = [];
   const paces = [];
+  const disabled = [];
+  const confirmed = [];
+  const skips = [];
+  const outputs = [];
+  const outputNames = /* @__PURE__ */ new Set();
+  const overruns = [];
+  let stopped = null;
+  let unpressedGuard = null;
   let capped = false;
   for (const [stepIdx, step] of actions.steps.entries()) {
     if (capReached(now(), maxSeconds)) {
@@ -937,17 +2818,90 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       gestureMs += now() - t;
       return out;
     };
-    const skippedBefore = skipped.length;
-    const urlBefore = page.url();
-    let stepRect = null;
+    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 = {};
+    const tag = `#${stepIdx}${step.id ? ` ${step.id}` : ""}`;
+    const skip = (selector, reason) => {
+      skipped.push({
+        step: stepIdx,
+        ...step.id ? { id: step.id } : {},
+        do: step.do,
+        selector,
+        ...reason ? { reason } : {}
+      });
+      if (reason) extra.reason = reason;
+    };
+    if (step.guard) extra.guard = step.guard;
+    const rehearseGuard = async (sel, point) => {
+      if (!step.guard || !dry) return false;
+      const rect = sel ? await boxOf(sel) : null;
+      stepRect = rect;
+      if (sel && !rect) skip(sel);
+      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 || point ? "hovered" : "left alone"}, not pressed`
+        );
+      }
+      unpressedGuard = stepIdx;
+      return true;
+    };
+    const notWaited = () => {
+      if (!dry || unpressedGuard === null) return false;
+      extra.followsGuard = unpressedGuard;
+      log(
+        `${tag} ${step.do}: not waited: it follows #${unpressedGuard} (guarded, not pressed)`
+      );
+      return true;
+    };
+    const boundMs = stepBoundMs(
+      step,
+      askedMs(step),
+      {
+        expectS: EXPECT_TIMEOUT_S,
+        awaitS: AWAIT_TIMEOUT_S,
+        downloadS: DOWNLOAD_TIMEOUT_S
+      }
+    );
+    opts.onEvent?.({
+      event: "step",
+      phase: "start",
+      i: stepIdx,
+      ...step.id ? { id: step.id } : {},
+      do: step.do
+    });
+    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) {
@@ -959,11 +2913,38 @@ 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;
         if (rect) {
-          await gesture(() => clickAt(rect));
-          log(`click ${step.selector}`);
+          const enabled = await page.locator(step.selector).first().isEnabled({ timeout: 1e3 }).catch(() => true);
+          if (!enabled) {
+            disabled.push({
+              step: stepIdx,
+              ...step.id ? { id: step.id } : {},
+              selector: step.selector
+            });
+            log(
+              `   (${tag} click: ${step.selector} is disabled; pressed anyway)`
+            );
+          }
+          await gesture(() => clickAt(rect, how));
+          log(`${said} ${step.selector}`);
           const sinceChange = await gesture(() => waitSettled());
           await sleep(holdLeftMs(settleMs(step), sinceChange));
         } else
@@ -971,6 +2952,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "type": {
+        if (await rehearseGuard(step.selector)) break;
         const rect = await boxOf(step.selector);
         stepRect = rect;
         if (rect) {
@@ -986,17 +2968,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}`);
@@ -1006,6 +2992,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "press": {
+        if (await rehearseGuard(step.selector)) break;
         let rect = null;
         if (step.selector) {
           rect = await boxOf(step.selector);
@@ -1019,14 +3006,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;
@@ -1057,9 +3048,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) {
@@ -1077,46 +3078,351 @@ 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 res = await pollCondition(page, cond, {
+          timeoutMs,
+          everyMs: EXPECT_EVERY_MS,
+          sleep: realSleep
+        });
+        if (res.ok) log(`expect ${sayCondition(cond)}: holds`);
+        else {
+          const reason = conditionMiss(cond, res.last, timeoutMs);
+          skip(step.selector ?? step.gone ?? step.text ?? "", reason);
+          log(`   (${tag} expect: ${reason})`);
+        }
+        break;
+      }
+      case "await": {
+        if (notWaited()) break;
+        const cond = step.until;
+        const timeoutMs = (step.timeout ?? AWAIT_TIMEOUT_S) * 1e3;
+        const reload = step.reload ? () => reloadUntilReady(page, readyMode, timeoutMs) : void 0;
+        log(`await ${sayCondition(cond)} (off camera)\u2026`);
+        const awaitEvent = {
+          event: "await",
+          step: stepIdx,
+          ...step.id ? { id: step.id } : {}
+        };
+        opts.onEvent?.({ ...awaitEvent, phase: "start" });
+        const beatMs = opts.awaitHeartbeatMs ?? AWAIT_HEARTBEAT_MS;
+        const waitFrom = Date.now();
+        const beat = setInterval(() => {
+          const elapsedMs = Date.now() - waitFrom;
+          opts.onEvent?.({ ...awaitEvent, phase: "wait", elapsedMs });
+          log(`   still waiting, ${sayDuration(elapsedMs)} so far`);
+        }, beatMs);
+        let waited;
+        try {
+          waited = await offCamera(
+            () => pollCondition(page, cond, {
+              timeoutMs,
+              everyMs: (step.poll ?? AWAIT_POLL_S) * 1e3,
+              sleep: realSleep,
+              between: reload,
+              // After a reload the condition must hold on two reads in a
+              // row, or a half-built page ends the wait early.
+              ...reload ? { confirm: { reads: 2, gapMs: 500 } } : {}
+            })
+          );
+        } finally {
+          clearInterval(beat);
+        }
+        const { out, at, ms } = waited;
+        opts.onEvent?.({ ...awaitEvent, phase: "end", ms, held: out.ok });
+        extra.offCameraMs = ms;
+        if (!out.ok) extra.timedOut = true;
+        if (!dry && (ms >= MIN_SKIP_MS || !out.ok))
+          skips.push({
+            step: stepIdx,
+            ...step.id ? { id: step.id } : {},
+            at: +(at / 1e3).toFixed(3),
+            ms,
+            ...out.ok ? {} : { timedOut: true }
+          });
+        if (out.ok) log(`   held after ${sayDuration(ms)} off camera`);
+        else if ((step.onTimeout ?? "fail") === "continue")
+          log(
+            `   (${tag} await: ${conditionMiss(cond, out.last, ms)}; going on, as onTimeout says)`
+          );
+        else {
+          stopped = {
+            step: stepIdx,
+            ...step.id ? { id: step.id } : {},
+            reason: `${tag} await: ${conditionMiss(cond, out.last, ms)}, so the take stopped there. Raise its timeout, or set onTimeout: "continue" to go on without it`
+          };
+          extra.reason = stopped.reason;
+          log(`   ${stopped.reason}`);
+        }
+        break;
+      }
+      case "download": {
+        let got = null;
+        let reason = null;
+        const target = step.selector ?? step.src ?? "";
+        try {
+          if (step.selector !== void 0) {
+            const rect = await boxOf(step.selector);
+            stepRect = rect;
+            if (!rect) {
+              skip(step.selector);
+              break;
+            }
+            if (!page.waitForEvent) {
+              reason = "this browser reports no downloads";
+            } else {
+              const waitMs = DOWNLOAD_TIMEOUT_S * 1e3;
+              const arriving = page.waitForEvent("download", { timeout: waitMs }).catch(() => null);
+              await gesture(() => clickAt(rect));
+              log(`click ${step.selector} (download)`);
+              const dl = await arriving;
+              if (!dl)
+                reason = `no download arrived within ${sayDuration(waitMs)} of the click on '${step.selector}'`;
+              else {
+                const stream = await dl.createReadStream();
+                if (!stream) reason = "the download failed in the browser";
+                else
+                  got = {
+                    bytes: await readAllBytes(stream),
+                    suggested: dl.suggestedFilename(),
+                    // A browser download carries no headers here: the type is
+                    // read from the name the page gave it.
+                    ...typeOfName(dl.suggestedFilename())
+                  };
+              }
+            }
+          } else if (step.src !== void 0) {
+            const src = await srcOf(step.src);
+            if (src === null) reason = `no element matches '${step.src}'`;
+            else if (!src) reason = `'${step.src}' has no source to fetch`;
+            else got = await fetchSource(src);
+          }
+        } catch (e) {
+          reason = e instanceof Error ? e.message : String(e);
+        }
+        if (got) {
+          const name = outputName(
+            step.as,
+            got.suggested,
+            `download-${stepIdx}${extForType(got.contentType)}`,
+            outputNames
+          );
+          outputNames.add(name);
+          if (!dry) await opts.outputs?.save(name, got.bytes, got.contentType);
+          outputs.push({
+            step: stepIdx,
+            ...step.id ? { id: step.id } : {},
+            name,
+            bytes: got.bytes.length,
+            ...got.contentType ? { contentType: got.contentType } : {}
+          });
+          log(
+            `download \u2192 outputs/${name} (${got.bytes.length} bytes)${dry ? ", not kept in a rehearsal" : ""}`
+          );
+        } else {
+          const why = reason ?? "nothing came";
+          skip(target, why);
+          log(`   (${tag} download: ${why})`);
+        }
         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;
+    }
     const stepInfo = step;
+    const about = stepInfo.selector ?? stepInfo.until?.selector ?? stepInfo.until?.gone ?? stepInfo.gone ?? stepInfo.src;
     const urlAfter = publicUrl(page.url());
     const text = stepInfo.read ? await readText(page, stepInfo.read) : null;
     if (stepInfo.read && text === null)
@@ -1125,7 +3431,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       step: stepIdx,
       ...stepInfo.id ? { id: stepInfo.id } : {},
       do: step.do,
-      ...stepInfo.selector ? { selector: stepInfo.selector } : {},
+      ...about ? { selector: about } : {},
       tStart: +(stepStart / 1e3).toFixed(3),
       tEnd: +(now() / 1e3).toFixed(3),
       ...skipped.length > skippedBefore ? { skipped: true } : {},
@@ -1139,28 +3445,58 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
           w: +stepRect.w.toFixed(1),
           h: +stepRect.h.toFixed(1)
         }
-      } : {}
+      } : {},
+      ...extra
     });
     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];
+    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;
   }
-  if (!capped) await sleep(TRAILING_HOLD_MS);
+  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(() => "");
-  await context.close();
+  const pageTitle = await page.title().catch(() => "") ?? "";
+  for (const line of pageErrors.repeats()) log(line);
+  pageBound.end();
+  pageBound.start(CLOSE_BOUND_MS);
+  await pageBound.race(context.close().catch(() => {
+  }));
+  pageBound.end();
   await sinkChain;
   const meta = {
     dpr: 1,
@@ -1183,7 +3519,11 @@ 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() } : {},
-    ...masks.length ? { masks: exposureLog.masks(masks) } : {}
+    ...noticeLog.notices().length ? { notices: noticeLog.notices() } : {},
+    ...masks.length ? { masks: exposureLog.masks(masks) } : {},
+    ...skips.length ? { skips } : {},
+    ...outputs.length ? { outputs } : {},
+    ...media.length ? { media } : {}
   };
   const freezes = [];
   for (let i = 1; i < frames.length; i++) {
@@ -1199,9 +3539,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,
@@ -1209,155 +3551,90 @@ 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,
     dead,
     capped,
-    actions: { ...actions, url }
+    disabled,
+    confirmed,
+    skips,
+    outputs,
+    media,
+    stopped,
+    pageErrors: pageErrors.entries(),
+    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 }
   };
 }
-
-// src/record/actions.ts
-var VERBS2 = /* @__PURE__ */ new Set([
-  "wait",
-  "hover",
-  "click",
-  "type",
-  "press",
-  "scroll",
-  "move",
-  "drag"
-]);
-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));
-  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"`);
+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})`);
     }
   }
-  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
-    errors.push("steps must be a non-empty array");
-    return errors;
-  }
-  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);
-      }
-    }
-    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))
-        errors.push(
-          `${at}: press needs a key, one of ${PRESS_KEYS.join(", ")}; 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 === "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.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`
-        );
-    }
-  });
-  return errors;
+  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",
+  "video/quicktime": ".mov",
+  "audio/mpeg": ".mp3",
+  "audio/mp4": ".m4a",
+  "audio/wav": ".wav",
+  "audio/ogg": ".ogg",
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "image/svg+xml": ".svg",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "text/csv": ".csv",
+  "application/zip": ".zip"
+};
+function extForType(type) {
+  return (type && EXT_FOR_TYPE[type.split(";")[0].trim().toLowerCase()]) ?? "";
+}
+function typeOfName(name) {
+  const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+  if (!name.includes(".")) return {};
+  for (const [type, e] of Object.entries(EXT_FOR_TYPE))
+    if (e === ext) return { contentType: type };
+  return ext === ".jpeg" ? { contentType: "image/jpeg" } : {};
 }
 
 // src/record/encodePage.ts
@@ -1392,7 +3669,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)
@@ -1416,14 +3701,18 @@ 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 = {}) {
   const ingest = opts.backdrop ? { frame: withBackdrop(DEFAULT_FRAME_STYLE, opts.backdrop) } : {};
   const doc = projectFromArtifact(artifact, recordingName, ingest).doc;
+  doc.segments = splitSegmentsAtSkips(doc.segments, artifact.meta.skips);
   doc.zoom = planAutoZoom(doc.source.cursor, {
     width: doc.source.meta.width,
     height: doc.source.meta.height,
@@ -1436,75 +3725,272 @@ 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) {
+  if (!skips?.length) return segments;
+  const cuts = [...new Set(skips.map((s) => s.at))].sort((a, b) => a - b);
+  const out = [];
+  for (const seg of segments) {
+    const inside = seg.media ? [] : cuts.filter((at) => at > seg.in + 1e-3 && at < seg.out - 1e-3);
+    if (!inside.length) {
+      out.push(seg);
+      continue;
+    }
+    const { anim, hold, ...plain } = seg;
+    const edges = [seg.in, ...inside, seg.out];
+    for (let i = 0; i < edges.length - 1; i++) {
+      const first = i === 0;
+      const last = i === edges.length - 2;
+      const pieceAnim = anim && (first || last) ? {
+        ...first && anim.enter ? { enter: anim.enter } : {},
+        ...last && anim.exit ? { exit: anim.exit } : {}
+      } : null;
+      out.push({
+        ...plain,
+        in: edges[i],
+        out: edges[i + 1],
+        ...pieceAnim && Object.keys(pieceAnim).length ? { anim: pieceAnim } : {},
+        ...last && hold !== void 0 ? { hold } : {}
+      });
+    }
+  }
+  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,
+  DRAG_HOLD_MS,
+  DRAG_MODIFIERS,
+  EXPECT_TIMEOUT_S,
   EXPOSURE_ADVICE,
   EXPOSURE_MATCHERS_SRC,
   EXPOSURE_PROBE,
   ExposureLog,
+  IDLE_CALL_MS,
+  KEY_ROUNDTRIP_MS,
+  KEY_SEQUENCE_GAP_MS,
+  MAX_KEYS,
+  MAX_PATH_POINTS,
+  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,
   POINTER_MAX_MS,
   POINTER_MIN_MS,
   POINTER_MS_PER_PX,
   PRESS_HOLD_MS,
   PRESS_KEYS,
   PRESS_LEAD_MS,
+  PageErrorLog,
+  PageSoundLog,
   QUIET_MS,
+  READY_MODES,
+  READY_SETTLE_CAP_MS,
   READ_BEAT_MS,
   RESPONSE_MS,
+  RecordRefusedError,
   SCROLL_MAX_MS,
   SCROLL_MIN_MS,
   SCROLL_MS_PER_PX,
   SCROLL_SETTLE_MS,
   SETTLE_CAP_MS,
   SETTLE_MS,
+  SETTLE_VERBS,
+  STEP_GUARDS,
+  STEP_MARGIN_MS,
   SetupEnvError,
   SetupError,
+  StepBound,
   TRAILING_HOLD_MS,
+  TakeClock,
+  WAIT_MARGIN_MS,
   WALL_PROBE,
   WallError,
+  appSettled,
   askedMs,
   base64Bytes,
+  bounded,
   buildEncodePage,
+  buttonNumber,
   capReached,
   cappedLine,
+  chordProblem,
   clampWait,
   clockMotion,
   clockTyping,
+  conditionMiss,
   deadLine,
   deadTime,
   deadWarns,
+  domSettled,
   easeInOutCubic,
   exposureLine,
+  extForType,
+  fetchInPageScript,
+  fileNameProblem,
+  fitSurfaceToViewport,
   formatDurationCap,
+  guardVerdict,
+  guardedSteps,
+  hangReason,
   headersFor,
   holdLeftMs,
+  hostedRefusals,
+  inlinePoints,
+  inlineScript,
   isIdpHost,
+  isKeyName,
   isSignInPath,
   jpegDims,
+  keySequencePlanMs,
+  loadScriptFiles,
   maskInitScript,
+  modifierBits,
+  nameFromUrl,
+  noticeAdvice,
+  noticeLine,
+  outputName,
+  overrunLine,
+  overrunOf,
   paceLine,
   paceReport,
+  pageErrorLine,
   parseHeaders,
+  pasteTypeOf,
+  pathDurationMs,
+  plainName,
   planFreshTake,
   pointerTravelMs,
+  pollCondition,
+  pressSequence,
   publicUrl,
+  readAllBytes,
+  readCondition,
+  readMediaSource,
+  readPath,
+  readyLine,
+  readyProblem,
   realSleep,
   recordTake,
   redirectedAway,
+  reloadUntilReady,
+  resolveChord,
+  resolveModifier,
   resolveSetupText,
   runSetup,
+  sayCondition,
+  sayDuration,
+  schedulePath,
+  scriptFiles,
   scrollByScript,
   scrollTravelMs,
   settleMs,
+  settleOn,
   settleVerdict,
   setupEnvNames,
+  soundSrcForMeta,
+  splitChord,
+  splitSegmentsAtSkips,
+  stageClipboardScript,
+  stepBoundMs,
+  syntheticPasteScript,
+  typeOfName,
+  untilReady,
   urlSchemeProblem,
   validateActions,
   validateSetup,
-  wallVerdict
+  visibleTextScript,
+  wallVerdict,
+  withFittingExport,
+  withPageSound
 };
 //# sourceMappingURL=index.js.map