@pixerate/editor 0.77.0 → 0.79.0

package/dist/video-editor/index.js

@@ -17,6 +17,194 @@ var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe"];
 var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
 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 +234,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 +308,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 +322,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")
@@ -311,6 +532,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 +549,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 +585,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);
@@ -408,6 +648,7 @@ var VIDEO_EDIT_OPS = [
   "delete_clips",
   "update_clip",
   "set_transition",
+  "set_keyframes",
   "close_gaps",
   "add_marker",
   "update_marker",
@@ -426,6 +667,21 @@ 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 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 Editor = class {
   constructor(p) {
@@ -596,6 +852,7 @@ 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]));
@@ -633,6 +890,12 @@ var Editor = class {
         const right = { ...structuredClone(clip), id, start: e.at, duration: end - e.at };
         delete right.transition;
         delete right.fadeIn;
+        const leftValues = clipAnimatables(clip);
+        clipAnimatables(right).forEach((r, i) => {
+          const [l, rr] = splitVideoAnimatable(leftValues[i].get(), left);
+          if (isVideoKeyframes(l)) leftValues[i].set(l);
+          if (isVideoKeyframes(rr)) r.set(rr);
+        });
         if (clip.type === "media") {
           right.in = (clip.in ?? 0) + left * videoClipSpeed(clip);
         }
@@ -659,12 +922,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 +948,37 @@ var Editor = class {
         else clip.transition = parseVideoTransition(e.transition, "transition");
         return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
       }
+      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 +1056,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 +1070,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 +1121,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 +1140,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 +1363,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 +1394,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 +1412,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 +1456,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 +1473,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 +1500,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 = [
@@ -1604,7 +1937,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 +1946,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 = {
@@ -1660,6 +1993,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,
@@ -1711,6 +2070,11 @@ function createVideoEditorToolProvider(controller, options = {}) {
     }
     return null;
   };
+  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 +2112,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: () => {
@@ -1973,6 +2337,22 @@ 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 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 +2379,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, 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 }, set_keyframes { clip, property, keys (null removes) }, 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 +2420,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, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return {
     id: options.id ?? "video",
     namespace: options.namespace,
@@ -2162,14 +2542,85 @@ 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_TIME_EPSILON,
+  VIDEO_TRANSFORM_PROPERTIES,
   VIDEO_TRANSITION_TYPES,
   VIDEO_WIPE_DIRECTIONS,
   VideoEditorController,
@@ -2186,9 +2637,12 @@ export {
   findVideoGaps,
   formatVideoSeconds,
   formatVideoTimecode,
+  isVideoKeyframes,
   nextFreeVideoSlot,
+  parseVideoAnimatable,
   parseVideoAsset,
   parseVideoClip,
+  parseVideoKeyframes,
   parseVideoMarker,
   parseVideoProject,
   parseVideoTrack,
@@ -2197,9 +2651,14 @@ export {
   placeVideoRect,
   planVideoClipDrag,
   probeVideoMedia,
+  removeVideoKey,
+  retimeVideoAnimatable,
+  setVideoKey,
   snapToVideoFrame,
   snapVideoTime,
+  sortVideoKeys,
   sortedVideoClips,
+  splitVideoAnimatable,
   toVideoEdl,
   toVideoFfmpeg,
   videoAssetDropEdit,
@@ -2209,6 +2668,7 @@ export {
   videoClipBefore,
   videoClipEnd,
   videoClipHandles,
+  videoClipKeyframes,
   videoClipLabel,
   videoClipOverhang,
   videoClipSourceRange,
@@ -2217,11 +2677,19 @@ export {
   videoClipsAt,
   videoContactSheetSvg,
   videoDropTracks,
+  videoEaseBezier,
+  videoEaseProgress,
   videoFrameAt,
   videoFrameDuration,
   videoFrameToSvg,
   videoFrames,
   videoIssueKey,
+  videoKeyframeBreakpoints,
+  videoKeyframeFfmpegExpr,
+  videoKeyframeRows,
+  videoKeyframeToggleEdit,
+  videoKeyframeValueEdit,
+  videoKeysOf,
   videoOverlap,
   videoProjectDuration,
   videoProjectSvg,
@@ -2229,6 +2697,8 @@ export {
   videoSnapPoints,
   videoTextStyle,
   videoTitleFrame,
+  videoTransformAt,
+  videoValueAt,
   videoWipeRect
 };
 //# sourceMappingURL=index.js.map