@pixerate/editor 0.79.0 → 0.80.0

package/dist/video-editor/index.js

@@ -15,6 +15,7 @@ import "../chunk-AGR4P4UZ.js";
 var VIDEO_FITS = ["contain", "cover", "fill", "none"];
 var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe"];
 var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
+var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
 var VIDEO_CLIP_TYPES = ["media", "text", "color"];
 
 // src/video-editor/keyframes.ts
@@ -348,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}]`))
   });
@@ -411,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;
@@ -632,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",
@@ -648,6 +652,12 @@ 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",
@@ -667,6 +677,15 @@ 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 = [
@@ -683,6 +702,7 @@ function retimeClipKeys(clip, fn) {
   }
 }
 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;
@@ -714,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) {
@@ -726,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;
@@ -773,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 });
@@ -794,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));
@@ -811,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);
@@ -826,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);
@@ -854,8 +1021,17 @@ var Editor = class {
           }
           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}"`);
@@ -871,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 });
@@ -883,37 +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;
-        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);
-        }
-        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);
@@ -948,6 +1123,102 @@ 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);
@@ -1914,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)." },
@@ -1982,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 = {
@@ -2042,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) } : {} }))
     })),
@@ -2070,6 +2353,12 @@ 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];
@@ -2239,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);
@@ -2266,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 = {
@@ -2288,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",
@@ -2301,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",
@@ -2337,6 +2629,66 @@ 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",
@@ -2379,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 }, 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 }.`,
+    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"]
   };
@@ -2420,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, setKeyframes, removeKeyframes, 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,
@@ -2479,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") {
@@ -2497,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(/[?#].*$/, "");
@@ -2619,6 +2976,7 @@ export {
   VIDEO_ISSUE_CODES,
   VIDEO_KEYFRAME_LIMITS,
   VIDEO_KEYFRAME_PROPERTIES,
+  VIDEO_PLACEMENT_MODES,
   VIDEO_TIME_EPSILON,
   VIDEO_TRANSFORM_PROPERTIES,
   VIDEO_TRANSITION_TYPES,
@@ -2676,6 +3034,7 @@ export {
   videoClipTint,
   videoClipsAt,
   videoContactSheetSvg,
+  videoDragLabel,
   videoDropTracks,
   videoEaseBezier,
   videoEaseProgress,
@@ -2697,6 +3056,7 @@ export {
   videoSnapPoints,
   videoTextStyle,
   videoTitleFrame,
+  videoTrackSyncLocked,
   videoTransformAt,
   videoValueAt,
   videoWipeRect