@pixerate/editor 0.84.0 → 0.86.0

package/dist/video-editor/index.js

@@ -340,6 +340,105 @@ function videoGradeFfmpegFilters(grade) {
   });
 }
 
+// src/video-editor/remap.ts
+function videoClipSourceTime(clip, clipTime) {
+  const base = clip.in ?? 0;
+  return clip.timeRemap ? base + videoValueAt(clip.timeRemap, clipTime, 0) : base + clipTime * (clip.speed ?? 1);
+}
+function videoClipSpeedAt(clip, clipTime) {
+  if (clip.type !== "media") return 1;
+  if (!clip.timeRemap) return clip.speed ?? 1;
+  const t = Math.min(Math.max(clipTime, 0), Math.max(0, clip.duration - 1));
+  return Math.max(0, videoClipSourceTime(clip, t + 1) - videoClipSourceTime(clip, t));
+}
+function videoSpeedRampKeys(segments) {
+  if (!segments.length) throw new Error("Give at least one stretch { duration, speed }.");
+  const keys = [];
+  let t = 0;
+  let v = 0;
+  segments.forEach((s, i) => {
+    if (!(s.duration > 0)) throw new Error(`Stretch ${i + 1} needs a duration above 0 ms.`);
+    for (const [name, x] of [["speed", s.speed], ["toSpeed", s.toSpeed]])
+      if (x !== void 0 && !(x >= 0 && x <= 20)) throw new Error(`Stretch ${i + 1}'s ${name} must be from 0 (a freeze) to 20; got ${x}.`);
+    const a = s.speed;
+    const b = s.toSpeed ?? s.speed;
+    const avg = (a + b) / 2;
+    let ease = "linear";
+    if (a !== b && avg > 0) {
+      ease = [1 / 3, 2 * a / (3 * (a + b)), 2 / 3, 1 - 2 * b / (3 * (a + b))].map((n2) => Math.round(n2 * 1e6) / 1e6);
+    }
+    keys.push({ t, v, ...ease === "linear" ? {} : { ease } });
+    t += s.duration;
+    v += avg * s.duration;
+  });
+  keys.push({ t, v });
+  return { keys: mergeLinear(keys), duration: t, source: v };
+}
+function mergeLinear(keys) {
+  const out = [keys[0]];
+  for (let i = 1; i < keys.length; i++) {
+    const prev = out[out.length - 1];
+    const k = keys[i];
+    const before = out.length > 1 ? out[out.length - 2] : null;
+    if (before && !before.ease && !prev.ease) {
+      const s1 = (prev.v - before.v) / (prev.t - before.t);
+      const s2 = (k.v - prev.v) / (k.t - prev.t);
+      if (Math.abs(s1 - s2) < 1e-9) {
+        out[out.length - 1] = k;
+        continue;
+      }
+    }
+    out.push(k);
+  }
+  return out;
+}
+function checkVideoTimeRemap(remap, path = "timeRemap") {
+  const { keys } = remap;
+  if (!keys.length) throw new Error(`${path} needs at least one key.`);
+  keys.forEach((k, i) => {
+    if (k.v < 0) throw new Error(`${path}.keys[${i}].v must be at least 0 (ms after the in point).`);
+    const next = keys[i + 1];
+    if (!next) return;
+    if (next.v < k.v - 1e-6) throw new Error(`${path}.keys[${i + 1}] goes back in the source (${next.v} ms after ${k.v} ms); a ramp only plays forwards, so make each value at least the one before.`);
+    if (!videoEaseBezier(k.ease)) return;
+    let prev = k.v;
+    for (let n2 = 1; n2 <= 32; n2++) {
+      const v = videoValueAt(remap, k.t + (next.t - k.t) * n2 / 32);
+      if (v < prev - 1e-3) throw new Error(`${path}.keys[${i}].ease overshoots, which would play backwards; use a curve that only moves forwards (or linear).`);
+      prev = v;
+    }
+  });
+}
+function videoTimeRemapSpan(remap) {
+  return { from: remap.keys[0].v, to: remap.keys[remap.keys.length - 1].v };
+}
+function videoTimeRemapBreakpoints(remap, step) {
+  const { points, holds } = videoKeyframeBreakpoints(remap, step);
+  const out = [];
+  points.forEach(([t, v], i) => {
+    out.push({ t, v });
+    if (holds.has(i) && points[i + 1]) out.push({ t: points[i + 1][0], v });
+  });
+  return out;
+}
+function videoSpeedRampEdit(clip, segments, ripple = true) {
+  const ramp = videoSpeedRampKeys(segments);
+  const offset = videoClipSourceTime(clip, 0) - (clip.in ?? 0);
+  return { op: "set_time_remap", clip: clip.id, keys: ramp.keys.map((k) => ({ ...k, v: k.v + offset })), duration: ramp.duration, ripple };
+}
+function videoFreezeFrameEdit(clip, at, duration, ripple = true) {
+  if (at < 0 || at > clip.duration) throw new Error(`${Math.round(at)} ms is outside clip "${clip.id}" (0\u2013${clip.duration} ms of clip time).`);
+  const remap = clip.timeRemap ?? { keys: [{ t: 0, v: 0 }, { t: clip.duration, v: clip.duration * (clip.speed ?? 1) }] };
+  const [left, right] = splitVideoAnimatable(remap, at);
+  const keys = [...left.keys.slice(0, -1), { ...left.keys[left.keys.length - 1], ease: "linear" }, ...right.keys.map((k) => ({ ...k, t: k.t + at + duration }))];
+  return { op: "set_time_remap", clip: clip.id, keys, duration: clip.duration + duration, ripple };
+}
+var videoSlowMotionRamp = (duration) => [
+  { duration: Math.max(1, duration / 2), speed: 1 },
+  { duration: 500, speed: 1, toSpeed: 0.3 },
+  { duration: 1500, speed: 0.3 }
+];
+
 // src/video-editor/parse.ts
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var fail = (path, what) => {
@@ -408,6 +507,18 @@ function parseVideoTransform(v, path) {
     rotation: parseVideoAnimatable(v.rotation, `${path}.rotation`, { optional: true })
   });
 }
+function parseVideoTimeRemap(v, speed, path) {
+  if (v === void 0) return void 0;
+  const remap = parseVideoAnimatable(v, path, { optional: true, min: 0 });
+  if (typeof remap === "number" || remap === void 0) return fail(path, "must be keyframes { keys: [{ t, v, ease }] } (v: ms of source after the in point)");
+  if (speed !== void 0 && speed !== 1) fail(path, 'cannot be used with a speed; a ramp sets the speed itself (remove "speed")');
+  try {
+    checkVideoTimeRemap(remap, path);
+  } catch (e) {
+    throw new Error(e.message.replace(/\.?$/, "."));
+  }
+  return remap;
+}
 function parseVideoClipAnimation(v, path) {
   if (v === void 0) return void 0;
   if (!isObject(v)) return fail(path, "must be an object { effect, duration }");
@@ -435,6 +546,18 @@ function parseVideoTransition(v, path) {
     audioCurve: oneOf(v.audioCurve, VIDEO_FADE_CURVES, `${path}.audioCurve`)
   });
 }
+function parseVideoTranscriptWords(v, path) {
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v)) return fail(path, "must be an array of { word, start, end } (ms in the source)");
+  const words = v.map((w, i) => {
+    if (!isObject(w)) return fail(`${path}[${i}]`, "must be an object { word, start, end }");
+    const word = str(w.word, `${path}[${i}].word`);
+    const start = num(w.start, `${path}[${i}].start`, { min: 0 });
+    const end = num(w.end, `${path}[${i}].end`, { min: start });
+    return { word, start, end };
+  });
+  return words.sort((a, b) => a.start - b.start);
+}
 function parseVideoAsset(v, path = "asset") {
   if (!isObject(v)) return fail(path, "must be an object");
   const kind = oneOf(v.kind, ["video", "audio", "image"], `${path}.kind`, false);
@@ -447,8 +570,10 @@ function parseVideoAsset(v, path = "asset") {
     width: num(v.width, `${path}.width`, { optional: true, positive: true }),
     height: num(v.height, `${path}.height`, { optional: true, positive: true }),
     hasAudio: bool(v.hasAudio, `${path}.hasAudio`),
-    poster: str(v.poster, `${path}.poster`, true)
+    poster: str(v.poster, `${path}.poster`, true),
+    transcript: parseVideoTranscriptWords(v.transcript, `${path}.transcript`)
   });
+  if (kind === "image" && asset.transcript) fail(`${path}.transcript`, "is only for video and audio assets");
   if (kind === "image" && asset.duration !== void 0) fail(`${path}.duration`, "is only for video and audio assets");
   return asset;
 }
@@ -480,6 +605,7 @@ function parseVideoClip(v, path = "clip") {
       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`),
+      timeRemap: parseVideoTimeRemap(v.timeRemap, v.speed, `${path}.timeRemap`),
       fadeInCurve: oneOf(v.fadeInCurve, VIDEO_FADE_CURVES, `${path}.fadeInCurve`),
       fadeOutCurve: oneOf(v.fadeOutCurve, VIDEO_FADE_CURVES, `${path}.fadeOutCurve`)
     });
@@ -575,6 +701,7 @@ var videoClipSpeed = (clip) => clip.type === "media" ? clip.speed ?? 1 : 1;
 function videoClipSourceRange(clip) {
   if (clip.type !== "media") return null;
   const start = clip.in ?? 0;
+  if (clip.timeRemap?.keys.length) return { in: start + clip.timeRemap.keys[0].v, out: start + clip.timeRemap.keys[clip.timeRemap.keys.length - 1].v };
   return { in: start, out: start + clip.duration * videoClipSpeed(clip) };
 }
 var videoFrameDuration = (fps) => 1e3 / fps;
@@ -914,6 +1041,7 @@ var VIDEO_EDIT_OPS = [
   "extract_range",
   "split_at",
   "set_keyframes",
+  "set_time_remap",
   "close_gaps",
   "add_marker",
   "update_marker",
@@ -941,11 +1069,14 @@ function mergeSpans(spans) {
   }
   return out;
 }
+var isRamped = (clip) => clip.type === "media" && !!clip.timeRemap;
 function clipAnimatables(clip) {
   const c = clip;
   const out = [
     { get: () => c.opacity, set: (v) => c.opacity = v },
-    { get: () => c.volume, set: (v) => c.volume = v }
+    { get: () => c.volume, set: (v) => c.volume = v },
+    // A speed ramp is keys in clip time too, so trims and splits keep it on the same frames of source.
+    { get: () => c.timeRemap, set: (v) => c.timeRemap = v }
   ];
   for (const p of VIDEO_TRANSFORM_PROPERTIES) out.push({ get: () => c.transform?.[p], set: (v) => c.transform && (c.transform[p] = v) });
   return out;
@@ -956,7 +1087,7 @@ function retimeClipKeys(clip, fn) {
     if (isVideoKeyframes(v)) a.set(fn(v));
   }
 }
-var OPTIONAL_CLIP_FIELDS = ["name", "opacity", "transform", "fit", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "transition", "in", "speed", "volume", "muted", "color", "fontSize", "fontFamily", "fontWeight", "background"];
+var OPTIONAL_CLIP_FIELDS = ["name", "opacity", "transform", "fit", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "transition", "in", "speed", "timeRemap", "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) {
@@ -1043,7 +1174,7 @@ var Editor = class {
   }
   /** Moves a clip's head `delta` later in time (start, in point and keys); the caller sets start and duration. */
   trimHead(clip, delta) {
-    this.moveIn(clip, delta);
+    if (!isRamped(clip)) this.moveIn(clip, delta);
     retimeClipKeys(clip, (v) => retimeVideoAnimatable(v, -delta));
   }
   /** Cuts `clip` at `at` (inside it): the left part keeps the id, the right part is returned. */
@@ -1060,7 +1191,7 @@ var Editor = class {
       if (isVideoKeyframes(l)) leftValues[i].set(l);
       if (isVideoKeyframes(rr)) r.set(rr);
     });
-    this.moveIn(right, at - clip.start);
+    if (!isRamped(right)) this.moveIn(right, at - clip.start);
     clip.duration = at - clip.start;
     delete clip.fadeOut;
     delete clip.animateOut;
@@ -1272,7 +1403,7 @@ var Editor = class {
         if (e.edge === "start") {
           const delta = e.to - clip.start;
           if (clip.duration - delta < minimum - VIDEO_TIME_EPSILON) refuse(`Trimming the start to ${formatVideoSeconds(e.to)} would leave "${clip.id}" shorter than a frame; it ends at ${formatVideoSeconds(end)}.`);
-          if (clip.type === "media") {
+          if (clip.type === "media" && !isRamped(clip)) {
             const sourceIn = (clip.in ?? 0) + delta * speed;
             if (sourceIn < -VIDEO_TIME_EPSILON) refuse(`"${clip.id}" starts ${Math.round((clip.in ?? 0) / speed)} ms into its source, so its start can move at most that far earlier (to ${formatVideoSeconds(clip.start - (clip.in ?? 0) / speed)}).`);
             clip.in = Math.max(0, sourceIn);
@@ -1300,7 +1431,7 @@ var Editor = class {
         } else {
           const duration = e.to - clip.start;
           if (duration < minimum - VIDEO_TIME_EPSILON) refuse(`Trimming the end to ${formatVideoSeconds(e.to)} would leave "${clip.id}" shorter than a frame; it starts at ${formatVideoSeconds(clip.start)}.`);
-          if (clip.type === "media") {
+          if (clip.type === "media" && !isRamped(clip)) {
             const asset = assets.get(clip.asset);
             const out = (clip.in ?? 0) + duration * speed;
             if (asset?.duration !== void 0 && out > asset.duration + VIDEO_TIME_EPSILON)
@@ -1356,6 +1487,8 @@ var Editor = class {
         for (const k of ["id", "type"]) if (k in set) refuse(`A clip's ${k} cannot be changed; delete it and add a new one.`);
         for (const k of e.remove ?? []) if (!OPTIONAL_CLIP_FIELDS.includes(k)) refuse(`"${k}" cannot be removed; removable fields are ${OPTIONAL_CLIP_FIELDS.join(", ")}.`);
         if ("speed" in set && (typeof set.speed !== "number" || !(set.speed > 0))) refuse('"speed" must be a number greater than 0 (1 = normal speed).');
+        if ("speed" in set && isRamped(at.clip)) refuse(`Clip "${at.clip.id}" has a speed ramp, which sets its speed; change the ramp, or remove it first.`);
+        if ("timeRemap" in set) refuse("Set a speed ramp with set_time_remap, which checks it against the media and moves later clips if asked.");
         let stretch = 1;
         if (at.clip.type === "media" && !("duration" in set)) {
           const was = videoClipSpeed(at.clip);
@@ -1375,6 +1508,56 @@ var Editor = class {
         at.track.clips.sort((a, b) => a.start - b.start);
         return this.outcomes.push({ op: e.op, clip: clip.id, track: at.track.id });
       }
+      case "set_time_remap": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        if (clip.type !== "media") refuse(`Clip "${clip.id}" is a ${clip.type === "text" ? "title" : "colour"}, so it has no source to ramp; only video and audio clips change speed.`);
+        const asset = this.asset(clip.asset);
+        if (asset.kind === "image") refuse(`Clip "${clip.id}" is a still ("${asset.id}"), so it has no motion to ramp.`);
+        const media = clip;
+        const end = videoClipEnd(media);
+        const duration = e.duration ?? media.duration;
+        if (!(duration >= 1e3 / this.p.fps - VIDEO_TIME_EPSILON)) refuse(`"duration" must be at least a frame (${Math.ceil(1e3 / this.p.fps)} ms).`);
+        if (e.keys === null) {
+          if (!media.timeRemap) refuse(`Clip "${clip.id}" has no speed ramp to remove.`);
+          const from = (media.in ?? 0) + media.timeRemap.keys[0].v;
+          if (asset.duration !== void 0 && from + duration > asset.duration + VIDEO_TIME_EPSILON)
+            refuse(`At normal speed from ${Math.round(from)} ms, "${clip.id}" would run past the end of "${asset.id}" (${asset.duration} ms); give a duration of at most ${Math.floor(asset.duration - from)} ms.`);
+          delete media.timeRemap;
+          media.in = from;
+          if (media.in < 1e-9) delete media.in;
+        } else {
+          if (!Array.isArray(e.keys) || !e.keys.length) refuse('"keys" must be a list of at least one { t, v, ease } (or null to remove the ramp).');
+          const remap = parseVideoTimeRemap({ keys: e.keys }, void 0, "keys");
+          remap.keys = sortVideoKeys(remap.keys);
+          checkVideoTimeRemap(remap, "keys");
+          const span = videoTimeRemapSpan(remap);
+          if (asset.duration !== void 0 && (media.in ?? 0) + span.to > asset.duration + VIDEO_TIME_EPSILON)
+            refuse(`The ramp plays ${Math.round(span.to)} ms of source from the in point (${media.in ?? 0} ms), past the end of "${asset.id}" (${asset.duration} ms); it can use at most ${Math.floor(asset.duration - (media.in ?? 0))} ms.`);
+          media.timeRemap = remap;
+          delete media.speed;
+        }
+        const newEnd = media.start + duration;
+        const outcome = { op: e.op, clip: clip.id, track: track.id };
+        if (Math.abs(newEnd - end) > VIDEO_TIME_EPSILON) {
+          if (e.ripple) {
+            const tracks = this.rippleTracks([track]);
+            if (newEnd < end) {
+              media.duration = duration;
+              this.close(tracks, newEnd, end);
+            } else {
+              const created = this.open(tracks, end, newEnd - end, /* @__PURE__ */ new Set([clip.id]));
+              media.duration = duration;
+              if (created.length) outcome.created = created;
+            }
+            outcome.rippled = tracks.map((t) => t.id);
+          } else {
+            if (newEnd > end) this.fits(track, end, newEnd - end, /* @__PURE__ */ new Set([clip.id]), `Lengthening "${clip.id}"`);
+            media.duration = duration;
+          }
+        }
+        return this.outcomes.push(outcome);
+      }
       case "set_transition": {
         const { track, clip } = this.clip(e.clip);
         this.unlocked(track);
@@ -1657,7 +1840,7 @@ function activeOnTrack(track, time) {
   }
   return out;
 }
-var sourceTimeAt = (clip, time) => clip.type === "media" ? (clip.in ?? 0) + (time - clip.start) * videoClipSpeed(clip) : 0;
+var sourceTimeAt = (clip, time) => clip.type === "media" ? videoClipSourceTime(clip, time - clip.start) : 0;
 function videoFrameAt(project, time) {
   const assets = videoAssetMap(project);
   const layers = [];
@@ -1677,7 +1860,7 @@ function videoFrameAt(project, time) {
       const audible = videoAssetHasSound(asset);
       if (audible && clip.type === "media" && !clip.muted && !track.muted) {
         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) });
+        audio.push({ clip: clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeedAt(clip, clipTime) });
       }
       if (track.kind !== "video" || track.hidden) continue;
       if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
@@ -1941,6 +2124,171 @@ var VideoAudioPeaksCache = class {
   }
 };
 
+// src/video-editor/transcript.ts
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function cueTime(s) {
+  const m = s.trim().match(/^(?:(\d+):)?(\d{1,2}):(\d{1,2})[.,](\d{1,3})$/);
+  if (!m) throw new Error(`"${s.trim()}" is not a cue time (HH:MM:SS,mmm).`);
+  return ((Number(m[1] ?? 0) * 60 + Number(m[2])) * 60 + Number(m[3])) * 1e3 + Number(m[4].padEnd(3, "0"));
+}
+function cueWords(text, start, end) {
+  const words = text.replace(/<[^>]+>/g, "").split(/\s+/).filter(Boolean);
+  const step = (end - start) / Math.max(1, words.length);
+  return words.map((word, i) => ({ word, start: Math.round(start + i * step), end: Math.round(start + (i + 1) * step) }));
+}
+function parseVideoTranscript(input) {
+  let data = input;
+  if (typeof input === "string") {
+    const text = input.replace(/^/, "").trim();
+    if (text.startsWith("{") || text.startsWith("[")) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        throw new Error("The transcript looks like JSON but is not valid JSON.");
+      }
+    } else {
+      const words2 = [];
+      for (const block of text.replace(/\r\n?/g, "\n").split(/\n{2,}/)) {
+        const lines = block.split("\n");
+        const at = lines.findIndex((l) => l.includes("-->"));
+        if (at < 0) continue;
+        const [a, b] = lines[at].split("-->");
+        words2.push(...cueWords(lines.slice(at + 1).join(" "), cueTime(a), cueTime(b.trim().split(/\s+/)[0])));
+      }
+      if (!words2.length) throw new Error("No words found: expected Whisper-style JSON with word timings, SubRip (.srt) or WebVTT.");
+      return { words: words2, approximate: true };
+    }
+  }
+  const seconds = (v) => typeof v === "number" && Number.isFinite(v) ? Math.round(v * 1e3) : NaN;
+  const fromList = (list, toMs) => list.map((w, i) => {
+    if (!isRecord(w)) throw new Error(`Word ${i + 1} is not an object { word, start, end }.`);
+    const word = String(w.word ?? w.text ?? "").trim();
+    const start = toMs(w.start);
+    const end = toMs(w.end);
+    if (!word || !Number.isFinite(start) || !Number.isFinite(end)) throw new Error(`Word ${i + 1} needs a word and numeric start and end.`);
+    return { word, start, end: Math.max(start, end) };
+  });
+  let words = [];
+  if (Array.isArray(data)) words = fromList(data, (v) => typeof v === "number" ? v : NaN);
+  else if (isRecord(data) && Array.isArray(data.words)) words = fromList(data.words, seconds);
+  else if (isRecord(data) && Array.isArray(data.segments)) {
+    const segments = data.segments.filter(isRecord);
+    if (segments.some((s) => Array.isArray(s.words))) words = fromList(segments.flatMap((s) => Array.isArray(s.words) ? s.words : []), seconds);
+    else {
+      for (const s of segments) words.push(...cueWords(String(s.text ?? ""), seconds(s.start), seconds(s.end)));
+      if (!words.length) throw new Error("No words found in the segments.");
+      return { words, approximate: true };
+    }
+  }
+  if (!words.length) throw new Error("No words found: expected Whisper-style JSON with word timings, SubRip (.srt) or WebVTT.");
+  return { words: words.sort((a, b) => a.start - b.start), approximate: false };
+}
+function videoTranscriptTrack(project, track) {
+  if (track !== void 0) {
+    if (!project.tracks.some((t) => t.id === track)) throw new Error(`There is no track "${track}"; the tracks are ${project.tracks.map((t) => `"${t.id}"`).join(", ")}.`);
+    return track;
+  }
+  const assets = videoAssetMap(project);
+  const transcribed = (t) => t.clips.some((c) => c.type === "media" && assets.get(c.asset)?.transcript?.length);
+  return (project.tracks.find((t) => t.kind === "audio" && transcribed(t)) ?? project.tracks.find(transcribed))?.id ?? null;
+}
+function videoTimelineTranscript(project, options = {}) {
+  const id = videoTranscriptTrack(project, options.track);
+  if (!id) return [];
+  const track = project.tracks.find((t) => t.id === id);
+  const assets = videoAssetMap(project);
+  const out = [];
+  for (const clip of sortedVideoClips(track)) {
+    if (clip.type !== "media") continue;
+    const words = assets.get(clip.asset)?.transcript;
+    if (!words?.length) continue;
+    const speed = videoClipSpeed(clip);
+    const from = clip.in ?? 0;
+    const to = from + clip.duration * speed;
+    const toTimeline = (s) => Math.min(videoClipEnd(clip), Math.max(clip.start, clip.start + (s - from) / speed));
+    words.forEach((w, index) => {
+      const mid = (w.start + w.end) / 2;
+      if (mid < from || mid >= to) return;
+      out.push({ word: w.word, start: toTimeline(w.start), end: toTimeline(w.end), clip: clip.id, track: track.id, index });
+    });
+  }
+  return out;
+}
+var normalizeVideoWord = (word) => word.toLowerCase().replace(/^[^\p{L}\p{N}']+|[^\p{L}\p{N}']+$/gu, "");
+var rangeOf = (words, i, n2) => ({ from: words[i].start, to: words[i + n2 - 1].end, text: words.slice(i, i + n2).map((w) => w.word).join(" ") });
+function findVideoTranscriptText(words, query) {
+  const q = query.split(/\s+/).map(normalizeVideoWord).filter(Boolean);
+  if (!q.length) throw new Error("Search for at least one word.");
+  const norm = words.map((w) => normalizeVideoWord(w.word));
+  const out = [];
+  for (let i = 0; i + q.length <= norm.length; i++) if (q.every((x, k) => norm[i + k] === x)) out.push(rangeOf(words, i, q.length));
+  return out;
+}
+var VIDEO_DEFAULT_FILLERS = ["um", "umm", "uh", "uhh", "uhm", "erm", "er", "ah", "hmm", "mm", "you know", "i mean"];
+function findVideoFillers(words, fillers = VIDEO_DEFAULT_FILLERS) {
+  const phrases = fillers.map((f) => f.split(/\s+/).map(normalizeVideoWord).filter(Boolean)).filter((p) => p.length).sort((a, b) => b.length - a.length);
+  const norm = words.map((w) => normalizeVideoWord(w.word));
+  const out = [];
+  for (let i = 0; i < norm.length; ) {
+    const hit = phrases.find((p) => i + p.length <= norm.length && p.every((x, k) => norm[i + k] === x));
+    if (hit) {
+      out.push(rangeOf(words, i, hit.length));
+      i += hit.length;
+    } else i++;
+  }
+  return out;
+}
+function findVideoTranscriptPauses(words, options = {}) {
+  const min = options.min ?? 700;
+  const keep = options.keep ?? 150;
+  const out = [];
+  for (let i = 1; i < words.length; i++) {
+    const a = words[i - 1];
+    const b = words[i];
+    if (a.clip !== b.clip || b.start - a.end < min) continue;
+    let from = a.end + keep;
+    let to = b.start - keep;
+    if (options.fps) {
+      const f = 1e3 / options.fps;
+      from = snapToVideoFrame(Math.ceil(from / f - 1e-9) * f, options.fps);
+      to = snapToVideoFrame(Math.floor(to / f + 1e-9) * f, options.fps);
+    }
+    if (to - from > VIDEO_TIME_EPSILON) out.push({ from, to, text: `(pause after "${a.word}")` });
+  }
+  return out;
+}
+function mergeVideoRanges(ranges) {
+  const sorted = ranges.filter((r) => r.to - r.from > VIDEO_TIME_EPSILON).map((r) => ({ from: r.from, to: r.to })).sort((a, b) => a.from - b.from);
+  const out = [];
+  for (const r of sorted) {
+    const last = out[out.length - 1];
+    if (last && r.from <= last.to + VIDEO_TIME_EPSILON) last.to = Math.max(last.to, r.to);
+    else out.push(r);
+  }
+  return out;
+}
+function videoRemoveRangesEdits(ranges, tracks) {
+  return mergeVideoRanges(ranges).reverse().map((r) => ({ op: "extract_range", from: r.from, to: r.to, ...tracks ? { tracks } : {} }));
+}
+function videoWordsRange(words, a, b) {
+  const [i, j] = a <= b ? [a, b] : [b, a];
+  return { from: words[i].start, to: words[j].end };
+}
+function videoTranscriptEdit(assetId, text) {
+  return { op: "update_asset", asset: assetId, set: { transcript: parseVideoTranscript(text).words } };
+}
+function videoWordAt(words, time) {
+  let lo = 0;
+  let hi = words.length - 1;
+  while (lo <= hi) {
+    const mid = lo + hi >> 1;
+    if (words[mid].end <= time) lo = mid + 1;
+    else if (words[mid].start > time) hi = mid - 1;
+    else return mid;
+  }
+  return -1;
+}
+
 // 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);
@@ -2165,6 +2513,7 @@ function parseVideoLoudnessMeasurement(output) {
   return m;
 }
 var sec = (ms) => String(Math.round(ms) / 1e3);
+var fmtMs = (v) => String(Math.round(v * 100) / 100);
 var FFMPEG_BLEND = {
   multiply: "multiply",
   screen: "screen",
@@ -2224,6 +2573,58 @@ function buildFfmpeg(project, options, measure) {
   let cur = "base";
   let usesDrawtext = false;
   const animated = /* @__PURE__ */ new Set();
+  const ramped = /* @__PURE__ */ new Set();
+  const rampedPicture = (remap, lead, end) => {
+    const pts = videoTimeRemapBreakpoints(remap, 2e3 / fps);
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    const s = `(T*1000+${fmtMs(first.v)})`;
+    let e = fmtMs(last.t - first.t);
+    for (let i = pts.length - 2; i >= 0; i--) {
+      const a = pts[i];
+      const b = pts[i + 1];
+      if (b.v - a.v < 1e-6) continue;
+      e = `if(lt(${s},${fmtMs(b.v)}),${fmtMs(a.t - first.t)}+(${s}-${fmtMs(a.v)})*${fmtMs((b.t - a.t) / (b.v - a.v))},${e})`;
+    }
+    const before = lead + first.t;
+    const after = Math.max(0, end - last.t);
+    return ["setpts=PTS-STARTPTS", `setpts='(${e})/1000/TB'`, `fps=${fps}`, ...before > 0.5 || after > 0.5 ? [`tpad=start_mode=clone:start_duration=${sec(before)}:stop_mode=clone:stop_duration=${sec(after + 1e3 / fps)}`] : [`tpad=stop_mode=clone:stop_duration=${sec(1e3 / fps)}`], `trim=duration=${sec(lead + end)}`];
+  };
+  const rampedSound = (remap, input2, output, lead, end) => {
+    const pts = videoTimeRemapBreakpoints(remap, Math.max(80, 2e3 / fps));
+    const first = pts[0];
+    const last = pts[pts.length - 1];
+    const n2 = audio.length;
+    const fmtA = "aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo";
+    const silence = (ms) => `anullsrc=r=48000:cl=stereo,atrim=duration=${sec(ms)},${fmtA}`;
+    const pieces = [];
+    const out = [];
+    const parts = [];
+    if (lead + first.t > 0.5) parts.push(silence(lead + first.t));
+    const played = [];
+    for (let i = 0; i + 1 < pts.length; i++) {
+      const dt = pts[i + 1].t - pts[i].t;
+      if (dt < 0.5) continue;
+      const speed = (pts[i + 1].v - pts[i].v) / dt;
+      if (speed < 0.1) parts.push(silence(dt));
+      else {
+        played.push({ from: pts[i].v - first.v, to: pts[i + 1].v - first.v, speed });
+        parts.push(`#${played.length - 1}`);
+      }
+    }
+    if (end - last.t > 0.5) parts.push(silence(end - last.t));
+    if (played.length) out.push(`[${input2}]asplit=${played.length}${played.map((_, k2) => `[r${n2}s${k2}]`).join("")}`);
+    parts.forEach((p, k2) => {
+      const label = `[r${n2}p${k2}]`;
+      if (p.startsWith("#")) {
+        const piece = played[Number(p.slice(1))];
+        out.push(`[r${n2}s${p.slice(1)}]atrim=start=${sec(piece.from)}:end=${sec(piece.to)},asetpts=PTS-STARTPTS,${atempo(piece.speed).join(",") || "anull"},${fmtA}${label}`);
+      } else out.push(`${p}${label}`);
+      pieces.push(label);
+    });
+    out.push(`${pieces.join("")}concat=n=${pieces.length}:v=0:a=1${output}`);
+    return out;
+  };
   const blended = /* @__PURE__ */ new Set();
   let k = 0;
   const step = 2e3 / fps;
@@ -2236,7 +2637,10 @@ function buildFfmpeg(project, options, measure) {
     const src = options.resolve ? options.resolve(asset) : asset.src;
     const span = clip.duration + lead + tail;
     if (asset.kind === "image") inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", src]);
-    else inputs.push(["-ss", sec((clip.in ?? 0) - lead * speed), "-t", sec(span * speed), "-i", src]);
+    else if (clip.timeRemap) {
+      const { from, to } = videoTimeRemapSpan(clip.timeRemap);
+      inputs.push(["-ss", sec((clip.in ?? 0) + from), "-t", sec(to - from + 1e3 / fps), "-i", src]);
+    } else inputs.push(["-ss", sec((clip.in ?? 0) - lead * speed), "-t", sec(span * speed), "-i", src]);
     return inputs.length - 1;
   };
   for (const track of [...project.tracks].reverse()) {
@@ -2258,7 +2662,13 @@ function buildFfmpeg(project, options, measure) {
         const ai = index ?? input(clip, asset, lead, tail);
         const trackGain = track.volume ?? 1;
         const volume = isVideoKeyframes(clip.volume) ? `volume='${trackGain}*(${expr(clip.volume, `(t*1000${lead ? `-${Math.round(lead)}` : ""})`, 1, "volume")})':eval=frame` : `volume=${(clip.volume ?? 1) * trackGain}`;
-        const chain2 = ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip)), volume];
+        let source2 = `[${ai}:a]`;
+        if (clip.timeRemap) {
+          source2 = `[r${audio.length}]`;
+          graph.push(...rampedSound(clip.timeRemap, `${ai}:a`, source2, lead, clip.duration + tail));
+          ramped.add("sound");
+        }
+        const chain2 = [...clip.timeRemap ? [] : ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip))], volume];
         const before2 = clip.transition ? videoClipBefore(track, clip) : null;
         const next2 = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition);
         const inCurve = clip.transition ? afadeCurve(videoTransitionAudioCurve(clip.transition)) : "";
@@ -2270,7 +2680,7 @@ function buildFfmpeg(project, options, measure) {
         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}]`);
+        graph.push(`${source2}${chain2.join(",")}[a${audio.length}]`);
         audio.push(`[a${audio.length}]`);
       }
       if (measure || track.kind !== "video" || track.hidden) continue;
@@ -2320,7 +2730,8 @@ function buildFfmpeg(project, options, measure) {
       if (clip.type === "color") source = `color=c=${color(clip.color)}:s=${even(rect.width)}x${even(rect.height)}:r=${fps}:d=${sec(span)}`;
       else {
         source = `[${index}:v]`;
-        chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
+        if (clip.type === "media" && clip.timeRemap) chain.push(...rampedPicture(clip.timeRemap, lead, clip.duration + tail), `scale=${even(rect.width)}:${even(rect.height)}`);
+        else chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
       }
       const grade = videoGradeFfmpegFilters(clip.grade);
       if (grade.length) chain.push("format=rgba", ...grade);
@@ -2404,6 +2815,7 @@ function buildFfmpeg(project, options, measure) {
   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 (blended.has("soft-light")) notes.push("ffmpeg's soft-light blend uses a slightly different formula from the browser's, so the render can differ a little from the preview.");
+  if (ramped.has("sound")) notes.push("Sound through a speed ramp plays each stretch at its own speed, so a gliding change is heard in small steps (about every 80 ms), and freezes are silent.");
   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) {
@@ -2503,13 +2915,14 @@ var VideoPreviewEngine = class {
       const { media } = this.entry(clip, src, kind);
       active.add(clip);
       const target = sourceTime / 1e3;
-      if (Math.abs(media.playbackRate - speed) > 1e-6) media.playbackRate = speed;
+      const frozen = speed < 0.0625;
+      if (!frozen && Math.abs(media.playbackRate - speed) > 1e-6) media.playbackRate = speed;
       if (gain === null) media.muted = true;
       else {
         media.muted = gain <= 0;
         media.volume = Math.min(1, Math.max(0, gain));
       }
-      if (playing) {
+      if (playing && !frozen) {
         if (media.paused || Math.abs(media.currentTime - target) > tolerance) media.currentTime = target;
         if (media.paused) void Promise.resolve(media.play()).catch(() => {
         });
@@ -2991,6 +3404,10 @@ var issueSummary = (issues) => ({
   notes: issues.filter((i) => i.severity === "note").length,
   lines: issues.map((i) => `${i.severity}: ${i.message}`)
 });
+var videoAssetOut = (a) => {
+  const { transcript, ...rest } = a;
+  return transcript ? { ...rest, transcriptWords: transcript.length } : rest;
+};
 function describeVideoProject(project) {
   return {
     ...project.name ? { name: project.name } : {},
@@ -2999,7 +3416,7 @@ function describeVideoProject(project) {
     fps: project.fps,
     duration: videoProjectDuration(project),
     ...project.background ? { background: project.background } : {},
-    assets: project.assets,
+    assets: project.assets.map(videoAssetOut),
     tracks: project.tracks.map((t, index) => ({
       id: t.id,
       kind: t.kind,
@@ -3221,9 +3638,9 @@ function createVideoEditorToolProvider(controller, options = {}) {
     name: "update_video_asset",
     title: "Change media details",
     description: "Changes an asset's src, name, duration, size, sound or poster (e.g. relinking moved media). Clips that now run past its end are refused. Returns the asset.",
-    inputSchema: object({ asset: ASSET_ID, set: object(ASSET_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "duration", "width", "height", "hasAudio", "poster"] }, description: "Fields to clear." } }, ["asset"]),
+    inputSchema: object({ asset: ASSET_ID, set: object(ASSET_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "duration", "width", "height", "hasAudio", "poster", "transcript"] }, description: "Fields to clear (transcript removes its words)." } }, ["asset"]),
     annotations: { title: "Change media details", ...WRITE_IDEMPOTENT },
-    handler: ({ asset, set, remove }) => apply({ op: "update_asset", asset, set, remove }, "Change media", (r) => ({ asset: r.project.assets.find((a) => a.id === asset) }))
+    handler: ({ asset, set, remove }) => apply({ op: "update_asset", asset, set, remove }, "Change media", (r) => ({ asset: videoAssetOut(r.project.assets.find((a) => a.id === asset)) }))
   };
   const removeAsset = {
     name: "remove_video_asset",
@@ -3380,6 +3797,191 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return apply(edits, "Copy grade", () => ({ grade: grade ?? null, clips: to }));
     }
   };
+  const TRANSCRIPT_TRACK = { ...TRACK_ID, description: "Track whose words to read (default: the first audio track with a transcribed clip, else the first video track with one)." };
+  const RANGE_OUT = (r) => ({ from: round(r.from), to: round(r.to), text: r.text });
+  const timelineWords = (track) => {
+    const words = videoTimelineTranscript(project(), { track });
+    if (!words.length) throw new Error(track ? `No clip on track "${track}" plays a transcribed asset; attach one with set_video_transcript.` : "No clip plays a transcribed asset; attach a transcript to the media with set_video_transcript first.");
+    return words;
+  };
+  const setTranscript = {
+    name: "set_video_transcript",
+    title: "Attach a transcript",
+    description: 'Attaches what is said in a video or audio asset, word by word, so the edit can be cut by text (one undo step). Pass "text" (Whisper-style JSON with word timings, SubRip or WebVTT, as the file says it) or "words" ([{ word, start, end }] in ms of the source). Captions have no word timings, so their words are spread across each cue (approximate). Replaces any transcript the asset had. Returns the word count, whether timings are approximate, and the first and last words.',
+    inputSchema: object(
+      {
+        asset: { ...ASSET_ID, description: "A video or audio asset." },
+        text: { type: "string", minLength: 1, description: "The transcript file's contents: Whisper-style JSON (times in seconds), .srt or .vtt. Pass this or words." },
+        words: { type: "array", minItems: 1, items: object({ word: { type: "string", minLength: 1, description: "The word as said." }, start: { type: "number", minimum: 0, description: "Start in ms of the source." }, end: { type: "number", minimum: 0, description: "End in ms of the source." } }, ["word", "start", "end"], "One word."), description: "Words with source times in ms. Pass this or text." }
+      },
+      ["asset"]
+    ),
+    annotations: { title: "Attach a transcript", ...WRITE_IDEMPOTENT },
+    handler: ({ asset, text, words }) => {
+      if (text === void 0 === (words === void 0)) throw new Error(`Pass either "text" (a transcript file's contents) or "words", not both.`);
+      const a = project().assets.find((x) => x.id === asset);
+      if (!a) throw new Error(`There is no asset "${asset}"; the assets are ${project().assets.map((x) => `"${x.id}"`).join(", ") || "none"}.`);
+      if (a.kind === "image") throw new Error(`Asset "${asset}" is an image and has no sound to transcribe.`);
+      const parsed = text !== void 0 ? parseVideoTranscript(text) : { words, approximate: false };
+      const list = parsed.words;
+      return apply({ op: "update_asset", asset, set: { transcript: list } }, "Attach transcript", () => ({
+        asset,
+        words: list.length,
+        approximate: parsed.approximate,
+        first: list[0],
+        last: list[list.length - 1],
+        ...a.duration !== void 0 && list[list.length - 1].end > a.duration + VIDEO_TIME_EPSILON ? { warning: `The transcript runs to ${list[list.length - 1].end} ms, past the asset's ${a.duration} ms: is it for this asset?` } : {}
+      }));
+    }
+  };
+  const getTranscript = {
+    name: "get_video_transcript",
+    title: "Read the transcript",
+    description: "Returns what the timeline says, in order, from the transcripts of the media its clips play on one track: the text, and each word with its timeline start and end (ms) and the clip that plays it, so ranges can go straight to remove_video_ranges or split_video_at. Words cut out of the edit are not included.",
+    inputSchema: object({
+      track: TRANSCRIPT_TRACK,
+      from: MS("Only words from this timeline time (default 0)"),
+      to: MS("Only words up to this timeline time (default the end)"),
+      limit: { type: "integer", minimum: 1, maximum: 5e3, description: 'Most words to return (default 1000); "more" says if there are others.' }
+    }),
+    annotations: { title: "Read the transcript", ...READ },
+    handler: ({ track, from, to, limit }) => {
+      const all = timelineWords(track).filter((w) => w.end > (from ?? 0) && w.start < (to ?? Infinity));
+      const words = all.slice(0, limit ?? 1e3);
+      return { track: words[0]?.track ?? videoTranscriptTrack(project(), track), text: words.map((w) => w.word).join(" "), words: words.map((w) => ({ word: w.word, start: round(w.start), end: round(w.end), clip: w.clip })), more: all.length > words.length };
+    }
+  };
+  const findText = {
+    name: "find_video_transcript_text",
+    title: "Find words in the transcript",
+    description: "Lists every place a word or phrase is said on the timeline (case and punctuation ignored) as { from, to, text } ranges in timeline ms, ready for remove_video_ranges, split_video_at or seek_video.",
+    inputSchema: object({ query: { type: "string", minLength: 1, description: "The word or phrase." }, track: TRANSCRIPT_TRACK }, ["query"]),
+    annotations: { title: "Find words in the transcript", ...READ },
+    handler: ({ query, track }) => ({ matches: findVideoTranscriptText(timelineWords(track), query).map(RANGE_OUT) })
+  };
+  const findFillers = {
+    name: "find_video_fillers",
+    title: "Find filler words",
+    description: `Lists filler words and phrases on the timeline as { from, to, text } ranges in timeline ms, longest phrase first so "you know" is found whole. Default fillers: ${VIDEO_DEFAULT_FILLERS.join(", ")} ("like" and "so" are left out as too often meant). Check them, then pass the ones to cut to remove_video_ranges.`,
+    inputSchema: object({ track: TRANSCRIPT_TRACK, fillers: { type: "array", minItems: 1, items: { type: "string", minLength: 1 }, description: "Words or phrases to treat as fillers instead of the defaults." } }),
+    annotations: { title: "Find filler words", ...READ },
+    handler: ({ track, fillers }) => {
+      const found = findVideoFillers(timelineWords(track), fillers);
+      return { fillers: found.map(RANGE_OUT), total: round(found.reduce((n2, r) => n2 + r.to - r.from, 0)) };
+    }
+  };
+  const findPauses = {
+    name: "find_video_pauses",
+    title: "Find pauses between words",
+    description: 'Lists the gaps between consecutive words on the timeline (within one clip) longer than "min", less "keep" next to each word so speech is not clipped, snapped inward to frames, as { from, to } ranges in timeline ms ready for remove_video_ranges. Uses word timings; find_video_silences measures the sound instead.',
+    inputSchema: object({
+      track: TRANSCRIPT_TRACK,
+      min: { type: "number", exclusiveMinimum: 0, description: "Shortest gap that counts, in ms (default 700)." },
+      keep: { type: "number", minimum: 0, description: "Silence to keep after the word before and before the word after, in ms (default 150)." }
+    }),
+    annotations: { title: "Find pauses between words", ...READ },
+    handler: ({ track, min, keep }) => {
+      const found = findVideoTranscriptPauses(timelineWords(track), { min, keep, fps: project().fps });
+      return { pauses: found.map(RANGE_OUT), total: round(found.reduce((n2, r) => n2 + r.to - r.from, 0)) };
+    }
+  };
+  const removeRanges = {
+    name: "remove_video_ranges",
+    title: "Cut out stretches",
+    description: "Cuts stretches of the timeline out and closes them up, as one undo step: the ranges are merged where they touch and extracted from the last to the first, so the times from find_video_fillers, find_video_pauses, find_video_transcript_text or find_video_silences can be passed as they are. Like extract_video_range, every sync-locked track moves with the cut. Returns how many stretches and how much time were removed and the new length.",
+    inputSchema: object(
+      {
+        ranges: { type: "array", minItems: 1, maxItems: 500, items: object({ from: MS("Start, on the timeline"), to: MS("End, on the timeline"), text: { type: "string", description: "Ignored: the words in the stretch, as the find tools return them." } }, ["from", "to"], "A stretch to remove."), description: "The stretches, in any order (timeline ms)." },
+        tracks: { type: "array", items: TRACK_ID, minItems: 1, description: "Tracks to cut (default every unlocked track)." }
+      },
+      ["ranges"]
+    ),
+    annotations: { title: "Cut out stretches", ...DESTRUCTIVE },
+    handler: ({ ranges, tracks }) => {
+      const bad = ranges.findIndex((r) => !(r.to > r.from));
+      if (bad >= 0) throw new Error(`Range ${bad + 1} is empty or backwards (${ranges[bad].from}\u2013${ranges[bad].to} ms); "to" must be after "from".`);
+      const merged = mergeVideoRanges(ranges);
+      const before = videoProjectDuration(project());
+      return apply(videoRemoveRangesEdits(merged, tracks), merged.length > 1 ? `Cut ${merged.length} stretches` : "Cut stretch", (r) => ({ removed: merged.length, time: round(before - videoProjectDuration(r.project)), duration: videoProjectDuration(r.project) }));
+    }
+  };
+  const rampTarget = (id) => {
+    const at = findVideoClip(project(), id);
+    if (!at) throw new Error(`There is no clip "${id}"; get_video_project lists the clips.`);
+    const { clip } = at;
+    if (clip.type !== "media") throw new Error(`Clip "${id}" is a ${clip.type === "text" ? "title" : "colour"}, so it has no source to change the speed of; use a video or audio clip.`);
+    if (project().assets.find((a) => a.id === clip.asset)?.kind === "image") throw new Error(`Clip "${id}" is a still, so it has no motion to change the speed of.`);
+    return clip;
+  };
+  const rampOut = (r, id) => {
+    const outcome2 = r.outcomes[r.outcomes.length - 1];
+    return { clip: clipOut(r.project, id), ...outcome2.rippled ? { rippled: outcome2.rippled } : {}, duration: videoProjectDuration(r.project) };
+  };
+  const RIPPLE_RAMP = { type: "boolean", description: "Move later material on every sync-locked track by the change in length (default true); false refuses if the clip would overlap the next one." };
+  const setSpeedRamp = {
+    name: "set_video_speed_ramp",
+    title: "Ramp the speed",
+    description: `Plays a video or audio clip through stretches of speed, from its first frame: e.g. [{ duration: 1500, speed: 1 }, { duration: 500, speed: 1, toSpeed: 0.25 }, { duration: 2000, speed: 0.25 }] for a slow-motion ramp. "toSpeed" glides evenly to a new speed over the stretch; speed 0 is a freeze frame. The clip's length becomes the stretches' total (one undo step). Replaces any ramp or speed it had. Returns the clip (with its timeRemap keys and source range).`,
+    inputSchema: object(
+      {
+        clip: CLIP_ID,
+        segments: {
+          type: "array",
+          minItems: 1,
+          maxItems: 100,
+          description: "The stretches in order, from the clip's start.",
+          items: object(
+            {
+              duration: { type: "number", exclusiveMinimum: 0, description: "Length of the stretch on the timeline, in ms." },
+              speed: { type: "number", minimum: 0, maximum: 20, description: "Speed at its start: 1 normal, 0.5 half speed (slow motion), 2 double, 0 a freeze frame." },
+              toSpeed: { type: "number", minimum: 0, maximum: 20, description: "Glide evenly to this speed by the stretch's end (default: stay at speed). A ramp between two speeds." }
+            },
+            ["duration", "speed"],
+            "One stretch."
+          )
+        },
+        ripple: RIPPLE_RAMP
+      },
+      ["clip", "segments"]
+    ),
+    annotations: { title: "Ramp the speed", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, segments, ripple }) => {
+      const edit = videoSpeedRampEdit(rampTarget(clip), segments, ripple ?? true);
+      return apply(edit, "Speed ramp", (r) => ({ ...rampOut(r, clip), source: Math.round(videoSpeedRampKeys(segments).source) }));
+    }
+  };
+  const addFreeze = {
+    name: "add_video_freeze_frame",
+    title: "Add a freeze frame",
+    description: "Holds the frame a video clip shows at a timeline time for a while, then plays on (one undo step): the clip gets longer by the hold, and with ripple (default) everything after it on sync-locked tracks moves along. Works on clips with or without a speed ramp. Returns the clip.",
+    inputSchema: object(
+      {
+        clip: CLIP_ID,
+        at: MS("Timeline time of the frame to hold (inside the clip)"),
+        duration: { type: "number", exclusiveMinimum: 0, description: "How long to hold it, in ms." },
+        ripple: RIPPLE_RAMP
+      },
+      ["clip", "at", "duration"]
+    ),
+    annotations: { title: "Add a freeze frame", ...WRITE },
+    handler: ({ clip, at, duration, ripple }) => {
+      const c = rampTarget(clip);
+      const t = at - c.start;
+      if (t < 0 || t > c.duration) throw new Error(`${formatVideoSeconds(at)} is outside clip "${clip}" (${formatVideoSeconds(c.start)}\u2013${formatVideoSeconds(videoClipEnd(c))}); pick a time inside it.`);
+      return apply(videoFreezeFrameEdit(c, t, duration, ripple ?? true), "Freeze frame", (r) => rampOut(r, clip));
+    }
+  };
+  const removeRamp = {
+    name: "remove_video_speed_ramp",
+    title: "Remove a speed ramp",
+    description: 'Puts a ramped clip back to normal speed from the moment its ramp started (one undo step), keeping its length unless "duration" is given. Returns the clip.',
+    inputSchema: object({ clip: CLIP_ID, duration: { type: "number", exclusiveMinimum: 0, description: "New length in ms (default: unchanged)." }, ripple: RIPPLE_RAMP }, ["clip"]),
+    annotations: { title: "Remove a speed ramp", ...WRITE },
+    handler: ({ clip, duration, ripple }) => {
+      rampTarget(clip);
+      return apply({ op: "set_time_remap", clip, keys: null, ...duration !== void 0 ? { duration } : {}, ripple: ripple ?? true }, "Remove speed ramp", (r) => rampOut(r, clip));
+    }
+  };
   const setTransition = {
     name: "set_video_transition",
     title: "Set a transition",
@@ -3490,7 +4092,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
   };
   const EDIT_OP = {
     type: "object",
-    description: `One edit: { "op": one of ${VIDEO_EDIT_OPS.filter((o) => o !== "replace_project").join(", ")}, \u2026its fields }. Fields match the single tools: add_clip { track, clip, mode, ripple }, move_clip { clip, start, track, mode }, trim_clip { clip, edge, to, ripple }, split_clip { clip, at, id }, delete_clips { clips, ripple }, update_clip { clip, set, remove }, set_transition { clip, transition }, set_keyframes { clip, property, keys (null removes) }, slip_clip { clip, delta }, roll_edit { left, right, delta }, slide_clip { clip, delta }, lift_range { from, to, tracks }, extract_range { from, to, tracks }, split_at { at, tracks }, close_gaps { track, from }, add_asset { asset }, update_asset { asset, set, remove }, remove_asset { asset }, add_track { track: { kind, id, \u2026 }, at }, update_track { track, set, remove }, remove_track { track }, move_track { track, to }, add_marker { marker: { time, label } }, update_marker { marker, set }, remove_marker { marker }, set_settings { name, width, height, fps, background }.`,
+    description: `One edit: { "op": one of ${VIDEO_EDIT_OPS.filter((o) => o !== "replace_project").join(", ")}, \u2026its fields }. Fields match the single tools: add_clip { track, clip, mode, ripple }, move_clip { clip, start, track, mode }, trim_clip { clip, edge, to, ripple }, split_clip { clip, at, id }, delete_clips { clips, ripple }, update_clip { clip, set, remove }, set_transition { clip, transition }, set_keyframes { clip, property, keys (null removes) }, set_time_remap { clip, keys (clip ms \u2192 source ms after the in point; null removes), duration, ripple }, slip_clip { clip, delta }, roll_edit { left, right, delta }, slide_clip { clip, delta }, lift_range { from, to, tracks }, extract_range { from, to, tracks }, split_at { at, tracks }, close_gaps { track, from }, add_asset { asset }, update_asset { asset, set, remove }, remove_asset { asset }, add_track { track: { kind, id, \u2026 }, at }, update_track { track, set, remove }, remove_track { track }, move_track { track, to }, add_marker { marker: { time, label } }, update_marker { marker, set }, remove_marker { marker }, set_settings { name, width, height, fps, background }.`,
     properties: { op: { type: "string", enum: VIDEO_EDIT_OPS.filter((o) => o !== "replace_project"), description: "Which edit." } },
     required: ["op"]
   };
@@ -3597,8 +4199,8 @@ function createVideoEditorToolProvider(controller, options = {}) {
       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, applyGradePreset, copyGrade, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
+  const reads = [getProject, getFrame, getTranscript, findText, findFillers, findPauses, 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, setSpeedRamp, addFreeze, removeRamp, setTranscript, removeRanges, applyGradePreset, copyGrade, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return {
     id: options.id ?? "video",
     namespace: options.namespace,
@@ -3843,6 +4445,7 @@ export {
   VIDEO_CLIP_ANIMATION_EFFECTS,
   VIDEO_CLIP_ANIMATION_LABELS,
   VIDEO_CLIP_TYPES,
+  VIDEO_DEFAULT_FILLERS,
   VIDEO_DEFAULT_STILL_DURATION,
   VIDEO_DEFAULT_TITLE_DURATION,
   VIDEO_EASE_NAMES,
@@ -3871,6 +4474,7 @@ export {
   applyVideoGrade,
   buildVideoAudioPeaks,
   checkVideoProject,
+  checkVideoTimeRemap,
   createVideoEditorToolProvider,
   createVideoProject,
   decodeVideoAudioPeaks,
@@ -3879,14 +4483,19 @@ export {
   ffmpegFilterValue,
   findVideoAudioSilences,
   findVideoClip,
+  findVideoFillers,
   findVideoGaps,
+  findVideoTranscriptPauses,
+  findVideoTranscriptText,
   formatVideoSeconds,
   formatVideoTimecode,
   formatVideoTimecodeFrames,
   isVideoDropFrameRate,
   isVideoKeyframes,
+  mergeVideoRanges,
   nextFreeVideoSlot,
   normalizeVideoGrade,
+  normalizeVideoWord,
   parseVideoAnimatable,
   parseVideoAsset,
   parseVideoClip,
@@ -3896,7 +4505,10 @@ export {
   parseVideoLoudnessMeasurement,
   parseVideoMarker,
   parseVideoProject,
+  parseVideoTimeRemap,
   parseVideoTrack,
+  parseVideoTranscript,
+  parseVideoTranscriptWords,
   parseVideoTransform,
   parseVideoTransition,
   placeVideoRect,
@@ -3934,7 +4546,9 @@ export {
   videoClipShowsWaveform,
   videoClipSoundGain,
   videoClipSourceRange,
+  videoClipSourceTime,
   videoClipSpeed,
+  videoClipSpeedAt,
   videoClipTint,
   videoClipWaveform,
   videoClipWaveformPath,
@@ -3949,6 +4563,7 @@ export {
   videoFrameDuration,
   videoFrameToSvg,
   videoFrames,
+  videoFreezeFrameEdit,
   videoGradeCssFilter,
   videoGradeFfmpegFilters,
   videoGradeGainsFilterId,
@@ -3971,18 +4586,29 @@ export {
   videoPeakDb,
   videoProjectDuration,
   videoProjectSvg,
+  videoRemoveRangesEdits,
   videoRulerTicks,
+  videoSlowMotionRamp,
   videoSnapPoints,
+  videoSpeedRampEdit,
+  videoSpeedRampKeys,
   videoTextStyle,
+  videoTimeRemapBreakpoints,
+  videoTimeRemapSpan,
   videoTimecodeFrames,
+  videoTimelineTranscript,
   videoTitleFrame,
   videoTrackSyncLocked,
+  videoTranscriptEdit,
+  videoTranscriptTrack,
   videoTransformAt,
   videoTransitionAudioCurve,
   videoTransitionEase,
   videoTransitionHasDirection,
   videoValueAt,
   videoWaveformPath,
-  videoWipeRect
+  videoWipeRect,
+  videoWordAt,
+  videoWordsRange
 };
 //# sourceMappingURL=index.js.map