@pixerate/editor 0.82.0 → 0.83.0

package/dist/video-editor/index.js

@@ -15,6 +15,7 @@ import "../chunk-AGR4P4UZ.js";
 var VIDEO_FITS = ["contain", "cover", "fill", "none"];
 var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe"];
 var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
+var VIDEO_FADE_CURVES = ["linear", "equal-power", "s-curve", "exponential", "logarithmic"];
 var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
 var VIDEO_CLIP_TYPES = ["media", "text", "color"];
 
@@ -324,7 +325,9 @@ function parseVideoClip(v, path = "clip") {
       in: num(v.in, `${path}.in`, { optional: true, min: 0 }),
       speed: num(v.speed, `${path}.speed`, { optional: true, min: 0.05, max: 20 }),
       volume: parseVideoAnimatable(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
-      muted: bool(v.muted, `${path}.muted`)
+      muted: bool(v.muted, `${path}.muted`),
+      fadeInCurve: oneOf(v.fadeInCurve, VIDEO_FADE_CURVES, `${path}.fadeInCurve`),
+      fadeOutCurve: oneOf(v.fadeOutCurve, VIDEO_FADE_CURVES, `${path}.fadeOutCurve`)
     });
   if (type === "text")
     return compact({
@@ -426,15 +429,41 @@ function snapToVideoFrame(time, fps) {
   return Math.round(frame * 1e3 / fps * 1e3) / 1e3;
 }
 var videoFrames = (time, fps) => Math.round(time * fps / 1e3);
-function formatVideoTimecode(time, fps) {
+function isVideoDropFrameRate(fps) {
+  const nominal = Math.round(fps);
+  return (nominal === 30 || nominal === 60) && Math.abs(fps - nominal * 1e3 / 1001) < 5e-3;
+}
+var exactVideoRate = (fps) => {
+  const nominal = Math.round(fps);
+  return nominal !== fps && Math.abs(fps - nominal * 1e3 / 1001) < 5e-3 ? nominal * 1e3 / 1001 : fps;
+};
+var videoTimecodeFrames = (time, fps) => Math.max(0, Math.round(time * exactVideoRate(fps) / 1e3));
+function formatVideoTimecode(time, fps, dropFrame = isVideoDropFrameRate(fps)) {
+  return formatVideoTimecodeFrames(videoTimecodeFrames(time, fps), fps, dropFrame);
+}
+function formatVideoTimecodeFrames(frames, fps, dropFrame = isVideoDropFrameRate(fps)) {
   const base = Math.round(fps);
-  const total = Math.max(0, videoFrames(time, fps));
+  let total = Math.max(0, Math.round(frames));
+  const drop = dropFrame && isVideoDropFrameRate(fps);
+  if (drop) {
+    const skip = base / 15;
+    const perMinute = base * 60 - skip;
+    const perTen = perMinute * 10 + skip;
+    const tens = Math.floor(total / perTen);
+    const rest = total % perTen;
+    total += skip * 9 * tens + (rest > skip ? skip * Math.floor((rest - skip) / perMinute) : 0);
+  }
   const ff = total % base;
   const secs = Math.floor(total / base);
   const pad = (n2) => String(n2).padStart(2, "0");
-  return `${pad(Math.floor(secs / 3600))}:${pad(Math.floor(secs / 60) % 60)}:${pad(secs % 60)}:${pad(ff)}`;
+  return `${pad(Math.floor(secs / 3600))}:${pad(Math.floor(secs / 60) % 60)}:${pad(secs % 60)}${drop ? ";" : ":"}${pad(ff)}`;
 }
+var videoHourFrames = (fps, dropFrame = isVideoDropFrameRate(fps)) => {
+  const base = Math.round(fps);
+  return dropFrame && isVideoDropFrameRate(fps) ? base * 3600 - base / 15 * 54 : base * 3600;
+};
 var formatVideoSeconds = (time) => `${(time / 1e3).toFixed(2)} s`;
+var videoAssetHasSound = (asset) => !!asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
 function videoAssetMap(project) {
   return new Map(project.assets.map((a) => [a.id, a]));
 }
@@ -701,7 +730,7 @@ function retimeClipKeys(clip, fn) {
     if (isVideoKeyframes(v)) a.set(fn(v));
   }
 }
-var OPTIONAL_CLIP_FIELDS = ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "transition", "in", "speed", "volume", "muted", "color", "fontSize", "fontFamily", "fontWeight", "background"];
+var OPTIONAL_CLIP_FIELDS = ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "transition", "in", "speed", "volume", "muted", "color", "fontSize", "fontFamily", "fontWeight", "background"];
 var TIME_FIELDS = { slip_clip: ["delta"], roll_edit: ["delta"], slide_clip: ["delta"], lift_range: ["from", "to"], extract_range: ["from", "to"], split_at: ["at"] };
 var Editor = class {
   constructor(p) {
@@ -797,6 +826,7 @@ var Editor = class {
     const right = { ...structuredClone(clip), id: id ?? freshId(`${clip.id}-`, this.ids()), start: at, duration: end - at };
     delete right.transition;
     delete right.fadeIn;
+    delete right.fadeInCurve;
     const leftValues = clipAnimatables(clip);
     clipAnimatables(right).forEach((r, i) => {
       const [l, rr] = splitVideoAnimatable(leftValues[i].get(), at - clip.start);
@@ -806,6 +836,7 @@ var Editor = class {
     this.moveIn(right, at - clip.start);
     clip.duration = at - clip.start;
     delete clip.fadeOut;
+    if (clip.type === "media") delete clip.fadeOutCurve;
     track.clips.push(right);
     track.clips.sort((a, b) => a.start - b.start);
     return right;
@@ -1356,12 +1387,32 @@ function videoTitleFrame(project, clip, clipTime = 0) {
   return { time: clip.start, width: project.width, height: project.height, background: "rgba(0,0,0,0)", layers: [layer], audio: [] };
 }
 var clamp01 = (v) => Math.min(1, Math.max(0, v));
-function fadeGain(clip, time) {
+function videoFadeCurveGain(curve, x) {
+  const t = clamp01(x);
+  switch (curve) {
+    case "equal-power":
+      return Math.sin(t * Math.PI / 2);
+    case "s-curve":
+      return (1 - Math.cos(t * Math.PI)) / 2;
+    case "exponential":
+      return t * t * t;
+    case "logarithmic":
+      return 1 - (1 - t) * (1 - t);
+    default:
+      return t;
+  }
+}
+function fadeGain(clip, time, sound = false) {
   let g = 1;
-  if (clip.fadeIn) g *= clamp01((time - clip.start) / clip.fadeIn);
-  if (clip.fadeOut) g *= clamp01((videoClipEnd(clip) - time) / clip.fadeOut);
+  const shape = sound && clip.type === "media" ? clip : void 0;
+  if (clip.fadeIn) g *= videoFadeCurveGain(shape?.fadeInCurve, (time - clip.start) / clip.fadeIn);
+  if (clip.fadeOut) g *= videoFadeCurveGain(shape?.fadeOutCurve, (videoClipEnd(clip) - time) / clip.fadeOut);
   return g;
 }
+function videoClipSoundGain(clip, clipTime) {
+  const volume = clip.type === "media" ? videoValueAt(clip.volume, clipTime, 1) : 1;
+  return volume * fadeGain(clip, clip.start + Math.min(Math.max(clipTime, 0), clip.duration), true);
+}
 function activeOnTrack(track, time) {
   const out = [];
   for (const clip of sortedVideoClips(track)) {
@@ -1387,15 +1438,16 @@ function videoFrameAt(project, time) {
     for (const { clip, incoming, outgoing } of activeOnTrack(track, time)) {
       if (incoming?.type === "dip" && incoming.progress < 0.5) continue;
       if (outgoing?.type === "dip" && outgoing.progress >= 0.5) continue;
-      const fade = fadeGain(clip, Math.min(Math.max(time, clip.start), videoClipEnd(clip)));
+      const inside = Math.min(Math.max(time, clip.start), videoClipEnd(clip));
+      const fade = fadeGain(clip, inside);
       const level = (t, into) => t.type === "dip" ? Math.abs(1 - 2 * t.progress) : into ? t.progress : 1 - t.progress;
       const mix = (incoming ? level(incoming, true) : 1) * (outgoing ? level(outgoing, false) : 1);
       const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
       const sourceTime = sourceTimeAt(clip, time);
       const clipTime = time - clip.start;
-      const audible = asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
+      const audible = videoAssetHasSound(asset);
       if (audible && clip.type === "media" && !clip.muted && !track.muted) {
-        const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fade * mix;
+        const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fadeGain(clip, inside, true) * mix;
         audio.push({ clip: clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeed(clip) });
       }
       if (track.kind !== "video" || track.hidden) continue;
@@ -1424,6 +1476,223 @@ function videoFrameAt(project, time) {
   return { time, width: project.width, height: project.height, background: project.background ?? "#000000", layers, audio };
 }
 
+// src/video-editor/audio.ts
+var VIDEO_PEAK_BLOCK = 32;
+function buildVideoAudioPeaks(channels, sampleRate, blockSize = VIDEO_PEAK_BLOCK) {
+  if (!(sampleRate > 0)) throw new Error("The sample rate must be above 0.");
+  const length = channels.reduce((n2, c) => Math.max(n2, c.length), 0);
+  const blocks = Math.max(1, Math.ceil(length / blockSize));
+  const level0 = new Float32Array(blocks * 2);
+  for (let b = 0; b < blocks; b++) {
+    let lo = Infinity;
+    let hi = -Infinity;
+    const end = Math.min(length, (b + 1) * blockSize);
+    for (const channel of channels) {
+      for (let i = b * blockSize; i < Math.min(end, channel.length); i++) {
+        const v = channel[i];
+        if (!Number.isFinite(v)) continue;
+        if (v < lo) lo = v;
+        if (v > hi) hi = v;
+      }
+    }
+    level0[2 * b] = lo === Infinity ? 0 : lo;
+    level0[2 * b + 1] = hi === -Infinity ? 0 : hi;
+  }
+  const levels = [level0];
+  while (levels[levels.length - 1].length > 2) {
+    const below = levels[levels.length - 1];
+    const n2 = below.length / 2;
+    const up = new Float32Array(Math.ceil(n2 / 4) * 2);
+    for (let j = 0; j < up.length / 2; j++) {
+      let lo = Infinity;
+      let hi = -Infinity;
+      for (let i = 4 * j; i < Math.min(n2, 4 * j + 4); i++) {
+        lo = Math.min(lo, below[2 * i]);
+        hi = Math.max(hi, below[2 * i + 1]);
+      }
+      up[2 * j] = lo;
+      up[2 * j + 1] = hi;
+    }
+    levels.push(up);
+  }
+  return { sampleRate, length, blockSize, levels };
+}
+var videoAudioPeaksDuration = (peaks) => peaks.length * 1e3 / peaks.sampleRate;
+function videoAudioPeakRange(peaks, from, to) {
+  const blocks = peaks.levels[0].length / 2;
+  let a = Math.max(0, Math.floor(from * peaks.sampleRate / 1e3 / peaks.blockSize));
+  let b = Math.min(blocks, Math.ceil(to * peaks.sampleRate / 1e3 / peaks.blockSize));
+  if (b <= a) {
+    if (a >= blocks || to < 0) return { min: 0, max: 0 };
+    b = a + 1;
+  }
+  let min = Infinity;
+  let max = -Infinity;
+  const take = (level, i) => {
+    if (2 * i + 1 >= level.length) return;
+    if (level[2 * i] < min) min = level[2 * i];
+    if (level[2 * i + 1] > max) max = level[2 * i + 1];
+  };
+  for (let k = 0; a < b; k++) {
+    const level = peaks.levels[k];
+    if (k === peaks.levels.length - 1) {
+      for (let i = a; i < b; i++) take(level, i);
+      break;
+    }
+    while (a < b && a % 4) take(level, a++);
+    while (a < b && b % 4) take(level, --b);
+    a /= 4;
+    b /= 4;
+  }
+  return min === Infinity ? { min: 0, max: 0 } : { min, max };
+}
+function videoAudioPeakSpans(peaks, from, to, columns) {
+  const n2 = Math.max(0, Math.floor(columns));
+  const out = new Float32Array(n2 * 2);
+  const step = (to - from) / Math.max(1, n2);
+  for (let c = 0; c < n2; c++) {
+    const { min, max } = videoAudioPeakRange(peaks, from + c * step, from + (c + 1) * step);
+    out[2 * c] = min;
+    out[2 * c + 1] = max;
+  }
+  return out;
+}
+function videoClipWaveform(clip, peaks, columns) {
+  const n2 = Math.max(0, Math.floor(columns));
+  const out = new Float32Array(n2 * 2);
+  const speed = clip.speed ?? 1;
+  const start = clip.in ?? 0;
+  const step = clip.duration / Math.max(1, n2);
+  for (let c = 0; c < n2; c++) {
+    const { min, max } = videoAudioPeakRange(peaks, start + c * step * speed, start + (c + 1) * step * speed);
+    const gain = videoClipSoundGain(clip, (c + 0.5) * step);
+    out[2 * c] = min * gain;
+    out[2 * c + 1] = max * gain;
+  }
+  return out;
+}
+function videoWaveformPath(spans, width, height) {
+  const n2 = spans.length / 2;
+  if (!n2 || width <= 0 || height <= 0) return "";
+  const mid = height / 2;
+  const y = (v) => (mid - Math.max(-1, Math.min(1, v)) * mid).toFixed(1);
+  const x = (i) => ((i + 0.5) * (width / n2)).toFixed(1);
+  const floor = 0.5 / mid;
+  const top = [];
+  const bottom = [];
+  for (let i = 0; i < n2; i++) top.push(`${i ? "L" : "M"}${x(i)} ${y(Math.max(spans[2 * i + 1], floor))}`);
+  for (let i = n2 - 1; i >= 0; i--) bottom.push(`L${x(i)} ${y(Math.min(spans[2 * i], -floor))}`);
+  return `${top.join("")}${bottom.join("")}Z`;
+}
+function videoClipWaveformPath(clip, peaks, width, height) {
+  const columns = Math.max(1, Math.min(2e3, Math.ceil(width / 2)));
+  return videoWaveformPath(videoClipWaveform(clip, peaks, columns), width, height);
+}
+var videoPeakDb = (value) => Math.abs(value) > 1e-5 ? Math.max(-100, Math.round(200 * Math.log10(Math.abs(value))) / 10) : -100;
+function videoAudioLevels(peaks, from, to, buckets) {
+  const spans = videoAudioPeakSpans(peaks, from, to, buckets);
+  const step = (to - from) / Math.max(1, buckets);
+  return Array.from({ length: spans.length / 2 }, (_, i) => ({ start: from + i * step, end: from + (i + 1) * step, peakDb: videoPeakDb(Math.max(Math.abs(spans[2 * i]), Math.abs(spans[2 * i + 1]))) }));
+}
+function findVideoAudioSilences(peaks, from, to, options = {}) {
+  const threshold = options.thresholdDb ?? -40;
+  const minDuration = options.minDuration ?? 300;
+  const resolution = Math.max(1, options.resolution ?? 10);
+  const buckets = Math.max(1, Math.ceil((to - from) / resolution));
+  const out = [];
+  let run = null;
+  const levels = videoAudioLevels(peaks, from, to, buckets);
+  levels.forEach((l, i) => {
+    const quiet = l.peakDb < threshold;
+    if (quiet && run === null) run = l.start;
+    if ((!quiet || i === levels.length - 1) && run !== null) {
+      const end = quiet ? l.end : l.start;
+      if (end - run >= minDuration) out.push({ start: run, end });
+      run = null;
+    }
+  });
+  return out;
+}
+async function decodeVideoAudioPeaks(src, options = {}) {
+  const Offline = globalThis.OfflineAudioContext;
+  if (!Offline || typeof fetch === "undefined") throw new Error("Audio can only be decoded in a browser with Web Audio.");
+  const response = await fetch(src, options.signal ? { signal: options.signal } : {});
+  if (!response.ok) throw new Error(`"${src}" could not be loaded (${response.status}).`);
+  const data = await response.arrayBuffer();
+  let buffer;
+  try {
+    buffer = await new Offline(1, 1, 44100).decodeAudioData(data);
+  } catch {
+    throw new Error(`"${src}" has no sound this browser can decode.`);
+  }
+  return buildVideoAudioPeaks(Array.from({ length: buffer.numberOfChannels }, (_, i) => buffer.getChannelData(i)), buffer.sampleRate);
+}
+var VideoAudioPeaksCache = class {
+  constructor(loader = (asset) => decodeVideoAudioPeaks(asset.src)) {
+    this.loader = loader;
+  }
+  loader;
+  ready = /* @__PURE__ */ new Map();
+  pending = /* @__PURE__ */ new Map();
+  failed = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  /** The peaks if ready, without starting to load them. */
+  peek(asset) {
+    return this.ready.get(asset.src);
+  }
+  /** The peaks if ready; otherwise `undefined`, and loading starts (once) unless it failed. */
+  get(asset) {
+    const peaks = this.ready.get(asset.src);
+    if (!peaks && !this.failed.has(asset.src)) void this.load(asset).catch(() => {
+    });
+    return peaks;
+  }
+  /** Why loading an asset's peaks failed, if it did. */
+  error(asset) {
+    return this.failed.get(asset.src);
+  }
+  /** The peaks, loading them if needed. Rejects with a readable error. */
+  load(asset) {
+    const ready = this.ready.get(asset.src);
+    if (ready) return Promise.resolve(ready);
+    const failed = this.failed.get(asset.src);
+    if (failed) return Promise.reject(new Error(failed));
+    let pending = this.pending.get(asset.src);
+    if (!pending) {
+      pending = this.loader(asset).then(
+        (peaks) => {
+          this.pending.delete(asset.src);
+          this.ready.set(asset.src, peaks);
+          this.emit();
+          return peaks;
+        },
+        (e) => {
+          this.pending.delete(asset.src);
+          const message = `The sound of "${asset.id}" could not be read: ${e instanceof Error ? e.message : String(e)}`;
+          this.failed.set(asset.src, message);
+          this.emit();
+          throw new Error(message);
+        }
+      );
+      this.pending.set(asset.src, pending);
+    }
+    return pending;
+  }
+  /** Uses peaks the host already has (computed earlier or stored). */
+  set(src, peaks) {
+    this.ready.set(src, peaks);
+    this.failed.delete(src);
+    this.emit();
+  }
+  subscribe(fn) {
+    this.listeners.add(fn);
+    return () => this.listeners.delete(fn);
+  }
+  emit() {
+    for (const fn of this.listeners) fn();
+  }
+};
+
 // src/video-editor/render.ts
 var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var n = (v) => String(Math.round(v * 100) / 100);
@@ -1562,15 +1831,17 @@ function toVideoEdl(project, options = {}) {
   const track = options.track !== void 0 ? project.tracks.find((t) => t.id === options.track) : [...project.tracks].reverse().find((t) => t.kind === "video");
   if (!track) throw new Error(options.track !== void 0 ? `There is no track "${options.track}".` : "The project has no video track.");
   const fps = project.fps;
-  const tc = (ms) => formatVideoTimecode(ms, fps);
-  const rec0 = options.recordStart ?? 36e5;
+  const dropFrame = (options.dropFrame ?? true) && isVideoDropFrameRate(fps);
+  const tc = (ms) => formatVideoTimecode(ms, fps, dropFrame);
+  const rec0 = options.recordStart !== void 0 ? videoTimecodeFrames(options.recordStart, fps) : videoHourFrames(fps, dropFrame);
+  const rtc = (ms) => formatVideoTimecodeFrames(rec0 + videoTimecodeFrames(ms, fps), fps, dropFrame);
   const assets = videoAssetMap(project);
   const channel = track.kind === "video" ? "V" : "A";
-  const lines = [`TITLE: ${(options.title ?? project.name ?? "Untitled").toUpperCase()}`, "FCM: NON-DROP FRAME", ""];
+  const lines = [`TITLE: ${(options.title ?? project.name ?? "Untitled").toUpperCase()}`, `FCM: ${dropFrame ? "DROP FRAME" : "NON-DROP FRAME"}`, ""];
   let event = 0;
   const num2 = () => String(++event).padStart(3, "0");
   const sourceAt = (clip, time) => clip.type === "media" ? (clip.in ?? 0) + (time - clip.start) * videoClipSpeed(clip) : time - clip.start;
-  const row = (n2, reel, kind, srcIn, srcOut, recIn, recOut) => `${n2}  ${reel.padEnd(8)} ${channel.padEnd(5)} ${kind.padEnd(8)} ${tc(srcIn)} ${tc(srcOut)} ${tc(rec0 + recIn)} ${tc(rec0 + recOut)}`;
+  const row = (n2, reel, kind, srcIn, srcOut, recIn, recOut) => `${n2}  ${reel.padEnd(8)} ${channel.padEnd(5)} ${kind.padEnd(8)} ${tc(srcIn)} ${tc(srcOut)} ${rtc(recIn)} ${rtc(recOut)}`;
   for (const clip of sortedVideoClips(track)) {
     const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
     const reel = clip.type === "media" ? reelName(asset) : "BL";
@@ -1597,7 +1868,34 @@ function toVideoEdl(project, options = {}) {
   }
   return lines.join("\n");
 }
+function loudnormFilter(target = {}, measure = false) {
+  const I = target.integrated ?? -14;
+  const TP = target.truePeak ?? -1;
+  const LRA = target.range ?? 11;
+  if (!(I >= -70 && I <= -5)) throw new Error(`The loudness target must be between -70 and -5 LUFS (got ${I}); -14 suits streaming, -23 broadcast.`);
+  if (!(TP >= -9 && TP <= 0)) throw new Error(`The true peak ceiling must be between -9 and 0 dBTP (got ${TP}); -1 is usual.`);
+  if (!(LRA >= 1 && LRA <= 50)) throw new Error(`The loudness range must be between 1 and 50 LU (got ${LRA}).`);
+  const parts = [`loudnorm=I=${I}:TP=${TP}:LRA=${LRA}`];
+  const m = target.measured;
+  if (m && !measure) {
+    for (const [k, v] of Object.entries(m)) if (!Number.isFinite(v)) throw new Error(`The measured ${k} is not a number (${v}); measure again, or leave "measured" out for a one-pass normalisation.`);
+    parts.push(`measured_I=${m.integrated}:measured_TP=${m.truePeak}:measured_LRA=${m.range}:measured_thresh=${m.threshold}:offset=${m.offset}:linear=true`);
+  }
+  if (measure) parts.push("print_format=json");
+  return `${parts.join(":")},aresample=48000`;
+}
+function parseVideoLoudnessMeasurement(output) {
+  const blocks = output.match(/\{[^{}]*"input_i"[^{}]*\}/g);
+  if (!blocks) throw new Error("No loudness measurement found: pass the stderr of the command from toVideoLoudnessMeasure.");
+  const json = JSON.parse(blocks[blocks.length - 1]);
+  const n2 = (k) => Number(json[k]);
+  const m = { integrated: n2("input_i"), truePeak: n2("input_tp"), range: n2("input_lra"), threshold: n2("input_thresh"), offset: n2("target_offset") };
+  if (!Number.isFinite(m.integrated)) throw new Error("The mix is silent, so its loudness cannot be normalised.");
+  return m;
+}
 var sec = (ms) => String(Math.round(ms) / 1e3);
+var AFADE_CURVES = { linear: "tri", "equal-power": "qsin", "s-curve": "hsin", exponential: "cub", logarithmic: "ipar" };
+var afadeCurve = (curve) => curve && curve !== "linear" ? `:curve=${AFADE_CURVES[curve]}` : "";
 var even = (v) => Math.max(2, 2 * Math.round(v / 2));
 var ffmpegFilterValue = (s) => s.replace(/[\\':%]/g, (c) => `\\${c}`).replace(/[\\'[\],;]/g, (c) => `\\${c}`);
 var color = (c) => {
@@ -1622,6 +1920,12 @@ function atempo(speed) {
   return out;
 }
 function toVideoFfmpeg(project, options = {}) {
+  return buildFfmpeg(project, options, false);
+}
+function toVideoLoudnessMeasure(project, options = {}) {
+  return buildFfmpeg(project, { ...options, loudness: { ...options.loudness, measured: void 0 } }, true);
+}
+function buildFfmpeg(project, options, measure) {
   const notes = [];
   const assets = videoAssetMap(project);
   const D = videoProjectDuration(project);
@@ -1630,7 +1934,7 @@ function toVideoFfmpeg(project, options = {}) {
   const H = even(project.height);
   const fps = project.fps;
   const inputs = [];
-  const graph = [`color=c=${color(project.background ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(D)},format=yuva420p[base]`];
+  const graph = measure ? [] : [`color=c=${color(project.background ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(D)},format=yuva420p[base]`];
   const audio = [];
   let cur = "base";
   let usesDrawtext = false;
@@ -1661,8 +1965,8 @@ function toVideoFfmpeg(project, options = {}) {
         continue;
       }
       let index;
-      if (asset && asset.kind !== "audio" && track.kind === "video" && !track.hidden) index = input(clip, asset, lead, tail);
-      const audible = asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
+      if (!measure && asset && asset.kind !== "audio" && track.kind === "video" && !track.hidden) index = input(clip, asset, lead, tail);
+      const audible = videoAssetHasSound(asset);
       if (audible && clip.type === "media" && !clip.muted && !track.muted) {
         const ai = index ?? input(clip, asset, lead, tail);
         const trackGain = track.volume ?? 1;
@@ -1674,13 +1978,13 @@ function toVideoFfmpeg(project, options = {}) {
         if (before2 && clip.transition.type === "dip") chain2.push(`afade=t=in:st=0:d=${sec(clip.transition.duration / 2)}`);
         const after = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition?.type === "dip");
         if (after) chain2.push(`afade=t=out:st=${sec(span - after.transition.duration / 2)}:d=${sec(after.transition.duration / 2)}`);
-        if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}`);
-        if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}`);
+        if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}${afadeCurve(clip.fadeInCurve)}`);
+        if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}${afadeCurve(clip.fadeOutCurve)}`);
         chain2.push(`adelay=${Math.round(t0)}:all=1`);
         graph.push(`[${ai}:a]${chain2.join(",")}[a${audio.length}]`);
         audio.push(`[a${audio.length}]`);
       }
-      if (track.kind !== "video" || track.hidden) continue;
+      if (measure || track.kind !== "video" || track.hidden) continue;
       const enable = `enable='between(t,${sec(t0)},${sec(t0 + span)})'`;
       const next = `v${k++}`;
       const onTimeline = `(t*1000-${Math.round(clip.start)})`;
@@ -1767,14 +2071,23 @@ function toVideoFfmpeg(project, options = {}) {
       }
     }
   }
-  graph.push(`[${cur}]format=yuv420p[vout]`);
-  if (audio.length) graph.push(`${audio.join("")}amix=inputs=${audio.length}:normalize=0:duration=longest,apad,atrim=0:${sec(D)}[aout]`);
+  if (!measure) graph.push(`[${cur}]format=yuv420p[vout]`);
+  if (measure && !audio.length) throw new Error("Nothing on the timeline makes a sound, so there is no loudness to measure.");
+  const loudness = options.loudness || measure ? `,${loudnormFilter(options.loudness, measure)}` : "";
+  if (audio.length) graph.push(`${audio.join("")}amix=inputs=${audio.length}:normalize=0:duration=longest,apad,atrim=0:${sec(D)}${loudness}[aout]`);
+  if (options.loudness && !audio.length) notes.push("Nothing makes a sound, so there was no loudness to normalise.");
+  else if (options.loudness && !options.loudness.measured)
+    notes.push("Loudness is normalised in one pass, which adjusts the level as it goes; for a fixed gain that keeps the dynamics, run toVideoLoudnessMeasure first and pass its result as loudness.measured.");
   if (project.tracks.some((t) => t.clips.some((c) => c.type === "media" && assets.get(c.asset)?.kind === "video" && assets.get(c.asset)?.hasAudio === void 0)))
     notes.push('Video assets are assumed to have sound; set "hasAudio": false on any that do not, or ffmpeg will stop at a missing audio stream.');
   if (animated.size)
     notes.push(`Keyframed ${[...animated].sort().join(", ")} ${animated.size > 1 ? "are" : "is"} rendered as straight lines between keys, with eased segments sampled every two frames${animated.has("scale") ? "; animated scale needs ffmpeg 5 or later (scale with eval=frame)" : ""}.`);
   if (usesDrawtext) notes.push("Titles use drawtext, which needs an ffmpeg built with libfreetype (Homebrew's is not: check `ffmpeg -filters | grep drawtext`); pass titleImage to render them as images instead.");
   const filterComplex = graph.join(";");
+  if (measure) {
+    const args2 = ["-hide_banner", "-nostats", ...inputs.flat(), "-filter_complex", filterComplex, "-map", "[aout]", "-f", "null", "-"];
+    return { args: args2, command: ["ffmpeg", ...args2].map(shellQuote).join(" "), filterComplex, duration: D, notes };
+  }
   const args = [
     "-y",
     ...inputs.flat(),
@@ -1933,6 +2246,8 @@ var VideoPreviewEngine = class {
 var VideoEditorController = class {
   history;
   player;
+  /** Sound levels per asset, loaded on demand for waveforms and agents. */
+  audioPeaks;
   project;
   issues;
   selection = [];
@@ -1946,6 +2261,7 @@ var VideoEditorController = class {
   state;
   constructor(options = {}) {
     this.history = options.history ?? new HistoryManager();
+    this.audioPeaks = options.audioPeaks instanceof VideoAudioPeaksCache ? options.audioPeaks : new VideoAudioPeaksCache(options.audioPeaks);
     this.project = options.project ? parseVideoProject(options.project) : createVideoProject();
     this.issues = checkVideoProject(this.project);
     this.readOnly = options.readOnly ?? false;
@@ -2162,6 +2478,10 @@ var VideoEditorController = class {
   toFfmpeg(options = {}) {
     return toVideoFfmpeg(this.project, options);
   }
+  /** The ffmpeg command that measures the mix's loudness (see `toVideoLoudnessMeasure`). */
+  toLoudnessMeasure(options = {}) {
+    return toVideoLoudnessMeasure(this.project, options);
+  }
   /** One track as a CMX 3600 EDL. */
   toEdl(options = {}) {
     return toVideoEdl(this.project, options);
@@ -2169,6 +2489,7 @@ var VideoEditorController = class {
 };
 
 // src/video-editor/tools.ts
+var round = (ms) => Math.round(ms * 10) / 10;
 var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
 var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
 var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
@@ -2228,7 +2549,9 @@ var MEDIA_FIELDS = {
   in: MS("Where in the source it starts (default 0)"),
   speed: { type: "number", minimum: 0.05, maximum: 20, description: "Playback speed (default 1). Changing it keeps the stretch of source, so the clip gets shorter or longer." },
   volume: { type: "number", minimum: 0, maximum: 4, description: "Gain (1 = unchanged, default 1). A number replaces any keyframes; set_video_keyframes animates it." },
-  muted: { type: "boolean", description: "Silence this clip (default false)." }
+  muted: { type: "boolean", description: "Silence this clip (default false)." },
+  fadeInCurve: { type: "string", enum: [...VIDEO_FADE_CURVES], description: "Shape of the sound's fade in (default linear; the picture always fades linearly): linear, equal-power (steady loudness, best for crossfades), s-curve (gentle at both ends), exponential (slow start, natural from silence) or logarithmic (fast start)." },
+  fadeOutCurve: { type: "string", enum: [...VIDEO_FADE_CURVES], description: "Shape of the sound's fade out (default linear), the same choices as fadeInCurve; exponential sounds natural fading to silence." }
 };
 var TEXT_FIELDS = {
   text: { type: "string", minLength: 1, description: `The title's text ("\\n" breaks lines).` },
@@ -2432,27 +2755,59 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return { svg };
     }
   };
+  const LOUDNESS_TARGET = {
+    integrated: { type: "number", minimum: -70, maximum: -5, description: "Integrated loudness to reach, in LUFS (default -14, what streaming services play at; -16 for podcasts, -23 for EBU R128 broadcast)." },
+    truePeak: { type: "number", minimum: -9, maximum: 0, description: "Highest true peak, in dBTP (default -1)." },
+    range: { type: "number", minimum: 1, maximum: 50, description: "Loudness range, in LU (default 11)." }
+  };
   const exportFfmpeg = {
     name: "export_video_ffmpeg",
     title: "Export an ffmpeg command",
-    description: "Returns the ffmpeg command that renders the project to a file: { args (for spawn), command (one shell line), filterComplex, duration, notes on anything approximated }. Fails when the project has no clips.",
+    description: "Returns the ffmpeg command that renders the project to a file: { args (for spawn), command (one shell line), filterComplex, duration, notes on anything approximated }. With loudness, the mix is normalised to a target loudness (EBU R128); add loudness.measured from a measuring pass (export_video_loudness_measure) for an exact fixed gain. Fails when the project has no clips.",
     inputSchema: object({
       output: { type: "string", minLength: 1, description: "Output file name (default output.mp4)." },
-      crf: { type: "integer", minimum: 0, maximum: 51, description: "x264 quality, lower is better (default 18)." }
+      crf: { type: "integer", minimum: 0, maximum: 51, description: "x264 quality, lower is better (default 18)." },
+      loudness: object(
+        {
+          ...LOUDNESS_TARGET,
+          measured: object(
+            {
+              integrated: { type: "number", description: `Measured integrated loudness, LUFS (loudnorm's "input_i").` },
+              truePeak: { type: "number", description: 'Measured true peak, dBTP ("input_tp").' },
+              range: { type: "number", description: 'Measured loudness range, LU ("input_lra").' },
+              threshold: { type: "number", description: 'Measured gating threshold, LUFS ("input_thresh").' },
+              offset: { type: "number", description: 'Offset for the second pass, LU ("target_offset").' }
+            },
+            ["integrated", "truePeak", "range", "threshold", "offset"],
+            "What the measuring pass printed (the JSON at the end of its stderr), for a linear second pass that keeps the dynamics. Leave out for one-pass normalisation."
+          )
+        },
+        [],
+        "Normalise the mix's loudness (default: not normalised). An empty object uses -14 LUFS, -1 dBTP."
+      )
     }),
     annotations: { title: "Export an ffmpeg command", ...READ },
-    handler: ({ output, crf }) => controller.toFfmpeg({ ...output ? { output } : {}, ...crf !== void 0 ? { crf } : {} })
+    handler: ({ output, crf, loudness }) => controller.toFfmpeg({ ...output ? { output } : {}, ...crf !== void 0 ? { crf } : {}, ...loudness ? { loudness } : {} })
+  };
+  const exportLoudnessMeasure = {
+    name: "export_video_loudness_measure",
+    title: "Export a loudness measuring command",
+    description: "Returns the ffmpeg command for the first pass of a loudness normalisation: it mixes only the sound and prints its loudness as JSON at the end of stderr (input_i, input_tp, input_lra, input_thresh, target_offset) instead of writing a file. Pass those numbers as loudness.measured (integrated, truePeak, range, threshold, offset) to export_video_ffmpeg, with the same target. Fails when nothing makes a sound.",
+    inputSchema: object(LOUDNESS_TARGET),
+    annotations: { title: "Export a loudness measuring command", ...READ },
+    handler: (target) => controller.toLoudnessMeasure({ loudness: target })
   };
   const exportEdl = {
     name: "export_video_edl",
     title: "Export an EDL",
-    description: "Returns one track as a CMX 3600 edit decision list (text) for conforming in another editor: events with source and record timecode, dissolves, speed changes and clip names.",
+    description: "Returns one track as a CMX 3600 edit decision list (text) for conforming in another editor: events with source and record timecode (drop-frame at 29.97 and 59.94 fps unless dropFrame is false), dissolves, speed changes and clip names.",
     inputSchema: object({
       track: { ...TRACK_ID, description: "Track to export (default: the bottom video track)." },
-      title: { type: "string", description: "TITLE line (default: the project name)." }
+      title: { type: "string", description: "TITLE line (default: the project name)." },
+      dropFrame: { type: "boolean", description: "Drop-frame timecode (HH:MM:SS;FF). Default true at 29.97 and 59.94 fps, where it is the norm; ignored at other rates, which have no drop-frame form." }
     }),
     annotations: { title: "Export an EDL", ...READ },
-    handler: ({ track, title }) => ({ edl: controller.toEdl({ ...track ? { track } : {}, ...title ? { title } : {} }) })
+    handler: ({ track, title, dropFrame }) => ({ edl: controller.toEdl({ ...track ? { track } : {}, ...title ? { title } : {}, ...dropFrame !== void 0 ? { dropFrame } : {} }) })
   };
   const seek = {
     name: "seek_video",
@@ -2601,12 +2956,12 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const updateClip = {
     name: "update_video_clip",
     title: "Change a clip",
-    description: `Changes a clip's properties (one undo step): opacity, transform, fit, fades, name; for media volume, mute, speed (keeps the stretch of source, so the length changes) or asset; for titles text and style; for colours the colour. Fields in "remove" go back to their defaults. Use move / trim for timing. Returns the clip.`,
+    description: `Changes a clip's properties (one undo step): opacity, transform, fit, fades, name; for media volume, mute, the sound's fade curves, speed (keeps the stretch of source, so the length changes) or asset; for titles text and style; for colours the colour. Fields in "remove" go back to their defaults. Use move / trim for timing. Returns the clip.`,
     inputSchema: object(
       {
         clip: CLIP_ID,
         set: object({ ...CLIP_COMMON, ...MEDIA_FIELDS, asset: { ...ASSET_ID, description: "For media: play another asset (same in point)." }, ...TEXT_FIELDS, color: COLOR("Text colour, or a colour clip's fill") }, [], "Fields to replace (only those that fit the clip's type)."),
-        remove: { type: "array", items: { type: "string", enum: ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "in", "speed", "volume", "muted", "fontSize", "fontFamily", "fontWeight", "background"] }, description: "Fields to reset to their defaults." }
+        remove: { type: "array", items: { type: "string", enum: ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "in", "speed", "volume", "muted", "fontSize", "fontFamily", "fontWeight", "background"] }, description: "Fields to reset to their defaults." }
       },
       ["clip"]
     ),
@@ -2614,7 +2969,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     handler: ({ clip, set, remove }) => {
       const current = clipOut(project(), clip);
       if (current && set) {
-        const allowed = /* @__PURE__ */ new Set(["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", ...current.type === "media" ? ["in", "speed", "volume", "muted", "asset"] : current.type === "text" ? Object.keys(TEXT_FIELDS) : ["color"]]);
+        const allowed = /* @__PURE__ */ new Set(["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", ...current.type === "media" ? ["in", "speed", "volume", "muted", "asset", "fadeInCurve", "fadeOutCurve"] : current.type === "text" ? Object.keys(TEXT_FIELDS) : ["color"]]);
         const wrong = Object.keys(set).filter((k) => !allowed.has(k));
         if (wrong.length) throw new Error(`${wrong.map((k) => `"${k}"`).join(", ")} cannot be set on a ${current.type} clip; it takes ${[...allowed].join(", ")}.`);
       }
@@ -2771,7 +3126,74 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return { redone, ...redone ? { label } : {} };
     }
   };
-  const reads = [getProject, getFrame, findGaps, checkProject, renderFrame, exportFfmpeg, exportEdl, seek];
+  const soundRange = (args) => {
+    const p = project();
+    if (args.clip === void 0 === (args.asset === void 0)) throw new Error('Pass either "clip" (a media clip, times on the timeline) or "asset" (times in the source), not both.');
+    let asset;
+    let toSource = (t) => t;
+    let toOut = (t) => t;
+    let from;
+    let to;
+    if (args.clip !== void 0) {
+      const found = findVideoClip(p, args.clip);
+      if (!found) throw new Error(`There is no clip "${args.clip}"; get_video_project lists the clips.`);
+      const c = found.clip;
+      if (c.type !== "media") throw new Error(`Clip "${c.id}" is a ${c.type} clip and has no sound; pass a media clip.`);
+      asset = p.assets.find((a) => a.id === c.asset);
+      const speed = c.speed ?? 1;
+      toSource = (t) => (c.in ?? 0) + (t - c.start) * speed;
+      toOut = (s) => c.start + (s - (c.in ?? 0)) / speed;
+      from = Math.max(c.start, args.from ?? c.start);
+      to = Math.min(videoClipEnd(c), args.to ?? videoClipEnd(c));
+    } else {
+      asset = p.assets.find((a) => a.id === args.asset);
+      if (!asset) throw new Error(`There is no asset "${args.asset}"; the assets are ${p.assets.map((a) => `"${a.id}"`).join(", ") || "none"}.`);
+      from = args.from ?? 0;
+      to = args.to ?? asset.duration ?? 0;
+    }
+    if (!asset) throw new Error(`Clip "${args.clip}" uses a missing asset.`);
+    if (asset.kind === "image" || asset.hasAudio === false) throw new Error(`Asset "${asset.id}" has no sound.`);
+    if (!(to > from)) throw new Error(`The stretch to read is empty (${from}\u2013${to} ms); "to" must be after "from"${args.clip !== void 0 ? " and both inside the clip" : asset.duration === void 0 ? ', and the asset has no duration, so pass "to"' : ""}.`);
+    return { asset, from, to, toSource, toOut };
+  };
+  const SOUND_TARGET = {
+    clip: { ...CLIP_ID, description: "A media clip: read the stretch of source it plays, with times on the timeline. Pass this or asset." },
+    asset: { ...ASSET_ID, description: "A video or audio asset: read its source, with times in the source. Pass this or clip." },
+    from: MS("Start of the stretch (default: the clip's start, or 0 for an asset)"),
+    to: MS("End of the stretch (default: the clip's end, or the asset's duration)")
+  };
+  const SOUND_ANNOTATIONS = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true };
+  const audioLevels = {
+    name: "get_video_audio_levels",
+    title: "Read sound levels",
+    description: 'Measures how loud the source sound is over a clip or an asset, without changing anything: the peak level in dBFS (0 = full scale, -100 = silence) for each of "buckets" equal stretches, plus the loudest peak. Levels are the recording as it is, before clip volume and fades. Use it to find where speech or a beat starts, or to judge whether a clip is too loud. The first call for an asset decodes its file, which can take a moment.',
+    inputSchema: object({ ...SOUND_TARGET, buckets: { type: "integer", minimum: 1, maximum: 500, description: "How many equal stretches to measure (default 50)." } }),
+    annotations: { title: "Read sound levels", ...SOUND_ANNOTATIONS },
+    handler: async (args) => {
+      const r = soundRange(args);
+      const peaks = await controller.audioPeaks.load(r.asset);
+      const levels = videoAudioLevels(peaks, r.toSource(r.from), r.toSource(r.to), args.buckets ?? 50).map((l) => ({ start: round(r.toOut(l.start)), end: round(r.toOut(l.end)), peakDb: l.peakDb }));
+      return { asset: r.asset.id, from: r.from, to: r.to, peakDb: Math.max(...levels.map((l) => l.peakDb)), levels };
+    }
+  };
+  const findSilences = {
+    name: "find_video_silences",
+    title: "Find silences",
+    description: "Lists the stretches of a clip or an asset whose source sound stays below a level for at least a minimum length, as { start, end } ms (timeline times for a clip, so they can go straight to extract_video_range or split_video_at; source times for an asset). Use it to cut pauses, dead air or the gaps between takes. The first call for an asset decodes its file.",
+    inputSchema: object({
+      ...SOUND_TARGET,
+      thresholdDb: { type: "number", minimum: -100, maximum: 0, description: "Quieter than this peak level counts as silence, in dBFS (default -40; -50 for a quiet room, -30 over background noise)." },
+      minDuration: { type: "number", exclusiveMinimum: 0, description: "Shortest silence to report, in ms (default 300)." }
+    }),
+    annotations: { title: "Find silences", ...SOUND_ANNOTATIONS },
+    handler: async (args) => {
+      const r = soundRange(args);
+      const peaks = await controller.audioPeaks.load(r.asset);
+      const silences = findVideoAudioSilences(peaks, r.toSource(r.from), r.toSource(r.to), { thresholdDb: args.thresholdDb, minDuration: args.minDuration }).map((x) => ({ start: round(r.toOut(x.start)), end: round(r.toOut(x.end)) }));
+      return { asset: r.asset.id, from: r.from, to: r.to, silences, total: round(silences.reduce((n2, x) => n2 + x.end - x.start, 0)) };
+    }
+  };
+  const reads = [getProject, getFrame, findGaps, checkProject, renderFrame, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek];
   const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return {
     id: options.id ?? "video",
@@ -2804,6 +3226,17 @@ function videoRulerTicks(duration, pxPerSecond, fps) {
   }
   return ticks;
 }
+function videoClipShowsWaveform(clip, asset, mode = "audio") {
+  if (clip.type !== "media" || mode === "none" || !videoAssetHasSound(asset)) return false;
+  return mode === "all" || asset.kind === "audio";
+}
+var VIDEO_FADE_CURVE_LABELS = {
+  linear: "Linear",
+  "equal-power": "Equal power",
+  "s-curve": "S-curve",
+  exponential: "Exponential",
+  logarithmic: "Logarithmic"
+};
 function videoClipTint(clip, asset) {
   if (clip.type === "text") return "#a855f7";
   if (clip.type === "color") return clip.color;
@@ -2915,7 +3348,7 @@ function videoKeyframeRows(project, clipId, time) {
   const { clip } = at;
   const asset = clip.type === "media" ? videoAssetMap(project).get(clip.asset) : void 0;
   const visual = !(asset?.kind === "audio" || at.track.kind === "audio");
-  const audible = clip.type === "media" && (asset?.kind === "audio" || asset?.kind === "video" && asset.hasAudio !== false);
+  const audible = clip.type === "media" && videoAssetHasSound(asset);
   const properties = [...visual ? ["opacity"] : [], ...audible ? ["volume"] : [], ...visual ? VIDEO_TRANSFORM_PROPERTIES : []];
   const clipTime = playheadInClip(clip, time);
   return properties.map((property) => {
@@ -2972,35 +3405,45 @@ export {
   VIDEO_DEFAULT_TITLE_DURATION,
   VIDEO_EASE_NAMES,
   VIDEO_EDIT_OPS,
+  VIDEO_FADE_CURVES,
+  VIDEO_FADE_CURVE_LABELS,
   VIDEO_FITS,
   VIDEO_ISSUE_CODES,
   VIDEO_KEYFRAME_LIMITS,
   VIDEO_KEYFRAME_PROPERTIES,
+  VIDEO_PEAK_BLOCK,
   VIDEO_PLACEMENT_MODES,
   VIDEO_TIME_EPSILON,
   VIDEO_TRANSFORM_PROPERTIES,
   VIDEO_TRANSITION_TYPES,
   VIDEO_WIPE_DIRECTIONS,
+  VideoAudioPeaksCache,
   VideoEditorController,
   VideoPreviewEngine,
   allVideoClipIds,
   applyVideoEdits,
+  buildVideoAudioPeaks,
   checkVideoProject,
   createVideoEditorToolProvider,
   createVideoProject,
+  decodeVideoAudioPeaks,
   describeVideoProject,
   drawVideoFrame,
   ffmpegFilterValue,
+  findVideoAudioSilences,
   findVideoClip,
   findVideoGaps,
   formatVideoSeconds,
   formatVideoTimecode,
+  formatVideoTimecodeFrames,
+  isVideoDropFrameRate,
   isVideoKeyframes,
   nextFreeVideoSlot,
   parseVideoAnimatable,
   parseVideoAsset,
   parseVideoClip,
   parseVideoKeyframes,
+  parseVideoLoudnessMeasurement,
   parseVideoMarker,
   parseVideoProject,
   parseVideoTrack,
@@ -3019,9 +3462,15 @@ export {
   splitVideoAnimatable,
   toVideoEdl,
   toVideoFfmpeg,
+  toVideoLoudnessMeasure,
   videoAssetDropEdit,
+  videoAssetHasSound,
   videoAssetKindOf,
   videoAssetMap,
+  videoAudioLevels,
+  videoAudioPeakRange,
+  videoAudioPeakSpans,
+  videoAudioPeaksDuration,
   videoClipAfter,
   videoClipBefore,
   videoClipEnd,
@@ -3029,19 +3478,25 @@ export {
   videoClipKeyframes,
   videoClipLabel,
   videoClipOverhang,
+  videoClipShowsWaveform,
+  videoClipSoundGain,
   videoClipSourceRange,
   videoClipSpeed,
   videoClipTint,
+  videoClipWaveform,
+  videoClipWaveformPath,
   videoClipsAt,
   videoContactSheetSvg,
   videoDragLabel,
   videoDropTracks,
   videoEaseBezier,
   videoEaseProgress,
+  videoFadeCurveGain,
   videoFrameAt,
   videoFrameDuration,
   videoFrameToSvg,
   videoFrames,
+  videoHourFrames,
   videoIssueKey,
   videoKeyframeBreakpoints,
   videoKeyframeFfmpegExpr,
@@ -3050,15 +3505,18 @@ export {
   videoKeyframeValueEdit,
   videoKeysOf,
   videoOverlap,
+  videoPeakDb,
   videoProjectDuration,
   videoProjectSvg,
   videoRulerTicks,
   videoSnapPoints,
   videoTextStyle,
+  videoTimecodeFrames,
   videoTitleFrame,
   videoTrackSyncLocked,
   videoTransformAt,
   videoValueAt,
+  videoWaveformPath,
   videoWipeRect
 };
 //# sourceMappingURL=index.js.map