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