@vosjs/studio-core 0.11.0 → 0.12.0

package/dist/index.js

@@ -8,6 +8,13 @@ var TRANSITION_SPEED_MULT = {
 function transitionMult(t) {
   return t !== void 0 && t in TRANSITION_SPEED_MULT ? TRANSITION_SPEED_MULT[t] : 1;
 }
+var FREEZE_SECONDS_MIN = 0.25;
+var FREEZE_SECONDS_MAX = 30;
+var FREEZE_DEFAULT_SECONDS = 2;
+function clampFreezeSeconds(seconds) {
+  const s = Math.min(FREEZE_SECONDS_MAX, Math.max(FREEZE_SECONDS_MIN, seconds));
+  return Math.round(s * 1e3) / 1e3;
+}
 var SPEED_RATE_MIN = 0.1;
 var SPEED_RATE_MAX = 16;
 var SPEED_SPAN_MIN = 0.25;
@@ -506,17 +513,43 @@ function lastLayerEnd(doc) {
 import { splitBySpeed, totalDuration } from "@vosjs/timeline";
 function docRestTime(doc) {
   if (doc.endCard) return null;
-  const last = doc.segments.at(-1);
-  const hold = last?.hold;
-  if (typeof hold !== "number" || !(hold > 0)) return null;
-  const segs = doc.segments.length ? doc.segments : [{ in: 0, out: doc.source.meta.durationMs / 1e3 }];
-  const total = totalDuration(
-    withHolds(segs, splitBySpeed(segs, doc.speed ?? []))
+  const freezes = docFreezes(doc);
+  if (!freezes.length) return null;
+  const segs = docSegmentsOf(doc);
+  const marks = freezeOutputExtents(
+    splitBySpeed(segs, doc.speed ?? []),
+    freezes
   );
-  const rest = total - hold;
-  if (!(rest >= 0)) return null;
+  let rest = null;
+  for (const m of marks.values()) if (rest === null || m.t > rest) rest = m.t;
+  if (rest === null || !(rest >= 0)) return null;
   return Math.round(rest * 1e3) / 1e3;
 }
+function docSegmentsOf(doc) {
+  const segs = Array.isArray(doc.segments) ? doc.segments : [];
+  if (segs.length) return segs;
+  const ms = doc.source?.meta?.durationMs;
+  return [{ in: 0, out: typeof ms === "number" ? ms / 1e3 : 0 }];
+}
+function docFreezes(doc) {
+  const own = Array.isArray(doc.freeze) ? doc.freeze : [];
+  const legacy = legacyHoldFreezes(
+    Array.isArray(doc.segments) ? doc.segments : []
+  );
+  const all = [...own, ...legacy].filter(
+    (f) => typeof f.at === "number" && Number.isFinite(f.at) && typeof f.seconds === "number" && f.seconds > 0
+  );
+  return all.sort((a, b) => a.at - b.at);
+}
+function legacyHoldFreezes(segments) {
+  const out = [];
+  segments.forEach((s, i) => {
+    const hold = s.hold;
+    if (typeof hold === "number" && hold > 0)
+      out.push({ id: `h${i}`, at: s.out, seconds: hold });
+  });
+  return out;
+}
 var ENTRANCE_SECONDS = 1.2;
 var END_CARD_SECONDS = 2.5;
 var END_CARD_RECEDE = 0.7;
@@ -540,28 +573,67 @@ function exitSeconds(e) {
   const house = e.kind === "fade" ? CARD_FADE_SECONDS : END_CARD_RECEDE;
   return Math.max(0.1, Math.min(3, e.seconds ?? house));
 }
-function withHolds(docSegments, rated) {
-  const out = [];
-  const pending = docSegments.filter((s) => typeof s.hold === "number" && s.hold > 0).map((s) => ({ out: s.out, hold: s.hold, used: false }));
+function placeFreezes(rated, freezes) {
+  const marks = /* @__PURE__ */ new Map();
+  const pending = [...freezes].filter((f) => f.seconds > 0).sort((a, b) => a.at - b.at);
+  const pieces = [];
+  let acc = 0;
+  const freezePiece = (f) => {
+    const at = Math.max(HOLD_SOURCE_SPAN, f.at);
+    marks.set(f.id, { t: acc, duration: f.seconds });
+    pieces.push({
+      in: at - HOLD_SOURCE_SPAN,
+      out: at,
+      rate: HOLD_SOURCE_SPAN / f.seconds
+    });
+    acc += f.seconds;
+  };
+  const push2 = (p) => {
+    pieces.push(p);
+    acc += Math.max(0, p.out - p.in) / (p.rate ?? 1);
+  };
   for (let i = 0; i < rated.length; i++) {
-    const piece = rated[i];
-    out.push(piece);
+    let piece = rated[i];
     const next = rated[i + 1];
-    for (const p of pending) {
-      if (p.used) continue;
-      const endsHere = Math.abs(piece.out - p.out) < 1e-9;
-      const nextContinues = next && Math.abs(next.in - p.out) < 1e-9 && next.out > p.out;
-      if (endsHere && !nextContinues) {
-        out.push({
-          in: p.out - HOLD_SOURCE_SPAN,
-          out: p.out,
-          rate: HOLD_SOURCE_SPAN / p.hold
-        });
-        p.used = true;
+    while (pending.length) {
+      const f = pending[0];
+      if (f.at > piece.out + 1e-9) break;
+      if (f.at < piece.in - 1e-9) {
+        pending.shift();
+        continue;
+      }
+      if (f.at <= piece.in + 1e-9) {
+        pending.shift();
+        freezePiece(f);
+        continue;
+      }
+      if (f.at < piece.out - 1e-9) {
+        push2({ ...piece, out: f.at });
+        pending.shift();
+        freezePiece(f);
+        piece = { ...piece, in: f.at };
+        continue;
       }
+      const continues = next && Math.abs(next.in - piece.out) < 1e-9 && next.out > piece.out;
+      if (continues) break;
+      push2(piece);
+      piece = null;
+      pending.shift();
+      freezePiece(f);
+      break;
     }
+    if (piece) push2(piece);
   }
-  return out;
+  return { pieces, marks };
+}
+function withFreezes(rated, freezes) {
+  return placeFreezes(rated, freezes).pieces;
+}
+function freezeOutputExtents(rated, freezes) {
+  return placeFreezes(rated, freezes).marks;
+}
+function withHolds(docSegments, rated) {
+  return withFreezes(rated, legacyHoldFreezes(docSegments));
 }
 function entranceTiltKeyframes(e) {
   const s = entranceSeconds(e);
@@ -704,9 +776,29 @@ function migrateMotion(doc) {
   const segments = Array.isArray(doc.segments) ? doc.segments : [];
   const overlays = Array.isArray(doc.overlays) ? doc.overlays : [];
   const objects = Array.isArray(doc.objects) ? doc.objects : [];
-  const legacy = frame.entrance !== void 0 || doc.endCard !== void 0 || overlays.some(hasLegacyClipMotion) || objects.some((o) => o.animation !== void 0);
+  const heldSegments = segments.some((s) => s.hold !== void 0);
+  const legacy = frame.entrance !== void 0 || doc.endCard !== void 0 || heldSegments || overlays.some(hasLegacyClipMotion) || objects.some((o) => o.animation !== void 0);
   if (!legacy) return doc;
   const out = { ...doc };
+  if (heldSegments) {
+    const holds = legacyHoldFreezes(segments);
+    const own = Array.isArray(doc.freeze) ? doc.freeze : [];
+    const taken = new Set(own.map((f) => f.id));
+    let n = own.length;
+    const migrated = holds.map((h) => {
+      let id = `f${n++}`;
+      while (taken.has(id)) id = `f${n++}`;
+      taken.add(id);
+      return { id, at: h.at, seconds: h.seconds };
+    });
+    out.freeze = [...own, ...migrated].sort((a, b) => a.at - b.at);
+    out.segments = segments.map((s) => {
+      if (s.hold === void 0) return s;
+      const next = { ...s };
+      delete next.hold;
+      return next;
+    });
+  }
   const nextFrame = { ...frame };
   if (frame.entrance !== void 0) {
     const e = frame.entrance;
@@ -730,7 +822,10 @@ function migrateMotion(doc) {
     const card = doc.endCard;
     if (card && segments.length) {
       const seconds = Math.max(1, Math.min(8, card.seconds ?? END_CARD_SECONDS));
-      const rated = withHolds(segments, splitBySpeed(segments, doc.speed ?? []));
+      const rated = withFreezes(
+        splitBySpeed(segments, doc.speed ?? []),
+        docFreezes(doc)
+      );
       const endStart = totalDuration(rated);
       nextOverlays = [...nextOverlays, ...endCardClips(card, doc, endStart)];
       nextFrame.anim = {
@@ -767,12 +862,12 @@ function outputEnd(doc, footageEnd) {
 }
 
 // src/docVersion.ts
-var DOC_SCHEMA_VERSION = 3;
+var DOC_SCHEMA_VERSION = 4;
 function migrateHostedDoc(raw) {
   const version = typeof raw.docSchemaVersion === "number" ? raw.docSchemaVersion : 0;
   if (version >= DOC_SCHEMA_VERSION) return raw;
   let doc = raw;
-  if (version < 3 && doc.source && typeof doc.source === "object") {
+  if (version < 4 && doc.source && typeof doc.source === "object") {
     doc = migrateMotion(doc);
   }
   return { ...doc, docSchemaVersion: DOC_SCHEMA_VERSION };
@@ -3222,7 +3317,8 @@ var CAM_PAN_EASE = ZOOM_PAN_EASE;
 var PROGRAM_DURATION = 1;
 function ratedSegments(doc) {
   const segs = isRecordingDoc(doc) ? doc.segments.length ? doc.segments : [{ in: 0, out: doc.source.meta.durationMs / 1e3 }] : [{ in: 0, out: programDuration(doc) }];
-  return withHolds(segs, splitBySpeed2(segs, doc.speed ?? []));
+  const freezes = isRecordingDoc(doc) ? docFreezes(doc) : [];
+  return withFreezes(splitBySpeed2(segs, doc.speed ?? []), freezes);
 }
 function durationSec(doc, rated) {
   const trimmed = totalDuration2(rated);
@@ -3960,6 +4056,15 @@ var ON_FRAME = `(ctx, content, dt) => {
   // range); the paused/seek path needs nothing \u2014 mapTime already lands srcT.
   var srcRate = TL.rateAt ? TL.rateAt(d.segments || [], t) : 1
   var playRate = Math.min(16, Math.max(0.0625, srcRate))
+  // Where the FOOTAGE ends in output seconds. The output may outlast it
+  // (clips placed after the footage), and a hold is a freeze piece whose
+  // rate is tiny: in both the element must stay PAUSED on its frame. An
+  // ended element's play() rewinds it to zero and the drift guard then
+  // seeks it back, which reads as frames jumping back and forth; a hold
+  // crawling at the clamped 1/16 speed toward that same end was the same
+  // bug in slow motion.
+  var footEnd = TL.totalDuration ? TL.totalDuration(d.segments || []) : Infinity
+  var frozen = srcRate < 0.01 || t >= footEnd - 1e-3
   // Drive a <video> to the on-screen SOURCE moment: play natively while playing (drift
   // correction covers cut-boundary jumps), else step to the exact frame (registering a
   // decode promise so the deterministic export awaits it). Shared by the screen video
@@ -3967,7 +4072,7 @@ var ON_FRAME = `(ctx, content, dt) => {
   ${FRAME_STEP_SRC}
   function syncVid(vid) {
     try {
-      if (playing) {
+      if (playing && !frozen) {
         if (vid.playbackRate !== playRate) {
           vid.playbackRate = playRate
           // Resampled (tape-style) speed, matching the export's offline mix.
@@ -5629,7 +5734,7 @@ function layoutOf(doc) {
     frame: LAYOUT_FRAME_FIELDS.filter((k) => frame[k] !== void 0),
     clips: (doc.overlays ?? []).filter(isStageClip).map((o) => o.id),
     lean: restLeanOf(doc) !== null,
-    hold: (doc.segments.at(-1)?.hold ?? 0) > 0
+    freeze: trailingFreeze(doc) !== null
   };
 }
 function copyLayout(from, to, opts = {}) {
@@ -5691,11 +5796,33 @@ function copyLayout(from, to, opts = {}) {
       notes.push("lean kept: this take has tilt spans of its own");
     }
   }
-  const hold = from.segments.at(-1)?.hold;
+  const freeze = trailingFreeze(from);
   const last = doc.segments.at(-1);
-  if (typeof hold === "number" && hold > 0 && last) last.hold = hold;
+  if (freeze && last) {
+    const own2 = (doc.freeze ?? []).filter(
+      (f) => Math.abs(f.at - last.out) > 1e-9
+    );
+    const taken = new Set(own2.map((f) => f.id));
+    let n = 0;
+    while (taken.has(`f${n}`)) n++;
+    doc.freeze = [
+      ...own2,
+      { id: `f${n}`, at: last.out, seconds: freeze.seconds }
+    ].sort((a, b) => a.at - b.at);
+    doc.segments = doc.segments.map((s) => {
+      if (s.hold === void 0) return s;
+      const next = { ...s };
+      delete next.hold;
+      return next;
+    });
+  }
   return { doc, notes };
 }
+function trailingFreeze(doc) {
+  const last = doc.segments.at(-1);
+  if (!last) return null;
+  return docFreezes(doc).find((f) => Math.abs(f.at - last.out) < 1e-9) ?? null;
+}
 var shiftBy = (at, templateEnd, takeEnd) => at === "start" ? 0 : at === "end" ? takeEnd - templateEnd : at;
 function clipsFrom(doc, from) {
   return {
@@ -6667,33 +6794,44 @@ function effectiveSegments(doc) {
   if (isRecordingDoc(doc) && doc.segments.length) return doc.segments;
   return [{ in: 0, out: anchorSourceDuration(doc) }];
 }
-var outputLen = (seg, speeds) => totalDuration6(splitBySpeed3([seg], speeds));
-var segmentStarts = (segments, speeds) => {
+var segmentPieces = (seg, speeds, freezes, leading) => {
+  const own = freezes.filter(
+    (f) => f.at <= seg.out + 1e-9 && (leading ? f.at >= seg.in - 1e-9 : f.at > seg.in + 1e-9)
+  );
+  return withFreezes(splitBySpeed3([seg], speeds), own);
+};
+var outputLen = (seg, speeds, freezes = [], leading = true) => totalDuration6(segmentPieces(seg, speeds, freezes, leading));
+var segmentStarts = (segments, speeds, freezes = []) => {
   const starts = [];
   let acc = 0;
-  for (const s of segments) {
+  segments.forEach((s, i) => {
     starts.push(acc);
-    acc += outputLen(s, speeds);
-  }
+    acc += outputLen(s, speeds, freezes, i === 0 || !contiguous(segments, i));
+  });
   return starts;
 };
+var contiguous = (segments, i) => i > 0 && Math.abs(segments[i - 1].out - segments[i].in) < 1e-9;
 var videoLane = {
   id: "video",
   label: "Video",
   items(doc) {
     const segments = effectiveSegments(doc);
     const speeds = doc.speed ?? [];
-    const starts = segmentStarts(segments, speeds);
+    const freezes = docFreezes(doc);
+    const starts = segmentStarts(segments, speeds, freezes);
     return segments.map((s, i) => ({
       id: `seg-${i}`,
       kind: "clip",
-      t: starts[i],
-      duration: outputLen(s, speeds)
+      t: round10(starts[i]),
+      duration: round10(
+        outputLen(s, speeds, freezes, i === 0 || !contiguous(segments, i))
+      )
     }));
   },
   gesture(doc, g) {
     const segments = effectiveSegments(doc);
     const speeds = doc.speed ?? [];
+    const freezes = docFreezes(doc);
     const sourceDuration = anchorSourceDuration(doc);
     switch (g.type) {
       case "move": {
@@ -6705,7 +6843,7 @@ var videoLane = {
         let acc = 0;
         let insert = others.length;
         for (let i = 0; i < others.length; i++) {
-          const dur = outputLen(others[i], speeds);
+          const dur = outputLen(others[i], speeds, freezes);
           if (g.t < acc + dur / 2) {
             insert = i;
             break;
@@ -6723,10 +6861,15 @@ var videoLane = {
         const index = segIndex(g.id);
         if (index < 0 || index >= segments.length) return null;
         const seg = segments[index];
-        const starts = segmentStarts(segments, speeds);
+        const starts = segmentStarts(segments, speeds, freezes);
         const fullMap = splitBySpeed3([{ in: 0, out: sourceDuration }], speeds);
         const edgeSrc = g.edge === "start" ? seg.in : seg.out;
-        const edgeOutNow = g.edge === "start" ? starts[index] : starts[index] + outputLen(seg, speeds);
+        const edgeOutNow = g.edge === "start" ? starts[index] : starts[index] + outputLen(
+          seg,
+          speeds,
+          freezes.filter((f) => f.at < seg.out - 1e-9),
+          index === 0 || !contiguous(segments, index)
+        );
         const anchorOut = sourceToTimeline3(fullMap, Math.min(edgeSrc, sourceDuration)) ?? edgeSrc;
         const sourceT = mapTime2(fullMap, anchorOut + (g.t - edgeOutNow));
         const next = trimSegment(
@@ -6741,13 +6884,31 @@ var videoLane = {
         };
       }
       case "create": {
-        const starts = segmentStarts(segments, speeds);
+        const starts = segmentStarts(segments, speeds, freezes);
         const index = segments.findIndex(
-          (s2, i) => g.t >= starts[i] && g.t < starts[i] + outputLen(s2, speeds)
+          (s2, i) => g.t >= starts[i] && g.t < starts[i] + outputLen(
+            s2,
+            speeds,
+            freezes,
+            i === 0 || !contiguous(segments, i)
+          )
         );
         if (index < 0) return null;
         const s = segments[index];
-        const sourceT = mapTime2(splitBySpeed3([s], speeds), g.t - starts[index]);
+        const leading = index === 0 || !contiguous(segments, index);
+        const local = g.t - starts[index];
+        for (const m of freezeOutputExtents(
+          splitBySpeed3([s], speeds),
+          freezes.filter(
+            (f) => f.at <= s.out + 1e-9 && (leading ? f.at >= s.in - 1e-9 : f.at > s.in + 1e-9)
+          )
+        ).values()) {
+          if (local >= m.t - 1e-9 && local <= m.t + m.duration + 1e-9)
+            return null;
+        }
+        const sourceT = round10(
+          mapTime2(segmentPieces(s, speeds, freezes, leading), local)
+        );
         if (sourceT - s.in < 0.05 || s.out - sourceT < 0.05) return null;
         const next = [
           ...segments.slice(0, index),
@@ -6773,15 +6934,154 @@ var videoLane = {
   magnets(doc) {
     const segments = effectiveSegments(doc);
     const speeds = doc.speed ?? [];
-    const starts = segmentStarts(segments, speeds);
+    const freezes = docFreezes(doc);
+    const starts = segmentStarts(segments, speeds, freezes);
+    const n = segments.length;
     return [
       ...starts,
-      ...starts.length ? [
-        starts[starts.length - 1] + outputLen(segments[segments.length - 1], speeds)
+      ...n ? [
+        starts[n - 1] + outputLen(
+          segments[n - 1],
+          speeds,
+          freezes,
+          n === 1 || !contiguous(segments, n - 1)
+        )
       ] : []
-    ];
+    ].map(round10);
+  }
+};
+function nextFreezeId(doc) {
+  const taken = new Set((doc.freeze ?? []).map((f) => f.id));
+  let n = 0;
+  while (taken.has(`f${n}`)) n++;
+  return `f${n}`;
+}
+var FREEZE_GAP = 0.05;
+var freezeLane = {
+  id: "freeze",
+  label: "Freeze",
+  items(doc) {
+    const freezes = docFreezes(doc);
+    if (!freezes.length) return [];
+    const segs = effectiveSegments(doc);
+    const marks = freezeOutputExtents(
+      splitBySpeed3(segs, doc.speed ?? []),
+      freezes
+    );
+    return freezes.flatMap((f) => {
+      const m = marks.get(f.id);
+      return m ? [
+        {
+          id: f.id,
+          kind: "clip",
+          t: round10(m.t),
+          duration: round10(m.duration),
+          label: `${trimZeros(f.seconds)}s`
+        }
+      ] : [];
+    });
+  },
+  gesture(doc, g) {
+    const freezes = docFreezes(doc);
+    const segs = effectiveSegments(doc);
+    const speeds = doc.speed ?? [];
+    const sourceDuration = anchorSourceDuration(doc);
+    const kept = (t) => segs.some((s) => t >= s.in - 1e-9 && t <= s.out + 1e-9);
+    const clear = (t, except) => !freezes.some((f2) => f2.id !== except && Math.abs(f2.at - t) < FREEZE_GAP);
+    if (g.type === "create") {
+      const rated = ratedSegments(doc);
+      for (const m of freezeOutputExtents(
+        splitBySpeed3(segs, speeds),
+        freezes
+      ).values()) {
+        if (g.t >= m.t - 1e-9 && g.t <= m.t + m.duration + 1e-9) return null;
+      }
+      if (g.t > totalDuration6(rated) + 1e-9) return null;
+      const srcT = round10(mapTime2(rated, Math.max(0, g.t)));
+      if (!kept(srcT) || !clear(srcT)) return null;
+      const id = nextFreezeId(doc);
+      return (d) => {
+        d.freeze = [
+          ...d.freeze ?? [],
+          { id, at: srcT, seconds: FREEZE_DEFAULT_SECONDS }
+        ].sort((a, b) => a.at - b.at);
+      };
+    }
+    const f = freezes.find((x) => x.id === g.id);
+    if (!f) return null;
+    const own = (d) => {
+      const list = d.freeze ?? [];
+      let mine = list.find((x) => x.id === f.id);
+      if (!mine) {
+        const id = nextFreezeId(d);
+        mine = { id, at: f.at, seconds: f.seconds };
+        d.freeze = [...list, mine];
+        d.segments = d.segments.map((sg) => {
+          if (sg.hold === void 0 || Math.abs(sg.out - f.at) > 1e-9) return sg;
+          const next = { ...sg };
+          delete next.hold;
+          return next;
+        });
+      }
+      return mine;
+    };
+    const base = withFreezes(
+      splitBySpeed3(segs, speeds),
+      freezes.filter((x) => x.id !== f.id)
+    );
+    if (g.type === "move" || g.type === "resize" && g.edge === "start") {
+      const marks = freezeOutputExtents(splitBySpeed3(segs, speeds), freezes);
+      const mine = marks.get(f.id);
+      const endOut = mine ? mine.t + mine.duration : null;
+      const srcT = round10(
+        Math.min(sourceDuration, mapTime2(base, Math.max(0, g.t)))
+      );
+      if (!kept(srcT) || !clear(srcT, f.id)) return null;
+      return (d) => {
+        const x = own(d);
+        if (!x) return;
+        x.at = srcT;
+        if (g.type === "resize" && endOut !== null) {
+          const after = freezeOutputExtents(
+            splitBySpeed3(effectiveSegments(d), d.speed ?? []),
+            docFreezes({
+              ...d,
+              freeze: (d.freeze ?? []).map(
+                (y) => y.id === x.id ? { ...y, seconds: FREEZE_SECONDS_MIN } : y
+              )
+            })
+          ).get(x.id);
+          if (after) x.seconds = clampFreezeSeconds(endOut - after.t);
+        }
+        d.freeze.sort((a, b) => a.at - b.at);
+      };
+    }
+    if (g.type === "resize") {
+      const marks = freezeOutputExtents(splitBySpeed3(segs, speeds), freezes);
+      const mine = marks.get(f.id);
+      if (!mine) return null;
+      const seconds = clampFreezeSeconds(g.t - mine.t);
+      if (Math.abs(seconds - f.seconds) < 1e-6) return null;
+      return (d) => {
+        const x = own(d);
+        if (x) x.seconds = seconds;
+      };
+    }
+    if (g.type === "remove") {
+      return (d) => {
+        const x = own(d);
+        d.freeze = (d.freeze ?? []).filter((y) => y !== x);
+      };
+    }
+    return null;
+  },
+  magnets(doc) {
+    return freezeLane.items(doc).flatMap((it) => [it.t, it.t + (it.duration ?? 0)]);
   }
 };
+function trimZeros(n) {
+  return String(Math.round(n * 100) / 100);
+}
 var zoomLane = {
   id: "zoom",
   label: "Zoom",
@@ -7136,7 +7436,8 @@ var camLane = {
     if (!doc.source.camKey || !doc.cam.visible) return [];
     const segments = effectiveSegments(doc);
     const speeds = doc.speed ?? [];
-    const starts = segmentStarts(segments, speeds);
+    const freezes = docFreezes(doc);
+    const starts = segmentStarts(segments, speeds, freezes);
     const first = segments[0];
     const last = segments[segments.length - 1];
     const win = doc.cam.window ?? { in: first.in, out: last.out };
@@ -7145,11 +7446,16 @@ var camLane = {
       const a = Math.max(s.in, win.in);
       const b = Math.min(s.out, win.out);
       if (b - a <= 1e-6) return;
+      const leading = i === 0 || !contiguous(segments, i);
       items.push({
         id: `cam-${i}`,
         kind: "clip",
-        t: round10(starts[i] + outputLen({ in: s.in, out: a }, speeds)),
-        duration: round10(outputLen({ in: a, out: b }, speeds))
+        t: round10(
+          starts[i] + outputLen({ in: s.in, out: a }, speeds, freezes, leading)
+        ),
+        duration: round10(
+          outputLen({ in: a, out: b }, speeds, freezes, a === s.in && leading)
+        )
       });
     });
     return items;
@@ -7205,12 +7511,15 @@ var micLane = {
     if (!voiceKey(doc)) return [];
     const segments = effectiveSegments(doc);
     const speeds = doc.speed ?? [];
-    const starts = segmentStarts(segments, speeds);
+    const freezes = docFreezes(doc);
+    const starts = segmentStarts(segments, speeds, freezes);
     return segments.map((s, i) => ({
       id: `mic-${i}`,
       kind: "clip",
-      t: starts[i],
-      duration: outputLen(s, speeds)
+      t: round10(starts[i]),
+      duration: round10(
+        outputLen(s, speeds, freezes, i === 0 || !contiguous(segments, i))
+      )
     }));
   },
   gesture() {
@@ -7877,6 +8186,9 @@ export {
   FRAME_BORDER_COLOR_DEFAULT,
   FRAME_BORDER_DEFAULT,
   FRAME_BORDER_WIDTH_DEFAULT,
+  FREEZE_DEFAULT_SECONDS,
+  FREEZE_SECONDS_MAX,
+  FREEZE_SECONDS_MIN,
   HOUSE_GRADIENT,
   IDLE_KINDS,
   LAYOUT_FRAME_FIELDS,
@@ -7967,6 +8279,7 @@ export {
   clampCamFrac,
   clampCamSize,
   clampFocus,
+  clampFreezeSeconds,
   clampSpeedRate,
   clampTiltDeg,
   clampZoomLevel,
@@ -7984,6 +8297,7 @@ export {
   destinationById,
   destinationsForChannel,
   docCardLayout,
+  docFreezes,
   docOutputDuration,
   docRestTime,
   docToCropSpace,
@@ -8007,6 +8321,8 @@ export {
   focusBounds,
   followFocusEvents,
   frameGeometry,
+  freezeLane,
+  freezeOutputExtents,
   hexToRgbTriplet,
   houseLook,
   idleGaps,
@@ -8054,6 +8370,7 @@ export {
   pageDisplayUrl,
   parsePoseId,
   pickStyle,
+  placeFreezes,
   planAutoSpeed,
   planAutoTilt,
   planAutoZoom,
@@ -8089,6 +8406,7 @@ export {
   videoLane,
   voiceKey,
   withBackdrop,
+  withFreezes,
   withHolds,
   withoutRejected,
   wrapProgramLength,