@vosjs/studio-core 0.43.0 → 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 = [];
@@ -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) {
@@ -8731,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) => ({
@@ -11326,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 = {
@@ -12197,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 {
@@ -12317,6 +12519,7 @@ export {
   DIGEST_CROP_MAX,
   DIGEST_FULL_MAX,
   DIGEST_VERSION,
+  DOC_FEATURES,
   DOC_SCHEMA_VERSION,
   DRAG_FIT_LEVEL,
   DRAG_MIN_S,
@@ -12358,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,
@@ -12439,6 +12646,7 @@ export {
   aspectRatioValue,
   audioLane,
   backdropMedia,
+  bakeDocFeatures,
   boldWeightFor,
   buildDigest,
   calloutBox,
@@ -12473,9 +12681,11 @@ export {
   clampZoomLevel,
   clearStyle,
   clipEnvelope,
+  clipGain,
   clipLength,
   clipsFrom,
   commonStyle,
+  compareVersions,
   computeCardLayout,
   computeMicRms,
   computePeaks,
@@ -12496,6 +12706,7 @@ export {
   destinationsForChannel,
   diffInput,
   docCardLayout,
+  docFeatures,
   docFreezes,
   docMediaList,
   docOutputDuration,
@@ -12525,6 +12736,7 @@ export {
   expectedFrameSize,
   exportSizeFor,
   extractClicks,
+  featuresNewerThan,
   findStep,
   focusBounds,
   focusForViewportCentre,
@@ -12572,6 +12784,7 @@ export {
   liveZoomStyleName,
   lookFromBrand,
   lookKindForGround,
+  loudnessMatches,
   lowerProgramDoc,
   lowerStudioDoc,
   lowerToComposition,