@vosjs/studio-core 0.42.5 → 0.44.0

package/dist/index.js

@@ -3531,16 +3531,17 @@ function planAutoZoom(track, options) {
   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: round2(Math.max(0, d.t0 - lead)),
-    out: round2(d.t1 + hold),
-    level: clampZoomLevel(Math.min(Math.max(dragLevel, 1.1), maxLevel)),
-    cx: round2(d.nx),
-    cy: round2(d.ny),
-    focusMode: "auto",
-    source: "auto"
+  const dragWork = drags.map((d) => ({
+    in: Math.max(0, d.t0 - lead),
+    out: d.t1 + hold,
+    cx: d.nx,
+    cy: d.ny,
+    level: Math.min(Math.max(dragLevel, 1.1), maxLevel)
   }));
+  for (let i = 0; i + 1 < dragWork.length; i++) {
+    if (dragWork[i].out > dragWork[i + 1].in)
+      dragWork[i].out = dragWork[i + 1].in;
+  }
   const eligible = clusters.filter((c) => c.length >= minClusterClicks);
   const clickSpans = [];
   const dragReserved = surfaces.map((cluster, i) => {
@@ -3612,6 +3613,19 @@ function planAutoZoom(track, options) {
     if (typing[i].out > typing[i + 1].in) typing[i].out = typing[i + 1].in;
   }
   typing = typing.filter((t) => t.out - t.in >= 0.3);
+  for (const w of [...clickSpans, ...typing]) cedeTo(w, dragWork);
+  typing = typing.filter((t) => !t.dead && t.out - t.in >= 0.3);
+  for (const z of clickSpans) if (z.out - z.in < 0.3) z.dead = true;
+  const dragSpans = dragWork.filter((d) => d.out - d.in >= 0.3).map((d, i) => ({
+    id: `g${i}`,
+    in: round2(d.in),
+    out: round2(d.out),
+    level: clampZoomLevel(d.level),
+    cx: round2(d.cx),
+    cy: round2(d.cy),
+    focusMode: "auto",
+    source: "auto"
+  }));
   const zSpans = clickSpans.filter((s) => !s.dead).sort((a, b) => a.in - b.in).map((s, i) => ({
     id: `z${i}`,
     in: round2(s.in),
@@ -3645,6 +3659,17 @@ function planAutoZoom(track, options) {
   ]).filter((d) => firstStep === void 0 || d.out > firstStep);
   return within([...spans, ...dwells]).sort((a, b) => a.in - b.in);
 }
+function cedeTo(w, keep) {
+  for (const k of keep) {
+    if (w.dead || w.in >= k.out || w.out <= k.in) continue;
+    if (k.in <= w.in && k.out >= w.out) w.dead = true;
+    else if (k.in > w.in && k.out < w.out) {
+      if (k.in - w.in >= w.out - k.out) w.out = k.in;
+      else w.in = k.out;
+    } else if (k.in > w.in) w.out = k.in;
+    else w.in = k.out;
+  }
+}
 function typingSessions(track, width, height, typingGap) {
   const pings = track.filter((e) => e.type === "key").map((e) => ({ t: e.t / 1e3, rect: e.rect, x: e.x, y: e.y }));
   const all = [];
@@ -3791,7 +3816,7 @@ import {
   EASINGS,
   lerpArray as lerpArray2,
   sample as sample2,
-  segmentRate as segmentRate2,
+  segmentRate as segmentRate3,
   sortKeyframes as sortKeyframes2,
   sourceToTimeline,
   splitBySpeed as splitBySpeed3,
@@ -4245,6 +4270,51 @@ function sourceAt(rated, t) {
   return null;
 }
 
+// src/lower/loudness.ts
+var NORMALIZE_MIN_LUFS = -30;
+var NORMALIZE_MAX_LUFS = -6;
+var NORMALIZE_PEAK_CEILING_DB = -1;
+var NORMALIZE_MAX_LIFT_DB = 24;
+var finite = (v) => typeof v === "number" && Number.isFinite(v);
+var clamp014 = (v) => Math.max(0, Math.min(1, v));
+function loudnessMatches(clip) {
+  const l = clip.loudness;
+  return !!l && typeof l === "object" && finite(l.lufs) && typeof l.src === "string" && l.src === clip.key;
+}
+function clipGain(clip) {
+  const trim = finite(clip.gain) ? Math.max(0, clip.gain) : 1;
+  if (!finite(clip.normalize)) return { gain: clamp014(trim), basis: "gain" };
+  if (!clip.loudness || typeof clip.loudness !== "object")
+    return { gain: clamp014(trim), basis: "unmeasured" };
+  if (!loudnessMatches(clip)) return { gain: clamp014(trim), basis: "stale" };
+  const l = clip.loudness;
+  const target = Math.max(
+    NORMALIZE_MIN_LUFS,
+    Math.min(NORMALIZE_MAX_LUFS, clip.normalize)
+  );
+  const asked = Math.pow(10, (target - l.lufs) / 20) * trim;
+  let gain = asked;
+  let capped;
+  const lift = Math.pow(10, NORMALIZE_MAX_LIFT_DB / 20);
+  if (gain > lift) {
+    gain = lift;
+    capped = "lift";
+  }
+  if (finite(l.peakDb)) {
+    const peak = Math.pow(10, (NORMALIZE_PEAK_CEILING_DB - l.peakDb) / 20);
+    if (gain > peak) {
+      gain = peak;
+      capped = "peak";
+    }
+  }
+  return {
+    gain: Math.max(0, gain),
+    basis: "normalize",
+    asked,
+    ...capped ? { capped } : {}
+  };
+}
+
 // src/lower/audioEnvelope.ts
 function clipEnvelope(clip) {
   const span = clipLength(clip);
@@ -4256,7 +4326,7 @@ function clipEnvelope(clip) {
     fi *= scale;
     fo *= scale;
   }
-  const g = Math.max(0, Math.min(1, clip.gain));
+  const g = clipGain(clip).gain;
   const pts = [];
   pts.push({ t: clip.start, g: fi > 0 ? 0 : g });
   if (fi > 0) pts.push({ t: clip.start + fi, g });
@@ -4293,8 +4363,8 @@ function followFocusEvents(span, cursor, space, layout, options = {}) {
   }
   const pts = cursor.filter((e) => e.type === "move" || e.type === "down" || e.type === "up").map((e) => ({
     t: e.t / 1e3,
-    nx: clamp014(e.x / space.w),
-    ny: clamp014(e.y / space.h)
+    nx: clamp015(e.x / space.w),
+    ny: clamp015(e.y / space.h)
   }));
   if (!pts.length) return { entry: null, events: [] };
   const entry = clampFocus(span.cx, span.cy, level, layout, camera);
@@ -4372,7 +4442,7 @@ function sampleAt2(pts, t) {
   }
   return pts[pts.length - 1];
 }
-function clamp014(v) {
+function clamp015(v) {
   return Math.max(0, Math.min(1, v));
 }
 function round4(v) {
@@ -4709,6 +4779,114 @@ function round42(v) {
   return Math.round(v * 1e5) / 1e5;
 }
 
+// src/lower/anchor.ts
+import { segmentRate } from "@vosjs/timeline";
+var ELAPSED_PLACEHOLDER = "{elapsed}";
+var EPS = 1e-9;
+function sourceMomentToOutput(rated, t, media) {
+  if (!Number.isFinite(t)) return null;
+  let acc = 0;
+  let edge = null;
+  for (const p of rated) {
+    const rate = segmentRate(p);
+    const len = Math.max(0, p.out - p.in) / rate;
+    if (sameMedia(p.media, media)) {
+      if (t >= p.in - EPS && t < p.out - EPS)
+        return acc + Math.max(0, t - p.in) / rate;
+      if (edge === null && Math.abs(t - p.out) <= 1e-6) edge = acc + len;
+    }
+    acc += len;
+  }
+  return edge;
+}
+var isNum = (v) => typeof v === "number" && Number.isFinite(v);
+function stepElapsedMs(meta, step) {
+  const skips = Array.isArray(meta.skips) ? meta.skips : [];
+  for (const raw of skips) {
+    if (!raw || typeof raw !== "object") continue;
+    const s = raw;
+    if (!isNum(s.ms) || s.ms < 0) continue;
+    const named = step.id !== void 0 && (s.id === step.id || s.step === step.id) || s.step === step.step;
+    if (named) return s.ms;
+  }
+  const own = step.offCameraMs;
+  return isNum(own) && own >= 0 ? own : null;
+}
+function elapsedFor(meta, step) {
+  const own = stepElapsedMs(meta, step);
+  if (own !== null) return { ms: own };
+  const earlier = (meta.steps ?? []).filter((s) => s !== step && s.step < step.step).sort((a, b) => b.step - a.step);
+  for (const s of earlier) {
+    const ms = stepElapsedMs(meta, s);
+    if (ms !== null) return { ms, from: s };
+  }
+  return null;
+}
+function resolveAnchor(doc, anchor, rated) {
+  const source = mediaSource(doc, anchor.media);
+  if (!source) return { start: null, miss: "media" };
+  const meta = source.meta;
+  const step = findStep(meta.steps ?? [], anchor.step);
+  if (!step) return { start: null, miss: "step" };
+  const elapsed = elapsedFor(meta, step);
+  const extra = elapsed ? {
+    elapsedMs: elapsed.ms,
+    ...elapsed.from ? { elapsedFrom: elapsed.from } : {}
+  } : {};
+  if (step.skipped) return { start: null, step, miss: "skipped", ...extra };
+  const moment = anchor.at === "end" ? step.tEnd : step.tStart;
+  const out = sourceMomentToOutput(rated, moment, anchor.media);
+  if (out === null) return { start: null, step, miss: "cut", ...extra };
+  const offset = isNum(anchor.offset) ? anchor.offset : 0;
+  return { start: round33(Math.max(0, out + offset)), step, ...extra };
+}
+var round33 = (v) => Math.round(v * 1e3) / 1e3;
+function formatElapsed(ms) {
+  const s = Math.max(0, ms) / 1e3;
+  const plural = (n, unit) => `${n} ${unit}${n === 1 ? "" : "s"}`;
+  if (s < 9.5) return plural(Math.max(1, Math.round(s)), "second");
+  if (s < 57.5) return plural(Math.round(s / 5) * 5, "second");
+  const m = s / 60;
+  if (m < 59.5) return plural(Math.max(1, Math.round(m)), "minute");
+  const h = m / 60;
+  if (h < 47.5) return plural(Math.max(1, Math.round(h)), "hour");
+  return plural(Math.round(h / 24), "day");
+}
+function hasElapsed(text) {
+  if (typeof text === "string") return text.includes(ELAPSED_PLACEHOLDER);
+  return Array.isArray(text) && text.some(
+    (r) => typeof r?.text === "string" && r.text.includes(ELAPSED_PLACEHOLDER)
+  );
+}
+function fillElapsed(text, words) {
+  const fill = (s) => s.split(ELAPSED_PLACEHOLDER).join(words);
+  if (typeof text === "string") return fill(text);
+  return text.map(
+    (r) => typeof r.text === "string" && r.text.includes(ELAPSED_PLACEHOLDER) ? { ...r, text: fill(r.text) } : r
+  );
+}
+function anchoredClip(clip, doc, rated) {
+  if (!clip.anchor || typeof clip.anchor !== "object") return clip;
+  const r = resolveAnchor(doc, clip.anchor, rated);
+  let next = clip;
+  if (r.start !== null && r.start !== clip.start)
+    next = { ...next, start: r.start };
+  if (next.kind === "text" && r.elapsedMs !== void 0 && hasElapsed(next.text)) {
+    next = { ...next, text: fillElapsed(next.text, formatElapsed(r.elapsedMs)) };
+  }
+  return next;
+}
+function resolveOverlayAnchors(doc, rated) {
+  const overlays = Array.isArray(doc.overlays) ? doc.overlays : [];
+  if (!overlays.some((o) => o && o.anchor)) return doc;
+  return {
+    ...doc,
+    overlays: overlays.map(
+      (o) => o && o.anchor ? anchoredClip(o, doc, rated) : o
+    )
+  };
+}
+
 // src/lower/cursorIdle.ts
 var CURSOR_IDLE_HOLD = 1;
 var CURSOR_IDLE_FADE_OUT = 0.35;
@@ -6264,7 +6442,7 @@ var STUDIO_FRAME = `(ctx, content, dt) => {
 }`;
 
 // src/lower/extractClicks.ts
-import { segmentRate } from "@vosjs/timeline";
+import { segmentRate as segmentRate2 } from "@vosjs/timeline";
 var CLICK_FX_PRE = 0.06;
 var CLICK_RIPPLE_DUR = 0.45;
 var CLICK_PULSE_DUR = 0.35;
@@ -6277,7 +6455,7 @@ function outputAt(segments, sourceT, media) {
   if (!segments.length) return sourceT;
   let acc = 0;
   for (const s of segments) {
-    const rate = segmentRate(s);
+    const rate = segmentRate2(s);
     if (sameMedia(s.media, media) && sourceT >= s.in && sourceT <= s.out)
       return acc + (sourceT - s.in) / rate;
     acc += Math.max(0, s.out - s.in) / rate;
@@ -6288,7 +6466,7 @@ function keptOutputEnd(segments, sIn, sOut, media) {
   let acc = 0;
   let end = null;
   for (const p of segments) {
-    const rate = segmentRate(p);
+    const rate = segmentRate2(p);
     if (sameMedia(p.media, media)) {
       const ovIn = Math.max(sIn, p.in);
       const ovOut = Math.min(sOut, p.out);
@@ -6401,7 +6579,7 @@ function spanOutputExtent(segments, sIn, sOut, media) {
   let start = null;
   let end = null;
   for (const p of segments) {
-    const rate = segmentRate2(p);
+    const rate = segmentRate3(p);
     const len = Math.max(0, p.out - p.in) / rate;
     if (!sameMedia(p.media, media)) {
       acc += len;
@@ -8623,17 +8801,22 @@ function studioLayerData(input, duration, pins) {
     // preview scheduler and the export's offline mix). `duckEnv` (the mic-derived
     // duck multiplier curve) is merged in asynchronously by useComposition — it
     // needs a decoded recording, which a sync lowering can't produce.
-    audio: (layers.audio ?? []).map((c) => ({
-      key: c.key,
-      start: round8(c.start),
-      in: round8(c.in),
-      out: round8(c.out),
-      gain: round8(c.gain),
-      loop: !!c.loop,
-      len: round8(clipLength(c)),
-      duck: !!c.duck,
-      env: clipEnvelope(c).map((p) => ({ t: round8(p.t), g: round8(p.g) }))
-    })),
+    // A measured `normalize` sets the gain (it may exceed 1); a clip with
+    // no target keeps its own, byte for byte.
+    audio: (layers.audio ?? []).map((c) => {
+      const g = clipGain(c);
+      return {
+        key: c.key,
+        start: round8(c.start),
+        in: round8(c.in),
+        out: round8(c.out),
+        gain: round8(g.basis === "normalize" ? g.gain : c.gain),
+        loop: !!c.loop,
+        len: round8(clipLength(c)),
+        duck: !!c.duck,
+        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 ? {
       objects: layers.objects.map((o) => ({
@@ -8851,8 +9034,9 @@ function studioLayerData(input, duration, pins) {
   };
 }
 function lowerToComposition(input) {
-  const doc = migrateText(migrateMotion(input));
-  const rated = ratedSegments(doc);
+  const read = migrateText(migrateMotion(input));
+  const rated = ratedSegments(read);
+  const doc = resolveOverlayAnchors(read, rated);
   const transitions = docTransitions(doc);
   const footageEnd = durationSec(doc, rated);
   const duration = outputEnd(doc, footageEnd);
@@ -9066,8 +9250,9 @@ function loweredZoomSpans(doc, rated, transitions, layout, camera, zoomStyle) {
   });
 }
 function docZoomTrack(input) {
-  const doc = migrateText(migrateMotion(input));
-  const rated = ratedSegments(doc);
+  const read = migrateText(migrateMotion(input));
+  const rated = ratedSegments(read);
+  const doc = resolveOverlayAnchors(read, rated);
   const transitions = docTransitions(doc);
   const layout = docCardLayout(doc);
   const camera = cameraModel(doc.frame);
@@ -9795,14 +9980,16 @@ import { totalDuration as totalDuration5 } from "@vosjs/timeline";
 
 // src/audioBeds.ts
 import { totalDuration as totalDuration4 } from "@vosjs/timeline";
-var round33 = (v) => Math.round(v * 1e3) / 1e3;
+var round34 = (v) => Math.round(v * 1e3) / 1e3;
 function docOutputDuration(doc) {
-  const footage = totalDuration4(ratedSegments(doc));
-  return isRecordingDoc(doc) ? outputEnd(migrateMotion(doc), footage) : footage;
+  const rated = ratedSegments(doc);
+  const footage = totalDuration4(rated);
+  if (!isRecordingDoc(doc)) return footage;
+  return outputEnd(resolveOverlayAnchors(migrateMotion(doc), rated), footage);
 }
 function musicBedClip(input) {
-  const track = round33(input.trackDuration);
-  const output = round33(input.outputDuration);
+  const track = round34(input.trackDuration);
+  const output = round34(input.outputDuration);
   const clip = {
     id: input.id,
     key: input.key,
@@ -9817,7 +10004,7 @@ function musicBedClip(input) {
     fadeIn: 0,
     // A bed that just stops reads as a glitch; clamp so a very short cut
     // still spends most of its time at full level.
-    fadeOut: output > 0 ? Math.min(1.5, round33(output / 4)) : 1.5,
+    fadeOut: output > 0 ? Math.min(1.5, round34(output / 4)) : 1.5,
     duck: input.hasMic || void 0
   };
   if (output <= 0) return clip;
@@ -9836,28 +10023,28 @@ function isMusicBed(clip, outputDuration) {
   return Math.abs(placed - outputDuration) <= 1;
 }
 function refillAudioBeds(doc, prevDuration, nextDuration) {
-  const EPS2 = 0.05;
-  if (Math.abs(nextDuration - prevDuration) <= EPS2 || nextDuration <= 0) {
+  const EPS3 = 0.05;
+  if (Math.abs(nextDuration - prevDuration) <= EPS3 || nextDuration <= 0) {
     return false;
   }
   let changed = false;
   for (const clip of doc.audio) {
     if (clip.start >= nextDuration) continue;
     const placed = clip.loop ? Math.max(clip.out - clip.in, clip.loopLen ?? clip.out - clip.in) : clip.out - clip.in;
-    if (Math.abs(clip.start + placed - prevDuration) > EPS2) continue;
+    if (Math.abs(clip.start + placed - prevDuration) > EPS3) continue;
     const span = clip.out - clip.in;
-    const nextLen = round33(nextDuration - clip.start);
+    const nextLen = round34(nextDuration - clip.start);
     if (clip.loop) {
       if (nextLen >= span) {
         clip.loopLen = nextLen;
       } else {
         clip.loop = void 0;
         clip.loopLen = void 0;
-        clip.out = round33(clip.in + nextLen);
+        clip.out = round34(clip.in + nextLen);
       }
     } else {
       if (clip.in + nextLen <= clip.duration) {
-        clip.out = round33(clip.in + nextLen);
+        clip.out = round34(clip.in + nextLen);
       } else {
         clip.out = clip.duration;
         clip.loop = true;
@@ -10102,7 +10289,7 @@ function applyTemplate(template, take, opts) {
   const skipped = [];
   for (const clip of template.overlays ?? []) {
     const next = structuredClone(clip);
-    next.start = Math.max(0, round34(clip.start + shift));
+    next.start = Math.max(0, round35(clip.start + shift));
     next.from = from;
     const mine = own.get(clip.id);
     if (next.kind === "text") {
@@ -10131,7 +10318,7 @@ function applyTemplate(template, take, opts) {
   for (const clip of template.objects ?? []) {
     const next = structuredClone(clip);
     if (next.span)
-      next.span.start = Math.max(0, round34(next.span.start + shift));
+      next.span.start = Math.max(0, round35(next.span.start + shift));
     next.from = from;
     objects.push(next);
   }
@@ -10141,7 +10328,7 @@ function applyTemplate(template, take, opts) {
   );
   for (const clip of template.audio ?? []) {
     const next = structuredClone(clip);
-    next.start = Math.max(0, round34(clip.start + shift));
+    next.start = Math.max(0, round35(clip.start + shift));
     next.from = from;
     audio.push(next);
   }
@@ -10162,7 +10349,7 @@ function applyTemplate(template, take, opts) {
   }
   return { doc, notes };
 }
-var round34 = (v) => Math.round(v * 1e3) / 1e3;
+var round35 = (v) => Math.round(v * 1e3) / 1e3;
 
 // src/digest/geometry.ts
 var CROP_MIN_FRAC = 0.25;
@@ -10345,15 +10532,15 @@ function outputRangeToSource(doc, t0, t1) {
     srcOut: mapTime2(rated, Math.max(0, t1))
   };
 }
-var EPS = 1e-6;
+var EPS2 = 1e-6;
 var MIN_REMAINDER = 0.25;
 var MIN_SEGMENT = 0.05;
 function setSpeedInRange(spans, srcIn, srcOut, rate) {
-  if (srcOut - srcIn < EPS) return [...spans];
+  if (srcOut - srcIn < EPS2) return [...spans];
   const kept = [];
   const used = new Set(spans.map((s) => s.id));
   for (const s of spans) {
-    if (s.out <= srcIn + EPS || s.in >= srcOut - EPS) {
+    if (s.out <= srcIn + EPS2 || s.in >= srcOut - EPS2) {
       kept.push(s);
       continue;
     }
@@ -10378,12 +10565,12 @@ function setSpeedInRange(spans, srcIn, srcOut, rate) {
   return kept.sort((a, b) => a.in - b.in);
 }
 function removeSpeedInRange(spans, srcIn, srcOut) {
-  return spans.filter((s) => s.out <= srcIn + EPS || s.in >= srcOut - EPS);
+  return spans.filter((s) => s.out <= srcIn + EPS2 || s.in >= srcOut - EPS2);
 }
 function removeSourceRange(segments, srcIn, srcOut) {
   const next = [];
   for (const seg of segments) {
-    if (seg.out <= srcIn + EPS || seg.in >= srcOut - EPS) {
+    if (seg.out <= srcIn + EPS2 || seg.in >= srcOut - EPS2) {
       next.push(seg);
       continue;
     }
@@ -10395,11 +10582,11 @@ function removeSourceRange(segments, srcIn, srcOut) {
 }
 function zoomSpanForRange(zoom, srcIn, srcOut) {
   let start = srcIn;
-  const covering = zoom.find((z) => z.in <= start + EPS && z.out > start + EPS);
+  const covering = zoom.find((z) => z.in <= start + EPS2 && z.out > start + EPS2);
   if (covering) start = covering.out;
   let end = srcOut;
   for (const z of zoom) {
-    if (z.in >= start - EPS && z.in < end) end = z.in;
+    if (z.in >= start - EPS2 && z.in < end) end = z.in;
   }
   if (end - start < ZOOM_SPAN_MIN) return null;
   const used = new Set(zoom.map((z) => z.id));
@@ -10808,7 +10995,7 @@ function applyLook(frame, look, size, video, placement) {
 import {
   mapTime as mapTime3,
   removeSegment,
-  segmentRate as segmentRate3,
+  segmentRate as segmentRate4,
   sourceToTimeline as sourceToTimeline2,
   splitBySpeed as splitBySpeed4,
   totalDuration as totalDuration7,
@@ -11214,10 +11401,10 @@ function cursorFocusAt(doc, srcT) {
   let best = track[0];
   for (const e of track)
     if (Math.abs(e.t - ms) < Math.abs(best.t - ms)) best = e;
-  const clamp015 = (v) => Math.max(0, Math.min(1, v));
+  const clamp016 = (v) => Math.max(0, Math.min(1, v));
   return {
-    cx: round13(clamp015(best.x / width)),
-    cy: round13(clamp015(best.y / height))
+    cx: round13(clamp016(best.x / width)),
+    cy: round13(clamp016(best.y / height))
   };
 }
 var tiltLane = {
@@ -11549,7 +11736,7 @@ var micLane = {
 var spanDefaultLen = (sourceDuration) => Math.max(1, sourceDuration * 0.05);
 function rateAt(rated, srcT) {
   for (const p of rated)
-    if (srcT >= p.in - 1e-9 && srcT < p.out + 1e-9) return segmentRate3(p);
+    if (srcT >= p.in - 1e-9 && srcT < p.out + 1e-9) return segmentRate4(p);
   return 1;
 }
 function clampToKept(kept, newIn, len) {
@@ -11579,7 +11766,7 @@ var speedLane = {
       let start = null;
       let end = 0;
       for (const p of rated) {
-        const len = Math.max(0, p.out - p.in) / segmentRate3(p);
+        const len = Math.max(0, p.out - p.in) / segmentRate4(p);
         if (p.rate === sp.rate && p.in >= sp.in - 1e-9 && p.out <= sp.out + 1e-9) {
           if (start === null) start = acc;
           end = acc + len;
@@ -12085,6 +12272,133 @@ function duckCurve(rms, segments, durationSec2, opts = DEFAULT_DUCK) {
   return points;
 }
 
+// src/docFeatures.ts
+var overlaysOf = (doc) => Array.isArray(doc.overlays) ? doc.overlays : [];
+var audioOf = (doc) => Array.isArray(doc.audio) ? doc.audio : [];
+var anchored = (o) => !!o && !!o.anchor && typeof o.anchor === "object";
+function bakeAnchors(doc) {
+  const layers = overlaysOf(doc);
+  if (!layers.some(anchored)) return { doc, notes: [] };
+  const notes = [];
+  let resolved = doc;
+  if (isRecordingDoc(doc)) {
+    const rated = ratedSegments(migrateMotion(doc));
+    resolved = resolveOverlayAnchors(doc, rated);
+    for (const o of layers) {
+      if (!anchored(o) || !o.anchor) continue;
+      const r = resolveAnchor(doc, o.anchor, rated);
+      if (r.start === null)
+        notes.push(
+          `overlay ${o.id}: its step ${r.miss === "cut" ? "is cut out of the film" : r.miss === "skipped" ? "was skipped by the recorder" : "is not in the take"}, so it plays at its fallback start (${o.start.toFixed(2)}s)`
+        );
+    }
+  }
+  const overlays = overlaysOf(resolved).map((o) => {
+    if (!anchored(o)) return o;
+    const { anchor: _anchor, ...rest } = o;
+    return rest;
+  });
+  return { doc: { ...resolved, overlays }, notes };
+}
+var DOC_FEATURES = [
+  {
+    id: "text-runs",
+    since: "0.38.0",
+    name: "styled text runs",
+    before: "would draw those layers without their words",
+    uses: (doc) => overlaysOf(doc).filter((o) => o?.kind === "text" && Array.isArray(o.text)).length
+  },
+  {
+    id: "overlay-anchor",
+    since: "0.43.0",
+    name: "caption anchors",
+    before: "would show them at their fallback start",
+    uses: (doc) => overlaysOf(doc).filter(anchored).length,
+    bake: bakeAnchors
+  },
+  {
+    id: "text-elapsed",
+    since: "0.43.0",
+    name: "{elapsed} in text",
+    before: "would show the placeholder as it is written",
+    // Filled only on an anchored layer: anywhere else every release shows
+    // the placeholder as written.
+    uses: (doc) => overlaysOf(doc).filter(
+      (o) => anchored(o) && o.kind === "text" && hasElapsed(o.text)
+    ).length,
+    // The anchors' bake fills it.
+    bake: bakeAnchors
+  },
+  {
+    id: "audio-normalize",
+    since: "0.44.0",
+    name: "loudness targets on sound",
+    before: "would play those clips at their gain alone",
+    // Only a target that applies: one with no measurement for its key is
+    // ignored by every release alike.
+    uses: (doc) => audioOf(doc).filter((a) => a && clipGain(a).basis === "normalize").length,
+    bake: (doc) => {
+      const notes = [];
+      const audio = audioOf(doc).map((a) => {
+        if (!a || a.normalize === void 0) return a;
+        const { normalize: _normalize, ...rest } = a;
+        const g = clipGain(a);
+        if (g.basis !== "normalize") return rest;
+        const gain = Math.round(Math.min(1, g.gain) * 1e3) / 1e3;
+        if (g.gain > 1)
+          notes.push(
+            `audio ${a.id}: its target asks for gain ${g.gain.toFixed(2)}, which an older renderer cannot play; baked at 1, so it plays ${(20 * Math.log10(g.gain)).toFixed(1)} dB quieter than asked`
+          );
+        return { ...rest, gain };
+      });
+      return { doc: { ...doc, audio }, notes };
+    }
+  }
+];
+function compareVersions(a, b) {
+  const parts = (v) => v.trim().replace(/^v/, "").split(/[-+]/)[0].split(".").map((n) => parseInt(n, 10) || 0);
+  const x = parts(a);
+  const y = parts(b);
+  for (let i = 0; i < Math.max(x.length, y.length, 3); i++) {
+    const d = (x[i] ?? 0) - (y[i] ?? 0);
+    if (d) return d < 0 ? -1 : 1;
+  }
+  return 0;
+}
+function docFeatures(doc) {
+  const out = [];
+  for (const feature of DOC_FEATURES) {
+    const count = feature.uses(doc);
+    if (count > 0) out.push({ feature, count });
+  }
+  return out;
+}
+function featuresNewerThan(doc, version) {
+  return docFeatures(doc).filter(
+    (u) => compareVersions(u.feature.since, version) > 0
+  );
+}
+function bakeDocFeatures(doc, version) {
+  let next = structuredClone(doc);
+  const baked = [];
+  const unbakeable = [];
+  const notes = [];
+  const done = /* @__PURE__ */ new Set();
+  for (const { feature } of featuresNewerThan(doc, version)) {
+    if (!feature.bake) {
+      unbakeable.push(feature);
+      continue;
+    }
+    baked.push(feature);
+    if (done.has(feature.bake)) continue;
+    done.add(feature.bake);
+    const r = feature.bake(next);
+    next = r.doc;
+    notes.push(...r.notes);
+  }
+  return { doc: next, baked, unbakeable, notes };
+}
+
 // src/backdrop.ts
 function backdropMedia(backdrop) {
   return {
@@ -12205,10 +12519,12 @@ export {
   DIGEST_CROP_MAX,
   DIGEST_FULL_MAX,
   DIGEST_VERSION,
+  DOC_FEATURES,
   DOC_SCHEMA_VERSION,
   DRAG_FIT_LEVEL,
   DRAG_MIN_S,
   DRAG_MIN_TRAVEL_FRAC,
+  ELAPSED_PLACEHOLDER,
   END_CARD_FROM,
   END_CARD_RECEDE,
   END_CARD_SECONDS,
@@ -12245,6 +12561,10 @@ export {
   MIXED,
   MOTION_DELTA,
   MOTION_EASE,
+  NORMALIZE_MAX_LIFT_DB,
+  NORMALIZE_MAX_LUFS,
+  NORMALIZE_MIN_LUFS,
+  NORMALIZE_PEAK_CEILING_DB,
   OBJECT_DEFAULT_SCALE,
   OVERLAY_FONT_FACES,
   OVERLAY_LINE_HEIGHT,
@@ -12319,12 +12639,14 @@ export {
   ambientDrift,
   anchorKindOf,
   anchorSourceDuration,
+  anchoredClip,
   animStep,
   applyLook,
   applyTemplate,
   aspectRatioValue,
   audioLane,
   backdropMedia,
+  bakeDocFeatures,
   boldWeightFor,
   buildDigest,
   calloutBox,
@@ -12359,9 +12681,11 @@ export {
   clampZoomLevel,
   clearStyle,
   clipEnvelope,
+  clipGain,
   clipLength,
   clipsFrom,
   commonStyle,
+  compareVersions,
   computeCardLayout,
   computeMicRms,
   computePeaks,
@@ -12382,6 +12706,7 @@ export {
   destinationsForChannel,
   diffInput,
   docCardLayout,
+  docFeatures,
   docFreezes,
   docMediaList,
   docOutputDuration,
@@ -12395,6 +12720,7 @@ export {
   dropTemplate,
   duckCurve,
   effectiveSegments,
+  elapsedFor,
   endCardClips,
   enterKey,
   enterOf,
@@ -12410,13 +12736,16 @@ export {
   expectedFrameSize,
   exportSizeFor,
   extractClicks,
+  featuresNewerThan,
   findStep,
   focusBounds,
   focusForViewportCentre,
   followFocusEvents,
+  formatElapsed,
   frameGeometry,
   freezeLane,
   freezeOutputExtents,
+  hasElapsed,
   hexToRgb,
   hexToRgbTriplet,
   houseLook,
@@ -12455,6 +12784,7 @@ export {
   liveZoomStyleName,
   lookFromBrand,
   lookKindForGround,
+  loudnessMatches,
   lowerProgramDoc,
   lowerStudioDoc,
   lowerToComposition,
@@ -12532,7 +12862,9 @@ export {
   removeSourceRange,
   removeSpeedInRange,
   replaceRange,
+  resolveAnchor,
   resolveExportSize,
+  resolveOverlayAnchors,
   resolveOverlayBox,
   resolveOverlayStyle,
   resolvePins,
@@ -12556,8 +12888,10 @@ export {
   smoothCursor,
   snapOffset,
   snapRunWeight,
+  sourceMomentToOutput,
   spanOutputExtent,
   speedLane,
+  stepElapsedMs,
   studioAudioPlan,
   studioEntry,
   studioLayerData,