@pixerate/editor 0.78.0 → 0.80.0

package/dist/video-editor/index.js

@@ -15,8 +15,197 @@ import "../chunk-AGR4P4UZ.js";
 var VIDEO_FITS = ["contain", "cover", "fill", "none"];
 var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe"];
 var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
+var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
 var VIDEO_CLIP_TYPES = ["media", "text", "color"];
 
+// src/video-editor/keyframes.ts
+var VIDEO_EASE_NAMES = ["linear", "hold", "ease-in", "ease-out", "ease-in-out"];
+var VIDEO_KEYFRAME_PROPERTIES = ["opacity", "volume", "x", "y", "scale", "rotation"];
+var VIDEO_TRANSFORM_PROPERTIES = ["x", "y", "scale", "rotation"];
+var VIDEO_KEYFRAME_LIMITS = {
+  opacity: { default: 1, min: 0, max: 1 },
+  volume: { default: 1, min: 0, max: 4 },
+  x: { default: 0 },
+  y: { default: 0 },
+  scale: { default: 1, min: 0 },
+  rotation: { default: 0 }
+};
+var NAMED = {
+  "ease-in": [0.42, 0, 1, 1],
+  "ease-out": [0, 0, 0.58, 1],
+  "ease-in-out": [0.42, 0, 0.58, 1]
+};
+var isVideoKeyframes = (v) => typeof v === "object" && v !== null && Array.isArray(v.keys);
+function videoEaseBezier(ease) {
+  if (ease === void 0 || ease === "linear" || ease === "hold") return null;
+  return Array.isArray(ease) ? ease : NAMED[ease];
+}
+var bez = (a, b, s) => 3 * a * (1 - s) * (1 - s) * s + 3 * b * (1 - s) * s * s + s * s * s;
+var bezSlope = (a, b, s) => 3 * a * (1 - s) * (1 - s) + 6 * (b - a) * (1 - s) * s + 3 * (1 - b) * s * s;
+function bezierParam(x1, x2, x) {
+  let s = x;
+  for (let i = 0; i < 8; i++) {
+    const err = bez(x1, x2, s) - x;
+    if (Math.abs(err) < 1e-7) return s;
+    const d = bezSlope(x1, x2, s);
+    if (Math.abs(d) < 1e-6) break;
+    s -= err / d;
+    if (s < 0 || s > 1) break;
+  }
+  let lo = 0;
+  let hi = 1;
+  s = x;
+  for (let i = 0; i < 60; i++) {
+    const v = bez(x1, x2, s);
+    if (Math.abs(v - x) < 1e-9) break;
+    if (v < x) lo = s;
+    else hi = s;
+    s = (lo + hi) / 2;
+  }
+  return s;
+}
+function videoEaseProgress(ease, p) {
+  if (p <= 0) return 0;
+  if (p >= 1) return ease === "hold" ? 0 : 1;
+  if (ease === "hold") return 0;
+  const b = videoEaseBezier(ease);
+  if (!b) return p;
+  return bez(b[1], b[3], bezierParam(b[0], b[2], p));
+}
+function keyBefore(keys, t) {
+  let lo = 0;
+  let hi = keys.length - 1;
+  if (t < keys[0].t) return -1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    if (keys[mid].t <= t) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+function videoValueAt(prop, clipTime, fallback = 0) {
+  if (prop === void 0) return fallback;
+  if (typeof prop === "number") return prop;
+  const { keys } = prop;
+  if (!keys.length) return fallback;
+  const i = keyBefore(keys, clipTime);
+  if (i < 0) return keys[0].v;
+  if (i >= keys.length - 1) return keys[keys.length - 1].v;
+  const a = keys[i];
+  const b = keys[i + 1];
+  if (a.ease === "hold") return a.v;
+  return a.v + (b.v - a.v) * videoEaseProgress(a.ease, (clipTime - a.t) / (b.t - a.t));
+}
+var videoKeysOf = (prop) => isVideoKeyframes(prop) ? prop.keys : [];
+function retimeVideoAnimatable(prop, dt, k = 1) {
+  if (!isVideoKeyframes(prop)) return prop;
+  return { keys: prop.keys.map((key) => ({ ...key, t: key.t * k + dt })) };
+}
+function splitEase(ease, p) {
+  if (ease === "hold") return ["hold", "hold"];
+  const b = videoEaseBezier(ease);
+  if (!b) return [ease, ease];
+  const s = bezierParam(b[0], b[2], p);
+  const lerp = (u, v, k) => [u[0] + (v[0] - u[0]) * k, u[1] + (v[1] - u[1]) * k];
+  const P0 = [0, 0];
+  const P1 = [b[0], b[1]];
+  const P2 = [b[2], b[3]];
+  const P3 = [1, 1];
+  const A = lerp(P0, P1, s);
+  const B = lerp(P1, P2, s);
+  const C = lerp(P2, P3, s);
+  const AB = lerp(A, B, s);
+  const BC = lerp(B, C, s);
+  const M = lerp(AB, BC, s);
+  const r = (v) => Math.round(v * 1e6) / 1e6;
+  const left = Math.abs(M[1]) < 1e-9 ? "linear" : [r(A[0] / M[0]), r(A[1] / M[1]), r(AB[0] / M[0]), r(AB[1] / M[1])];
+  const dx = 1 - M[0];
+  const dy = 1 - M[1];
+  const right = Math.abs(dy) < 1e-9 ? "linear" : [r((BC[0] - M[0]) / dx), r((BC[1] - M[1]) / dy), r((C[0] - M[0]) / dx), r((C[1] - M[1]) / dy)];
+  return [left, right];
+}
+function splitVideoAnimatable(prop, at) {
+  if (!isVideoKeyframes(prop)) return [prop, prop];
+  const keys = prop.keys;
+  const eps = 1e-6;
+  const v = videoValueAt(prop, at);
+  const i = keyBefore(keys, at);
+  const exact = i >= 0 && Math.abs(keys[i].t - at) < eps;
+  let leftEase;
+  let rightEase;
+  if (exact) rightEase = keys[i].ease;
+  else if (i >= 0 && i < keys.length - 1) {
+    const a = keys[i];
+    [leftEase, rightEase] = splitEase(a.ease, (at - a.t) / (keys[i + 1].t - a.t));
+  }
+  const before = keys.slice(0, exact ? i : i + 1).map((k) => ({ ...k }));
+  if (before.length && leftEase !== void 0) before[before.length - 1] = withEase(before[before.length - 1], leftEase);
+  const left = [...before, { t: at, v }];
+  const right = [withEase({ t: 0, v }, rightEase), ...keys.slice(i + 1).map((k) => ({ ...k, t: k.t - at }))];
+  return [{ keys: left }, { keys: right }];
+}
+var withEase = (key, ease) => {
+  const { ease: _old, ...rest } = key;
+  return ease === void 0 || ease === "linear" ? rest : { ...rest, ease };
+};
+function sortVideoKeys(keys) {
+  const sorted = [...keys].sort((a, b) => a.t - b.t);
+  for (let i = 1; i < sorted.length; i++) if (Math.abs(sorted[i].t - sorted[i - 1].t) < 1e-6) throw new Error(`Two keys are at ${sorted[i].t} ms; give each key its own time.`);
+  return sorted;
+}
+function setVideoKey(prop, key, fallback) {
+  const keys = isVideoKeyframes(prop) ? prop.keys.filter((k) => Math.abs(k.t - key.t) >= 1e-6) : [];
+  if (!isVideoKeyframes(prop)) {
+    const v = prop ?? fallback;
+    if (key.t !== 0) keys.push({ t: 0, v });
+  }
+  return { keys: sortVideoKeys([...keys, key]) };
+}
+function removeVideoKey(prop, t) {
+  const keys = prop.keys.filter((k) => Math.abs(k.t - t) >= 1e-6);
+  return keys.length ? { keys } : prop.keys[0].v;
+}
+var fmt = (v) => {
+  const r = Math.round(v * 1e4) / 1e4;
+  return Object.is(r, -0) ? "0" : String(r);
+};
+var signed = (v) => fmt(v).startsWith("-") ? fmt(v) : `+${fmt(v)}`;
+function videoKeyframeBreakpoints(prop, step) {
+  const { keys } = prop;
+  const points = [];
+  const holds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < keys.length; i++) {
+    const a = keys[i];
+    points.push([a.t, a.v]);
+    const b = keys[i + 1];
+    if (!b) break;
+    if (a.ease === "hold") {
+      holds.add(points.length - 1);
+      continue;
+    }
+    if (!videoEaseBezier(a.ease)) continue;
+    const n2 = Math.max(1, Math.ceil((b.t - a.t) / step));
+    for (let k = 1; k < n2; k++) {
+      const t = a.t + (b.t - a.t) * k / n2;
+      points.push([t, videoValueAt(prop, t)]);
+    }
+  }
+  return { points, holds };
+}
+function videoKeyframeFfmpegExpr(prop, time, fallback, step) {
+  if (!isVideoKeyframes(prop)) return fmt(prop ?? fallback);
+  const { points, holds } = videoKeyframeBreakpoints(prop, step);
+  if (points.length === 1 || points.every(([, v]) => v === points[0][1])) return fmt(points[0][1]);
+  let expr = fmt(points[points.length - 1][1]);
+  for (let i = points.length - 2; i >= 0; i--) {
+    const [t0, v0] = points[i];
+    const [t1, v1] = points[i + 1];
+    const seg = holds.has(i) || v0 === v1 ? fmt(v0) : `${fmt(v0)}${signed((v1 - v0) / (t1 - t0))}*(${time}${signed(-t0)})`;
+    expr = `if(lt(${time},${fmt(t1)}),${seg},${expr})`;
+  }
+  return `if(lt(${time},${fmt(points[0][0])}),${fmt(points[0][1])},${expr})`;
+}
+
 // src/video-editor/parse.ts
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var fail = (path, what) => {
@@ -46,11 +235,44 @@ var oneOf = (v, options, path, optional = true) => {
   return v;
 };
 var compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+function parseVideoEase(v, path) {
+  if (v === void 0) return void 0;
+  if (Array.isArray(v)) {
+    if (v.length !== 4 || !v.every((n2) => typeof n2 === "number" && Number.isFinite(n2))) fail(path, "must be four numbers [x1, y1, x2, y2] (CSS cubic-bezier)");
+    if (v[0] < 0 || v[0] > 1 || v[2] < 0 || v[2] > 1) fail(path, "must have x1 and x2 between 0 and 1");
+    return [v[0], v[1], v[2], v[3]];
+  }
+  return oneOf(v, VIDEO_EASE_NAMES, path);
+}
+function parseVideoKeyframes(v, path, { min, max } = {}) {
+  if (!isObject(v)) return fail(path, "must be a number or keyframes { keys: [{ t, v, ease }] }");
+  for (const key of Object.keys(v)) if (key !== "keys") fail(`${path}.${key}`, "is not a keyframes field (keys)");
+  if (!Array.isArray(v.keys) || !v.keys.length) fail(`${path}.keys`, "must be an array of at least one key { t, v, ease }");
+  const keys = v.keys.map((k, i) => {
+    const at = `${path}.keys[${i}]`;
+    if (!isObject(k)) return fail(at, "must be an object { t, v, ease }");
+    for (const key of Object.keys(k)) if (!["t", "v", "ease"].includes(key)) fail(`${at}.${key}`, "is not a key field (t, v, ease)");
+    return compact({ t: num(k.t, `${at}.t`), v: num(k.v, `${at}.v`, { min, max }), ease: parseVideoEase(k.ease, `${at}.ease`) });
+  });
+  for (let i = 1; i < keys.length; i++) if (!(keys[i].t > keys[i - 1].t)) fail(`${path}.keys[${i}].t`, `must be later than the key before (${keys[i - 1].t} ms); keys go in time order, one per time`);
+  return { keys };
+}
+function parseVideoAnimatable(v, path, range = {}) {
+  if (v === void 0 && range.optional) return void 0;
+  const { min, max } = range;
+  if (isObject(v)) return parseVideoKeyframes(v, path, { min, max });
+  return num(v, path, { min, max });
+}
 function parseVideoTransform(v, path) {
   if (v === void 0) return void 0;
   if (!isObject(v)) return fail(path, "must be an object { x, y, scale, rotation }");
   for (const key of Object.keys(v)) if (!["x", "y", "scale", "rotation"].includes(key)) fail(`${path}.${key}`, "is not a transform field (x, y, scale, rotation)");
-  return compact({ x: num(v.x, `${path}.x`, { optional: true }), y: num(v.y, `${path}.y`, { optional: true }), scale: num(v.scale, `${path}.scale`, { optional: true, min: 0 }), rotation: num(v.rotation, `${path}.rotation`, { optional: true }) });
+  return compact({
+    x: parseVideoAnimatable(v.x, `${path}.x`, { optional: true }),
+    y: parseVideoAnimatable(v.y, `${path}.y`, { optional: true }),
+    scale: parseVideoAnimatable(v.scale, `${path}.scale`, { optional: true, min: 0 }),
+    rotation: parseVideoAnimatable(v.rotation, `${path}.rotation`, { optional: true })
+  });
 }
 function parseVideoTransition(v, path) {
   if (v === void 0) return void 0;
@@ -87,7 +309,7 @@ function parseVideoClip(v, path = "clip") {
     name: str(v.name, `${path}.name`, true),
     start: num(v.start, `${path}.start`, { min: 0 }),
     duration: num(v.duration, `${path}.duration`, { positive: true }),
-    opacity: num(v.opacity, `${path}.opacity`, { optional: true, min: 0, max: 1 }),
+    opacity: parseVideoAnimatable(v.opacity, `${path}.opacity`, { optional: true, min: 0, max: 1 }),
     transform: parseVideoTransform(v.transform, `${path}.transform`),
     fit: oneOf(v.fit, VIDEO_FITS, `${path}.fit`),
     fadeIn: num(v.fadeIn, `${path}.fadeIn`, { optional: true, min: 0 }),
@@ -101,7 +323,7 @@ function parseVideoClip(v, path = "clip") {
       asset: str(v.asset, `${path}.asset`),
       in: num(v.in, `${path}.in`, { optional: true, min: 0 }),
       speed: num(v.speed, `${path}.speed`, { optional: true, min: 0.05, max: 20 }),
-      volume: num(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
+      volume: parseVideoAnimatable(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
       muted: bool(v.muted, `${path}.muted`)
     });
   if (type === "text")
@@ -127,6 +349,7 @@ function parseVideoTrack(v, path = "track") {
     muted: bool(v.muted, `${path}.muted`),
     hidden: bool(v.hidden, `${path}.hidden`),
     locked: bool(v.locked, `${path}.locked`),
+    syncLocked: bool(v.syncLocked, `${path}.syncLocked`),
     volume: num(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
     clips: (v.clips ?? []).map((c, i) => parseVideoClip(c, `${path}.clips[${i}]`))
   });
@@ -190,6 +413,7 @@ function createVideoProject(options = {}) {
 // src/video-editor/timeline.ts
 var VIDEO_TIME_EPSILON = 0.5;
 var videoClipEnd = (clip) => clip.start + clip.duration;
+var videoTrackSyncLocked = (track) => track.syncLocked !== false;
 var videoClipSpeed = (clip) => clip.type === "media" ? clip.speed ?? 1 : 1;
 function videoClipSourceRange(clip) {
   if (clip.type !== "media") return null;
@@ -311,6 +535,14 @@ function videoClipsAt(project, time) {
 }
 
 // src/video-editor/check.ts
+function videoClipKeyframes(clip) {
+  const out = [
+    { property: "opacity", keys: videoKeysOf(clip.opacity) },
+    { property: "volume", keys: clip.type === "media" ? videoKeysOf(clip.volume) : [] },
+    ...VIDEO_TRANSFORM_PROPERTIES.map((p) => ({ property: p, keys: videoKeysOf(clip.transform?.[p]) }))
+  ];
+  return out.filter((o) => o.keys.length);
+}
 var VIDEO_ISSUE_CODES = [
   "missing-asset",
   "wrong-track",
@@ -320,6 +552,7 @@ var VIDEO_ISSUE_CODES = [
   "transition-too-long",
   "transition-handles",
   "fades-too-long",
+  "keyframes-outside-clip",
   "unknown-duration",
   "unused-asset",
   "marker-past-end",
@@ -355,6 +588,16 @@ function checkVideoProject(project) {
         issues.push({ code: "overlap", severity: "error", ...at, message: `Clips "${clip.id}" and "${next.id}" overlap on track "${track.id}" from ${formatVideoSeconds(next.start)}; move one of them.` });
       if ((clip.fadeIn ?? 0) + (clip.fadeOut ?? 0) > clip.duration + VIDEO_TIME_EPSILON)
         issues.push({ code: "fades-too-long", severity: "warning", ...at, message: `Clip "${clip.id}"'s fades (${clip.fadeIn ?? 0} + ${clip.fadeOut ?? 0} ms) are longer than the clip (${clip.duration} ms); shorten them.` });
+      for (const { property, keys } of videoClipKeyframes(clip)) {
+        const outside = keys.filter((k) => k.t < -VIDEO_TIME_EPSILON || k.t > clip.duration + VIDEO_TIME_EPSILON);
+        if (outside.length)
+          issues.push({
+            code: "keyframes-outside-clip",
+            severity: "warning",
+            ...at,
+            message: `Clip "${clip.id}" has ${property} key${outside.length > 1 ? "s" : ""} at ${outside.map((k) => `${Math.round(k.t)} ms`).join(", ")}, outside the clip (0\u2013${Math.round(clip.duration)} ms in clip time), so ${outside.length > 1 ? "they never play" : "it never plays"} directly; move ${outside.length > 1 ? "them" : "it"} inside or remove ${outside.length > 1 ? "them" : "it"} (set_video_keyframes).`
+          });
+      }
       if (clip.transition) {
         const d = clip.transition.duration;
         const before = videoClipBefore(track, clip);
@@ -392,6 +635,7 @@ function checkVideoProject(project) {
 }
 
 // src/video-editor/edit.ts
+var TRACK_FIELD_KEYS = ["name", "muted", "hidden", "locked", "syncLocked", "volume"];
 var VIDEO_EDIT_OPS = [
   "set_settings",
   "add_asset",
@@ -408,6 +652,13 @@ var VIDEO_EDIT_OPS = [
   "delete_clips",
   "update_clip",
   "set_transition",
+  "slip_clip",
+  "roll_edit",
+  "slide_clip",
+  "lift_range",
+  "extract_range",
+  "split_at",
+  "set_keyframes",
   "close_gaps",
   "add_marker",
   "update_marker",
@@ -426,7 +677,32 @@ function freshId(prefix, taken) {
   for (let n2 = 1; ; n2++) if (!used.has(`${prefix}${n2}`)) return `${prefix}${n2}`;
 }
 var slug = (s) => s.replace(/^.*[\\/]/, "").replace(/\.[a-z0-9]+(\?.*)?$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+function mergeSpans(spans) {
+  const out = [];
+  for (const [from, to] of [...spans].sort((a, b) => a[0] - b[0])) {
+    const last = out[out.length - 1];
+    if (last && from <= last[1] + VIDEO_TIME_EPSILON) last[1] = Math.max(last[1], to);
+    else out.push([from, to]);
+  }
+  return out;
+}
+function clipAnimatables(clip) {
+  const c = clip;
+  const out = [
+    { get: () => c.opacity, set: (v) => c.opacity = v },
+    { get: () => c.volume, set: (v) => c.volume = v }
+  ];
+  for (const p of VIDEO_TRANSFORM_PROPERTIES) out.push({ get: () => c.transform?.[p], set: (v) => c.transform && (c.transform[p] = v) });
+  return out;
+}
+function retimeClipKeys(clip, fn) {
+  for (const a of clipAnimatables(clip)) {
+    const v = a.get();
+    if (isVideoKeyframes(v)) a.set(fn(v));
+  }
+}
 var OPTIONAL_CLIP_FIELDS = ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "transition", "in", "speed", "volume", "muted", "color", "fontSize", "fontFamily", "fontWeight", "background"];
+var 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) {
     this.p = p;
@@ -458,7 +734,7 @@ var Editor = class {
     const hit = videoOverlap(track, start, start + duration, ignore);
     if (hit) {
       const free = nextFreeVideoSlot(track, start, duration, ignore);
-      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 pass ripple to push later clips along.`);
+      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.`);
     }
   }
   kindFits(track, clip) {
@@ -470,8 +746,160 @@ var Editor = class {
   shift(track, from, delta, except = /* @__PURE__ */ new Set()) {
     if (!delta) return;
     for (const c of track.clips) if (!except.has(c.id) && c.start >= from - VIDEO_TIME_EPSILON) c.start = Math.max(0, c.start + delta);
+    track.clips.sort((a, b) => a.start - b.start);
+  }
+  get frame() {
+    return 1e3 / this.p.fps;
+  }
+  ids() {
+    return this.p.tracks.flatMap((t) => t.clips.map((c) => c.id));
+  }
+  /**
+   * The tracks a ripple on `sources` moves, top to bottom: the sources, and every unlocked
+   * sync-locked track when one of the sources is sync-locked.
+   */
+  rippleTracks(sources) {
+    const set = new Set(sources);
+    if ([...set].some(videoTrackSyncLocked)) {
+      for (const t of this.p.tracks) if (videoTrackSyncLocked(t) && !t.locked) set.add(t);
+    }
+    return this.p.tracks.filter((t) => set.has(t));
+  }
+  /** The tracks a range edit works on: the named ones (unlocked), or every unlocked track. */
+  rangeTracks(ids) {
+    if (ids) {
+      if (!ids.length) refuse('"tracks" is empty; name at least one track, or leave it out for every unlocked track.');
+      const tracks = [...new Set(ids)].map((id) => this.track(id));
+      tracks.forEach((t) => this.unlocked(t));
+      return this.p.tracks.filter((t) => tracks.includes(t));
+    }
+    const open = this.p.tracks.filter((t) => !t.locked);
+    if (!open.length) refuse("Every track is locked; unlock one (update_track with locked false) first.");
+    return open;
+  }
+  range(from, to) {
+    if (!(to - from > VIDEO_TIME_EPSILON)) refuse(`"to" (${formatVideoSeconds(to)}) must be after "from" (${formatVideoSeconds(from)}).`);
+  }
+  /** Moves a media clip's in point by `delta` of timeline time (stills, titles and colours have none). */
+  moveIn(clip, delta) {
+    if (clip.type !== "media" || videoAssetMap(this.p).get(clip.asset)?.kind === "image") return;
+    clip.in = Math.max(0, (clip.in ?? 0) + delta * videoClipSpeed(clip));
+    if (clip.in < 1e-9) delete clip.in;
+  }
+  /** Moves a clip's head `delta` later in time (start, in point and keys); the caller sets start and duration. */
+  trimHead(clip, delta) {
+    this.moveIn(clip, delta);
+    retimeClipKeys(clip, (v) => retimeVideoAnimatable(v, -delta));
+  }
+  /** Cuts `clip` at `at` (inside it): the left part keeps the id, the right part is returned. */
+  cut(track, clip, at, id) {
+    const end = videoClipEnd(clip);
+    const right = { ...structuredClone(clip), id: id ?? freshId(`${clip.id}-`, this.ids()), start: at, duration: end - at };
+    delete right.transition;
+    delete right.fadeIn;
+    const leftValues = clipAnimatables(clip);
+    clipAnimatables(right).forEach((r, i) => {
+      const [l, rr] = splitVideoAnimatable(leftValues[i].get(), at - clip.start);
+      if (isVideoKeyframes(l)) leftValues[i].set(l);
+      if (isVideoKeyframes(rr)) r.set(rr);
+    });
+    this.moveIn(right, at - clip.start);
+    clip.duration = at - clip.start;
+    delete clip.fadeOut;
+    track.clips.push(right);
+    track.clips.sort((a, b) => a.start - b.start);
+    return right;
+  }
+  /** Cuts every clip on `tracks` that runs across `at`; returns the new right-hand parts. */
+  cutAcross(tracks, at) {
+    const made = [];
+    for (const t of tracks) for (const c of [...t.clips]) if (c.start < at - VIDEO_TIME_EPSILON && videoClipEnd(c) > at + VIDEO_TIME_EPSILON) made.push(this.cut(t, c, at));
+    return made;
+  }
+  /**
+   * Opens `amount` of empty time at `at` on `tracks`: clips across `at` are cut there and everything
+   * from `at` on moves later. Returns the clips made by cutting.
+   */
+  open(tracks, at, amount, except = /* @__PURE__ */ new Set()) {
+    const made = this.cutAcross(tracks, at).map((c) => c.id);
+    for (const t of tracks) this.shift(t, at, amount, except);
+    return made;
+  }
+  /**
+   * Closes `[from, to)` on `tracks`, pulling everything after it earlier. Refuses, before moving
+   * anything, when a track still has a clip in that stretch (it would be pulled out of sync).
+   */
+  close(tracks, from, to) {
+    for (const t of tracks) {
+      const hit = videoOverlap(t, from, to);
+      if (hit)
+        refuse(
+          `Rippling out ${formatVideoSeconds(from)}\u2013${formatVideoSeconds(to)} would pull track "${t.id}" out of sync: clip "${hit.id}" (${formatVideoSeconds(hit.start)}\u2013${formatVideoSeconds(videoClipEnd(hit))}) is in that stretch. Extract the range across "${t.id}" too (extract_range with its id in "tracks"), turn its sync lock off (update_track with syncLocked false) or lock it, or lift instead of rippling.`
+        );
+    }
+    for (const t of tracks) this.shift(t, to, from - to);
+  }
+  /**
+   * Empties `[from, to)` on one track, leaving a gap: clips inside go, clips across an edge are
+   * trimmed back to it, and a clip across both is cut in two around the gap.
+   */
+  clear(track, from, to, report) {
+    for (const c of [...track.clips]) {
+      const start = c.start;
+      const end = videoClipEnd(c);
+      if (end <= from + VIDEO_TIME_EPSILON || start >= to - VIDEO_TIME_EPSILON) continue;
+      const coversHead = start >= from - VIDEO_TIME_EPSILON;
+      const coversTail = end <= to + VIDEO_TIME_EPSILON;
+      if (coversHead && coversTail) {
+        track.clips = track.clips.filter((x) => x !== c);
+        report.removed.push(c.id);
+        continue;
+      }
+      if (!coversHead && !coversTail) report.created.push(this.cut(track, c, to).id);
+      else if (coversHead) {
+        this.trimHead(c, to - start);
+        c.start = to;
+        c.duration = end - to;
+        delete c.transition;
+        report.trimmed.push(c.id);
+        continue;
+      }
+      c.duration = from - start;
+      if (!report.trimmed.includes(c.id)) report.trimmed.push(c.id);
+    }
+    track.clips.sort((a, b) => a.start - b.start);
+  }
+  /** Clamps a slip, roll or slide to `[lo, hi]`, refusing when it cannot move that way at all. */
+  clamp(delta, lo, hi, why) {
+    const applied = Math.min(Math.max(delta, Math.min(0, lo)), Math.max(0, hi));
+    if (Math.abs(delta) > VIDEO_TIME_EPSILON && Math.abs(applied) <= VIDEO_TIME_EPSILON) refuse(why());
+    return Math.abs(applied) <= VIDEO_TIME_EPSILON ? 0 : applied;
+  }
+  /** Places a clip on a track by `mode`, returning what it cut, trimmed, removed and rippled. */
+  place(track, clip, mode, outcome) {
+    if (mode === "insert") {
+      const tracks = this.rippleTracks([track]);
+      outcome.created = this.open(tracks, clip.start, clip.duration);
+      outcome.rippled = tracks.map((t) => t.id);
+    } else if (mode === "overwrite") {
+      const report = { removed: [], trimmed: [], created: [] };
+      this.clear(track, clip.start, videoClipEnd(clip), report);
+      Object.assign(outcome, report);
+    } else this.fits(track, clip.start, clip.duration, /* @__PURE__ */ new Set([clip.id]), `Clip "${clip.id}"`);
+    track.clips.push(clip);
+    track.clips.sort((a, b) => a.start - b.start);
+  }
+  placement(mode, ripple) {
+    if (mode !== void 0 && !VIDEO_PLACEMENT_MODES.includes(mode)) refuse(`"mode" must be ${VIDEO_PLACEMENT_MODES.map((m) => `"${m}"`).join(", ")}.`);
+    if (ripple && mode !== void 0 && mode !== "insert") refuse(`"ripple" means mode "insert", so it cannot go with mode "${mode}"; pass one or the other.`);
+    return mode ?? (ripple ? "insert" : "refuse");
   }
   run(e) {
+    for (const k of TIME_FIELDS[e.op] ?? []) {
+      const v = e[k];
+      if (typeof v !== "number" || !Number.isFinite(v)) refuse(`"${k}" must be a number of milliseconds.`);
+      if (k !== "delta" && v < 0) refuse(`"${k}" must be a time of at least 0.`);
+    }
     switch (e.op) {
       case "set_settings": {
         const { op: _op, ...settings } = e;
@@ -517,7 +945,7 @@ var Editor = class {
       }
       case "update_track": {
         const track = this.track(e.track);
-        for (const k of Object.keys(e.set ?? {})) if (!["name", "muted", "hidden", "locked", "volume"].includes(k)) refuse(`"${k}" cannot be set on a track; use name, muted, hidden, locked or volume.`);
+        for (const k of Object.keys(e.set ?? {})) if (!TRACK_FIELD_KEYS.includes(k)) refuse(`"${k}" cannot be set on a track; use ${TRACK_FIELD_KEYS.join(", ")}.`);
         Object.assign(track, e.set);
         for (const k of e.remove ?? []) delete track[k];
         return this.outcomes.push({ op: e.op, track: track.id });
@@ -538,6 +966,7 @@ var Editor = class {
       case "add_clip": {
         const track = this.track(e.track);
         this.unlocked(track);
+        const mode = this.placement(e.mode, e.ripple);
         const draft = { ...e.clip, type: e.clip.type ?? "media" };
         this.kindFits(track, draft);
         const ids = this.p.tracks.flatMap((t) => t.clips.map((c) => c.id));
@@ -555,14 +984,9 @@ var Editor = class {
         const end = sortedVideoClips(track).reduce((m, c) => Math.max(m, videoClipEnd(c)), 0);
         draft.start ??= end;
         const clip = parseVideoClip(draft, "clip");
-        if (e.ripple) {
-          const inside = track.clips.find((c) => c.start < clip.start - VIDEO_TIME_EPSILON && videoClipEnd(c) > clip.start + VIDEO_TIME_EPSILON);
-          if (inside) refuse(`${formatVideoSeconds(clip.start)} is inside clip "${inside.id}"; split it there first (split_clip), or insert at its start or end.`);
-          this.shift(track, clip.start, clip.duration);
-        } else this.fits(track, clip.start, clip.duration, /* @__PURE__ */ new Set(), `Clip "${clip.id}"`);
-        track.clips.push(clip);
-        track.clips.sort((a, b) => a.start - b.start);
-        return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
+        const outcome = { op: e.op, clip: clip.id, track: track.id };
+        this.place(track, clip, mode, outcome);
+        return this.outcomes.push(outcome);
       }
       case "move_clip": {
         const from = this.clip(e.clip);
@@ -570,15 +994,14 @@ var Editor = class {
         const to = e.track !== void 0 ? this.track(e.track) : from.track;
         this.unlocked(to);
         if (to !== from.track) this.kindFits(to, from.clip);
+        const mode = this.placement(e.mode);
         const start = e.start ?? from.clip.start;
-        this.fits(to, start, from.clip.duration, /* @__PURE__ */ new Set([from.clip.id]), `Clip "${from.clip.id}"`);
+        if (start < 0) refuse("A clip cannot start before 0.");
+        from.track.clips.splice(from.index, 1);
         from.clip.start = start;
-        if (to !== from.track) {
-          from.track.clips.splice(from.index, 1);
-          to.clips.push(from.clip);
-        }
-        to.clips.sort((a, b) => a.start - b.start);
-        return this.outcomes.push({ op: e.op, clip: from.clip.id, track: to.id });
+        const outcome = { op: e.op, clip: from.clip.id, track: to.id };
+        this.place(to, from.clip, mode, outcome);
+        return this.outcomes.push(outcome);
       }
       case "trim_clip": {
         const { track, clip } = this.clip(e.clip);
@@ -596,9 +1019,19 @@ var Editor = class {
             clip.in = Math.max(0, sourceIn);
             if (clip.in === 0) delete clip.in;
           }
+          retimeClipKeys(clip, (v) => retimeVideoAnimatable(v, -delta));
           if (e.ripple) {
-            clip.duration -= delta;
-            this.shift(track, end, -delta, /* @__PURE__ */ new Set([clip.id]));
+            const tracks = this.rippleTracks([track]);
+            if (delta > 0) {
+              clip.start += delta;
+              clip.duration -= delta;
+              this.close(tracks, clip.start - delta, clip.start);
+            } else if (delta < 0) {
+              const created = this.open(tracks, clip.start, -delta, /* @__PURE__ */ new Set([clip.id]));
+              clip.duration -= delta;
+              return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id, rippled: tracks.map((t) => t.id), ...created.length ? { created } : {} });
+            }
+            return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id, rippled: tracks.map((t) => t.id) });
           } else {
             if (e.to < 0) refuse("A clip cannot start before 0.");
             if (delta < 0) this.fits(track, e.to, -delta, /* @__PURE__ */ new Set([clip.id]), `Extending "${clip.id}"`);
@@ -614,8 +1047,19 @@ var Editor = class {
             if (asset?.duration !== void 0 && out > asset.duration + VIDEO_TIME_EPSILON)
               refuse(`"${clip.id}" can end at most at ${formatVideoSeconds(clip.start + (asset.duration - (clip.in ?? 0)) / speed)}, where "${asset.id}" runs out.`);
           }
-          if (e.ripple) this.shift(track, end, e.to - end, /* @__PURE__ */ new Set([clip.id]));
-          else if (e.to > end) this.fits(track, end, e.to - end, /* @__PURE__ */ new Set([clip.id]), `Extending "${clip.id}"`);
+          if (e.ripple) {
+            const tracks = this.rippleTracks([track]);
+            let created = [];
+            if (e.to < end) {
+              clip.duration = duration;
+              this.close(tracks, e.to, end);
+            } else if (e.to > end) {
+              created = this.open(tracks, end, e.to - end, /* @__PURE__ */ new Set([clip.id]));
+              clip.duration = duration;
+            }
+            return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id, rippled: tracks.map((t) => t.id), ...created.length ? { created } : {} });
+          }
+          if (e.to > end) this.fits(track, end, e.to - end, /* @__PURE__ */ new Set([clip.id]), `Extending "${clip.id}"`);
           clip.duration = duration;
         }
         return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
@@ -626,31 +1070,25 @@ var Editor = class {
         const end = videoClipEnd(clip);
         const minimum = 1e3 / this.p.fps;
         if (e.at < clip.start + minimum - VIDEO_TIME_EPSILON || e.at > end - minimum + VIDEO_TIME_EPSILON) refuse(`${formatVideoSeconds(e.at)} is not inside "${clip.id}" (${formatVideoSeconds(clip.start)}\u2013${formatVideoSeconds(end)}), at least a frame from either end.`);
-        const ids = this.p.tracks.flatMap((t) => t.clips.map((c) => c.id));
-        if (e.id !== void 0 && ids.includes(e.id)) refuse(`There is already a clip "${e.id}".`);
-        const id = e.id ?? freshId(`${clip.id}-`, ids);
-        const left = e.at - clip.start;
-        const right = { ...structuredClone(clip), id, start: e.at, duration: end - e.at };
-        delete right.transition;
-        delete right.fadeIn;
-        if (clip.type === "media") {
-          right.in = (clip.in ?? 0) + left * videoClipSpeed(clip);
-        }
-        clip.duration = left;
-        delete clip.fadeOut;
-        track.clips.push(right);
-        track.clips.sort((a, b) => a.start - b.start);
-        return this.outcomes.push({ op: e.op, clips: [clip.id, id], clip: id, track: track.id });
+        if (e.id !== void 0 && this.ids().includes(e.id)) refuse(`There is already a clip "${e.id}".`);
+        const right = this.cut(track, clip, e.at, e.id);
+        return this.outcomes.push({ op: e.op, clips: [clip.id, right.id], clip: right.id, track: track.id });
       }
       case "delete_clips": {
         const found = [...new Set(e.clips)].map((id) => this.clip(id));
         for (const f of found) this.unlocked(f.track);
-        for (const track of new Set(found.map((f) => f.track))) {
-          const gone = found.filter((f) => f.track === track).map((f) => f.clip);
-          track.clips = track.clips.filter((c) => !gone.includes(c));
-          if (e.ripple) for (const c of [...gone].sort((a, b) => b.start - a.start)) this.shift(track, videoClipEnd(c), -c.duration);
+        for (const track of new Set(found.map((f) => f.track))) track.clips = track.clips.filter((c) => !found.some((f) => f.clip === c));
+        if (!e.ripple) return this.outcomes.push({ op: e.op, clips: found.map((f) => f.clip.id) });
+        const rippled = /* @__PURE__ */ new Set();
+        const groups = [...new Set(found.map((f) => f.track))].filter((t) => !videoTrackSyncLocked(t)).map((t) => [t]);
+        if (found.some((f) => videoTrackSyncLocked(f.track))) groups.push(found.filter((f) => videoTrackSyncLocked(f.track)).map((f) => f.track));
+        for (const sources of groups) {
+          const tracks = this.rippleTracks(sources);
+          tracks.forEach((t) => rippled.add(t));
+          const spans = mergeSpans(found.filter((f) => sources.includes(f.track)).map((f) => [f.clip.start, videoClipEnd(f.clip)]));
+          for (const [from, to] of spans.reverse()) this.close(tracks, from, to);
         }
-        return this.outcomes.push({ op: e.op, clips: found.map((f) => f.clip.id) });
+        return this.outcomes.push({ op: e.op, clips: found.map((f) => f.clip.id), rippled: this.p.tracks.filter((t) => rippled.has(t)).map((t) => t.id) });
       }
       case "update_clip": {
         const at = this.clip(e.clip);
@@ -659,12 +1097,17 @@ var Editor = class {
         for (const k of ["id", "type"]) if (k in set) refuse(`A clip's ${k} cannot be changed; delete it and add a new one.`);
         for (const k of e.remove ?? []) if (!OPTIONAL_CLIP_FIELDS.includes(k)) refuse(`"${k}" cannot be removed; removable fields are ${OPTIONAL_CLIP_FIELDS.join(", ")}.`);
         if ("speed" in set && (typeof set.speed !== "number" || !(set.speed > 0))) refuse('"speed" must be a number greater than 0 (1 = normal speed).');
+        let stretch = 1;
         if (at.clip.type === "media" && !("duration" in set)) {
           const was = videoClipSpeed(at.clip);
           const now = "speed" in set ? set.speed : e.remove?.includes("speed") ? 1 : was;
-          if (now !== was) set.duration = at.clip.duration * was / now;
+          if (now !== was) {
+            set.duration = at.clip.duration * was / now;
+            stretch = was / now;
+          }
         }
-        const next = { ...at.clip, ...set };
+        const next = { ...structuredClone(at.clip), ...set };
+        if (stretch !== 1) retimeClipKeys(next, (v) => retimeVideoAnimatable(v, 0, stretch));
         for (const k of e.remove ?? []) delete next[k];
         const clip = parseVideoClip(next, "set");
         if (clip.type === "media" && clip.asset !== at.clip.asset) this.kindFits(at.track, clip);
@@ -680,6 +1123,133 @@ var Editor = class {
         else clip.transition = parseVideoTransition(e.transition, "transition");
         return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
       }
+      case "slip_clip": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        if (clip.type !== "media") refuse(`Clip "${clip.id}" is a ${clip.type === "text" ? "title" : "colour"}, so it has no source to slip; only video and audio clips slip.`);
+        const asset = this.asset(clip.asset);
+        if (asset.kind === "image") refuse(`Clip "${clip.id}" is a still ("${asset.id}"), so it has no source to slip; only video and audio clips slip.`);
+        const handles = videoClipHandles(clip, videoAssetMap(this.p));
+        const { lead, tail } = videoClipOverhang(track, clip);
+        const delta = this.clamp(
+          e.delta,
+          lead - handles.before,
+          handles.after - tail,
+          () => e.delta > 0 ? `"${clip.id}" already plays to the end of "${asset.id}"${tail ? ` (less the ${tail} ms the transition after it needs)` : ""}, so it cannot slip later; slip it earlier (a negative delta).` : `"${clip.id}" already starts at the beginning of "${asset.id}"${lead ? ` (plus the ${lead} ms its transition needs)` : ""}, so it cannot slip earlier; slip it later (a positive delta).`
+        );
+        this.moveIn(clip, delta);
+        return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id, delta });
+      }
+      case "roll_edit": {
+        const left = this.clip(e.left);
+        const right = this.clip(e.right);
+        if (left.track !== right.track) refuse(`"${e.left}" is on track "${left.track.id}" and "${e.right}" on "${right.track.id}"; a roll moves the cut between two clips on one track.`);
+        const track = left.track;
+        this.unlocked(track);
+        const L = left.clip;
+        const R = right.clip;
+        if (Math.abs(videoClipEnd(L) - R.start) > VIDEO_TIME_EPSILON) {
+          if (Math.abs(videoClipEnd(R) - L.start) <= VIDEO_TIME_EPSILON) refuse(`"${R.id}" comes before "${L.id}"; pass left "${R.id}" and right "${L.id}".`);
+          refuse(`"${L.id}" ends at ${formatVideoSeconds(videoClipEnd(L))} but "${R.id}" starts at ${formatVideoSeconds(R.start)}; a roll needs two clips that meet at a cut (use trim_clip to move one edge).`);
+        }
+        const assets = videoAssetMap(this.p);
+        const lo = Math.max(-(L.duration - this.frame), -(videoClipHandles(R, assets).before - videoClipOverhang(track, R).lead));
+        const hi = Math.min(R.duration - this.frame, videoClipHandles(L, assets).after - videoClipOverhang(track, L).tail);
+        const delta = this.clamp(
+          e.delta,
+          lo,
+          hi,
+          () => e.delta > 0 ? `The cut cannot move later: ${R.duration - this.frame < 1 ? `"${R.id}" is already a frame long` : `"${L.id}" has no media after its out point`}. Roll it earlier (a negative delta).` : `The cut cannot move earlier: ${L.duration - this.frame < 1 ? `"${L.id}" is already a frame long` : `"${R.id}" has no media before its in point`}. Roll it later (a positive delta).`
+        );
+        L.duration += delta;
+        R.start += delta;
+        R.duration -= delta;
+        this.trimHead(R, delta);
+        return this.outcomes.push({ op: e.op, clip: R.id, clips: [L.id, R.id], track: track.id, delta });
+      }
+      case "slide_clip": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        const before = videoClipBefore(track, clip);
+        const after = videoClipAfter(track, clip);
+        if (!before && !after) refuse(`"${clip.id}" has no clip right before or after it on track "${track.id}", so there is nothing to slide against; use move_clip.`);
+        const assets = videoAssetMap(this.p);
+        const end = videoClipEnd(clip);
+        const others = track.clips.filter((c) => c !== clip);
+        const room = {
+          earlier: before ? before.duration - this.frame : clip.start - others.filter((c) => videoClipEnd(c) <= clip.start + VIDEO_TIME_EPSILON).reduce((m, c) => Math.max(m, videoClipEnd(c)), 0),
+          later: after ? after.duration - this.frame : others.filter((c) => c.start >= end - VIDEO_TIME_EPSILON).reduce((m, c) => Math.min(m, c.start - end), Infinity)
+        };
+        const lo = -Math.min(room.earlier, after ? videoClipHandles(after, assets).before - videoClipOverhang(track, after).lead : Infinity);
+        const hi = Math.min(room.later, before ? videoClipHandles(before, assets).after - videoClipOverhang(track, before).tail : Infinity);
+        const delta = this.clamp(
+          e.delta,
+          lo,
+          hi,
+          () => e.delta > 0 ? `"${clip.id}" cannot slide later: ${room.later < 1 ? after ? `"${after.id}" is already a frame long` : "the next clip is right after it" : `"${before.id}" has no media after its out point to fill in behind it`}. Slide it earlier (a negative delta).` : `"${clip.id}" cannot slide earlier: ${room.earlier < 1 ? before ? `"${before.id}" is already a frame long` : "it is against the clip before it or the start" : `"${after.id}" has no media before its in point to fill in behind it`}. Slide it later (a positive delta).`
+        );
+        clip.start += delta;
+        if (before) before.duration += delta;
+        if (after) {
+          after.start += delta;
+          after.duration -= delta;
+          this.trimHead(after, delta);
+        }
+        track.clips.sort((a, b) => a.start - b.start);
+        return this.outcomes.push({ op: e.op, clip: clip.id, clips: [before?.id, clip.id, after?.id].filter((x) => !!x), track: track.id, delta });
+      }
+      case "lift_range":
+      case "extract_range": {
+        this.range(e.from, e.to);
+        const tracks = this.rangeTracks(e.tracks);
+        const report = { removed: [], trimmed: [], created: [] };
+        for (const t of tracks) this.clear(t, e.from, e.to, report);
+        const outcome = { op: e.op, ...report };
+        if (e.op === "extract_range") {
+          const rippled = this.rippleTracks(tracks);
+          this.close(rippled, e.from, e.to);
+          outcome.rippled = rippled.map((t) => t.id);
+        }
+        return this.outcomes.push(outcome);
+      }
+      case "split_at": {
+        const tracks = this.rangeTracks(e.tracks);
+        const lefts = tracks.flatMap((t) => t.clips.filter((c) => c.start < e.at - VIDEO_TIME_EPSILON && videoClipEnd(c) > e.at + VIDEO_TIME_EPSILON).map((c) => c.id));
+        if (!lefts.length) refuse(`No clip runs across ${formatVideoSeconds(e.at)} on ${e.tracks ? `track${tracks.length > 1 ? "s" : ""} ${tracks.map((t) => `"${t.id}"`).join(", ")}` : "the unlocked tracks"}, so there is nothing to split there.`);
+        const created = this.cutAcross(tracks, e.at).map((c) => c.id);
+        return this.outcomes.push({ op: e.op, clips: lefts, created });
+      }
+      case "set_keyframes": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        if (!VIDEO_KEYFRAME_PROPERTIES.includes(e.property)) refuse(`"${e.property}" cannot be keyframed; use one of ${VIDEO_KEYFRAME_PROPERTIES.join(", ")}.`);
+        if (e.property === "volume" && clip.type !== "media") refuse(`Clip "${clip.id}" is a ${clip.type} clip and has no volume; volume keys go on media clips.`);
+        const limits = VIDEO_KEYFRAME_LIMITS[e.property];
+        const transform = VIDEO_TRANSFORM_PROPERTIES.includes(e.property);
+        const c = clip;
+        const current = transform ? c.transform?.[e.property] : c[e.property];
+        let value;
+        if (e.keys === null) {
+          const v = videoValueAt(current, 0, limits.default);
+          value = isVideoKeyframes(current) ? v === limits.default ? void 0 : v : current;
+        } else {
+          if (!Array.isArray(e.keys) || !e.keys.length) refuse('"keys" must list at least one key { t, v }; pass null to remove the keyframes.');
+          let sorted = [];
+          try {
+            sorted = sortVideoKeys(e.keys);
+          } catch (error) {
+            refuse(error.message);
+          }
+          value = parseVideoAnimatable({ keys: sorted }, e.property, limits);
+        }
+        if (transform) {
+          c.transform = { ...c.transform, [e.property]: value };
+          if (value === void 0) delete c.transform[e.property];
+          if (!Object.keys(c.transform).length) delete c.transform;
+        } else if (value === void 0) delete c[e.property];
+        else c[e.property] = value;
+        return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
+      }
       case "close_gaps": {
         const track = this.track(e.track);
         this.unlocked(track);
@@ -757,7 +1327,10 @@ function applyVideoEdits(project, edits) {
 }
 
 // src/video-editor/evaluate.ts
-function placeVideoRect(frame, size, fit = "contain", transform = {}) {
+function videoTransformAt(transform, clipTime = 0) {
+  return { x: videoValueAt(transform?.x, clipTime, 0), y: videoValueAt(transform?.y, clipTime, 0), scale: videoValueAt(transform?.scale, clipTime, 1), rotation: videoValueAt(transform?.rotation, clipTime, 0) };
+}
+function placeVideoRect(frame, size, fit = "contain", transform = {}, clipTime = 0) {
   let w = size.width;
   let h = size.height;
   if (fit === "fill") {
@@ -768,18 +1341,18 @@ function placeVideoRect(frame, size, fit = "contain", transform = {}) {
     w *= k;
     h *= k;
   }
-  const scale = transform?.scale ?? 1;
-  w *= scale;
-  h *= scale;
-  const cx = frame.width / 2 + (transform?.x ?? 0);
-  const cy = frame.height / 2 + (transform?.y ?? 0);
+  const t = videoTransformAt(transform, clipTime);
+  w *= t.scale;
+  h *= t.scale;
+  const cx = frame.width / 2 + t.x;
+  const cy = frame.height / 2 + t.y;
   return { x: cx - w / 2, y: cy - h / 2, width: w, height: h };
 }
 function videoTextStyle(clip) {
   return { text: clip.text, color: clip.color ?? "#ffffff", fontSize: clip.fontSize ?? 64, fontFamily: clip.fontFamily ?? "sans-serif", fontWeight: clip.fontWeight ?? 700, ...clip.background ? { background: clip.background } : {} };
 }
-function videoTitleFrame(project, clip) {
-  const layer = { clip: clip.id, track: "", type: "text", opacity: 1, rect: placeVideoRect(project, project, "fill", clip.transform), rotation: clip.transform?.rotation ?? 0, text: videoTextStyle(clip) };
+function videoTitleFrame(project, clip, clipTime = 0) {
+  const layer = { clip: clip.id, track: "", type: "text", opacity: 1, rect: placeVideoRect(project, project, "fill", clip.transform, clipTime), rotation: videoTransformAt(clip.transform, clipTime).rotation, text: videoTextStyle(clip) };
   return { time: clip.start, width: project.width, height: project.height, background: "rgba(0,0,0,0)", layers: [layer], audio: [] };
 }
 var clamp01 = (v) => Math.min(1, Math.max(0, v));
@@ -819,14 +1392,15 @@ function videoFrameAt(project, time) {
       const mix = (incoming ? level(incoming, true) : 1) * (outgoing ? level(outgoing, false) : 1);
       const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
       const sourceTime = sourceTimeAt(clip, time);
+      const clipTime = time - clip.start;
       const audible = asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
       if (audible && clip.type === "media" && !clip.muted && !track.muted) {
-        const gain = (clip.volume ?? 1) * (track.volume ?? 1) * fade * mix;
+        const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fade * mix;
         audio.push({ clip: clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeed(clip) });
       }
       if (track.kind !== "video" || track.hidden) continue;
       if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
-      let opacity = (clip.opacity ?? 1) * fade;
+      let opacity = videoValueAt(clip.opacity, clipTime, 1) * fade;
       let wipe;
       let dip = null;
       if (incoming) {
@@ -837,8 +1411,8 @@ function videoFrameAt(project, time) {
       if (outgoing?.type === "dip") dip = { color: outgoing.next.transition.color ?? "#000000", opacity: outgoing.progress * 2 };
       const size = clip.type === "media" ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
       const fit = clip.fit ?? (clip.type === "media" ? "contain" : "fill");
-      const rect = clip.type === "text" ? placeVideoRect(project, size, "fill", clip.transform) : placeVideoRect(project, size, fit, clip.transform);
-      const layer = { clip: clip.id, track: track.id, type: clip.type, opacity: clamp01(opacity), rect, rotation: clip.transform?.rotation ?? 0 };
+      const rect = placeVideoRect(project, size, clip.type === "text" ? "fill" : fit, clip.transform, clipTime);
+      const layer = { clip: clip.id, track: track.id, type: clip.type, opacity: clamp01(opacity), rect, rotation: videoValueAt(clip.transform?.rotation, clipTime, 0) };
       if (wipe) layer.wipe = wipe;
       if (clip.type === "media") Object.assign(layer, { asset: asset.id, assetKind: asset.kind, src: asset.src, sourceTime });
       if (clip.type === "text") layer.text = videoTextStyle(clip);
@@ -1060,7 +1634,13 @@ function toVideoFfmpeg(project, options = {}) {
   const audio = [];
   let cur = "base";
   let usesDrawtext = false;
+  const animated = /* @__PURE__ */ new Set();
   let k = 0;
+  const step = 2e3 / fps;
+  const expr = (prop, clipTime, fallback, what) => {
+    if (isVideoKeyframes(prop)) animated.add(what);
+    return videoKeyframeFfmpegExpr(prop, clipTime, fallback, step);
+  };
   const input = (clip, asset, lead, tail) => {
     const speed = videoClipSpeed(clip);
     const src = options.resolve ? options.resolve(asset) : asset.src;
@@ -1085,8 +1665,9 @@ function toVideoFfmpeg(project, options = {}) {
       const audible = asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
       if (audible && clip.type === "media" && !clip.muted && !track.muted) {
         const ai = index ?? input(clip, asset, lead, tail);
-        const gain = (clip.volume ?? 1) * (track.volume ?? 1);
-        const chain2 = ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip)), `volume=${gain}`];
+        const trackGain = track.volume ?? 1;
+        const volume = isVideoKeyframes(clip.volume) ? `volume='${trackGain}*(${expr(clip.volume, `(t*1000${lead ? `-${Math.round(lead)}` : ""})`, 1, "volume")})':eval=frame` : `volume=${(clip.volume ?? 1) * trackGain}`;
+        const chain2 = ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip)), volume];
         const before2 = clip.transition ? videoClipBefore(track, clip) : null;
         if (lead) chain2.push(`afade=t=in:st=0:d=${sec(2 * lead)}`);
         if (tail) chain2.push(`afade=t=out:st=${sec(span - 2 * tail)}:d=${sec(2 * tail)}`);
@@ -1102,33 +1683,43 @@ function toVideoFfmpeg(project, options = {}) {
       if (track.kind !== "video" || track.hidden) continue;
       const enable = `enable='between(t,${sec(t0)},${sec(t0 + span)})'`;
       const next = `v${k++}`;
+      const onTimeline = `(t*1000-${Math.round(clip.start)})`;
+      const onChain = (v) => `(${v}*1000${lead ? `-${Math.round(lead)}` : ""})`;
+      const tf = clip.transform;
+      const moving = VIDEO_TRANSFORM_PROPERTIES.some((p) => isVideoKeyframes(tf?.[p]));
       if (clip.type === "text" && options.titleImage) {
-        inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", options.titleImage(clip, { width: project.width, height: project.height })]);
+        inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", options.titleImage(moving ? { ...clip, transform: void 0 } : clip, { width: project.width, height: project.height })]);
         index = inputs.length - 1;
       } else if (clip.type === "text") {
         usesDrawtext = true;
-        const op = clip.opacity ?? 1;
-        const alpha = [String(op), clip.fadeIn ? `min(1,(t-${sec(clip.start)})/${sec(clip.fadeIn)})` : "", clip.fadeOut ? `min(1,(${sec(end)}-t)/${sec(clip.fadeOut)})` : ""].filter(Boolean).join("*");
-        const x = clip.transform?.x ?? 0;
-        const y = clip.transform?.y ?? 0;
+        const op = isVideoKeyframes(clip.opacity) ? `clip(${expr(clip.opacity, onTimeline, 1, "opacity")},0,1)` : String(clip.opacity ?? 1);
+        const alpha = [op, clip.fadeIn ? `min(1,(t-${sec(clip.start)})/${sec(clip.fadeIn)})` : "", clip.fadeOut ? `min(1,(${sec(end)}-t)/${sec(clip.fadeOut)})` : ""].filter(Boolean).join("*");
+        const coord = (axis) => {
+          const v = tf?.[axis];
+          const base = `(${axis === "x" ? "w-text_w" : "h-text_h"})/2`;
+          return isVideoKeyframes(v) ? `${axis}='${base}+(${expr(v, onTimeline, 0, "position")})'` : `${axis}=${base}+${v ?? 0}`;
+        };
+        const fontSize = clip.fontSize ?? 64;
         const opts = [
           `text=${ffmpegFilterValue(clip.text)}`,
           options.fontFile ? `fontfile=${ffmpegFilterValue(options.fontFile)}` : `font=${ffmpegFilterValue(clip.fontFamily ?? "sans-serif")}`,
-          `fontsize=${Math.round((clip.fontSize ?? 64) * (clip.transform?.scale ?? 1))}`,
+          isVideoKeyframes(tf?.scale) ? `fontsize='${fontSize}*(${expr(tf.scale, onTimeline, 1, "scale")})'` : `fontsize=${Math.round(fontSize * (tf?.scale ?? 1))}`,
           `fontcolor=${color(clip.color ?? "#ffffff")}`,
-          `x=(w-text_w)/2+${x}`,
-          `y=(h-text_h)/2+${y}`,
+          coord("x"),
+          coord("y"),
           `alpha='${alpha}'`,
           ...clip.background ? ["box=1", `boxcolor=${color(clip.background)}`, `boxborderw=${Math.round((clip.fontSize ?? 64) / 2)}`] : [],
           `enable='between(t,${sec(clip.start)},${sec(end)})'`
         ];
-        if (clip.transform?.rotation) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
+        if (tf?.rotation) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
         graph.push(`[${cur}]drawtext=${opts.join(":")}[${next}]`);
         cur = next;
         continue;
       }
       const size = asset ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
-      const rect = clip.type === "text" ? { x: 0, y: 0, width: project.width, height: project.height } : placeVideoRect(project, size, clip.fit ?? (clip.type === "media" ? "contain" : "fill"), clip.transform);
+      const placed = clip.type === "text" && !moving ? void 0 : tf;
+      const still = Object.fromEntries(Object.entries(placed ?? {}).filter(([, v]) => !isVideoKeyframes(v)));
+      const rect = placeVideoRect(project, size, clip.type === "text" ? "fill" : clip.fit ?? (clip.type === "media" ? "contain" : "fill"), still);
       const chain = [];
       let source;
       if (clip.type === "color") source = `color=c=${color(clip.color)}:s=${even(rect.width)}x${even(rect.height)}:r=${fps}:d=${sec(span)}`;
@@ -1136,8 +1727,13 @@ function toVideoFfmpeg(project, options = {}) {
         source = `[${index}:v]`;
         chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
       }
+      if (isVideoKeyframes(placed?.scale)) {
+        const s = expr(placed.scale, onChain("t"), 1, "scale");
+        chain.push(`scale=w='max(2,trunc(${even(rect.width)}*(${s})/2)*2)':h='max(2,trunc(${even(rect.height)}*(${s})/2)*2)':eval=frame`);
+      }
       chain.push("format=yuva420p");
-      if (clip.opacity !== void 0 && clip.opacity < 1) chain.push(`colorchannelmixer=aa=${clip.opacity}`);
+      if (isVideoKeyframes(clip.opacity)) chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='alpha(X,Y)*clip(${expr(clip.opacity, onChain("T"), 1, "opacity")},0,1)'`);
+      else if (clip.opacity !== void 0 && clip.opacity < 1) chain.push(`colorchannelmixer=aa=${clip.opacity}`);
       if (clip.fadeIn) chain.push(`fade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}:alpha=1`);
       if (clip.fadeOut) chain.push(`fade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}:alpha=1`);
       if (lead && clip.transition.type === "crossfade") chain.push(`fade=t=in:st=0:d=${sec(2 * lead)}:alpha=1`);
@@ -1148,12 +1744,18 @@ function toVideoFfmpeg(project, options = {}) {
         const test = dir === "right" ? `lt(X,W*${p})` : dir === "left" ? `gt(X,W*(1-${p}))` : dir === "down" ? `lt(Y,H*${p})` : `gt(Y,H*(1-${p}))`;
         chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(${test},alpha(X,Y),0)'`);
       }
-      if (clip.transform?.rotation && clip.type !== "text") chain.push(`rotate=${clip.transform.rotation}*PI/180:c=none:ow=rotw(${clip.transform.rotation}*PI/180):oh=roth(${clip.transform.rotation}*PI/180)`);
+      const rotation = placed?.rotation;
+      if (isVideoKeyframes(rotation)) chain.push(`rotate=a='(${expr(rotation, onChain("t"), 0, "rotation")})*PI/180':c=none:ow='hypot(iw,ih)':oh=ow`);
+      else if (rotation) chain.push(`rotate=${rotation}*PI/180:c=none:ow=rotw(${rotation}*PI/180):oh=roth(${rotation}*PI/180)`);
       chain.push(`setpts=PTS+${sec(t0)}/TB`);
       const cx = rect.x + rect.width / 2;
       const cy = rect.y + rect.height / 2;
+      const at = (axis, c) => {
+        const v = placed?.[axis];
+        return isVideoKeyframes(v) ? `${axis}='${Math.round(axis === "x" ? project.width / 2 : project.height / 2)}+(${expr(v, onTimeline, 0, "position")})-${axis === "x" ? "w" : "h"}/2'` : `${axis}='${Math.round(c)}-${axis === "x" ? "w" : "h"}/2'`;
+      };
       graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[l${next}]`);
-      graph.push(`[${cur}][l${next}]overlay=x='${Math.round(cx)}-w/2':y='${Math.round(cy)}-h/2':eof_action=pass:${enable}[${next}]`);
+      graph.push(`[${cur}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable}[${next}]`);
       cur = next;
       const before = clip.transition ? videoClipBefore(track, clip) : null;
       if (before && clip.transition.type === "dip") {
@@ -1169,6 +1771,8 @@ function toVideoFfmpeg(project, options = {}) {
   if (audio.length) graph.push(`${audio.join("")}amix=inputs=${audio.length}:normalize=0:duration=longest,apad,atrim=0:${sec(D)}[aout]`);
   if (project.tracks.some((t) => t.clips.some((c) => c.type === "media" && assets.get(c.asset)?.kind === "video" && assets.get(c.asset)?.hasAudio === void 0)))
     notes.push('Video assets are assumed to have sound; set "hasAudio": false on any that do not, or ffmpeg will stop at a missing audio stream.');
+  if (animated.size)
+    notes.push(`Keyframed ${[...animated].sort().join(", ")} ${animated.size > 1 ? "are" : "is"} rendered as straight lines between keys, with eased segments sampled every two frames${animated.has("scale") ? "; animated scale needs ffmpeg 5 or later (scale with eval=frame)" : ""}.`);
   if (usesDrawtext) notes.push("Titles use drawtext, which needs an ffmpeg built with libfreetype (Homebrew's is not: check `ffmpeg -filters | grep drawtext`); pass titleImage to render them as images instead.");
   const filterComplex = graph.join(";");
   const args = [
@@ -1581,7 +2185,17 @@ var CLIP_ID = { type: "string", minLength: 1, description: 'A clip id from get_v
 var TRACK_ID = { type: "string", minLength: 1, description: 'A track id from get_video_project (e.g. "v1" or "a1").' };
 var ASSET_ID = { type: "string", minLength: 1, description: "An asset id from get_video_project." };
 var COLOR = (what) => ({ type: "string", minLength: 1, description: `${what}: a CSS colour such as "#ffcc00".` });
-var RIPPLE = { type: "boolean", description: "Push (or pull) the later clips on the same track along by the change, keeping the cuts after it in sync (default false: refuse if it would overlap)." };
+var RIPPLE = {
+  type: "boolean",
+  description: "Push (or pull) later material along by the change, keeping the cuts after it in sync (default false: refuse if it would overlap). When the track is sync-locked (the default), every other unlocked sync-locked track moves too: clips across the edit point are cut when time opens, and closing time is refused if another sync-locked track has a clip in that stretch."
+};
+var MODE = {
+  type: "string",
+  enum: [...VIDEO_PLACEMENT_MODES],
+  description: 'What to do with clips already where it lands: "refuse" (default) fails with the next free place; "overwrite" cuts, trims or removes what is underneath on that track; "insert" cuts everything across the start and pushes later material along by its length on this track and every sync-locked track.'
+};
+var DELTA = (what) => ({ type: "number", description: `${what}, in milliseconds of timeline time: positive is later, negative earlier. It is clamped to what the media and neighbours allow; the result says how far it went.` });
+var RANGE_TRACKS = { type: "array", items: TRACK_ID, minItems: 1, uniqueItems: true, description: "Tracks to work on (default: every unlocked track). Locked tracks are refused." };
 var TRANSFORM = object(
   {
     x: { type: "number", description: "Offset of the centre to the right of the frame's centre, in pixels (default 0)." },
@@ -1604,7 +2218,7 @@ var TRANSITION = object(
 );
 var CLIP_COMMON = {
   name: { type: "string", description: "A label for the clip." },
-  opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0\u20131 (default 1)." },
+  opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0\u20131 (default 1). A number replaces any keyframes; set_video_keyframes animates it." },
   transform: TRANSFORM,
   fit: { type: "string", enum: [...VIDEO_FITS], description: "How the picture fits the frame before the transform, as CSS object-fit (default contain for media, fill for colours)." },
   fadeIn: MS("Fade up from nothing (picture and sound) over this long"),
@@ -1613,7 +2227,7 @@ var CLIP_COMMON = {
 var MEDIA_FIELDS = {
   in: MS("Where in the source it starts (default 0)"),
   speed: { type: "number", minimum: 0.05, maximum: 20, description: "Playback speed (default 1). Changing it keeps the stretch of source, so the clip gets shorter or longer." },
-  volume: { type: "number", minimum: 0, maximum: 4, description: "Gain (1 = unchanged, default 1)." },
+  volume: { type: "number", minimum: 0, maximum: 4, description: "Gain (1 = unchanged, default 1). A number replaces any keyframes; set_video_keyframes animates it." },
   muted: { type: "boolean", description: "Silence this clip (default false)." }
 };
 var TEXT_FIELDS = {
@@ -1649,6 +2263,7 @@ var TRACK_FIELDS = {
   muted: { type: "boolean", description: "Silence every clip on it." },
   hidden: { type: "boolean", description: "Leave its pictures out of the frame." },
   locked: { type: "boolean", description: "Refuse edits to its clips." },
+  syncLocked: { type: "boolean", description: "Move with ripple edits on other sync-locked tracks so it stays in sync (default true). Turn off for a track that should stay put, e.g. a music bed." },
   volume: { type: "number", minimum: 0, maximum: 4, description: "Gain for every clip on it (1 = unchanged)." }
 };
 var ASSET_FIELDS = {
@@ -1660,6 +2275,32 @@ var ASSET_FIELDS = {
   hasAudio: { type: "boolean", description: "For video: whether it has sound (default true)." },
   poster: { type: "string", description: "For video: a still (URL) to show in rendered frames." }
 };
+var KEY_PROPERTY = {
+  type: "string",
+  enum: [...VIDEO_KEYFRAME_PROPERTIES],
+  description: "Which property: opacity (0\u20131), volume (media only, 0\u20134 gain), x / y (pixels from the frame's centre, right / down), scale (1 = fitted size) or rotation (degrees clockwise)."
+};
+var KEYS = {
+  type: "array",
+  minItems: 1,
+  maxItems: 500,
+  description: "The keys, replacing any the property had (any order, one per time). Before the first key the property holds the first value, after the last the last value.",
+  items: object(
+    {
+      t: { type: "number", description: "Time in ms from the clip's start (clip time, not timeline time: 0 is the clip's first frame, its duration the end). Keys stay with the clip when it moves, is trimmed or split." },
+      v: { type: "number", description: "The value at that time, in the property's units." },
+      ease: {
+        description: "How the value moves from this key to the next (default linear): linear, hold (stays, then jumps at the next key), ease-in, ease-out, ease-in-out, or CSS cubic-bezier points [x1, y1, x2, y2] with x1 and x2 in 0\u20131.",
+        anyOf: [
+          { type: "string", enum: [...VIDEO_EASE_NAMES] },
+          { type: "array", items: { type: "number" }, minItems: 4, maxItems: 4 }
+        ]
+      }
+    },
+    ["t", "v"],
+    "One keyframe."
+  )
+};
 var issueSummary = (issues) => ({
   errors: issues.filter((i) => i.severity === "error").length,
   warnings: issues.filter((i) => i.severity === "warning").length,
@@ -1683,6 +2324,7 @@ function describeVideoProject(project) {
       ...t.muted ? { muted: true } : {},
       ...t.hidden ? { hidden: true } : {},
       ...t.locked ? { locked: true } : {},
+      ...t.syncLocked === false ? { syncLocked: false } : {},
       ...t.volume !== void 0 ? { volume: t.volume } : {},
       clips: sortedVideoClips(t).map((c) => ({ ...c, end: videoClipEnd(c), ...c.type === "media" ? { source: videoClipSourceRange(c) } : {} }))
     })),
@@ -1711,6 +2353,17 @@ function createVideoEditorToolProvider(controller, options = {}) {
     }
     return null;
   };
+  const placed = (o) => ({
+    ...o.created?.length ? { created: o.created } : {},
+    ...o.trimmed?.length ? { trimmed: o.trimmed } : {},
+    ...o.removed?.length ? { removed: o.removed } : {},
+    ...o.rippled ? { rippled: o.rippled } : {}
+  });
+  const keysOut = (p, clip, property) => {
+    const c = clipOut(p, clip);
+    const value = VIDEO_TRANSFORM_PROPERTIES.includes(property) ? c?.transform?.[property] : c?.[property];
+    return typeof value === "object" ? { keys: value.keys } : { keys: [], value: value ?? null };
+  };
   const getProject = {
     name: "get_video_project",
     title: "Read the video project",
@@ -1748,7 +2401,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const checkProject = {
     name: "check_video_project",
     title: "Check the video project",
-    description: "Lists the project's problems, errors first, each with a code, the clip / track / asset it is about and how to fix it: missing assets, overlaps, clips past the end of their source, transitions without a cut or handles, fades longer than the clip, assets with no duration, unused assets.",
+    description: "Lists the project's problems, errors first, each with a code, the clip / track / asset it is about and how to fix it: missing assets, overlaps, clips past the end of their source, transitions without a cut or handles, fades longer than the clip, keyframes outside their clip, assets with no duration, unused assets.",
     inputSchema: object({}),
     annotations: { title: "Check the video project", ...READ },
     handler: () => {
@@ -1875,8 +2528,8 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const updateTrack = {
     name: "update_video_track",
     title: "Change a track",
-    description: "Renames, mutes, hides, locks or sets the volume of a track (one undo step). Returns the track's settings.",
-    inputSchema: object({ track: TRACK_ID, set: object(TRACK_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "muted", "hidden", "locked", "volume"] }, description: "Fields to clear." } }, ["track"]),
+    description: "Renames, mutes, hides, locks, sync-locks or sets the volume of a track (one undo step). Returns the track's settings.",
+    inputSchema: object({ track: TRACK_ID, set: object(TRACK_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "muted", "hidden", "locked", "syncLocked", "volume"] }, description: "Fields to clear." } }, ["track"]),
     annotations: { title: "Change a track", ...WRITE_IDEMPOTENT },
     handler: ({ track, set, remove }) => apply({ op: "update_track", track, set, remove }, "Change track", (r) => {
       const { clips, ...t } = r.project.tracks.find((x) => x.id === track);
@@ -1902,20 +2555,20 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const addClip = {
     name: "add_video_clip",
     title: "Add a clip",
-    description: 'Puts a clip on a track (one undo step): media (a stretch of an asset from its "in" point), a title or a colour. With no start it goes at the end of the track; with ripple it is inserted at "start", pushing later clips along; otherwise an overlap is refused with the next free place. Returns the clip with its end and source range.',
-    inputSchema: object({ track: TRACK_ID, clip: NEW_CLIP, ripple: RIPPLE }, ["track", "clip"]),
+    description: 'Puts a clip on a track (one undo step): media (a stretch of an asset from its "in" point), a title or a colour. With no start it goes at the end of the track. Where it lands on other clips, mode decides: refuse (default, with the next free place), overwrite (replace what is underneath) or insert (push later material along on every sync-locked track). Returns the clip with its end and source range, plus any clips it cut (created), trimmed or removed and the tracks it rippled.',
+    inputSchema: object({ track: TRACK_ID, clip: NEW_CLIP, mode: MODE, ripple: { type: "boolean", description: 'Same as mode "insert" (kept for older callers; default false).' } }, ["track", "clip"]),
     annotations: { title: "Add a clip", ...WRITE },
-    handler: ({ track, clip, ripple }) => apply({ op: "add_clip", track, clip, ripple }, "Add clip", (r) => ({ clip: clipOut(r.project, r.outcomes[0].clip) }))
+    handler: ({ track, clip, mode, ripple }) => apply({ op: "add_clip", track, clip, mode, ripple }, mode === "overwrite" ? "Overwrite clip" : mode === "insert" || ripple ? "Insert clip" : "Add clip", (r) => ({ clip: clipOut(r.project, r.outcomes[0].clip), ...placed(r.outcomes[0]) }))
   };
   const moveClip = {
     name: "move_video_clip",
     title: "Move a clip",
-    description: "Moves a clip to a new start and/or another track of the same kind (one undo step). Refused if it would overlap another clip, naming it and the next free place. Returns the clip.",
-    inputSchema: object({ clip: CLIP_ID, start: MS("New start on the timeline (default: unchanged)"), track: { ...TRACK_ID, description: "Track to move it to (default: its own)." } }, ["clip"]),
-    annotations: { title: "Move a clip", ...WRITE_IDEMPOTENT },
-    handler: ({ clip, start, track }) => {
+    description: "Moves a clip to a new start and/or another track of the same kind (one undo step), leaving a gap where it was. Where it lands on other clips, mode decides: refuse (default, naming the clip and the next free place), overwrite or insert. Returns the clip, plus any clips it cut (created), trimmed or removed and the tracks it rippled.",
+    inputSchema: object({ clip: CLIP_ID, start: MS("New start on the timeline (default: unchanged)"), track: { ...TRACK_ID, description: "Track to move it to (default: its own)." }, mode: MODE }, ["clip"]),
+    annotations: { title: "Move a clip", ...WRITE },
+    handler: ({ clip, start, track, mode }) => {
       if (start === void 0 && track === void 0) throw new Error('Give "start", "track" or both.');
-      return apply({ op: "move_clip", clip, start, track }, "Move clip", (r) => ({ clip: clipOut(r.project, clip) }));
+      return apply({ op: "move_clip", clip, start, track, mode }, mode === "overwrite" ? "Overwrite clip" : mode === "insert" ? "Insert clip" : "Move clip", (r) => ({ clip: clipOut(r.project, clip), ...placed(r.outcomes[0]) }));
     }
   };
   const trimClip = {
@@ -1924,7 +2577,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     description: 'Moves one edge of a clip to a timeline time (one undo step): "start" also moves its source in point, "end" its out point. Refused past the ends of the source (the error says how far it can go) or below one frame. With ripple the clip keeps its start and the later clips on the track move by the change, so no gap or overlap opens. Returns the clip.',
     inputSchema: object({ clip: CLIP_ID, edge: { type: "string", enum: ["start", "end"], description: "Which edge to move." }, to: MS("Where that edge goes on the timeline"), ripple: RIPPLE }, ["clip", "edge", "to"]),
     annotations: { title: "Trim a clip", ...WRITE_IDEMPOTENT },
-    handler: ({ clip, edge, to, ripple }) => apply({ op: "trim_clip", clip, edge, to, ripple }, "Trim clip", (r) => ({ clip: clipOut(r.project, clip) }))
+    handler: ({ clip, edge, to, ripple }) => apply({ op: "trim_clip", clip, edge, to, ripple }, ripple ? "Ripple trim" : "Trim clip", (r) => ({ clip: clipOut(r.project, clip), ...placed(r.outcomes[0]) }))
   };
   const splitClip = {
     name: "split_video_clip",
@@ -1937,10 +2590,13 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const deleteClips = {
     name: "delete_video_clips",
     title: "Delete clips",
-    description: "Removes clips (one undo step). With ripple the later clips on each track move up to close the gaps. Returns the ids removed.",
-    inputSchema: object({ clips: { type: "array", items: CLIP_ID, minItems: 1, description: "Clip ids." }, ripple: { type: "boolean", description: "Close the gaps they leave (default false)." } }, ["clips"]),
+    description: "Removes clips (one undo step). With ripple the later material moves up to close the gaps they leave: on every sync-locked track when they were on one (refused, naming the clip, if another sync-locked track has something in a gap), else on their own track. Returns the ids removed and the tracks rippled.",
+    inputSchema: object(
+      { clips: { type: "array", items: CLIP_ID, minItems: 1, description: "Clip ids." }, ripple: { type: "boolean", description: "Close the gaps they leave, on every sync-locked track (default false)." } },
+      ["clips"]
+    ),
     annotations: { title: "Delete clips", ...DESTRUCTIVE },
-    handler: ({ clips, ripple }) => apply({ op: "delete_clips", clips, ripple }, ripple ? "Ripple delete" : "Delete clips", () => ({ removed: clips }))
+    handler: ({ clips, ripple }) => apply({ op: "delete_clips", clips, ripple }, ripple ? "Ripple delete" : "Delete clips", (r) => ({ removed: clips, ...r.outcomes[0].rippled ? { rippled: r.outcomes[0].rippled } : {} }))
   };
   const updateClip = {
     name: "update_video_clip",
@@ -1973,6 +2629,82 @@ function createVideoEditorToolProvider(controller, options = {}) {
     annotations: { title: "Set a transition", ...WRITE_IDEMPOTENT },
     handler: ({ clip, transition }) => apply({ op: "set_transition", clip, transition }, transition ? "Set transition" : "Remove transition", (r) => ({ clip: clipOut(r.project, clip) }))
   };
+  const slipClip = {
+    name: "slip_video_clip",
+    title: "Slip a clip",
+    description: "Shows a different stretch of a video or audio clip's source without moving it on the timeline: its in and out points both move by delta (one undo step). Clamped to the media past either end, keeping what its transitions need. Returns the clip (with its new source range) and the delta applied.",
+    inputSchema: object({ clip: CLIP_ID, delta: DELTA("How far to move the source (positive shows later media)") }, ["clip", "delta"]),
+    annotations: { title: "Slip a clip", ...WRITE },
+    handler: ({ clip, delta }) => apply({ op: "slip_clip", clip, delta }, "Slip clip", (r) => ({ clip: clipOut(r.project, clip), delta: r.outcomes[0].delta }))
+  };
+  const rollEdit = {
+    name: "roll_video_edit",
+    title: "Roll a cut",
+    description: "Moves the cut between two clips that meet on one track (one undo step): the left one's out point and the right one's in point move together, so nothing else moves and no gap opens. Clamped to each clip's media and at least a frame of each. Returns both clips, the new cut time and the delta applied.",
+    inputSchema: object({ left: { ...CLIP_ID, description: "The clip before the cut (from get_video_project)." }, right: { ...CLIP_ID, description: 'The clip after the cut, starting where "left" ends.' }, delta: DELTA("How far to move the cut") }, ["left", "right", "delta"]),
+    annotations: { title: "Roll a cut", ...WRITE },
+    handler: ({ left, right, delta }) => apply({ op: "roll_edit", left, right, delta }, "Roll edit", (r) => {
+      const after = clipOut(r.project, right);
+      return { left: clipOut(r.project, left), right: after, cut: after.start, delta: r.outcomes[0].delta };
+    })
+  };
+  const slideClip = {
+    name: "slide_video_clip",
+    title: "Slide a clip",
+    description: "Moves a clip along its track keeping its content, trimming the clips either side so the stretch stays gapless (one undo step): the one before gets longer as the one after gets shorter, or the other way. Without a neighbour on one side it moves through the gap there. Clamped to the neighbours' media and at least a frame of each. Returns the clip, its neighbours and the delta applied.",
+    inputSchema: object({ clip: CLIP_ID, delta: DELTA("How far to move it") }, ["clip", "delta"]),
+    annotations: { title: "Slide a clip", ...WRITE },
+    handler: ({ clip, delta }) => apply({ op: "slide_clip", clip, delta }, "Slide clip", (r) => {
+      const ids = r.outcomes[0].clips;
+      const i = ids.indexOf(clip);
+      return { clip: clipOut(r.project, clip), ...i > 0 ? { before: clipOut(r.project, ids[0]) } : {}, ...i < ids.length - 1 ? { after: clipOut(r.project, ids[ids.length - 1]) } : {}, delta: r.outcomes[0].delta };
+    })
+  };
+  const rangeArgs = object({ from: MS("Start of the range on the timeline"), to: MS('End of the range on the timeline (after "from")'), tracks: RANGE_TRACKS }, ["from", "to"]);
+  const rangeOut = (o) => ({ removed: o.removed ?? [], trimmed: o.trimmed ?? [], created: o.created ?? [], ...o.rippled ? { rippled: o.rippled } : {} });
+  const liftRange = {
+    name: "lift_video_range",
+    title: "Lift a range",
+    description: "Empties a stretch of time on some or all tracks, leaving a gap (one undo step): clips inside are deleted, clips across an edge are trimmed to it, and a clip across both is cut in two. Returns the clips removed, trimmed and created (right-hand parts of cuts).",
+    inputSchema: rangeArgs,
+    annotations: { title: "Lift a range", ...DESTRUCTIVE },
+    handler: ({ from, to, tracks }) => apply({ op: "lift_range", from, to, tracks }, "Lift", (r) => rangeOut(r.outcomes[0]))
+  };
+  const extractRange = {
+    name: "extract_video_range",
+    title: "Extract a range",
+    description: 'Removes a stretch of time and closes it up (one undo step): like lift, then everything after it moves earlier by its length on those tracks and every sync-locked track. Refused, naming the clip, when a sync-locked track left out of "tracks" has something in the range. Returns the clips removed, trimmed and created and the tracks that moved.',
+    inputSchema: rangeArgs,
+    annotations: { title: "Extract a range", ...DESTRUCTIVE },
+    handler: ({ from, to, tracks }) => apply({ op: "extract_range", from, to, tracks }, "Extract", (r) => rangeOut(r.outcomes[0]))
+  };
+  const splitAt = {
+    name: "split_video_at",
+    title: "Cut across tracks",
+    description: "Cuts every clip that runs across a time on some or all tracks (a razor through the timeline), as one undo step. Each left part keeps its id, fade in and transition; each right part gets a new id and the fade out. Refused when no clip runs across that time. Returns the pairs { left, right }.",
+    inputSchema: object({ at: MS("Where to cut, on the timeline"), tracks: RANGE_TRACKS }, ["at"]),
+    annotations: { title: "Cut across tracks", ...WRITE },
+    handler: ({ at, tracks }) => apply({ op: "split_at", at, tracks }, "Split", (r) => {
+      const o = r.outcomes[0];
+      return { cuts: o.clips.map((left, i) => ({ left: clipOut(r.project, left), right: clipOut(r.project, o.created[i]) })) };
+    })
+  };
+  const setKeyframes = {
+    name: "set_video_keyframes",
+    title: "Animate a clip property",
+    description: "Animates one property of a clip with keyframes (one undo step), replacing any keys it had: opacity, volume, or the transform's x, y, scale and rotation. Times are clip time (ms from the clip's start), so a key at 0 is the clip's first frame; get_video_project gives each clip's duration. Plays in the preview, renders and the ffmpeg export. Returns the property's keys, sorted.",
+    inputSchema: object({ clip: CLIP_ID, property: KEY_PROPERTY, keys: KEYS }, ["clip", "property", "keys"]),
+    annotations: { title: "Animate a clip property", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, property, keys }) => apply({ op: "set_keyframes", clip, property, keys }, `Keyframe ${property}`, (r) => ({ clip, property, ...keysOut(r.project, clip, property) }))
+  };
+  const removeKeyframes = {
+    name: "remove_video_keyframes",
+    title: "Stop animating a clip property",
+    description: "Removes all of a property's keyframes (one undo step), leaving it at the value it had at the clip's start. Returns the remaining keys (none) and that value (null for the default).",
+    inputSchema: object({ clip: CLIP_ID, property: KEY_PROPERTY }, ["clip", "property"]),
+    annotations: { title: "Stop animating a clip property", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, property }) => apply({ op: "set_keyframes", clip, property, keys: null }, `Remove ${property} keyframes`, (r) => ({ clip, property, ...keysOut(r.project, clip, property) }))
+  };
   const closeGaps = {
     name: "close_video_gaps",
     title: "Close gaps",
@@ -1999,7 +2731,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
   };
   const EDIT_OP = {
     type: "object",
-    description: `One edit: { "op": one of ${VIDEO_EDIT_OPS.filter((o) => o !== "replace_project").join(", ")}, \u2026its fields }. Fields match the single tools: add_clip { track, clip, ripple }, move_clip { clip, start, track }, trim_clip { clip, edge, to, ripple }, split_clip { clip, at, id }, delete_clips { clips, ripple }, update_clip { clip, set, remove }, set_transition { clip, transition }, close_gaps { track, from }, add_asset { asset }, update_asset { asset, set, remove }, remove_asset { asset }, add_track { track: { kind, id, \u2026 }, at }, update_track { track, set, remove }, remove_track { track }, move_track { track, to }, add_marker { marker: { time, label } }, update_marker { marker, set }, remove_marker { marker }, set_settings { name, width, height, fps, background }.`,
+    description: `One edit: { "op": one of ${VIDEO_EDIT_OPS.filter((o) => o !== "replace_project").join(", ")}, \u2026its fields }. Fields match the single tools: add_clip { track, clip, mode, ripple }, move_clip { clip, start, track, mode }, trim_clip { clip, edge, to, ripple }, split_clip { clip, at, id }, delete_clips { clips, ripple }, update_clip { clip, set, remove }, set_transition { clip, transition }, set_keyframes { clip, property, keys (null removes) }, slip_clip { clip, delta }, roll_edit { left, right, delta }, slide_clip { clip, delta }, lift_range { from, to, tracks }, extract_range { from, to, tracks }, split_at { at, tracks }, close_gaps { track, from }, add_asset { asset }, update_asset { asset, set, remove }, remove_asset { asset }, add_track { track: { kind, id, \u2026 }, at }, update_track { track, set, remove }, remove_track { track }, move_track { track, to }, add_marker { marker: { time, label } }, update_marker { marker, set }, remove_marker { marker }, set_settings { name, width, height, fps, background }.`,
     properties: { op: { type: "string", enum: VIDEO_EDIT_OPS.filter((o) => o !== "replace_project"), description: "Which edit." } },
     required: ["op"]
   };
@@ -2040,7 +2772,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     }
   };
   const reads = [getProject, getFrame, findGaps, checkProject, renderFrame, exportFfmpeg, exportEdl, seek];
-  const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
+  const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return {
     id: options.id ?? "video",
     namespace: options.namespace,
@@ -2099,7 +2831,8 @@ function planVideoClipDrag(project, input) {
     const start = Math.max(0, raw + (shifts.length ? shifts.reduce((a, b) => Math.abs(b) < Math.abs(a) ? b : a) : 0));
     const target = input.track ?? track.id;
     const moved = Math.abs(start - clip.start) > 1e-6 || target !== track.id;
-    return { start, duration: clip.duration, track: target, edit: moved ? { op: "move_clip", clip: clip.id, start, ...target !== track.id ? { track: target } : {} } : null };
+    const mode = input.placement && input.placement !== "refuse" ? { mode: input.placement } : {};
+    return { start, duration: clip.duration, track: target, edit: moved ? { op: "move_clip", clip: clip.id, start, ...target !== track.id ? { track: target } : {}, ...mode } : null };
   }
   const minimum = 1e3 / project.fps;
   if (input.mode === "trim-start") {
@@ -2117,13 +2850,17 @@ function videoDropTracks(project, clipId) {
   if (!at) return [];
   return project.tracks.filter((t) => t.kind === at.track.kind && !t.locked).map((t) => t.id);
 }
+function videoDragLabel(edit) {
+  if (edit.op === "move_clip") return edit.mode === "insert" ? "Insert clip" : edit.mode === "overwrite" ? "Overwrite clip" : "Move clip";
+  return edit.op === "trim_clip" && edit.ripple ? "Ripple trim" : "Trim clip";
+}
 function videoAssetDropEdit(project, assetId, options = {}) {
   const asset = videoAssetMap(project).get(assetId);
   if (!asset) return null;
   const kind = asset.kind === "audio" ? "audio" : "video";
   const track = options.track ?? project.tracks.find((t) => t.kind === kind && !t.locked)?.id;
   if (!track) return null;
-  return { op: "add_clip", track, clip: { type: "media", asset: asset.id, ...options.start !== void 0 ? { start: options.start } : {} }, ...options.ripple ? { ripple: true } : {} };
+  return { op: "add_clip", track, clip: { type: "media", asset: asset.id, ...options.start !== void 0 ? { start: options.start } : {} }, ...options.ripple ? { ripple: true } : {}, ...options.mode && options.mode !== "refuse" ? { mode: options.mode } : {} };
 }
 function videoAssetKindOf(typeOrName) {
   const s = typeOrName.toLowerCase().replace(/[?#].*$/, "");
@@ -2162,14 +2899,86 @@ function probeVideoMedia(src, kind, timeout = 15e3) {
     el.src = src;
   });
 }
+var KEY_LABELS = {
+  opacity: { label: "Opacity", step: 0.05 },
+  volume: { label: "Volume", step: 0.05 },
+  x: { label: "X", step: 1 },
+  y: { label: "Y", step: 1 },
+  scale: { label: "Scale", step: 0.05 },
+  rotation: { label: "Rotation", step: 1 }
+};
+var animatableOf = (clip, property) => VIDEO_TRANSFORM_PROPERTIES.includes(property) ? clip.transform?.[property] : property === "volume" ? clip.type === "media" ? clip.volume : void 0 : clip.opacity;
+var playheadInClip = (clip, time) => Math.round(Math.min(clip.duration, Math.max(0, time - clip.start)));
+function videoKeyframeRows(project, clipId, time) {
+  const at = findVideoClip(project, clipId);
+  if (!at) return [];
+  const { clip } = at;
+  const asset = clip.type === "media" ? videoAssetMap(project).get(clip.asset) : void 0;
+  const visual = !(asset?.kind === "audio" || at.track.kind === "audio");
+  const audible = clip.type === "media" && (asset?.kind === "audio" || asset?.kind === "video" && asset.hasAudio !== false);
+  const properties = [...visual ? ["opacity"] : [], ...audible ? ["volume"] : [], ...visual ? VIDEO_TRANSFORM_PROPERTIES : []];
+  const clipTime = playheadInClip(clip, time);
+  return properties.map((property) => {
+    const prop = animatableOf(clip, property);
+    const keys = isVideoKeyframes(prop) ? prop.keys : [];
+    const limits = VIDEO_KEYFRAME_LIMITS[property];
+    return {
+      property,
+      ...KEY_LABELS[property],
+      value: Math.round(videoValueAt(prop, clipTime, limits.default) * 1e3) / 1e3,
+      keyed: keys.length > 0,
+      keys: keys.length,
+      onKey: keys.some((k) => Math.abs(k.t - clipTime) < 0.5),
+      clipTime,
+      ...limits.min !== void 0 ? { min: limits.min } : {},
+      ...limits.max !== void 0 ? { max: limits.max } : {}
+    };
+  });
+}
+function plainValueEdit(clip, property, value) {
+  if (!VIDEO_TRANSFORM_PROPERTIES.includes(property))
+    return value === void 0 ? { op: "update_clip", clip: clip.id, remove: [property] } : { op: "update_clip", clip: clip.id, set: { [property]: value } };
+  const transform = { ...clip.transform, [property]: value };
+  if (value === void 0) delete transform[property];
+  return Object.keys(transform).length ? { op: "update_clip", clip: clip.id, set: { transform } } : { op: "update_clip", clip: clip.id, remove: ["transform"] };
+}
+function videoKeyframeValueEdit(project, clipId, property, time, value) {
+  const at = findVideoClip(project, clipId);
+  if (!at) return null;
+  const prop = animatableOf(at.clip, property);
+  if (!isVideoKeyframes(prop)) return plainValueEdit(at.clip, property, value);
+  if (value === void 0) return null;
+  return { op: "set_keyframes", clip: clipId, property, keys: setVideoKey(prop, { t: playheadInClip(at.clip, time), v: value }, VIDEO_KEYFRAME_LIMITS[property].default).keys };
+}
+function videoKeyframeToggleEdit(project, clipId, property, time) {
+  const at = findVideoClip(project, clipId);
+  if (!at) return null;
+  const prop = animatableOf(at.clip, property);
+  const t = playheadInClip(at.clip, time);
+  const fallback = VIDEO_KEYFRAME_LIMITS[property].default;
+  if (isVideoKeyframes(prop)) {
+    const key = prop.keys.find((k) => Math.abs(k.t - t) < 0.5);
+    if (key) {
+      const rest = removeVideoKey(prop, key.t);
+      return isVideoKeyframes(rest) ? { op: "set_keyframes", clip: clipId, property, keys: rest.keys } : plainValueEdit(at.clip, property, rest === fallback ? void 0 : rest);
+    }
+  }
+  const v = videoValueAt(prop, t, fallback);
+  return { op: "set_keyframes", clip: clipId, property, keys: isVideoKeyframes(prop) ? setVideoKey(prop, { t, v }, fallback).keys : [{ t, v }] };
+}
 export {
   VIDEO_CLIP_TYPES,
   VIDEO_DEFAULT_STILL_DURATION,
   VIDEO_DEFAULT_TITLE_DURATION,
+  VIDEO_EASE_NAMES,
   VIDEO_EDIT_OPS,
   VIDEO_FITS,
   VIDEO_ISSUE_CODES,
+  VIDEO_KEYFRAME_LIMITS,
+  VIDEO_KEYFRAME_PROPERTIES,
+  VIDEO_PLACEMENT_MODES,
   VIDEO_TIME_EPSILON,
+  VIDEO_TRANSFORM_PROPERTIES,
   VIDEO_TRANSITION_TYPES,
   VIDEO_WIPE_DIRECTIONS,
   VideoEditorController,
@@ -2186,9 +2995,12 @@ export {
   findVideoGaps,
   formatVideoSeconds,
   formatVideoTimecode,
+  isVideoKeyframes,
   nextFreeVideoSlot,
+  parseVideoAnimatable,
   parseVideoAsset,
   parseVideoClip,
+  parseVideoKeyframes,
   parseVideoMarker,
   parseVideoProject,
   parseVideoTrack,
@@ -2197,9 +3009,14 @@ export {
   placeVideoRect,
   planVideoClipDrag,
   probeVideoMedia,
+  removeVideoKey,
+  retimeVideoAnimatable,
+  setVideoKey,
   snapToVideoFrame,
   snapVideoTime,
+  sortVideoKeys,
   sortedVideoClips,
+  splitVideoAnimatable,
   toVideoEdl,
   toVideoFfmpeg,
   videoAssetDropEdit,
@@ -2209,6 +3026,7 @@ export {
   videoClipBefore,
   videoClipEnd,
   videoClipHandles,
+  videoClipKeyframes,
   videoClipLabel,
   videoClipOverhang,
   videoClipSourceRange,
@@ -2216,12 +3034,21 @@ export {
   videoClipTint,
   videoClipsAt,
   videoContactSheetSvg,
+  videoDragLabel,
   videoDropTracks,
+  videoEaseBezier,
+  videoEaseProgress,
   videoFrameAt,
   videoFrameDuration,
   videoFrameToSvg,
   videoFrames,
   videoIssueKey,
+  videoKeyframeBreakpoints,
+  videoKeyframeFfmpegExpr,
+  videoKeyframeRows,
+  videoKeyframeToggleEdit,
+  videoKeyframeValueEdit,
+  videoKeysOf,
   videoOverlap,
   videoProjectDuration,
   videoProjectSvg,
@@ -2229,6 +3056,9 @@ export {
   videoSnapPoints,
   videoTextStyle,
   videoTitleFrame,
+  videoTrackSyncLocked,
+  videoTransformAt,
+  videoValueAt,
   videoWipeRect
 };
 //# sourceMappingURL=index.js.map