@pixerate/editor 0.90.0 → 0.92.0

package/dist/video-editor/index.js

@@ -20,7 +20,7 @@ var VIDEO_BLEND_MODES = ["normal", "multiply", "screen", "overlay", "darken", "l
 var VIDEO_CLIP_ANIMATION_EFFECTS = ["fade", "rise", "drop", "slide-left", "slide-right", "zoom", "pop"];
 var VIDEO_FADE_CURVES = ["linear", "equal-power", "s-curve", "exponential", "logarithmic"];
 var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
-var VIDEO_CLIP_TYPES = ["media", "text", "color"];
+var VIDEO_CLIP_TYPES = ["media", "text", "color", "sequence"];
 
 // src/video-editor/keyframes.ts
 var VIDEO_EASE_NAMES = ["linear", "hold", "ease-in", "ease-out", "ease-in-out"];
@@ -852,12 +852,33 @@ function parseVideoAsset(v, path = "asset") {
     height: num(v.height, `${path}.height`, { optional: true, positive: true }),
     hasAudio: bool(v.hasAudio, `${path}.hasAudio`),
     poster: str(v.poster, `${path}.poster`, true),
-    transcript: parseVideoTranscriptWords(v.transcript, `${path}.transcript`)
+    transcript: parseVideoTranscriptWords(v.transcript, `${path}.transcript`),
+    proxies: parseVideoAssetProxies(v.proxies, `${path}.proxies`)
   });
+  if (kind !== "video" && asset.proxies) fail(`${path}.proxies`, "are only for video assets");
   if (kind === "image" && asset.transcript) fail(`${path}.transcript`, "is only for video and audio assets");
   if (kind === "image" && asset.duration !== void 0) fail(`${path}.duration`, "is only for video and audio assets");
   return asset;
 }
+function parseVideoAssetProxies(v, path) {
+  if (v === void 0) return void 0;
+  if (!Array.isArray(v)) return fail(path, "must be a list of { scale, src }");
+  const out = v.map((p, i) => {
+    const at = `${path}[${i}]`;
+    if (!isObject(p)) return fail(at, "must be an object { scale, src }");
+    const unknown = Object.keys(p).find((k) => !["scale", "src", "width", "height"].includes(k));
+    if (unknown) fail(`${at}.${unknown}`, "is not a proxy setting; use scale, src, width, height");
+    const scale = num(p.scale, `${at}.scale`, { positive: true });
+    if (scale >= 1) fail(`${at}.scale`, "must be less than 1 (0.5 is half size)");
+    return compact({ scale, src: str(p.src, `${at}.src`), width: num(p.width, `${at}.width`, { optional: true, positive: true }), height: num(p.height, `${at}.height`, { optional: true, positive: true }) });
+  });
+  const scales = /* @__PURE__ */ new Set();
+  for (const [i, p] of out.entries()) {
+    if (scales.has(p.scale)) fail(`${path}[${i}].scale`, `repeats ${p.scale}; give each proxy its own scale`);
+    scales.add(p.scale);
+  }
+  return out.length ? out : void 0;
+}
 function parseVideoClip(v, path = "clip") {
   if (!isObject(v)) return fail(path, "must be an object");
   const type = oneOf(v.type ?? "media", VIDEO_CLIP_TYPES, `${path}.type`, false);
@@ -890,6 +911,20 @@ function parseVideoClip(v, path = "clip") {
       fadeInCurve: oneOf(v.fadeInCurve, VIDEO_FADE_CURVES, `${path}.fadeInCurve`),
       fadeOutCurve: oneOf(v.fadeOutCurve, VIDEO_FADE_CURVES, `${path}.fadeOutCurve`)
     });
+  if (type === "sequence") {
+    for (const key of ["speed", "timeRemap"])
+      if (v[key] !== void 0 && !(key === "speed" && v[key] === 1)) fail(`${path}.${key}`, 'is not supported on a compound clip (type "sequence"), which plays its sequence at normal speed; remove it, or change the speed of the clips inside the sequence');
+    return compact({
+      type,
+      ...base,
+      sequence: str(v.sequence, `${path}.sequence`),
+      in: num(v.in, `${path}.in`, { optional: true, min: 0 }),
+      volume: parseVideoAnimatable(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
+      muted: bool(v.muted, `${path}.muted`),
+      fadeInCurve: oneOf(v.fadeInCurve, VIDEO_FADE_CURVES, `${path}.fadeInCurve`),
+      fadeOutCurve: oneOf(v.fadeOutCurve, VIDEO_FADE_CURVES, `${path}.fadeOutCurve`)
+    });
+  }
   if (type === "text")
     return compact({
       type,
@@ -918,6 +953,21 @@ function parseVideoTrack(v, path = "track") {
     clips: (v.clips ?? []).map((c, i) => parseVideoClip(c, `${path}.clips[${i}]`))
   });
 }
+function parseVideoSequence(v, path = "sequence") {
+  if (!isObject(v)) return fail(path, "must be an object { id, name, tracks }");
+  if (v.tracks !== void 0 && !Array.isArray(v.tracks)) fail(`${path}.tracks`, "must be an array");
+  const sequence = compact({
+    id: str(v.id, `${path}.id`),
+    name: str(v.name, `${path}.name`, true),
+    tracks: (v.tracks ?? []).map((t, i) => parseVideoTrack(t, `${path}.tracks[${i}]`))
+  });
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of sequence.tracks) {
+    if (seen.has(t.id)) throw new Error(`Two tracks in sequence "${sequence.id}" share the id "${t.id}"; ids must be unique.`);
+    seen.add(t.id);
+  }
+  return sequence;
+}
 function parseVideoMarker(v, path = "marker") {
   if (!isObject(v)) return fail(path, "must be an object");
   return compact({ id: str(v.id, `${path}.id`), time: num(v.time, `${path}.time`, { min: 0 }), label: str(v.label, `${path}.label`, true), color: str(v.color, `${path}.color`, true) });
@@ -933,7 +983,7 @@ function parseVideoProject(input) {
   }
   if (!isObject(v)) return fail("The project", "must be an object");
   if (v.version !== void 0 && v.version !== 1) fail("version", "must be 1");
-  for (const key of ["assets", "tracks", "markers"]) if (v[key] !== void 0 && !Array.isArray(v[key])) fail(key, "must be an array");
+  for (const key of ["assets", "tracks", "sequences", "markers"]) if (v[key] !== void 0 && !Array.isArray(v[key])) fail(key, "must be an array");
   const project = compact({
     version: 1,
     name: str(v.name, "name", true),
@@ -943,6 +993,7 @@ function parseVideoProject(input) {
     background: str(v.background, "background", true),
     assets: (v.assets ?? []).map((a, i) => parseVideoAsset(a, `assets[${i}]`)),
     tracks: (v.tracks ?? []).map((t, i) => parseVideoTrack(t, `tracks[${i}]`)),
+    sequences: v.sequences === void 0 ? void 0 : v.sequences.map((q, i) => parseVideoSequence(q, `sequences[${i}]`)),
     markers: v.markers === void 0 ? void 0 : v.markers.map((m, i) => parseVideoMarker(m, `markers[${i}]`))
   });
   const unique = (ids, what) => {
@@ -954,7 +1005,8 @@ function parseVideoProject(input) {
   };
   unique(project.assets.map((a) => a.id), "assets");
   unique(project.tracks.map((t) => t.id), "tracks");
-  unique(project.tracks.flatMap((t) => t.clips.map((c) => c.id)), "clips");
+  unique((project.sequences ?? []).map((q) => q.id), "sequences");
+  unique([...project.tracks, ...(project.sequences ?? []).flatMap((q) => q.tracks)].flatMap((t) => t.clips.map((c) => c.id)), "clips");
   unique((project.markers ?? []).map((m) => m.id), "markers");
   return project;
 }
@@ -980,6 +1032,7 @@ 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 === "sequence") return { in: clip.in ?? 0, out: (clip.in ?? 0) + clip.duration };
   if (clip.type !== "media") return null;
   const start = clip.in ?? 0;
   if (clip.timeRemap?.keys.length) return { in: start + clip.timeRemap.keys[0].v, out: start + clip.timeRemap.keys[clip.timeRemap.keys.length - 1].v };
@@ -1029,6 +1082,33 @@ var videoAssetHasSound = (asset) => !!asset && (asset.kind === "audio" || asset.
 function videoAssetMap(project) {
   return new Map(project.assets.map((a) => [a.id, a]));
 }
+function videoSequenceMap(project) {
+  return new Map((project.sequences ?? []).map((q) => [q.id, q]));
+}
+function videoSequenceDuration(sequence) {
+  let end = 0;
+  for (const track of sequence.tracks) for (const clip of track.clips) end = Math.max(end, videoClipEnd(clip));
+  return end;
+}
+var videoSequenceChildren = (sequence) => [...new Set(sequence.tracks.flatMap((t) => t.clips.flatMap((c) => c.type === "sequence" ? [c.sequence] : [])))];
+function findVideoSequenceCycle(project, id) {
+  const sequences = videoSequenceMap(project);
+  const walk = (at, path) => {
+    const seq = sequences.get(at);
+    if (!seq) return null;
+    for (const child of videoSequenceChildren(seq)) {
+      if (child === id) return [...path, child];
+      if (path.includes(child)) continue;
+      const found = walk(child, [...path, child]);
+      if (found) return found;
+    }
+    return null;
+  };
+  return walk(id, [id]);
+}
+function allVideoTracks(project) {
+  return [...project.tracks.map((track) => ({ track })), ...(project.sequences ?? []).flatMap((q) => q.tracks.map((track) => ({ sequence: q.id, track })))];
+}
 function sortedVideoClips(track) {
   return [...track.clips].sort((a, b) => a.start - b.start || a.duration - b.duration);
 }
@@ -1041,7 +1121,15 @@ function findVideoClip(project, id) {
   return null;
 }
 function allVideoClipIds(project) {
-  return project.tracks.flatMap((t) => t.clips.map((c) => c.id));
+  return allVideoTracks(project).flatMap(({ track }) => track.clips.map((c) => c.id));
+}
+function findVideoSequenceClip(project, id) {
+  for (const sequence of project.sequences ?? [])
+    for (const track of sequence.tracks) {
+      const clip = track.clips.find((c) => c.id === id);
+      if (clip) return { sequence, track, clip };
+    }
+  return null;
 }
 function videoProjectDuration(project) {
   let end = 0;
@@ -1057,7 +1145,12 @@ function videoClipAfter(track, clip) {
   for (const c of track.clips) if (c !== clip && Math.abs(c.start - videoClipEnd(clip)) <= VIDEO_TIME_EPSILON) return c;
   return null;
 }
-function videoClipHandles(clip, assets) {
+function videoClipHandles(clip, assets, sequences) {
+  if (clip.type === "sequence") {
+    const seq = sequences?.get(clip.sequence);
+    const range2 = videoClipSourceRange(clip);
+    return { before: range2.in, after: seq ? Math.max(0, videoSequenceDuration(seq) - range2.out) : Infinity };
+  }
   if (clip.type !== "media") return { before: Infinity, after: Infinity };
   const asset = assets.get(clip.asset);
   const speed = videoClipSpeed(clip);
@@ -1189,13 +1282,15 @@ function videoClipAnimated(clip, project) {
 function videoClipKeyframes(clip) {
   const out = [
     { property: "opacity", keys: videoKeysOf(clip.opacity) },
-    { property: "volume", keys: clip.type === "media" ? videoKeysOf(clip.volume) : [] },
+    { property: "volume", keys: clip.type === "media" || clip.type === "sequence" ? 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",
+  "missing-sequence",
+  "sequence-cycle",
   "wrong-track",
   "overlap",
   "source-overrun",
@@ -1208,23 +1303,41 @@ var VIDEO_ISSUE_CODES = [
   "keyframes-outside-clip",
   "unknown-duration",
   "unused-asset",
+  "unused-sequence",
   "marker-past-end",
   "empty"
 ];
-var videoIssueKey = (i) => [i.code, i.track ?? "", i.clip ?? "", i.asset ?? "", i.marker ?? ""].join("|");
+var videoIssueKey = (i) => [i.code, i.sequence ?? "", i.track ?? "", i.clip ?? "", i.asset ?? "", i.marker ?? ""].join("|");
 function checkVideoProject(project) {
   const issues = [];
   const assets = videoAssetMap(project);
+  const sequences = videoSequenceMap(project);
   const used = /* @__PURE__ */ new Set();
+  const usedSequences = /* @__PURE__ */ new Set();
+  const cycles = /* @__PURE__ */ new Map();
   for (const asset of project.assets)
     if ((asset.kind === "video" || asset.kind === "audio") && asset.duration === void 0)
       issues.push({ code: "unknown-duration", severity: "warning", asset: asset.id, message: `Asset "${asset.id}" has no duration, so clips of it cannot be checked against its length; set "duration" in ms.` });
-  for (const track of project.tracks) {
+  const checkTrack = (track, sequence) => {
     const clips = sortedVideoClips(track);
+    const where = sequence ? ` in sequence "${sequence}"` : "";
     for (let i = 0; i < clips.length; i++) {
       const clip = clips[i];
-      const at = { track: track.id, clip: clip.id };
-      if (clip.type === "media") {
+      const at = { ...sequence ? { sequence } : {}, track: track.id, clip: clip.id };
+      if (clip.type === "sequence") {
+        usedSequences.add(clip.sequence);
+        const seq = sequences.get(clip.sequence);
+        if (!seq) issues.push({ code: "missing-sequence", severity: "error", ...at, message: `Compound clip "${clip.id}" plays sequence "${clip.sequence}", which is not in the project; add the sequence or delete the clip.` });
+        else {
+          if (!cycles.has(seq.id)) cycles.set(seq.id, findVideoSequenceCycle(project, seq.id));
+          const cycle = cycles.get(seq.id);
+          if (cycle) issues.push({ code: "sequence-cycle", severity: "error", ...at, message: `Compound clip "${clip.id}" plays sequence "${seq.id}", which contains itself (${cycle.join(" \u2192 ")}), so it is left out of the picture and sound; remove the compound clip that closes the loop.` });
+          const length = videoSequenceDuration(seq);
+          const range = videoClipSourceRange(clip);
+          if (range.out > length + VIDEO_TIME_EPSILON)
+            issues.push({ code: "source-overrun", severity: "error", ...at, message: `Compound clip "${clip.id}" plays to ${formatVideoSeconds(range.out)} of sequence "${seq.id}", which is only ${formatVideoSeconds(length)} long; shorten the clip or move its in point.` });
+        }
+      } else if (clip.type === "media") {
         used.add(clip.asset);
         const asset = assets.get(clip.asset);
         if (!asset) issues.push({ code: "missing-asset", severity: "error", ...at, asset: clip.asset, message: `Clip "${clip.id}" plays asset "${clip.asset}", which is not in the project; add the asset or delete the clip.` });
@@ -1238,7 +1351,7 @@ function checkVideoProject(project) {
       } else if (track.kind === "audio") issues.push({ code: "wrong-track", severity: "error", ...at, message: `Clip "${clip.id}" is a ${clip.type} clip on audio track "${track.id}"; move it to a video track.` });
       const next = clips[i + 1];
       if (next && next.start < videoClipEnd(clip) - VIDEO_TIME_EPSILON)
-        issues.push({ code: "overlap", severity: "error", ...at, message: `Clips "${clip.id}" and "${next.id}" overlap on track "${track.id}" from ${formatVideoSeconds(next.start)}; move one of them.` });
+        issues.push({ code: "overlap", severity: "error", ...at, message: `Clips "${clip.id}" and "${next.id}" overlap on track "${track.id}"${where} from ${formatVideoSeconds(next.start)}; move one of them.` });
       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.` });
       const anim = (clip.animateIn ? clip.animateIn.duration ?? VIDEO_CLIP_ANIMATION_DURATION : 0) + (clip.animateOut ? clip.animateOut.duration ?? VIDEO_CLIP_ANIMATION_DURATION : 0);
@@ -1273,8 +1386,8 @@ function checkVideoProject(project) {
           continue;
         }
         if (clip.transition.type === "dip") continue;
-        const outgoing = videoClipHandles(before, assets).after;
-        const incoming = videoClipHandles(clip, assets).before;
+        const outgoing = videoClipHandles(before, assets, sequences).after;
+        const incoming = videoClipHandles(clip, assets, sequences).before;
         const half = d / 2;
         if (outgoing < half - VIDEO_TIME_EPSILON || incoming < half - VIDEO_TIME_EPSILON) {
           const fits = 2 * Math.min(outgoing, incoming);
@@ -1287,7 +1400,11 @@ function checkVideoProject(project) {
         }
       }
     }
-  }
+  };
+  for (const track of project.tracks) checkTrack(track);
+  for (const sequence of project.sequences ?? []) for (const track of sequence.tracks) checkTrack(track, sequence.id);
+  for (const sequence of project.sequences ?? [])
+    if (!usedSequences.has(sequence.id)) issues.push({ code: "unused-sequence", severity: "note", sequence: sequence.id, message: `Sequence "${sequence.id}" is not played by any compound clip.` });
   for (const asset of project.assets) if (!used.has(asset.id)) issues.push({ code: "unused-asset", severity: "note", asset: asset.id, message: `Asset "${asset.id}" is not used by any clip.` });
   const end = videoProjectDuration(project);
   for (const marker of project.markers ?? [])
@@ -1383,6 +1500,8 @@ var Editor = class {
   }
   clip(id) {
     const at = findVideoClip(this.p, id);
+    const nested = at ? null : findVideoSequenceClip(this.p, id);
+    if (nested) refuse(`Clip "${id}" is inside sequence "${nested.sequence.id}", and clips inside sequences cannot be edited yet; edit the compound clip that plays the sequence instead (list_video_sequences shows which).`);
     if (!at) {
       const ids = this.p.tracks.flatMap((t) => t.clips.map((c) => c.id));
       refuse(`There is no clip ${namedWithSuggestion(id, ids)}${ids.length ? "" : "; the project has no clips yet"}.`);
@@ -1406,6 +1525,11 @@ var Editor = class {
   }
   kindFits(track, clip) {
     const asset = clip.type === "media" ? this.asset(clip.asset) : null;
+    if (clip.type === "sequence") {
+      const ids = (this.p.sequences ?? []).map((q) => q.id);
+      if (typeof clip.sequence !== "string" || !ids.includes(clip.sequence)) refuse(`There is no sequence ${namedWithSuggestion(String(clip.sequence), ids)}; the sequences are ${ids.map((q) => `"${q}"`).join(", ") || "none"}.`);
+      return;
+    }
     if (track.kind === "audio" && (clip.type !== "media" || asset.kind === "image")) refuse(`Track "${track.id}" is an audio track; ${clip.type === "media" ? "images" : `${clip.type} clips`} go on a video track.`);
     if (track.kind === "video" && asset?.kind === "audio") refuse(`Track "${track.id}" is a video track; audio asset "${asset.id}" goes on an audio track.`);
   }
@@ -1419,7 +1543,7 @@ var Editor = class {
     return 1e3 / this.p.fps;
   }
   ids() {
-    return this.p.tracks.flatMap((t) => t.clips.map((c) => c.id));
+    return allVideoClipIds(this.p);
   }
   /**
    * The tracks a ripple on `sources` moves, top to bottom: the sources, and every unlocked
@@ -1447,8 +1571,13 @@ var Editor = class {
   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). */
+  /** Moves a media or compound clip's in point by `delta` of timeline time (stills, titles and colours have none). */
   moveIn(clip, delta) {
+    if (clip.type === "sequence") {
+      clip.in = Math.max(0, (clip.in ?? 0) + delta);
+      if (clip.in < 1e-9) delete clip.in;
+      return;
+    }
     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;
@@ -1476,7 +1605,7 @@ var Editor = class {
     clip.duration = at - clip.start;
     delete clip.fadeOut;
     delete clip.animateOut;
-    if (clip.type === "media") delete clip.fadeOutCurve;
+    if (clip.type === "media" || clip.type === "sequence") delete clip.fadeOutCurve;
     track.clips.push(right);
     track.clips.sort((a, b) => a.start - b.start);
     return right;
@@ -1598,7 +1727,7 @@ var Editor = class {
       }
       case "remove_asset": {
         const asset = this.asset(e.asset);
-        const users = this.p.tracks.flatMap((t) => t.clips.filter((c) => c.type === "media" && c.asset === asset.id).map((c) => c.id));
+        const users = allVideoTracks(this.p).flatMap(({ track: t }) => t.clips.filter((c) => c.type === "media" && c.asset === asset.id).map((c) => c.id));
         if (users.length) refuse(`Asset "${asset.id}" is used by clip${users.length > 1 ? "s" : ""} ${users.map((u) => `"${u}"`).join(", ")}; delete ${users.length > 1 ? "them" : "it"} first.`);
         this.p.assets = this.p.assets.filter((a) => a !== asset);
         return this.outcomes.push({ op: e.op, asset: asset.id });
@@ -1640,7 +1769,7 @@ var Editor = class {
         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));
+        const ids = this.ids();
         if (draft.id !== void 0 && ids.includes(draft.id)) refuse(`There is already a clip "${draft.id}".`);
         draft.id ??= freshId("c", ids);
         if (draft.duration === void 0) {
@@ -1650,6 +1779,10 @@ var Editor = class {
             else if (asset.duration === void 0) refuse(`Asset "${asset.id}" has no duration, so give the clip a "duration".`);
             else draft.duration = (asset.duration - (draft.in ?? 0)) / (draft.speed ?? 1);
             if (!(draft.duration > 0)) refuse(`"in" (${draft.in} ms) is at or past the end of "${asset.id}" (${asset.duration} ms).`);
+          } else if (draft.type === "sequence") {
+            const length = videoSequenceDuration(videoSequenceMap(this.p).get(draft.sequence)) - (draft.in ?? 0);
+            if (!(length > 0)) refuse(`"in" (${draft.in ?? 0} ms) is at or past the end of sequence "${draft.sequence}".`);
+            draft.duration = length;
           } else draft.duration = VIDEO_DEFAULT_TITLE_DURATION;
         }
         const end = sortedVideoClips(track).reduce((m, c) => Math.max(m, videoClipEnd(c)), 0);
@@ -1684,7 +1817,7 @@ var Editor = class {
         if (e.edge === "start") {
           const delta = e.to - clip.start;
           if (clip.duration - delta < minimum - VIDEO_TIME_EPSILON) refuse(`Trimming the start to ${formatVideoSeconds(e.to)} would leave "${clip.id}" shorter than a frame; it ends at ${formatVideoSeconds(end)}.`);
-          if (clip.type === "media" && !isRamped(clip)) {
+          if (clip.type === "media" && !isRamped(clip) || clip.type === "sequence") {
             const sourceIn = (clip.in ?? 0) + delta * speed;
             if (sourceIn < -VIDEO_TIME_EPSILON) refuse(`"${clip.id}" starts ${Math.round((clip.in ?? 0) / speed)} ms into its source, so its start can move at most that far earlier (to ${formatVideoSeconds(clip.start - (clip.in ?? 0) / speed)}).`);
             clip.in = Math.max(0, sourceIn);
@@ -1718,6 +1851,11 @@ 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 (clip.type === "sequence") {
+            const seq = videoSequenceMap(this.p).get(clip.sequence);
+            const length = seq ? videoSequenceDuration(seq) : Infinity;
+            if ((clip.in ?? 0) + duration > length + VIDEO_TIME_EPSILON) refuse(`"${clip.id}" can end at most at ${formatVideoSeconds(clip.start + length - (clip.in ?? 0))}, where sequence "${clip.sequence}" ends.`);
+          }
           if (e.ripple) {
             const tracks = this.rippleTracks([track]);
             let created = [];
@@ -1792,6 +1930,7 @@ var Editor = class {
       case "set_time_remap": {
         const { track, clip } = this.clip(e.clip);
         this.unlocked(track);
+        if (clip.type === "sequence") refuse(`Clip "${clip.id}" is a compound clip, which plays its sequence at normal speed; ramp the clips inside the sequence instead.`);
         if (clip.type !== "media") refuse(`Clip "${clip.id}" is a ${clip.type === "text" ? "title" : "colour"}, so it has no source to ramp; only video and audio clips change speed.`);
         const asset = this.asset(clip.asset);
         if (asset.kind === "image") refuse(`Clip "${clip.id}" is a still ("${asset.id}"), so it has no motion to ramp.`);
@@ -1849,16 +1988,16 @@ var Editor = class {
       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));
+        if (clip.type !== "media" && clip.type !== "sequence") refuse(`Clip "${clip.id}" is a ${clip.type === "text" ? "title" : "colour"}, so it has no source to slip; only video, audio and compound clips slip.`);
+        const source = clip.type === "sequence" ? `sequence "${clip.sequence}"` : `"${this.asset(clip.asset).id}"`;
+        if (clip.type === "media" && this.asset(clip.asset).kind === "image") refuse(`Clip "${clip.id}" is a still ("${clip.asset}"), so it has no source to slip; only video and audio clips slip.`);
+        const handles = videoClipHandles(clip, videoAssetMap(this.p), videoSequenceMap(this.p));
         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).`
+          () => e.delta > 0 ? `"${clip.id}" already plays to the end of ${source}${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 ${source}${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 });
@@ -1876,8 +2015,8 @@ var Editor = class {
           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 lo = Math.max(-(L.duration - this.frame), -(videoClipHandles(R, assets, videoSequenceMap(this.p)).before - videoClipOverhang(track, R).lead));
+        const hi = Math.min(R.duration - this.frame, videoClipHandles(L, assets, videoSequenceMap(this.p)).after - videoClipOverhang(track, L).tail);
         const delta = this.clamp(
           e.delta,
           lo,
@@ -1903,8 +2042,8 @@ var Editor = class {
           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 lo = -Math.min(room.earlier, after ? videoClipHandles(after, assets, videoSequenceMap(this.p)).before - videoClipOverhang(track, after).lead : Infinity);
+        const hi = Math.min(room.later, before ? videoClipHandles(before, assets, videoSequenceMap(this.p)).after - videoClipOverhang(track, before).tail : Infinity);
         const delta = this.clamp(
           e.delta,
           lo,
@@ -1946,7 +2085,7 @@ var Editor = class {
         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.`);
+        if (e.property === "volume" && clip.type !== "media" && clip.type !== "sequence") refuse(`Clip "${clip.id}" is a ${clip.type} clip and has no volume; volume keys go on media and compound clips.`);
         const limits = VIDEO_KEYFRAME_LIMITS[e.property];
         const transform = VIDEO_TRANSFORM_PROPERTIES.includes(e.property);
         const c = clip;
@@ -2097,13 +2236,13 @@ function videoFadeCurveGain(curve, x) {
 }
 function fadeGain(clip, time, sound = false) {
   let g = 1;
-  const shape = sound && clip.type === "media" ? clip : void 0;
+  const shape = sound && (clip.type === "media" || clip.type === "sequence") ? clip : void 0;
   if (clip.fadeIn) g *= videoFadeCurveGain(shape?.fadeInCurve, (time - clip.start) / clip.fadeIn);
   if (clip.fadeOut) g *= videoFadeCurveGain(shape?.fadeOutCurve, (videoClipEnd(clip) - time) / clip.fadeOut);
   return g;
 }
 function videoClipSoundGain(clip, clipTime) {
-  const volume = clip.type === "media" ? videoValueAt(clip.volume, clipTime, 1) : 1;
+  const volume = clip.type === "media" || clip.type === "sequence" ? videoValueAt(clip.volume, clipTime, 1) : 1;
   return volume * fadeGain(clip, clip.start + Math.min(Math.max(clipTime, 0), clip.duration), true);
 }
 function activeOnTrack(track, time) {
@@ -2123,11 +2262,15 @@ function activeOnTrack(track, time) {
 }
 var sourceTimeAt = (clip, time) => clip.type === "media" ? videoClipSourceTime(clip, time - clip.start) : 0;
 function videoFrameAt(project, time) {
-  const assets = videoAssetMap(project);
+  const { layers, audio } = tracksAt(project, project.tracks, time, { assets: videoAssetMap(project), sequences: videoSequenceMap(project), within: [], prefix: "" });
+  return { time, width: project.width, height: project.height, background: project.background ?? "#000000", layers, audio };
+}
+function tracksAt(project, tracks, time, scope) {
+  const { assets, prefix } = scope;
   const layers = [];
   const audio = [];
-  for (let ti = project.tracks.length - 1; ti >= 0; ti--) {
-    const track = project.tracks[ti];
+  for (let ti = tracks.length - 1; ti >= 0; ti--) {
+    const track = tracks[ti];
     for (const { clip, incoming, outgoing } of activeOnTrack(track, time)) {
       if (incoming?.type === "dip" && incoming.progress < 0.5) continue;
       if (outgoing?.type === "dip" && outgoing.progress >= 0.5) continue;
@@ -2136,15 +2279,26 @@ function videoFrameAt(project, time) {
       const level = (t, transition, into) => videoFadeCurveGain(videoTransitionAudioCurve(transition), t.type === "dip" ? Math.abs(1 - 2 * t.progress) : into ? t.progress : 1 - t.progress);
       const mix = (incoming ? level(incoming, incoming.transition, true) : 1) * (outgoing ? level(outgoing, outgoing.next.transition, false) : 1);
       const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
-      const sourceTime = sourceTimeAt(clip, time);
+      const sourceTime = clip.type === "sequence" ? (clip.in ?? 0) + time - clip.start : sourceTimeAt(clip, time);
       const clipTime = time - clip.start;
+      let nested = null;
+      if (clip.type === "sequence") {
+        const seq = scope.sequences.get(clip.sequence);
+        if (!seq || scope.within.includes(seq.id)) continue;
+        nested = tracksAt(project, seq.tracks, sourceTime, { ...scope, within: [...scope.within, seq.id], prefix: `${prefix}${clip.id}/` });
+      }
       const audible = videoAssetHasSound(asset);
       if (audible && clip.type === "media" && !clip.muted && !track.muted) {
         const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fadeGain(clip, inside, true) * mix;
-        audio.push({ clip: clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeedAt(clip, clipTime) });
+        audio.push({ clip: prefix + clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeedAt(clip, clipTime) });
+      }
+      if (nested && clip.type === "sequence" && !clip.muted && !track.muted) {
+        const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fadeGain(clip, inside, true) * mix;
+        for (const a of nested.audio) audio.push({ ...a, gain: a.gain * gain });
       }
       if (track.kind !== "video" || track.hidden) continue;
       if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
+      if (nested && !nested.layers.length) continue;
       const shown = videoClipAnimated(clip, project);
       let opacity = videoValueAt(shown.opacity, clipTime, 1) * fade;
       let wipe;
@@ -2167,25 +2321,29 @@ function videoFrameAt(project, time) {
         shift = videoTransitionEase(outgoing.progress);
       }
       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 fit = clip.fit ?? (clip.type === "media" || clip.type === "sequence" ? "contain" : "fill");
       const placed = placeVideoRect(project, size, clip.type === "text" ? "fill" : fit, shown.transform, clipTime);
       const across = shiftDirection === "left" || shiftDirection === "right";
       const sign = shiftDirection === "left" || shiftDirection === "up" ? -1 : 1;
       const rect = shift ? { ...placed, ...across ? { x: placed.x + sign * shift * project.width } : { y: placed.y + sign * shift * project.height } } : placed;
-      const layer = { clip: clip.id, track: track.id, type: clip.type, opacity: clamp012(opacity), rect, rotation: videoValueAt(shown.transform?.rotation, clipTime, 0) };
+      const layer = { clip: prefix + clip.id, track: track.id, type: clip.type, opacity: clamp012(opacity), rect, rotation: videoValueAt(shown.transform?.rotation, clipTime, 0) };
       if (wipe) layer.wipe = wipe;
       if (iris) layer.iris = iris;
       if (clip.blend && clip.blend !== "normal") layer.blend = clip.blend;
       const grade = normalizeVideoGrade(clip.grade);
       if (grade) layer.grade = grade;
       if (clip.type === "media") Object.assign(layer, { asset: asset.id, assetKind: asset.kind, src: asset.src, sourceTime });
+      if (clip.type === "sequence") Object.assign(layer, { sequence: clip.sequence, sourceTime, layers: nested.layers });
       if (clip.type === "text") layer.text = videoTextStyle(clip);
       if (clip.type === "color") layer.color = clip.color;
       if (layer.opacity > 0) layers.push(layer);
-      if (dip && dip.opacity > 0) layers.push({ clip: `transition:${incoming ? clip.id : outgoing.next.id}`, track: track.id, type: "color", color: dip.color, opacity: clamp012(dip.opacity), rect: { x: 0, y: 0, width: project.width, height: project.height }, rotation: 0 });
+      if (dip && dip.opacity > 0) layers.push({ clip: `transition:${prefix}${incoming ? clip.id : outgoing.next.id}`, track: track.id, type: "color", color: dip.color, opacity: clamp012(dip.opacity), rect: { x: 0, y: 0, width: project.width, height: project.height }, rotation: 0 });
     }
   }
-  return { time, width: project.width, height: project.height, background: project.background ?? "#000000", layers, audio };
+  return { layers, audio };
+}
+function videoFrameLeafLayers(layers) {
+  return layers.flatMap((l) => l.layers ? videoFrameLeafLayers(l.layers) : [l]);
 }
 
 // src/video-editor/audio.ts
@@ -2946,6 +3104,7 @@ function videoWordAt(words, time) {
 // src/video-editor/render.ts
 var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 var n = (v) => String(Math.round(v * 100) / 100);
+var n4 = (v) => String(Math.round(v * 1e4) / 1e4);
 var videoIrisRadius = (frame, progress) => progress * Math.hypot(frame.width / 2, frame.height / 2);
 function videoWipeRect(rect, wipe) {
   const { direction, progress } = wipe;
@@ -2958,13 +3117,16 @@ function videoWipeRect(rect, wipe) {
 }
 function videoFrameToSvg(frame, options = {}, assets = []) {
   const defs = [];
-  const body = [];
   const posters = new Map(assets.map((a) => [a.id, a.poster]));
-  frame.layers.forEach((layer, i) => {
+  const draw = (layers, prefix) => layers.map((layer, index) => {
+    const i = `${prefix}${index}`;
     const { rect } = layer;
     const attrs = [];
+    const style = [];
     if (layer.opacity < 1) attrs.push(`opacity="${n(layer.opacity)}"`);
-    if (layer.blend) attrs.push(`style="mix-blend-mode:${layer.blend === "add" ? "plus-lighter" : layer.blend}"`);
+    if (layer.blend) style.push(`mix-blend-mode:${layer.blend === "add" ? "plus-lighter" : layer.blend}`);
+    if (layer.layers) style.push("isolation:isolate");
+    if (style.length) attrs.push(`style="${style.join(";")}"`);
     if (layer.grade) {
       defs.push(videoGradeSvgFilter(`g${i}`, layer.grade, layer.grade.lut ? options.lutFor?.(layer.grade.lut.src) : null));
       attrs.push(`filter="url(#g${i})"`);
@@ -2977,7 +3139,9 @@ function videoFrameToSvg(frame, options = {}, assets = []) {
     }
     const box = `x="${n(rect.x)}" y="${n(rect.y)}" width="${n(rect.width)}" height="${n(rect.height)}"`;
     let inner = "";
-    if (layer.type === "color") inner = `<rect ${box} fill="${esc(layer.color ?? "#000000")}"/>`;
+    if (layer.layers) {
+      inner = `<g transform="translate(${n(rect.x)} ${n(rect.y)}) scale(${n4(rect.width / frame.width)} ${n4(rect.height / frame.height)})">${draw(layer.layers, `${i}-`)}</g>`;
+    } else if (layer.type === "color") inner = `<rect ${box} fill="${esc(layer.color ?? "#000000")}"/>`;
     else if (layer.type === "text" && layer.text) {
       const t = layer.text;
       const lines = t.text.split("\n");
@@ -3005,9 +3169,10 @@ function videoFrameToSvg(frame, options = {}, assets = []) {
       defs.push(`<clipPath id="i${i}"><circle cx="${n(frame.width / 2)}" cy="${n(frame.height / 2)}" r="${n(videoIrisRadius(frame, layer.iris.progress))}"/></clipPath>`);
       item = `<g clip-path="url(#i${i})">${item}</g>`;
     }
-    body.push(item);
-  });
-  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(frame.width)} ${n(frame.height)}" width="${n(frame.width)}" height="${n(frame.height)}">${defs.length ? `<defs>${defs.join("")}</defs>` : ""}<rect width="100%" height="100%" fill="${esc(frame.background)}"/>${body.join("")}</svg>`;
+    return item;
+  }).join("");
+  const body = draw(frame.layers, "");
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(frame.width)} ${n(frame.height)}" width="${n(frame.width)}" height="${n(frame.height)}">${defs.length ? `<defs>${defs.join("")}</defs>` : ""}<rect width="100%" height="100%" fill="${esc(frame.background)}"/>${body}</svg>`;
 }
 function videoProjectSvg(project, time, options = {}) {
   return videoFrameToSvg(videoFrameAt(project, time), { fps: project.fps, ...options }, project.assets);
@@ -3091,13 +3256,36 @@ function drawVideoFrame(ctx, frame, sourceFor, scale = 1, options = {}) {
   ctx.globalAlpha = 1;
   ctx.fillStyle = frame.background;
   ctx.fillRect(0, 0, frame.width, frame.height);
+  drawVideoLayers(ctx, frame, frame.layers, sourceFor, scale, options, 0);
+  ctx.restore();
+}
+function drawVideoLayers(ctx, frame, layers, sourceFor, scale, options, depth) {
   const cw = Math.max(1, Math.round(frame.width * scale));
   const ch = Math.max(1, Math.round(frame.height * scale));
-  for (const layer of frame.layers) {
+  for (const layer of layers) {
+    let source = sourceFor;
+    if (layer.layers) {
+      const group = options.scratch?.(cw, ch, 2 * depth);
+      if (!group) {
+        drawVideoLayers(ctx, frame, layer.layers, sourceFor, scale, options, depth + 1);
+        continue;
+      }
+      const g = group.ctx;
+      g.save();
+      g.setTransform(1, 0, 0, 1, 0, 0);
+      g.clearRect(0, 0, cw, ch);
+      g.setTransform(scale, 0, 0, scale, 0, 0);
+      g.globalAlpha = 1;
+      g.globalCompositeOperation = "source-over";
+      drawVideoLayers(g, frame, layer.layers, sourceFor, scale, options, depth + 1);
+      g.restore();
+      source = (l) => l === layer ? group.canvas : sourceFor(l);
+    }
     const setting = layer.grade?.lut;
     const lut = setting ? options.lutFor?.(setting.src) : null;
-    const scratch = lut ? options.scratch?.(cw, ch) : null;
+    const scratch = lut ? options.scratch?.(cw, ch, 2 * depth + 1) : null;
     ctx.save();
+    ctx.setTransform(scale, 0, 0, scale, 0, 0);
     if (lut && scratch) {
       const s = scratch.ctx;
       s.save();
@@ -3106,7 +3294,7 @@ function drawVideoFrame(ctx, frame, sourceFor, scale = 1, options = {}) {
       s.setTransform(scale, 0, 0, scale, 0, 0);
       s.globalAlpha = 1;
       s.globalCompositeOperation = "source-over";
-      paintVideoLayer(s, frame, layer, sourceFor, options);
+      paintVideoLayer(s, frame, layer, source, options);
       s.restore();
       const img = s.getImageData(0, 0, cw, ch);
       applyVideoLutToPixels(lut, img.data, setting.strength ?? 1);
@@ -3118,11 +3306,10 @@ function drawVideoFrame(ctx, frame, sourceFor, scale = 1, options = {}) {
     } else {
       ctx.globalAlpha = layer.opacity;
       if (layer.blend && layer.blend !== "normal") ctx.globalCompositeOperation = layer.blend === "add" ? "lighter" : layer.blend;
-      paintVideoLayer(ctx, frame, layer, sourceFor, options);
+      paintVideoLayer(ctx, frame, layer, source, options);
     }
     ctx.restore();
   }
-  ctx.restore();
 }
 
 // src/video-editor/export.ts
@@ -3164,6 +3351,7 @@ function toVideoEdl(project, options = {}) {
     if (clip.type === "media") lines.push(`* FROM CLIP NAME: ${asset?.name ?? asset?.src ?? clip.asset}`);
     if (clip.type === "text") lines.push(`* TITLE: ${clip.text.replace(/\n/g, " ")}`);
     if (clip.type === "color") lines.push(`* COLOR: ${clip.color}`);
+    if (clip.type === "sequence") lines.push(`* COMPOUND CLIP: ${clip.name ?? clip.sequence} (sequence ${clip.sequence} from ${tc(clip.in ?? 0)}, not flattened)`);
     lines.push("");
   }
   return lines.join("\n");
@@ -3219,7 +3407,7 @@ var color = (c) => {
   const h = hex[1].length === 3 ? [...hex[1]].map((x) => x + x).join("") : hex[1];
   return `0x${h.slice(0, 6)}${h.length === 8 ? `@${(parseInt(h.slice(6), 16) / 255).toFixed(3)}` : ""}`;
 };
-var shellQuote = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
+var videoShellQuote = (s) => /^[\w@%+=:,./-]+$/.test(s) ? s : `'${s.replace(/'/g, `'\\''`)}'`;
 function atempo(speed) {
   const out = [];
   let s = speed;
@@ -3243,6 +3431,7 @@ function toVideoLoudnessMeasure(project, options = {}) {
 function buildFfmpeg(project, options, measure) {
   const notes = [];
   const assets = videoAssetMap(project);
+  const sequences = videoSequenceMap(project);
   const D = videoProjectDuration(project);
   if (D <= 0) throw new Error("The project has no clips, so there is nothing to render.");
   const W = even(project.width);
@@ -3250,8 +3439,6 @@ function buildFfmpeg(project, options, measure) {
   const fps = project.fps;
   const inputs = [];
   const graph = measure ? [] : [`color=c=${color(project.background ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(D)},format=yuva420p[base]`];
-  const audio = [];
-  let cur = "base";
   let usesDrawtext = false;
   const animated = /* @__PURE__ */ new Set();
   const ramped = /* @__PURE__ */ new Set();
@@ -3275,7 +3462,7 @@ function buildFfmpeg(project, options, measure) {
     const pts = videoTimeRemapBreakpoints(remap, Math.max(80, 2e3 / fps));
     const first = pts[0];
     const last = pts[pts.length - 1];
-    const n2 = audio.length;
+    const n2 = ak;
     const fmtA = "aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo";
     const silence = (ms) => `anullsrc=r=48000:cl=stereo,atrim=duration=${sec(ms)},${fmtA}`;
     const pieces = [];
@@ -3324,180 +3511,228 @@ function buildFfmpeg(project, options, measure) {
     } else inputs.push(["-ss", sec((clip.in ?? 0) - lead * speed), "-t", sec(span * speed), "-i", src]);
     return inputs.length - 1;
   };
-  for (const track of [...project.tracks].reverse()) {
-    for (const raw of sortedVideoClips(track)) {
-      const clip = videoClipAnimated(raw, project);
-      const { lead, tail } = videoClipOverhang(track, clip);
-      const t0 = clip.start - lead;
-      const span = clip.duration + lead + tail;
-      const end = videoClipEnd(clip);
-      const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
-      if (clip.type === "media" && !asset) {
-        notes.push(`Clip "${clip.id}" was left out: its asset "${clip.asset}" is missing.`);
-        continue;
-      }
-      let index;
-      if (!measure && asset && asset.kind !== "audio" && track.kind === "video" && !track.hidden) index = input(clip, asset, lead, tail);
-      const audible = videoAssetHasSound(asset);
-      if (audible && clip.type === "media" && !clip.muted && !track.muted) {
-        const ai = index ?? input(clip, asset, lead, tail);
-        const trackGain = track.volume ?? 1;
-        const volume = isVideoKeyframes(clip.volume) ? `volume='${trackGain}*(${expr(clip.volume, `(t*1000${lead ? `-${Math.round(lead)}` : ""})`, 1, "volume")})':eval=frame` : `volume=${(clip.volume ?? 1) * trackGain}`;
-        let source2 = `[${ai}:a]`;
-        if (clip.timeRemap) {
-          source2 = `[r${audio.length}]`;
-          graph.push(...rampedSound(clip.timeRemap, `${ai}:a`, source2, lead, clip.duration + tail));
-          ramped.add("sound");
+  let ak = 0;
+  let q = 0;
+  const compose = (tracks, base, length, scope) => {
+    let cur2 = base;
+    const sounds = [];
+    for (const track of [...tracks].reverse()) {
+      for (const raw of sortedVideoClips(track)) {
+        const clip = videoClipAnimated(raw, project);
+        const { lead, tail } = videoClipOverhang(track, clip);
+        const t0 = clip.start - lead;
+        const span = clip.duration + lead + tail;
+        const end = videoClipEnd(clip);
+        const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
+        if (clip.type === "media" && !asset) {
+          notes.push(`Clip "${clip.id}" was left out: its asset "${clip.asset}" is missing.`);
+          continue;
         }
-        const chain2 = [...clip.timeRemap ? [] : ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip))], volume];
-        const before2 = clip.transition ? videoClipBefore(track, clip) : null;
-        const next2 = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition);
-        const inCurve = clip.transition ? afadeCurve(videoTransitionAudioCurve(clip.transition)) : "";
-        const outCurve = next2 ? afadeCurve(videoTransitionAudioCurve(next2.transition)) : "";
-        if (lead) chain2.push(`afade=t=in:st=0:d=${sec(2 * lead)}${inCurve}`);
-        if (tail) chain2.push(`afade=t=out:st=${sec(span - 2 * tail)}:d=${sec(2 * tail)}${outCurve}`);
-        if (before2 && clip.transition.type === "dip") chain2.push(`afade=t=in:st=0:d=${sec(clip.transition.duration / 2)}${inCurve}`);
-        if (next2?.transition.type === "dip") chain2.push(`afade=t=out:st=${sec(span - next2.transition.duration / 2)}:d=${sec(next2.transition.duration / 2)}${outCurve}`);
-        if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}${afadeCurve(clip.fadeInCurve)}`);
-        if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}${afadeCurve(clip.fadeOutCurve)}`);
-        chain2.push(`adelay=${Math.round(t0)}:all=1`);
-        graph.push(`${source2}${chain2.join(",")}[a${audio.length}]`);
-        audio.push(`[a${audio.length}]`);
-      }
-      if (measure || 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(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 = 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 shows = scope.picture && track.kind === "video" && !track.hidden;
+        let compound = null;
+        if (clip.type === "sequence") {
+          const seq = sequences.get(clip.sequence);
+          if (!seq || scope.within.includes(seq.id)) {
+            notes.push(`Compound clip "${clip.id}" was left out: its sequence "${clip.sequence}" ${seq ? "contains itself" : "is missing"}.`);
+            continue;
+          }
+          const from = (clip.in ?? 0) - lead;
+          if (from < -0.5) notes.push(`Compound clip "${clip.id}"'s transition needs ${Math.round(-from)} ms of sequence "${seq.id}" before its start, which is not there; it shows nothing then.`);
+          const length2 = Math.max(videoSequenceDuration(seq), from + span);
+          const hears = scope.sound && !clip.muted && !track.muted;
+          const n2 = q++;
+          const nestedBase = shows ? `nb${n2}` : null;
+          if (nestedBase) graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(length2)},format=yuva420p[${nestedBase}]`);
+          const sub = compose(seq.tracks, nestedBase, length2, { within: [...scope.within, seq.id], picture: shows, sound: hears });
+          compound = { picture: null, sound: null };
+          if (sub.video) {
+            graph.push(`[${sub.video}]trim=start=${sec(Math.max(0, from))}:duration=${sec(span)},setpts=PTS-STARTPTS[sq${n2}]`);
+            compound.picture = `[sq${n2}]`;
+          }
+          if (sub.audio.length) {
+            graph.push(`${sub.audio.join("")}amix=inputs=${sub.audio.length}:normalize=0:duration=longest,apad,atrim=start=${sec(Math.max(0, from))}:end=${sec(from + span)}[sm${n2}]`);
+            compound.sound = `[sm${n2}]`;
+          }
+        }
+        let index;
+        if (shows && asset && asset.kind !== "audio") index = input(clip, asset, lead, tail);
+        const audible = clip.type === "sequence" ? !!compound?.sound : videoAssetHasSound(asset);
+        if (scope.sound && audible && (clip.type === "media" || clip.type === "sequence") && !clip.muted && !track.muted) {
+          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 ramp = clip.type === "media" ? clip.timeRemap : void 0;
+          const ai = compound ? -1 : index ?? input(clip, asset, lead, tail);
+          let source2 = compound?.sound ?? `[${ai}:a]`;
+          if (ramp) {
+            source2 = `[r${ak}]`;
+            graph.push(...rampedSound(ramp, `${ai}:a`, source2, lead, clip.duration + tail));
+            ramped.add("sound");
+          }
+          const chain2 = [...ramp ? [] : ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip))], volume];
+          const before2 = clip.transition ? videoClipBefore(track, clip) : null;
+          const next2 = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition);
+          const inCurve = clip.transition ? afadeCurve(videoTransitionAudioCurve(clip.transition)) : "";
+          const outCurve = next2 ? afadeCurve(videoTransitionAudioCurve(next2.transition)) : "";
+          if (lead) chain2.push(`afade=t=in:st=0:d=${sec(2 * lead)}${inCurve}`);
+          if (tail) chain2.push(`afade=t=out:st=${sec(span - 2 * tail)}:d=${sec(2 * tail)}${outCurve}`);
+          if (before2 && clip.transition.type === "dip") chain2.push(`afade=t=in:st=0:d=${sec(clip.transition.duration / 2)}${inCurve}`);
+          if (next2?.transition.type === "dip") chain2.push(`afade=t=out:st=${sec(span - next2.transition.duration / 2)}:d=${sec(next2.transition.duration / 2)}${outCurve}`);
+          if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}${afadeCurve(clip.fadeInCurve)}`);
+          if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}${afadeCurve(clip.fadeOutCurve)}`);
+          chain2.push(`adelay=${Math.round(t0)}:all=1`);
+          graph.push(`${source2}${chain2.join(",")}[a${ak}]`);
+          sounds.push(`[a${ak++}]`);
+        }
+        if (!shows || compound && !compound.picture) 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(moving ? { ...clip, transform: void 0 } : clip, { width: project.width, height: project.height })]);
+          index = inputs.length - 1;
+        } else if (clip.type === "text") {
+          usesDrawtext = true;
+          if (scope.within.length) notes.push(`Title "${clip.id}" is inside a compound clip and drawn with drawtext, which leaves the sequence's transparent areas transparent, so it shows only over pictures in the sequence; pass titleImage to draw it anywhere.`);
+          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 base2 = `(${axis === "x" ? "w-text_w" : "h-text_h"})/2`;
+            return isVideoKeyframes(v) ? `${axis}='${base2}+(${expr(v, onTimeline, 0, "position")})'` : `${axis}=${base2}+${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")}`,
+            isVideoKeyframes(tf?.scale) ? `fontsize='${fontSize}*(${expr(tf.scale, onTimeline, 1, "scale")})'` : `fontsize=${Math.round(fontSize * (tf?.scale ?? 1))}`,
+            `fontcolor=${color(clip.color ?? "#ffffff")}`,
+            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 (tf?.rotation) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
+          if (videoGradeFfmpegFilters(clip.grade).length || normalizeVideoGradeLut(clip.grade?.lut)) notes.push(`Title "${clip.id}" is drawn without its grade (drawtext draws straight onto the picture); pass titleImage to grade titles.`);
+          if (clip.blend && clip.blend !== "normal") notes.push(`Title "${clip.id}" is drawn without its blend mode (drawtext draws straight onto the picture); pass titleImage to blend titles.`);
+          graph.push(`[${cur2}]drawtext=${opts.join(":")}[${next}]`);
+          cur2 = next;
+          continue;
+        }
+        const size = asset ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
+        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" || clip.type === "sequence" ? "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)}`;
+        else if (compound?.picture) {
+          source = compound.picture;
+          chain.push(`scale=${even(rect.width)}:${even(rect.height)}`);
+        } else {
+          source = `[${index}:v]`;
+          if (clip.type === "media" && clip.timeRemap) chain.push(...rampedPicture(clip.timeRemap, lead, clip.duration + tail), `scale=${even(rect.width)}:${even(rect.height)}`);
+          else chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
+        }
+        const grade = videoGradeFfmpegFilters(clip.grade);
+        if (grade.length) chain.push("format=rgba", ...grade);
+        const lut = normalizeVideoGradeLut(clip.grade?.lut);
+        if (lut) {
+          chain.push("format=gbrap");
+          const path = options.resolveLut ? options.resolveLut(lut.src) : lut.src;
+          if (/^(blob|data|https?):/i.test(path)) notes.push(`ffmpeg's lut3d reads only local files, and clip "${clip.id}"'s LUT is "${path.slice(0, 80)}"; save it and pass resolveLut to give its path.`);
+          const file = ffmpegFilterValue(path);
+          const into2 = `q${next}`;
+          graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[${into2}]`);
+          const lut3d = `lut3d=file=${file}:interp=tetrahedral`;
+          if ((lut.strength ?? 1) >= 1) graph.push(`[${into2}]${lut3d}[r${next}]`);
+          else graph.push(`[${into2}]split[o${next}][p${next}]`, `[p${next}]${lut3d}[s${next}]`, `[s${next}][o${next}]blend=all_mode=normal:all_opacity=${lut.strength}[r${next}]`);
+          source = `[r${next}]`;
+          chain.length = 0;
+        }
+        chain.push("format=yuva420p");
+        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`);
+        if (lead && clip.transition.type === "wipe") {
+          const d = sec(2 * lead);
+          const p = `min(1,T/${d})`;
+          const dir = clip.transition.direction ?? "right";
+          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 (lead && clip.transition.type === "iris") {
+          const r = videoIrisRadius({ width: W, height: H }, 1);
+          chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(lte(hypot(X+${Math.round(rect.x)}-${W / 2},Y+${Math.round(rect.y)}-${H / 2}),${Math.round(r)}*min(1,T/${sec(2 * lead)})),alpha(X,Y),0)'`);
+        }
+        const rotation = placed?.rotation;
+        if (isVideoKeyframes(rotation)) chain.push(`rotate=a='(${expr(rotation, onChain("t"), 0, "rotation")})*PI/180':c=black@0:ow='hypot(iw,ih)':oh=ow`);
+        else if (rotation) chain.push(`rotate=${rotation}*PI/180:c=black@0:ow=rotw(${rotation}*PI/180):oh=roth(${rotation}*PI/180)`);
+        if (isVideoKeyframes(placed?.scale)) {
+          const s = expr(placed.scale, onChain("t"), 1, "scale");
+          chain.push(`scale=w='max(2,trunc(iw*(${s})/2)*2)':h='max(2,trunc(ih*(${s})/2)*2)':eval=frame`);
+        }
+        chain.push(`setpts=PTS+${sec(t0)}/TB`);
+        const cx = rect.x + rect.width / 2;
+        const cy = rect.y + rect.height / 2;
+        const shifts = { x: [], y: [] };
+        const shiftBy = (direction, from, d, entering) => {
+          const dir = direction ?? "right";
+          const axis = dir === "left" || dir === "right" ? "x" : "y";
+          const size2 = axis === "x" ? W : H;
+          const sign = dir === "left" || dir === "up" ? -1 : 1;
+          const ease = `(1-cos(PI*clip((t-${sec(from)})/${sec(d)},0,1)))/2`;
+          shifts[axis].push(`${sign * size2}*(${ease}${entering ? "-1" : ""})`);
         };
-        const fontSize = clip.fontSize ?? 64;
-        const opts = [
-          `text=${ffmpegFilterValue(clip.text)}`,
-          options.fontFile ? `fontfile=${ffmpegFilterValue(options.fontFile)}` : `font=${ffmpegFilterValue(clip.fontFamily ?? "sans-serif")}`,
-          isVideoKeyframes(tf?.scale) ? `fontsize='${fontSize}*(${expr(tf.scale, onTimeline, 1, "scale")})'` : `fontsize=${Math.round(fontSize * (tf?.scale ?? 1))}`,
-          `fontcolor=${color(clip.color ?? "#ffffff")}`,
-          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 (tf?.rotation) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
-        if (videoGradeFfmpegFilters(clip.grade).length || normalizeVideoGradeLut(clip.grade?.lut)) notes.push(`Title "${clip.id}" is drawn without its grade (drawtext draws straight onto the picture); pass titleImage to grade titles.`);
-        if (clip.blend && clip.blend !== "normal") notes.push(`Title "${clip.id}" is drawn without its blend mode (drawtext draws straight onto the picture); pass titleImage to blend titles.`);
-        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 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)}`;
-      else {
-        source = `[${index}:v]`;
-        if (clip.type === "media" && clip.timeRemap) chain.push(...rampedPicture(clip.timeRemap, lead, clip.duration + tail), `scale=${even(rect.width)}:${even(rect.height)}`);
-        else chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
-      }
-      const grade = videoGradeFfmpegFilters(clip.grade);
-      if (grade.length) chain.push("format=rgba", ...grade);
-      const lut = normalizeVideoGradeLut(clip.grade?.lut);
-      if (lut) {
-        chain.push("format=gbrap");
-        const path = options.resolveLut ? options.resolveLut(lut.src) : lut.src;
-        if (/^(blob|data|https?):/i.test(path)) notes.push(`ffmpeg's lut3d reads only local files, and clip "${clip.id}"'s LUT is "${path.slice(0, 80)}"; save it and pass resolveLut to give its path.`);
-        const file = ffmpegFilterValue(path);
-        const into2 = `q${next}`;
-        graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[${into2}]`);
-        const lut3d = `lut3d=file=${file}:interp=tetrahedral`;
-        if ((lut.strength ?? 1) >= 1) graph.push(`[${into2}]${lut3d}[r${next}]`);
-        else graph.push(`[${into2}]split[o${next}][p${next}]`, `[p${next}]${lut3d}[s${next}]`, `[s${next}][o${next}]blend=all_mode=normal:all_opacity=${lut.strength}[r${next}]`);
-        source = `[r${next}]`;
-        chain.length = 0;
-      }
-      chain.push("format=yuva420p");
-      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`);
-      if (lead && clip.transition.type === "wipe") {
-        const d = sec(2 * lead);
-        const p = `min(1,T/${d})`;
-        const dir = clip.transition.direction ?? "right";
-        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 (lead && clip.transition.type === "iris") {
-        const r = videoIrisRadius({ width: W, height: H }, 1);
-        chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(lte(hypot(X+${Math.round(rect.x)}-${W / 2},Y+${Math.round(rect.y)}-${H / 2}),${Math.round(r)}*min(1,T/${sec(2 * lead)})),alpha(X,Y),0)'`);
-      }
-      const rotation = placed?.rotation;
-      if (isVideoKeyframes(rotation)) chain.push(`rotate=a='(${expr(rotation, onChain("t"), 0, "rotation")})*PI/180':c=black@0:ow='hypot(iw,ih)':oh=ow`);
-      else if (rotation) chain.push(`rotate=${rotation}*PI/180:c=black@0:ow=rotw(${rotation}*PI/180):oh=roth(${rotation}*PI/180)`);
-      if (isVideoKeyframes(placed?.scale)) {
-        const s = expr(placed.scale, onChain("t"), 1, "scale");
-        chain.push(`scale=w='max(2,trunc(iw*(${s})/2)*2)':h='max(2,trunc(ih*(${s})/2)*2)':eval=frame`);
-      }
-      chain.push(`setpts=PTS+${sec(t0)}/TB`);
-      const cx = rect.x + rect.width / 2;
-      const cy = rect.y + rect.height / 2;
-      const shifts = { x: [], y: [] };
-      const shiftBy = (direction, from, d, entering) => {
-        const dir = direction ?? "right";
-        const axis = dir === "left" || dir === "right" ? "x" : "y";
-        const size2 = axis === "x" ? W : H;
-        const sign = dir === "left" || dir === "up" ? -1 : 1;
-        const ease = `(1-cos(PI*clip((t-${sec(from)})/${sec(d)},0,1)))/2`;
-        shifts[axis].push(`${sign * size2}*(${ease}${entering ? "-1" : ""})`);
-      };
-      const into = lead ? clip.transition.type : void 0;
-      if (into === "push" || into === "slide") shiftBy(clip.transition.direction, clip.start - lead, 2 * lead, true);
-      const after = tail ? sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition) : void 0;
-      if (after?.transition.type === "push") shiftBy(after.transition.direction, end - tail, 2 * tail, false);
-      const at = (axis, c) => {
-        const v = placed?.[axis];
-        const extra = shifts[axis].map((s) => `+${s}`).join("");
-        return isVideoKeyframes(v) ? `${axis}='${Math.round(axis === "x" ? project.width / 2 : project.height / 2)}+(${expr(v, onTimeline, 0, "position")})-${axis === "x" ? "w" : "h"}/2${extra}'` : `${axis}='${Math.round(c)}-${axis === "x" ? "w" : "h"}/2${extra}'`;
-      };
-      graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[l${next}]`);
-      if (clip.blend && clip.blend !== "normal") {
-        graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(D)},format=yuva420p[t${next}]`);
-        graph.push(`[t${next}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable},format=gbrap,split[f${next}][g${next}]`);
-        graph.push(`[${cur}]format=gbrap,split[c${next}][d${next}]`);
-        const layerFirst = clip.blend === "color-dodge" || clip.blend === "color-burn";
-        graph.push(`${layerFirst ? `[f${next}][c${next}]` : `[c${next}][f${next}]`}blend=all_mode=${FFMPEG_BLEND[clip.blend]}[b${next}]`);
-        graph.push(`[g${next}]alphaextract[m${next}]`);
-        graph.push(`[b${next}][m${next}]alphamerge[x${next}]`);
-        graph.push(`[d${next}][x${next}]overlay=format=gbrp,format=yuva420p[${next}]`);
-        blended.add(clip.blend);
-      } else 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") {
-        const d = clip.transition.duration;
-        const dip = `d${k}`;
-        graph.push(`color=c=${color(clip.transition.color ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(d)},format=yuva420p,fade=t=in:st=0:d=${sec(d / 2)}:alpha=1,fade=t=out:st=${sec(d / 2)}:d=${sec(d / 2)}:alpha=1,setpts=PTS+${sec(clip.start - d / 2)}/TB[l${dip}]`);
-        graph.push(`[${cur}][l${dip}]overlay=eof_action=pass:enable='between(t,${sec(clip.start - d / 2)},${sec(clip.start + d / 2)})'[${dip}]`);
-        cur = dip;
+        const into = lead ? clip.transition.type : void 0;
+        if (into === "push" || into === "slide") shiftBy(clip.transition.direction, clip.start - lead, 2 * lead, true);
+        const after = tail ? sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition) : void 0;
+        if (after?.transition.type === "push") shiftBy(after.transition.direction, end - tail, 2 * tail, false);
+        const at = (axis, c) => {
+          const v = placed?.[axis];
+          const extra = shifts[axis].map((s) => `+${s}`).join("");
+          return isVideoKeyframes(v) ? `${axis}='${Math.round(axis === "x" ? project.width / 2 : project.height / 2)}+(${expr(v, onTimeline, 0, "position")})-${axis === "x" ? "w" : "h"}/2${extra}'` : `${axis}='${Math.round(c)}-${axis === "x" ? "w" : "h"}/2${extra}'`;
+        };
+        graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[l${next}]`);
+        if (clip.blend && clip.blend !== "normal") {
+          graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(length)},format=yuva420p[t${next}]`);
+          const clear = scope.within.length > 0;
+          graph.push(`[t${next}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable},format=gbrap,split${clear ? `=3` : ""}[f${next}][g${next}]${clear ? `[h${next}]` : ""}`);
+          graph.push(`[${cur2}]format=gbrap,split${clear ? `=3` : ""}[c${next}][d${next}]${clear ? `[e${next}]` : ""}`);
+          const layerFirst = clip.blend === "color-dodge" || clip.blend === "color-burn";
+          graph.push(`${layerFirst ? `[f${next}][c${next}]` : `[c${next}][f${next}]`}blend=all_mode=${FFMPEG_BLEND[clip.blend]}[b${next}]`);
+          graph.push(`[g${next}]alphaextract[m${next}]`);
+          if (clear) {
+            graph.push(`[e${next}]alphaextract[ea${next}]`);
+            graph.push(`[b${next}][ea${next}]alphamerge[bb${next}]`);
+            graph.push(`[h${next}]format=gbrp[ho${next}]`);
+            graph.push(`[ho${next}][bb${next}]overlay=format=gbrp[bm${next}]`);
+            graph.push(`[bm${next}][m${next}]alphamerge[x${next}]`);
+          } else graph.push(`[b${next}][m${next}]alphamerge[x${next}]`);
+          graph.push(`[d${next}][x${next}]overlay=format=gbrp,format=yuva420p[${next}]`);
+          blended.add(clip.blend);
+        } else graph.push(`[${cur2}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable}[${next}]`);
+        cur2 = next;
+        const before = clip.transition ? videoClipBefore(track, clip) : null;
+        if (before && clip.transition.type === "dip") {
+          const d = clip.transition.duration;
+          const dip = `d${k}`;
+          graph.push(`color=c=${color(clip.transition.color ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(d)},format=yuva420p,fade=t=in:st=0:d=${sec(d / 2)}:alpha=1,fade=t=out:st=${sec(d / 2)}:d=${sec(d / 2)}:alpha=1,setpts=PTS+${sec(clip.start - d / 2)}/TB[l${dip}]`);
+          graph.push(`[${cur2}][l${dip}]overlay=eof_action=pass:enable='between(t,${sec(clip.start - d / 2)},${sec(clip.start + d / 2)})'[${dip}]`);
+          cur2 = dip;
+        }
       }
     }
-  }
+    return { video: cur2, audio: sounds };
+  };
+  const top = compose(project.tracks, measure ? null : "base", D, { within: [], picture: !measure, sound: true });
+  const audio = top.audio;
+  const cur = top.video;
   if (!measure) graph.push(`[${cur}]format=yuv420p[vout]`);
   if (measure && !audio.length) throw new Error("Nothing on the timeline makes a sound, so there is no loudness to measure.");
   const loudness = options.loudness || measure ? `,${loudnormFilter(options.loudness, measure)}` : "";
@@ -3505,7 +3740,7 @@ function buildFfmpeg(project, options, measure) {
   if (options.loudness && !audio.length) notes.push("Nothing makes a sound, so there was no loudness to normalise.");
   else if (options.loudness && !options.loudness.measured)
     notes.push("Loudness is normalised in one pass, which adjusts the level as it goes; for a fixed gain that keeps the dynamics, run toVideoLoudnessMeasure first and pass its result as loudness.measured.");
-  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)))
+  if (allVideoTracks(project).some(({ track: 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)" : ""}.`);
@@ -3515,7 +3750,7 @@ function buildFfmpeg(project, options, measure) {
   const filterComplex = graph.join(";");
   if (measure) {
     const args2 = ["-hide_banner", "-nostats", ...inputs.flat(), "-filter_complex", filterComplex, "-map", "[aout]", "-f", "null", "-"];
-    return { args: args2, command: ["ffmpeg", ...args2].map(shellQuote).join(" "), filterComplex, duration: D, notes };
+    return { args: args2, command: ["ffmpeg", ...args2].map(videoShellQuote).join(" "), filterComplex, duration: D, notes };
   }
   const args = [
     "-y",
@@ -3536,7 +3771,333 @@ function buildFfmpeg(project, options, measure) {
     sec(D),
     options.output ?? "output.mp4"
   ];
-  return { args, command: ["ffmpeg", ...args].map(shellQuote).join(" "), filterComplex, duration: D, notes };
+  return { args, command: ["ffmpeg", ...args].map(videoShellQuote).join(" "), filterComplex, duration: D, notes };
+}
+
+// src/video-editor/proxy.ts
+var VIDEO_PROXY_SCALES = [0.5, 0.25];
+function videoAssetProxy(asset, scale) {
+  if (!asset?.proxies?.length || !(scale > 0) || scale >= 1) return null;
+  let best = null;
+  for (const p of asset.proxies) if (p.scale >= scale - 1e-9 && p.scale < 1 && (!best || p.scale < best.scale)) best = p;
+  return best;
+}
+var videoPreviewSrc = (asset, scale, fallback = asset?.src ?? "") => videoAssetProxy(asset, scale)?.src ?? fallback;
+function resolveVideoPreviewScale(scale, shown) {
+  if (scale === void 0 || scale === "auto") return Math.min(1, Math.max(0, shown));
+  if (scale === "full") return 1;
+  return Math.min(1, Math.max(0, scale));
+}
+function videoProxyName(src, scale = 0.5) {
+  const clean = src.replace(/[?#].*$/, "");
+  const base = clean.replace(/\.[^./\\]+$/, "");
+  return `${base}.proxy-${Math.round(scale * 100)}.mp4`;
+}
+function videoProxyFfmpeg(asset, options = {}) {
+  if (asset.kind !== "video") throw new Error(`Asset "${asset.id}" is ${asset.kind === "image" ? "an image" : "audio"}; only video assets have proxies.`);
+  const scale = options.scale ?? 0.5;
+  if (!(scale > 0 && scale < 1)) throw new Error(`A proxy's scale must be between 0 and 1 (not including either), not ${scale}; 0.5 is half size.`);
+  const gop = Math.max(1, Math.round(options.gop ?? 12));
+  const output = options.output ?? videoProxyName(asset.src, scale);
+  const src = options.resolve ? options.resolve(asset) : asset.src;
+  const size = `scale=trunc(iw*${scale}/2)*2:trunc(ih*${scale}/2)*2`;
+  const args = [
+    "-y",
+    "-i",
+    src,
+    "-vf",
+    size,
+    "-c:v",
+    "libx264",
+    "-preset",
+    "veryfast",
+    "-tune",
+    "fastdecode",
+    "-crf",
+    String(options.crf ?? 28),
+    "-g",
+    String(gop),
+    "-keyint_min",
+    String(gop),
+    "-sc_threshold",
+    "0",
+    "-bf",
+    "0",
+    "-pix_fmt",
+    "yuv420p",
+    ...asset.hasAudio === false ? ["-an"] : ["-c:a", "aac", "-b:a", "128k"],
+    "-movflags",
+    "+faststart",
+    output
+  ];
+  const proxy = { scale, src: output, ...asset.width && asset.height ? { width: Math.trunc(asset.width * scale / 2) * 2, height: Math.trunc(asset.height * scale / 2) * 2 } : {} };
+  return { asset: asset.id, args, command: ["ffmpeg", ...args].map(videoShellQuote).join(" "), proxy };
+}
+function videoProxyPlan(project, options = {}) {
+  const scale = options.scale ?? 0.5;
+  const wanted = options.assets ? new Set(options.assets) : null;
+  if (options.assets) for (const id of options.assets) {
+    const a = project.assets.find((x) => x.id === id);
+    if (!a) throw new Error(`There is no asset "${id}"; the assets are ${project.assets.map((x) => `"${x.id}"`).join(", ") || "none"}.`);
+    if (a.kind !== "video") throw new Error(`Asset "${id}" is ${a.kind === "image" ? "an image" : "audio"}; only video assets have proxies.`);
+  }
+  return project.assets.filter((a) => a.kind === "video" && (!wanted || wanted.has(a.id)) && !a.proxies?.some((p) => Math.abs(p.scale - scale) < 1e-9)).map((a) => videoProxyFfmpeg(a, { ...options, scale }));
+}
+var VIDEO_PREVIEW_SCALE_OPTIONS = [
+  { value: "auto", label: "Auto", scale: "auto" },
+  { value: "full", label: "Full", scale: "full" },
+  ...VIDEO_PROXY_SCALES.map((s) => ({ value: String(s), label: s === 0.5 ? "\xBD" : s === 0.25 ? "\xBC" : `${s * 100}%`, scale: s }))
+];
+var parseVideoPreviewScale = (value) => value === "full" ? "full" : Number(value) > 0 && Number(value) <= 1 ? Number(value) : "auto";
+var videoProjectHasProxies = (project) => project.assets.some((a) => !!a.proxies?.length);
+
+// src/video-editor/frame-cache.ts
+var videoSourceFrame = (sourceTime, fps) => Math.max(0, Math.floor(sourceTime * fps / 1e3 + 1e-6));
+var videoSourceFrameTime = (frame, fps) => (frame + 0.5) * 1e3 / fps;
+var videoFrameCacheKey = (src, frame) => `${frame}@${src}`;
+function videoFrameRequestsAt(project, time, srcFor = (l) => l.src) {
+  const out = [];
+  for (const layer of videoFrameLeafLayers(videoFrameAt(project, time).layers)) {
+    if (layer.type !== "media" || layer.assetKind !== "video") continue;
+    const src = srcFor(layer);
+    if (!src) continue;
+    const frame = videoSourceFrame(layer.sourceTime ?? 0, project.fps);
+    out.push({ key: videoFrameCacheKey(src, frame), src, frame, sourceTime: videoSourceFrameTime(frame, project.fps), time });
+  }
+  return out;
+}
+function planVideoPrefetch(project, time, options = {}) {
+  const window2 = options.window ?? 2e3;
+  const dir = options.direction ?? 1;
+  const step = 1e3 / project.fps;
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (let i = 0; i * step <= window2 + 1e-6; i++) {
+    const t = time + dir * i * step;
+    if (t < 0) break;
+    for (const r of videoFrameRequestsAt(project, t, options.srcFor)) {
+      if (seen.has(r.key)) continue;
+      seen.add(r.key);
+      out.push(r);
+    }
+  }
+  return out;
+}
+function videoCacheEvictions(entries, options) {
+  let total = entries.reduce((n2, e) => n2 + e.bytes, 0);
+  if (total <= options.maxBytes) return [];
+  const dir = options.direction ?? 1;
+  const behind = options.behind ?? 2;
+  const cost = (e) => {
+    const d = (e.time - options.playhead) * dir;
+    return d >= 0 ? d : -d * behind;
+  };
+  const out = [];
+  for (const e of entries.filter((x) => !options.protect?.has(x.key)).sort((a, b) => cost(b) - cost(a))) {
+    if (total <= options.maxBytes) break;
+    out.push(e.key);
+    total -= e.bytes;
+  }
+  return out;
+}
+var defaultCapture = async (source) => {
+  if (typeof createImageBitmap !== "function") return null;
+  const image = await createImageBitmap(source);
+  return { image, width: image.width, height: image.height };
+};
+var VideoFrameCache = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.maxBytes = options.maxBytes ?? 512 * 1024 * 1024;
+    this.prefetch = options.prefetch ?? 2e3;
+    this.decode = options.decode !== void 0 ? options.decode : typeof document !== "undefined" ? createVideoElementDecoder() : null;
+  }
+  options;
+  entries = /* @__PURE__ */ new Map();
+  inFlight = /* @__PURE__ */ new Set();
+  queue = [];
+  protect = /* @__PURE__ */ new Set();
+  listeners = /* @__PURE__ */ new Set();
+  playhead = 0;
+  direction = 1;
+  hits = 0;
+  misses = 0;
+  bytes = 0;
+  generation = 0;
+  destroyed = false;
+  srcFor;
+  maxBytes;
+  prefetch;
+  decode;
+  /** The cached frame of `src` showing at a source time (ms), on the project's `fps` grid. Counts a hit or a miss. */
+  get(src, sourceTime, fps) {
+    const entry = this.entries.get(videoFrameCacheKey(src, videoSourceFrame(sourceTime, fps)));
+    if (entry) this.hits++;
+    else this.misses++;
+    return entry?.frame.image;
+  }
+  /** Whether a frame is cached, without counting it. */
+  has(src, sourceTime, fps) {
+    return this.entries.has(videoFrameCacheKey(src, videoSourceFrame(sourceTime, fps)));
+  }
+  /** Keeps a decoded frame (replacing any with the same key), then evicts to the budget. */
+  put(request, frame) {
+    if (this.destroyed) return void frame.image.close?.();
+    const old = this.entries.get(request.key);
+    if (old) this.drop(old);
+    const bytes = Math.max(1, frame.width * frame.height * 4);
+    this.entries.set(request.key, { key: request.key, time: request.time, bytes, frame });
+    this.bytes += bytes;
+    this.evict();
+    this.emit();
+  }
+  /** Keeps what a ready media element shows now as the frame of `src` at `sourceTime` (async; does nothing if it is cached). */
+  capture(src, sourceTime, fps, time, source) {
+    const frame = videoSourceFrame(sourceTime, fps);
+    const key = videoFrameCacheKey(src, frame);
+    if (this.entries.has(key) || this.inFlight.has(key)) return;
+    this.inFlight.add(key);
+    void (this.options.capture ?? defaultCapture)(source).then((f) => {
+      if (f) this.put({ key, time }, f);
+    }).catch(() => {
+    }).finally(() => this.inFlight.delete(key));
+  }
+  /**
+   * Follows the playhead: protects the prefetch window, evicts to the budget, and queues the
+   * window's missing frames for decoding (nearest first). `srcFor` gives the file a layer plays.
+   */
+  update(project, time, options = {}) {
+    if (this.destroyed) return;
+    this.direction = options.direction ?? (time < this.playhead && !options.playing ? -1 : 1);
+    this.playhead = time;
+    this.srcFor = options.srcFor;
+    const plan = this.prefetch > 0 ? planVideoPrefetch(project, time, { window: this.prefetch, direction: this.direction, srcFor: options.srcFor }) : videoFrameRequestsAt(project, time, options.srcFor);
+    this.protect = new Set(plan.map((r) => r.key));
+    for (const r of plan) {
+      const e = this.entries.get(r.key);
+      if (e) e.time = r.time;
+    }
+    this.evict();
+    this.generation++;
+    this.queue = this.decode ? plan.filter((r) => !this.entries.has(r.key) && !this.inFlight.has(r.key)) : [];
+    this.pump();
+  }
+  /**
+   * The stretches of the timeline whose video frames are all cached, between `from` and `to` (ms),
+   * for the files the preview last played (its `srcFor`, e.g. proxies) unless `srcFor` is given.
+   * `step` (ms, at least a frame) samples more coarsely.
+   */
+  cachedRanges(project, options = {}) {
+    const step = Math.max(1e3 / project.fps, options.step ?? 0);
+    const from = Math.max(0, options.from ?? 0);
+    const to = options.to ?? Math.max(...project.tracks.flatMap((t) => t.clips.map((c) => c.start + c.duration)), 0);
+    const out = [];
+    for (let t = from; t < to - 1e-6; t += step) {
+      const requests = videoFrameRequestsAt(project, t, options.srcFor ?? this.srcFor);
+      const cached = requests.length > 0 && requests.every((r) => this.entries.has(r.key));
+      const last = out[out.length - 1];
+      if (!cached) continue;
+      const end = Math.min(to, t + step);
+      if (last && Math.abs(last.end - t) < 1e-6) last.end = end;
+      else out.push({ start: t, end });
+    }
+    return out.map((r) => ({ start: Math.round(r.start * 10) / 10, end: Math.round(r.end * 10) / 10 }));
+  }
+  stats() {
+    return { frames: this.entries.size, bytes: this.bytes, maxBytes: this.maxBytes, hits: this.hits, misses: this.misses, pending: this.inFlight.size + this.queue.length, prefetch: this.prefetch };
+  }
+  /** Called when frames arrive or leave. */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /** Drops every frame (closing them) and the queue. */
+  clear() {
+    for (const e of [...this.entries.values()]) this.drop(e);
+    this.queue = [];
+    this.generation++;
+    this.emit();
+  }
+  /** Clears and stops decoding for good. */
+  destroy() {
+    this.clear();
+    this.destroyed = true;
+    this.listeners.clear();
+  }
+  pump() {
+    const limit = Math.max(1, this.options.concurrency ?? 2);
+    while (this.decode && this.inFlight.size < limit && this.queue.length) {
+      const r = this.queue.shift();
+      if (this.entries.has(r.key) || this.inFlight.has(r.key)) continue;
+      if (this.bytes >= this.maxBytes && [...this.entries.keys()].every((k) => this.protect.has(k))) {
+        this.queue = [];
+        break;
+      }
+      const generation = this.generation;
+      this.inFlight.add(r.key);
+      this.decode(r.src, r.sourceTime).then(
+        (frame) => {
+          this.inFlight.delete(r.key);
+          if (generation === this.generation || this.bytes + frame.width * frame.height * 4 <= this.maxBytes) this.put(r, frame);
+          else frame.image.close?.();
+        },
+        () => this.inFlight.delete(r.key)
+      ).finally(() => this.pump());
+    }
+  }
+  evict() {
+    const drop = videoCacheEvictions([...this.entries.values()], { playhead: this.playhead, maxBytes: this.maxBytes, direction: this.direction, behind: this.options.behind, protect: this.protect });
+    for (const key of drop) this.drop(this.entries.get(key));
+  }
+  drop(e) {
+    this.entries.delete(e.key);
+    this.bytes -= e.bytes;
+    e.frame.image.close?.();
+  }
+  emit() {
+    for (const l of [...this.listeners]) l();
+  }
+};
+function createVideoElementDecoder(options = {}) {
+  const videos = /* @__PURE__ */ new Map();
+  const make = options.createVideo ?? (() => {
+    const el = document.createElement("video");
+    el.muted = true;
+    el.preload = "auto";
+    el.crossOrigin = "anonymous";
+    el.playsInline = true;
+    return el;
+  });
+  const timeout = options.timeout ?? 5e3;
+  const once = (el, type) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(`The video did not ${type} within ${timeout} ms.`)), timeout);
+    el.addEventListener(type, () => (clearTimeout(timer), resolve()), { once: true });
+    el.addEventListener("error", () => (clearTimeout(timer), reject(new Error("The video could not be loaded."))), { once: true });
+  });
+  return (src, sourceTime) => {
+    let v = videos.get(src);
+    if (!v) {
+      const el2 = make();
+      el2.src = src;
+      v = { el: el2, chain: el2.readyState >= 1 ? Promise.resolve() : once(el2, "loadedmetadata") };
+      videos.set(src, v);
+    }
+    const { el } = v;
+    const next = v.chain.then(async () => {
+      const presented = "requestVideoFrameCallback" in el ? new Promise((r) => el.requestVideoFrameCallback(() => r())) : null;
+      const seeked = once(el, "seeked");
+      el.currentTime = sourceTime / 1e3;
+      await seeked;
+      if (presented) await Promise.race([presented, new Promise((r) => setTimeout(r, 100))]);
+      const image = await createImageBitmap(el);
+      return { image, width: image.width, height: image.height };
+    });
+    v.chain = next.catch(() => {
+    });
+    return next;
+  };
 }
 
 // src/video-editor/preview.ts
@@ -3550,6 +4111,9 @@ var VideoPreviewEngine = class {
     this.lutCache = options.luts !== void 0 ? options.luts : source.luts ?? null;
     this.unsubscribeLuts = this.lutCache ? this.lutCache.subscribe(() => this.redraw()) : () => {
     };
+    this.frameCache = options.frameCache !== void 0 ? options.frameCache : source.frameCache ?? null;
+    this.unsubscribeFrames = this.frameCache ? this.frameCache.subscribe(() => this.redraw()) : () => {
+    };
     const pixels = options.pixels !== void 0 ? options.pixels : source.previewPixels;
     this.detachPixels = pixels ? pixels.attach(() => this.readPixels()) : () => {
     };
@@ -3572,8 +4136,13 @@ var VideoPreviewEngine = class {
   drawn = null;
   complete = true;
   lutCache;
+  frameCache;
+  unsubscribeFrames;
+  srcFor = (layer) => layer.src;
+  playing = false;
+  fps = 30;
   unsubscribeLuts;
-  scratchCanvas;
+  scratchCanvases = /* @__PURE__ */ new Map();
   /** The canvas's pixels and the frame they show, or `null` when its context cannot be read. */
   readPixels() {
     const ctx = this.ctx;
@@ -3622,8 +4191,15 @@ var VideoPreviewEngine = class {
   /** Brings the media elements in step with the editor and draws the frame. */
   update() {
     if (this.destroyed) return;
-    const { project, time, playing } = this.source.getState();
+    const state = this.source.getState();
+    const { project, time, playing } = state;
     const frame = videoFrameAt(project, time);
+    const scale = resolveVideoPreviewScale(this.options.previewScale ?? state.previewScale, this.resolutionFor(project.width));
+    const assets = new Map(project.assets.map((a) => [a.id, a]));
+    this.srcFor = (layer) => videoPreviewSrc(assets.get(layer.asset ?? ""), scale, layer.src);
+    this.playing = playing;
+    this.fps = project.fps;
+    this.frameCache?.update(project, time, { playing, srcFor: this.srcFor });
     const tolerance = (this.options.tolerance ?? 200) / 1e3;
     const active = /* @__PURE__ */ new Set();
     const sync = (clip, src, kind, sourceTime, speed, gain) => {
@@ -3647,10 +4223,10 @@ var VideoPreviewEngine = class {
       }
     };
     const sounding = new Map(frame.audio.map((a) => [a.clip, a]));
-    for (const layer of frame.layers) {
+    for (const layer of videoFrameLeafLayers(frame.layers)) {
       if (layer.type !== "media" || layer.assetKind !== "video" || !layer.src) continue;
       const sound = sounding.get(layer.clip);
-      sync(layer.clip, layer.src, "video", layer.sourceTime ?? 0, sound?.speed ?? 1, sound ? sound.gain : null);
+      sync(layer.clip, this.srcFor(layer), "video", layer.sourceTime ?? 0, sound?.speed ?? 1, sound ? sound.gain : null);
       sounding.delete(layer.clip);
     }
     for (const a of sounding.values()) sync(a.clip, a.src, "audio", a.sourceTime, a.speed, a.gain);
@@ -3671,15 +4247,29 @@ var VideoPreviewEngine = class {
       return img.complete ? img : null;
     }
     const entry = this.media.get(layer.clip);
-    if (!entry || entry.media.readyState < 2) return null;
+    const ready = !!entry && entry.media.readyState >= 2;
+    const cache = this.frameCache;
+    const src = entry?.src ?? this.srcFor(layer);
+    const sourceTime = layer.sourceTime ?? 0;
+    if (cache && src && (!this.playing || !ready || entry.media.seeking)) {
+      const hit = cache.get(src, sourceTime, this.fps);
+      if (hit) return hit;
+    }
+    if (!ready) return null;
     if (entry.media.seeking) this.complete = false;
+    else if (cache && !this.playing) cache.capture(entry.src, sourceTime, this.fps, this.source.getState().time, entry.media);
     return entry.media;
   };
+  /** Canvas pixels per frame pixel: the option, else the displayed width at the device pixel ratio (at most 1). */
+  resolutionFor(frameWidth) {
+    if (this.options.resolution !== void 0) return this.options.resolution;
+    const shown = this.canvas.clientWidth || frameWidth;
+    const dpr = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
+    return Math.min(1, shown * dpr / frameWidth);
+  }
   draw(frame) {
     if (!this.ctx) return;
-    const shown = this.canvas.clientWidth || frame.width;
-    const dpr = typeof window !== "undefined" ? window.devicePixelRatio || 1 : 1;
-    const resolution = this.options.resolution ?? Math.min(1, shown * dpr / frame.width);
+    const resolution = this.resolutionFor(frame.width);
     const w = Math.max(1, Math.round(frame.width * resolution));
     const h = Math.max(1, Math.round(frame.height * resolution));
     if (this.canvas.width !== w) this.canvas.width = w;
@@ -3701,16 +4291,18 @@ var VideoPreviewEngine = class {
     if (!lut) this.complete = false;
     return lut;
   };
-  scratch = (width, height) => {
-    if (this.scratchCanvas === void 0) {
-      if (this.options.createScratch) this.scratchCanvas = this.options.createScratch(width, height);
+  scratch = (width, height, slot) => {
+    if (!this.scratchCanvases.has(slot)) {
+      let made = null;
+      if (this.options.createScratch) made = this.options.createScratch(width, height, slot);
       else if (typeof document !== "undefined") {
         const canvas2 = document.createElement("canvas");
         const ctx = canvas2.getContext("2d", { willReadFrequently: true });
-        this.scratchCanvas = ctx ? { canvas: canvas2, ctx } : null;
-      } else this.scratchCanvas = null;
+        made = ctx ? { canvas: canvas2, ctx } : null;
+      }
+      this.scratchCanvases.set(slot, made);
     }
-    const s = this.scratchCanvas;
+    const s = this.scratchCanvases.get(slot);
     if (!s) return null;
     const c = s.canvas;
     if (c.width !== width) c.width = width;
@@ -3738,6 +4330,7 @@ var VideoPreviewEngine = class {
     this.destroyed = true;
     this.detachPixels();
     this.unsubscribeLuts();
+    this.unsubscribeFrames();
     this.filterHost?.remove();
     this.filterHost = null;
     this.filters.clear();
@@ -3757,10 +4350,13 @@ var VideoEditorController = class {
   previewPixels = new VideoPreviewPixels();
   /** Grades' LUTs, loaded on demand for the preview, SVG frames and agents. */
   luts;
+  /** The host's frame cache, if it gave one (the preview fills and reads it). */
+  frameCache;
   project;
   issues;
   selection = [];
   readOnly;
+  previewScale;
   error = null;
   revision = 0;
   applying = false;
@@ -3772,9 +4368,11 @@ var VideoEditorController = class {
     this.history = options.history ?? new HistoryManager();
     this.audioPeaks = options.audioPeaks instanceof VideoAudioPeaksCache ? options.audioPeaks : new VideoAudioPeaksCache(options.audioPeaks);
     this.luts = options.luts instanceof VideoLutCache ? options.luts : new VideoLutCache(options.luts);
+    this.frameCache = options.frameCache ?? null;
     this.project = options.project ? parseVideoProject(options.project) : createVideoProject();
     this.issues = checkVideoProject(this.project);
     this.readOnly = options.readOnly ?? false;
+    this.previewScale = checkPreviewScale(options.previewScale ?? "auto");
     this.onChange = options.onChange;
     this.player = new AnimationPlayer({ clock: options.clock, duration: () => videoProjectDuration(this.project), loop: "none" });
     this.state = this.computeState();
@@ -3824,6 +4422,7 @@ var VideoEditorController = class {
       canRedo: h.canRedo,
       undoLabel: h.undoName,
       redoLabel: h.redoName,
+      previewScale: this.previewScale,
       revision: this.revision
     };
   }
@@ -3913,6 +4512,17 @@ var VideoEditorController = class {
     this.readOnly = readOnly;
     this.notify();
   }
+  /**
+   * Sets how large a picture the preview plays: `full` (the originals), a fraction such as 0.5
+   * (the smallest proxy at least that large, else the original) or `auto` (as large as the canvas
+   * shows). A view setting, not part of the project: no undo step.
+   */
+  setPreviewScale(scale) {
+    const next = checkPreviewScale(scale);
+    if (next === this.previewScale) return;
+    this.previewScale = next;
+    this.notify();
+  }
   /** Selects clips (unknown ids are dropped). `add` toggles them into the current selection. */
   select(clips, options = {}) {
     const known = clips?.filter((id) => findVideoClip(this.project, id)) ?? [];
@@ -3997,6 +4607,11 @@ var VideoEditorController = class {
     return toVideoEdl(this.project, options);
   }
 };
+function checkPreviewScale(scale) {
+  if (scale === "auto" || scale === "full") return scale;
+  if (typeof scale !== "number" || !(scale > 0 && scale <= 1)) throw new Error(`A preview scale is "auto", "full" or a fraction above 0 up to 1 (0.5 is half size), not ${JSON.stringify(scale)}.`);
+  return scale === 1 ? "full" : scale;
+}
 
 // src/video-editor/ui.ts
 var STEPS = [40, 100, 200, 500, 1e3, 2e3, 5e3, 1e4, 15e3, 3e4, 6e4, 12e4, 3e5, 6e5];
@@ -4058,14 +4673,16 @@ var VIDEO_FADE_CURVE_LABELS = {
 };
 function videoClipTint(clip, asset) {
   if (clip.type === "text") return "#a855f7";
+  if (clip.type === "sequence") return "#0d9488";
   if (clip.type === "color") return clip.color;
   if (!asset) return "#ef4444";
   return asset.kind === "audio" ? "#10b981" : asset.kind === "image" ? "#f59e0b" : "#3b82f6";
 }
-function videoClipLabel(clip, asset) {
+function videoClipLabel(clip, asset, sequence) {
   if (clip.name) return clip.name;
   if (clip.type === "text") return clip.text.split("\n")[0];
   if (clip.type === "color") return clip.color;
+  if (clip.type === "sequence") return `Compound: ${sequence?.name ?? clip.sequence}`;
   const base = asset?.name ?? asset?.src.replace(/^.*[\\/]/, "") ?? clip.asset;
   const speed = videoClipSpeed(clip);
   return speed !== 1 ? `${base} (${Math.round(speed * 100)}%)` : base;
@@ -4159,7 +4776,7 @@ var KEY_LABELS = {
   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 animatableOf = (clip, property) => VIDEO_TRANSFORM_PROPERTIES.includes(property) ? clip.transform?.[property] : property === "volume" ? clip.type === "media" || clip.type === "sequence" ? 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);
@@ -4167,7 +4784,7 @@ function videoKeyframeRows(project, clipId, time) {
   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" && videoAssetHasSound(asset);
+  const audible = clip.type === "media" && videoAssetHasSound(asset) || clip.type === "sequence";
   const properties = [...visual ? ["opacity"] : [], ...audible ? ["volume"] : [], ...visual ? VIDEO_TRANSFORM_PROPERTIES : []];
   const clipTime = playheadInClip(clip, time);
   return properties.map((property) => {
@@ -4400,6 +5017,34 @@ var videoAssetOut = (a) => {
   const { transcript, ...rest } = a;
   return transcript ? { ...rest, transcriptWords: transcript.length } : rest;
 };
+var describeVideoTracks = (tracks) => tracks.map((t, index) => ({
+  id: t.id,
+  kind: t.kind,
+  index,
+  ...t.name ? { name: t.name } : {},
+  ...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" || c.type === "sequence" ? { source: videoClipSourceRange(c) } : {} }))
+}));
+var videoSequenceUsers = (project, id) => allVideoTracks(project).flatMap(
+  ({ sequence, track }) => track.clips.flatMap((c) => c.type === "sequence" && c.sequence === id ? [{ clip: c.id, ...sequence ? { inSequence: sequence } : {}, track: track.id, start: c.start, end: videoClipEnd(c), source: videoClipSourceRange(c) }] : [])
+);
+function describeVideoSequence(project, sequence, tracks = true) {
+  const cycle = findVideoSequenceCycle(project, sequence.id);
+  return {
+    id: sequence.id,
+    ...sequence.name ? { name: sequence.name } : {},
+    duration: videoSequenceDuration(sequence),
+    clipCount: sequence.tracks.reduce((n2, t) => n2 + t.clips.length, 0),
+    nests: videoSequenceChildren(sequence),
+    usedBy: videoSequenceUsers(project, sequence.id),
+    ...cycle ? { cycle } : {},
+    ...tracks ? { tracks: describeVideoTracks(sequence.tracks) } : { trackCount: sequence.tracks.length }
+  };
+}
 function describeVideoProject(project) {
   return {
     ...project.name ? { name: project.name } : {},
@@ -4409,18 +5054,8 @@ function describeVideoProject(project) {
     duration: videoProjectDuration(project),
     ...project.background ? { background: project.background } : {},
     assets: project.assets.map(videoAssetOut),
-    tracks: project.tracks.map((t, index) => ({
-      id: t.id,
-      kind: t.kind,
-      index,
-      ...t.name ? { name: t.name } : {},
-      ...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) } : {} }))
-    })),
+    tracks: describeVideoTracks(project.tracks),
+    ...project.sequences?.length ? { sequences: project.sequences.map((q) => describeVideoSequence(project, q, false)) } : {},
     markers: project.markers ?? []
   };
 }
@@ -4442,7 +5077,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const clipOut = (p, id) => {
     for (const t of p.tracks) {
       const c = t.clips.find((x) => x.id === id);
-      if (c) return { track: t.id, ...c, end: videoClipEnd(c), ...c.type === "media" ? { source: videoClipSourceRange(c) } : {} };
+      if (c) return { track: t.id, ...c, end: videoClipEnd(c), ...c.type === "media" || c.type === "sequence" ? { source: videoClipSourceRange(c) } : {} };
     }
     return null;
   };
@@ -4460,19 +5095,19 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const getProject = {
     name: "get_video_project",
     title: "Read the video project",
-    description: "Returns the whole project: frame size, fps, length (ms), assets (id, kind, src, duration), tracks top to bottom (an earlier video track draws over a later one) with each clip in time order (id, type, start, duration, end, source in/out for media, fades, transition) and markers, plus the playhead, selection, issues and whether it can be edited.",
+    description: `Returns the whole project: frame size, fps, length (ms), assets (id, kind, src, duration), tracks top to bottom (an earlier video track draws over a later one) with each clip in time order (id, type, start, duration, end, source in/out for media and compound clips, fades, transition), a summary of each nested sequence (id, name, length, clip count, the sequences it nests, the compound clips that play it) and markers, plus the playhead, selection, issues and whether it can be edited. Compound clips (type "sequence") play a sequence's tracks as one picture and sound; list_video_sequences reads what is inside them.`,
     inputSchema: object({}),
     annotations: { title: "Read the video project", ...READ },
     handler: () => {
       const state = controller.getState();
       const reason = readOnlyReason();
-      return { ...describeVideoProject(state.project), playhead: state.time, selection: state.selection, issues: issueSummary(state.issues), editable: !reason, ...reason ? { readOnlyReason: reason } : {} };
+      return { ...describeVideoProject(state.project), playhead: state.time, previewScale: state.previewScale, selection: state.selection, issues: issueSummary(state.issues), editable: !reason, ...reason ? { readOnlyReason: reason } : {} };
     }
   };
   const getFrame = {
     name: "get_video_frame",
     title: "What plays at a moment",
-    description: "Returns what plays at a time without changing anything: the pictures back to front (clip, track, asset, source time in ms, opacity, placement rect, rotation, any wipe or iris) and the sounds (clip, source time, gain after volumes, fades and transitions).",
+    description: `Returns what plays at a time without changing anything: the pictures back to front (clip, track, asset, source time in ms, opacity, placement rect, rotation, any wipe or iris) and the sounds (clip, source time, gain after volumes, fades and transitions). A compound clip is one picture with its sequence, the moment of the sequence it shows (sourceTime) and the sequence's own pictures as "layers"; its sounds are listed with clip paths such as "compound/inner".`,
     inputSchema: object({ time: MS("Time from the start (default: the playhead)") }),
     annotations: { title: "What plays at a moment", ...READ },
     handler: ({ time }) => {
@@ -4480,6 +5115,23 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return { ...frame, timecode: formatVideoTimecode(frame.time, project().fps) };
     }
   };
+  const listSequences = {
+    name: "list_video_sequences",
+    title: "List nested sequences",
+    description: `Lists the project's nested sequences, the tracks that compound clips (type "sequence") play as one picture and sound, without changing anything. For each: id, name, length (ms), the sequences it nests, the compound clips that play it (clip id, the track and sequence they sit on, timeline start and end, and the stretch of the sequence they play as source in / out) and its tracks with their clips, in the same shape as get_video_project. A sequence that contains itself lists the loop as "cycle". Clips inside sequences can be read here but not edited yet; edit the compound clip instead (move, trim, its opacity, blend, grade, volume).`,
+    inputSchema: object({ sequence: { type: "string", minLength: 1, description: "Only this sequence id (default: every sequence)." } }),
+    annotations: { title: "List nested sequences", ...READ },
+    handler: ({ sequence }) => {
+      const p = project();
+      const all = p.sequences ?? [];
+      if (sequence !== void 0) {
+        const found = all.find((q) => q.id === sequence);
+        if (!found) throw new Error(`There is no sequence "${sequence}"; ${all.length ? `the sequences are ${all.map((q) => `"${q.id}"`).join(", ")}` : "the project has no sequences"}.`);
+        return { sequences: [describeVideoSequence(p, found)] };
+      }
+      return { sequences: all.map((q) => describeVideoSequence(p, q)) };
+    }
+  };
   const findGaps = {
     name: "find_video_gaps",
     title: "Find gaps",
@@ -4634,7 +5286,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     name: "update_video_asset",
     title: "Change media details",
     description: "Changes an asset's src, name, duration, size, sound or poster (e.g. relinking moved media). Clips that now run past its end are refused. Returns the asset.",
-    inputSchema: object({ asset: ASSET_ID, set: object(ASSET_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "duration", "width", "height", "hasAudio", "poster", "transcript"] }, description: "Fields to clear (transcript removes its words)." } }, ["asset"]),
+    inputSchema: object({ asset: ASSET_ID, set: object(ASSET_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "duration", "width", "height", "hasAudio", "poster", "transcript", "proxies"] }, description: "Fields to clear (transcript removes its words, proxies its proxies)." } }, ["asset"]),
     annotations: { title: "Change media details", ...WRITE_IDEMPOTENT },
     handler: ({ asset, set, remove }) => apply({ op: "update_asset", asset, set, remove }, "Change media", (r) => ({ asset: videoAssetOut(r.project.assets.find((a) => a.id === asset)) }))
   };
@@ -4730,7 +5382,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
   const updateClip = {
     name: "update_video_clip",
     title: "Change a clip",
-    description: `Changes a clip's properties (one undo step): opacity, transform, fit, blend mode, colour grade, entrance and exit animations, fades, name; for media volume, mute, the sound's fade curves, speed (keeps the stretch of source, so the length changes) or asset; for titles text and style; for colours the colour. Fields in "remove" go back to their defaults. Use move / trim for timing. Returns the clip.`,
+    description: `Changes a clip's properties (one undo step): opacity, transform, fit, blend mode, colour grade, entrance and exit animations, fades, name; for media volume, mute, the sound's fade curves, speed (keeps the stretch of source, so the length changes) or asset; for compound clips in point, volume, mute and fade curves (no speed); for titles text and style; for colours the colour. Fields in "remove" go back to their defaults. Use move / trim for timing. Returns the clip.`,
     inputSchema: object(
       {
         clip: CLIP_ID,
@@ -4743,7 +5395,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     handler: ({ clip, set, remove }) => {
       const current = clipOut(project(), clip);
       if (current && set) {
-        const allowed = /* @__PURE__ */ new Set(["name", "opacity", "transform", "fit", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", ...current.type === "media" ? ["in", "speed", "volume", "muted", "asset", "fadeInCurve", "fadeOutCurve"] : current.type === "text" ? Object.keys(TEXT_FIELDS) : ["color"]]);
+        const allowed = /* @__PURE__ */ new Set(["name", "opacity", "transform", "fit", "blend", "grade", "animateIn", "animateOut", "fadeIn", "fadeOut", ...current.type === "media" ? ["in", "speed", "volume", "muted", "asset", "fadeInCurve", "fadeOutCurve"] : current.type === "sequence" ? ["in", "volume", "muted", "fadeInCurve", "fadeOutCurve"] : current.type === "text" ? Object.keys(TEXT_FIELDS) : ["color"]]);
         const wrong = Object.keys(set).filter((k) => !allowed.has(k));
         if (wrong.length) throw new Error(`${wrong.map((k) => `"${k}"`).join(", ")} cannot be set on a ${current.type} clip; it takes ${[...allowed].join(", ")}.`);
       }
@@ -4832,6 +5484,79 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return apply(videoLutEdits(p, withLut, null), "Remove LUT", (r) => ({ clips: clips.map((id) => ({ id, grade: findVideoClip(r.project, id)?.clip.grade ?? null })) }));
     }
   };
+  const PROXY_SCALE = { type: "number", exclusiveMinimum: 0, exclusiveMaximum: 1, description: "Proxy size as a fraction of the original: 0.5 (half width and height, the default) or 0.25 for very large footage." };
+  const planProxies = {
+    name: "plan_video_proxies",
+    title: "Plan proxy files",
+    description: 'Returns the ffmpeg commands that make smaller proxy copies of video assets for smooth preview playback, without changing anything: one per video asset (or each of "assets") that has no proxy at that scale yet, each with { asset, args, command, proxy }. Proxies are scaled, H.264 with a keyframe every few frames so scrubbing is quick, and keep the sound. After the host runs a command, attach its "proxy" with set_video_proxies. The export always uses the originals.',
+    inputSchema: object({
+      scale: PROXY_SCALE,
+      assets: { type: "array", items: ASSET_ID, minItems: 1, uniqueItems: true, description: "Only these video assets (default: every video asset without a proxy at this scale)." },
+      gop: { type: "integer", minimum: 1, maximum: 300, description: "Frames between keyframes (default 12): fewer makes seeking cheaper and files larger." },
+      crf: { type: "integer", minimum: 0, maximum: 51, description: "x264 quality, lower is better (default 28: proxies are for editing)." }
+    }),
+    annotations: { title: "Plan proxy files", ...READ },
+    handler: ({ scale, assets, gop, crf }) => {
+      const commands = videoProxyPlan(project(), { scale, assets, gop, crf });
+      return { scale: scale ?? 0.5, commands, ...commands.length ? {} : { note: "Every video asset already has a proxy at this scale." } };
+    }
+  };
+  const setProxies = {
+    name: "set_video_proxies",
+    title: "Attach proxies",
+    description: "Sets a video asset's proxies, the smaller copies the preview plays instead of the original (one undo step); an empty list removes them. Each proxy must match the original's length and timing (plan_video_proxies makes such files). The export, EDL and source times always use the original. Returns the asset.",
+    inputSchema: object(
+      {
+        asset: { ...ASSET_ID, description: "A video asset id from get_video_project." },
+        proxies: {
+          type: "array",
+          maxItems: 8,
+          description: "Its proxies, one per scale (empty removes them all).",
+          items: object({ scale: PROXY_SCALE, src: { type: "string", minLength: 1, description: "Where the preview loads the proxy from (URL or path)." }, width: { type: "number", exclusiveMinimum: 0, description: "Its width in pixels." }, height: { type: "number", exclusiveMinimum: 0, description: "Its height in pixels." } }, ["scale", "src"], "One proxy.")
+        }
+      },
+      ["asset", "proxies"]
+    ),
+    annotations: { title: "Attach proxies", ...WRITE_IDEMPOTENT },
+    handler: ({ asset, proxies }) => {
+      const a = project().assets.find((x) => x.id === asset);
+      if (!a) throw new Error(`There is no asset "${asset}"; the assets are ${project().assets.map((x) => `"${x.id}"`).join(", ") || "none"}.`);
+      if (a.kind !== "video") throw new Error(`Asset "${asset}" is ${a.kind === "image" ? "an image" : "audio"}; only video assets have proxies.`);
+      const edit = proxies.length ? { op: "update_asset", asset, set: { proxies } } : { op: "update_asset", asset, remove: ["proxies"] };
+      return apply(edit, proxies.length ? "Attach proxies" : "Remove proxies", (r) => ({ asset: videoAssetOut(r.project.assets.find((x) => x.id === asset)) }));
+    }
+  };
+  const setPreviewScale = {
+    name: "set_video_preview_scale",
+    title: "Set the preview size",
+    description: 'Sets how large a picture the preview plays, without changing the project (no undo step): "full" plays the originals, a fraction (0.5, 0.25) plays the smallest proxy at least that large (or the original where there is none), "auto" (the default) picks by the size the preview is shown at. Use a proxy scale when playback stutters on large footage. Returns the setting and, for each video asset, what the preview plays at a fixed scale.',
+    inputSchema: object(
+      { scale: { anyOf: [{ type: "string", enum: ["auto", "full"] }, { type: "number", exclusiveMinimum: 0, maximum: 1 }], description: '"auto", "full", or a fraction above 0 up to 1 (0.5 is half size).' } },
+      ["scale"]
+    ),
+    annotations: { title: "Set the preview size", ...WRITE_IDEMPOTENT },
+    handler: ({ scale }) => {
+      controller.setPreviewScale(scale);
+      const s = controller.getState().previewScale;
+      const fixed = s === "full" ? 1 : typeof s === "number" ? s : null;
+      const plays = fixed === null ? void 0 : project().assets.filter((a) => a.kind === "video").map((a) => ({ asset: a.id, src: videoAssetProxy(a, fixed)?.src ?? a.src, proxy: !!videoAssetProxy(a, fixed) }));
+      return { previewScale: s, ...plays ? { plays } : { note: "auto picks the smallest proxy at least as large as the preview canvas shows, so it depends on the preview's size." } };
+    }
+  };
+  const previewCache = {
+    name: "get_video_preview_cache",
+    title: "Read the preview's frame cache",
+    description: `Reports the preview's cache of decoded frames, without changing anything: whether the host has one, how many frames and bytes it holds against its budget, hits and misses, frames still decoding, how far ahead it prefetches (ms), and the stretches of the timeline between "from" and "to" whose frames are all cached (these play and scrub without waiting). Use it to tell whether stuttering is the cache filling, and before asking the person to review a passage. With no cache, says so.`,
+    inputSchema: object({ from: MS("Start of the stretch to report cached ranges for (default 0)"), to: MS("End of it (default: the end of the project)") }),
+    annotations: { title: "Read the preview's frame cache", ...READ },
+    handler: ({ from, to }) => {
+      const cache = controller.frameCache;
+      if (!cache) return { enabled: false, reason: "The host has not given this editor a frame cache (VideoEditorController frameCache), so the preview decodes each frame as it plays." };
+      if (from !== void 0 && to !== void 0 && !(to > from)) throw new Error(`"to" (${to} ms) must be after "from" (${from} ms).`);
+      const ranges = cache.cachedRanges(project(), { from, to });
+      return { enabled: true, ...cache.stats(), cachedRanges: ranges };
+    }
+  };
   const TRANSCRIPT_TRACK = { ...TRACK_ID, description: "Track whose words to read (default: the first audio track with a transcribed clip, else the first video track with one)." };
   const RANGE_OUT = (r) => ({ from: round(r.from), to: round(r.to), text: r.text });
   const timelineWords = (track) => {
@@ -4944,6 +5669,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     const at = findVideoClip(project(), id);
     if (!at) throw new Error(`There is no clip "${id}"; get_video_project lists the clips.`);
     const { clip } = at;
+    if (clip.type === "sequence") throw new Error(`Clip "${id}" is a compound clip, which plays its sequence at normal speed; change the speed of the clips inside the sequence instead.`);
     if (clip.type !== "media") throw new Error(`Clip "${id}" is a ${clip.type === "text" ? "title" : "colour"}, so it has no source to change the speed of; use a video or audio clip.`);
     if (project().assets.find((a) => a.id === clip.asset)?.kind === "image") throw new Error(`Clip "${id}" is a still, so it has no motion to change the speed of.`);
     return clip;
@@ -5179,6 +5905,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
       const found = findVideoClip(p, args.clip);
       if (!found) throw new Error(`There is no clip "${args.clip}"; get_video_project lists the clips.`);
       const c = found.clip;
+      if (c.type === "sequence") throw new Error(`Clip "${c.id}" is a compound clip; its sound is the mix of its sequence "${c.sequence}", so read the levels of the media in it (list_video_sequences lists its clips and assets).`);
       if (c.type !== "media") throw new Error(`Clip "${c.id}" is a ${c.type} clip and has no sound; pass a media clip.`);
       asset = p.assets.find((a) => a.id === c.asset);
       const speed = c.speed ?? 1;
@@ -5273,8 +6000,8 @@ function createVideoEditorToolProvider(controller, options = {}) {
       return { time: t, timecode: formatVideoTimecode(t, p.fps), width: pixels.width, height: pixels.height, ...summarizeVideoScopes(pixels, { bins, columns }) };
     }
   };
-  const reads = [getProject, getFrame, getTranscript, findText, findFillers, findPauses, findGaps, checkProject, renderFrame, getScopes, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek];
-  const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setSpeedRamp, addFreeze, removeRamp, setTranscript, removeRanges, applyGradePreset, copyGrade, setLut, removeLut, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
+  const reads = [getProject, listSequences, getFrame, getTranscript, findText, findFillers, findPauses, findGaps, checkProject, renderFrame, getScopes, previewCache, planProxies, exportFfmpeg, exportLoudnessMeasure, exportEdl, audioLevels, findSilences, seek, setPreviewScale];
+  const writes = [setSettings, addAsset, updateAsset, removeAsset, setProxies, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, setSpeedRamp, addFreeze, removeRamp, setTranscript, removeRanges, applyGradePreset, copyGrade, setLut, removeLut, setKeyframes, removeKeyframes, slipClip, rollEdit, slideClip, liftRange, extractRange, splitAt, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
   return {
     id: options.id ?? "video",
     namespace: options.namespace,
@@ -5315,6 +6042,8 @@ export {
   VIDEO_LUT_MAX_SIZE,
   VIDEO_PEAK_BLOCK,
   VIDEO_PLACEMENT_MODES,
+  VIDEO_PREVIEW_SCALE_OPTIONS,
+  VIDEO_PROXY_SCALES,
   VIDEO_SCOPE_KINDS,
   VIDEO_TIME_EPSILON,
   VIDEO_TRANSFORM_PROPERTIES,
@@ -5324,10 +6053,12 @@ export {
   VIDEO_WIPE_DIRECTIONS,
   VideoAudioPeaksCache,
   VideoEditorController,
+  VideoFrameCache,
   VideoLutCache,
   VideoPreviewEngine,
   VideoPreviewPixels,
   allVideoClipIds,
+  allVideoTracks,
   applyVideoEdits,
   applyVideoGrade,
   applyVideoLut,
@@ -5336,15 +6067,19 @@ export {
   checkVideoProject,
   checkVideoTimeRemap,
   createVideoEditorToolProvider,
+  createVideoElementDecoder,
   createVideoProject,
   decodeVideoAudioPeaks,
   describeVideoProject,
+  describeVideoSequence,
   drawVideoFrame,
   ffmpegFilterValue,
   findVideoAudioSilences,
   findVideoClip,
   findVideoFillers,
   findVideoGaps,
+  findVideoSequenceClip,
+  findVideoSequenceCycle,
   findVideoTranscriptPauses,
   findVideoTranscriptText,
   formatVideoSeconds,
@@ -5359,6 +6094,7 @@ export {
   normalizeVideoWord,
   parseVideoAnimatable,
   parseVideoAsset,
+  parseVideoAssetProxies,
   parseVideoClip,
   parseVideoClipAnimation,
   parseVideoCubeLut,
@@ -5367,7 +6103,9 @@ export {
   parseVideoKeyframes,
   parseVideoLoudnessMeasurement,
   parseVideoMarker,
+  parseVideoPreviewScale,
   parseVideoProject,
+  parseVideoSequence,
   parseVideoTimeRemap,
   parseVideoTrack,
   parseVideoTranscript,
@@ -5376,9 +6114,11 @@ export {
   parseVideoTransition,
   placeVideoRect,
   planVideoClipDrag,
+  planVideoPrefetch,
   probeVideoMedia,
   readVideoScopesPanel,
   removeVideoKey,
+  resolveVideoPreviewScale,
   retimeVideoAnimatable,
   setVideoKey,
   snapToVideoFrame,
@@ -5394,10 +6134,12 @@ export {
   videoAssetHasSound,
   videoAssetKindOf,
   videoAssetMap,
+  videoAssetProxy,
   videoAudioLevels,
   videoAudioPeakRange,
   videoAudioPeakSpans,
   videoAudioPeaksDuration,
+  videoCacheEvictions,
   videoChroma,
   videoClipAfter,
   videoClipAnimated,
@@ -5428,7 +6170,10 @@ export {
   videoExposureStats,
   videoFadeCurveGain,
   videoFrameAt,
+  videoFrameCacheKey,
   videoFrameDuration,
+  videoFrameLeafLayers,
+  videoFrameRequestsAt,
   videoFrameToSvg,
   videoFrames,
   videoFreezeFrameEdit,
@@ -5462,13 +6207,24 @@ export {
   videoLutToCube,
   videoOverlap,
   videoPeakDb,
+  videoPreviewSrc,
   videoProjectDuration,
+  videoProjectHasProxies,
   videoProjectSvg,
+  videoProxyFfmpeg,
+  videoProxyName,
+  videoProxyPlan,
   videoRemoveRangesEdits,
   videoRulerTicks,
   videoScopeImage,
+  videoSequenceChildren,
+  videoSequenceDuration,
+  videoSequenceMap,
+  videoShellQuote,
   videoSlowMotionRamp,
   videoSnapPoints,
+  videoSourceFrame,
+  videoSourceFrameTime,
   videoSpeedRampEdit,
   videoSpeedRampKeys,
   videoTextStyle,