@vosjs/studio-core 0.30.3 → 0.31.1

package/dist/index.js

@@ -665,6 +665,527 @@ function projectFromArtifact(artifact, videoUrl, opts = {}) {
   return { doc, videoUrl };
 }
 
+// src/ingest/traces.ts
+var CLICK_HOLD_MS = 40;
+function traceKindOf(name) {
+  const m = /\.([a-z0-9]+)$/i.exec(name);
+  const ext = m ? m[1].toLowerCase() : "";
+  if (ext === "zip") return "zip";
+  if (ext === "csv") return "csv";
+  if (ext === "jsonl" || ext === "ndjson") return "jsonl";
+  if (ext === "json") return "json";
+  if (ext === "trace") return "trace";
+  return null;
+}
+function cursorFromTrace(name, text, opts = {}) {
+  const kind = traceKindOf(name);
+  if (kind === "csv") return cursorFromCsv(text, opts);
+  if (kind === "trace" || looksLikePlaywright(text))
+    return cursorFromPlaywrightTrace(text, opts);
+  return cursorFromRecords(text, opts);
+}
+function looksLikePlaywright(text) {
+  const head = text.slice(0, 4e3);
+  return head.includes('"type":"context-options"') || head.includes('"type":"before"') && head.includes('"callId"');
+}
+function sortEvents(events) {
+  return events.map((e, i) => ({ e, i })).sort((a, b) => a.e.t - b.e.t || a.i - b.i).map((x) => x.e);
+}
+function round(n) {
+  return Math.round(n * 1e3) / 1e3;
+}
+var PW_PRESS = /* @__PURE__ */ new Set([
+  "click",
+  "dblclick",
+  "tap",
+  "check",
+  "uncheck",
+  "setChecked",
+  "selectOption"
+]);
+var PW_TYPE = /* @__PURE__ */ new Set(["fill", "type", "press", "pressSequentially"]);
+function cursorFromPlaywrightTrace(text, opts = {}) {
+  const befores = [];
+  const afters = /* @__PURE__ */ new Map();
+  const inputs = /* @__PURE__ */ new Map();
+  let viewport;
+  let wallTime;
+  let monotonicAtOptions;
+  for (const line of text.split("\n")) {
+    if (!line.trim()) continue;
+    let ev;
+    try {
+      ev = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const type = ev.type;
+    if (type === "context-options") {
+      const o = ev.options;
+      const v = o?.viewport;
+      if (v && typeof v.width === "number" && typeof v.height === "number")
+        viewport = { width: v.width, height: v.height };
+      if (typeof ev.wallTime === "number") wallTime = ev.wallTime;
+      if (typeof ev.monotonicTime === "number")
+        monotonicAtOptions = ev.monotonicTime;
+    } else if (type === "before" && typeof ev.startTime === "number") {
+      befores.push({
+        callId: String(ev.callId),
+        startTime: ev.startTime,
+        class: typeof ev.class === "string" ? ev.class : void 0,
+        method: typeof ev.method === "string" ? ev.method : void 0,
+        params: ev.params && typeof ev.params === "object" ? ev.params : void 0
+      });
+    } else if (type === "after") {
+      afters.set(String(ev.callId), {
+        endTime: typeof ev.endTime === "number" ? ev.endTime : void 0,
+        point: asPoint(ev.point)
+      });
+    } else if (type === "input") {
+      const p = asPoint(ev.point);
+      if (p) inputs.set(String(ev.callId), p);
+    }
+  }
+  const notes = [];
+  if (befores.length === 0) {
+    return {
+      events: [],
+      notes: ['not a Playwright trace: no "before" events with a startTime'],
+      viewport,
+      kind: "playwright",
+      placed: 0,
+      dropped: 0
+    };
+  }
+  const newPage = befores.find((b) => b.method === "newPage");
+  const origin = newPage?.startTime ?? monotonicAtOptions ?? befores[0].startTime;
+  const offset = opts.offsetMs ?? 0;
+  const t0 = wallTime !== void 0 && monotonicAtOptions !== void 0 ? Math.round(wallTime + (origin - monotonicAtOptions) - offset) : void 0;
+  const at = (ms) => round(ms - origin + offset);
+  const events = [];
+  const cur = { pos: null };
+  let placed = 0;
+  let dropped = 0;
+  const move2 = (t, p) => {
+    if (!cur.pos || cur.pos.x !== p.x || cur.pos.y !== p.y) {
+      events.push({ t, x: p.x, y: p.y, type: "move" });
+    }
+    cur.pos = p;
+  };
+  const press = (start, end, p, times = 1) => {
+    move2(start, p);
+    let downAt = Math.max(start, end - CLICK_HOLD_MS);
+    for (let i = 0; i < times; i++) {
+      events.push({ t: round(downAt), x: p.x, y: p.y, type: "down", button: 0 });
+      events.push({
+        t: round(downAt + CLICK_HOLD_MS),
+        x: p.x,
+        y: p.y,
+        type: "up",
+        button: 0
+      });
+      downAt += CLICK_HOLD_MS * 2;
+    }
+  };
+  for (const b of befores) {
+    const after = afters.get(b.callId);
+    const end = after?.endTime ?? b.startTime;
+    const point = after?.point ?? inputs.get(b.callId);
+    const method = b.method ?? "";
+    const cls = b.class ?? "";
+    const start = at(b.startTime);
+    const label = `${cls}.${method}`;
+    if (cls === "Page" && method === "mouseMove") {
+      const p = asPoint(b.params);
+      if (!p) {
+        notes.push(`${label} at ${start}ms has no x/y`);
+        dropped++;
+        continue;
+      }
+      move2(start, p);
+      placed++;
+    } else if (cls === "Page" && method === "mouseClick") {
+      const p = asPoint(b.params) ?? point;
+      if (!p) {
+        notes.push(`${label} at ${start}ms has no x/y`);
+        dropped++;
+        continue;
+      }
+      press(start, at(end), p, clickCount(b.params));
+      placed++;
+    } else if (cls === "Page" && (method === "mouseDown" || method === "mouseUp")) {
+      if (!cur.pos) {
+        notes.push(`${label} at ${start}ms before any pointer position`);
+        dropped++;
+        continue;
+      }
+      events.push({
+        t: start,
+        x: cur.pos.x,
+        y: cur.pos.y,
+        type: method === "mouseDown" ? "down" : "up",
+        button: 0
+      });
+      placed++;
+    } else if (cls === "Page" && method === "mouseWheel") {
+      if (!cur.pos) {
+        notes.push(`${label} at ${start}ms before any pointer position`);
+        dropped++;
+        continue;
+      }
+      events.push({ t: start, x: cur.pos.x, y: cur.pos.y, type: "scroll" });
+      placed++;
+    } else if (cls === "Frame" && method === "hover") {
+      if (!point) {
+        notes.push(
+          `${label} ${selectorOf(b)} at ${start}ms landed nowhere the trace recorded`
+        );
+        dropped++;
+        continue;
+      }
+      move2(start, point);
+      placed++;
+    } else if (cls === "Frame" && PW_PRESS.has(method)) {
+      if (!point) {
+        notes.push(
+          `${label} ${selectorOf(b)} at ${start}ms landed nowhere the trace recorded`
+        );
+        dropped++;
+        continue;
+      }
+      press(start, at(end), point, method === "dblclick" ? 2 : 1);
+      placed++;
+    } else if (cls === "Frame" && PW_TYPE.has(method)) {
+      if (!point && !cur.pos) {
+        notes.push(
+          `${label} ${selectorOf(b)} at ${start}ms typed into a field the trace never placed`
+        );
+        dropped++;
+        continue;
+      }
+      const p = point ?? cur.pos;
+      events.push({ t: start, x: p.x, y: p.y, type: "key" });
+      placed++;
+    } else if (cls === "Frame" && method === "dragAndDrop") {
+      notes.push(
+        `${label} at ${start}ms: a drag has two points the trace records as one; not placed`
+      );
+      dropped++;
+    }
+  }
+  const negative = events.filter((e) => e.t < 0).length;
+  if (negative)
+    notes.push(`${negative} event(s) before the video's start were dropped`);
+  return {
+    events: sortEvents(events.filter((e) => e.t >= 0)),
+    notes,
+    viewport,
+    t0,
+    kind: "playwright",
+    placed,
+    dropped
+  };
+}
+function asPoint(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const o = v;
+  return typeof o.x === "number" && typeof o.y === "number" ? { x: o.x, y: o.y } : void 0;
+}
+function clickCount(params) {
+  const n = params?.clickCount;
+  return typeof n === "number" && n > 1 ? Math.min(3, Math.floor(n)) : 1;
+}
+function selectorOf(b) {
+  const s = b.params?.selector;
+  return typeof s === "string" ? s : "";
+}
+var CSV_TYPES = /* @__PURE__ */ new Set(["move", "down", "up", "click", "scroll"]);
+function cursorFromCsv(text, opts = {}) {
+  const notes = [];
+  const events = [];
+  const offset = opts.offsetMs ?? 0;
+  let placed = 0;
+  let dropped = 0;
+  const lines = text.split(/\r?\n/);
+  let cols = ["t", "x", "y", "type"];
+  let start = 0;
+  const first = (lines[0] ?? "").split(",").map((c) => c.trim().toLowerCase());
+  if (first.length >= 3 && first.some((c) => c !== "" && Number.isNaN(Number(c)))) {
+    cols = first;
+    start = 1;
+  }
+  const ti = cols.indexOf("t");
+  const xi = cols.indexOf("x");
+  const yi = cols.indexOf("y");
+  const ki = cols.indexOf("type");
+  if (ti < 0 || xi < 0 || yi < 0) {
+    return {
+      events: [],
+      notes: [
+        "the CSV needs t, x and y columns (a header row names them; without one the order is t,x,y,type)"
+      ],
+      kind: "csv",
+      placed: 0,
+      dropped: 0
+    };
+  }
+  for (let i = start; i < lines.length; i++) {
+    const raw = lines[i];
+    if (!raw.trim()) continue;
+    const cells = raw.split(",").map((c) => c.trim());
+    const t = Number(cells[ti]);
+    const x = Number(cells[xi]);
+    const y = Number(cells[yi]);
+    const type = (ki >= 0 ? cells[ki] : "") || "move";
+    if (![t, x, y].every(Number.isFinite)) {
+      notes.push(`line ${i + 1}: t, x and y must be numbers`);
+      dropped++;
+      continue;
+    }
+    if (!CSV_TYPES.has(type)) {
+      notes.push(
+        `line ${i + 1}: unknown type "${type}" (move, down, up, click, scroll)`
+      );
+      dropped++;
+      continue;
+    }
+    const at = round(t + offset);
+    if (type === "click") {
+      events.push({ t: at, x, y, type: "move" });
+      events.push({ t: at, x, y, type: "down", button: 0 });
+      events.push({ t: round(at + CLICK_HOLD_MS), x, y, type: "up", button: 0 });
+    } else if (type === "down" || type === "up") {
+      events.push({ t: at, x, y, type, button: 0 });
+    } else {
+      events.push({ t: at, x, y, type });
+    }
+    placed++;
+  }
+  return { events: sortEvents(events), notes, kind: "csv", placed, dropped };
+}
+var RECORD_TYPES = {
+  move: "move",
+  hover: "move",
+  down: "down",
+  mousedown: "down",
+  up: "up",
+  mouseup: "up",
+  click: "click",
+  press: "click",
+  scroll: "scroll",
+  wheel: "scroll",
+  key: "key",
+  type: "key",
+  fill: "key",
+  focus: "focus"
+};
+function cursorFromRecords(input, opts = {}) {
+  const notes = [];
+  const events = [];
+  const offset = opts.offsetMs ?? 0;
+  let placed = 0;
+  let dropped = 0;
+  let records;
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (trimmed.startsWith("[")) {
+      try {
+        records = JSON.parse(trimmed);
+      } catch {
+        return {
+          events: [],
+          notes: ["not JSON: the records file could not be parsed"],
+          kind: "records",
+          placed: 0,
+          dropped: 0
+        };
+      }
+    } else {
+      records = [];
+      let n = 0;
+      for (const line of trimmed.split("\n")) {
+        n++;
+        if (!line.trim()) continue;
+        try {
+          records.push(JSON.parse(line));
+        } catch {
+          notes.push(`line ${n}: not JSON`);
+          dropped++;
+        }
+      }
+    }
+  } else records = input;
+  let epochZero = null;
+  let sawNoTime = 0;
+  let sawNoPoint = 0;
+  records.forEach((r, i) => {
+    if (!r || typeof r !== "object") {
+      notes.push(`record ${i + 1}: not an object`);
+      dropped++;
+      return;
+    }
+    const o = r;
+    let t = numberOf(o.t ?? o.ts ?? o.time ?? o.timestamp);
+    if (t !== void 0 && t > 1e12) {
+      if (epochZero === null) epochZero = t;
+      t -= epochZero;
+    }
+    const kind = recordKind(o);
+    if (!kind) return;
+    const p = asPoint(o) ?? asPoint(o.point) ?? centerOf(o.rect);
+    if (t === void 0) {
+      sawNoTime++;
+      dropped++;
+      return;
+    }
+    if (!p) {
+      sawNoPoint++;
+      dropped++;
+      return;
+    }
+    const at = round(t + offset);
+    const rect = asRect(o.rect);
+    if (kind === "click") {
+      events.push({ t: at, x: p.x, y: p.y, type: "move" });
+      events.push({
+        t: at,
+        x: p.x,
+        y: p.y,
+        type: "down",
+        button: 0,
+        ...rect ? { rect } : {}
+      });
+      events.push({
+        t: round(at + CLICK_HOLD_MS),
+        x: p.x,
+        y: p.y,
+        type: "up",
+        button: 0
+      });
+    } else if (kind === "down" || kind === "up") {
+      events.push({
+        t: at,
+        x: p.x,
+        y: p.y,
+        type: kind,
+        button: 0,
+        ...rect ? { rect } : {}
+      });
+    } else {
+      events.push({
+        t: at,
+        x: p.x,
+        y: p.y,
+        type: kind,
+        ...rect ? { rect } : {}
+      });
+    }
+    placed++;
+  });
+  if (sawNoTime)
+    notes.push(
+      `${sawNoTime} gesture record(s) carry no time (t, ts or time, in ms), so they cannot meet the video; agent-browser's own log has none, so stamp one per command when you keep it`
+    );
+  if (sawNoPoint)
+    notes.push(
+      `${sawNoPoint} gesture record(s) carry no point (x/y, point, or rect); a ref alone says which element, not where it was`
+    );
+  return { events: sortEvents(events), notes, kind: "records", placed, dropped };
+}
+function recordKind(o) {
+  const explicit = typeof o.type === "string" ? o.type.toLowerCase() : "";
+  if (explicit && explicit in RECORD_TYPES) return RECORD_TYPES[explicit];
+  const cmd = commandWords(o.command ?? o.action ?? o.kind);
+  const verb = cmd[0] === "mouse" ? `${cmd[0]}${cmd[1] ?? ""}` : cmd[0];
+  if (!verb) return null;
+  const key = verb.toLowerCase();
+  if (key in RECORD_TYPES) return RECORD_TYPES[key];
+  if (key === "mousemove") return "move";
+  if (key === "mouseclick") return "click";
+  if (key === "mousedown") return "down";
+  if (key === "mouseup") return "up";
+  if (key === "dblclick") return "click";
+  return null;
+}
+function commandWords(v) {
+  if (Array.isArray(v)) return v.map(String);
+  if (typeof v === "string") return v.trim().split(/\s+/);
+  return [];
+}
+function numberOf(v) {
+  if (typeof v === "number" && Number.isFinite(v)) return v;
+  if (typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v)))
+    return Number(v);
+  return void 0;
+}
+function asRect(v) {
+  if (!v || typeof v !== "object") return void 0;
+  const o = v;
+  const x = numberOf(o.x);
+  const y = numberOf(o.y);
+  const w = numberOf(o.w ?? o.width);
+  const h = numberOf(o.h ?? o.height);
+  return x !== void 0 && y !== void 0 && w !== void 0 && h !== void 0 ? { x, y, w, h } : void 0;
+}
+function centerOf(v) {
+  const r = asRect(v);
+  return r ? { x: r.x + r.w / 2, y: r.y + r.h / 2 } : void 0;
+}
+
+// src/ingest/zip.ts
+var EOCD = 101010256;
+var CENTRAL = 33639248;
+var LOCAL = 67324752;
+function zipEntries(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  let eocd = -1;
+  for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 22 - 65535); i--) {
+    if (view.getUint32(i, true) === EOCD) {
+      eocd = i;
+      break;
+    }
+  }
+  if (eocd < 0) throw new Error("not a zip: no end-of-central-directory record");
+  const count = view.getUint16(eocd + 10, true);
+  let p = view.getUint32(eocd + 16, true);
+  const entries = [];
+  const decoder = new TextDecoder();
+  for (let i = 0; i < count; i++) {
+    if (view.getUint32(p, true) !== CENTRAL)
+      throw new Error("not a zip: central directory entry expected");
+    const method = view.getUint16(p + 10, true);
+    const compressedSize = view.getUint32(p + 20, true);
+    const size = view.getUint32(p + 24, true);
+    const nameLen = view.getUint16(p + 28, true);
+    const extraLen = view.getUint16(p + 30, true);
+    const commentLen = view.getUint16(p + 32, true);
+    const local = view.getUint32(p + 42, true);
+    const name = decoder.decode(bytes.subarray(p + 46, p + 46 + nameLen));
+    if (view.getUint32(local, true) !== LOCAL)
+      throw new Error(`not a zip: local header expected for ${name}`);
+    const localNameLen = view.getUint16(local + 26, true);
+    const localExtraLen = view.getUint16(local + 28, true);
+    entries.push({
+      name,
+      method,
+      compressedSize,
+      size,
+      dataOffset: local + 30 + localNameLen + localExtraLen
+    });
+    p += 46 + nameLen + extraLen + commentLen;
+  }
+  return entries;
+}
+function zipEntryBytes(bytes, entry) {
+  return bytes.subarray(
+    entry.dataOffset,
+    entry.dataOffset + entry.compressedSize
+  );
+}
+function playwrightTraceEntry(entries) {
+  return entries.find((e) => e.name === "trace.trace") ?? entries.find((e) => /(^|\/)trace\.trace$/.test(e.name)) ?? null;
+}
+
 // src/lower/motion.ts
 import { sortKeyframes } from "@vosjs/timeline";
 
@@ -1752,7 +2273,7 @@ function planAutoZoom(track, options) {
     typingMinLevel = style.typingMinLevel,
     duration
   } = options;
-  const within = (spans2) => duration === void 0 ? spans2 : spans2.map((z) => ({ ...z, out: Math.min(z.out, round(duration)) })).filter((z) => z.out - z.in >= 0.3);
+  const within = (spans2) => duration === void 0 ? spans2 : spans2.map((z) => ({ ...z, out: Math.min(z.out, round2(duration)) })).filter((z) => z.out - z.in >= 0.3);
   const grouped = groupTrack(track, {
     width,
     height,
@@ -1764,17 +2285,17 @@ function planAutoZoom(track, options) {
   });
   const { sessions } = grouped;
   const drags = dragsFromTrack(track, width, height);
-  const dragPress = new Set(drags.map((d) => round(d.t0)));
-  const withoutDrags = (list) => list.map((cl) => cl.filter((c) => !dragPress.has(round(c.t)))).filter((cl) => cl.length > 0);
+  const dragPress = new Set(drags.map((d) => round2(d.t0)));
+  const withoutDrags = (list) => list.map((cl) => cl.filter((c) => !dragPress.has(round2(c.t)))).filter((cl) => cl.length > 0);
   const clusters = withoutDrags(grouped.clusters);
   const surfaces = withoutDrags(grouped.surfaces);
   const dragSpans = drags.map((d, i) => ({
     id: `g${i}`,
-    in: round(Math.max(0, d.t0 - lead)),
-    out: round(d.t1 + hold),
+    in: round2(Math.max(0, d.t0 - lead)),
+    out: round2(d.t1 + hold),
     level: clampZoomLevel(Math.min(Math.max(dragLevel, 1.1), maxLevel)),
-    cx: round(d.nx),
-    cy: round(d.ny),
+    cx: round2(d.nx),
+    cy: round2(d.ny),
     focusMode: "auto",
     source: "auto"
   }));
@@ -1851,11 +2372,11 @@ function planAutoZoom(track, options) {
   typing = typing.filter((t) => t.out - t.in >= 0.3);
   const zSpans = clickSpans.filter((s) => !s.dead).sort((a, b) => a.in - b.in).map((s, i) => ({
     id: `z${i}`,
-    in: round(s.in),
-    out: round(s.out),
+    in: round2(s.in),
+    out: round2(s.out),
     level: clampZoomLevel(s.level),
-    cx: round(s.cx),
-    cy: round(s.cy),
+    cx: round2(s.cx),
+    cy: round2(s.cy),
     // Follow styles ride the cursor through the span (entry + dead-zone
     // recenters baked at lowering); typing/dwell spans stay fixed-focus.
     ...followByDefault ? { focusMode: "auto" } : {},
@@ -1863,11 +2384,11 @@ function planAutoZoom(track, options) {
   }));
   const kSpans = typing.map((s, i) => ({
     id: `k${i}`,
-    in: round(s.in),
-    out: round(s.out),
+    in: round2(s.in),
+    out: round2(s.out),
     level: clampZoomLevel(s.level),
-    cx: round(s.cx),
-    cy: round(s.cy),
+    cx: round2(s.cx),
+    cy: round2(s.cy),
     // Never focusMode:'auto': the dot is parked (and fading) while typing —
     // the FIELD is the anchor, and a follow would be a no-op at best.
     source: "auto"
@@ -1944,12 +2465,12 @@ function dwellSpans(track, width, height, maxLevel, reserved) {
     if (taken.some((z) => spanIn < z.out && spanOut > z.in)) continue;
     const span = {
       id: `d${accepted.length}`,
-      in: round(spanIn),
-      out: round(spanOut),
+      in: round2(spanIn),
+      out: round2(spanOut),
       // No element rect on moves → point zoom at the planner ceiling.
       level: clampZoomLevel(maxLevel),
-      cx: round(clamp012(c.cx)),
-      cy: round(clamp012(c.cy)),
+      cx: round2(clamp012(c.cx)),
+      cy: round2(clamp012(c.cy)),
       source: "auto"
     };
     accepted.push(span);
@@ -2018,7 +2539,7 @@ function clamp3(v, lo, hi) {
 function clamp012(v) {
   return clamp3(v, 0, 1);
 }
-function round(v) {
+function round2(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -2858,14 +3379,14 @@ function resolveOverlayFx(clip, clipDuration) {
     const maxTotal = Math.max(dur, clipDuration * 0.9);
     st = Math.min(st, Math.max(0, (maxTotal - dur) / (upperN - 1)));
   }
-  const round13 = (v) => Math.round(v * 1e4) / 1e4;
+  const round14 = (v) => Math.round(v * 1e4) / 1e4;
   return {
     k: spec.fx,
     u: unit,
     d: FX_DIR[spec.direction ?? "forward"] ?? 0,
-    st: round13(st),
-    dur: round13(dur),
-    tt: round13(st * (upperN - 1) + dur),
+    st: round14(st),
+    dur: round14(dur),
+    tt: round14(st * (upperN - 1) + dur),
     units,
     n
   };
@@ -3199,10 +3720,10 @@ function followFocusEvents(span, cursor, space, layout, options = {}) {
         camera
       );
       pathEvents.push({
-        t: round2(at),
+        t: round4(at),
         path: true,
-        cx: round2(f.cx),
-        cy: round2(f.cy)
+        cx: round4(f.cx),
+        cy: round4(f.cy)
       });
       if (at >= to) break;
     }
@@ -3226,7 +3747,7 @@ function followFocusEvents(span, cursor, space, layout, options = {}) {
       const target = lookahead > 0 ? sampleAt2(pts, Math.min(p.t + lookahead, span.out)) : p;
       const f = clampFocus(target.nx, target.ny, level, layout, camera);
       if (Math.abs(f.cx - cx) < 1e-3 && Math.abs(f.cy - cy) < 1e-3) continue;
-      events.push({ t: round2(p.t), cx: round2(f.cx), cy: round2(f.cy) });
+      events.push({ t: round4(p.t), cx: round4(f.cx), cy: round4(f.cy) });
       cx = f.cx;
       cy = f.cy;
       nextAllowed = p.t + recenter;
@@ -3250,7 +3771,7 @@ function sampleAt2(pts, t) {
 function clamp014(v) {
   return Math.max(0, Math.min(1, v));
 }
-function round2(v) {
+function round4(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -3540,7 +4061,7 @@ function pinPlacement(input) {
     side,
     track: { keyframes: simplify(poses, [W, H, 1, 1, 1]) },
     tip: { keyframes: simplify(tips, [W, H]) },
-    clamped: round4(clamped),
+    clamped: round5(clamped),
     box
   };
 }
@@ -3569,13 +4090,13 @@ function simplify(keys, scalePx) {
     }
   }
   const last = keys[keys.length - 1];
-  if (out[out.length - 1].t !== round4(last.t)) out.push(roundKey(last));
+  if (out[out.length - 1].t !== round5(last.t)) out.push(roundKey(last));
   return out;
 }
 function roundKey(k) {
-  return { t: round4(k.t), value: k.value.map(round42), ease: k.ease };
+  return { t: round5(k.t), value: k.value.map(round42), ease: k.ease };
 }
-function round4(v) {
+function round5(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 function round42(v) {
@@ -3587,7 +4108,7 @@ var CURSOR_IDLE_HOLD = 1;
 var CURSOR_IDLE_FADE_OUT = 0.35;
 var CURSOR_IDLE_FADE_IN = 0.18;
 var CURSOR_IDLE_EPS_FRAC = 25e-4;
-var round5 = (n) => Math.round(n * 1e3) / 1e3;
+var round6 = (n) => Math.round(n * 1e3) / 1e3;
 function cursorIdleFade(track, o) {
   const moves = track.filter((e) => e.type === "move" || e.type === "down" || e.type === "up").map((e) => ({ t: e.t / 1e3, x: e.x, y: e.y }));
   if (moves.length === 0) return [];
@@ -3639,7 +4160,7 @@ function emit(keys, s, e) {
   push(keys, e + CURSOR_IDLE_FADE_IN, 1);
 }
 function push(keys, t, a) {
-  const rt = round5(t);
+  const rt = round6(t);
   if (keys.length > 0 && rt <= keys[keys.length - 1].t) {
     keys[keys.length - 1].a = a;
     return;
@@ -5147,7 +5668,7 @@ function gatedRect(rect, x, y, space) {
     return null;
   const m = RECT_CONTAIN_MARGIN;
   const inside = x >= rect.x - m && x <= rect.x + rect.w + m && y >= rect.y - m && y <= rect.y + rect.h + m;
-  return inside ? [round6(rect.x), round6(rect.y), round6(rect.w), round6(rect.h)] : null;
+  return inside ? [round7(rect.x), round7(rect.y), round7(rect.w), round7(rect.h)] : null;
 }
 function extractClicks(track, segments, opts) {
   const out = [];
@@ -5172,11 +5693,11 @@ function extractClicks(track, segments, opts) {
     const upSrc = st + Math.max(pressLen, 0.02);
     const up = keptOutputEnd(segments, st, upSrc, opts.media) ?? ot + CLICK_SYNTH_RELEASE;
     const click = {
-      ot: round6(ot),
-      up: round6(Math.max(up, ot + 0.02)),
-      st: round6(st),
-      x: round6(e.x),
-      y: round6(e.y),
+      ot: round7(ot),
+      up: round7(Math.max(up, ot + 0.02)),
+      st: round7(st),
+      x: round7(e.x),
+      y: round7(e.y),
       b: button
     };
     if (opts.rects && e.rect) {
@@ -5195,7 +5716,7 @@ function hexToRgbTriplet(hex) {
   const n = parseInt(h, 16);
   return [n >> 16, n >> 8 & 255, n & 255];
 }
-function round6(v) {
+function round7(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -5278,7 +5799,7 @@ function trackEmitter() {
       if (tt <= prev.t + 1e-6 && sameVec(prev.value, value)) return prev.t;
       if (tt <= prev.t + 1e-6) tt = prev.t + 1e-3;
     }
-    keyframes.push({ t: round7(tt), value: value.map(round7), ease });
+    keyframes.push({ t: round8(tt), value: value.map(round8), ease });
     return tt;
   };
   return { keyframes, push: push2 };
@@ -7206,24 +7727,25 @@ var ON_FRAME = `(ctx, content, dt) => {
     var cpH = 2 * ${Math.abs(CARD_Z)} * Math.tan(${CARD_FOV} * Math.PI / 180 / 2)
     var cpv = null
     if (cpk && cpk.keyframes && cpk.keyframes.length) cpv = TL.sample(cpk, t, TL.lerpArray)
-    if ((cpv || trIn) && card.mesh.scale && card.mesh.position) {
-      // The pose track, then a boundary's enter on top: a slide is an
-      // offset in plane widths and heights, a fade an opacity, a scale both.
-      var cpS = (cpv ? cpv[0] : 1) * trSc
-      var cpO = (cpv ? cpv[2] : 1) * trOp
-      card.mesh.scale.x = cpS; card.mesh.scale.y = cpS
+    // The pose track, then a boundary's enter on top: a slide is an offset
+    // in plane widths and heights, a fade an opacity, a scale both. Outside
+    // both, every term is its rest value.
+    //
+    // EVERY field is written EVERY frame, so the pose is a pure function of
+    // t. A pose restored only when some field looked off-rest kept whatever
+    // the last frame left in the fields it did not look at: a fade moves
+    // opacity alone, so a scrub that jumped out of one mid-window left the
+    // card translucent until something else moved it.
+    var cpS = (cpv ? cpv[0] : 1) * trSc
+    var cpO = (cpv ? cpv[2] : 1) * trOp
+    if (card.mesh.scale) { card.mesh.scale.x = cpS; card.mesh.scale.y = cpS }
+    if (card.mesh.position) {
       card.mesh.position.x = trOx * cpH * (W / H)
       card.mesh.position.y = ((cpv ? cpv[1] : 0) + trOy) * cpH
-      if (card.mesh.material) card.mesh.material.opacity = cpO
-      // Gone past its clip: the mesh leaves the scene, not just its paint.
-      card.mesh.visible = cpO > 0.001
-    } else if (card.mesh.scale && card.mesh.position && ((card.mesh.scale.x !== undefined && card.mesh.scale.x !== 1) || (card.mesh.position.y !== undefined && card.mesh.position.y !== 0) || (card.mesh.position.x !== undefined && card.mesh.position.x !== 0) || card.mesh.visible === false)) {
-      card.mesh.scale.x = 1; card.mesh.scale.y = 1
-      card.mesh.position.x = 0
-      card.mesh.position.y = 0
-      if (card.mesh.material) card.mesh.material.opacity = 1
-      card.mesh.visible = true
     }
+    if (card.mesh.material) card.mesh.material.opacity = cpO
+    // Gone past its clip: the mesh leaves the scene, not just its paint.
+    card.mesh.visible = cpO > 0.001
     var tilted = rx * rx + ry * ry > 1e-6
     if (card.texture && card.texture.generateMipmaps !== tilted) {
       var THREE2 = ctx.THREE
@@ -7278,14 +7800,14 @@ function studioLayerData(layers, duration, pins) {
     // needs a decoded recording, which a sync lowering can't produce.
     audio: (layers.audio ?? []).map((c) => ({
       key: c.key,
-      start: round7(c.start),
-      in: round7(c.in),
-      out: round7(c.out),
-      gain: round7(c.gain),
+      start: round8(c.start),
+      in: round8(c.in),
+      out: round8(c.out),
+      gain: round8(c.gain),
       loop: !!c.loop,
-      len: round7(clipLength(c)),
+      len: round8(clipLength(c)),
       duck: !!c.duck,
-      env: clipEnvelope(c).map((p) => ({ t: round7(p.t), g: round7(p.g) }))
+      env: clipEnvelope(c).map((p) => ({ t: round8(p.t), g: round8(p.g) }))
     })),
     // Object clips: numbers resolved HERE; shapes are the drafted engine spec.
     ...layers.objects && layers.objects.length ? {
@@ -7298,17 +7820,17 @@ function studioLayerData(layers, duration, pins) {
         } : o.asset.kind === "text3d" ? resolveText3dAsset(o.asset) : { kind: "gltf", key: o.asset.key },
         ...o.span ? {
           span: {
-            start: round7(o.span.start),
-            duration: round7(o.span.duration)
+            start: round8(o.span.start),
+            duration: round8(o.span.duration)
           }
         } : {},
-        x: round7(o.transform3d.x),
-        y: round7(o.transform3d.y),
-        z: round7(o.transform3d.z),
-        rx: round7(o.transform3d.rx),
-        ry: round7(o.transform3d.ry),
-        rz: round7(o.transform3d.rz),
-        scale: round7(o.transform3d.scale || OBJECT_DEFAULT_SCALE),
+        x: round8(o.transform3d.x),
+        y: round8(o.transform3d.y),
+        z: round8(o.transform3d.z),
+        rx: round8(o.transform3d.rx),
+        ry: round8(o.transform3d.ry),
+        rz: round8(o.transform3d.rz),
+        scale: round8(o.transform3d.scale || OBJECT_DEFAULT_SCALE),
         anim: idleKey(o),
         // Pose keyframes: clip-local [x,y,z,rx,ry,rz,scale] track,
         // sampled at t − span.start. Omitted when absent — parity.
@@ -7335,12 +7857,12 @@ function studioLayerData(layers, duration, pins) {
         const base = {
           id: o.id,
           kind: o.kind,
-          start: round7(o.start),
-          dur: round7(Math.max(OVERLAY_MIN_DURATION, o.duration)),
-          x: round7(o.transform.x),
-          y: round7(o.transform.y),
-          scale: round7(o.transform.scale || 1),
-          rot: round7(o.transform.rotation || 0),
+          start: round8(o.start),
+          dur: round8(Math.max(OVERLAY_MIN_DURATION, o.duration)),
+          x: round8(o.transform.x),
+          y: round8(o.transform.y),
+          scale: round8(o.transform.scale || 1),
+          rot: round8(o.transform.rotation || 0),
           enter: enterKey(o),
           exit: exitKey(o),
           // Pose keyframes: a CLIP-LOCAL [x, y, scale, rot, opacity]
@@ -7365,10 +7887,10 @@ function studioLayerData(layers, duration, pins) {
             ...base,
             kind: "image",
             key: hl.key,
-            w: round7(hl.width),
+            w: round8(hl.width),
             radius: 0,
             shadow: "none",
-            opacity: round7(o.opacity ?? 1),
+            opacity: round8(o.opacity ?? 1),
             html: hl.html
           };
         }
@@ -7385,8 +7907,8 @@ function studioLayerData(layers, duration, pins) {
               ...o.frame.browserBar?.theme ? { theme: o.frame.browserBar.theme } : {}
             },
             lean: [
-              round7(o.frame.lean?.rx ?? 0),
-              round7(o.frame.lean?.ry ?? 0)
+              round8(o.frame.lean?.rx ?? 0),
+              round8(o.frame.lean?.ry ?? 0)
             ],
             shadow: o.frame.shadow ?? LAYER_CARD_SHADOW,
             shadowContact: o.frame.shadowContact ?? 0,
@@ -7402,17 +7924,17 @@ function studioLayerData(layers, duration, pins) {
             for (const ev of lm.cursor) {
               if (ev.type === "down")
                 clicks.push({
-                  t: round7(ev.t / 1e3),
-                  x: round7(ev.x),
-                  y: round7(ev.y)
+                  t: round8(ev.t / 1e3),
+                  x: round8(ev.x),
+                  y: round8(ev.y)
                 });
             }
             return {
               cur: {
                 pts: sm.map((p) => ({
-                  t: round7(p.t),
-                  x: round7(p.x),
-                  y: round7(p.y)
+                  t: round8(p.t),
+                  x: round8(p.x),
+                  y: round8(p.y)
                 })),
                 space: { w: lm.meta.width, h: lm.meta.height },
                 size: rec.cursor.size,
@@ -7427,7 +7949,7 @@ function studioLayerData(layers, duration, pins) {
             ...lm && lm.crop ? { crop: lm.crop } : {},
             ...lmCard ? { card: lmCard } : {},
             ...lmFacts,
-            w: round7(o.width ?? OVERLAY_MEDIA_DEFAULT_WIDTH),
+            w: round8(o.width ?? OVERLAY_MEDIA_DEFAULT_WIDTH),
             radius: o.radius ?? OVERLAY_MEDIA_DEFAULT_RADIUS,
             opacity: o.opacity ?? 1,
             loop: !!o.loop,
@@ -7437,7 +7959,7 @@ function studioLayerData(layers, duration, pins) {
             ...o.shadow ? { shadow: o.shadow } : {},
             ...o.border && o.border.width > 0 ? {
               border: {
-                width: round7(o.border.width),
+                width: round8(o.border.width),
                 color: o.border.color
               }
             } : {}
@@ -7457,11 +7979,11 @@ function studioLayerData(layers, duration, pins) {
           // Style-v2 fields bake only when non-default (byte parity for
           // older docs); ON_FRAME reads them unconditionally.
           ...st.fontStyle === "italic" ? { sty: "italic" } : {},
-          ...o.maxWidth ? { mw: round7(o.maxWidth) } : {},
-          ...st.letterSpacing ? { ls: round7(st.letterSpacing) } : {},
-          ...st.lineHeight !== OVERLAY_LINE_HEIGHT ? { lh: round7(st.lineHeight) } : {},
+          ...o.maxWidth ? { mw: round8(o.maxWidth) } : {},
+          ...st.letterSpacing ? { ls: round8(st.letterSpacing) } : {},
+          ...st.lineHeight !== OVERLAY_LINE_HEIGHT ? { lh: round8(st.lineHeight) } : {},
           ...st.align !== "center" ? { align: st.align } : {},
-          ...st.stroke ? { stroke: { c: st.stroke.color, w: round7(st.stroke.width) } } : {},
+          ...st.stroke ? { stroke: { c: st.stroke.color, w: round8(st.stroke.width) } } : {},
           // Hosted face behind an override: ON_FRAME lazy-loads it so a
           // live family/weight edit paints without a LOAD (SETUP only
           // runs on cold load).
@@ -7474,10 +7996,10 @@ function studioLayerData(layers, duration, pins) {
           ...bx ? {
             box: {
               c: bx.color,
-              o: round7(bx.opacity),
-              px: round7(bx.padX),
-              py: round7(bx.padY),
-              r: round7(bx.radius)
+              o: round8(bx.opacity),
+              px: round8(bx.padX),
+              py: round8(bx.padY),
+              r: round8(bx.radius)
             }
           } : {},
           // Entrance animation: segmentation + timing normalized
@@ -7549,17 +8071,17 @@ function lowerToComposition(input) {
     // Rated segments (speed spans pre-intersected): ON_FRAME's mapTime and the
     // export's audio splice read the rate straight off each segment.
     segments: rated.map((seg) => ({
-      in: round7(seg.in),
-      out: round7(seg.out),
-      ...seg.rate !== void 0 && seg.rate !== 1 ? { rate: round7(seg.rate) } : {},
+      in: round8(seg.in),
+      out: round8(seg.out),
+      ...seg.rate !== void 0 && seg.rate !== 1 ? { rate: round8(seg.rate) } : {},
       ...seg.media ? { media: seg.media } : {}
     })),
     frame: doc.frame,
     micGain: doc.micGain ?? 1,
     cursor: smoothed.map((p) => ({
-      t: round7(p.t),
-      x: round7(p.x),
-      y: round7(p.y)
+      t: round8(p.t),
+      x: round8(p.x),
+      y: round8(p.y)
     })),
     cursorStyle: doc.cursor,
     cursorSpace: { w: doc.source.meta.width, h: doc.source.meta.height },
@@ -7582,9 +8104,9 @@ function lowerToComposition(input) {
           crop: m.crop ?? null,
           hasAudio: !!m.meta.hasAudio,
           cursor: sm.map((p) => ({
-            t: round7(p.t),
-            x: round7(p.x),
-            y: round7(p.y)
+            t: round8(p.t),
+            x: round8(p.x),
+            y: round8(p.y)
           })),
           cursorSpace: { w: m.meta.width, h: m.meta.height },
           // The card this media wears (its own placement, bar, corner,
@@ -7766,8 +8288,8 @@ function pinCandidates(doc, clip) {
       step: s.id ?? s.step,
       do: s.do,
       ...s.selector ? { selector: s.selector } : {},
-      output: { start: round7(ext.start), end: round7(ext.end) },
-      overlap: round7(overlap)
+      output: { start: round8(ext.start), end: round8(ext.end) },
+      overlap: round8(overlap)
     });
   }
   return out.sort((x, y) => y.overlap - x.overlap);
@@ -7798,8 +8320,8 @@ function pinsDataOf(doc, pins) {
     if (!ref) continue;
     out.push({
       id: o.id,
-      start: round7(o.start),
-      dur: round7(Math.max(OVERLAY_MIN_DURATION, o.duration)),
+      start: round8(o.start),
+      dur: round8(Math.max(OVERLAY_MIN_DURATION, o.duration)),
       x: round43(ref.rect.x),
       y: round43(ref.rect.y),
       w: round43(ref.rect.w),
@@ -7812,8 +8334,8 @@ function pinsDataOf(doc, pins) {
       // leader's end with the pointer through [t0, t1], source seconds.
       ...ref.carry ? {
         carry: {
-          t0: round7(ref.carry.t0),
-          t1: round7(ref.carry.t1),
+          t0: round8(ref.carry.t0),
+          t1: round8(ref.carry.t1),
           x0: round43(ref.carry.x0),
           y0: round43(ref.carry.y0)
         }
@@ -7860,7 +8382,7 @@ function clickFxData(doc, rated) {
     }
   };
 }
-function round7(v) {
+function round8(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -7950,8 +8472,8 @@ function planAutoSpeed(track, opts) {
   accepted.sort((a, b) => a.in - b.in);
   return accepted.map((c, i) => ({
     id: `s${i}`,
-    in: round8(c.in),
-    out: round8(c.out),
+    in: round9(c.in),
+    out: round9(c.out),
     rate: clampSpeedRate(c.rate),
     source: "auto"
   }));
@@ -8004,7 +8526,7 @@ function collectRuns(evs, gap, minLen, emit2) {
   }
   flush();
 }
-function round8(v) {
+function round9(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -8186,16 +8708,16 @@ function momentsFromDoc(doc, plan, opts = {}) {
     return {
       id: `m${String(i + 1).padStart(2, "0")}`,
       kind: d.kind,
-      source: { in: round9(d.in), out: round9(d.out) },
-      output: output ? { in: round9(output.start), out: round9(output.end) } : null,
-      at: d.at === null ? null : round9(d.at),
-      outputAt: outAt ? round9(outAt.start) : null,
-      focus: d.focus ? { cx: round9(d.focus.cx), cy: round9(d.focus.cy) } : null,
+      source: { in: round10(d.in), out: round10(d.out) },
+      output: output ? { in: round10(output.start), out: round10(output.end) } : null,
+      at: d.at === null ? null : round10(d.at),
+      outputAt: outAt ? round10(outAt.start) : null,
+      focus: d.focus ? { cx: round10(d.focus.cx), cy: round10(d.focus.cy) } : null,
       rect: d.rect ? {
-        x: round9(d.rect.x),
-        y: round9(d.rect.y),
-        w: round9(d.rect.w),
-        h: round9(d.rect.h)
+        x: round10(d.rect.x),
+        y: round10(d.rect.y),
+        w: round10(d.rect.w),
+        h: round10(d.rect.h)
       } : null,
       ...d.clicks !== void 0 ? { clicks: d.clicks } : {},
       ...d.surface ? { surface: true } : {},
@@ -8216,7 +8738,7 @@ function activityOf(bins, d) {
     sum += bins[i];
     n++;
   }
-  return n ? round9(sum / n) : null;
+  return n ? round10(sum / n) : null;
 }
 function saidOver(transcript, d) {
   if (!transcript?.length) return null;
@@ -8225,7 +8747,7 @@ function saidOver(transcript, d) {
   const text = transcript.filter((s) => s.start < hi && s.end > lo).map((s) => s.text.trim()).filter(Boolean).join(" ");
   return text || null;
 }
-function round9(v) {
+function round10(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -8732,8 +9254,8 @@ function buildDigest(input) {
   return {
     digestVersion: DIGEST_VERSION,
     take: {
-      sourceDuration: round10(meta.durationMs / 1e3),
-      outputDuration: round10(input.outputDuration),
+      sourceDuration: round11(meta.durationMs / 1e3),
+      outputDuration: round11(input.outputDuration),
       width: meta.width,
       height: meta.height,
       captureWidth: meta.captureWidth ?? null,
@@ -8785,7 +9307,7 @@ function buildDigest(input) {
 function outputDurationOf(doc) {
   return docOutputDuration(doc);
 }
-function round10(v) {
+function round11(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -8811,20 +9333,20 @@ function setSpeedInRange(spans, srcIn, srcOut, rate) {
       continue;
     }
     if (srcIn - s.in >= MIN_REMAINDER)
-      kept.push({ ...s, out: round11(srcIn), source: "manual" });
+      kept.push({ ...s, out: round12(srcIn), source: "manual" });
     if (s.out - srcOut >= MIN_REMAINDER)
       kept.push({
         ...s,
         id: mintId(used),
-        in: round11(srcOut),
+        in: round12(srcOut),
         source: "manual"
       });
   }
   if (rate != null)
     kept.push({
       id: mintId(used),
-      in: round11(srcIn),
-      out: round11(srcOut),
+      in: round12(srcIn),
+      out: round12(srcOut),
       rate: clampSpeedRate(rate),
       source: "manual"
     });
@@ -8840,9 +9362,9 @@ function removeSourceRange(segments, srcIn, srcOut) {
       next.push(seg);
       continue;
     }
-    if (srcIn - seg.in >= MIN_SEGMENT) next.push({ ...seg, out: round11(srcIn) });
+    if (srcIn - seg.in >= MIN_SEGMENT) next.push({ ...seg, out: round12(srcIn) });
     if (seg.out - srcOut >= MIN_SEGMENT)
-      next.push({ ...seg, in: round11(srcOut) });
+      next.push({ ...seg, in: round12(srcOut) });
   }
   return next.length ? next : [...segments];
 }
@@ -8860,8 +9382,8 @@ function zoomSpanForRange(zoom, srcIn, srcOut) {
   while (used.has(`u${n}`)) n++;
   return {
     id: `u${n}`,
-    in: round11(start),
-    out: round11(end),
+    in: round12(start),
+    out: round12(end),
     level: DEFAULT_ZOOM_LEVEL,
     cx: 0.5,
     cy: 0.5,
@@ -8875,7 +9397,7 @@ function mintId(used) {
   used.add(id);
   return id;
 }
-function round11(v) {
+function round12(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -9586,8 +10108,8 @@ var videoLane = {
     return segments.map((s, i) => ({
       id: `seg-${i}`,
       kind: "clip",
-      t: round12(starts[i]),
-      duration: round12(
+      t: round13(starts[i]),
+      duration: round13(
         outputLen(s, speeds, freezes, i === 0 || !contiguous(segments, i))
       )
     }));
@@ -9670,7 +10192,7 @@ var videoLane = {
           if (local >= m.t - 1e-9 && local <= m.t + m.duration + 1e-9)
             return null;
         }
-        const sourceT = round12(
+        const sourceT = round13(
           mapTime3(segmentPieces(s, speeds, freezes, leading), local)
         );
         if (sourceT - s.in < 0.05 || s.out - sourceT < 0.05) return null;
@@ -9711,7 +10233,7 @@ var videoLane = {
           n === 1 || !contiguous(segments, n - 1)
         )
       ] : []
-    ].map(round12);
+    ].map(round13);
   }
 };
 function nextFreezeId(doc) {
@@ -9738,8 +10260,8 @@ var freezeLane = {
         {
           id: f.id,
           kind: "clip",
-          t: round12(m.t),
-          duration: round12(m.duration),
+          t: round13(m.t),
+          duration: round13(m.duration),
           label: `${trimZeros(f.seconds)}s`
         }
       ] : [];
@@ -9761,7 +10283,7 @@ var freezeLane = {
         if (g.t >= m.t - 1e-9 && g.t <= m.t + m.duration + 1e-9) return null;
       }
       if (g.t > totalDuration7(rated) + 1e-9) return null;
-      const srcT = round12(mapTime3(rated, Math.max(0, g.t)));
+      const srcT = round13(mapTime3(rated, Math.max(0, g.t)));
       if (!kept(srcT) || !clear(srcT)) return null;
       const id = nextFreezeId(doc);
       const mediaHere = mediaAtOutput(rated, Math.max(0, g.t));
@@ -9803,7 +10325,7 @@ var freezeLane = {
       const marks = freezeOutputExtents(splitBySpeed4(segs, speeds), freezes);
       const mine = marks.get(f.id);
       const endOut = mine ? mine.t + mine.duration : null;
-      const srcT = round12(
+      const srcT = round13(
         Math.min(sourceDuration, mapTime3(base, Math.max(0, g.t)))
       );
       if (!kept(srcT) || !clear(srcT, f.id)) return null;
@@ -9863,8 +10385,8 @@ var zoomLane = {
         {
           id: z.id,
           kind: "clip",
-          t: round12(ext.start),
-          duration: round12(ext.end - ext.start),
+          t: round13(ext.start),
+          duration: round13(ext.end - ext.start),
           label: `${z.level.toFixed(2)}\xD7`
         }
       ];
@@ -9891,8 +10413,8 @@ var zoomLane = {
           ...d.zoom,
           {
             id,
-            in: round12(srcT),
-            out: round12(srcT + len),
+            in: round13(srcT),
+            out: round13(srcT + len),
             level: DEFAULT_ZOOM_LEVEL,
             cx,
             cy,
@@ -9924,8 +10446,8 @@ var zoomLane = {
       return (d) => {
         const z = d.zoom.find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round12(newIn);
-        z.out = round12(newIn + len);
+        z.in = round13(newIn);
+        z.out = round13(newIn + len);
         z.source = "manual";
         d.zoom.sort((a, b) => a.in - b.in);
       };
@@ -9954,8 +10476,8 @@ var zoomLane = {
       return (d) => {
         const z = d.zoom.find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round12(next.in);
-        z.out = round12(next.out);
+        z.in = round13(next.in);
+        z.out = round13(next.out);
         z.source = "manual";
       };
     }
@@ -9977,8 +10499,8 @@ function cursorFocusAt(doc, srcT) {
     if (Math.abs(e.t - ms) < Math.abs(best.t - ms)) best = e;
   const clamp015 = (v) => Math.max(0, Math.min(1, v));
   return {
-    cx: round12(clamp015(best.x / width)),
-    cy: round12(clamp015(best.y / height))
+    cx: round13(clamp015(best.x / width)),
+    cy: round13(clamp015(best.y / height))
   };
 }
 var tiltLane = {
@@ -9992,8 +10514,8 @@ var tiltLane = {
         {
           id: z.id,
           kind: "clip",
-          t: round12(ext.start),
-          duration: round12(ext.end - ext.start),
+          t: round13(ext.start),
+          duration: round13(ext.end - ext.start),
           label: `${formatDeg(z.rx)}\xB0/${formatDeg(z.ry)}\xB0`
         }
       ];
@@ -10019,8 +10541,8 @@ var tiltLane = {
           ...d.tilt ?? [],
           {
             id,
-            in: round12(srcT),
-            out: round12(srcT + len),
+            in: round13(srcT),
+            out: round13(srcT + len),
             rx: DEFAULT_TILT_POSE.rx,
             ry: DEFAULT_TILT_POSE.ry,
             source: "manual",
@@ -10051,8 +10573,8 @@ var tiltLane = {
       return (d) => {
         const z = (d.tilt ?? []).find((x) => x.id === g.id);
         if (!z || !d.tilt) return;
-        z.in = round12(newIn);
-        z.out = round12(newIn + len);
+        z.in = round13(newIn);
+        z.out = round13(newIn + len);
         z.source = "manual";
         d.tilt.sort((a, b) => a.in - b.in);
       };
@@ -10081,8 +10603,8 @@ var tiltLane = {
       return (d) => {
         const z = (d.tilt ?? []).find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round12(next.in);
-        z.out = round12(next.out);
+        z.in = round13(next.in);
+        z.out = round13(next.out);
         z.source = "manual";
       };
     }
@@ -10109,8 +10631,8 @@ var camMoveLane = {
         {
           id: z.id,
           kind: "clip",
-          t: round12(ext.start),
-          duration: round12(ext.end - ext.start),
+          t: round13(ext.start),
+          duration: round13(ext.end - ext.start),
           label: z.size != null ? `${Math.round(z.size * 100)}%` : "Move"
         }
       ];
@@ -10134,8 +10656,8 @@ var camMoveLane = {
           ...d.camMotion ?? [],
           {
             id,
-            in: round12(srcT),
-            out: round12(srcT + len),
+            in: round13(srcT),
+            out: round13(srcT + len),
             ...DEFAULT_CAM_POSE,
             source: "manual"
           }
@@ -10164,8 +10686,8 @@ var camMoveLane = {
       return (d) => {
         const z = (d.camMotion ?? []).find((x) => x.id === g.id);
         if (!z || !d.camMotion) return;
-        z.in = round12(newIn);
-        z.out = round12(newIn + len);
+        z.in = round13(newIn);
+        z.out = round13(newIn + len);
         z.source = "manual";
         d.camMotion.sort((a, b) => a.in - b.in);
       };
@@ -10194,8 +10716,8 @@ var camMoveLane = {
       return (d) => {
         const z = (d.camMotion ?? []).find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round12(next.in);
-        z.out = round12(next.out);
+        z.in = round13(next.in);
+        z.out = round13(next.out);
         z.source = "manual";
       };
     }
@@ -10228,10 +10750,10 @@ var camLane = {
       items.push({
         id: `cam-${i}`,
         kind: "clip",
-        t: round12(
+        t: round13(
           starts[i] + outputLen({ in: s.in, out: a }, speeds, freezes, leading)
         ),
-        duration: round12(
+        duration: round13(
           outputLen({ in: a, out: b }, speeds, freezes, a === s.in && leading)
         )
       });
@@ -10260,7 +10782,7 @@ var camLane = {
         Math.max(first.in, last.out - span)
       );
       return (d) => {
-        d.cam.window = { in: round12(newIn), out: round12(newIn + span) };
+        d.cam.window = { in: round13(newIn), out: round13(newIn + span) };
       };
     }
     const overlapping = eff.map((s, i) => ({
@@ -10273,8 +10795,8 @@ var camLane = {
     const next = g.edge === "start" ? { in: Math.min(sourceT, current.out - 0.05), out: current.out } : { in: current.in, out: Math.max(sourceT, current.in + 0.05) };
     return (d) => {
       d.cam.window = {
-        in: round12(Math.max(0, next.in)),
-        out: round12(Math.min(sourceDuration, next.out))
+        in: round13(Math.max(0, next.in)),
+        out: round13(Math.min(sourceDuration, next.out))
       };
     };
   },
@@ -10294,8 +10816,8 @@ var micLane = {
     return segments.map((s, i) => ({
       id: `mic-${i}`,
       kind: "clip",
-      t: round12(starts[i]),
-      duration: round12(
+      t: round13(starts[i]),
+      duration: round13(
         outputLen(s, speeds, freezes, i === 0 || !contiguous(segments, i))
       )
     }));
@@ -10351,8 +10873,8 @@ var speedLane = {
         {
           id: sp.id,
           kind: "clip",
-          t: round12(start),
-          duration: round12(end - start),
+          t: round13(start),
+          duration: round13(end - start),
           label: `${sp.rate}\xD7`
         }
       ];
@@ -10376,8 +10898,8 @@ var speedLane = {
           ...d.speed ?? [],
           {
             id,
-            in: round12(srcT),
-            out: round12(srcT + len),
+            in: round13(srcT),
+            out: round13(srcT + len),
             rate: DEFAULT_SPEED_RATE,
             source: "manual",
             ...mediaHere ? { media: mediaHere } : {}
@@ -10408,8 +10930,8 @@ var speedLane = {
       return (d) => {
         const s = d.speed?.find((x) => x.id === g.id);
         if (!s) return;
-        s.in = round12(newIn);
-        s.out = round12(newIn + len);
+        s.in = round13(newIn);
+        s.out = round13(newIn + len);
         s.source = "manual";
         d.speed.sort((a, b) => a.in - b.in);
       };
@@ -10438,8 +10960,8 @@ var speedLane = {
       return (d) => {
         const s = d.speed?.find((x) => x.id === g.id);
         if (!s) return;
-        s.in = round12(next.in);
-        s.out = round12(next.out);
+        s.in = round13(next.in);
+        s.out = round13(next.out);
         s.source = "manual";
       };
     }
@@ -10458,8 +10980,8 @@ var audioLane = {
     return doc.audio.map((c) => ({
       id: c.id,
       kind: "clip",
-      t: round12(c.start),
-      duration: round12(clipLength(c)),
+      t: round13(c.start),
+      duration: round13(clipLength(c)),
       label: c.name
     }));
   },
@@ -10470,7 +10992,7 @@ var audioLane = {
       const start = Math.max(0, g.t);
       return (d) => {
         const c = d.audio.find((x) => x.id === g.id);
-        if (c) c.start = round12(start);
+        if (c) c.start = round13(start);
       };
     }
     if (g.type === "resize") {
@@ -10483,8 +11005,8 @@ var audioLane = {
           return (d) => {
             const c = d.audio.find((x) => x.id === g.id);
             if (!c) return;
-            c.start = round12(newStart2);
-            c.loopLen = round12(end - newStart2);
+            c.start = round13(newStart2);
+            c.loopLen = round13(end - newStart2);
           };
         }
         const delta = g.t - clip.start;
@@ -10493,22 +11015,22 @@ var audioLane = {
         return (d) => {
           const c = d.audio.find((x) => x.id === g.id);
           if (!c) return;
-          c.in = round12(newIn);
-          c.start = round12(newStart);
+          c.in = round13(newIn);
+          c.start = round13(newStart);
         };
       }
       if (clip.loop) {
         const newLen = Math.max(0.1, g.t - clip.start);
         return (d) => {
           const c = d.audio.find((x) => x.id === g.id);
-          if (c) c.loopLen = round12(newLen);
+          if (c) c.loopLen = round13(newLen);
         };
       }
       const span = Math.max(0.05, g.t - clip.start);
       const newOut = Math.min(clip.in + span, clip.duration);
       return (d) => {
         const c = d.audio.find((x) => x.id === g.id);
-        if (c) c.out = round12(Math.max(c.in + 0.05, newOut));
+        if (c) c.out = round13(Math.max(c.in + 0.05, newOut));
       };
     }
     if (g.type === "remove") {
@@ -10521,8 +11043,8 @@ var audioLane = {
   },
   magnets(doc) {
     return doc.audio.flatMap((c) => [
-      round12(c.start),
-      round12(c.start + clipLength(c))
+      round13(c.start),
+      round13(c.start + clipLength(c))
     ]);
   }
 };
@@ -10540,7 +11062,7 @@ function poseItems(clipId, start, duration, motion) {
   return (motion ?? []).map((p, i) => ({
     id: `${clipId}::k${i}`,
     kind: "keyframe",
-    t: round12(start + Math.min(Math.max(0, p.at), duration))
+    t: round13(start + Math.min(Math.max(0, p.at), duration))
   }));
 }
 var overlaysLane = {
@@ -10551,8 +11073,8 @@ var overlaysLane = {
       {
         id: o.id,
         kind: "clip",
-        t: round12(o.start),
-        duration: round12(o.duration),
+        t: round13(o.start),
+        duration: round13(o.duration),
         label: o.kind === "text" ? o.text.split("\n")[0].slice(0, 24) || "Text" : o.kind === "html" ? htmlLayerLabel(o) : o.kind === "image" ? "Image" : "Video"
       },
       // Pose diamonds render after the clips, so they sit on top.
@@ -10572,7 +11094,7 @@ var overlaysLane = {
           return (d) => {
             const o = (d.overlays ?? []).find((x) => x.id === kf.clipId);
             const p = o?.motion?.[kf.index];
-            if (p) p.at = round12(at);
+            if (p) p.at = round13(at);
           };
         }
         if (g.type === "remove") {
@@ -10601,8 +11123,8 @@ var overlaysLane = {
           {
             id,
             kind: "text",
-            start: round12(start),
-            duration: round12(len),
+            start: round13(start),
+            duration: round13(len),
             text: "Title",
             preset: "title",
             // Frame fractions: centered, lower-third — at any aspect ratio.
@@ -10617,7 +11139,7 @@ var overlaysLane = {
       const start = Math.max(0, g.t);
       return (d) => {
         const o = (d.overlays ?? []).find((x) => x.id === g.id);
-        if (o) o.start = round12(start);
+        if (o) o.start = round13(start);
       };
     }
     if (g.type === "resize") {
@@ -10627,14 +11149,14 @@ var overlaysLane = {
         return (d) => {
           const o = (d.overlays ?? []).find((x) => x.id === g.id);
           if (!o) return;
-          o.start = round12(newStart);
-          o.duration = round12(end - newStart);
+          o.start = round13(newStart);
+          o.duration = round13(end - newStart);
         };
       }
       const newLen = Math.max(OVERLAY_MIN_DURATION, g.t - clip.start);
       return (d) => {
         const o = (d.overlays ?? []).find((x) => x.id === g.id);
-        if (o) o.duration = round12(newLen);
+        if (o) o.duration = round13(newLen);
       };
     }
     return (d) => {
@@ -10643,8 +11165,8 @@ var overlaysLane = {
   },
   magnets(doc) {
     return (doc.overlays ?? []).flatMap((o) => [
-      round12(o.start),
-      round12(o.start + o.duration)
+      round13(o.start),
+      round13(o.start + o.duration)
     ]);
   }
 };
@@ -10657,8 +11179,8 @@ var objectsLane = {
       {
         id: o.id,
         kind: "clip",
-        t: round12(o.span?.start ?? 0),
-        duration: round12(o.span?.duration ?? outDur),
+        t: round13(o.span?.start ?? 0),
+        duration: round13(o.span?.duration ?? outDur),
         label: o.asset.kind === "primitive" ? o.asset.shape : o.asset.kind === "text3d" ? o.asset.text : "model"
       },
       // Pose diamonds: clip-local `at` from the span start (0 span-less).
@@ -10686,7 +11208,7 @@ var objectsLane = {
         return (d) => {
           const o = (d.objects ?? []).find((x) => x.id === kf.clipId);
           const p = o?.motion?.[kf.index];
-          if (p) p.at = round12(at);
+          if (p) p.at = round13(at);
         };
       }
       if (g.type === "remove") {
@@ -10707,7 +11229,7 @@ var objectsLane = {
       const start = Math.max(0, g.t);
       return (d) => {
         const o = (d.objects ?? []).find((x) => x.id === g.id);
-        if (o?.span) o.span.start = round12(start);
+        if (o?.span) o.span.start = round13(start);
       };
     }
     if (g.type === "resize") {
@@ -10718,14 +11240,14 @@ var objectsLane = {
         return (d) => {
           const o = (d.objects ?? []).find((x) => x.id === g.id);
           if (!o?.span) return;
-          o.span.start = round12(newStart);
-          o.span.duration = round12(end - newStart);
+          o.span.start = round13(newStart);
+          o.span.duration = round13(end - newStart);
         };
       }
       const newLen = Math.max(OVERLAY_MIN_DURATION, g.t - clip.span.start);
       return (d) => {
         const o = (d.objects ?? []).find((x) => x.id === g.id);
-        if (o?.span) o.span.duration = round12(newLen);
+        if (o?.span) o.span.duration = round13(newLen);
       };
     }
     return (d) => {
@@ -10734,7 +11256,7 @@ var objectsLane = {
   },
   magnets(doc) {
     return (doc.objects ?? []).flatMap(
-      (o) => o.span ? [round12(o.span.start), round12(o.span.start + o.span.duration)] : []
+      (o) => o.span ? [round13(o.span.start), round13(o.span.start + o.span.duration)] : []
     );
   }
 };
@@ -10761,7 +11283,7 @@ function nextSpeedId(doc) {
 function segIndex(id) {
   return Number(id.replace("seg-", ""));
 }
-function round12(v) {
+function round13(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -10929,6 +11451,7 @@ export {
   CLICK_FX_INTENSITY,
   CLICK_FX_PRE,
   CLICK_HIGHLIGHT_FADE,
+  CLICK_HOLD_MS,
   CLICK_PAIR_MAX,
   CLICK_PULSE_DUR,
   CLICK_RECT_MAX_FRAC,
@@ -11111,6 +11634,10 @@ export {
   cropBox,
   cssFamilies,
   cssWeights,
+  cursorFromCsv,
+  cursorFromPlaywrightTrace,
+  cursorFromRecords,
+  cursorFromTrace,
   cursorIdleFade,
   deltaE,
   deriveViewportCrop,
@@ -11239,6 +11766,7 @@ export {
   planForDigest,
   planeSizeAtDepth,
   platformBarKind,
+  playwrightTraceEntry,
   programDuration,
   projectFromArtifact,
   pumpFreeChainGap,
@@ -11274,6 +11802,7 @@ export {
   studioLayerData,
   tiltLane,
   tiltTrackFromDoc,
+  traceKindOf,
   transitionMult,
   transitionSeconds,
   unionFitLevel,
@@ -11286,6 +11815,8 @@ export {
   withHolds,
   withoutRejected,
   wrapProgramLength,
+  zipEntries,
+  zipEntryBytes,
   zoomCoversRect,
   zoomLane,
   zoomSpanForRange,