@vosjs/studio-core 0.11.1 → 0.13.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;
@@ -538,30 +571,69 @@ function entranceSeconds(e) {
 function exitSeconds(e) {
   if (!e || e.kind === "none") return 0;
   const house = e.kind === "fade" ? CARD_FADE_SECONDS : END_CARD_RECEDE;
-  return Math.max(0.1, Math.min(3, e.seconds ?? house));
+  return Math.max(0.1, Math.min(8, 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);
@@ -591,8 +663,9 @@ function prependEntrance(track, head) {
   return { keyframes: sortKeyframes([...head, ...rest]) };
 }
 function exitPose(e) {
-  return e?.kind === "fade" ? [1, 0, 0] : [0.9, -0.02, 0.22];
+  return e?.kind === "fade" ? [1, 0, 0] : [0.9, -0.02, 0];
 }
+var RECEDE_MID = [0.91, -0.018, 0.8];
 function cardPoseTrack(enter, exit, footageEnd, outputEnd2 = footageEnd) {
   const keyframes = [];
   const s = entranceSeconds(enter);
@@ -602,16 +675,36 @@ function cardPoseTrack(enter, exit, footageEnd, outputEnd2 = footageEnd) {
     keyframes.push({ t: s, value: [1, 0, 1], ease: "power3.out" });
   }
   const x = exitSeconds(exit);
+  let last = [1, 0, 1];
   if (x > 0 && footageEnd > 0) {
-    const room = outputEnd2 - footageEnd;
-    const t0 = Math.max(s, room > 1e-6 ? footageEnd : footageEnd - x);
-    const t1 = room > 1e-6 ? t0 + Math.min(x, Math.max(0.1, room)) : t0 + x;
+    const t0 = round3(Math.max(s, footageEnd - x));
+    const t1 = round3(Math.max(t0 + 0.05, footageEnd));
+    last = exitPose(exit);
     keyframes.push({ t: t0, value: [1, 0, 1], ease: "none" });
-    keyframes.push({ t: t1, value: exitPose(exit), ease: "power2.out" });
+    if (exit?.kind !== "fade") {
+      keyframes.push({
+        t: round3(t0 + (t1 - t0) * 0.45),
+        value: [...RECEDE_MID],
+        ease: "power2.out"
+      });
+      keyframes.push({ t: t1, value: last, ease: "power1.in" });
+    } else {
+      keyframes.push({ t: t1, value: last, ease: "power2.out" });
+    }
+  }
+  if (outputEnd2 > footageEnd + 1e-6 && footageEnd > 0) {
+    if (!keyframes.some((k) => Math.abs(k.t - footageEnd) < 1e-9))
+      keyframes.push({ t: footageEnd, value: [...last], ease: "none" });
+    keyframes.push({
+      t: round3(footageEnd + 1e-3),
+      value: [last[0], last[1], 0],
+      ease: "none"
+    });
   }
   if (!keyframes.length) return void 0;
   return { keyframes: sortKeyframes(keyframes) };
 }
+var round3 = (v) => Math.round(v * 1e3) / 1e3;
 function endCardClips(card, doc, endStart) {
   const seconds = Math.max(1, Math.min(8, card.seconds ?? END_CARD_SECONDS));
   const anim = { enter: "rise", exit: "none" };
@@ -704,9 +797,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,15 +843,25 @@ 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 segsNow = out.segments ?? segments;
+      const lastSeg = segsNow.at(-1);
+      const freezesNow = docFreezes({ segments: segsNow, freeze: out.freeze });
+      const rated = withFreezes(
+        splitBySpeed(segsNow, doc.speed ?? []),
+        freezesNow
+      );
       const endStart = totalDuration(rated);
+      const taken = new Set(freezesNow.map((f) => f.id));
+      let n = 0;
+      while (taken.has(`f${n}`)) n++;
+      out.freeze = [
+        ...freezesNow,
+        { id: `f${n}`, at: lastSeg.out, seconds, from: END_CARD_FROM }
+      ].sort((a, b) => a.at - b.at);
       nextOverlays = [...nextOverlays, ...endCardClips(card, doc, endStart)];
       nextFrame.anim = {
         ...nextFrame.anim ?? {},
-        exit: {
-          kind: "recede",
-          seconds: Math.min(END_CARD_RECEDE, seconds * 0.4)
-        }
+        exit: { kind: "recede", seconds }
       };
     }
     delete out.endCard;
@@ -767,12 +890,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 };
@@ -1815,14 +1938,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 round11 = (v) => Math.round(v * 1e4) / 1e4;
+  const round12 = (v) => Math.round(v * 1e4) / 1e4;
   return {
     k: spec.fx,
     u: unit,
     d: FX_DIR[spec.direction ?? "forward"] ?? 0,
-    st: round11(st),
-    dur: round11(dur),
-    tt: round11(st * (upperN - 1) + dur),
+    st: round12(st),
+    dur: round12(dur),
+    tt: round12(st * (upperN - 1) + dur),
     units,
     n
   };
@@ -2037,7 +2160,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 round3 = (n) => Math.round(n * 1e3) / 1e3;
+var round4 = (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 [];
@@ -2089,7 +2212,7 @@ function emit(keys, s, e) {
   push(keys, e + CURSOR_IDLE_FADE_IN, 1);
 }
 function push(keys, t, a) {
-  const rt = round3(t);
+  const rt = round4(t);
   if (keys.length > 0 && rt <= keys[keys.length - 1].t) {
     keys[keys.length - 1].a = a;
     return;
@@ -3147,7 +3270,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 ? [round4(rect.x), round4(rect.y), round4(rect.w), round4(rect.h)] : null;
+  return inside ? [round5(rect.x), round5(rect.y), round5(rect.w), round5(rect.h)] : null;
 }
 function extractClicks(track, segments, opts) {
   const out = [];
@@ -3172,11 +3295,11 @@ function extractClicks(track, segments, opts) {
     const upSrc = st + Math.max(pressLen, 0.02);
     const up = keptOutputEnd(segments, st, upSrc) ?? ot + CLICK_SYNTH_RELEASE;
     const click = {
-      ot: round4(ot),
-      up: round4(Math.max(up, ot + 0.02)),
-      st: round4(st),
-      x: round4(e.x),
-      y: round4(e.y),
+      ot: round5(ot),
+      up: round5(Math.max(up, ot + 0.02)),
+      st: round5(st),
+      x: round5(e.x),
+      y: round5(e.y),
       b: button
     };
     if (opts.rects && e.rect) {
@@ -3195,7 +3318,7 @@ function hexToRgbTriplet(hex) {
   const n = parseInt(h, 16);
   return [n >> 16, n >> 8 & 255, n & 255];
 }
-function round4(v) {
+function round5(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -3222,7 +3345,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);
@@ -3257,7 +3381,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: round5(tt), value: value.map(round5), ease });
+    keyframes.push({ t: round6(tt), value: value.map(round6), ease });
     return tt;
   };
   return { keyframes, push: push2 };
@@ -4753,10 +4877,13 @@ var ON_FRAME = `(ctx, content, dt) => {
       card.mesh.scale.x = cpv[0]; card.mesh.scale.y = cpv[0]
       card.mesh.position.y = cpv[1] * cpH
       if (card.mesh.material) card.mesh.material.opacity = cpv[2]
-    } 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))) {
+      // Gone past its clip: the mesh leaves the scene, not just its paint.
+      card.mesh.visible = cpv[2] > 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.visible === false)) {
       card.mesh.scale.x = 1; card.mesh.scale.y = 1
       card.mesh.position.y = 0
       if (card.mesh.material) card.mesh.material.opacity = 1
+      card.mesh.visible = true
     }
     var tilted = rx * rx + ry * ry > 1e-6
     if (card.texture && card.texture.generateMipmaps !== tilted) {
@@ -4788,14 +4915,14 @@ function studioLayerData(layers, duration) {
     // needs a decoded recording, which a sync lowering can't produce.
     audio: (layers.audio ?? []).map((c) => ({
       key: c.key,
-      start: round5(c.start),
-      in: round5(c.in),
-      out: round5(c.out),
-      gain: round5(c.gain),
+      start: round6(c.start),
+      in: round6(c.in),
+      out: round6(c.out),
+      gain: round6(c.gain),
       loop: !!c.loop,
-      len: round5(clipLength(c)),
+      len: round6(clipLength(c)),
       duck: !!c.duck,
-      env: clipEnvelope(c).map((p) => ({ t: round5(p.t), g: round5(p.g) }))
+      env: clipEnvelope(c).map((p) => ({ t: round6(p.t), g: round6(p.g) }))
     })),
     // Object clips: numbers resolved HERE; shapes are the drafted engine spec.
     ...layers.objects && layers.objects.length ? {
@@ -4808,17 +4935,17 @@ function studioLayerData(layers, duration) {
         } : o.asset.kind === "text3d" ? resolveText3dAsset(o.asset) : { kind: "gltf", key: o.asset.key },
         ...o.span ? {
           span: {
-            start: round5(o.span.start),
-            duration: round5(o.span.duration)
+            start: round6(o.span.start),
+            duration: round6(o.span.duration)
           }
         } : {},
-        x: round5(o.transform3d.x),
-        y: round5(o.transform3d.y),
-        z: round5(o.transform3d.z),
-        rx: round5(o.transform3d.rx),
-        ry: round5(o.transform3d.ry),
-        rz: round5(o.transform3d.rz),
-        scale: round5(o.transform3d.scale || OBJECT_DEFAULT_SCALE),
+        x: round6(o.transform3d.x),
+        y: round6(o.transform3d.y),
+        z: round6(o.transform3d.z),
+        rx: round6(o.transform3d.rx),
+        ry: round6(o.transform3d.ry),
+        rz: round6(o.transform3d.rz),
+        scale: round6(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.
@@ -4845,12 +4972,12 @@ function studioLayerData(layers, duration) {
         const base = {
           id: o.id,
           kind: o.kind,
-          start: round5(o.start),
-          dur: round5(Math.max(OVERLAY_MIN_DURATION, o.duration)),
-          x: round5(o.transform.x),
-          y: round5(o.transform.y),
-          scale: round5(o.transform.scale || 1),
-          rot: round5(o.transform.rotation || 0),
+          start: round6(o.start),
+          dur: round6(Math.max(OVERLAY_MIN_DURATION, o.duration)),
+          x: round6(o.transform.x),
+          y: round6(o.transform.y),
+          scale: round6(o.transform.scale || 1),
+          rot: round6(o.transform.rotation || 0),
           enter: enterKey(o),
           exit: exitKey(o),
           // Pose keyframes: a CLIP-LOCAL [x, y, scale, rot, opacity]
@@ -4871,7 +4998,7 @@ function studioLayerData(layers, duration) {
           return {
             ...base,
             key: o.key,
-            w: round5(o.width ?? OVERLAY_MEDIA_DEFAULT_WIDTH),
+            w: round6(o.width ?? OVERLAY_MEDIA_DEFAULT_WIDTH),
             radius: o.radius ?? OVERLAY_MEDIA_DEFAULT_RADIUS,
             opacity: o.opacity ?? 1,
             loop: !!o.loop,
@@ -4881,7 +5008,7 @@ function studioLayerData(layers, duration) {
             ...o.shadow ? { shadow: o.shadow } : {},
             ...o.border && o.border.width > 0 ? {
               border: {
-                width: round5(o.border.width),
+                width: round6(o.border.width),
                 color: o.border.color
               }
             } : {}
@@ -4901,11 +5028,11 @@ function studioLayerData(layers, duration) {
           // 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: round5(o.maxWidth) } : {},
-          ...st.letterSpacing ? { ls: round5(st.letterSpacing) } : {},
-          ...st.lineHeight !== OVERLAY_LINE_HEIGHT ? { lh: round5(st.lineHeight) } : {},
+          ...o.maxWidth ? { mw: round6(o.maxWidth) } : {},
+          ...st.letterSpacing ? { ls: round6(st.letterSpacing) } : {},
+          ...st.lineHeight !== OVERLAY_LINE_HEIGHT ? { lh: round6(st.lineHeight) } : {},
           ...st.align !== "center" ? { align: st.align } : {},
-          ...st.stroke ? { stroke: { c: st.stroke.color, w: round5(st.stroke.width) } } : {},
+          ...st.stroke ? { stroke: { c: st.stroke.color, w: round6(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).
@@ -4918,10 +5045,10 @@ function studioLayerData(layers, duration) {
           ...bx ? {
             box: {
               c: bx.color,
-              o: round5(bx.opacity),
-              px: round5(bx.padX),
-              py: round5(bx.padY),
-              r: round5(bx.radius)
+              o: round6(bx.opacity),
+              px: round6(bx.padX),
+              py: round6(bx.padY),
+              r: round6(bx.radius)
             }
           } : {},
           // Entrance animation: segmentation + timing normalized
@@ -4996,16 +5123,16 @@ 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: round5(seg.in),
-      out: round5(seg.out),
-      ...seg.rate !== void 0 && seg.rate !== 1 ? { rate: round5(seg.rate) } : {}
+      in: round6(seg.in),
+      out: round6(seg.out),
+      ...seg.rate !== void 0 && seg.rate !== 1 ? { rate: round6(seg.rate) } : {}
     })),
     frame: doc.frame,
     micGain: doc.micGain ?? 1,
     cursor: smoothed.map((p) => ({
-      t: round5(p.t),
-      x: round5(p.x),
-      y: round5(p.y)
+      t: round6(p.t),
+      x: round6(p.x),
+      y: round6(p.y)
     })),
     cursorStyle: doc.cursor,
     cursorSpace: { w: doc.source.meta.width, h: doc.source.meta.height },
@@ -5090,7 +5217,7 @@ function clickFxData(doc, rated) {
     }
   };
 }
-function round5(v) {
+function round6(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -5180,8 +5307,8 @@ function planAutoSpeed(track, opts) {
   accepted.sort((a, b) => a.in - b.in);
   return accepted.map((c, i) => ({
     id: `s${i}`,
-    in: round6(c.in),
-    out: round6(c.out),
+    in: round7(c.in),
+    out: round7(c.out),
     rate: clampSpeedRate(c.rate),
     source: "auto"
   }));
@@ -5234,7 +5361,7 @@ function collectRuns(evs, gap, minLen, emit2) {
   }
   flush();
 }
-function round6(v) {
+function round7(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -5411,16 +5538,16 @@ function momentsFromDoc(doc, plan, opts = {}) {
     return {
       id: `m${String(i + 1).padStart(2, "0")}`,
       kind: d.kind,
-      source: { in: round7(d.in), out: round7(d.out) },
-      output: output ? { in: round7(output.start), out: round7(output.end) } : null,
-      at: d.at === null ? null : round7(d.at),
-      outputAt: outAt ? round7(outAt.start) : null,
-      focus: d.focus ? { cx: round7(d.focus.cx), cy: round7(d.focus.cy) } : null,
+      source: { in: round8(d.in), out: round8(d.out) },
+      output: output ? { in: round8(output.start), out: round8(output.end) } : null,
+      at: d.at === null ? null : round8(d.at),
+      outputAt: outAt ? round8(outAt.start) : null,
+      focus: d.focus ? { cx: round8(d.focus.cx), cy: round8(d.focus.cy) } : null,
       rect: d.rect ? {
-        x: round7(d.rect.x),
-        y: round7(d.rect.y),
-        w: round7(d.rect.w),
-        h: round7(d.rect.h)
+        x: round8(d.rect.x),
+        y: round8(d.rect.y),
+        w: round8(d.rect.w),
+        h: round8(d.rect.h)
       } : null,
       ...d.clicks !== void 0 ? { clicks: d.clicks } : {},
       ...d.pings !== void 0 ? { pings: d.pings } : {},
@@ -5440,7 +5567,7 @@ function activityOf(bins, d) {
     sum += bins[i];
     n++;
   }
-  return n ? round7(sum / n) : null;
+  return n ? round8(sum / n) : null;
 }
 function saidOver(transcript, d) {
   if (!transcript?.length) return null;
@@ -5449,7 +5576,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 round7(v) {
+function round8(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -5638,7 +5765,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 = {}) {
@@ -5700,11 +5827,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 {
@@ -5715,12 +5864,14 @@ function clipsFrom(doc, from) {
 }
 function dropTemplate(doc, from) {
   const has = clipsFrom(doc, from);
-  if (!has.overlays.length && !has.objects.length && !has.audio.length)
+  const freezes = (doc.freeze ?? []).some((f) => f.from === from);
+  if (!has.overlays.length && !has.objects.length && !has.audio.length && !freezes)
     return doc;
   const out = { ...doc };
   if (doc.overlays) out.overlays = doc.overlays.filter((o) => o.from !== from);
   if (doc.objects) out.objects = doc.objects.filter((o) => o.from !== from);
   out.audio = doc.audio.filter((a) => a.from !== from);
+  if (doc.freeze) out.freeze = doc.freeze.filter((f) => f.from !== from);
   return out;
 }
 function applyTemplate(template, take, opts) {
@@ -5728,8 +5879,22 @@ function applyTemplate(template, take, opts) {
   const notes = [];
   const base = dropTemplate(take, from);
   const doc = structuredClone(base);
+  const tail = trailingFreeze(template);
+  const lastSeg = doc.segments.at(-1);
+  if (tail && opts.at === "end" && lastSeg) {
+    const own2 = (doc.freeze ?? []).filter(
+      (f) => Math.abs(f.at - lastSeg.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: lastSeg.out, seconds: tail.seconds, from }
+    ].sort((a, b) => a.at - b.at);
+  }
   const templateEnd = totalDuration4(ratedSegments(template));
-  const takeEnd = totalDuration4(ratedSegments(take));
+  const takeEnd = totalDuration4(ratedSegments(doc));
   const shift = shiftBy(opts.at, templateEnd, takeEnd);
   const own = new Map((take.overlays ?? []).map((o) => [o.id, o]));
   const overlays = (doc.overlays ?? []).filter(
@@ -5893,8 +6058,8 @@ function buildDigest(input) {
   return {
     digestVersion: DIGEST_VERSION,
     take: {
-      sourceDuration: round8(meta.durationMs / 1e3),
-      outputDuration: round8(input.outputDuration),
+      sourceDuration: round9(meta.durationMs / 1e3),
+      outputDuration: round9(input.outputDuration),
       width: meta.width,
       height: meta.height,
       captureWidth: meta.captureWidth ?? null,
@@ -5943,7 +6108,7 @@ function buildDigest(input) {
 function outputDurationOf(doc) {
   return docOutputDuration(doc);
 }
-function round8(v) {
+function round9(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -5969,20 +6134,20 @@ function setSpeedInRange(spans, srcIn, srcOut, rate) {
       continue;
     }
     if (srcIn - s.in >= MIN_REMAINDER)
-      kept.push({ ...s, out: round9(srcIn), source: "manual" });
+      kept.push({ ...s, out: round10(srcIn), source: "manual" });
     if (s.out - srcOut >= MIN_REMAINDER)
       kept.push({
         ...s,
         id: mintId(used),
-        in: round9(srcOut),
+        in: round10(srcOut),
         source: "manual"
       });
   }
   if (rate != null)
     kept.push({
       id: mintId(used),
-      in: round9(srcIn),
-      out: round9(srcOut),
+      in: round10(srcIn),
+      out: round10(srcOut),
       rate: clampSpeedRate(rate),
       source: "manual"
     });
@@ -5998,9 +6163,9 @@ function removeSourceRange(segments, srcIn, srcOut) {
       next.push(seg);
       continue;
     }
-    if (srcIn - seg.in >= MIN_SEGMENT) next.push({ ...seg, out: round9(srcIn) });
+    if (srcIn - seg.in >= MIN_SEGMENT) next.push({ ...seg, out: round10(srcIn) });
     if (seg.out - srcOut >= MIN_SEGMENT)
-      next.push({ ...seg, in: round9(srcOut) });
+      next.push({ ...seg, in: round10(srcOut) });
   }
   return next.length ? next : [...segments];
 }
@@ -6018,8 +6183,8 @@ function zoomSpanForRange(zoom, srcIn, srcOut) {
   while (used.has(`u${n}`)) n++;
   return {
     id: `u${n}`,
-    in: round9(start),
-    out: round9(end),
+    in: round10(start),
+    out: round10(end),
     level: DEFAULT_ZOOM_LEVEL,
     cx: 0.5,
     cy: 0.5,
@@ -6033,7 +6198,7 @@ function mintId(used) {
   used.add(id);
   return id;
 }
-function round9(v) {
+function round10(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -6676,33 +6841,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: round11(starts[i]),
+      duration: round11(
+        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": {
@@ -6714,7 +6890,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;
@@ -6732,10 +6908,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(
@@ -6750,13 +6931,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 = round11(
+          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),
@@ -6782,15 +6981,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(round11);
+  }
+};
+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: round11(m.t),
+          duration: round11(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 = round11(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 = round11(
+        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",
@@ -6802,8 +7140,8 @@ var zoomLane = {
         {
           id: z.id,
           kind: "clip",
-          t: round10(ext.start),
-          duration: round10(ext.end - ext.start),
+          t: round11(ext.start),
+          duration: round11(ext.end - ext.start),
           label: `${z.level.toFixed(2)}\xD7`
         }
       ];
@@ -6827,8 +7165,8 @@ var zoomLane = {
           ...d.zoom,
           {
             id,
-            in: round10(srcT),
-            out: round10(srcT + len),
+            in: round11(srcT),
+            out: round11(srcT + len),
             level: DEFAULT_ZOOM_LEVEL,
             cx,
             cy,
@@ -6859,8 +7197,8 @@ var zoomLane = {
       return (d) => {
         const z = d.zoom.find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round10(newIn);
-        z.out = round10(newIn + len);
+        z.in = round11(newIn);
+        z.out = round11(newIn + len);
         z.source = "manual";
         d.zoom.sort((a, b) => a.in - b.in);
       };
@@ -6889,8 +7227,8 @@ var zoomLane = {
       return (d) => {
         const z = d.zoom.find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round10(next.in);
-        z.out = round10(next.out);
+        z.in = round11(next.in);
+        z.out = round11(next.out);
         z.source = "manual";
       };
     }
@@ -6912,8 +7250,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: round10(clamp015(best.x / width)),
-    cy: round10(clamp015(best.y / height))
+    cx: round11(clamp015(best.x / width)),
+    cy: round11(clamp015(best.y / height))
   };
 }
 var tiltLane = {
@@ -6927,8 +7265,8 @@ var tiltLane = {
         {
           id: z.id,
           kind: "clip",
-          t: round10(ext.start),
-          duration: round10(ext.end - ext.start),
+          t: round11(ext.start),
+          duration: round11(ext.end - ext.start),
           label: `${formatDeg(z.rx)}\xB0/${formatDeg(z.ry)}\xB0`
         }
       ];
@@ -6951,8 +7289,8 @@ var tiltLane = {
           ...d.tilt ?? [],
           {
             id,
-            in: round10(srcT),
-            out: round10(srcT + len),
+            in: round11(srcT),
+            out: round11(srcT + len),
             rx: DEFAULT_TILT_POSE.rx,
             ry: DEFAULT_TILT_POSE.ry,
             source: "manual"
@@ -6982,8 +7320,8 @@ var tiltLane = {
       return (d) => {
         const z = (d.tilt ?? []).find((x) => x.id === g.id);
         if (!z || !d.tilt) return;
-        z.in = round10(newIn);
-        z.out = round10(newIn + len);
+        z.in = round11(newIn);
+        z.out = round11(newIn + len);
         z.source = "manual";
         d.tilt.sort((a, b) => a.in - b.in);
       };
@@ -7012,8 +7350,8 @@ var tiltLane = {
       return (d) => {
         const z = (d.tilt ?? []).find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round10(next.in);
-        z.out = round10(next.out);
+        z.in = round11(next.in);
+        z.out = round11(next.out);
         z.source = "manual";
       };
     }
@@ -7040,8 +7378,8 @@ var camMoveLane = {
         {
           id: z.id,
           kind: "clip",
-          t: round10(ext.start),
-          duration: round10(ext.end - ext.start),
+          t: round11(ext.start),
+          duration: round11(ext.end - ext.start),
           label: z.size != null ? `${Math.round(z.size * 100)}%` : "Move"
         }
       ];
@@ -7065,8 +7403,8 @@ var camMoveLane = {
           ...d.camMotion ?? [],
           {
             id,
-            in: round10(srcT),
-            out: round10(srcT + len),
+            in: round11(srcT),
+            out: round11(srcT + len),
             ...DEFAULT_CAM_POSE,
             source: "manual"
           }
@@ -7095,8 +7433,8 @@ var camMoveLane = {
       return (d) => {
         const z = (d.camMotion ?? []).find((x) => x.id === g.id);
         if (!z || !d.camMotion) return;
-        z.in = round10(newIn);
-        z.out = round10(newIn + len);
+        z.in = round11(newIn);
+        z.out = round11(newIn + len);
         z.source = "manual";
         d.camMotion.sort((a, b) => a.in - b.in);
       };
@@ -7125,8 +7463,8 @@ var camMoveLane = {
       return (d) => {
         const z = (d.camMotion ?? []).find((x) => x.id === g.id);
         if (!z) return;
-        z.in = round10(next.in);
-        z.out = round10(next.out);
+        z.in = round11(next.in);
+        z.out = round11(next.out);
         z.source = "manual";
       };
     }
@@ -7145,7 +7483,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 };
@@ -7154,11 +7493,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: round11(
+          starts[i] + outputLen({ in: s.in, out: a }, speeds, freezes, leading)
+        ),
+        duration: round11(
+          outputLen({ in: a, out: b }, speeds, freezes, a === s.in && leading)
+        )
       });
     });
     return items;
@@ -7185,7 +7529,7 @@ var camLane = {
         Math.max(first.in, last.out - span)
       );
       return (d) => {
-        d.cam.window = { in: round10(newIn), out: round10(newIn + span) };
+        d.cam.window = { in: round11(newIn), out: round11(newIn + span) };
       };
     }
     const overlapping = eff.map((s, i) => ({
@@ -7198,8 +7542,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: round10(Math.max(0, next.in)),
-        out: round10(Math.min(sourceDuration, next.out))
+        in: round11(Math.max(0, next.in)),
+        out: round11(Math.min(sourceDuration, next.out))
       };
     };
   },
@@ -7214,12 +7558,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: round11(starts[i]),
+      duration: round11(
+        outputLen(s, speeds, freezes, i === 0 || !contiguous(segments, i))
+      )
     }));
   },
   gesture() {
@@ -7273,8 +7620,8 @@ var speedLane = {
         {
           id: sp.id,
           kind: "clip",
-          t: round10(start),
-          duration: round10(end - start),
+          t: round11(start),
+          duration: round11(end - start),
           label: `${sp.rate}\xD7`
         }
       ];
@@ -7297,8 +7644,8 @@ var speedLane = {
           ...d.speed ?? [],
           {
             id,
-            in: round10(srcT),
-            out: round10(srcT + len),
+            in: round11(srcT),
+            out: round11(srcT + len),
             rate: DEFAULT_SPEED_RATE,
             source: "manual"
           }
@@ -7328,8 +7675,8 @@ var speedLane = {
       return (d) => {
         const s = d.speed?.find((x) => x.id === g.id);
         if (!s) return;
-        s.in = round10(newIn);
-        s.out = round10(newIn + len);
+        s.in = round11(newIn);
+        s.out = round11(newIn + len);
         s.source = "manual";
         d.speed.sort((a, b) => a.in - b.in);
       };
@@ -7358,8 +7705,8 @@ var speedLane = {
       return (d) => {
         const s = d.speed?.find((x) => x.id === g.id);
         if (!s) return;
-        s.in = round10(next.in);
-        s.out = round10(next.out);
+        s.in = round11(next.in);
+        s.out = round11(next.out);
         s.source = "manual";
       };
     }
@@ -7378,8 +7725,8 @@ var audioLane = {
     return doc.audio.map((c) => ({
       id: c.id,
       kind: "clip",
-      t: round10(c.start),
-      duration: round10(clipLength(c)),
+      t: round11(c.start),
+      duration: round11(clipLength(c)),
       label: c.name
     }));
   },
@@ -7390,7 +7737,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 = round10(start);
+        if (c) c.start = round11(start);
       };
     }
     if (g.type === "resize") {
@@ -7403,8 +7750,8 @@ var audioLane = {
           return (d) => {
             const c = d.audio.find((x) => x.id === g.id);
             if (!c) return;
-            c.start = round10(newStart2);
-            c.loopLen = round10(end - newStart2);
+            c.start = round11(newStart2);
+            c.loopLen = round11(end - newStart2);
           };
         }
         const delta = g.t - clip.start;
@@ -7413,22 +7760,22 @@ var audioLane = {
         return (d) => {
           const c = d.audio.find((x) => x.id === g.id);
           if (!c) return;
-          c.in = round10(newIn);
-          c.start = round10(newStart);
+          c.in = round11(newIn);
+          c.start = round11(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 = round10(newLen);
+          if (c) c.loopLen = round11(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 = round10(Math.max(c.in + 0.05, newOut));
+        if (c) c.out = round11(Math.max(c.in + 0.05, newOut));
       };
     }
     if (g.type === "remove") {
@@ -7441,8 +7788,8 @@ var audioLane = {
   },
   magnets(doc) {
     return doc.audio.flatMap((c) => [
-      round10(c.start),
-      round10(c.start + clipLength(c))
+      round11(c.start),
+      round11(c.start + clipLength(c))
     ]);
   }
 };
@@ -7460,7 +7807,7 @@ function poseItems(clipId, start, duration, motion) {
   return (motion ?? []).map((p, i) => ({
     id: `${clipId}::k${i}`,
     kind: "keyframe",
-    t: round10(start + Math.min(Math.max(0, p.at), duration))
+    t: round11(start + Math.min(Math.max(0, p.at), duration))
   }));
 }
 var overlaysLane = {
@@ -7471,8 +7818,8 @@ var overlaysLane = {
       {
         id: o.id,
         kind: "clip",
-        t: round10(o.start),
-        duration: round10(o.duration),
+        t: round11(o.start),
+        duration: round11(o.duration),
         label: o.kind === "text" ? o.text.split("\n")[0].slice(0, 24) || "Text" : o.kind === "image" ? "Image" : "Video"
       },
       // Pose diamonds render after the clips, so they sit on top.
@@ -7492,7 +7839,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 = round10(at);
+            if (p) p.at = round11(at);
           };
         }
         if (g.type === "remove") {
@@ -7521,8 +7868,8 @@ var overlaysLane = {
           {
             id,
             kind: "text",
-            start: round10(start),
-            duration: round10(len),
+            start: round11(start),
+            duration: round11(len),
             text: "Title",
             preset: "title",
             // Frame fractions: centered, lower-third — at any aspect ratio.
@@ -7537,7 +7884,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 = round10(start);
+        if (o) o.start = round11(start);
       };
     }
     if (g.type === "resize") {
@@ -7547,14 +7894,14 @@ var overlaysLane = {
         return (d) => {
           const o = (d.overlays ?? []).find((x) => x.id === g.id);
           if (!o) return;
-          o.start = round10(newStart);
-          o.duration = round10(end - newStart);
+          o.start = round11(newStart);
+          o.duration = round11(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 = round10(newLen);
+        if (o) o.duration = round11(newLen);
       };
     }
     return (d) => {
@@ -7563,8 +7910,8 @@ var overlaysLane = {
   },
   magnets(doc) {
     return (doc.overlays ?? []).flatMap((o) => [
-      round10(o.start),
-      round10(o.start + o.duration)
+      round11(o.start),
+      round11(o.start + o.duration)
     ]);
   }
 };
@@ -7577,8 +7924,8 @@ var objectsLane = {
       {
         id: o.id,
         kind: "clip",
-        t: round10(o.span?.start ?? 0),
-        duration: round10(o.span?.duration ?? outDur),
+        t: round11(o.span?.start ?? 0),
+        duration: round11(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).
@@ -7606,7 +7953,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 = round10(at);
+          if (p) p.at = round11(at);
         };
       }
       if (g.type === "remove") {
@@ -7627,7 +7974,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 = round10(start);
+        if (o?.span) o.span.start = round11(start);
       };
     }
     if (g.type === "resize") {
@@ -7638,14 +7985,14 @@ var objectsLane = {
         return (d) => {
           const o = (d.objects ?? []).find((x) => x.id === g.id);
           if (!o?.span) return;
-          o.span.start = round10(newStart);
-          o.span.duration = round10(end - newStart);
+          o.span.start = round11(newStart);
+          o.span.duration = round11(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 = round10(newLen);
+        if (o?.span) o.span.duration = round11(newLen);
       };
     }
     return (d) => {
@@ -7654,7 +8001,7 @@ var objectsLane = {
   },
   magnets(doc) {
     return (doc.objects ?? []).flatMap(
-      (o) => o.span ? [round10(o.span.start), round10(o.span.start + o.span.duration)] : []
+      (o) => o.span ? [round11(o.span.start), round11(o.span.start + o.span.duration)] : []
     );
   }
 };
@@ -7681,7 +8028,7 @@ function nextSpeedId(doc) {
 function segIndex(id) {
   return Number(id.replace("seg-", ""));
 }
-function round10(v) {
+function round11(v) {
   return Math.round(v * 1e3) / 1e3;
 }
 
@@ -7886,6 +8233,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,
@@ -7976,6 +8326,7 @@ export {
   clampCamFrac,
   clampCamSize,
   clampFocus,
+  clampFreezeSeconds,
   clampSpeedRate,
   clampTiltDeg,
   clampZoomLevel,
@@ -7993,6 +8344,7 @@ export {
   destinationById,
   destinationsForChannel,
   docCardLayout,
+  docFreezes,
   docOutputDuration,
   docRestTime,
   docToCropSpace,
@@ -8016,6 +8368,8 @@ export {
   focusBounds,
   followFocusEvents,
   frameGeometry,
+  freezeLane,
+  freezeOutputExtents,
   hexToRgbTriplet,
   houseLook,
   idleGaps,
@@ -8063,6 +8417,7 @@ export {
   pageDisplayUrl,
   parsePoseId,
   pickStyle,
+  placeFreezes,
   planAutoSpeed,
   planAutoTilt,
   planAutoZoom,
@@ -8098,6 +8453,7 @@ export {
   videoLane,
   voiceKey,
   withBackdrop,
+  withFreezes,
   withHolds,
   withoutRejected,
   wrapProgramLength,