@vosjs/render-core 0.2.9 → 0.3.1

package/dist/record/index.js

@@ -0,0 +1,1324 @@
+// src/record/driver.ts
+var realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// src/record/cap.ts
+function capReached(elapsedMs, capSeconds) {
+  return elapsedMs >= capSeconds * 1e3;
+}
+function clampWait(waitMs, elapsedMs, capSeconds) {
+  return Math.max(0, Math.min(waitMs, capSeconds * 1e3 - elapsedMs));
+}
+function formatDurationCap(seconds) {
+  if (seconds < 60) return `${seconds} s`;
+  const m = Math.round(seconds / 60);
+  if (m < 60) return `${m} min`;
+  const h = Math.floor(m / 60);
+  const rest = m % 60;
+  return rest ? `${h} h ${rest} min` : `${h} h`;
+}
+function cappedLine(capSeconds) {
+  return `stopped at ${formatDurationCap(capSeconds)} (--max-duration ${capSeconds}); the remaining steps did not run`;
+}
+
+// src/record/pace.ts
+var POINTER_MS_PER_PX = 0.7;
+var POINTER_MIN_MS = 250;
+var POINTER_MAX_MS = 800;
+var MOTION_TICK_MS = 16;
+var SETTLE_MS = {
+  click: 150,
+  type: 150,
+  scroll: 200,
+  drag: 80
+};
+var PRESS_LEAD_MS = 80;
+var PRESS_HOLD_MS = 70;
+var SCROLL_SETTLE_MS = 120;
+var TRAILING_HOLD_MS = 400;
+function pointerTravelMs(dist) {
+  return Math.min(
+    POINTER_MAX_MS,
+    Math.max(POINTER_MIN_MS, Math.round(dist * POINTER_MS_PER_PX))
+  );
+}
+var RESPONSE_MS = 400;
+var QUIET_MS = 250;
+var SETTLE_CAP_MS = 1200;
+function settleVerdict(t, c = { response: RESPONSE_MS, quiet: QUIET_MS, cap: SETTLE_CAP_MS }) {
+  if (t.sincePress >= c.cap) return "settled";
+  if (t.sinceChange === null)
+    return t.sincePress >= c.response ? "settled" : "wait";
+  return t.sinceChange >= c.quiet ? "settled" : "wait";
+}
+function holdLeftMs(holdMs, sinceChange) {
+  return Math.max(0, holdMs - (sinceChange ?? 0));
+}
+function settleMs(step) {
+  if (typeof step.ms === "number" && step.ms >= 0) return step.ms;
+  const d = step.do;
+  return SETTLE_MS[d] ?? 0;
+}
+var easeInOutCubic = (u) => u < 0.5 ? 4 * u * u * u : 1 - Math.pow(-2 * u + 2, 3) / 2;
+async function clockMotion(dur, at, clock) {
+  const start = clock.now();
+  let samples = 0;
+  for (; ; ) {
+    const elapsed = clock.now() - start;
+    if (elapsed >= dur) break;
+    await at(easeInOutCubic(Math.min(1, elapsed / dur)));
+    samples++;
+    const next = start + Math.ceil((clock.now() - start) / MOTION_TICK_MS) * MOTION_TICK_MS;
+    const wait = Math.min(next, start + dur) - clock.now();
+    if (wait > 0) await clock.sleep(wait);
+  }
+  await at(1);
+  return samples + 1;
+}
+async function clockTyping(chars, delay, type, clock) {
+  const start = clock.now();
+  for (let i = 0; i < chars.length; i++) {
+    await type(chars[i], i);
+    const due = start + (i + 1) * delay;
+    const wait = due - clock.now();
+    if (wait > 0 && i < chars.length - 1) await clock.sleep(wait);
+  }
+}
+function askedMs(step) {
+  switch (step.do) {
+    case "wait":
+      return step.ms ?? 0;
+    // A click's ms is the read after the page settled: the author's.
+    case "click":
+      return step.ms ?? SETTLE_MS.click;
+    case "hover":
+      return step.ms ?? 700;
+    case "drag":
+      return step.ms ?? 700;
+    case "type":
+      return (step.text?.length ?? 0) * (step.delayMs ?? 40);
+    default:
+      return 0;
+  }
+}
+function paceReport(steps) {
+  const askedMs2 = steps.reduce((a, s) => a + s.askedMs, 0);
+  const gestureMs = steps.reduce((a, s) => a + s.gestureMs, 0);
+  const wallMs = steps.reduce((a, s) => a + s.wallMs, 0);
+  const overheadMs = Math.max(0, wallMs - askedMs2 - gestureMs);
+  const slow = steps.filter((s) => s.wallMs > (s.askedMs + s.gestureMs) * 1.34 + 60).map((s) => ({
+    step: s.step,
+    do: s.do,
+    askedMs: s.askedMs,
+    wallMs: s.wallMs
+  }));
+  return {
+    askedMs: askedMs2,
+    gestureMs,
+    wallMs,
+    overheadMs,
+    overheadPct: wallMs > 0 ? Math.round(overheadMs / wallMs * 100) : 0,
+    slow
+  };
+}
+function paceLine(r) {
+  const s = (ms) => `${(ms / 1e3).toFixed(1)} s`;
+  const slow = r.slow.length ? `; slow: ${r.slow.map((x) => `#${x.step} ${x.do} ${s(x.wallMs)} for ${s(x.askedMs)} asked`).join(", ")}` : "";
+  return `pace: the script asked ${s(r.askedMs)}, the gestures added ${s(r.gestureMs)}, the take ran ${s(r.wallMs)} (${r.overheadPct} % overhead${slow})`;
+}
+var READ_BEAT_MS = { page: 1e3, control: 600 };
+var DEAD_STRETCH_WARN_MS = 1500;
+var DEAD_SHARE_WARN_PCT = 20;
+function deadTime(steps, frames, events, durationMs) {
+  const out = [];
+  let ms = 0;
+  let longestMs = 0;
+  for (const s of steps) {
+    const t0 = s.tStart * 1e3;
+    const t1 = s.tEnd * 1e3;
+    if (!(t1 > t0)) continue;
+    const press = events.find(
+      (e) => e.type === "down" && e.t >= t0 && e.t <= t1
+    );
+    const act = press ? press.t : t0;
+    let last = act;
+    for (const f of frames) {
+      if (f.tMs > act && f.tMs <= t1) last = f.tMs;
+    }
+    const settledMs = Math.round(last - act);
+    const heldMs = Math.round(t1 - last);
+    const moved = events.some(
+      (e) => (e.type === "move" || e.type === "scroll") && e.t > last && e.t <= t1
+    );
+    const beat = s.navigated || s.step === 0 ? READ_BEAT_MS.page : READ_BEAT_MS.control;
+    const deadMs = moved ? 0 : Math.max(0, heldMs - beat);
+    if (deadMs > 0) {
+      out.push({
+        step: s.step,
+        ...s.id ? { id: s.id } : {},
+        do: s.do,
+        settledMs,
+        heldMs,
+        deadMs
+      });
+      ms += deadMs;
+      longestMs = Math.max(longestMs, deadMs);
+    }
+  }
+  return {
+    ms,
+    pct: durationMs > 0 ? Math.round(ms / durationMs * 100) : 0,
+    steps: out,
+    longestMs
+  };
+}
+function deadWarns(r) {
+  return r.pct >= DEAD_SHARE_WARN_PCT || r.longestMs >= DEAD_STRETCH_WARN_MS;
+}
+function deadLine(r) {
+  const s = (ms) => `${(ms / 1e3).toFixed(1)} s`;
+  if (!r.steps.length) return "dead time: none";
+  const parts = r.steps.map(
+    (d) => `#${d.step}${d.id ? ` (${d.id})` : ""} ${d.do} held ${s(d.heldMs)} after it settled, ${s(d.deadMs)} past the beat`
+  );
+  return `dead time: ${s(r.ms)} (${r.pct} %), a still frame under a parked cursor past the reading beat: ${parts.join("; ")}. Cut those steps' ms; a hold is what it takes to read what changed.`;
+}
+
+// src/record/wall.ts
+var IDP_HOSTS = [
+  "accounts.google.com",
+  "login.microsoftonline.com",
+  "login.live.com",
+  "appleid.apple.com",
+  "auth0.com",
+  "okta.com",
+  "onelogin.com",
+  "clerk.accounts.dev",
+  "accounts.dev",
+  "b2clogin.com",
+  "amazoncognito.com",
+  "workos.com",
+  "stytch.com"
+];
+var SIGNIN_SEGMENTS = /* @__PURE__ */ new Set([
+  "login",
+  "log-in",
+  "signin",
+  "sign-in",
+  "sign_in",
+  "sso",
+  "auth",
+  "authenticate",
+  "authorize",
+  "oauth",
+  "oauth2",
+  "saml"
+]);
+function parse(url) {
+  try {
+    return new URL(url);
+  } catch {
+    return null;
+  }
+}
+var bareHost = (h) => h.replace(/^www\./, "").toLowerCase();
+var trimSlash = (p) => p.length > 1 ? p.replace(/\/+$/, "") : p;
+var place = (u) => `${u.origin}${trimSlash(u.pathname)}`;
+function isIdpHost(host) {
+  const h = host.toLowerCase();
+  if (h.startsWith("clerk.")) return true;
+  return IDP_HOSTS.some((idp) => h === idp || h.endsWith(`.${idp}`));
+}
+function isSignInPath(pathname) {
+  const segs = pathname.toLowerCase().split("/").filter(Boolean);
+  return segs.some((s) => SIGNIN_SEGMENTS.has(s));
+}
+function redirectedAway(asked, landed) {
+  if (bareHost(asked.hostname) !== bareHost(landed.hostname)) return true;
+  const a = trimSlash(asked.pathname).toLowerCase();
+  const l = trimSlash(landed.pathname).toLowerCase();
+  if (a === l || a === "/") return false;
+  if (l.startsWith(`${a}/`)) return false;
+  if (l.endsWith(a)) return false;
+  return true;
+}
+var LADDER = 'This is a missing or expired session, not a script bug. Ways past, cheapest first: mint a session from the test auth the project already has; script the sign-in off camera and save the storage state; or have a person sign in once (npx playwright open --channel chrome --save-storage=<file> <url>). Then pass --storage-state <file>. The ladder: https://vos.so/llms-full.txt, "Sessions". A take OF this page is --allow-wall.';
+function wallVerdict(a) {
+  const asked = parse(a.askedUrl);
+  const landed = parse(a.landedUrl);
+  if (!asked || !landed) return null;
+  if (!/^https?:$/.test(asked.protocol)) return null;
+  const away = redirectedAway(asked, landed);
+  const where = { asked: place(asked), landed: place(landed) };
+  const host = bareHost(asked.hostname);
+  if (a.status === 401 || a.status === 403) {
+    return {
+      kind: "status",
+      level: "hard",
+      ...where,
+      message: `asked for ${asked.pathname}, answered ${a.status}: no session for ${host}. ${LADDER}`
+    };
+  }
+  const askedForSignIn = isSignInPath(asked.pathname) || isIdpHost(asked.hostname);
+  if (askedForSignIn && !away) return null;
+  if (away && isIdpHost(landed.hostname) && !isIdpHost(asked.hostname)) {
+    return {
+      kind: "idp",
+      level: "hard",
+      ...where,
+      message: `asked for ${asked.pathname}, landed on ${landed.hostname}: no session for ${host}. ${LADDER}`
+    };
+  }
+  const signInForm = a.passwordFields === 1 && !a.newPasswordField || a.oneTimeCodeField;
+  if (away && isSignInPath(landed.pathname) || signInForm && !askedForSignIn) {
+    const seen = away ? `landed on ${landed.pathname}` : "the page is a sign-in form";
+    return {
+      kind: "signin",
+      level: "hard",
+      ...where,
+      message: `asked for ${asked.pathname}, ${seen}: no session for ${host}. ${LADDER}`
+    };
+  }
+  if (away) {
+    return {
+      kind: "redirect",
+      level: "soft",
+      ...where,
+      message: `asked for ${asked.pathname}, landed on ${landed.pathname}: the site sent the recorder elsewhere, which is what a page behind a login does to a stranger. If that is the page you meant, record it by its own URL. ${LADDER}`
+    };
+  }
+  return null;
+}
+var WallError = class extends Error {
+  constructor(verdict) {
+    super(verdict.message);
+    this.verdict = verdict;
+    this.name = "WallError";
+  }
+  verdict;
+};
+var WALL_PROBE = `(() => {
+  const shown = (el) => {
+    const r = el.getBoundingClientRect()
+    if (r.width < 2 || r.height < 2) return false
+    const s = getComputedStyle(el)
+    return s.visibility !== 'hidden' && s.display !== 'none'
+  }
+  const pw = [...document.querySelectorAll('input[type="password"]')].filter(shown)
+  const otp = [...document.querySelectorAll('input[autocomplete="one-time-code"]')].filter(shown)
+  return {
+    passwordFields: pw.length,
+    newPasswordField: pw.some((el) => (el.getAttribute('autocomplete') || '').includes('new-password')),
+    oneTimeCodeField: otp.length > 0,
+  }
+})()`;
+
+// src/record/exposure.ts
+var EXPOSURE_MATCHERS_SRC = `(() => {
+  const EMAIL = /[A-Za-z0-9._%+-]+@((?:[A-Za-z0-9-]+\\.)+[A-Za-z]{2,})/g
+  const SAFE_HOST = /(^|\\.)example\\.(com|org|net)$|\\.(test|example|invalid|localhost)$/i
+  const KEY = new RegExp([
+    '\\\\b[srp]k_(?:live|test)_[A-Za-z0-9]{8,}',
+    '\\\\bgh[pousr]_[A-Za-z0-9]{20,}',
+    '\\\\bgithub_pat_[A-Za-z0-9_]{20,}',
+    '\\\\bxox[abprs]-[A-Za-z0-9-]{10,}',
+    '\\\\bAKIA[0-9A-Z]{16}\\\\b',
+    '\\\\bAIza[0-9A-Za-z_-]{30,}',
+    '\\\\bvos_(?:sk|rg|ho)_[A-Za-z0-9]{8,}',
+    '\\\\beyJ[A-Za-z0-9_-]{8,}\\\\.eyJ[A-Za-z0-9_-]{8,}\\\\.[A-Za-z0-9_-]{8,}',
+  ].join('|'))
+  const CARD = /(?:^|[^0-9])((?:[0-9][ -]?){12,18}[0-9])(?![0-9])/g
+  const TAIL = /[\\u2022\\u00b7*xX]{2,}[ -]?[0-9]{4}(?![0-9])/
+  const luhn = (digits) => {
+    let sum = 0, alt = false
+    for (let i = digits.length - 1; i >= 0; i--) {
+      let d = digits.charCodeAt(i) - 48
+      if (alt) { d *= 2; if (d > 9) d -= 9 }
+      sum += d; alt = !alt
+    }
+    return sum % 10 === 0
+  }
+  const kindsIn = (text) => {
+    const kinds = []
+    if (!text || text.length < 6) return kinds
+    EMAIL.lastIndex = 0
+    for (let m; (m = EMAIL.exec(text)); ) {
+      if (!SAFE_HOST.test(m[1])) { kinds.push('email'); break }
+    }
+    if (KEY.test(text)) kinds.push('key')
+    CARD.lastIndex = 0
+    for (let m; (m = CARD.exec(text)); ) {
+      const digits = m[1].replace(/[ -]/g, '')
+      if (digits.length >= 13 && digits.length <= 19 && !/^0+$/.test(digits) && luhn(digits)) { kinds.push('card'); break }
+    }
+    if (TAIL.test(text)) kinds.push('card-tail')
+    return kinds
+  }
+  return { kindsIn }
+})()`;
+var EXPOSURE_PROBE = `(() => {
+  const { kindsIn } = ${EXPOSURE_MATCHERS_SRC}
+  const vw = innerWidth, vh = innerHeight
+  // A selector that reaches THIS element and no other, so it can be pasted
+  // into "mask" as it is: climb until the path is unique, and say which
+  // sibling wherever a tag-and-class alone would match several.
+  const segment = (el) => {
+    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
+    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
+    if (p && [...p.children].filter((c) => c.matches(seg)).length > 1)
+      seg += ':nth-child(' + ([...p.children].indexOf(el) + 1) + ')'
+    return seg
+  }
+  const name = (el) => {
+    const parts = []
+    for (let cur = el; cur && cur !== document.body && cur !== document.documentElement; cur = cur.parentElement) {
+      parts.unshift(segment(cur))
+      let n = 2
+      try { n = document.querySelectorAll(parts.join(' > ')).length } catch {}
+      // a bare tag is unique HERE and nowhere else: give it its parent too
+      const bare = parts.length === 1 && !/[#.\\[]/.test(parts[0])
+      if ((n === 1 && !bare) || parts.length >= 5) break
+    }
+    return parts.join(' > ')
+  }
+  const seen = (el) => {
+    if (el.closest('[data-vos-masked]')) return null
+    const r = el.getBoundingClientRect()
+    if (r.width < 2 || r.height < 2) return null
+    if (r.bottom <= 0 || r.right <= 0 || r.top >= vh || r.left >= vw) return null
+    const s = getComputedStyle(el)
+    if (s.visibility === 'hidden' || s.display === 'none' || +s.opacity === 0) return null
+    return r
+  }
+  const out = [], keys = new Set()
+  const add = (el, text) => {
+    const kinds = kindsIn(text)
+    if (!kinds.length) return
+    const r = seen(el)
+    if (!r) return
+    const selector = name(el)
+    for (const kind of kinds) {
+      const k = kind + '|' + selector
+      if (keys.has(k) || out.length >= 40) continue
+      keys.add(k)
+      out.push({ kind, selector, rect: { x: Math.round(r.left), y: Math.round(r.top), w: Math.round(r.width), h: Math.round(r.height) } })
+    }
+  }
+  const walker = document.createTreeWalker(document.body || document.documentElement, NodeFilter.SHOW_TEXT)
+  for (let n; (n = walker.nextNode()); ) {
+    const el = n.parentElement
+    if (!el || /^(SCRIPT|STYLE|NOSCRIPT|TEMPLATE)$/.test(el.tagName)) continue
+    add(el, n.nodeValue)
+  }
+  for (const el of document.querySelectorAll('input, textarea')) {
+    if (/^(password|hidden|file|checkbox|radio)$/.test(el.type)) continue
+    add(el, el.value)
+  }
+  const hits = {}
+  for (const [sel, n] of Object.entries(window.__vosMaskHits || {})) hits[sel] = n
+  return { exposures: out, maskHits: hits }
+})()`;
+function maskInitScript(masks) {
+  const rules = masks.map((m) => ({
+    selector: m.selector,
+    as: m.as === "text" ? "text" : "blur",
+    text: m.text ?? ""
+  }));
+  return `(() => {
+  const RULES = ${JSON.stringify(rules)}
+  const hits = (window.__vosMaskHits = window.__vosMaskHits || {})
+  for (const r of RULES) hits[r.selector] = hits[r.selector] || 0
+  const css = RULES.map((r) => r.selector + '[data-vos-masked="blur"]{filter:blur(7px) !important;user-select:none !important}').join('\\n')
+  const paint = () => {
+    const root = document.head || document.documentElement
+    if (!root || document.getElementById('__vos-mask-style')) return
+    const style = document.createElement('style')
+    style.id = '__vos-mask-style'
+    style.textContent = css
+    root.appendChild(style)
+  }
+  const apply = () => {
+    paint()
+    for (const r of RULES) {
+      let found
+      try { found = document.querySelectorAll(r.selector) } catch { continue }
+      if (found.length > hits[r.selector]) hits[r.selector] = found.length
+      for (const el of found) {
+        const form = /^(INPUT|TEXTAREA|SELECT)$/.test(el.tagName)
+        const mode = r.as === 'text' && !form ? 'text' : 'blur'
+        if (el.getAttribute('data-vos-masked') !== mode) el.setAttribute('data-vos-masked', mode)
+        if (mode !== 'text') continue
+        const texts = []
+        const w = document.createTreeWalker(el, NodeFilter.SHOW_TEXT)
+        for (let n; (n = w.nextNode()); ) texts.push(n)
+        if (!texts.length) { if (el.textContent !== r.text) el.textContent = r.text; continue }
+        texts.forEach((n, i) => { const want = i === 0 ? r.text : ''; if (n.nodeValue !== want) n.nodeValue = want })
+      }
+    }
+  }
+  new MutationObserver(apply).observe(document, { childList: true, subtree: true, characterData: true })
+  document.addEventListener('DOMContentLoaded', apply)
+  apply()
+})()`;
+}
+var ExposureLog = class {
+  byKey = /* @__PURE__ */ new Map();
+  maskHits = /* @__PURE__ */ new Map();
+  constructor(masks = []) {
+    for (const m of masks) this.maskHits.set(m.selector, 0);
+  }
+  add(step, scan) {
+    if (!scan) return;
+    for (const e of scan.exposures ?? []) {
+      const key = `${e.kind}|${e.selector}`;
+      const had = this.byKey.get(key);
+      if (had) had.seen += 1;
+      else this.byKey.set(key, { step, ...e, seen: 1 });
+    }
+    for (const [sel, n] of Object.entries(scan.maskHits ?? {})) {
+      if (n > (this.maskHits.get(sel) ?? 0)) this.maskHits.set(sel, n);
+    }
+  }
+  exposures() {
+    return [...this.byKey.values()];
+  }
+  masks(rules) {
+    return rules.map((m) => ({
+      selector: m.selector,
+      as: m.as === "text" ? "text" : "blur",
+      hits: this.maskHits.get(m.selector) ?? 0
+    }));
+  }
+};
+var KIND_WORDS = {
+  email: "an email address",
+  key: "something shaped like an API key or token",
+  card: "a card number",
+  "card-tail": "a card's last digits"
+};
+function exposureLine(e) {
+  const when = e.step < 0 ? "as the page opened" : `at step #${e.step}`;
+  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.';
+
+// src/record/setup.ts
+var VERBS = /* @__PURE__ */ new Set(["wait", "click", "type", "press", "goto"]);
+function validateSetup(value) {
+  const errors = [];
+  if (!Array.isArray(value)) return ["setup must be an array of steps"];
+  value.forEach((raw, i) => {
+    const at = `setup[${i}]`;
+    if (typeof raw !== "object" || raw === null) {
+      errors.push(`${at}: must be an object`);
+      return;
+    }
+    const s = raw;
+    if (typeof s.do !== "string" || !VERBS.has(s.do)) {
+      errors.push(`${at}: "do" must be one of ${[...VERBS].join(", ")}`);
+      return;
+    }
+    if ((s.do === "click" || s.do === "type") && 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.do === "press" && typeof s.key !== "string")
+      errors.push(`${at}: press needs a key`);
+    if (s.do === "goto" && typeof s.url !== "string")
+      errors.push(`${at}: goto needs a url`);
+    if (s.do === "type") {
+      const t = s.text;
+      const isEnv = typeof t === "object" && t !== null && typeof t.env === "string" && Object.keys(t).length === 1;
+      if (typeof t !== "string" && !isEnv)
+        errors.push(
+          `${at}: type needs text, a string or { "env": "NAME" } read at run time`
+        );
+      if (typeof t === "string" && /passw|secret|token/i.test(String(s.selector)) && t.length > 0)
+        errors.push(
+          `${at}: a literal value typed into ${String(s.selector)} would live in actions.json, which is committed and pushed. Use { "env": "NAME" }`
+        );
+    }
+  });
+  return errors;
+}
+function setupEnvNames(steps) {
+  const out = /* @__PURE__ */ new Set();
+  for (const s of steps ?? []) {
+    if (s.do === "type" && typeof s.text === "object") out.add(s.text.env);
+  }
+  return [...out];
+}
+function resolveSetupText(t, env) {
+  if (typeof t === "string") return { value: t, secret: false };
+  const v = env[t.env];
+  if (v === void 0 || v === "")
+    throw new SetupEnvError(
+      `setup: the environment variable ${t.env} is not set, and a type step reads it. Export it in the shell that runs vos record; it is never written to a file`
+    );
+  return { value: v, secret: true };
+}
+async function runSetup(page, steps, opts) {
+  const env = opts.env ?? {};
+  const lines = [];
+  for (const [i, step] of steps.entries()) {
+    const settle = "ms" in step && typeof step.ms === "number" ? step.ms : 150;
+    try {
+      switch (step.do) {
+        case "wait":
+          await opts.sleep(step.ms);
+          lines.push(`setup #${i} wait ${step.ms}ms`);
+          break;
+        case "goto":
+          await page.goto(step.url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => null);
+          lines.push(`setup #${i} goto ${step.url}`);
+          break;
+        case "press":
+          await page.keyboard.press(step.key);
+          await opts.sleep(settle);
+          lines.push(`setup #${i} press ${step.key}`);
+          break;
+        case "click": {
+          const loc = page.locator(step.selector).first();
+          await loc.waitFor({ state: "visible", timeout: 8e3 });
+          await loc.click();
+          await opts.sleep(settle);
+          lines.push(`setup #${i} click ${step.selector}`);
+          break;
+        }
+        case "type": {
+          const loc = page.locator(step.selector).first();
+          await loc.waitFor({ state: "visible", timeout: 8e3 });
+          const { value, secret } = resolveSetupText(step.text, env);
+          await loc.fill(value);
+          await opts.sleep(settle);
+          lines.push(
+            `setup #${i} type ${secret ? `\${${step.text.env}}` : `${value.length} chars`} into ${step.selector}`
+          );
+          break;
+        }
+      }
+    } catch (e) {
+      if (e instanceof SetupEnvError) throw e;
+      return {
+        ran: i,
+        lines,
+        failed: {
+          step: i,
+          do: step.do,
+          ..."selector" in step ? { selector: step.selector } : {}
+        }
+      };
+    }
+  }
+  return { ran: steps.length, lines };
+}
+var SetupEnvError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SetupEnvError";
+  }
+};
+var SetupError = class extends Error {
+  constructor(failed) {
+    super(
+      `setup #${failed.step} ${failed.do}${failed.selector ? ` ${failed.selector}` : ""}: the selector never appeared, so the take would begin at a half-finished setup. Nothing was recorded. Fix the setup step (rehearse with --dry-run), then record.`
+    );
+    this.failed = failed;
+    this.name = "SetupError";
+  }
+  failed;
+};
+function parseHeaders(given) {
+  const out = {};
+  for (const h of given ?? []) {
+    const i = h.indexOf("=");
+    if (i <= 0) throw new Error(`--header wants name=value, got "${h}"`);
+    out[h.slice(0, i).trim()] = h.slice(i + 1);
+  }
+  return out;
+}
+
+// src/record/recorder.ts
+var DRY_PAUSE_MS = 120;
+function jpegDims(buf) {
+  const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let i = 2;
+  while (i < buf.length - 9) {
+    if (buf[i] !== 255) return null;
+    const marker = buf[i + 1];
+    const len = view.getUint16(i + 2);
+    if (marker >= 192 && marker <= 207 && marker !== 196 && marker !== 200 && marker !== 204) {
+      return { h: view.getUint16(i + 5), w: view.getUint16(i + 7) };
+    }
+    i += 2 + len;
+  }
+  return null;
+}
+function base64Bytes(data) {
+  const bin = atob(data);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+async function recordTake(browser, url, actions, sink, log, opts = {}) {
+  const dry = opts.dryRun === true;
+  const sleep = dry ? (ms) => realSleep(Math.min(ms, DRY_PAUSE_MS)) : realSleep;
+  const maxSeconds = dry ? Infinity : opts.maxDurationSeconds ?? Infinity;
+  const vw = actions.viewport?.width ?? 1280;
+  const vh = actions.viewport?.height ?? 720;
+  const context = opts.context ?? await browser.newContext({
+    viewport: { width: vw, height: vh },
+    deviceScaleFactor: 1,
+    ...opts.storageState ? { storageState: opts.storageState } : {},
+    ...opts.headers && Object.keys(opts.headers).length ? { extraHTTPHeaders: opts.headers } : {}
+  });
+  if (opts.context && opts.headers && Object.keys(opts.headers).length)
+    await context.setExtraHTTPHeaders(opts.headers);
+  const masks = actions.mask ?? [];
+  if (masks.length) await context.addInitScript(maskInitScript(masks));
+  const exposureLog = new ExposureLog(masks);
+  const page = await context.newPage();
+  const scanExposures = async (step) => {
+    const scan = await page.evaluate(EXPOSURE_PROBE).catch(() => null);
+    exposureLog.add(step, scan);
+  };
+  page.on("console", (m) => {
+    if (m.type() === "error") log(`   [page error] ${m.text()}`);
+  });
+  log(`goto ${url}`);
+  let navTimeout = false;
+  let response = await page.goto(url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => {
+    navTimeout = true;
+    log("   (networkidle timeout \u2014 continuing)");
+    return null;
+  });
+  await sleep(800);
+  const setup = actions.setup ?? [];
+  if (setup.length) {
+    log(`setup: ${setup.length} step(s), off camera`);
+    const result = await runSetup(page, setup, {
+      sleep: realSleep,
+      env: opts.env ?? {}
+    });
+    for (const line of result.lines) log(`   ${line}`);
+    if (result.failed) {
+      await context.close().catch(() => {
+      });
+      throw new SetupError(result.failed);
+    }
+    log(`goto ${url} (after setup)`);
+    response = await page.goto(url, { waitUntil: "networkidle", timeout: 45e3 }).catch(() => null);
+    await sleep(800);
+  }
+  let wall = null;
+  if (opts.onArrival) {
+    const seen = await page.evaluate(WALL_PROBE).catch(() => null);
+    try {
+      wall = await opts.onArrival({
+        askedUrl: url,
+        landedUrl: page.url(),
+        ...response ? { status: response.status() } : {},
+        passwordFields: seen?.passwordFields ?? 0,
+        newPasswordField: seen?.newPasswordField ?? false,
+        oneTimeCodeField: seen?.oneTimeCodeField ?? false
+      }) ?? null;
+    } catch (e) {
+      await context.close().catch(() => {
+      });
+      throw e;
+    }
+  }
+  await scanExposures(-1);
+  const cdp = await context.newCDPSession(page);
+  const frames = [];
+  let frameIdx = 0;
+  let t0 = 0;
+  const first = { dims: null };
+  let sinkChain = Promise.resolve();
+  if (!dry)
+    cdp.on("Page.screencastFrame", (ev) => {
+      const tsMs = ev.metadata.timestamp ? ev.metadata.timestamp * 1e3 : Date.now();
+      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)) });
+      sinkChain = sinkChain.then(() => sink.frame(file, bytes)).catch(() => {
+      });
+      cdp.send("Page.screencastFrameAck", { sessionId: ev.sessionId }).catch(() => {
+      });
+    });
+  t0 = Date.now();
+  if (!dry)
+    await cdp.send("Page.startScreencast", {
+      format: "jpeg",
+      quality: 90,
+      maxWidth: vw,
+      maxHeight: vh,
+      everyNthFrame: 1
+    });
+  const events = [];
+  const cur = { x: 48, y: 48 };
+  const now = () => Date.now() - t0;
+  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" });
+  const clock = { now: () => Date.now(), sleep };
+  const moveTo = async (tx, ty) => {
+    const dist = Math.hypot(tx - cur.x, ty - cur.y);
+    const from = { ...cur };
+    await clockMotion(
+      dry ? 0 : pointerTravelMs(dist),
+      async (u) => {
+        cur.x = from.x + (tx - from.x) * u;
+        cur.y = from.y + (ty - from.y) * u;
+        await page.mouse.move(cur.x, cur.y);
+        emit({ x: Math.round(cur.x), y: Math.round(cur.y), type: "move" });
+      },
+      clock
+    );
+  };
+  const boxOf = async (selector) => {
+    const loc = page.locator(selector).first();
+    try {
+      await loc.waitFor({ state: "visible", timeout: 8e3 });
+      const before = await page.evaluate(() => [window.scrollX, window.scrollY]).catch(() => [0, 0]);
+      await loc.scrollIntoViewIfNeeded();
+      const after = await page.evaluate(() => [window.scrollX, window.scrollY]).catch(() => before);
+      if (before[0] !== after[0] || before[1] !== after[1])
+        await sleep(SCROLL_SETTLE_MS);
+      const bb = await loc.boundingBox();
+      if (!bb) return null;
+      return { x: bb.x, y: bb.y, w: bb.width, h: bb.height };
+    } catch {
+      log(`   (selector not found, skipping: ${selector})`);
+      return null;
+    }
+  };
+  const clickAt = async (rect) => {
+    await moveTo(rect.x + rect.w / 2, rect.y + rect.h / 2);
+    await sleep(PRESS_LEAD_MS);
+    emit({
+      x: Math.round(cur.x),
+      y: Math.round(cur.y),
+      type: "down",
+      button: 0,
+      rect
+    });
+    await page.mouse.down();
+    await sleep(PRESS_HOLD_MS);
+    await page.mouse.up();
+    emit({
+      x: Math.round(cur.x),
+      y: Math.round(cur.y),
+      type: "up",
+      button: 0,
+      rect
+    });
+  };
+  const waitSettled = async () => {
+    if (dry) return null;
+    const pressAt = now();
+    const before = frames.length;
+    for (; ; ) {
+      const t = now();
+      const last = frames.length > before ? frames[frames.length - 1] : null;
+      const sinceChange = last ? t - last.tMs : null;
+      if (settleVerdict({ sincePress: t - pressAt, sinceChange }) === "settled")
+        return sinceChange;
+      await sleep(40);
+    }
+  };
+  const skipped = [];
+  const stepSpans = [];
+  const paces = [];
+  let capped = false;
+  for (const [stepIdx, step] of actions.steps.entries()) {
+    if (capReached(now(), maxSeconds)) {
+      capped = true;
+      break;
+    }
+    const stepStart = now();
+    let gestureMs = 0;
+    const gesture = async (fn) => {
+      const t = now();
+      const out = await fn();
+      gestureMs += now() - t;
+      return out;
+    };
+    const skippedBefore = skipped.length;
+    const urlBefore = page.url();
+    let stepRect = null;
+    switch (step.do) {
+      case "wait":
+        await sleep(clampWait(step.ms, now(), maxSeconds));
+        break;
+      case "move":
+        await moveTo(step.x, step.y);
+        break;
+      case "hover": {
+        const rect = await boxOf(step.selector);
+        stepRect = rect;
+        if (rect) {
+          await gesture(() => moveTo(rect.x + rect.w / 2, rect.y + rect.h / 2));
+          log(`hover ${step.selector}`);
+          await sleep(step.ms ?? 700);
+        } else
+          skipped.push({ step: stepIdx, do: step.do, selector: step.selector });
+        break;
+      }
+      case "click": {
+        const rect = await boxOf(step.selector);
+        stepRect = rect;
+        if (rect) {
+          await gesture(() => clickAt(rect));
+          log(`click ${step.selector}`);
+          const sinceChange = await gesture(() => waitSettled());
+          await sleep(holdLeftMs(settleMs(step), sinceChange));
+        } else
+          skipped.push({ step: stepIdx, do: step.do, selector: step.selector });
+        break;
+      }
+      case "type": {
+        const rect = await boxOf(step.selector);
+        stepRect = rect;
+        if (rect) {
+          if (step.focus !== false) await gesture(() => clickAt(rect));
+          const delay = step.delayMs ?? 40;
+          const ping = () => emit({
+            x: Math.round(rect.x + rect.w / 2),
+            y: Math.round(rect.y + rect.h / 2),
+            type: "key",
+            rect
+          });
+          let lastPing = -Infinity;
+          await clockTyping(
+            [...step.text],
+            delay,
+            async (ch) => {
+              if (now() - lastPing >= 350) {
+                lastPing = now();
+                ping();
+              }
+              await page.keyboard.type(ch);
+            },
+            clock
+          );
+          ping();
+          log(`type "${step.text}" into ${step.selector}`);
+          await gesture(() => sleep(settleMs(step)));
+        } else
+          skipped.push({ step: stepIdx, do: step.do, selector: step.selector });
+        break;
+      }
+      case "scroll": {
+        const total = Math.abs(step.dy);
+        const dir = Math.sign(step.dy);
+        for (let done = 0; done < total; done += 120) {
+          await page.mouse.wheel(0, dir * Math.min(120, total - done));
+          emit({ x: Math.round(cur.x), y: Math.round(cur.y), type: "scroll" });
+          await sleep(40);
+        }
+        await gesture(() => sleep(settleMs(step)));
+        break;
+      }
+      case "drag": {
+        let start = null;
+        let rect;
+        if (step.selector) {
+          const box = await boxOf(step.selector);
+          stepRect = box;
+          if (box) {
+            rect = box;
+            start = { x: box.x + box.w / 2, y: box.y + box.h / 2 };
+          } else {
+            skipped.push({
+              step: stepIdx,
+              do: step.do,
+              selector: step.selector
+            });
+            break;
+          }
+        } else if (typeof step.x === "number" && typeof step.y === "number") {
+          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
+        );
+        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
+        });
+        log(
+          `drag ${step.selector ?? `${start.x},${start.y}`} \u2192 ${step.tx},${step.ty}`
+        );
+        await sleep(400);
+        break;
+      }
+    }
+    const stepInfo = step;
+    stepSpans.push({
+      step: stepIdx,
+      ...stepInfo.id ? { id: stepInfo.id } : {},
+      do: step.do,
+      ...stepInfo.selector ? { selector: stepInfo.selector } : {},
+      tStart: +(stepStart / 1e3).toFixed(3),
+      tEnd: +(now() / 1e3).toFixed(3),
+      ...skipped.length > skippedBefore ? { skipped: true } : {},
+      ...page.url() !== urlBefore ? { navigated: true } : {},
+      ...stepRect ? {
+        rect: {
+          x: +stepRect.x.toFixed(1),
+          y: +stepRect.y.toFixed(1),
+          w: +stepRect.w.toFixed(1),
+          h: +stepRect.h.toFixed(1)
+        }
+      } : {}
+    });
+    paces.push({
+      step: stepIdx,
+      do: step.do,
+      askedMs: askedMs(step),
+      gestureMs,
+      wallMs: now() - stepStart
+    });
+    await scanExposures(stepIdx);
+  }
+  if (!capped) await sleep(TRAILING_HOLD_MS);
+  if (capped || capReached(now(), maxSeconds)) {
+    capped = true;
+    log(`   ${cappedLine(maxSeconds)}`);
+  }
+  const durationMs = capped ? Math.min(now(), maxSeconds * 1e3) : now();
+  await cdp.send("Page.stopScreencast").catch(() => {
+  });
+  await sleep(200);
+  const pageTitle = await page.title().catch(() => "");
+  await context.close();
+  await sinkChain;
+  const meta = {
+    dpr: 1,
+    zoom: 1,
+    t0,
+    durationMs,
+    width: vw,
+    height: vh,
+    fps: 30,
+    hasAudio: false,
+    captureWidth: first.dims?.w ?? vw,
+    captureHeight: first.dims?.h ?? vh,
+    captureSurface: "tab",
+    pageUrl: url,
+    pageTitle,
+    platform: opts.platform ?? "linux",
+    producer: "cli",
+    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) } : {}
+  };
+  const freezes = [];
+  for (let i = 1; i < frames.length; i++) {
+    const gap = frames[i].tMs - frames[i - 1].tMs;
+    if (gap >= 400) {
+      freezes.push({
+        from: +(frames[i - 1].tMs / 1e3).toFixed(2),
+        to: +(frames[i].tMs / 1e3).toFixed(2),
+        ms: gap
+      });
+    }
+  }
+  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)}`);
+  const pace = paceReport(paces);
+  if (!dry) log(`   ${paceLine(pace)}`);
+  return {
+    events,
+    frames,
+    meta,
+    pace,
+    skipped,
+    navTimeout,
+    wall,
+    exposures: exposureLog.exposures(),
+    masks: exposureLog.masks(masks),
+    freezes,
+    freezePct,
+    dead,
+    capped,
+    actions: { ...actions, url }
+  };
+}
+
+// src/record/actions.ts
+var VERBS2 = /* @__PURE__ */ new Set([
+  "wait",
+  "hover",
+  "click",
+  "type",
+  "scroll",
+  "move",
+  "drag"
+]);
+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 && typeof obj.url !== "string")
+    errors.push("url must be a string");
+  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 (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 === "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;
+}
+
+// src/record/encodePage.ts
+var MEDIABUNNY_URL = "https://esm.sh/mediabunny@1.55.7?target=es2022";
+function buildEncodePage(o) {
+  const q = o.frameQuery ? `?${o.frameQuery}` : "";
+  return `<!doctype html><html><head><meta charset="utf-8"></head><body>
+<script type="module">
+try {
+  const MB = await import('${MEDIABUNNY_URL}')
+  const frames = await (await fetch(${JSON.stringify(o.framesIndexUrl)})).json()
+  const meta = await (await fetch(${JSON.stringify(o.metaUrl)})).json()
+  const W = meta.captureWidth ?? meta.width, H = meta.captureHeight ?? meta.height
+  const FPS = 30
+  const durSec = meta.durationMs / 1000
+  const cv = document.createElement('canvas')
+  cv.width = W; cv.height = H
+  const c2 = cv.getContext('2d')
+  const output = new MB.Output({ format: new MB.WebMOutputFormat(), target: new MB.BufferTarget() })
+  const src = new MB.CanvasSource(cv, { codec: 'vp9', bitrate: 8_000_000 })
+  output.addVideoTrack(src, { frameRate: FPS })
+  await output.start()
+  let fi = -1
+  const total = Math.ceil(durSec * FPS)
+  for (let i = 0; i < total; i++) {
+    const t = i / FPS
+    let next = fi
+    while (next + 1 < frames.length && frames[next + 1].tMs <= t * 1000) next++
+    if (next < 0) next = 0
+    if (next !== fi) {
+      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)
+      bmp.close()
+    }
+    await src.add(t, 1 / FPS)
+    window.__progress = i / total
+  }
+  await output.finalize()
+  const buf = output.target.buffer
+  const res = await fetch(${JSON.stringify(o.save.url)}, { method: ${JSON.stringify(o.save.method)}, headers: { 'content-type': 'video/webm' }, body: buf })
+  if (!res.ok) throw new Error('save failed: ' + res.status)
+  // Two hosts, two completion words: the CLI's take server polls __done,
+  // the fleet's page runner polls __renderComplete.
+  window.__done = { ok: true, bytes: buf.byteLength }
+  window.__renderComplete = { success: true, size: buf.byteLength, uploaded: true }
+} catch (e) {
+  window.__error = String(e && e.stack || e)
+  window.__renderComplete = { success: false, error: String(e && e.message || e) }
+}
+</script></body></html>`;
+}
+
+// src/record/plan.ts
+import {
+  DEFAULT_FRAME_STYLE,
+  planAutoSpeed,
+  planAutoZoom,
+  projectFromArtifact,
+  withBackdrop
+} from "@vosjs/studio-core";
+function planFreshTake(artifact, recordingName, opts = {}) {
+  const ingest = opts.backdrop ? { frame: withBackdrop(DEFAULT_FRAME_STYLE, opts.backdrop) } : {};
+  const doc = projectFromArtifact(artifact, recordingName, ingest).doc;
+  doc.zoom = planAutoZoom(doc.source.cursor, {
+    width: doc.source.meta.width,
+    height: doc.source.meta.height,
+    duration: doc.source.meta.durationMs / 1e3,
+    style: doc.zoomStyle,
+    params: doc.zoomParams
+  });
+  doc.speed = planAutoSpeed(doc.source.cursor, {
+    durationMs: doc.source.meta.durationMs,
+    params: doc.speedParams,
+    activity: opts.activity
+  });
+  return doc;
+}
+export {
+  DEAD_SHARE_WARN_PCT,
+  DEAD_STRETCH_WARN_MS,
+  EXPOSURE_ADVICE,
+  EXPOSURE_MATCHERS_SRC,
+  EXPOSURE_PROBE,
+  ExposureLog,
+  MOTION_TICK_MS,
+  POINTER_MAX_MS,
+  POINTER_MIN_MS,
+  POINTER_MS_PER_PX,
+  PRESS_HOLD_MS,
+  PRESS_LEAD_MS,
+  QUIET_MS,
+  READ_BEAT_MS,
+  RESPONSE_MS,
+  SCROLL_SETTLE_MS,
+  SETTLE_CAP_MS,
+  SETTLE_MS,
+  SetupEnvError,
+  SetupError,
+  TRAILING_HOLD_MS,
+  WALL_PROBE,
+  WallError,
+  askedMs,
+  base64Bytes,
+  buildEncodePage,
+  capReached,
+  cappedLine,
+  clampWait,
+  clockMotion,
+  clockTyping,
+  deadLine,
+  deadTime,
+  deadWarns,
+  easeInOutCubic,
+  exposureLine,
+  formatDurationCap,
+  holdLeftMs,
+  isIdpHost,
+  isSignInPath,
+  jpegDims,
+  maskInitScript,
+  paceLine,
+  paceReport,
+  parseHeaders,
+  planFreshTake,
+  pointerTravelMs,
+  realSleep,
+  recordTake,
+  redirectedAway,
+  resolveSetupText,
+  runSetup,
+  settleMs,
+  settleVerdict,
+  setupEnvNames,
+  validateActions,
+  validateSetup,
+  wallVerdict
+};
+//# sourceMappingURL=index.js.map