@vosjs/render-core 0.6.0 → 0.7.0

package/dist/record/index.js

@@ -149,6 +149,7 @@ function deadTime(steps, frames, events, durationMs) {
   let ms = 0;
   let longestMs = 0;
   for (const s of steps) {
+    if (s.do === "expect" || s.do === "await" || s.do === "download") continue;
     const t0 = s.tStart * 1e3;
     const t1 = s.tEnd * 1e3;
     if (!(t1 > t0)) continue;
@@ -376,11 +377,26 @@ var EXPOSURE_PROBE = `(() => {
   const vw = innerWidth, vh = innerHeight
   // A selector that reaches THIS element and no other, so it can be pasted
   // into "mask" as it is: climb until the path is unique, and say which
-  // sibling wherever a tag-and-class alone would match several.
+  // sibling wherever a tag-and-class alone would match several. What the
+  // page wrote for people and tests comes first (an id, a test id, an
+  // aria-label, a field's name or placeholder); utility classes are a
+  // layout's, and they come last. A value that itself holds what the scan
+  // looks for is never used: the selector would quote it.
+  const attr = (v) => '"' + v.replace(/\\\\/g, '\\\\\\\\').replace(/"/g, '\\\\"') + '"'
+  const quiet = (v) => !!v && v.length <= 80 && !kindsIn(v).length
   const segment = (el) => {
+    const tag = el.tagName.toLowerCase()
+    if (el.id && /^[A-Za-z_][\\w-]*$/.test(el.id) && !/\\d{2,}/.test(el.id) && quiet(el.id)) return tag + '#' + el.id
     const tid = el.getAttribute('data-testid')
-    if (tid) return el.tagName.toLowerCase() + '[data-testid="' + tid + '"]'
-    if (el.id && /^[A-Za-z_][\\w-]*$/.test(el.id)) return el.tagName.toLowerCase() + '#' + el.id
+    if (quiet(tid)) return tag + '[data-testid=' + attr(tid) + ']'
+    const label = el.getAttribute('aria-label')
+    if (quiet(label)) return tag + '[aria-label=' + attr(label) + ']'
+    if (/^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName)) {
+      const nm = el.getAttribute('name')
+      if (quiet(nm)) return tag + '[name=' + attr(nm) + ']'
+      const ph = el.getAttribute('placeholder')
+      if (quiet(ph)) return tag + '[placeholder=' + attr(ph) + ']'
+    }
     const cls = [...el.classList].filter((c) => /^[A-Za-z_-][\\w-]*$/.test(c)).slice(0, 2)
     let seg = el.tagName.toLowerCase() + (cls.length ? '.' + cls.join('.') : '')
     const p = el.parentElement
@@ -673,7 +689,549 @@ function parseHeaders(given) {
   return out;
 }
 
+// src/record/takeClock.ts
+var TakeClock = class {
+  constructor(t0) {
+    this.t0 = t0;
+  }
+  t0;
+  pauses = [];
+  lastFrameMs = -1;
+  /** Footage ms at a wall-clock instant (`Date.now()` space). */
+  footageMs(wallMs) {
+    let off = 0;
+    for (const p of this.pauses) {
+      if (wallMs <= p.from) break;
+      off += Math.min(wallMs, p.to ?? Infinity) - p.from;
+    }
+    return wallMs - this.t0 - off;
+  }
+  /** The camera stops at this instant; returns the cut's footage ms. */
+  pause(wallMs) {
+    const at = this.footageMs(wallMs);
+    this.pauses.push({ from: wallMs, to: null });
+    return at;
+  }
+  /** The camera rolls again; returns the wall ms the stretch lasted. */
+  resume(wallMs) {
+    const open = this.pauses[this.pauses.length - 1];
+    if (!open || open.to !== null) return 0;
+    open.to = Math.max(open.from, wallMs);
+    return open.to - open.from;
+  }
+  /**
+   * A captured frame's footage ms, or null when it is not later than the
+   * last frame kept (the frame is dropped; see the module comment).
+   */
+  placeFrame(captureWallMs) {
+    const t = Math.max(0, Math.round(this.footageMs(captureWallMs)));
+    if (t <= this.lastFrameMs) return null;
+    this.lastFrameMs = t;
+    return t;
+  }
+};
+
+// src/record/pageErrors.ts
+var PAGE_ERROR_LINE_CHARS = 160;
+function pageErrorLine(text) {
+  const one = text.replace(/\s+/g, " ").trim();
+  return one.length > PAGE_ERROR_LINE_CHARS ? `${one.slice(0, PAGE_ERROR_LINE_CHARS - 1)}\u2026` : one;
+}
+var PageErrorLog = class {
+  constructor(verbose = false) {
+    this.verbose = verbose;
+  }
+  verbose;
+  seen = /* @__PURE__ */ new Map();
+  /** The line to log for this error now, or null when it repeats one already said. */
+  add(text) {
+    const known = this.seen.get(text);
+    if (known) {
+      known.count++;
+      return this.verbose ? `   [page error] ${text}` : null;
+    }
+    this.seen.set(text, { text, count: 1 });
+    return `   [page error] ${this.verbose ? text : pageErrorLine(text)}`;
+  }
+  /** Every distinct error with how often it came, in the order first seen. */
+  entries() {
+    return [...this.seen.values()].map((e) => ({ ...e }));
+  }
+  /** The closing lines: each error that repeated, with its count. */
+  repeats() {
+    if (this.verbose) return [];
+    return [...this.seen.values()].filter((e) => e.count > 1).map((e) => `   [page error \xD7${e.count}] ${pageErrorLine(e.text)}`);
+  }
+};
+
+// src/record/actions.ts
+var STEP_GUARDS = ["spend"];
+var GUARDABLE = /* @__PURE__ */ new Set(["click", "press", "type"]);
+var EXPECT_TIMEOUT_S = 5;
+var AWAIT_TIMEOUT_S = 600;
+var AWAIT_POLL_S = 2;
+var DOWNLOAD_TIMEOUT_S = 30;
+var VERBS2 = /* @__PURE__ */ new Set([
+  "wait",
+  "hover",
+  "click",
+  "type",
+  "press",
+  "scroll",
+  "move",
+  "drag",
+  "expect",
+  "await",
+  "download"
+]);
+var PRESS_KEYS = [
+  "Escape",
+  "Enter",
+  "Tab",
+  "Backspace",
+  "Delete",
+  "ArrowUp",
+  "ArrowDown",
+  "ArrowLeft",
+  "ArrowRight",
+  "Home",
+  "End",
+  "PageUp",
+  "PageDown",
+  "Space"
+];
+function validateActions(value) {
+  const errors = [];
+  if (typeof value !== "object" || value === null)
+    return ["actions file must be a JSON object"];
+  const obj = value;
+  if (obj.url !== void 0) {
+    if (typeof obj.url !== "string") errors.push("url must be a string");
+    else {
+      const problem = urlSchemeProblem(obj.url);
+      if (problem) errors.push(`url ${problem}`);
+    }
+  }
+  if (obj.viewport !== void 0) {
+    const v = obj.viewport;
+    if (typeof v !== "object" || v === null) {
+      errors.push("viewport must be { width, height }");
+    } else {
+      const vp = v;
+      if (typeof vp.width !== "number" || typeof vp.height !== "number") {
+        errors.push("viewport must be { width, height }");
+      }
+    }
+  }
+  if (obj.setup !== void 0) errors.push(...validateSetup(obj.setup));
+  if (obj.mask !== void 0) {
+    if (!Array.isArray(obj.mask)) {
+      errors.push("mask must be an array of { selector, as?, text? }");
+    } else {
+      obj.mask.forEach((raw, i) => {
+        const at = `mask[${i}]`;
+        const m = raw ?? {};
+        if (typeof m.selector !== "string" || !m.selector.trim())
+          errors.push(`${at}: needs a selector`);
+        if (m.as !== void 0 && m.as !== "blur" && m.as !== "text")
+          errors.push(`${at}: as must be "blur" or "text"`);
+        if (m.as === "text" && (typeof m.text !== "string" || !m.text))
+          errors.push(`${at}: as "text" needs the text to show instead`);
+        if (m.as !== "text" && m.text !== void 0)
+          errors.push(`${at}: text is only read with as "text"`);
+      });
+    }
+  }
+  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
+    errors.push("steps must be a non-empty array");
+    return errors;
+  }
+  const seenIds = /* @__PURE__ */ new Set();
+  obj.steps.forEach((raw, i) => {
+    const at = `steps[${i}]`;
+    if (typeof raw !== "object" || raw === null) {
+      errors.push(`${at}: must be an object`);
+      return;
+    }
+    const s = raw;
+    if (s.read !== void 0 && (typeof s.read !== "string" || !s.read.trim()))
+      errors.push(`${at}: read must be a selector`);
+    if (typeof s.do !== "string" || !VERBS2.has(s.do)) {
+      errors.push(`${at}: "do" must be one of ${[...VERBS2].join(", ")}`);
+      return;
+    }
+    if (s.id !== void 0) {
+      if (typeof s.id !== "string" || !s.id.trim()) {
+        errors.push(`${at}: id must be a non-empty string`);
+      } else if (seenIds.has(s.id)) {
+        errors.push(
+          `${at}: duplicate id "${s.id}" \u2014 an anchor could not tell the two steps apart`
+        );
+      } else {
+        seenIds.add(s.id);
+      }
+    }
+    const needSelector = s.do === "hover" || s.do === "click" || s.do === "type";
+    if (needSelector && typeof s.selector !== "string")
+      errors.push(`${at}: ${s.do} needs a selector`);
+    if (s.do === "wait" && typeof s.ms !== "number")
+      errors.push(`${at}: wait needs ms`);
+    if (s.ms !== void 0 && (typeof s.ms !== "number" || !Number.isFinite(s.ms) || s.ms < 0))
+      errors.push(`${at}: ms must be a number of milliseconds \u2265 0`);
+    if (s.do === "type" && typeof s.text !== "string")
+      errors.push(`${at}: type needs text`);
+    if (s.do === "type" && s.focus !== void 0 && typeof s.focus !== "boolean")
+      errors.push(`${at}: type focus must be true or false`);
+    if (s.do === "type" && s.replace !== void 0 && typeof s.replace !== "boolean")
+      errors.push(`${at}: type replace must be true or false`);
+    if (s.do === "type" && s.at !== void 0 && s.at !== "end" && s.at !== "start")
+      errors.push(`${at}: type at must be "end" or "start"`);
+    if (s.do === "press") {
+      if (typeof s.key !== "string" || !PRESS_KEYS.includes(s.key))
+        errors.push(
+          `${at}: press needs a key, one of ${PRESS_KEYS.join(", ")}; words are typed with type`
+        );
+      if (s.selector !== void 0 && typeof s.selector !== "string")
+        errors.push(`${at}: press selector must be a string`);
+    }
+    if (s.do === "scroll" && typeof s.dy !== "number")
+      errors.push(`${at}: scroll needs dy`);
+    if (s.do === "move" && (typeof s.x !== "number" || typeof s.y !== "number")) {
+      errors.push(`${at}: move needs x and y (CSS px)`);
+    }
+    if (s.guard !== void 0) {
+      if (!STEP_GUARDS.includes(s.guard))
+        errors.push(
+          `${at}: guard must be ${STEP_GUARDS.map((g) => `"${g}"`).join(" or ")}`
+        );
+      else if (!GUARDABLE.has(s.do))
+        errors.push(
+          `${at}: guard sits on a click, a press or a type, the steps that commit something; a ${s.do} spends nothing`
+        );
+      else if (typeof s.id !== "string" || !s.id.trim())
+        errors.push(
+          `${at}: a guarded step needs an id, which is what --confirm <id> names`
+        );
+    }
+    if (s.do === "expect") {
+      const given = ["selector", "text", "gone"].filter(
+        (k) => s[k] !== void 0
+      );
+      if (given.length !== 1)
+        errors.push(
+          `${at}: expect needs exactly one of selector, text or gone${given.length ? ` (it has ${given.join(" and ")})` : ""}`
+        );
+      for (const k of given)
+        if (!isFilled(s[k]))
+          errors.push(`${at}: expect ${k} must be a non-empty string`);
+      if (s.enabled !== void 0) {
+        if (typeof s.enabled !== "boolean")
+          errors.push(`${at}: expect enabled must be true or false`);
+        else if (s.selector === void 0)
+          errors.push(
+            `${at}: expect enabled is about the selector's element, so it needs a selector`
+          );
+      }
+      errors.push(...secondsProblem(at, "expect timeout", s.timeout));
+    }
+    if (s.do === "await") {
+      const u = s.until;
+      if (typeof u !== "object" || u === null || Array.isArray(u)) {
+        errors.push(
+          `${at}: await needs until, one of { "selector" }, { "text" } or { "gone" }`
+        );
+      } else {
+        const until = u;
+        const keys = Object.keys(until);
+        const known = keys.filter(
+          (k) => k === "selector" || k === "text" || k === "gone"
+        );
+        const unknown = keys.filter((k) => !known.includes(k));
+        if (unknown.length)
+          errors.push(
+            `${at}: await until takes selector, text or gone, not ${unknown.join(", ")}`
+          );
+        if (known.length !== 1)
+          errors.push(
+            `${at}: await until needs exactly one of selector, text or gone${known.length ? ` (it has ${known.join(" and ")})` : ""}`
+          );
+        for (const k of known) {
+          const v = until[k];
+          if (typeof v !== "string" || !v.trim())
+            errors.push(`${at}: await until.${k} must be a non-empty string`);
+        }
+      }
+      errors.push(...secondsProblem(at, "await timeout", s.timeout));
+      errors.push(...secondsProblem(at, "await poll", s.poll));
+      if (s.reload !== void 0 && typeof s.reload !== "boolean")
+        errors.push(`${at}: await reload must be true or false`);
+      if (s.onTimeout !== void 0 && s.onTimeout !== "fail" && s.onTimeout !== "continue")
+        errors.push(`${at}: await onTimeout must be "fail" or "continue"`);
+    }
+    if (s.do === "download") {
+      const given = ["selector", "src"].filter(
+        (k) => s[k] !== void 0
+      );
+      if (given.length !== 1)
+        errors.push(
+          `${at}: download needs exactly one of selector (a control that downloads) or src (a video, audio or img element whose source is fetched)`
+        );
+      for (const k of given)
+        if (!isFilled(s[k]))
+          errors.push(`${at}: download ${k} must be a non-empty string`);
+      if (s.as !== void 0) {
+        const problem = typeof s.as === "string" ? fileNameProblem(s.as) : "is not a string";
+        if (problem) errors.push(`${at}: download as ${problem}`);
+      }
+    }
+    if (s.do === "drag") {
+      if (typeof s.tx !== "number" || typeof s.ty !== "number") {
+        errors.push(`${at}: drag needs tx and ty (CSS px)`);
+      }
+      const hasStart = typeof s.selector === "string" || typeof s.x === "number" && typeof s.y === "number";
+      if (!hasStart)
+        errors.push(
+          `${at}: drag needs a selector OR x and y as the start point`
+        );
+    }
+  });
+  return errors;
+}
+var isFilled = (v) => typeof v === "string" && v.trim().length > 0;
+function secondsProblem(at, what, v) {
+  if (v === void 0) return [];
+  if (typeof v !== "number" || !Number.isFinite(v) || v <= 0)
+    return [`${at}: ${what} must be a number of seconds above 0`];
+  return [];
+}
+function fileNameProblem(name) {
+  if (!name.trim()) return "must be a file name";
+  if (/[/\\]/.test(name))
+    return `"${name}" must be a plain file name, with no path separator`;
+  if (name.includes(".."))
+    return `"${name}" must be a plain file name, with no ".."`;
+  if (name.startsWith(".")) return `"${name}" must not be a hidden file`;
+  if (/[\u0000-\u001f\u007f]/.test(name))
+    return `"${name}" must not hold control characters`;
+  if (name.length > 200) return "must be at most 200 characters";
+  return null;
+}
+function guardedSteps(actions) {
+  const out = [];
+  actions.steps.forEach((s, i) => {
+    if (s.guard)
+      out.push({ step: i, id: s.id ?? String(i), do: s.do, guard: s.guard });
+  });
+  return out;
+}
+function guardVerdict(actions, confirm) {
+  const guarded = guardedSteps(actions);
+  const unconfirmed = guarded.filter((g) => !confirm.includes(g.id));
+  const unknown = confirm.filter((c) => !guarded.some((g) => g.id === c));
+  if (!unconfirmed.length && !unknown.length) return { ok: true };
+  const parts = [];
+  if (unconfirmed.length) {
+    const one = unconfirmed.length === 1;
+    parts.push(
+      `${unconfirmed.map((g) => `#${g.step} ${g.id} (${g.do})`).join(", ")} ${one ? "is" : "are"} guarded (${unconfirmed[0].guard}): ${one ? "it spends" : "they spend"} something real, so the recorder presses ${one ? "it" : "them"} only when the command says so. Add ${unconfirmed.map((g) => `--confirm ${g.id}`).join(" ")} to record ${one ? "it" : "them"}, or rehearse with --dry-run, which hovers and never presses`
+    );
+  }
+  if (unknown.length)
+    parts.push(
+      `${unknown.map((c) => `--confirm ${c}`).join(", ")} names no guarded step${guarded.length ? ` (the guarded ones: ${guarded.map((g) => g.id).join(", ")})` : ""}`
+    );
+  return {
+    ok: false,
+    unconfirmed: unconfirmed.map((g) => g.id),
+    unknown,
+    message: `${parts.join(". ")}. Nothing was recorded.`
+  };
+}
+function hostedRefusals(actions) {
+  const out = [];
+  for (const g of guardedSteps(actions))
+    out.push(
+      `steps[${g.step}] (${g.id}) is guarded (${g.guard}), and a hosted take has no way to confirm it: record it on this machine with --confirm ${g.id}`
+    );
+  actions.steps.forEach((s, i) => {
+    if (s.do === "download")
+      out.push(
+        `steps[${i}] is a download, which a hosted take does not keep: record it on this machine, where the file lands in the take's outputs/`
+      );
+  });
+  return out;
+}
+
+// src/record/waits.ts
+function visibleTextScript(text) {
+  return `(() => { const b = document.body; return !!b && (b.innerText || '').includes(${JSON.stringify(text)}) })()`;
+}
+async function readCondition(page, c) {
+  try {
+    if (c.text !== void 0)
+      return { holds: await page.evaluate(visibleTextScript(c.text)) };
+    if (c.gone !== void 0)
+      return { holds: !await page.locator(c.gone).first().isVisible() };
+    if (c.selector !== void 0) {
+      const loc = page.locator(c.selector).first();
+      const visible = await loc.isVisible();
+      if (!visible) return { holds: false, visible };
+      if (c.enabled === void 0) return { holds: true, visible };
+      const enabled = await loc.isEnabled({ timeout: 1e3 });
+      return { holds: enabled === c.enabled, visible };
+    }
+  } catch {
+  }
+  return { holds: false };
+}
+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/outputs.ts
+var OUTPUT_MAX_BYTES = 512 * 1024 * 1024;
+function plainName(suggested, fallback) {
+  const last = suggested.split(/[/\\]/).pop() ?? "";
+  const clean = last.replace(/[\u0000-\u001f\u007f]/g, "").replace(/\.\.+/g, ".").replace(/^\.+/, "").trim().slice(0, 200);
+  return clean && !fileNameProblem(clean) ? clean : fallback;
+}
+function nameFromUrl(url) {
+  try {
+    const u = new URL(url);
+    if (u.protocol === "blob:" || u.protocol === "data:") return "";
+    const seg = u.pathname.split("/").filter(Boolean).pop() ?? "";
+    return decodeURIComponent(seg);
+  } catch {
+    return "";
+  }
+}
+function outputName(asked, suggested, fallback, used) {
+  const base = asked ?? plainName(suggested, fallback);
+  if (!used.has(base)) return base;
+  const dot = base.lastIndexOf(".");
+  const stem = dot > 0 ? base.slice(0, dot) : base;
+  const ext = dot > 0 ? base.slice(dot) : "";
+  for (let n = 2; ; n++) {
+    const next = `${stem}-${n}${ext}`;
+    if (!used.has(next)) return next;
+  }
+}
+function chunkBytes(c) {
+  if (c instanceof Uint8Array) return c;
+  if (typeof c === "string") return new TextEncoder().encode(c);
+  if (c instanceof ArrayBuffer) return new Uint8Array(c);
+  throw new Error("the download stream gave something that is not bytes");
+}
+async function readAllBytes(stream, max = OUTPUT_MAX_BYTES) {
+  const parts = [];
+  let n = 0;
+  for await (const c of stream) {
+    const u = chunkBytes(c);
+    n += u.length;
+    if (n > max)
+      throw new Error(
+        `the file is larger than ${Math.round(max / 1024 / 1024)} MB`
+      );
+    parts.push(u);
+  }
+  const out = new Uint8Array(n);
+  let at = 0;
+  for (const p of parts) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+var readMediaSource = (el) => el.currentSrc || el.src || el.getAttribute("src") || "";
+function fetchInPageScript(url) {
+  return `(async () => {
+  try {
+    const res = await fetch(${JSON.stringify(url)}, { credentials: 'include' });
+    if (!res.ok) return { error: 'answered ' + res.status };
+    const buf = new Uint8Array(await res.arrayBuffer());
+    let bin = '';
+    for (let i = 0; i < buf.length; i += 0x8000) bin += String.fromCharCode.apply(null, buf.subarray(i, i + 0x8000));
+    return { b64: btoa(bin), type: res.headers.get('content-type') || '' };
+  } catch (e) {
+    return { error: String((e && e.message) || e) };
+  }
+})()`;
+}
+
 // src/record/recorder.ts
+var EXPECT_EVERY_MS = 100;
+var SRC_WAIT_MS = 8e3;
+var AWAIT_HEARTBEAT_MS = 3e4;
+var MIN_SKIP_MS = 250;
 var READ_WAIT_MS = 1500;
 var READ_MAX_CHARS = 2048;
 function headersFor(requestUrl, entryUrl, headers) {
@@ -705,6 +1263,12 @@ function publicUrl(u) {
     return "";
   }
 }
+var RecordRefusedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RecordRefusedError";
+  }
+};
 var DRY_PAUSE_MS = 120;
 function scrollByScript(x, y, dy) {
   return `(() => {
@@ -745,6 +1309,15 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const dry = opts.dryRun === true;
   const sleep = dry ? (ms) => realSleep(Math.min(ms, DRY_PAUSE_MS)) : realSleep;
   const maxSeconds = dry ? Infinity : opts.maxDurationSeconds ?? Infinity;
+  if (!dry) {
+    const guard = guardVerdict(actions, opts.confirm ?? []);
+    if (!guard.ok) throw new RecordRefusedError(guard.message);
+    const download = actions.steps.findIndex((s) => s.do === "download");
+    if (download >= 0 && !opts.outputs)
+      throw new RecordRefusedError(
+        `steps[${download}] is a download, and this recorder has nowhere to keep a file. Nothing was recorded.`
+      );
+  }
   const vw = actions.viewport?.width ?? 1280;
   const vh = actions.viewport?.height ?? 720;
   const context = opts.context ?? await browser.newContext({
@@ -762,8 +1335,11 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     const scan = await page.evaluate(EXPOSURE_PROBE).catch(() => null);
     exposureLog.add(step, scan);
   };
+  const pageErrors = new PageErrorLog(opts.verbose === true);
   page.on("console", (m) => {
-    if (m.type() === "error") log(`   [page error] ${m.text()}`);
+    if (m.type() !== "error") return;
+    const line = pageErrors.add(m.text());
+    if (line) log(line);
   });
   log(`goto ${url}`);
   let navTimeout = false;
@@ -813,32 +1389,46 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const frames = [];
   let frameIdx = 0;
   let t0 = 0;
+  let takeClock = new TakeClock(0);
   const first = { dims: null };
   let sinkChain = Promise.resolve();
   if (!dry)
     cdp.on("Page.screencastFrame", (ev) => {
+      cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
+      });
       const tsMs = ev.metadata.timestamp ? ev.metadata.timestamp * 1e3 : Date.now();
+      const tMs = takeClock.placeFrame(tsMs);
+      if (tMs === null) return;
       const file = `frame-${String(frameIdx++).padStart(5, "0")}.jpg`;
       const bytes = base64Bytes(ev.data);
       if (!first.dims) first.dims = jpegDims(bytes);
-      frames.push({ file, tMs: Math.max(0, Math.round(tsMs - t0)) });
+      frames.push({ file, tMs });
       sinkChain = sinkChain.then(() => sink.frame(file, bytes)).catch(() => {
       });
-      cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
-      });
     });
+  const screencast = {
+    format: "jpeg",
+    quality: 90,
+    maxWidth: vw,
+    maxHeight: vh,
+    everyNthFrame: 1
+  };
   t0 = Date.now();
-  if (!dry)
-    await cdp.send("Page.startScreencast", {
-      format: "jpeg",
-      quality: 90,
-      maxWidth: vw,
-      maxHeight: vh,
-      everyNthFrame: 1
-    });
+  takeClock = new TakeClock(t0);
+  if (!dry) await cdp.send("Page.startScreencast", screencast);
   const events = [];
   const cur = { x: 48, y: 48 };
-  const now = () => Date.now() - t0;
+  const now = () => takeClock.footageMs(Date.now());
+  const offCamera = async (fn) => {
+    const at = takeClock.pause(Date.now());
+    if (!dry) await cdp.send("Page.stopScreencast").catch(() => {
+    });
+    const out = await fn();
+    const ms = takeClock.resume(Date.now());
+    if (!dry) await cdp.send("Page.startScreencast", screencast).catch(() => {
+    });
+    return { out, at, ms };
+  };
   const emit = (e) => events.push({ t: now(), ...e });
   await page.mouse.move(cur.x, cur.y);
   emit({ x: cur.x, y: cur.y, type: "move" });
@@ -886,6 +1476,51 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       return null;
     }
   };
+  const srcOf = async (selector) => {
+    const deadline = Date.now() + SRC_WAIT_MS;
+    const loc = page.locator(selector).first();
+    try {
+      await loc.waitFor({ state: "attached", timeout: SRC_WAIT_MS });
+    } catch {
+      return null;
+    }
+    for (; ; ) {
+      const v = await loc.evaluate(readMediaSource).catch(() => "");
+      if (v || Date.now() >= deadline) return v;
+      await realSleep(200);
+    }
+  };
+  const fetchSource = async (src) => {
+    const abs = new URL(src, page.url()).href;
+    const suggested = nameFromUrl(abs);
+    if (page.request && /^https?:/i.test(abs)) {
+      const res = await page.request.get(abs, {
+        timeout: DOWNLOAD_TIMEOUT_S * 1e3
+      });
+      if (!res.ok())
+        throw new Error(
+          `fetching ${publicUrl(abs) || "the source"} answered ${res.status()}`
+        );
+      const bytes = await res.body();
+      if (bytes.length > OUTPUT_MAX_BYTES)
+        throw new Error(
+          `the file is larger than ${OUTPUT_MAX_BYTES / 1024 / 1024} MB`
+        );
+      const type2 = res.headers()["content-type"]?.split(";")[0].trim();
+      return { bytes, suggested, ...type2 ? { contentType: type2 } : {} };
+    }
+    const r = await page.evaluate(fetchInPageScript(abs));
+    if (!r || r.error || r.b64 === void 0)
+      throw new Error(
+        `fetching the source in the page failed: ${r?.error ?? "no answer"}`
+      );
+    const type = r.type?.split(";")[0].trim();
+    return {
+      bytes: base64Bytes(r.b64),
+      suggested,
+      ...type ? { contentType: type } : {}
+    };
+  };
   const clickAt = async (rect) => {
     await moveTo(rect.x + rect.w / 2, rect.y + rect.h / 2);
     await sleep(PRESS_LEAD_MS);
@@ -923,6 +1558,13 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   const skipped = [];
   const stepSpans = [];
   const paces = [];
+  const disabled = [];
+  const confirmed = [];
+  const skips = [];
+  const outputs = [];
+  const outputNames = /* @__PURE__ */ new Set();
+  let stopped = null;
+  let unpressedGuard = null;
   let capped = false;
   for (const [stepIdx, step] of actions.steps.entries()) {
     if (capReached(now(), maxSeconds)) {
@@ -940,6 +1582,42 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     const skippedBefore = skipped.length;
     const urlBefore = page.url();
     let stepRect = null;
+    const extra = {};
+    const tag = `#${stepIdx}${step.id ? ` ${step.id}` : ""}`;
+    const skip = (selector, reason) => {
+      skipped.push({
+        step: stepIdx,
+        ...step.id ? { id: step.id } : {},
+        do: step.do,
+        selector,
+        ...reason ? { reason } : {}
+      });
+      if (reason) extra.reason = reason;
+    };
+    if (step.guard) extra.guard = step.guard;
+    const rehearseGuard = async (sel) => {
+      if (!step.guard || !dry) return false;
+      const rect = sel ? await boxOf(sel) : null;
+      stepRect = rect;
+      if (sel && !rect) skip(sel);
+      else {
+        if (rect)
+          await gesture(() => moveTo(rect.x + rect.w / 2, rect.y + rect.h / 2));
+        log(
+          `${tag}: guarded (${step.guard}), ${rect ? "hovered" : "left alone"}, not pressed`
+        );
+      }
+      unpressedGuard = stepIdx;
+      return true;
+    };
+    const notWaited = () => {
+      if (!dry || unpressedGuard === null) return false;
+      extra.followsGuard = unpressedGuard;
+      log(
+        `${tag} ${step.do}: not waited: it follows #${unpressedGuard} (guarded, not pressed)`
+      );
+      return true;
+    };
     switch (step.do) {
       case "wait":
         await sleep(clampWait(step.ms, now(), maxSeconds));
@@ -959,9 +1637,21 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "click": {
+        if (await rehearseGuard(step.selector)) break;
         const rect = await boxOf(step.selector);
         stepRect = rect;
         if (rect) {
+          const enabled = await page.locator(step.selector).first().isEnabled({ timeout: 1e3 }).catch(() => true);
+          if (!enabled) {
+            disabled.push({
+              step: stepIdx,
+              ...step.id ? { id: step.id } : {},
+              selector: step.selector
+            });
+            log(
+              `   (${tag} click: ${step.selector} is disabled; pressed anyway)`
+            );
+          }
           await gesture(() => clickAt(rect));
           log(`click ${step.selector}`);
           const sinceChange = await gesture(() => waitSettled());
@@ -971,6 +1661,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "type": {
+        if (await rehearseGuard(step.selector)) break;
         const rect = await boxOf(step.selector);
         stepRect = rect;
         if (rect) {
@@ -1006,6 +1697,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         break;
       }
       case "press": {
+        if (await rehearseGuard(step.selector)) break;
         let rect = null;
         if (step.selector) {
           rect = await boxOf(step.selector);
@@ -1115,8 +1807,170 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
         await sleep(400);
         break;
       }
+      case "expect": {
+        if (notWaited()) break;
+        const cond = step;
+        const timeoutMs = (step.timeout ?? EXPECT_TIMEOUT_S) * 1e3;
+        const res = await pollCondition(page, cond, {
+          timeoutMs,
+          everyMs: EXPECT_EVERY_MS,
+          sleep: realSleep
+        });
+        if (res.ok) log(`expect ${sayCondition(cond)}: holds`);
+        else {
+          const reason = conditionMiss(cond, res.last, timeoutMs);
+          skip(step.selector ?? step.gone ?? step.text ?? "", reason);
+          log(`   (${tag} expect: ${reason})`);
+        }
+        break;
+      }
+      case "await": {
+        if (notWaited()) break;
+        const cond = step.until;
+        const timeoutMs = (step.timeout ?? AWAIT_TIMEOUT_S) * 1e3;
+        const reload = step.reload ? 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;
+        log(`await ${sayCondition(cond)} (off camera)\u2026`);
+        const awaitEvent = {
+          event: "await",
+          step: stepIdx,
+          ...step.id ? { id: step.id } : {}
+        };
+        opts.onEvent?.({ ...awaitEvent, phase: "start" });
+        const beatMs = opts.awaitHeartbeatMs ?? AWAIT_HEARTBEAT_MS;
+        const waitFrom = Date.now();
+        const beat = setInterval(() => {
+          const elapsedMs = Date.now() - waitFrom;
+          opts.onEvent?.({ ...awaitEvent, phase: "wait", elapsedMs });
+          log(`   still waiting, ${sayDuration(elapsedMs)} so far`);
+        }, beatMs);
+        let waited;
+        try {
+          waited = await offCamera(
+            () => pollCondition(page, cond, {
+              timeoutMs,
+              everyMs: (step.poll ?? AWAIT_POLL_S) * 1e3,
+              sleep: realSleep,
+              between: reload,
+              // After a reload the condition must hold on two reads in a
+              // row, or a half-built page ends the wait early.
+              ...reload ? { confirm: { reads: 2, gapMs: 500 } } : {}
+            })
+          );
+        } finally {
+          clearInterval(beat);
+        }
+        const { out, at, ms } = waited;
+        opts.onEvent?.({ ...awaitEvent, phase: "end", ms, held: out.ok });
+        extra.offCameraMs = ms;
+        if (!out.ok) extra.timedOut = true;
+        if (!dry && (ms >= MIN_SKIP_MS || !out.ok))
+          skips.push({
+            step: stepIdx,
+            ...step.id ? { id: step.id } : {},
+            at: +(at / 1e3).toFixed(3),
+            ms,
+            ...out.ok ? {} : { timedOut: true }
+          });
+        if (out.ok) log(`   held after ${sayDuration(ms)} off camera`);
+        else if ((step.onTimeout ?? "fail") === "continue")
+          log(
+            `   (${tag} await: ${conditionMiss(cond, out.last, ms)}; going on, as onTimeout says)`
+          );
+        else {
+          stopped = {
+            step: stepIdx,
+            ...step.id ? { id: step.id } : {},
+            reason: `${tag} await: ${conditionMiss(cond, out.last, ms)}, so the take stopped there. Raise its timeout, or set onTimeout: "continue" to go on without it`
+          };
+          extra.reason = stopped.reason;
+          log(`   ${stopped.reason}`);
+        }
+        break;
+      }
+      case "download": {
+        let got = null;
+        let reason = null;
+        const target = step.selector ?? step.src ?? "";
+        try {
+          if (step.selector !== void 0) {
+            const rect = await boxOf(step.selector);
+            stepRect = rect;
+            if (!rect) {
+              skip(step.selector);
+              break;
+            }
+            if (!page.waitForEvent) {
+              reason = "this browser reports no downloads";
+            } else {
+              const waitMs = DOWNLOAD_TIMEOUT_S * 1e3;
+              const arriving = page.waitForEvent("download", { timeout: waitMs }).catch(() => null);
+              await gesture(() => clickAt(rect));
+              log(`click ${step.selector} (download)`);
+              const dl = await arriving;
+              if (!dl)
+                reason = `no download arrived within ${sayDuration(waitMs)} of the click on '${step.selector}'`;
+              else {
+                const stream = await dl.createReadStream();
+                if (!stream) reason = "the download failed in the browser";
+                else
+                  got = {
+                    bytes: await readAllBytes(stream),
+                    suggested: dl.suggestedFilename(),
+                    // A browser download carries no headers here: the type is
+                    // read from the name the page gave it.
+                    ...typeOfName(dl.suggestedFilename())
+                  };
+              }
+            }
+          } else if (step.src !== void 0) {
+            const src = await srcOf(step.src);
+            if (src === null) reason = `no element matches '${step.src}'`;
+            else if (!src) reason = `'${step.src}' has no source to fetch`;
+            else got = await fetchSource(src);
+          }
+        } catch (e) {
+          reason = e instanceof Error ? e.message : String(e);
+        }
+        if (got) {
+          const name = outputName(
+            step.as,
+            got.suggested,
+            `download-${stepIdx}${extForType(got.contentType)}`,
+            outputNames
+          );
+          outputNames.add(name);
+          if (!dry) await opts.outputs?.save(name, got.bytes, got.contentType);
+          outputs.push({
+            step: stepIdx,
+            ...step.id ? { id: step.id } : {},
+            name,
+            bytes: got.bytes.length,
+            ...got.contentType ? { contentType: got.contentType } : {}
+          });
+          log(
+            `download \u2192 outputs/${name} (${got.bytes.length} bytes)${dry ? ", not kept in a rehearsal" : ""}`
+          );
+        } else {
+          const why = reason ?? "nothing came";
+          skip(target, why);
+          log(`   (${tag} download: ${why})`);
+        }
+        break;
+      }
+    }
+    if (step.guard && !dry && skipped.length === skippedBefore) {
+      confirmed.push(step.id ?? String(stepIdx));
+      extra.confirmed = true;
     }
     const stepInfo = step;
+    const about = stepInfo.selector ?? stepInfo.until?.selector ?? stepInfo.until?.gone ?? stepInfo.gone ?? stepInfo.src;
     const urlAfter = publicUrl(page.url());
     const text = stepInfo.read ? await readText(page, stepInfo.read) : null;
     if (stepInfo.read && text === null)
@@ -1125,7 +1979,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       step: stepIdx,
       ...stepInfo.id ? { id: stepInfo.id } : {},
       do: step.do,
-      ...stepInfo.selector ? { selector: stepInfo.selector } : {},
+      ...about ? { selector: about } : {},
       tStart: +(stepStart / 1e3).toFixed(3),
       tEnd: +(now() / 1e3).toFixed(3),
       ...skipped.length > skippedBefore ? { skipped: true } : {},
@@ -1139,7 +1993,8 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
           w: +stepRect.w.toFixed(1),
           h: +stepRect.h.toFixed(1)
         }
-      } : {}
+      } : {},
+      ...extra
     });
     paces.push({
       step: stepIdx,
@@ -1149,8 +2004,9 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
       wallMs: now() - stepStart
     });
     await scanExposures(stepIdx);
+    if (stopped) break;
   }
-  if (!capped) await sleep(TRAILING_HOLD_MS);
+  if (!capped && !stopped) await sleep(TRAILING_HOLD_MS);
   if (capped || capReached(now(), maxSeconds)) {
     capped = true;
     log(`   ${cappedLine(maxSeconds)}`);
@@ -1160,6 +2016,7 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
   });
   await sleep(200);
   const pageTitle = await page.title().catch(() => "");
+  for (const line of pageErrors.repeats()) log(line);
   await context.close();
   await sinkChain;
   const meta = {
@@ -1183,7 +2040,9 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     steps: stepSpans,
     ...wall ? { wall: { kind: wall.kind, asked: wall.asked, landed: wall.landed } } : {},
     ...exposureLog.exposures().length ? { exposures: exposureLog.exposures() } : {},
-    ...masks.length ? { masks: exposureLog.masks(masks) } : {}
+    ...masks.length ? { masks: exposureLog.masks(masks) } : {},
+    ...skips.length ? { skips } : {},
+    ...outputs.length ? { outputs } : {}
   };
   const freezes = [];
   for (let i = 1; i < frames.length; i++) {
@@ -1216,148 +2075,42 @@ async function recordTake(browser, url, actions, sink, log, opts = {}) {
     freezePct,
     dead,
     capped,
+    disabled,
+    confirmed,
+    skips,
+    outputs,
+    stopped,
+    pageErrors: pageErrors.entries(),
     actions: { ...actions, url }
   };
 }
-
-// src/record/actions.ts
-var VERBS2 = /* @__PURE__ */ new Set([
-  "wait",
-  "hover",
-  "click",
-  "type",
-  "press",
-  "scroll",
-  "move",
-  "drag"
-]);
-var PRESS_KEYS = [
-  "Escape",
-  "Enter",
-  "Tab",
-  "Backspace",
-  "Delete",
-  "ArrowUp",
-  "ArrowDown",
-  "ArrowLeft",
-  "ArrowRight",
-  "Home",
-  "End",
-  "PageUp",
-  "PageDown",
-  "Space"
-];
-function validateActions(value) {
-  const errors = [];
-  if (typeof value !== "object" || value === null)
-    return ["actions file must be a JSON object"];
-  const obj = value;
-  if (obj.url !== void 0) {
-    if (typeof obj.url !== "string") errors.push("url must be a string");
-    else {
-      const problem = urlSchemeProblem(obj.url);
-      if (problem) errors.push(`url ${problem}`);
-    }
-  }
-  if (obj.viewport !== void 0) {
-    const v = obj.viewport;
-    if (typeof v !== "object" || v === null) {
-      errors.push("viewport must be { width, height }");
-    } else {
-      const vp = v;
-      if (typeof vp.width !== "number" || typeof vp.height !== "number") {
-        errors.push("viewport must be { width, height }");
-      }
-    }
-  }
-  if (obj.setup !== void 0) errors.push(...validateSetup(obj.setup));
-  if (obj.mask !== void 0) {
-    if (!Array.isArray(obj.mask)) {
-      errors.push("mask must be an array of { selector, as?, text? }");
-    } else {
-      obj.mask.forEach((raw, i) => {
-        const at = `mask[${i}]`;
-        const m = raw ?? {};
-        if (typeof m.selector !== "string" || !m.selector.trim())
-          errors.push(`${at}: needs a selector`);
-        if (m.as !== void 0 && m.as !== "blur" && m.as !== "text")
-          errors.push(`${at}: as must be "blur" or "text"`);
-        if (m.as === "text" && (typeof m.text !== "string" || !m.text))
-          errors.push(`${at}: as "text" needs the text to show instead`);
-        if (m.as !== "text" && m.text !== void 0)
-          errors.push(`${at}: text is only read with as "text"`);
-      });
-    }
-  }
-  if (!Array.isArray(obj.steps) || obj.steps.length === 0) {
-    errors.push("steps must be a non-empty array");
-    return errors;
-  }
-  const seenIds = /* @__PURE__ */ new Set();
-  obj.steps.forEach((raw, i) => {
-    const at = `steps[${i}]`;
-    if (typeof raw !== "object" || raw === null) {
-      errors.push(`${at}: must be an object`);
-      return;
-    }
-    const s = raw;
-    if (s.read !== void 0 && (typeof s.read !== "string" || !s.read.trim()))
-      errors.push(`${at}: read must be a selector`);
-    if (typeof s.do !== "string" || !VERBS2.has(s.do)) {
-      errors.push(`${at}: "do" must be one of ${[...VERBS2].join(", ")}`);
-      return;
-    }
-    if (s.id !== void 0) {
-      if (typeof s.id !== "string" || !s.id.trim()) {
-        errors.push(`${at}: id must be a non-empty string`);
-      } else if (seenIds.has(s.id)) {
-        errors.push(
-          `${at}: duplicate id "${s.id}" \u2014 an anchor could not tell the two steps apart`
-        );
-      } else {
-        seenIds.add(s.id);
-      }
-    }
-    const needSelector = s.do === "hover" || s.do === "click" || s.do === "type";
-    if (needSelector && typeof s.selector !== "string")
-      errors.push(`${at}: ${s.do} needs a selector`);
-    if (s.do === "wait" && typeof s.ms !== "number")
-      errors.push(`${at}: wait needs ms`);
-    if (s.ms !== void 0 && (typeof s.ms !== "number" || !Number.isFinite(s.ms) || s.ms < 0))
-      errors.push(`${at}: ms must be a number of milliseconds \u2265 0`);
-    if (s.do === "type" && typeof s.text !== "string")
-      errors.push(`${at}: type needs text`);
-    if (s.do === "type" && s.focus !== void 0 && typeof s.focus !== "boolean")
-      errors.push(`${at}: type focus must be true or false`);
-    if (s.do === "type" && s.replace !== void 0 && typeof s.replace !== "boolean")
-      errors.push(`${at}: type replace must be true or false`);
-    if (s.do === "type" && s.at !== void 0 && s.at !== "end" && s.at !== "start")
-      errors.push(`${at}: type at must be "end" or "start"`);
-    if (s.do === "press") {
-      if (typeof s.key !== "string" || !PRESS_KEYS.includes(s.key))
-        errors.push(
-          `${at}: press needs a key, one of ${PRESS_KEYS.join(", ")}; words are typed with type`
-        );
-      if (s.selector !== void 0 && typeof s.selector !== "string")
-        errors.push(`${at}: press selector must be a string`);
-    }
-    if (s.do === "scroll" && typeof s.dy !== "number")
-      errors.push(`${at}: scroll needs dy`);
-    if (s.do === "move" && (typeof s.x !== "number" || typeof s.y !== "number")) {
-      errors.push(`${at}: move needs x and y (CSS px)`);
-    }
-    if (s.do === "drag") {
-      if (typeof s.tx !== "number" || typeof s.ty !== "number") {
-        errors.push(`${at}: drag needs tx and ty (CSS px)`);
-      }
-      const hasStart = typeof s.selector === "string" || typeof s.x === "number" && typeof s.y === "number";
-      if (!hasStart)
-        errors.push(
-          `${at}: drag needs a selector OR x and y as the start point`
-        );
-    }
-  });
-  return errors;
+var EXT_FOR_TYPE = {
+  "video/mp4": ".mp4",
+  "video/webm": ".webm",
+  "video/quicktime": ".mov",
+  "audio/mpeg": ".mp3",
+  "audio/mp4": ".m4a",
+  "audio/wav": ".wav",
+  "audio/ogg": ".ogg",
+  "image/png": ".png",
+  "image/jpeg": ".jpg",
+  "image/webp": ".webp",
+  "image/gif": ".gif",
+  "image/svg+xml": ".svg",
+  "application/pdf": ".pdf",
+  "application/json": ".json",
+  "text/csv": ".csv",
+  "application/zip": ".zip"
+};
+function extForType(type) {
+  return (type && EXT_FOR_TYPE[type.split(";")[0].trim().toLowerCase()]) ?? "";
+}
+function typeOfName(name) {
+  const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
+  if (!name.includes(".")) return {};
+  for (const [type, e] of Object.entries(EXT_FOR_TYPE))
+    if (e === ext) return { contentType: type };
+  return ext === ".jpeg" ? { contentType: "image/jpeg" } : {};
 }
 
 // src/record/encodePage.ts
@@ -1424,6 +2177,7 @@ import {
 function planFreshTake(artifact, recordingName, opts = {}) {
   const ingest = opts.backdrop ? { frame: withBackdrop(DEFAULT_FRAME_STYLE, opts.backdrop) } : {};
   const doc = projectFromArtifact(artifact, recordingName, ingest).doc;
+  doc.segments = splitSegmentsAtSkips(doc.segments, artifact.meta.skips);
   doc.zoom = planAutoZoom(doc.source.cursor, {
     width: doc.source.meta.width,
     height: doc.source.meta.height,
@@ -1438,32 +2192,77 @@ function planFreshTake(artifact, recordingName, opts = {}) {
   });
   return doc;
 }
+function splitSegmentsAtSkips(segments, skips) {
+  if (!skips?.length) return segments;
+  const cuts = [...new Set(skips.map((s) => s.at))].sort((a, b) => a - b);
+  const out = [];
+  for (const seg of segments) {
+    const inside = seg.media ? [] : cuts.filter((at) => at > seg.in + 1e-3 && at < seg.out - 1e-3);
+    if (!inside.length) {
+      out.push(seg);
+      continue;
+    }
+    const { anim, hold, ...plain } = seg;
+    const edges = [seg.in, ...inside, seg.out];
+    for (let i = 0; i < edges.length - 1; i++) {
+      const first = i === 0;
+      const last = i === edges.length - 2;
+      const pieceAnim = anim && (first || last) ? {
+        ...first && anim.enter ? { enter: anim.enter } : {},
+        ...last && anim.exit ? { exit: anim.exit } : {}
+      } : null;
+      out.push({
+        ...plain,
+        in: edges[i],
+        out: edges[i + 1],
+        ...pieceAnim && Object.keys(pieceAnim).length ? { anim: pieceAnim } : {},
+        ...last && hold !== void 0 ? { hold } : {}
+      });
+    }
+  }
+  return out;
+}
 export {
+  AWAIT_HEARTBEAT_MS,
+  AWAIT_POLL_S,
+  AWAIT_TIMEOUT_S,
   DEAD_SHARE_WARN_PCT,
   DEAD_STRETCH_WARN_MS,
+  DOM_CHANGE_PROBE,
+  DOM_QUIET_MS,
+  DOM_SETTLE_CAP_MS,
+  DOWNLOAD_TIMEOUT_S,
+  EXPECT_TIMEOUT_S,
   EXPOSURE_ADVICE,
   EXPOSURE_MATCHERS_SRC,
   EXPOSURE_PROBE,
   ExposureLog,
+  MIN_SKIP_MS,
   MOTION_TICK_MS,
+  OUTPUT_MAX_BYTES,
+  PAGE_ERROR_LINE_CHARS,
   POINTER_MAX_MS,
   POINTER_MIN_MS,
   POINTER_MS_PER_PX,
   PRESS_HOLD_MS,
   PRESS_KEYS,
   PRESS_LEAD_MS,
+  PageErrorLog,
   QUIET_MS,
   READ_BEAT_MS,
   RESPONSE_MS,
+  RecordRefusedError,
   SCROLL_MAX_MS,
   SCROLL_MIN_MS,
   SCROLL_MS_PER_PX,
   SCROLL_SETTLE_MS,
   SETTLE_CAP_MS,
   SETTLE_MS,
+  STEP_GUARDS,
   SetupEnvError,
   SetupError,
   TRAILING_HOLD_MS,
+  TakeClock,
   WALL_PROBE,
   WallError,
   askedMs,
@@ -1474,37 +2273,58 @@ export {
   clampWait,
   clockMotion,
   clockTyping,
+  conditionMiss,
   deadLine,
   deadTime,
   deadWarns,
+  domSettled,
   easeInOutCubic,
   exposureLine,
+  extForType,
+  fetchInPageScript,
+  fileNameProblem,
   formatDurationCap,
+  guardVerdict,
+  guardedSteps,
   headersFor,
   holdLeftMs,
+  hostedRefusals,
   isIdpHost,
   isSignInPath,
   jpegDims,
   maskInitScript,
+  nameFromUrl,
+  outputName,
   paceLine,
   paceReport,
+  pageErrorLine,
   parseHeaders,
+  plainName,
   planFreshTake,
   pointerTravelMs,
+  pollCondition,
   publicUrl,
+  readAllBytes,
+  readCondition,
+  readMediaSource,
   realSleep,
   recordTake,
   redirectedAway,
   resolveSetupText,
   runSetup,
+  sayCondition,
+  sayDuration,
   scrollByScript,
   scrollTravelMs,
   settleMs,
   settleVerdict,
   setupEnvNames,
+  splitSegmentsAtSkips,
+  typeOfName,
   urlSchemeProblem,
   validateActions,
   validateSetup,
+  visibleTextScript,
   wallVerdict
 };
 //# sourceMappingURL=index.js.map