@pixerate/editor 0.160.0 → 0.162.0

package/dist/video-editor/index.js

@@ -1,4 +1,8 @@
 import {
+  createEffectAuthoringSession
+} from "../chunk-ZGOHKS3X.js";
+import {
+  VIDEO_ADJUSTMENT_SCOPES,
   VIDEO_BLEND_MODES,
   VIDEO_CLIP_ANIMATION_DURATION,
   VIDEO_CLIP_ANIMATION_EFFECTS,
@@ -13,6 +17,8 @@ import {
   VIDEO_KEYFRAME_LIMITS,
   VIDEO_KEYFRAME_PROPERTIES,
   VIDEO_LUT_MAX_SIZE,
+  VIDEO_MASK_DEFAULTS,
+  VIDEO_MASK_SHAPES,
   VIDEO_PLACEMENT_MODES,
   VIDEO_TIME_EPSILON,
   VIDEO_TRANSFORM_PROPERTIES,
@@ -41,6 +47,7 @@ import {
   isVideoKeyframes,
   mixEffectPixels,
   nextFreeVideoSlot,
+  normalizeVideoClipMask,
   normalizeVideoGrade,
   normalizeVideoGradeLut,
   overEffectPixels,
@@ -75,6 +82,7 @@ import {
   videoClipSourceTime,
   videoClipSpeed,
   videoClipSpeedAt,
+  videoClipTypeLabel,
   videoClipsAt,
   videoContactSheetSvg,
   videoEaseBezier,
@@ -84,6 +92,7 @@ import {
   videoEffectValuesAt,
   videoFadeCurveGain,
   videoFfmpegUnsupportedEffects,
+  videoFfmpegUnsupportedFeatures,
   videoFrameAt,
   videoFrameDuration,
   videoFrameLeafLayers,
@@ -105,12 +114,16 @@ import {
   videoKeyframeBreakpoints,
   videoKeyframeFfmpegExpr,
   videoKeysOf,
+  videoLayerMask,
   videoLayersUseEffects,
   videoLayersWithoutTransitionEffects,
   videoLutFromFunction,
   videoLutSvgApproximation,
   videoLutSvgPrimitives,
   videoLutToCube,
+  videoMaskContains,
+  videoMaskPolygon,
+  videoMaskSvgPath,
   videoOverlap,
   videoProjectDuration,
   videoProjectEffects,
@@ -119,6 +132,7 @@ import {
   videoSequenceDuration,
   videoSequenceMap,
   videoShellQuote,
+  videoSkinToneWeight,
   videoSlowMotionRamp,
   videoSnapPoints,
   videoSpeedRampEdit,
@@ -134,7 +148,7 @@ import {
   videoTransitionEase,
   videoValueAt,
   videoWipeRect
-} from "../chunk-IQ6KKXOU.js";
+} from "../chunk-YN4AYYBJ.js";
 import "../chunk-EHLOCVWB.js";
 import {
   namedWithSuggestion
@@ -154,11 +168,15 @@ import {
 } from "../chunk-RNSANXPT.js";
 import {
   AnimationPlayer
-} from "../chunk-AY65VQSU.js";
-import "../chunk-5UJHB3BW.js";
-import "../chunk-KY3FYKP3.js";
+} from "../chunk-H3OEM3Q2.js";
+import {
+  CUBIC_BEZIER_PRESETS,
+  evaluateEasing
+} from "../chunk-5UJHB3BW.js";
+import "../chunk-BQWGN5WH.js";
 import "../chunk-2WPNAGHI.js";
-import "../chunk-AA34BA7G.js";
+import "../chunk-QYZGBVNC.js";
+import "../chunk-4VU4CP7R.js";
 import "../chunk-6ONMQ6WF.js";
 
 // src/video-editor/parse.ts
@@ -260,9 +278,38 @@ function parseVideoGrade(v, path) {
 function parseVideoGradeLut(v, path) {
   if (v === void 0) return void 0;
   if (!isObject(v)) return fail(path, "must be an object { src, strength } naming a .cube file");
-  const unknown = Object.keys(v).find((k) => !["src", "strength", "name"].includes(k));
-  if (unknown) fail(`${path}.${unknown}`, "is not a LUT setting; use src, strength, name");
-  return compact({ src: str(v.src, `${path}.src`), strength: num(v.strength, `${path}.strength`, { optional: true, min: 0, max: 1 }), name: str(v.name, `${path}.name`, true) });
+  const unknown = Object.keys(v).find((k) => !["src", "strength", "name", "preserveSkinTones"].includes(k));
+  if (unknown) fail(`${path}.${unknown}`, "is not a LUT setting; use src, strength, name, preserveSkinTones");
+  return compact({ src: str(v.src, `${path}.src`), strength: num(v.strength, `${path}.strength`, { optional: true, min: 0, max: 1 }), name: str(v.name, `${path}.name`, true), preserveSkinTones: num(v.preserveSkinTones, `${path}.preserveSkinTones`, { optional: true, min: 0, max: 1 }) });
+}
+var MASK_KEYS = ["shape", "x", "y", "width", "height", "rotation", "feather", "cornerRadius", "inverted", "points"];
+function parseVideoClipMask(v, path) {
+  if (v === void 0) return void 0;
+  if (!isObject(v)) return fail(path, 'must be an object such as { shape: "ellipse", x: 0.5, y: 0.5, width: 0.4, height: 0.6, feather: 20 }');
+  const unknown = Object.keys(v).find((k) => !MASK_KEYS.includes(k));
+  if (unknown) fail(`${path}.${unknown}`, `is not a mask setting; use ${MASK_KEYS.join(", ")}`);
+  const shape = oneOf(v.shape, VIDEO_MASK_SHAPES, `${path}.shape`, false);
+  let points;
+  if (v.points !== void 0) {
+    if (shape !== "polygon") fail(`${path}.points`, "is only for polygon masks");
+    if (!Array.isArray(v.points) || v.points.length < 3) fail(`${path}.points`, "must be a list of at least 3 { x, y } points");
+    points = v.points.map((p, i) => {
+      if (!isObject(p)) return fail(`${path}.points[${i}]`, "must be an object { x, y }");
+      return { x: num(p.x, `${path}.points[${i}].x`), y: num(p.y, `${path}.points[${i}].y`) };
+    });
+  } else if (shape === "polygon") fail(`${path}.points`, "is required for a polygon mask: at least 3 { x, y } points as fractions of the picture");
+  return compact({
+    shape,
+    x: num(v.x, `${path}.x`, { optional: true }),
+    y: num(v.y, `${path}.y`, { optional: true }),
+    width: num(v.width, `${path}.width`, { optional: true, min: 0 }),
+    height: num(v.height, `${path}.height`, { optional: true, min: 0 }),
+    rotation: num(v.rotation, `${path}.rotation`, { optional: true }),
+    feather: num(v.feather, `${path}.feather`, { optional: true, min: 0 }),
+    cornerRadius: num(v.cornerRadius, `${path}.cornerRadius`, { optional: true, min: 0, max: 1 }),
+    inverted: bool(v.inverted, `${path}.inverted`),
+    points
+  });
 }
 function parseVideoTransition(v, path) {
   if (v === void 0) return void 0;
@@ -384,7 +431,8 @@ function parseVideoClip(v, path = "clip") {
     fadeIn: num(v.fadeIn, `${path}.fadeIn`, { optional: true, min: 0 }),
     fadeOut: num(v.fadeOut, `${path}.fadeOut`, { optional: true, min: 0 }),
     transition: parseVideoTransition(v.transition, `${path}.transition`),
-    effects: parseVideoClipEffects(v.effects, `${path}.effects`)
+    effects: parseVideoClipEffects(v.effects, `${path}.effects`),
+    mask: parseVideoClipMask(v.mask, `${path}.mask`)
   };
   if (type === "media")
     return compact({
@@ -424,6 +472,13 @@ function parseVideoClip(v, path = "clip") {
       fontWeight: num(v.fontWeight, `${path}.fontWeight`, { optional: true, min: 100, max: 1e3 }),
       background: str(v.background, `${path}.background`, true)
     });
+  if (type === "adjustment") {
+    const scope = oneOf(v.scope, VIDEO_ADJUSTMENT_SCOPES, `${path}.scope`);
+    const targetTrack = str(v.targetTrack, `${path}.targetTrack`, true);
+    if (scope === "track" && !targetTrack) fail(`${path}.targetTrack`, 'is required when scope is "track": the id of the track whose pictures the adjustment changes');
+    if (targetTrack !== void 0 && scope !== "track") fail(`${path}.targetTrack`, 'is only for scope "track"');
+    return compact({ type, ...base, scope, targetTrack });
+  }
   if (type === "effect") {
     const ref = parseVideoEffectRef({ effect: v.effect, provider: v.provider, name: v.name === void 0 ? void 0 : v.name, values: v.values }, path);
     return compact({ type, ...base, ...ref, name: base.name });
@@ -545,6 +600,7 @@ var VIDEO_ISSUE_CODES = [
   "unused-asset",
   "unused-sequence",
   "marker-past-end",
+  "missing-target-track",
   "empty"
 ];
 var videoIssueKey = (i) => [i.code, i.sequence ?? "", i.track ?? "", i.clip ?? "", i.asset ?? "", i.marker ?? ""].join("|");
@@ -589,6 +645,8 @@ function checkVideoProject(project) {
             issues.push({ code: "source-overrun", severity: "error", ...at, message: `Clip "${clip.id}" plays to ${formatVideoSeconds(range.out)} of "${asset.id}", which is only ${formatVideoSeconds(asset.duration)} long; shorten the clip or move its in point.` });
         }
       } else if (track.kind === "audio") issues.push({ code: "wrong-track", severity: "error", ...at, message: `Clip "${clip.id}" is a ${clip.type} clip on audio track "${track.id}"; move it to a video track.` });
+      if (clip.type === "adjustment" && (clip.scope ?? "underneath") === "track" && !(sequence ? sequences.get(sequence)?.tracks ?? [] : project.tracks).some((t) => t.id === clip.targetTrack))
+        issues.push({ code: "missing-target-track", severity: "warning", ...at, message: `Adjustment clip "${clip.id}" changes track "${clip.targetTrack}", which is not ${sequence ? `in sequence "${sequence}"` : "in the project"}, so it changes nothing; set its targetTrack to a track beside it or change its scope.` });
       const next = clips[i + 1];
       if (next && next.start < videoClipEnd(clip) - VIDEO_TIME_EPSILON)
         issues.push({ code: "overlap", severity: "error", ...at, message: `Clips "${clip.id}" and "${next.id}" overlap on track "${track.id}"${where} from ${formatVideoSeconds(next.start)}; move one of them.` });
@@ -725,7 +783,7 @@ function retimeClipKeys(clip, fn) {
     if (isVideoKeyframes(v)) a.set(fn(v));
   }
 }
-var OPTIONAL_CLIP_FIELDS = ["name", "effects", "values", "provider", "opacity", "transform", "fit", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "transition", "in", "speed", "timeRemap", "volume", "muted", "color", "fontSize", "fontFamily", "fontWeight", "background"];
+var OPTIONAL_CLIP_FIELDS = ["name", "effects", "mask", "scope", "targetTrack", "values", "provider", "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) {
@@ -763,6 +821,12 @@ var Editor = class {
       refuse(`${what} at ${formatVideoSeconds(start)}\u2013${formatVideoSeconds(start + duration)} would overlap clip "${hit.id}" (${formatVideoSeconds(hit.start)}\u2013${formatVideoSeconds(videoClipEnd(hit))}) on track "${track.id}"; the next free place is ${formatVideoSeconds(free)}, or use mode "insert" to push later clips along or "overwrite" to replace what is there.`);
     }
   }
+  /** An adjustment clip's target track must exist. */
+  adjustmentTarget(clip) {
+    if (clip.type !== "adjustment" || clip.targetTrack === void 0) return;
+    const ids = allVideoTracks(this.p).map(({ track }) => track.id);
+    if (!ids.includes(clip.targetTrack)) refuse(`Adjustment clip "${clip.id}" targets track ${namedWithSuggestion(clip.targetTrack, ids)}, which does not exist; the tracks are ${ids.map((t) => `"${t}"`).join(", ")}.`);
+  }
   kindFits(track, clip) {
     const asset = clip.type === "media" ? this.asset(clip.asset) : null;
     if (clip.type === "sequence") {
@@ -1028,6 +1092,7 @@ var Editor = class {
         const end = sortedVideoClips(track).reduce((m, c) => Math.max(m, videoClipEnd(c)), 0);
         draft.start ??= end;
         const clip = parseVideoClip(draft, "clip");
+        this.adjustmentTarget(clip);
         const outcome = { op: e.op, clip: clip.id, track: track.id };
         this.place(track, clip, mode, outcome);
         return this.outcomes.push(outcome);
@@ -1161,6 +1226,7 @@ var Editor = class {
         if (stretch !== 1) retimeClipKeys(next, (v) => retimeVideoAnimatable(v, 0, stretch));
         for (const k of e.remove ?? []) delete next[k];
         const clip = parseVideoClip(next, "set");
+        this.adjustmentTarget(clip);
         if (clip.type === "media" && clip.asset !== at.clip.asset) this.kindFits(at.track, clip);
         if (clip.start !== at.clip.start || clip.duration !== at.clip.duration) this.fits(at.track, clip.start, clip.duration, /* @__PURE__ */ new Set([clip.id]), `Clip "${clip.id}"`);
         at.track.clips[at.index] = clip;
@@ -1171,7 +1237,7 @@ var Editor = class {
         const { track, clip } = this.clip(e.clip);
         this.unlocked(track);
         if (clip.type === "sequence") refuse(`Clip "${clip.id}" is a compound clip, which plays its sequence at normal speed; ramp the clips inside the sequence instead.`);
-        if (clip.type !== "media") refuse(`Clip "${clip.id}" is a ${clip.type === "text" ? "title" : clip.type === "effect" ? "effect clip" : "colour"}, so it has no source to ramp; only video and audio clips change speed.`);
+        if (clip.type !== "media") refuse(`Clip "${clip.id}" is a ${videoClipTypeLabel(clip)}, 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;
@@ -1228,7 +1294,7 @@ var Editor = class {
       case "slip_clip": {
         const { track, clip } = this.clip(e.clip);
         this.unlocked(track);
-        if (clip.type !== "media" && clip.type !== "sequence") refuse(`Clip "${clip.id}" is a ${clip.type === "text" ? "title" : clip.type === "effect" ? "effect clip" : "colour"}, so it has no source to slip; only video, audio and compound clips slip.`);
+        if (clip.type !== "media" && clip.type !== "sequence") refuse(`Clip "${clip.id}" is a ${videoClipTypeLabel(clip)}, so it has no source to slip; only video, audio and compound clips slip.`);
         const source = clip.type === "sequence" ? `sequence "${clip.sequence}"` : `"${this.asset(clip.asset).id}"`;
         if (clip.type === "media" && this.asset(clip.asset).kind === "image") refuse(`Clip "${clip.id}" is a still ("${clip.asset}"), so it has no source to slip; only video and audio clips slip.`);
         const handles = videoClipHandles(clip, videoAssetMap(this.p), videoSequenceMap(this.p));
@@ -1428,6 +1494,432 @@ function applyVideoEdits(project, edits) {
   return { ok: true, project: next, issues, outcomes: editor.outcomes };
 }
 
+// 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, n) => ({ from: words[i].start, to: words[i + n - 1].end, text: words.slice(i, i + n).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;
+}
+function findVideoRepetitions(words, options = {}) {
+  const max = Math.max(1, options.maxPhrase ?? 3);
+  const maxGap = options.maxGap ?? 1e3;
+  const norm = words.map((w) => normalizeVideoWord(w.word));
+  const out = [];
+  for (let i = 0; i < norm.length; i++) {
+    for (let n = Math.min(max, Math.floor((norm.length - i) / 2)); n >= 1; n--) {
+      let same = true;
+      for (let k = 0; k < n && same; k++) same = !!norm[i + k] && norm[i + k] === norm[i + n + k];
+      if (!same || words[i + n].start - words[i + n - 1].end > maxGap) continue;
+      out.push({ from: words[i].start, to: words[i + n].start, text: words.slice(i, i + n).map((w) => w.word).join(" ") });
+      i += n - 1;
+      break;
+    }
+  }
+  return out;
+}
+var VIDEO_DISFLUENCY_KINDS = ["filler", "pause", "repetition"];
+function detectVideoDisfluencies(words, options = {}) {
+  const kinds = new Set(options.kinds ?? VIDEO_DISFLUENCY_KINDS);
+  const startIndex = (time) => Math.max(0, words.findIndex((w) => w.start >= time - VIDEO_TIME_EPSILON));
+  const out = [];
+  if (kinds.has("filler"))
+    for (const r of findVideoFillers(words, options.fillers)) {
+      const first = startIndex(r.from);
+      out.push({ ...r, kind: "filler", words: [first, first + r.text.split(" ").length - 1] });
+    }
+  if (kinds.has("repetition"))
+    for (const r of findVideoRepetitions(words, options.repetitions)) {
+      const first = startIndex(r.from);
+      out.push({ ...r, kind: "repetition", words: [first, first + r.text.split(" ").length - 1] });
+    }
+  if (kinds.has("pause"))
+    for (const r of findVideoTranscriptPauses(words, options.pauses)) {
+      const after = words.findIndex((w) => w.start >= r.to - VIDEO_TIME_EPSILON);
+      out.push({ ...r, kind: "pause", words: [Math.max(0, after - 1), Math.max(0, after)] });
+    }
+  return out.sort((a, b) => a.from - b.from || a.to - b.to);
+}
+function videoCutsWithMargin(ranges, keep) {
+  return ranges.map((r) => ({ ...r, from: r.from + keep, to: r.to - keep })).filter((r) => r.to - r.from > VIDEO_TIME_EPSILON);
+}
+
+// src/video-editor/mix.ts
+var VIDEO_LOUDNESS_HOP = 100;
+function kWeighting(sampleRate) {
+  let K = Math.tan(Math.PI * 1681.974450955533 / sampleRate);
+  const Vh = 10 ** (3.999843853973347 / 20);
+  const Vb = Vh ** 0.4996667741545416;
+  let Q = 0.7071752369554196;
+  let a0 = 1 + K / Q + K * K;
+  const shelf = { b: [(Vh + Vb * K / Q + K * K) / a0, 2 * (K * K - Vh) / a0, (Vh - Vb * K / Q + K * K) / a0], a: [2 * (K * K - 1) / a0, (1 - K / Q + K * K) / a0] };
+  K = Math.tan(Math.PI * 38.13547087602444 / sampleRate);
+  Q = 0.5003270373238773;
+  a0 = 1 + K / Q + K * K;
+  const highPass = { b: [1, -2, 1], a: [2 * (K * K - 1) / a0, (1 - K / Q + K * K) / a0] };
+  return [shelf, highPass];
+}
+function videoLoudnessEnergy(channels, sampleRate) {
+  const length = channels.reduce((n, c) => Math.max(n, c.length), 0);
+  const hopSamples = Math.max(1, Math.round(sampleRate * VIDEO_LOUDNESS_HOP / 1e3));
+  const hops = Math.max(1, Math.ceil(length / hopSamples));
+  const energy = new Float32Array(hops);
+  const filters = kWeighting(sampleRate);
+  for (const channel of channels) {
+    const x1 = [0, 0];
+    const x2 = [0, 0];
+    const y1 = [0, 0];
+    const y2 = [0, 0];
+    for (let i = 0; i < channel.length; i++) {
+      let v = Number.isFinite(channel[i]) ? channel[i] : 0;
+      for (let f = 0; f < 2; f++) {
+        const { b, a } = filters[f];
+        const y = b[0] * v + b[1] * x1[f] + b[2] * x2[f] - a[0] * y1[f] - a[1] * y2[f];
+        x2[f] = x1[f];
+        x1[f] = v;
+        y2[f] = y1[f];
+        y1[f] = y;
+        v = y;
+      }
+      energy[Math.floor(i / hopSamples)] += v * v;
+    }
+  }
+  for (let h = 0; h < hops; h++) energy[h] /= Math.min(hopSamples, length - h * hopSamples) || 1;
+  return { hop: VIDEO_LOUDNESS_HOP, energy };
+}
+var lufs = (meanSquare) => -0.691 + 10 * Math.log10(meanSquare);
+function videoLoudnessOf(loudness, from = 0, to = Infinity) {
+  const { hop, energy } = loudness;
+  const a = Math.max(0, Math.floor(from / hop));
+  const b = Math.min(energy.length, Math.ceil(to / hop));
+  if (b <= a) return null;
+  const blocks = [];
+  if (b - a < 4) {
+    let sum = 0;
+    for (let h = a; h < b; h++) sum += energy[h];
+    blocks.push(sum / (b - a));
+  } else
+    for (let h = a; h + 4 <= b; h++) blocks.push((energy[h] + energy[h + 1] + energy[h + 2] + energy[h + 3]) / 4);
+  const absolute = blocks.filter((z) => z > 0 && lufs(z) > -70);
+  if (!absolute.length) return null;
+  const threshold = lufs(absolute.reduce((s, z) => s + z, 0) / absolute.length) - 10;
+  const gated = absolute.filter((z) => lufs(z) > threshold);
+  if (!gated.length) return null;
+  return Math.round(lufs(gated.reduce((s, z) => s + z, 0) / gated.length) * 10) / 10;
+}
+function measureVideoLoudness(channels, sampleRate) {
+  return videoLoudnessOf(videoLoudnessEnergy(channels, sampleRate));
+}
+function videoAudioLoudness(peaks, from = 0, to = Infinity) {
+  if (!peaks.loudness) throw new Error("These peaks have no loudness data; build them again with buildVideoAudioPeaks (or decodeVideoAudioPeaks), which measures it.");
+  return videoLoudnessOf(peaks.loudness, from, to);
+}
+function videoLoudnessGain(measured, target = -14, options = {}) {
+  let db = target - measured;
+  let limitedBy;
+  const maxDb = 20 * Math.log10(options.maxGain ?? 4);
+  if (db > maxDb) {
+    db = maxDb;
+    limitedBy = "max-gain";
+  }
+  if (options.peakDb !== void 0 && options.peakDb > -100) {
+    const room = (options.ceiling ?? -1) - options.peakDb;
+    if (db > room) {
+      db = room;
+      limitedBy = "peak";
+    }
+  }
+  return { gain: Math.round(10 ** (db / 20) * 1e3) / 1e3, gainDb: Math.round(db * 10) / 10, ...limitedBy ? { limitedBy } : {} };
+}
+function videoSpeechRanges(words, mergeGap = 500) {
+  const merged = [];
+  for (const r of mergeVideoRanges(words.map((w) => ({ from: w.start, to: w.end })))) {
+    const last = merged[merged.length - 1];
+    if (last && r.from - last.to < mergeGap) last.to = Math.max(last.to, r.to);
+    else merged.push({ ...r });
+  }
+  return merged;
+}
+function videoDuckingKeys(clip, speech, options = {}) {
+  const duckDb = options.duckDb ?? -14;
+  const attack = Math.max(0, options.attack ?? 200);
+  const release = Math.max(0, options.release ?? 400);
+  const gap = Math.max(options.mergeGap ?? 600, attack + release);
+  const base = options.base ?? 1;
+  const low = Math.round(base * 10 ** (duckDb / 20) * 1e4) / 1e4;
+  const end = videoClipEnd(clip);
+  const ranges = [];
+  for (const r of mergeVideoRanges(speech)) {
+    if (r.to <= clip.start - release || r.from >= end + attack) continue;
+    const last = ranges[ranges.length - 1];
+    if (last && r.from - last.to < gap) last.to = Math.max(last.to, r.to);
+    else ranges.push({ ...r });
+  }
+  if (!ranges.length) return [];
+  const keys = [];
+  const at = (t) => Math.round(Math.min(clip.duration, Math.max(0, t - clip.start)));
+  const push = (t, v, ease) => {
+    const last = keys[keys.length - 1];
+    if (last && t <= last.t) {
+      last.v = v;
+      if (ease) last.ease = ease;
+      else delete last.ease;
+      return;
+    }
+    keys.push({ t, v, ...ease ? { ease } : {} });
+  };
+  for (const r of ranges) {
+    const down = at(r.from - attack);
+    const held = at(r.from);
+    if (held > down) push(down, base, "ease-in-out");
+    push(held, low);
+    const hold = at(r.to);
+    const up = at(r.to + release);
+    if (up > hold) {
+      push(hold, low, "ease-in-out");
+      push(up, base);
+    }
+  }
+  return keys;
+}
+function findVideoAudioBeats(peaks, from, to, options = {}) {
+  const res = Math.max(1, options.resolution ?? 10);
+  const n = Math.max(2, Math.ceil((to - from) / res));
+  const spans = videoAudioPeakSpans(peaks, from, to, n);
+  const env = new Float32Array(n);
+  for (let i = 0; i < n; i++) env[i] = Math.max(Math.abs(spans[2 * i]), Math.abs(spans[2 * i + 1]));
+  const onset = new Float32Array(n);
+  for (let i = 1; i < n; i++) onset[i] = Math.max(0, env[i] - env[i - 1]);
+  const win = Math.max(1, Math.round(500 / res));
+  const k = options.sensitivity ?? 1.5;
+  const minGap = Math.max(1, Math.round((options.minInterval ?? 250) / res));
+  const onsets = [];
+  const strength = [];
+  let lastAt = -Infinity;
+  for (let i = 1; i < n - 1; i++) {
+    if (!(onset[i] > 0 && onset[i] >= onset[i - 1] && onset[i] >= onset[i + 1])) continue;
+    let sum = 0;
+    let sq = 0;
+    let count = 0;
+    for (let j = Math.max(0, i - win); j < Math.min(n, i + win + 1); j++) {
+      sum += onset[j];
+      sq += onset[j] * onset[j];
+      count++;
+    }
+    const mean = sum / count;
+    const sd = Math.sqrt(Math.max(0, sq / count - mean * mean));
+    if (onset[i] < mean + k * sd || onset[i] < 0.02) continue;
+    if (i - lastAt < minGap) {
+      if (onset[i] > strength[strength.length - 1]) {
+        onsets[onsets.length - 1] = from + i * res;
+        strength[strength.length - 1] = onset[i];
+        lastAt = i;
+      }
+      continue;
+    }
+    onsets.push(from + i * res);
+    strength.push(onset[i]);
+    lastAt = i;
+  }
+  const minLag = Math.max(1, Math.round(6e4 / (options.maxBpm ?? 200) / res));
+  const maxLag = Math.min(n - 1, Math.round(6e4 / (options.minBpm ?? 60) / res));
+  let bestLag = 0;
+  let best = 0;
+  let total = 0;
+  for (let i = 0; i < n; i++) total += onset[i] * onset[i];
+  for (let lag = minLag; lag <= maxLag; lag++) {
+    let s = 0;
+    for (let i = 0; i + lag < n; i++) s += onset[i] * onset[i + lag];
+    s /= n - lag;
+    if (s > best * 1.0001) {
+      best = s;
+      bestLag = lag;
+    }
+  }
+  const repeats = onsets.length >= 3 && bestLag > 0 && best * n > 0.2 * total;
+  if (!repeats) return { onsets, bpm: null, beats: [] };
+  const period = bestLag * res;
+  const bpm = Math.round(6e4 / period * 10) / 10;
+  let phase = onsets[0];
+  let agree = -1;
+  for (const o of onsets) {
+    let a = 0;
+    for (const p of onsets) {
+      const d = Math.abs(((p - o) % period + period) % period);
+      if (Math.min(d, period - d) <= res * 2) a++;
+    }
+    if (a > agree) {
+      agree = a;
+      phase = o;
+    }
+  }
+  const beats = [];
+  for (let t = phase - Math.floor((phase - from) / period) * period; t <= to + 1e-6; t += period) if (t >= from - 1e-6) beats.push(Math.round(t * 10) / 10);
+  return { onsets, bpm, beats };
+}
+function nearestVideoBeat(beats, time, tolerance = Infinity) {
+  let best = null;
+  for (const b of beats) if (Math.abs(b - time) <= tolerance && (best === null || Math.abs(b - time) < Math.abs(best - time))) best = b;
+  return best;
+}
+
 // src/video-editor/audio.ts
 var VIDEO_PEAK_BLOCK = 32;
 function buildVideoAudioPeaks(channels, sampleRate, blockSize = VIDEO_PEAK_BLOCK) {
@@ -1467,7 +1959,7 @@ function buildVideoAudioPeaks(channels, sampleRate, blockSize = VIDEO_PEAK_BLOCK
     }
     levels.push(up);
   }
-  return { sampleRate, length, blockSize, levels };
+  return { sampleRate, length, blockSize, levels, loudness: videoLoudnessEnergy(channels, sampleRate) };
 }
 var videoAudioPeaksDuration = (peaks) => peaks.length * 1e3 / peaks.sampleRate;
 function videoAudioPeakRange(peaks, from, to) {
@@ -1645,6 +2137,50 @@ var VideoAudioPeaksCache = class {
   }
 };
 
+// src/video-editor/plan.ts
+function clipIndex(project) {
+  const out = /* @__PURE__ */ new Map();
+  for (const { track } of allVideoTracks(project)) for (const c of track.clips) out.set(c.id, c);
+  return out;
+}
+function diffVideoProjects(before, after) {
+  const a = clipIndex(before);
+  const b = clipIndex(after);
+  const clipsAdded = [...b.keys()].filter((id) => !a.has(id));
+  const clipsRemoved = [...a.keys()].filter((id) => !b.has(id));
+  const clipsChanged = [...b.keys()].filter((id) => a.has(id) && JSON.stringify(a.get(id)) !== JSON.stringify(b.get(id)));
+  const durationBefore = videoProjectDuration(before);
+  const durationAfter = videoProjectDuration(after);
+  return { durationBefore, durationAfter, durationDelta: durationAfter - durationBefore, clipsAdded, clipsRemoved, clipsChanged };
+}
+function planVideoEdits(project, input) {
+  if (!input.title?.trim()) return { ok: false, error: 'A plan needs a title saying what it does (e.g. "Remove 12 filler words").' };
+  if (!input.edits.length) return { ok: false, error: "The plan has no edits; there is nothing to propose." };
+  const result = applyVideoEdits(project, input.edits);
+  if (!result.ok) return { ok: false, error: result.error };
+  const known = new Set(checkVideoProject(project).map(videoIssueKey));
+  const summary = { ...diffVideoProjects(project, result.project), newIssues: result.issues.filter((i) => !known.has(videoIssueKey(i))), edits: input.edits.length };
+  const plan = {
+    id: input.id ?? "plan",
+    title: input.title.trim(),
+    ...input.description ? { description: input.description } : {},
+    ...input.source ? { source: input.source } : {},
+    edits: structuredClone([...input.edits]),
+    ...input.ranges?.length ? { ranges: input.ranges.map((r) => ({ ...r })) } : {},
+    summary
+  };
+  return { ok: true, plan, project: result.project };
+}
+function describeVideoEditPlan(plan) {
+  const s = plan.summary;
+  const parts = [];
+  if (plan.ranges?.length) parts.push(`${plan.ranges.length} stretch${plan.ranges.length > 1 ? "es" : ""}`);
+  const delta = s.durationDelta;
+  const length = Math.abs(delta) < 0.5 ? "same length" : `${(Math.abs(delta) / 1e3).toFixed(1)} s ${delta < 0 ? "shorter" : "longer"}`;
+  const clips = [s.clipsAdded.length && `${s.clipsAdded.length} added`, s.clipsChanged.length && `${s.clipsChanged.length} changed`, s.clipsRemoved.length && `${s.clipsRemoved.length} removed`].filter(Boolean).join(", ");
+  return `${plan.title} (${parts.length ? `${parts.join(", ")}, ` : ""}${length})${clips ? `: clips ${clips}` : ""}`;
+}
+
 // src/video-editor/scopes.ts
 var VIDEO_SCOPE_KINDS = ["histogram", "waveform", "vectorscope"];
 var videoLuma = (r, g, b) => 0.2126 * r + 0.7152 * g + 0.0722 * b;
@@ -2014,174 +2550,178 @@ function readVideoScopesPanel(feed, kinds = VIDEO_SCOPE_KINDS, options = {}) {
   const opts = { maxPixels: options.maxPixels ?? 65536 };
   const images = {};
   for (const kind of kinds) images[kind] = videoScopeImage(kind, snap.pixels, width, height, opts);
-  const stats = videoExposureStats(snap.pixels, opts);
-  return { ok: true, time: snap.time, complete: snap.complete, images, stats, notes: videoExposureNotes(stats) };
-}
-
-// 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, n) => ({ from: words[i].start, to: words[i + n - 1].end, text: words.slice(i, i + n).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;
+  const stats = videoExposureStats(snap.pixels, opts);
+  return { ok: true, time: snap.time, complete: snap.complete, images, stats, notes: videoExposureNotes(stats) };
 }
-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);
+
+// src/video-editor/transcript-controller.ts
+var TranscriptVideoController = class {
+  constructor(controller, options = {}) {
+    this.controller = controller;
+    this.options = options;
+    this.track = options.track;
+    this.state = this.compute();
+    this.connect();
+  }
+  controller;
+  options;
+  listeners = /* @__PURE__ */ new Set();
+  unsubscribe = null;
+  track;
+  selection = null;
+  error = null;
+  state;
+  /** Words and disfluencies are worked out once per project. */
+  cache = null;
+  getState = () => this.state;
+  connect() {
+    if (this.unsubscribe) return;
+    this.unsubscribe = this.controller.subscribe(() => this.refresh());
+    this.refresh();
+  }
+  /** Listens for changes. Subscribing after `destroy` follows the editor again (React StrictMode remounts). */
+  subscribe = (listener) => {
+    this.connect();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** Stops following the editor. */
+  destroy() {
+    this.unsubscribe?.();
+    this.unsubscribe = null;
+    this.listeners.clear();
+  }
+  words(project) {
+    const c = this.cache;
+    if (c && c.project === project && c.track === this.track) return c;
+    let words = [];
+    let trackId = null;
+    try {
+      trackId = videoTranscriptTrack(project, this.track);
+      words = videoTimelineTranscript(project, { track: this.track });
+    } catch {
     }
-    if (to - from > VIDEO_TIME_EPSILON) out.push({ from, to, text: `(pause after "${a.word}")` });
+    const disfluencies = detectVideoDisfluencies(words, { ...this.options.disfluencies, pauses: { fps: project.fps, ...this.options.disfluencies?.pauses } });
+    const flags = {};
+    for (const d of disfluencies)
+      for (let i = d.words[0]; i <= d.words[1]; i++) {
+        if (d.kind === "pause" && i !== d.words[0]) continue;
+        const f = flags[i] ??= [];
+        if (!f.includes(d.kind)) f.push(d.kind);
+      }
+    this.cache = { project, track: this.track, words, trackId, text: words.map((w) => w.word).join(" "), disfluencies, flags };
+    return this.cache;
+  }
+  compute() {
+    const editor = this.controller.getState();
+    const c = this.words(editor.project);
+    if (this.selection && (this.selection[0] >= c.words.length || this.selection[1] >= c.words.length)) this.selection = null;
+    return { track: c.trackId, words: c.words, text: c.text, current: videoWordAt(c.words, editor.time), selection: this.selection, disfluencies: c.disfluencies, flags: c.flags, editable: !editor.readOnly, error: this.error };
+  }
+  refresh() {
+    const next = this.compute();
+    const prev = this.state;
+    if (next.words === prev.words && next.current === prev.current && next.selection === prev.selection && next.editable === prev.editable && next.error === prev.error && next.disfluencies === prev.disfluencies) return;
+    this.state = next;
+    this.listeners.forEach((l) => l(next));
+  }
+  /** Follows another track's words (`undefined`: the default track). */
+  setTrack(track) {
+    this.track = track;
+    this.selection = null;
+    this.refresh();
+  }
+  /** Moves the playhead to the start of a word. */
+  seekToWord(index) {
+    const w = this.state.words[index];
+    if (w) this.controller.seek(w.start);
+  }
+  /** Selects words `a` to `b` (either order), or clears the selection with `null`. */
+  select(a, b = a) {
+    const n = this.state.words.length;
+    this.selection = a === null || b === null || a < 0 || b < 0 || a >= n || b >= n ? null : a <= b ? [a, b] : [b, a];
+    this.error = null;
+    this.refresh();
+  }
+  /** Index of the word playing at a timeline time, or -1. */
+  wordAt(time) {
+    return videoWordAt(this.state.words, time);
+  }
+  /** Where word `index` begins in `text` (characters). */
+  textOffset(index) {
+    let offset = 0;
+    for (let i = 0; i < Math.min(index, this.state.words.length); i++) offset += this.state.words[i].word.length + 1;
+    return offset;
+  }
+  /** The word a caret at `offset` characters into `text` is in (or just after), as an index; -1 when there are no words. */
+  wordAtOffset(offset) {
+    const { words } = this.state;
+    let at = 0;
+    for (let i = 0; i < words.length; i++) {
+      at += words[i].word.length;
+      if (offset <= at) return i;
+      at += 1;
+    }
+    return words.length - 1;
   }
-  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);
+  /** The timeline time a caret at `offset` characters into `text` stands for: the start of its word. */
+  timeAtOffset(offset) {
+    const i = this.wordAtOffset(offset);
+    return i < 0 ? null : this.state.words[i].start;
   }
-  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;
+  fail(message) {
+    this.error = message;
+    this.refresh();
+    return { ok: false, error: message };
   }
-  return -1;
-}
+  /** Cuts ranges out (or proposes a plan to, with `plan`), as one undo step. */
+  cut(ranges, title, plan) {
+    if (!ranges.length) return this.fail("There is nothing to cut.");
+    const merged = mergeVideoRanges(ranges);
+    const edits = videoRemoveRangesEdits(merged);
+    if (plan) {
+      const r2 = this.controller.proposePlan({ title, edits, ranges, source: "transcript" });
+      if (!r2.ok) return this.fail(r2.error);
+      this.error = null;
+      this.select(null);
+      return { ok: true, plan: r2.plan };
+    }
+    const r = this.controller.apply(edits, title);
+    if (!r.ok) return this.fail(r.error);
+    this.error = null;
+    this.select(null);
+    return { ok: true, applied: r };
+  }
+  /** Deletes the selected words, cutting their stretch out of the timeline (or proposing it with `planFirst`). */
+  deleteSelection(options = {}) {
+    const sel = this.state.selection;
+    if (!sel) return this.fail("Select the words to delete first.");
+    const { words } = this.state;
+    const range = videoWordsRange(words, sel[0], sel[1]);
+    const text = words.slice(sel[0], sel[1] + 1).map((w) => w.word).join(" ");
+    return this.cut([{ ...range, text, reason: "deleted" }], sel[0] === sel[1] ? `Delete "${text}"` : `Delete ${sel[1] - sel[0] + 1} words`, options.plan ?? this.options.planFirst ?? false);
+  }
+  /** Cuts one disfluency out at once (its index in `disfluencies`), as one undo step. */
+  removeDisfluency(index) {
+    const d = this.state.disfluencies[index];
+    if (!d) return this.fail(`There is no disfluency ${index}; there are ${this.state.disfluencies.length}.`);
+    return this.cut([{ from: d.from, to: d.to, text: d.text, reason: d.kind }], d.kind === "pause" ? "Tighten pause" : `Remove "${d.text}"`, false);
+  }
+  /** Proposes one plan that cuts every disfluency of the given kinds (default all), for review. */
+  planCleanup(kinds) {
+    const found = this.state.disfluencies.filter((d) => !kinds || kinds.includes(d.kind));
+    if (!found.length) return this.fail(kinds ? `No ${kinds.join(", ")} found.` : "No fillers, long pauses or repetitions found.");
+    const counts = ["filler", "pause", "repetition"].map((k) => [k, found.filter((d) => d.kind === k).length]).filter(([, n]) => n);
+    const title = `Clean up ${counts.map(([k, n]) => `${n} ${k}${n > 1 ? "s" : ""}`).join(", ")}`;
+    return this.cut(
+      found.map((d) => ({ from: d.from, to: d.to, text: d.text, reason: d.kind })),
+      title,
+      true
+    );
+  }
+};
 
 // src/video-editor/proxy.ts
 var VIDEO_PROXY_SCALES = [0.5, 0.25];
@@ -2773,7 +3313,7 @@ var VideoPreviewEngine = class {
 };
 
 // src/video-editor/controller.ts
-var VideoEditorController = class {
+var VideoEditorController = class _VideoEditorController {
   history;
   player;
   /** Sound levels per asset, loaded on demand for waveforms and agents. */
@@ -2800,6 +3340,10 @@ var VideoEditorController = class {
   listeners = /* @__PURE__ */ new Set();
   unsubscribers = [];
   state;
+  plans = [];
+  /** The project each open plan was worked out against. */
+  planBasis = /* @__PURE__ */ new Map();
+  planCount = 0;
   constructor(options = {}) {
     this.history = options.history ?? new HistoryManager();
     this.audioPeaks = options.audioPeaks instanceof VideoAudioPeaksCache ? options.audioPeaks : new VideoAudioPeaksCache(options.audioPeaks);
@@ -2865,6 +3409,7 @@ var VideoEditorController = class {
       redoLabel: h.redoName,
       previewScale: this.previewScale,
       effectsProvider: this.effects.provider,
+      plans: this.plans,
       revision: this.revision
     };
   }
@@ -2933,6 +3478,86 @@ var VideoEditorController = class {
     if (!options.dryRun) this.commit(label, result.project, options.merge);
     return result;
   }
+  // -----------------------------------------------------------------------------------------
+  // Edit plans: propose, review, apply or discard
+  // -----------------------------------------------------------------------------------------
+  /** Most plans kept open at once; proposing another drops the oldest. */
+  static MAX_PLANS = 20;
+  /**
+   * Works out a batch of edits without applying it and keeps it for review (see `VideoEditPlan`):
+   * the result says what it would do. Allowed while read-only (nothing changes); applying is not.
+   * A plan with the id of an open one replaces it.
+   */
+  proposePlan(input) {
+    const ids = new Set(this.plans.map((p) => p.id));
+    let id = input.id;
+    let count = this.planCount;
+    if (id === void 0) {
+      do
+        id = `plan${++count}`;
+      while (ids.has(id));
+    }
+    const result = planVideoEdits(this.project, { ...input, id });
+    if (!result.ok) return result;
+    this.planCount = count;
+    const kept = this.plans.filter((p) => p.id !== id);
+    while (kept.length >= _VideoEditorController.MAX_PLANS) this.planBasis.delete(kept.shift().id);
+    this.plans = [...kept, result.plan];
+    this.planBasis.set(id, this.project);
+    this.notify();
+    return { ok: true, plan: result.plan };
+  }
+  /** An open plan, or `undefined`. */
+  getPlan(id) {
+    return this.plans.find((p) => p.id === id);
+  }
+  /** Whether the project changed since a plan was made (its summary may then be out of date). */
+  isPlanStale(id) {
+    const basis = this.planBasis.get(id);
+    return !!basis && basis !== this.project;
+  }
+  /** The project as an open plan would leave it, worked out against the current project; `null` when it no longer applies. */
+  planPreview(id) {
+    const plan = this.getPlan(id);
+    if (!plan) return null;
+    const result = applyVideoEdits(this.project, plan.edits);
+    return result.ok ? result.project : null;
+  }
+  /**
+   * Applies an open plan as one undo step labelled with its title and closes it. If the project
+   * changed since it was made, its edits are checked again against the project as it is now and
+   * refused (the plan stays open) when they no longer apply.
+   */
+  applyPlan(id) {
+    const plan = this.getPlan(id);
+    if (!plan) return this.refused(`There is no open plan "${id}"; the open plans are ${this.plans.map((p) => `"${p.id}"`).join(", ") || "none"}.`);
+    const reason = this.readOnlyReason();
+    if (reason) return this.refused(reason);
+    const stale = this.isPlanStale(id);
+    const result = applyVideoEdits(this.project, plan.edits);
+    if (!result.ok) return this.refused(stale ? `The project changed since plan "${id}" was made and it no longer applies (${result.error}); discard it and make a new plan.` : result.error);
+    this.dropPlan(id);
+    this.commit(plan.title, result.project);
+    return { ...result, plan, stale };
+  }
+  /** Closes an open plan without applying it. False when there is no such plan. */
+  discardPlan(id) {
+    if (!this.getPlan(id)) return false;
+    this.dropPlan(id);
+    this.notify();
+    return true;
+  }
+  /** Closes every open plan. */
+  discardPlans() {
+    if (!this.plans.length) return;
+    this.plans = [];
+    this.planBasis.clear();
+    this.notify();
+  }
+  dropPlan(id) {
+    this.plans = this.plans.filter((p) => p.id !== id);
+    this.planBasis.delete(id);
+  }
   /** Opens a project (JSON or object). `clearHistory` drops the undo stack (opening a file); otherwise it is one undo step. */
   load(project, options = {}) {
     let parsed;
@@ -3345,6 +3970,7 @@ function videoClipTint(clip, asset) {
   if (clip.type === "sequence") return "#0d9488";
   if (clip.type === "color") return clip.color;
   if (clip.type === "effect") return "#db2777";
+  if (clip.type === "adjustment") return "#64748b";
   if (!asset) return "#ef4444";
   return asset.kind === "audio" ? "#10b981" : asset.kind === "image" ? "#f59e0b" : "#3b82f6";
 }
@@ -3354,6 +3980,7 @@ function videoClipLabel(clip, asset, sequence) {
   if (clip.type === "color") return clip.color;
   if (clip.type === "sequence") return `Compound: ${sequence?.name ?? clip.sequence}`;
   if (clip.type === "effect") return `Effect: ${clip.effect}`;
+  if (clip.type === "adjustment") return `Adjustment${clip.scope === "all" ? " (all tracks)" : clip.scope === "track" ? ` (${clip.targetTrack})` : ""}`;
   const base = asset?.name ?? asset?.src.replace(/^.*[\\/]/, "") ?? clip.asset;
   const speed = videoClipSpeed(clip);
   return speed !== 1 ? `${base} (${Math.round(speed * 100)}%)` : base;
@@ -3518,6 +4145,50 @@ function videoLutEdits(project, clips, lut) {
   }
   return edits;
 }
+var VIDEO_ADJUSTMENT_SCOPE_LABELS = {
+  underneath: "Tracks underneath",
+  all: "Whole frame",
+  track: "One track"
+};
+var VIDEO_MASK_SHAPE_LABELS = {
+  rectangle: "Rectangle",
+  ellipse: "Ellipse",
+  linear: "Split",
+  polygon: "Polygon"
+};
+var videoClipHeading = (clip) => ({ media: "Media clip", text: "Title", sequence: "Compound clip", color: "Colour clip", effect: "Effect clip", adjustment: "Adjustment clip" })[clip.type];
+function videoAddAdjustmentEdits(project, time, options = {}) {
+  const duration = options.duration ?? 3e3;
+  const start = Math.max(0, time);
+  const top = project.tracks[0];
+  const free = top && top.kind === "video" && !top.locked && !top.clips.some((c) => c.start < start + duration && videoClipEnd(c) > start);
+  const edits = [];
+  let track = top?.id;
+  if (!free) {
+    const ids = new Set(project.tracks.map((t) => t.id));
+    let n = 1;
+    while (ids.has(n === 1 ? "adj" : `adj${n}`)) n++;
+    track = n === 1 ? "adj" : `adj${n}`;
+    edits.push({ op: "add_track", track: { id: track, kind: "video", name: "Adjustments" }, at: 0 });
+  }
+  edits.push({ op: "add_clip", track, clip: { type: "adjustment", ...options.id ? { id: options.id } : {}, start, duration, ...options.grade ? { grade: options.grade } : {} } });
+  return edits;
+}
+function videoMaskEdit(clip, mask) {
+  return mask ? { op: "update_clip", clip, set: { mask } } : { op: "update_clip", clip, remove: ["mask"] };
+}
+function videoSkinProtectionEdits(project, clips, amount) {
+  const edits = [];
+  for (const id of clips) {
+    const clip = findVideoClip(project, id)?.clip;
+    const lut = clip?.grade?.lut;
+    if (!clip || !lut) continue;
+    const { preserveSkinTones: _p, ...rest } = lut;
+    const k = Math.min(1, Math.max(0, amount));
+    edits.push({ op: "update_clip", clip: id, set: { grade: { ...clip.grade, lut: k > 0 ? { ...rest, preserveSkinTones: k } : rest } } });
+  }
+  return edits;
+}
 
 // src/video-editor/tools.ts
 var round = (ms) => Math.round(ms * 10) / 10;
@@ -3571,10 +4242,11 @@ var TRANSITION = object(
 );
 var LUT_SRC = { type: "string", minLength: 1, description: 'A .cube 3D LUT file the host can load and ffmpeg can read: a URL or path, often from the user (e.g. "luts/teal-orange.cube").' };
 var LUT_STRENGTH = { type: "number", minimum: 0, maximum: 1, description: "How much of the LUT's change to apply, 0 (none) to 1 (full, the default); 0.3-0.7 for a subtler look." };
+var SKIN = { type: "number", minimum: 0, maximum: 1, description: "How much of the LUT's change to hold back on skin tones, 0 (none, the default) to 1 (skin keeps its colour); 0.5-0.8 keeps faces natural under a heavy look. Applied in the preview and frame renders; ffmpeg's lut3d cannot, so the export notes it." };
 var GRADE = object(
   {
     ...Object.fromEntries(VIDEO_GRADE_CONTROLS.map((c) => [c.key, { type: "number", minimum: c.min, maximum: c.max, description: c.description }])),
-    lut: object({ src: LUT_SRC, strength: LUT_STRENGTH, name: { type: "string", minLength: 1, description: "A label for the look." } }, ["src"], "A 3D LUT applied after the other settings (set_video_lut checks the file first).")
+    lut: object({ src: LUT_SRC, strength: LUT_STRENGTH, name: { type: "string", minLength: 1, description: "A label for the look." }, preserveSkinTones: SKIN }, ["src"], "A 3D LUT applied after the other settings (set_video_lut checks the file first).")
   },
   [],
   "Colour correction of the picture, applied in order: exposure, contrast, saturation, hue, white balance (temperature, tint), then a LUT. Leave a setting out for no change; the object replaces the clip's whole grade."
@@ -4053,12 +4725,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, blend mode, colour grade, entrance and exit animations, fades, name; for media volume, mute, the sound's fade curves, speed (keeps the stretch of source, so the length changes) or asset; for compound clips in point, volume, mute and fade curves (no speed); 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, blend mode, colour grade, entrance and exit animations, fades, name; for media volume, mute, the sound's fade curves, speed (keeps the stretch of source, so the length changes) or asset; for compound clips in point, volume, mute and fade curves (no speed); for titles text and style; for colours the colour; for adjustment clips the scope and target track (masks: set_video_clip_mask). 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", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "in", "speed", "volume", "muted", "fontSize", "fontFamily", "fontWeight", "background"] }, description: "Fields to reset to their defaults." }
+        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"), scope: { type: "string", enum: [...VIDEO_ADJUSTMENT_SCOPES], description: "For adjustment clips: which pictures it changes, underneath (default), all or track." }, targetTrack: { ...TRACK_ID, description: 'For adjustment clips with scope "track": the track whose pictures it changes.' } }, [], "Fields to replace (only those that fit the clip's type)."),
+        remove: { type: "array", items: { type: "string", enum: ["name", "opacity", "transform", "fit", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", "fadeInCurve", "fadeOutCurve", "in", "speed", "volume", "muted", "fontSize", "fontFamily", "fontWeight", "background", "scope", "targetTrack"] }, description: 'Fields to reset to their defaults (an adjustment clip going from scope "track" to another scope must also remove targetTrack).' }
       },
       ["clip"]
     ),
@@ -4127,17 +4799,18 @@ function createVideoEditorToolProvider(controller, options = {}) {
         clips: { type: "array", items: CLIP_ID, minItems: 1, uniqueItems: true, description: "Clips on video tracks to grade." },
         src: LUT_SRC,
         strength: LUT_STRENGTH,
-        name: { type: "string", minLength: 1, description: "A label for the look (default the file's TITLE)." }
+        name: { type: "string", minLength: 1, description: "A label for the look (default the file's TITLE)." },
+        preserve_skin_tones: SKIN
       },
       ["clips", "src"]
     ),
     annotations: { title: "Apply a LUT", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
-    handler: async ({ clips, src, strength, name }) => {
+    handler: async ({ clips, src, strength, name, preserve_skin_tones }) => {
       if (strength === 0) throw new Error("A strength of 0 changes nothing; pass a strength above 0, or remove the LUT with remove_video_lut.");
       gradeTargets(clips);
       const lut = await controller.luts.load(src);
       const label = name ?? lut.title;
-      const setting = { src, ...strength !== void 0 && strength !== 1 ? { strength } : {}, ...label ? { name: label } : {} };
+      const setting = { src, ...strength !== void 0 && strength !== 1 ? { strength } : {}, ...label ? { name: label } : {}, ...preserve_skin_tones ? { preserveSkinTones: preserve_skin_tones } : {} };
       return apply(videoLutEdits(project(), clips, setting), "Apply LUT", (r) => ({ lut: { src, ...lut.title ? { title: lut.title } : {}, size: lut.size }, clips: clips.map((id) => ({ id, grade: findVideoClip(r.project, id)?.clip.grade ?? null })) }));
     }
   };
@@ -4341,7 +5014,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     if (!at) throw new Error(`There is no clip "${id}"; get_video_project lists the clips.`);
     const { clip } = at;
     if (clip.type === "sequence") throw new Error(`Clip "${id}" is a compound clip, which plays its sequence at normal speed; change the speed of the clips inside the sequence instead.`);
-    if (clip.type !== "media") throw new Error(`Clip "${id}" is a ${clip.type === "text" ? "title" : clip.type === "effect" ? "effect clip" : "colour"}, so it has no source to change the speed of; use a video or audio clip.`);
+    if (clip.type !== "media") throw new Error(`Clip "${id}" is a ${videoClipTypeLabel(clip)}, 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;
   };
@@ -4595,7 +5268,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     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 = {
+  const SOUND_TARGET2 = {
     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)"),
@@ -4606,7 +5279,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     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)." } }),
+    inputSchema: object({ ...SOUND_TARGET2, 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);
@@ -4620,7 +5293,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     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,
+      ...SOUND_TARGET2,
       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)." }
     }),
@@ -4671,8 +5344,167 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return { time: t, timecode: formatVideoTimecode(t, p.fps), width: pixels.width, height: pixels.height, ...summarizeVideoScopes(pixels, { bins, columns }) };
     }
   };
-  const reads = [getProject, listSequences, getFrame, getTranscript, findText, findFillers, findPauses, findGaps, checkProject, renderFrame, getScopes, previewCache, planProxies, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek, setPreviewScale];
-  const writes = [setSettings, addAsset, updateAsset, removeAsset, setProxies, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setSpeedRamp, addFreeze, removeRamp, setTranscript, removeRanges, applyGradePreset, copyGrade, setLut, removeLut, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
+  const MASK_FIELDS = {
+    shape: { type: "string", enum: [...VIDEO_MASK_SHAPES], description: "rectangle (with corner_radius), ellipse, linear (a straight split: the side above the line at rotation 0 shows) or polygon (points)." },
+    x: { type: "number", description: "Centre across the clip's picture, 0 (left edge) to 1 (right edge); default 0.5." },
+    y: { type: "number", description: "Centre down the clip's picture, 0 (top) to 1 (bottom); default 0.5." },
+    width: { type: "number", minimum: 0, description: "Width as a fraction of the picture's width (default 0.5). Unused by linear." },
+    height: { type: "number", minimum: 0, description: "Height as a fraction of the picture's height (default 0.5). Unused by linear." },
+    rotation: { type: "number", description: "Degrees clockwise (default 0)." },
+    feather: { type: "number", minimum: 0, description: "Soft edge width in frame pixels (default 0 = hard edge)." },
+    corner_radius: { type: "number", minimum: 0, maximum: 1, description: "For rectangle: corner rounding as a fraction of half the shorter side (default 0)." },
+    inverted: { type: "boolean", description: "Show the outside of the shape instead of the inside (default false)." },
+    points: { type: "array", minItems: 3, maxItems: 200, items: object({ x: { type: "number", description: "Across the picture, 0\u20131." }, y: { type: "number", description: "Down the picture, 0\u20131." } }, ["x", "y"], "A corner of the polygon."), description: "For polygon (required): its corners in order, as fractions of the clip's picture." }
+  };
+  const addAdjustment = {
+    name: "add_video_adjustment_clip",
+    title: "Add an adjustment clip",
+    description: 'Adds an adjustment clip to a video track (one undo step): it has no picture, but while it plays its grade (and any effects added later with apply_effect, and a mask from set_video_clip_mask) change the composite of the pictures in its scope: "underneath" (every video track below its own, the default), "all" (the whole frame) or "track" (only target_track). Put it on a track above what it should change, usually a new top track. Give the look as "grade" and/or "preset" (a named look at "amount"). Returns the clip (id, start, duration, end, scope).',
+    inputSchema: object(
+      {
+        track: { ...TRACK_ID, description: 'A video track to put it on; tracks below it are "underneath".' },
+        start: MS("Where it starts on the timeline (default: the end of the track)"),
+        duration: { type: "number", exclusiveMinimum: 0, description: "How long it lasts, in ms (default 3000)." },
+        scope: { type: "string", enum: [...VIDEO_ADJUSTMENT_SCOPES], description: "Which pictures it changes: underneath (default), all or track." },
+        target_track: { ...TRACK_ID, description: 'For scope "track" (required then): the track whose pictures it changes.' },
+        grade: GRADE,
+        preset: { type: "string", enum: [...VIDEO_GRADE_PRESET_NAMES], description: "A named look to start from (grade settings given override it)." },
+        amount: { type: "number", minimum: 0, maximum: 1, description: "Strength of the preset, 0\u20131 (default 1)." },
+        name: { type: "string", minLength: 1, description: 'A label for the clip (e.g. "Night look").' },
+        id: { type: "string", minLength: 1, description: 'Your own id for the clip (default: a fresh one such as "c7").' },
+        mode: MODE
+      },
+      ["track"]
+    ),
+    annotations: { title: "Add an adjustment clip", ...WRITE },
+    handler: ({ track, start, duration, scope, target_track, grade, preset, amount, name, id, mode }) => {
+      const t = project().tracks.find((x) => x.id === track);
+      if (t && t.kind !== "video") throw new Error(`Track "${track}" is an audio track; adjustment clips change pictures, so put it on a video track.`);
+      if (scope === "track" && !target_track) throw new Error('Scope "track" needs target_track: the id of the track whose pictures it changes.');
+      if (target_track !== void 0 && scope !== "track") throw new Error('target_track is only for scope "track"; leave it out or set scope to "track".');
+      const look = { ...preset ? videoGradePreset(preset, amount ?? 1) : {}, ...grade ?? {} };
+      const clip = { type: "adjustment", ...id ? { id } : {}, ...name ? { name } : {}, ...start !== void 0 ? { start } : {}, duration: duration ?? 3e3, ...scope ? { scope } : {}, ...target_track ? { targetTrack: target_track } : {}, ...Object.keys(look).length ? { grade: look } : {} };
+      return apply({ op: "add_clip", track, clip, mode }, "Add adjustment clip", (r) => ({ clip: clipOut(r.project, r.outcomes[0].clip), ...placed(r.outcomes[0]), ...Object.keys(look).length ? {} : { hint: "It changes nothing yet: give it a grade (update_video_clip), effects (apply_effect) or a mask." } }));
+    }
+  };
+  const maskTarget = (id) => {
+    const at = findVideoClip(project(), id);
+    if (!at) throw new Error(`There is no clip "${id}"; get_video_project lists the clips.`);
+    if (at.track.kind !== "video") throw new Error(`Clip "${id}" is on audio track "${at.track.id}"; masks cut pictures, so pass a clip on a video track.`);
+    return at;
+  };
+  const setMask = {
+    name: "set_video_clip_mask",
+    title: "Mask a clip",
+    description: `Cuts a clip's picture to a shape (one undo step): only the inside shows, or the outside when inverted, with a soft edge of "feather" pixels. Positions are fractions of the clip's placed picture, so the mask follows the clip's transform. On an adjustment clip it limits the adjustment to the shape (e.g. brighten a face). Replaces any mask the clip had. Returns the clip with its mask. ffmpeg exports need rendered frames for masks.`,
+    inputSchema: object({ clip: CLIP_ID, ...MASK_FIELDS }, ["clip", "shape"]),
+    annotations: { title: "Mask a clip", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, corner_radius, ...fields }) => {
+      maskTarget(clip);
+      if (fields.shape === "polygon" && !fields.points) throw new Error('A polygon mask needs "points": at least 3 { x, y } corners as fractions of the picture.');
+      if (fields.shape !== "polygon" && fields.points) throw new Error('"points" is only for shape "polygon".');
+      if (corner_radius !== void 0 && fields.shape !== "rectangle") throw new Error('"corner_radius" is only for shape "rectangle".');
+      const mask = { ...fields, ...corner_radius !== void 0 ? { cornerRadius: corner_radius } : {} };
+      return apply({ op: "update_clip", clip, set: { mask } }, "Mask clip", (r) => ({ clip: clipOut(r.project, clip) }));
+    }
+  };
+  const removeMask = {
+    name: "remove_video_clip_mask",
+    title: "Remove a clip's mask",
+    description: "Takes a clip's mask off, so its whole picture shows again (one undo step). Fails if it has none. Returns the clip.",
+    inputSchema: object({ clip: CLIP_ID }, ["clip"]),
+    annotations: { title: "Remove a clip's mask", ...DESTRUCTIVE },
+    handler: ({ clip }) => {
+      const at = maskTarget(clip);
+      if (!at.clip.mask) throw new Error(`Clip "${clip}" has no mask.`);
+      return apply({ op: "update_clip", clip, remove: ["mask"] }, "Remove mask", (r) => ({ clip: clipOut(r.project, clip) }));
+    }
+  };
+  const setSkin = {
+    name: "set_video_skin_protection",
+    title: "Protect skin tones from a LUT",
+    description: `Holds a LUT back on skin tones for clips that already have one (one undo step): at "amount" 1 skin keeps its colour while the rest of the picture takes the full look; 0 turns the protection off. Skin is found by colour, so warm orange or beige objects are protected too. Fails for clips without a LUT (add one with set_video_lut first). Returns each clip's LUT setting.`,
+    inputSchema: object({ clips: { type: "array", items: CLIP_ID, minItems: 1, uniqueItems: true, description: "Clips with a LUT." }, amount: { ...SKIN, description: "How much of the LUT to hold back on skin, 0 (off) to 1 (all of it)." } }, ["clips", "amount"]),
+    annotations: { title: "Protect skin tones from a LUT", ...WRITE_IDEMPOTENT },
+    handler: ({ clips, amount }) => {
+      gradeTargets(clips);
+      const edits = [];
+      for (const id of clips) {
+        const clip = findVideoClip(project(), id).clip;
+        const lut = clip.grade?.lut;
+        if (!lut) throw new Error(`Clip "${id}" has no LUT to protect skin from; add one with set_video_lut first.`);
+        const { preserveSkinTones: _p, ...rest } = lut;
+        edits.push({ op: "update_clip", clip: id, set: { grade: { ...clip.grade, lut: amount > 0 ? { ...rest, preserveSkinTones: amount } : rest } } });
+      }
+      return apply(edits, amount > 0 ? "Protect skin tones" : "Stop protecting skin tones", (r) => ({ clips: clips.map((id) => ({ id, lut: findVideoClip(r.project, id)?.clip.grade?.lut ?? null })) }));
+    }
+  };
+  const planOut = (plan) => ({
+    id: plan.id,
+    title: plan.title,
+    ...plan.description ? { description: plan.description } : {},
+    ...plan.source ? { source: plan.source } : {},
+    summary: { ...plan.summary, newIssues: issueSummary(plan.summary.newIssues) },
+    ...plan.ranges ? { ranges: plan.ranges.map((r) => ({ ...r, from: round(r.from), to: round(r.to) })) } : {},
+    edits: plan.edits.length,
+    stale: controller.isPlanStale(plan.id),
+    text: describeVideoEditPlan(plan)
+  });
+  const PLAN_ID = { type: "string", minLength: 1, description: 'A plan id from plan_video_edits, a plan_* tool or list_video_edit_plans (e.g. "plan1").' };
+  const planEdits = {
+    name: "plan_video_edits",
+    title: "Propose edits for review",
+    description: "Works out a batch of edits without applying them and keeps it as a plan for review: the project does not change. The plan says what it would do (length before and after, clips added, removed and changed, problems it would add) and shows in the editor for the user to accept or discard. Use it for anything the user should see before it happens (a rough cut, a cleanup, a re-time). Fails, keeping nothing, if the edits do not apply. Apply it with apply_video_edit_plan. Returns the plan.",
+    inputSchema: object(
+      {
+        title: { type: "string", minLength: 1, maxLength: 120, description: 'What the plan does, shown to the user and used as the undo label (e.g. "Tighten the intro").' },
+        description: { type: "string", maxLength: 2e3, description: "Why, and anything the reviewer should check." },
+        ops: { type: "array", items: EDIT_OP, minItems: 1, maxItems: 500, description: "The edits, in order, as for edit_video." },
+        ranges: { type: "array", maxItems: 500, items: object({ from: MS("Start, on the timeline"), to: MS("End, on the timeline"), text: { type: "string", description: "What is said there." }, reason: { type: "string", description: 'Why it is in the plan (e.g. "filler").' } }, ["from", "to"], "A stretch the plan cuts or changes."), description: "The stretches it cuts or changes, for the review view (optional)." }
+      },
+      ["title", "ops"]
+    ),
+    annotations: { title: "Propose edits for review", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: ({ title, description, ops, ranges }) => {
+      if (ops.some((o) => o.op === "replace_project")) throw new Error("A plan cannot replace the whole project; use the individual ops.");
+      const r = controller.proposePlan({ title, description, edits: ops, ranges, source: "agent" });
+      if (!r.ok) throw new Error(r.error);
+      return { plan: planOut(r.plan), hint: `Nothing changed yet. Ask the user to review it, then call apply_video_edit_plan with plan "${r.plan.id}" (or discard_video_edit_plan).` };
+    }
+  };
+  const listPlans = {
+    name: "list_video_edit_plans",
+    title: "List proposed edit plans",
+    description: "Lists the plans waiting for review, oldest first: id, title, summary (length change, clips added, removed and changed, new problems), the stretches they cut, and whether the project changed since each was made (stale: it is checked again when applied).",
+    inputSchema: object({}),
+    annotations: { title: "List proposed edit plans", ...READ },
+    handler: () => ({ plans: controller.getState().plans.map(planOut) })
+  };
+  const applyPlan = {
+    name: "apply_video_edit_plan",
+    title: "Apply an edit plan",
+    description: "Applies a proposed plan as one undo step (labelled with its title) and closes it. A plan made before the project changed is checked again first and refused, changing nothing, if its edits no longer apply. Returns what it did (each op's outcome), the new length and issues, and whether it was stale.",
+    inputSchema: object({ plan: PLAN_ID }, ["plan"]),
+    annotations: { title: "Apply an edit plan", ...DESTRUCTIVE },
+    handler: ({ plan }) => {
+      const r = controller.applyPlan(plan);
+      if (!r.ok) throw new Error(r.error);
+      return { plan: r.plan.id, title: r.plan.title, stale: r.stale, outcomes: r.outcomes, duration: videoProjectDuration(r.project), issues: issueSummary(r.issues) };
+    }
+  };
+  const discardPlan = {
+    name: "discard_video_edit_plan",
+    title: "Discard an edit plan",
+    description: "Closes a proposed plan without applying it; the project is unchanged. Returns the plans still open.",
+    inputSchema: object({ plan: PLAN_ID }, ["plan"]),
+    annotations: { title: "Discard an edit plan", readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    handler: ({ plan }) => {
+      if (!controller.discardPlan(plan)) throw new Error(`There is no open plan "${plan}"; the open plans are ${controller.getState().plans.map((p) => `"${p.id}"`).join(", ") || "none"}.`);
+      return { discarded: plan, open: controller.getState().plans.map((p) => p.id) };
+    }
+  };
+  const reads = [getProject, listPlans, listSequences, getFrame, getTranscript, findText, findFillers, findPauses, findGaps, checkProject, renderFrame, getScopes, previewCache, planProxies, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek, setPreviewScale];
+  const writes = [setSettings, addAsset, updateAsset, removeAsset, setProxies, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setSpeedRamp, addFreeze, removeRamp, setTranscript, removeRanges, applyGradePreset, copyGrade, setLut, removeLut, setSkin, addAdjustment, setMask, removeMask, planEdits, applyPlan, discardPlan, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return withVideoPlayback({
     id: options.id ?? "video",
     namespace: options.namespace,
@@ -4868,6 +5700,456 @@ function createVideoEffectsToolProvider(controller, options = {}) {
   }), options.playbackSurface);
 }
 
+// src/video-editor/dialogue-tools.ts
+var round2 = (ms) => Math.round(ms * 10) / 10;
+var object2 = (properties, required = []) => ({ type: "object", properties, ...required.length ? { required } : {}, additionalProperties: false });
+var FIND_FIELDS = {
+  track: { type: "string", minLength: 1, description: "Track whose words to read (default: the first audio track with a transcribed clip, else the first video track with one)." },
+  kinds: { type: "array", minItems: 1, uniqueItems: true, items: { type: "string", enum: [...VIDEO_DISFLUENCY_KINDS] }, description: 'What to look for: filler (um, uh, you know\u2026), pause (long gaps between words), repetition (stutters such as "I I think"). Default all three.' },
+  fillers: { type: "array", minItems: 1, items: { type: "string", minLength: 1 }, description: `Words or phrases counted as fillers instead of the defaults (${VIDEO_DEFAULT_FILLERS.join(", ")}).` },
+  min_pause: { type: "number", exclusiveMinimum: 0, description: "Shortest gap between words that counts as a pause, in ms (default 700; 600 for brisk talking heads)." },
+  keep: { type: "number", minimum: 0, maximum: 1e3, description: "Breath kept either side of a pause cut, in ms (default 150; 150\u2013250 sounds natural)." },
+  max_phrase: { type: "integer", minimum: 1, maximum: 6, description: "Longest phrase checked for a repeat, in words (default 3)." }
+};
+function createVideoDialogueToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (r) return typeof r === "string" ? r : "This video project is read-only.";
+    return controller.readOnlyReason();
+  };
+  const find = (args) => {
+    const project = controller.getProject();
+    const words = videoTimelineTranscript(project, { track: args.track });
+    if (!words.length) throw new Error(args.track ? `No clip on track "${args.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 detectVideoDisfluencies(words, {
+      kinds: args.kinds,
+      fillers: args.fillers,
+      pauses: { fps: project.fps, ...args.min_pause !== void 0 ? { min: args.min_pause } : {}, ...args.keep !== void 0 ? { keep: args.keep } : {} },
+      repetitions: args.max_phrase !== void 0 ? { maxPhrase: args.max_phrase } : void 0
+    });
+  };
+  const out = (d) => ({ kind: d.kind, from: round2(d.from), to: round2(d.to), text: d.text, words: d.words });
+  const findDisfluencies = {
+    name: "find_video_disfluencies",
+    title: "Find fillers, pauses and stutters",
+    description: `Reads the timeline transcript and lists, in time order, every filler word, long pause and repeated word or phrase as { kind, from, to, text, words } (timeline ms; "words" are the first and last word indexes in get_video_transcript's list), with a count and total per kind. Changes nothing. Review the list (some repeats and pauses are meant), then call plan_video_dialogue_cleanup or remove_video_ranges with the ones to cut.`,
+    inputSchema: object2(FIND_FIELDS),
+    annotations: { title: "Find fillers, pauses and stutters", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    handler: (args) => {
+      const found = find(args);
+      const totals = Object.fromEntries(VIDEO_DISFLUENCY_KINDS.map((k) => [k, { count: found.filter((d) => d.kind === k).length, time: round2(found.filter((d) => d.kind === k).reduce((n, d) => n + d.to - d.from, 0)) }]));
+      const merged = mergeVideoRanges(found);
+      return { disfluencies: found.map(out), totals, removable: round2(merged.reduce((n, r) => n + r.to - r.from, 0)) };
+    }
+  };
+  const planCleanup = {
+    name: "plan_video_dialogue_cleanup",
+    title: "Propose a dialogue cleanup",
+    description: 'Finds fillers, long pauses and stutters (as find_video_disfluencies) and proposes cutting them as one plan for review: nothing changes until apply_video_edit_plan. Pass "exclude" to keep finds the user wants (by their from time), and "margin" to keep a little breath around filler and stutter cuts. Every sync-locked track is cut with the dialogue. Returns the plan (id, title, length change, the stretches it cuts) for the user to review.',
+    inputSchema: object2(
+      {
+        ...FIND_FIELDS,
+        exclude: { type: "array", maxItems: 500, items: { type: "number", minimum: 0 }, description: 'The "from" times (ms) of finds to keep, from find_video_disfluencies.' },
+        margin: { type: "number", minimum: 0, maximum: 200, description: "Ms left uncut at each end of a filler or stutter cut, so the words around it are not clipped (default 0)." },
+        title: { type: "string", minLength: 1, maxLength: 120, description: `The plan's title (default: what it cleans up, e.g. "Clean up 12 fillers, 3 pauses").` }
+      }
+    ),
+    annotations: { title: "Propose a dialogue cleanup", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    handler: (args) => {
+      const skip = new Set((args.exclude ?? []).map((t) => Math.round(t)));
+      const found = find(args).filter((d) => !skip.has(Math.round(d.from)));
+      if (!found.length) throw new Error("Nothing to clean up: no fillers, long pauses or repetitions were found (or all were excluded).");
+      const margin = args.margin ?? 0;
+      const cuts = found.flatMap((d) => d.kind === "pause" || !margin ? [d] : videoCutsWithMargin([d], margin));
+      const counts = VIDEO_DISFLUENCY_KINDS.map((k) => [k, found.filter((d) => d.kind === k).length]).filter(([, n]) => n);
+      const title = args.title ?? `Clean up ${counts.map(([k, n]) => `${n} ${k}${n > 1 ? "s" : ""}`).join(", ")}`;
+      const r = controller.proposePlan({ title, description: "Cuts fillers, long pauses and stutters found in the transcript, closing up every sync-locked track.", edits: videoRemoveRangesEdits(cuts), ranges: cuts.map((d) => ({ from: d.from, to: d.to, text: d.text, reason: d.kind })), source: "plan_video_dialogue_cleanup" });
+      if (!r.ok) throw new Error(r.error);
+      const p = r.plan;
+      return { plan: { id: p.id, title: p.title, summary: p.summary, text: describeVideoEditPlan(p), cuts: cuts.length }, durationNow: videoProjectDuration(controller.getProject()), hint: `Nothing changed yet. Show the user the plan, then call apply_video_edit_plan with plan "${p.id}" (or discard_video_edit_plan).` };
+    }
+  };
+  return withVideoPlayback(
+    {
+      id: options.id ?? "video-dialogue",
+      namespace: options.namespace,
+      title: "Video dialogue cleanup",
+      description: "Talking-head cleanup by transcript: find fillers, long pauses and stutters, and propose cutting them as one plan for review.",
+      skill: "pixerate-talking-head-edit",
+      tools: () => readOnlyReason() ? [findDisfluencies] : [findDisfluencies, planCleanup],
+      subscribe: (notify) => {
+        let last = readOnlyReason();
+        return controller.subscribe(() => {
+          const now = readOnlyReason();
+          if (now !== last) {
+            last = now;
+            notify();
+          }
+        });
+      }
+    },
+    options.playbackSurface
+  );
+}
+
+// src/video-editor/music-tools.ts
+var round4 = (ms) => Math.round(ms * 10) / 10;
+var object3 = (properties, required = [], description) => ({ type: "object", ...description ? { description } : {}, properties, ...required.length ? { required } : {}, additionalProperties: false });
+var MS3 = (what) => ({ type: "number", minimum: 0, description: `${what}, in milliseconds.` });
+var CLIP_ID2 = { type: "string", minLength: 1, description: 'A clip id from get_video_project (e.g. "c1").' };
+var TRACK_ID2 = { type: "string", minLength: 1, description: 'A track id from get_video_project (e.g. "v1" or "a1").' };
+var SOUND_TARGET = {
+  clip: { ...CLIP_ID2, description: "A media clip with sound: read the stretch of source it plays, times on the timeline. Pass this or asset." },
+  asset: { type: "string", minLength: 1, description: "A video or audio asset: read its source, times in the source. Pass this or clip." },
+  from: MS3("Start of the stretch (default: the clip's start, or 0 for an asset)"),
+  to: MS3("End of the stretch (default: the clip's end, or the asset's duration)")
+};
+var SOUND = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: true };
+function createVideoMusicToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (r) return typeof r === "string" ? r : "This video project is read-only.";
+    return controller.readOnlyReason();
+  };
+  const project = () => controller.getProject();
+  const soundClip = (p, id) => {
+    const at = findVideoClip(p, id);
+    if (!at) throw new Error(`There is no clip "${id}"; get_video_project lists the clips.`);
+    const c = at.clip;
+    if (c.type !== "media") throw new Error(`Clip "${id}" is a ${c.type} clip and has no sound of its own; pass a video or audio clip.`);
+    const asset = p.assets.find((a) => a.id === c.asset);
+    if (!asset) throw new Error(`Clip "${id}" plays a missing asset "${c.asset}".`);
+    if (asset.kind === "image" || asset.hasAudio === false) throw new Error(`Clip "${id}" has no sound (asset "${asset.id}").`);
+    return { clip: c, asset, track: at.track.id };
+  };
+  const stretch = (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.');
+    if (args.clip !== void 0) {
+      const { clip, asset: asset2 } = soundClip(p, args.clip);
+      const speed = clip.speed ?? 1;
+      const from2 = Math.max(clip.start, args.from ?? clip.start);
+      const to2 = Math.min(videoClipEnd(clip), args.to ?? videoClipEnd(clip));
+      if (!(to2 > from2)) throw new Error(`The stretch is empty (${from2}\u2013${to2} ms); "from" and "to" must be inside the clip (${clip.start}\u2013${videoClipEnd(clip)} ms) with "to" after "from".`);
+      return { asset: asset2, from: (clip.in ?? 0) + (from2 - clip.start) * speed, to: (clip.in ?? 0) + (to2 - clip.start) * speed, out: (s) => clip.start + (s - (clip.in ?? 0)) / speed };
+    }
+    const 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"}.`);
+    if (asset.kind === "image" || asset.hasAudio === false) throw new Error(`Asset "${asset.id}" has no sound.`);
+    const from = args.from ?? 0;
+    const to = args.to ?? asset.duration ?? 0;
+    if (!(to > from)) throw new Error(`The stretch is empty (${from}\u2013${to} ms)${asset.duration === void 0 ? '; the asset has no duration, so pass "to"' : ""}.`);
+    return { asset, from, to, out: (s) => s };
+  };
+  const measureLoudness = {
+    name: "measure_video_loudness",
+    title: "Measure loudness",
+    description: "Measures how loud the source sound of a clip or an asset is, as streaming services and broadcasters do (ITU-R BS.1770, gated): integrated loudness in LUFS, the sample peak in dBFS, and the gain that would bring it to -14 LUFS (streaming) without the peak passing -1 dBFS. Before clip volume and fades. Changes nothing. The first call for an asset decodes its file. Use normalize_video_loudness to apply the gain.",
+    inputSchema: object3(SOUND_TARGET),
+    annotations: { title: "Measure loudness", ...SOUND },
+    handler: async (args) => {
+      const r = stretch(args);
+      const peaks = await controller.audioPeaks.load(r.asset);
+      const lufs2 = videoAudioLoudness(peaks, r.from, r.to);
+      const peakDb = Math.max(...videoAudioLevels(peaks, r.from, r.to, 50).map((l) => l.peakDb));
+      return { asset: r.asset.id, lufs: lufs2, peakDb, ...lufs2 === null ? { note: "The stretch is silent (everything is below the -70 LUFS gate)." } : { toStreaming: videoLoudnessGain(lufs2, -14, { peakDb }) } };
+    }
+  };
+  const normalizeLoudness = {
+    name: "normalize_video_loudness",
+    title: "Normalise loudness",
+    description: "Sets each clip's volume so its sound plays at a target loudness (default -14 LUFS, streaming; -16 podcasts, -23 EBU R128 broadcast), keeping its peak under the ceiling and the gain at most 4\xD7 (one undo step). Measures each clip's own stretch of source first; silent clips are skipped. Refuses clips with volume keyframes (a constant gain would replace them) unless replace is true. Returns each clip's measured loudness, the gain set (linear and dB) and whether a cap held it short of the target.",
+    inputSchema: object3(
+      {
+        clips: { type: "array", items: CLIP_ID2, minItems: 1, maxItems: 200, uniqueItems: true, description: "Media clips with sound." },
+        target: { type: "number", minimum: -40, maximum: -5, description: "Loudness to reach, in LUFS (default -14)." },
+        ceiling: { type: "number", minimum: -20, maximum: 0, description: "Highest sample peak allowed after the gain, in dBFS (default -1)." },
+        replace: { type: "boolean", description: "Replace volume keyframes with the constant gain (default false: refuse)." }
+      },
+      ["clips"]
+    ),
+    annotations: { title: "Normalise loudness", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    handler: async ({ clips, target, ceiling, replace }) => {
+      const p = project();
+      const targets = clips.map((id) => soundClip(p, id));
+      for (const t of targets) if (isVideoKeyframes(t.clip.volume) && !replace) throw new Error(`Clip "${t.clip.id}" has volume keyframes, which a constant gain would replace; pass replace: true, or remove them first.`);
+      const results = [];
+      const edits = [];
+      for (const { clip, asset } of targets) {
+        const peaks = await controller.audioPeaks.load(asset);
+        const speed = clip.speed ?? 1;
+        const from = clip.in ?? 0;
+        const to = from + clip.duration * speed;
+        const lufs2 = videoAudioLoudness(peaks, from, to);
+        if (lufs2 === null) {
+          results.push({ clip: clip.id, skipped: "silent" });
+          continue;
+        }
+        const peakDb = Math.max(...videoAudioLevels(peaks, from, to, 50).map((l) => l.peakDb));
+        const g = videoLoudnessGain(lufs2, target ?? -14, { peakDb, ceiling });
+        edits.push({ op: "update_clip", clip: clip.id, set: { volume: g.gain } });
+        results.push({ clip: clip.id, lufs: lufs2, gain: g.gain, gainDb: g.gainDb, ...g.limitedBy ? { limitedBy: g.limitedBy } : {} });
+      }
+      if (!edits.length) throw new Error("Every clip is silent, so there is nothing to normalise.");
+      const r = controller.apply(edits, "Normalise loudness");
+      if (!r.ok) throw new Error(r.error);
+      return { target: target ?? -14, clips: results };
+    }
+  };
+  const duckMusic = {
+    name: "duck_video_music",
+    title: "Duck music under speech",
+    description: `Dips music clips under speech with volume keyframes (one undo step): before each stretch of speech the level eases down by duck_db over "attack" ms, holds, and eases back over "release" ms after it; gaps shorter than merge_gap stay ducked. Speech comes from the transcript of the dialogue track ("transcript", the default when it has one) or from where its sound is above -40 dBFS ("audio", which decodes it). Refuses music clips that already have volume keyframes unless replace is true. Returns each music clip's keys and the speech stretches used.`,
+    inputSchema: object3(
+      {
+        music: { type: "array", items: CLIP_ID2, minItems: 1, maxItems: 100, uniqueItems: true, description: "The music clips to duck (media clips with sound)." },
+        dialogue_track: { ...TRACK_ID2, description: 'Track the speech is on (default: the transcript track for "transcript"; required for "audio").' },
+        speech: { type: "string", enum: ["transcript", "audio"], description: "Where speech is found: transcript words (default when transcribed) or the dialogue track's sound levels." },
+        duck_db: { type: "number", minimum: -40, maximum: -1, description: "How far to dip, in dB (default -14; -12 to -18 is usual)." },
+        attack: { type: "number", minimum: 0, maximum: 2e3, description: "Ms the dip takes to come in before speech (default 200)." },
+        release: { type: "number", minimum: 0, maximum: 4e3, description: "Ms the music takes to come back after speech (default 400)." },
+        merge_gap: { type: "number", minimum: 0, maximum: 1e4, description: "Speech gaps shorter than this stay ducked, in ms (default 600)." },
+        replace: { type: "boolean", description: "Replace existing volume keyframes (default false: refuse)." }
+      },
+      ["music"]
+    ),
+    annotations: { title: "Duck music under speech", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    handler: async (args) => {
+      const p = project();
+      const music = args.music.map((id) => soundClip(p, id));
+      for (const m of music) if (isVideoKeyframes(m.clip.volume) && !args.replace) throw new Error(`Music clip "${m.clip.id}" already has volume keyframes; pass replace: true to replace them, or remove them first.`);
+      const transcriptTrack = videoTranscriptTrack(p, args.dialogue_track);
+      const mode = args.speech ?? (transcriptTrack && videoTimelineTranscript(p, { track: transcriptTrack }).length ? "transcript" : "audio");
+      let ranges = [];
+      if (mode === "transcript") {
+        const words = videoTimelineTranscript(p, { track: args.dialogue_track });
+        if (!words.length) throw new Error(`No transcribed speech${args.dialogue_track ? ` on track "${args.dialogue_track}"` : ""}; attach a transcript with set_video_transcript, or pass speech: "audio" with dialogue_track.`);
+        ranges = videoSpeechRanges(words, 250);
+      } else {
+        if (!args.dialogue_track) throw new Error('speech "audio" needs dialogue_track: the track whose sound is the speech.');
+        const track = p.tracks.find((t) => t.id === args.dialogue_track);
+        if (!track) throw new Error(`There is no track "${args.dialogue_track}".`);
+        const musicIds = new Set(music.map((m) => m.clip.id));
+        for (const c of sortedVideoClips(track)) {
+          if (c.type !== "media" || musicIds.has(c.id)) continue;
+          const asset = p.assets.find((a) => a.id === c.asset);
+          if (!asset || asset.kind === "image" || asset.hasAudio === false) continue;
+          const peaks = await controller.audioPeaks.load(asset);
+          const speed = c.speed ?? 1;
+          const src0 = c.in ?? 0;
+          const silences = findVideoAudioSilences(peaks, src0, src0 + c.duration * speed, { thresholdDb: -40, minDuration: 250 });
+          let at = c.start;
+          for (const s of silences) {
+            const a = c.start + (s.start - src0) / speed;
+            if (a - at > VIDEO_TIME_EPSILON) ranges.push({ from: at, to: a });
+            at = c.start + (s.end - src0) / speed;
+          }
+          if (videoClipEnd(c) - at > VIDEO_TIME_EPSILON) ranges.push({ from: at, to: videoClipEnd(c) });
+        }
+        if (!ranges.length) throw new Error(`Track "${args.dialogue_track}" has no sound above -40 dBFS, so there is no speech to duck under.`);
+      }
+      const edits = [];
+      const out = [];
+      for (const { clip } of music) {
+        const base = typeof clip.volume === "number" ? clip.volume : 1;
+        const keys = videoDuckingKeys(clip, ranges, { duckDb: args.duck_db, attack: args.attack, release: args.release, mergeGap: args.merge_gap, base });
+        out.push({ clip: clip.id, keys: keys.length, ...keys.length ? { keyframes: keys } : { note: "No speech overlaps it." } });
+        if (keys.length) edits.push({ op: "set_keyframes", clip: clip.id, property: "volume", keys });
+      }
+      if (!edits.length) throw new Error("No speech overlaps the music clips, so there is nothing to duck.");
+      const r = controller.apply(edits, "Duck music");
+      if (!r.ok) throw new Error(r.error);
+      return { speech: mode, speechRanges: ranges.map((x) => ({ from: round4(x.from), to: round4(x.to) })), music: out };
+    }
+  };
+  const BEAT_FIELDS = {
+    sensitivity: { type: "number", minimum: 0.5, maximum: 4, description: "How far above the local average a hit must rise, in standard deviations (default 1.5; lower finds more)." },
+    min_bpm: { type: "number", minimum: 30, maximum: 300, description: "Slowest tempo to consider (default 60)." },
+    max_bpm: { type: "number", minimum: 30, maximum: 300, description: "Fastest tempo to consider (default 200)." }
+  };
+  const beatsOf = async (args) => {
+    const r = stretch(args);
+    const peaks = await controller.audioPeaks.load(r.asset);
+    const found = findVideoAudioBeats(peaks, r.from, r.to, { sensitivity: args.sensitivity, minBpm: args.min_bpm, maxBpm: args.max_bpm });
+    return { asset: r.asset.id, bpm: found.bpm, beats: found.beats.map((t) => round4(r.out(t))), onsets: found.onsets.map((t) => round4(r.out(t))) };
+  };
+  const findBeats = {
+    name: "find_video_beats",
+    title: "Find the beats",
+    description: "Finds the beat of a music clip or asset: the tempo (BPM, or null when the hits do not repeat), a steady beat grid at that tempo, and the onsets (each hit) \u2014 timeline ms for a clip, source ms for an asset. Changes nothing. Use the beats to cut on the music (plan_video_beat_snap), place markers (add_video_marker) or time titles. Works best on percussive music. The first call for an asset decodes its file.",
+    inputSchema: object3({ ...SOUND_TARGET, ...BEAT_FIELDS }),
+    annotations: { title: "Find the beats", ...SOUND },
+    handler: (args) => beatsOf(args)
+  };
+  const planBeatSnap = {
+    name: "plan_video_beat_snap",
+    title: "Propose cuts on the beat",
+    description: 'Proposes, as a plan for review, moving each cut on a track to the nearest beat within "tolerance" ms with roll edits (the outgoing clip gets longer as the incoming one gets shorter, so nothing else moves). Beats come from a music clip (found as find_video_beats does) or are given. Cuts already on a beat, with none in reach, or without enough media to roll are left (listed in "skipped"). Nothing changes until apply_video_edit_plan. Returns the plan and what was skipped.',
+    inputSchema: object3(
+      {
+        track: { ...TRACK_ID2, description: "The track whose cuts to move (default the first video track)." },
+        music: { ...CLIP_ID2, description: "A music clip to take the beats from. Pass this or beats." },
+        beats: { type: "array", minItems: 1, maxItems: 5e3, items: { type: "number", minimum: 0 }, description: "Beat times on the timeline, in ms. Pass this or music." },
+        tolerance: { type: "number", exclusiveMinimum: 0, maximum: 2e3, description: "Furthest a cut may move, in ms (default 150)." },
+        ...BEAT_FIELDS
+      }
+    ),
+    annotations: { title: "Propose cuts on the beat", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    handler: async (args) => {
+      const p = project();
+      if (args.music === void 0 === (args.beats === void 0)) throw new Error('Pass either "music" (a music clip to find the beats in) or "beats" (times in ms), not both.');
+      const track = args.track !== void 0 ? p.tracks.find((t) => t.id === args.track) : p.tracks.find((t) => t.kind === "video");
+      if (!track) throw new Error(args.track !== void 0 ? `There is no track "${args.track}".` : "The project has no video track.");
+      let beats;
+      if (args.music !== void 0) {
+        const found = await beatsOf({ clip: args.music, sensitivity: args.sensitivity, min_bpm: args.min_bpm, max_bpm: args.max_bpm });
+        beats = found.beats.length ? found.beats : found.onsets;
+        if (!beats.length) throw new Error(`No beats were found in "${args.music}"; try a lower sensitivity, or pass beats.`);
+      } else beats = [...args.beats].sort((a, b) => a - b);
+      const tolerance = args.tolerance ?? 150;
+      const clips = sortedVideoClips(track);
+      const edits = [];
+      const ranges = [];
+      const skipped = [];
+      let working = p;
+      for (let i = 0; i + 1 < clips.length; i++) {
+        const left = clips[i];
+        const right = clips[i + 1];
+        const cut = videoClipEnd(left);
+        if (Math.abs(right.start - cut) > VIDEO_TIME_EPSILON) continue;
+        const beat = nearestVideoBeat(beats, cut, tolerance);
+        if (beat === null) {
+          skipped.push({ cut: round4(cut), reason: `no beat within ${tolerance} ms` });
+          continue;
+        }
+        const delta = Math.round((beat - cut) * 10) / 10;
+        if (Math.abs(delta) < 1) {
+          skipped.push({ cut: round4(cut), reason: "already on the beat" });
+          continue;
+        }
+        const edit = { op: "roll_edit", left: left.id, right: right.id, delta };
+        const tried = applyVideoEdits(working, edit);
+        if (!tried.ok) {
+          skipped.push({ cut: round4(cut), reason: tried.error });
+          continue;
+        }
+        working = tried.project;
+        edits.push(edit);
+        ranges.push({ from: Math.min(cut, beat), to: Math.max(cut, beat), reason: "beat" });
+      }
+      if (!edits.length) throw new Error(`No cut on track "${track.id}" can move to a beat${skipped.length ? `: ${skipped.slice(0, 5).map((s) => `${s.cut} ms (${s.reason})`).join("; ")}` : " (it has no cuts between touching clips)"}.`);
+      const r = controller.proposePlan({ title: `Snap ${edits.length} cut${edits.length > 1 ? "s" : ""} to the beat`, description: `Rolls cuts on track "${track.id}" to the nearest beat within ${tolerance} ms.`, edits, ranges, source: "plan_video_beat_snap" });
+      if (!r.ok) throw new Error(r.error);
+      return { plan: { id: r.plan.id, title: r.plan.title, summary: r.plan.summary, text: describeVideoEditPlan(r.plan) }, moved: edits.length, skipped, hint: `Nothing changed yet. Call apply_video_edit_plan with plan "${r.plan.id}" once the user agrees.` };
+    }
+  };
+  const reads = [measureLoudness, findBeats];
+  const writes = [normalizeLoudness, duckMusic, planBeatSnap];
+  return withVideoPlayback(
+    {
+      id: options.id ?? "video-music",
+      namespace: options.namespace,
+      title: "Video music and mix",
+      description: "Music and the mix: beats and cuts on the beat, ducking music under speech, and loudness in LUFS.",
+      skill: "pixerate-bgm-alignment",
+      tools: () => readOnlyReason() ? reads : [...reads, ...writes],
+      subscribe: (notify) => {
+        let last = readOnlyReason();
+        return controller.subscribe(() => {
+          const now = readOnlyReason();
+          if (now !== last) {
+            last = now;
+            notify();
+          }
+        });
+      }
+    },
+    options.playbackSurface
+  );
+}
+
+// src/video-editor/effect-authoring.ts
+function videoEaseToAnimationEasing(ease) {
+  if (ease === void 0 || ease === "linear") return "linear";
+  if (Array.isArray(ease)) return { type: "cubic-bezier", x1: ease[0], y1: ease[1], x2: ease[2], y2: ease[3] };
+  return ease;
+}
+function animationEasingToVideoEase(easing) {
+  if (easing === void 0 || easing === "linear") return "linear";
+  if (easing === "hold" || easing === "ease-in" || easing === "ease-out" || easing === "ease-in-out") return easing;
+  if (typeof easing === "string") {
+    const p = CUBIC_BEZIER_PRESETS[easing];
+    return p ? [p[0], p[1], p[2], p[3]] : null;
+  }
+  if (easing.type === "cubic-bezier") return [easing.x1, easing.y1, easing.x2, easing.y2];
+  return null;
+}
+var SAMPLES = 12;
+function videoClipEffectDocument(clip, instance, providerId) {
+  const effect = (clip.effects ?? []).find((e) => e.id === instance);
+  if (!effect) throw new Error(`Clip "${clip.id}" has no effect "${instance}"; its effects are ${(clip.effects ?? []).map((e) => `"${e.id}" (${e.name ?? e.effect})`).join(", ") || "none"}.`);
+  const values = {};
+  const tracks = {};
+  for (const [control, v] of Object.entries(effect.values ?? {})) {
+    if (isVideoKeyframes(v)) {
+      values[control] = v.keys[0].v;
+      tracks[control] = v.keys.map((k) => ({ time: k.t, value: k.v, ...k.ease && k.ease !== "linear" ? { easing: videoEaseToAnimationEasing(k.ease) } : {} }));
+    } else values[control] = v;
+  }
+  return { version: 1, providerId, effectId: effect.effect, name: effect.name ?? effect.effect, values, tracks, presets: [], duration: clip.duration, loop: false };
+}
+function videoEffectValuesFromDocument(doc) {
+  const values = { ...doc.values };
+  const notes = [];
+  for (const [control, track] of Object.entries(doc.tracks ?? {})) {
+    const kfs = [...track].sort((a, b) => a.time - b.time);
+    if (!kfs.length) continue;
+    if (!kfs.every((k) => typeof k.value === "number")) {
+      values[control] = kfs[0].value;
+      notes.push(`"${control}" is keyframed with non-numeric values, which clip effects cannot animate; it keeps its first value.`);
+      continue;
+    }
+    const keys = [];
+    let sampled = false;
+    kfs.forEach((k, i) => {
+      const next = kfs[i + 1];
+      const ease = animationEasingToVideoEase(k.easing);
+      if (!next || ease) {
+        keys.push({ t: k.time, v: k.value, ...next && ease && ease !== "linear" ? { ease } : {} });
+        return;
+      }
+      sampled = true;
+      const a = k.value;
+      const b = next.value;
+      const span = next.time - k.time;
+      for (let s = 0; s < SAMPLES; s++) keys.push({ t: Math.round((k.time + span * s / SAMPLES) * 1e3) / 1e3, v: a + (b - a) * evaluateEasing(k.easing, s / SAMPLES, span) });
+    });
+    values[control] = { keys: keys.filter((k, i) => i === 0 || k.t > keys[i - 1].t) };
+    if (sampled) notes.push(`"${control}" uses a spring or elastic easing, sampled into ${SAMPLES} linear steps per segment.`);
+  }
+  return { values, notes };
+}
+async function openVideoClipEffectAuthoring(controller, clip, instance, options = {}) {
+  const provider = controller.effectsProvider;
+  if (!provider) throw new Error("No effects provider is registered, so the effect cannot be opened for authoring; register one with setEffectsProvider.");
+  const at = findVideoClip(controller.getProject(), clip);
+  if (!at) throw new Error(`There is no clip "${clip}".`);
+  const doc = videoClipEffectDocument(at.clip, instance, provider.id);
+  const session = await createEffectAuthoringSession({ document: doc }, { ...options, provider });
+  return {
+    clip,
+    instance,
+    session,
+    async commit() {
+      const { values, notes } = videoEffectValuesFromDocument(session.exportDocument());
+      const result = await controller.updateClipEffect(clip, instance, { values });
+      return result.ok && notes.length ? { ...result, notes } : result;
+    },
+    dispose: () => session.dispose()
+  };
+}
+var videoAuthorableEffects = (clip) => clip.effects ?? [];
+
 // src/video-editor/editorDocument.ts
 function createVideoEditorDocument(controller) {
   return defineEditorDocument({
@@ -4894,6 +6176,9 @@ function createVideoEditorDocument(controller) {
   });
 }
 export {
+  TranscriptVideoController,
+  VIDEO_ADJUSTMENT_SCOPES,
+  VIDEO_ADJUSTMENT_SCOPE_LABELS,
   VIDEO_BLEND_MODES,
   VIDEO_BLEND_MODE_LABELS,
   VIDEO_CLIP_ANIMATION_DURATION,
@@ -4903,6 +6188,7 @@ export {
   VIDEO_DEFAULT_FILLERS,
   VIDEO_DEFAULT_STILL_DURATION,
   VIDEO_DEFAULT_TITLE_DURATION,
+  VIDEO_DISFLUENCY_KINDS,
   VIDEO_EASE_NAMES,
   VIDEO_EDIT_OPS,
   VIDEO_EFFECT_PLACES,
@@ -4915,7 +6201,11 @@ export {
   VIDEO_ISSUE_CODES,
   VIDEO_KEYFRAME_LIMITS,
   VIDEO_KEYFRAME_PROPERTIES,
+  VIDEO_LOUDNESS_HOP,
   VIDEO_LUT_MAX_SIZE,
+  VIDEO_MASK_DEFAULTS,
+  VIDEO_MASK_SHAPES,
+  VIDEO_MASK_SHAPE_LABELS,
   VIDEO_PEAK_BLOCK,
   VIDEO_PLACEMENT_MODES,
   VIDEO_PREVIEW_SCALE_OPTIONS,
@@ -4936,6 +6226,7 @@ export {
   VideoPreviewPixels,
   allVideoClipIds,
   allVideoTracks,
+  animationEasingToVideoEase,
   applyVideoEdits,
   applyVideoGrade,
   applyVideoLut,
@@ -4945,20 +6236,27 @@ export {
   checkVideoEffectValues,
   checkVideoProject,
   checkVideoTimeRemap,
+  createVideoDialogueToolProvider,
   createVideoEditorDocument,
   createVideoEditorToolProvider,
   createVideoEffectsToolProvider,
   createVideoElementDecoder,
+  createVideoMusicToolProvider,
   createVideoProject,
   decodeVideoAudioPeaks,
+  describeVideoEditPlan,
   describeVideoProject,
   describeVideoSequence,
+  detectVideoDisfluencies,
+  diffVideoProjects,
   drawVideoFrame,
   ffmpegFilterValue,
+  findVideoAudioBeats,
   findVideoAudioSilences,
   findVideoClip,
   findVideoFillers,
   findVideoGaps,
+  findVideoRepetitions,
   findVideoSequenceClip,
   findVideoSequenceCycle,
   findVideoTranscriptPauses,
@@ -4968,12 +6266,16 @@ export {
   formatVideoTimecodeFrames,
   isVideoDropFrameRate,
   isVideoKeyframes,
+  measureVideoLoudness,
   mergeVideoRanges,
   mixEffectPixels,
+  nearestVideoBeat,
   nextFreeVideoSlot,
+  normalizeVideoClipMask,
   normalizeVideoGrade,
   normalizeVideoGradeLut,
   normalizeVideoWord,
+  openVideoClipEffectAuthoring,
   overEffectPixels,
   parseVideoAnimatable,
   parseVideoAsset,
@@ -4981,6 +6283,7 @@ export {
   parseVideoClip,
   parseVideoClipAnimation,
   parseVideoClipEffects,
+  parseVideoClipMask,
   parseVideoCubeLut,
   parseVideoEffectRef,
   parseVideoEffectValues,
@@ -5001,6 +6304,7 @@ export {
   parseVideoTransition,
   placeVideoRect,
   planVideoClipDrag,
+  planVideoEdits,
   planVideoPrefetch,
   planVideoToolPlayback,
   probeVideoMedia,
@@ -5019,15 +6323,18 @@ export {
   toVideoEdl,
   toVideoFfmpeg,
   toVideoLoudnessMeasure,
+  videoAddAdjustmentEdits,
   videoAssetDropEdit,
   videoAssetHasSound,
   videoAssetKindOf,
   videoAssetMap,
   videoAssetProxy,
   videoAudioLevels,
+  videoAudioLoudness,
   videoAudioPeakRange,
   videoAudioPeakSpans,
   videoAudioPeaksDuration,
+  videoAuthorableEffects,
   videoCacheEvictions,
   videoChroma,
   videoClipAfter,
@@ -5036,9 +6343,11 @@ export {
   videoClipAnimationSpans,
   videoClipAppliedEffects,
   videoClipBefore,
+  videoClipEffectDocument,
   videoClipEffectUses,
   videoClipEnd,
   videoClipHandles,
+  videoClipHeading,
   videoClipKeyframes,
   videoClipLabel,
   videoClipOverhang,
@@ -5049,21 +6358,27 @@ export {
   videoClipSpeed,
   videoClipSpeedAt,
   videoClipTint,
+  videoClipTypeLabel,
   videoClipWaveform,
   videoClipWaveformPath,
   videoClipsAt,
   videoContactSheetSvg,
+  videoCutsWithMargin,
   videoDragLabel,
   videoDropTracks,
+  videoDuckingKeys,
   videoEaseBezier,
   videoEaseProgress,
+  videoEaseToAnimationEasing,
   videoEffectFrameTime,
   videoEffectLayerKey,
   videoEffectValuesAt,
+  videoEffectValuesFromDocument,
   videoExposureNotes,
   videoExposureStats,
   videoFadeCurveGain,
   videoFfmpegUnsupportedEffects,
+  videoFfmpegUnsupportedFeatures,
   videoFrameAt,
   videoFrameCacheKey,
   videoFrameDuration,
@@ -5093,8 +6408,12 @@ export {
   videoKeyframeToggleEdit,
   videoKeyframeValueEdit,
   videoKeysOf,
+  videoLayerMask,
   videoLayersUseEffects,
   videoLayersWithoutTransitionEffects,
+  videoLoudnessEnergy,
+  videoLoudnessGain,
+  videoLoudnessOf,
   videoLuma,
   videoLumaWaveform,
   videoLutEdits,
@@ -5102,6 +6421,10 @@ export {
   videoLutSvgApproximation,
   videoLutSvgPrimitives,
   videoLutToCube,
+  videoMaskContains,
+  videoMaskEdit,
+  videoMaskPolygon,
+  videoMaskSvgPath,
   videoOverlap,
   videoPeakDb,
   videoPreviewSrc,
@@ -5119,10 +6442,13 @@ export {
   videoSequenceDuration,
   videoSequenceMap,
   videoShellQuote,
+  videoSkinProtectionEdits,
+  videoSkinToneWeight,
   videoSlowMotionRamp,
   videoSnapPoints,
   videoSourceFrame,
   videoSourceFrameTime,
+  videoSpeechRanges,
   videoSpeedRampEdit,
   videoSpeedRampKeys,
   videoTextStyle,