@pixerate/editor 0.75.0 → 0.77.0

package/dist/video-editor/index.js

@@ -0,0 +1,2234 @@
+import {
+  namedWithSuggestion
+} from "../chunk-INZJALPY.js";
+import {
+  HistoryManager
+} from "../chunk-QVZZGT4X.js";
+import {
+  AnimationPlayer
+} from "../chunk-JK6M6V7G.js";
+import "../chunk-ZRJMJIQU.js";
+import "../chunk-TGD52FEZ.js";
+import "../chunk-AGR4P4UZ.js";
+
+// src/video-editor/types.ts
+var VIDEO_FITS = ["contain", "cover", "fill", "none"];
+var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe"];
+var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
+var VIDEO_CLIP_TYPES = ["media", "text", "color"];
+
+// src/video-editor/parse.ts
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+var fail = (path, what) => {
+  throw new Error(`${path} ${what}.`);
+};
+var str = (v, path, optional = false) => {
+  if (v === void 0 && optional) return void 0;
+  if (typeof v !== "string" || !optional && !v.length) fail(path, "must be a non-empty string");
+  return v;
+};
+var num = (v, path, { min, positive, optional, max } = {}) => {
+  if (v === void 0 && optional) return void 0;
+  if (typeof v !== "number" || !Number.isFinite(v)) return fail(path, "must be a number");
+  if (positive && !(v > 0)) fail(path, "must be greater than 0");
+  if (min !== void 0 && v < min) fail(path, `must be at least ${min}`);
+  if (max !== void 0 && v > max) fail(path, `must be at most ${max}`);
+  return v;
+};
+var bool = (v, path) => {
+  if (v === void 0) return void 0;
+  if (typeof v !== "boolean") fail(path, "must be true or false");
+  return v;
+};
+var oneOf = (v, options, path, optional = true) => {
+  if (v === void 0 && optional) return void 0;
+  if (!options.includes(v)) fail(path, `must be one of ${options.map((o) => `"${o}"`).join(", ")}`);
+  return v;
+};
+var compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== void 0));
+function parseVideoTransform(v, path) {
+  if (v === void 0) return void 0;
+  if (!isObject(v)) return fail(path, "must be an object { x, y, scale, rotation }");
+  for (const key of Object.keys(v)) if (!["x", "y", "scale", "rotation"].includes(key)) fail(`${path}.${key}`, "is not a transform field (x, y, scale, rotation)");
+  return compact({ x: num(v.x, `${path}.x`, { optional: true }), y: num(v.y, `${path}.y`, { optional: true }), scale: num(v.scale, `${path}.scale`, { optional: true, min: 0 }), rotation: num(v.rotation, `${path}.rotation`, { optional: true }) });
+}
+function parseVideoTransition(v, path) {
+  if (v === void 0) return void 0;
+  if (!isObject(v)) return fail(path, "must be an object { type, duration }");
+  return compact({
+    type: oneOf(v.type, VIDEO_TRANSITION_TYPES, `${path}.type`, false),
+    duration: num(v.duration, `${path}.duration`, { positive: true }),
+    color: str(v.color, `${path}.color`, true),
+    direction: oneOf(v.direction, VIDEO_WIPE_DIRECTIONS, `${path}.direction`)
+  });
+}
+function parseVideoAsset(v, path = "asset") {
+  if (!isObject(v)) return fail(path, "must be an object");
+  const kind = oneOf(v.kind, ["video", "audio", "image"], `${path}.kind`, false);
+  const asset = compact({
+    id: str(v.id, `${path}.id`),
+    kind,
+    src: str(v.src, `${path}.src`),
+    name: str(v.name, `${path}.name`, true),
+    duration: num(v.duration, `${path}.duration`, { optional: true, positive: true }),
+    width: num(v.width, `${path}.width`, { optional: true, positive: true }),
+    height: num(v.height, `${path}.height`, { optional: true, positive: true }),
+    hasAudio: bool(v.hasAudio, `${path}.hasAudio`),
+    poster: str(v.poster, `${path}.poster`, true)
+  });
+  if (kind === "image" && asset.duration !== void 0) fail(`${path}.duration`, "is only for video and audio assets");
+  return asset;
+}
+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);
+  const base = {
+    id: str(v.id, `${path}.id`),
+    name: str(v.name, `${path}.name`, true),
+    start: num(v.start, `${path}.start`, { min: 0 }),
+    duration: num(v.duration, `${path}.duration`, { positive: true }),
+    opacity: num(v.opacity, `${path}.opacity`, { optional: true, min: 0, max: 1 }),
+    transform: parseVideoTransform(v.transform, `${path}.transform`),
+    fit: oneOf(v.fit, VIDEO_FITS, `${path}.fit`),
+    fadeIn: num(v.fadeIn, `${path}.fadeIn`, { optional: true, min: 0 }),
+    fadeOut: num(v.fadeOut, `${path}.fadeOut`, { optional: true, min: 0 }),
+    transition: parseVideoTransition(v.transition, `${path}.transition`)
+  };
+  if (type === "media")
+    return compact({
+      type,
+      ...base,
+      asset: str(v.asset, `${path}.asset`),
+      in: num(v.in, `${path}.in`, { optional: true, min: 0 }),
+      speed: num(v.speed, `${path}.speed`, { optional: true, min: 0.05, max: 20 }),
+      volume: num(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
+      muted: bool(v.muted, `${path}.muted`)
+    });
+  if (type === "text")
+    return compact({
+      type,
+      ...base,
+      text: str(v.text, `${path}.text`),
+      color: str(v.color, `${path}.color`, true),
+      fontSize: num(v.fontSize, `${path}.fontSize`, { optional: true, positive: true }),
+      fontFamily: str(v.fontFamily, `${path}.fontFamily`, true),
+      fontWeight: num(v.fontWeight, `${path}.fontWeight`, { optional: true, min: 100, max: 1e3 }),
+      background: str(v.background, `${path}.background`, true)
+    });
+  return compact({ type, ...base, color: str(v.color, `${path}.color`) });
+}
+function parseVideoTrack(v, path = "track") {
+  if (!isObject(v)) return fail(path, "must be an object");
+  if (v.clips !== void 0 && !Array.isArray(v.clips)) fail(`${path}.clips`, "must be an array");
+  return compact({
+    id: str(v.id, `${path}.id`),
+    kind: oneOf(v.kind, ["video", "audio"], `${path}.kind`, false),
+    name: str(v.name, `${path}.name`, true),
+    muted: bool(v.muted, `${path}.muted`),
+    hidden: bool(v.hidden, `${path}.hidden`),
+    locked: bool(v.locked, `${path}.locked`),
+    volume: num(v.volume, `${path}.volume`, { optional: true, min: 0, max: 4 }),
+    clips: (v.clips ?? []).map((c, i) => parseVideoClip(c, `${path}.clips[${i}]`))
+  });
+}
+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) });
+}
+function parseVideoProject(input) {
+  let v = input;
+  if (typeof v === "string") {
+    try {
+      v = JSON.parse(v);
+    } catch (error) {
+      throw new Error(`The project is not valid JSON: ${error.message}`);
+    }
+  }
+  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");
+  const project = compact({
+    version: 1,
+    name: str(v.name, "name", true),
+    width: num(v.width, "width", { positive: true }),
+    height: num(v.height, "height", { positive: true }),
+    fps: num(v.fps ?? 30, "fps", { positive: true, max: 240 }),
+    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}]`)),
+    markers: v.markers === void 0 ? void 0 : v.markers.map((m, i) => parseVideoMarker(m, `markers[${i}]`))
+  });
+  const unique = (ids, what) => {
+    const seen = /* @__PURE__ */ new Set();
+    for (const id of ids) {
+      if (seen.has(id)) throw new Error(`Two ${what} share the id "${id}"; ids must be unique.`);
+      seen.add(id);
+    }
+  };
+  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.markers ?? []).map((m) => m.id), "markers");
+  return project;
+}
+function createVideoProject(options = {}) {
+  return compact({
+    version: 1,
+    name: options.name,
+    width: options.width ?? 1920,
+    height: options.height ?? 1080,
+    fps: options.fps ?? 30,
+    background: options.background,
+    assets: [],
+    tracks: [
+      { id: "v1", kind: "video", name: "Video 1", clips: [] },
+      { id: "a1", kind: "audio", name: "Audio 1", clips: [] }
+    ]
+  });
+}
+
+// src/video-editor/timeline.ts
+var VIDEO_TIME_EPSILON = 0.5;
+var videoClipEnd = (clip) => clip.start + clip.duration;
+var videoClipSpeed = (clip) => clip.type === "media" ? clip.speed ?? 1 : 1;
+function videoClipSourceRange(clip) {
+  if (clip.type !== "media") return null;
+  const start = clip.in ?? 0;
+  return { in: start, out: start + clip.duration * videoClipSpeed(clip) };
+}
+var videoFrameDuration = (fps) => 1e3 / fps;
+function snapToVideoFrame(time, fps) {
+  const frame = Math.round(time * fps / 1e3);
+  return Math.round(frame * 1e3 / fps * 1e3) / 1e3;
+}
+var videoFrames = (time, fps) => Math.round(time * fps / 1e3);
+function formatVideoTimecode(time, fps) {
+  const base = Math.round(fps);
+  const total = Math.max(0, videoFrames(time, fps));
+  const ff = total % base;
+  const secs = Math.floor(total / base);
+  const pad = (n2) => String(n2).padStart(2, "0");
+  return `${pad(Math.floor(secs / 3600))}:${pad(Math.floor(secs / 60) % 60)}:${pad(secs % 60)}:${pad(ff)}`;
+}
+var formatVideoSeconds = (time) => `${(time / 1e3).toFixed(2)} s`;
+function videoAssetMap(project) {
+  return new Map(project.assets.map((a) => [a.id, a]));
+}
+function sortedVideoClips(track) {
+  return [...track.clips].sort((a, b) => a.start - b.start || a.duration - b.duration);
+}
+function findVideoClip(project, id) {
+  for (let trackIndex = 0; trackIndex < project.tracks.length; trackIndex++) {
+    const track = project.tracks[trackIndex];
+    const index = track.clips.findIndex((c) => c.id === id);
+    if (index >= 0) return { track, trackIndex, clip: track.clips[index], index };
+  }
+  return null;
+}
+function allVideoClipIds(project) {
+  return project.tracks.flatMap((t) => t.clips.map((c) => c.id));
+}
+function videoProjectDuration(project) {
+  let end = 0;
+  for (const track of project.tracks) for (const clip of track.clips) end = Math.max(end, videoClipEnd(clip));
+  return end;
+}
+function videoClipBefore(track, clip) {
+  let best = null;
+  for (const c of track.clips) if (c !== clip && Math.abs(videoClipEnd(c) - clip.start) <= VIDEO_TIME_EPSILON) best = c;
+  return best;
+}
+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) {
+  if (clip.type !== "media") return { before: Infinity, after: Infinity };
+  const asset = assets.get(clip.asset);
+  const speed = videoClipSpeed(clip);
+  const range = videoClipSourceRange(clip);
+  const before = range.in / speed;
+  if (!asset || asset.kind === "image" || asset.duration === void 0) return { before: asset?.kind === "image" ? Infinity : before, after: Infinity };
+  return { before, after: Math.max(0, (asset.duration - range.out) / speed) };
+}
+function videoClipOverhang(track, clip) {
+  const lead = clip.transition && clip.transition.type !== "dip" && videoClipBefore(track, clip) ? clip.transition.duration / 2 : 0;
+  const next = videoClipAfter(track, clip);
+  const tail = next?.transition && next.transition.type !== "dip" ? next.transition.duration / 2 : 0;
+  return { lead, tail };
+}
+function videoSnapPoints(project, options = {}) {
+  const exclude = new Set(options.exclude ?? []);
+  const points = /* @__PURE__ */ new Set([0]);
+  for (const track of project.tracks)
+    for (const clip of track.clips) {
+      if (exclude.has(clip.id)) continue;
+      points.add(clip.start);
+      points.add(videoClipEnd(clip));
+    }
+  for (const marker of project.markers ?? []) points.add(marker.time);
+  if (options.playhead !== void 0) points.add(options.playhead);
+  return [...points].sort((a, b) => a - b);
+}
+function snapVideoTime(time, points, threshold) {
+  let best = null;
+  for (const p of points) if (Math.abs(p - time) <= threshold && (best === null || Math.abs(p - time) < Math.abs(best - time))) best = p;
+  return best === null ? { time, snapped: null } : { time: best, snapped: best };
+}
+function findVideoGaps(project, trackId) {
+  const gaps = [];
+  for (const track of project.tracks) {
+    if (trackId !== void 0 && track.id !== trackId) continue;
+    let at = 0;
+    for (const clip of sortedVideoClips(track)) {
+      if (clip.start - at > VIDEO_TIME_EPSILON) gaps.push({ track: track.id, start: at, end: clip.start });
+      at = Math.max(at, videoClipEnd(clip));
+    }
+  }
+  return gaps;
+}
+function videoOverlap(track, start, end, ignore = /* @__PURE__ */ new Set()) {
+  for (const c of sortedVideoClips(track)) {
+    if (ignore.has(c.id)) continue;
+    if (c.start < end - VIDEO_TIME_EPSILON && videoClipEnd(c) > start + VIDEO_TIME_EPSILON) return c;
+  }
+  return null;
+}
+function nextFreeVideoSlot(track, from, duration, ignore = /* @__PURE__ */ new Set()) {
+  let at = from;
+  for (const c of sortedVideoClips(track)) {
+    if (ignore.has(c.id)) continue;
+    if (videoClipEnd(c) <= at + VIDEO_TIME_EPSILON) continue;
+    if (c.start >= at + duration - VIDEO_TIME_EPSILON) break;
+    at = videoClipEnd(c);
+  }
+  return at;
+}
+function videoClipsAt(project, time) {
+  const out = [];
+  for (const track of project.tracks) for (const clip of track.clips) if (time >= clip.start && time < videoClipEnd(clip)) out.push({ track: track.id, clip });
+  return out;
+}
+
+// src/video-editor/check.ts
+var VIDEO_ISSUE_CODES = [
+  "missing-asset",
+  "wrong-track",
+  "overlap",
+  "source-overrun",
+  "transition-without-cut",
+  "transition-too-long",
+  "transition-handles",
+  "fades-too-long",
+  "unknown-duration",
+  "unused-asset",
+  "marker-past-end",
+  "empty"
+];
+var videoIssueKey = (i) => [i.code, i.track ?? "", i.clip ?? "", i.asset ?? "", i.marker ?? ""].join("|");
+function checkVideoProject(project) {
+  const issues = [];
+  const assets = videoAssetMap(project);
+  const used = /* @__PURE__ */ new Set();
+  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 clips = sortedVideoClips(track);
+    for (let i = 0; i < clips.length; i++) {
+      const clip = clips[i];
+      const at = { track: track.id, clip: clip.id };
+      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.` });
+        else {
+          if (track.kind === "audio" && asset.kind === "image") issues.push({ code: "wrong-track", severity: "error", ...at, message: `Clip "${clip.id}" is an image on audio track "${track.id}"; move it to a video track.` });
+          if (track.kind === "video" && asset.kind === "audio") issues.push({ code: "wrong-track", severity: "error", ...at, message: `Clip "${clip.id}" is audio on video track "${track.id}"; move it to an audio track.` });
+          const range = videoClipSourceRange(clip);
+          if (asset.duration !== void 0 && range.out > asset.duration + VIDEO_TIME_EPSILON)
+            issues.push({ code: "source-overrun", severity: "error", ...at, message: `Clip "${clip.id}" plays to ${formatVideoSeconds(range.out)} of "${asset.id}", which is only ${formatVideoSeconds(asset.duration)} long; shorten the clip or move its in point.` });
+        }
+      } else if (track.kind === "audio") issues.push({ code: "wrong-track", severity: "error", ...at, message: `Clip "${clip.id}" is a ${clip.type} clip on audio track "${track.id}"; move it to a video track.` });
+      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.` });
+      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.` });
+      if (clip.transition) {
+        const d = clip.transition.duration;
+        const before = videoClipBefore(track, clip);
+        if (!before) {
+          issues.push({ code: "transition-without-cut", severity: "warning", ...at, message: `Clip "${clip.id}" has a transition but no clip ends where it starts on track "${track.id}", so it plays as nothing; butt a clip up against it or remove the transition.` });
+          continue;
+        }
+        if (d > clip.duration + VIDEO_TIME_EPSILON || d > before.duration + VIDEO_TIME_EPSILON) {
+          issues.push({ code: "transition-too-long", severity: "error", ...at, message: `The ${d} ms transition into "${clip.id}" is longer than "${clip.id}" (${clip.duration} ms) or "${before.id}" (${before.duration} ms); make it at most ${Math.min(clip.duration, before.duration)} ms.` });
+          continue;
+        }
+        if (clip.transition.type === "dip") continue;
+        const outgoing = videoClipHandles(before, assets).after;
+        const incoming = videoClipHandles(clip, assets).before;
+        const half = d / 2;
+        if (outgoing < half - VIDEO_TIME_EPSILON || incoming < half - VIDEO_TIME_EPSILON) {
+          const fits = 2 * Math.min(outgoing, incoming);
+          issues.push({
+            code: "transition-handles",
+            severity: "error",
+            ...at,
+            message: `The ${d} ms transition into "${clip.id}" needs ${half} ms of media past the cut on both sides, but "${before.id}" has ${Math.floor(outgoing)} ms after its out point and "${clip.id}" ${Math.floor(incoming)} ms before its in point; make it at most ${Math.floor(fits)} ms, or trim the clips to leave handles.`
+          });
+        }
+      }
+    }
+  }
+  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 ?? [])
+    if (marker.time > end + VIDEO_TIME_EPSILON) issues.push({ code: "marker-past-end", severity: "note", marker: marker.id, message: `Marker "${marker.id}" at ${formatVideoSeconds(marker.time)} is past the end (${formatVideoSeconds(end)}).` });
+  if (!project.tracks.some((t) => t.clips.length)) issues.push({ code: "empty", severity: "note", message: "The project has no clips yet; add assets and then clips." });
+  const rank = { error: 0, warning: 1, note: 2 };
+  return issues.sort((a, b) => rank[a.severity] - rank[b.severity]);
+}
+
+// src/video-editor/edit.ts
+var VIDEO_EDIT_OPS = [
+  "set_settings",
+  "add_asset",
+  "update_asset",
+  "remove_asset",
+  "add_track",
+  "update_track",
+  "remove_track",
+  "move_track",
+  "add_clip",
+  "move_clip",
+  "trim_clip",
+  "split_clip",
+  "delete_clips",
+  "update_clip",
+  "set_transition",
+  "close_gaps",
+  "add_marker",
+  "update_marker",
+  "remove_marker",
+  "replace_project"
+];
+var VIDEO_DEFAULT_STILL_DURATION = 5e3;
+var VIDEO_DEFAULT_TITLE_DURATION = 3e3;
+var EditError = class extends Error {
+};
+var refuse = (message) => {
+  throw new EditError(message);
+};
+function freshId(prefix, taken) {
+  const used = new Set(taken);
+  for (let n2 = 1; ; n2++) if (!used.has(`${prefix}${n2}`)) return `${prefix}${n2}`;
+}
+var slug = (s) => s.replace(/^.*[\\/]/, "").replace(/\.[a-z0-9]+(\?.*)?$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
+var OPTIONAL_CLIP_FIELDS = ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "transition", "in", "speed", "volume", "muted", "color", "fontSize", "fontFamily", "fontWeight", "background"];
+var Editor = class {
+  constructor(p) {
+    this.p = p;
+  }
+  p;
+  outcomes = [];
+  track(id) {
+    const t = this.p.tracks.find((x) => x.id === id);
+    if (!t) refuse(`There is no track ${namedWithSuggestion(id, this.p.tracks.map((x) => x.id))}; the tracks are ${this.p.tracks.map((x) => `"${x.id}" (${x.kind})`).join(", ") || "none"}.`);
+    return t;
+  }
+  clip(id) {
+    const at = findVideoClip(this.p, id);
+    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"}.`);
+    }
+    return at;
+  }
+  unlocked(track) {
+    if (track.locked) refuse(`Track "${track.id}" is locked; unlock it (update_track with locked false) first.`);
+  }
+  asset(id) {
+    const a = this.p.assets.find((x) => x.id === id);
+    if (!a) refuse(`There is no asset ${namedWithSuggestion(id, this.p.assets.map((x) => x.id))}; add it first (the assets are ${this.p.assets.map((x) => `"${x.id}"`).join(", ") || "none yet"}).`);
+    return a;
+  }
+  fits(track, start, duration, ignore, what) {
+    const hit = videoOverlap(track, start, start + duration, ignore);
+    if (hit) {
+      const free = nextFreeVideoSlot(track, start, duration, ignore);
+      refuse(`${what} at ${formatVideoSeconds(start)}\u2013${formatVideoSeconds(start + duration)} would overlap clip "${hit.id}" (${formatVideoSeconds(hit.start)}\u2013${formatVideoSeconds(videoClipEnd(hit))}) on track "${track.id}"; the next free place is ${formatVideoSeconds(free)}, or pass ripple to push later clips along.`);
+    }
+  }
+  kindFits(track, clip) {
+    const asset = clip.type === "media" ? this.asset(clip.asset) : null;
+    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.`);
+  }
+  /** Moves every clip on `track` starting at or after `from` by `delta`. */
+  shift(track, from, delta, except = /* @__PURE__ */ new Set()) {
+    if (!delta) return;
+    for (const c of track.clips) if (!except.has(c.id) && c.start >= from - VIDEO_TIME_EPSILON) c.start = Math.max(0, c.start + delta);
+  }
+  run(e) {
+    switch (e.op) {
+      case "set_settings": {
+        const { op: _op, ...settings } = e;
+        for (const [k, v] of Object.entries(settings)) {
+          if (!["name", "width", "height", "fps", "background"].includes(k)) refuse(`"${k}" is not a setting; use name, width, height, fps or background.`);
+          if (v !== void 0) this.p[k] = v;
+        }
+        return this.outcomes.push({ op: e.op });
+      }
+      case "add_asset": {
+        const ids = this.p.assets.map((a) => a.id);
+        if (e.asset.id !== void 0 && ids.includes(e.asset.id)) refuse(`There is already an asset "${e.asset.id}"; pick another id or use update_asset.`);
+        const base = slug(e.asset.name ?? e.asset.src ?? "") || e.asset.kind || "asset";
+        const unique = e.asset.id ?? (ids.includes(base) ? freshId(`${base}-`, ids) : base);
+        this.p.assets.push(parseVideoAsset({ ...e.asset, id: unique }));
+        return this.outcomes.push({ op: e.op, asset: unique });
+      }
+      case "update_asset": {
+        const asset = this.asset(e.asset);
+        if (e.set && "id" in e.set) refuse("An asset's id cannot be changed.");
+        const next = { ...asset, ...e.set };
+        for (const k of e.remove ?? []) delete next[k];
+        this.p.assets[this.p.assets.indexOf(asset)] = parseVideoAsset(next);
+        return this.outcomes.push({ op: e.op, asset: asset.id });
+      }
+      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));
+        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 });
+      }
+      case "add_track": {
+        const ids = this.p.tracks.map((t) => t.id);
+        if (e.track.id && ids.includes(e.track.id)) refuse(`There is already a track "${e.track.id}".`);
+        const id = e.track.id ?? freshId(e.track.kind === "video" ? "v" : "a", ids);
+        const n2 = this.p.tracks.filter((t) => t.kind === e.track.kind).length + 1;
+        const track = { name: `${e.track.kind === "video" ? "Video" : "Audio"} ${n2}`, ...e.track, id, clips: [] };
+        const at = e.at ?? (e.track.kind === "video" ? 0 : this.p.tracks.length);
+        if (at > this.p.tracks.length) refuse(`"at" is ${at} but there are only ${this.p.tracks.length} tracks; use 0\u2013${this.p.tracks.length}.`);
+        this.p.tracks.splice(at, 0, track);
+        return this.outcomes.push({ op: e.op, track: id });
+      }
+      case "update_track": {
+        const track = this.track(e.track);
+        for (const k of Object.keys(e.set ?? {})) if (!["name", "muted", "hidden", "locked", "volume"].includes(k)) refuse(`"${k}" cannot be set on a track; use name, muted, hidden, locked or volume.`);
+        Object.assign(track, e.set);
+        for (const k of e.remove ?? []) delete track[k];
+        return this.outcomes.push({ op: e.op, track: track.id });
+      }
+      case "remove_track": {
+        const track = this.track(e.track);
+        this.unlocked(track);
+        this.p.tracks = this.p.tracks.filter((t) => t !== track);
+        return this.outcomes.push({ op: e.op, track: track.id, clips: track.clips.map((c) => c.id) });
+      }
+      case "move_track": {
+        const track = this.track(e.track);
+        if (e.to < 0 || e.to >= this.p.tracks.length) refuse(`"to" must be 0\u2013${this.p.tracks.length - 1}.`);
+        this.p.tracks.splice(this.p.tracks.indexOf(track), 1);
+        this.p.tracks.splice(e.to, 0, track);
+        return this.outcomes.push({ op: e.op, track: track.id });
+      }
+      case "add_clip": {
+        const track = this.track(e.track);
+        this.unlocked(track);
+        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));
+        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) {
+          if (draft.type === "media") {
+            const asset = this.asset(draft.asset);
+            if (asset.kind === "image") draft.duration = VIDEO_DEFAULT_STILL_DURATION;
+            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 draft.duration = VIDEO_DEFAULT_TITLE_DURATION;
+        }
+        const end = sortedVideoClips(track).reduce((m, c) => Math.max(m, videoClipEnd(c)), 0);
+        draft.start ??= end;
+        const clip = parseVideoClip(draft, "clip");
+        if (e.ripple) {
+          const inside = track.clips.find((c) => c.start < clip.start - VIDEO_TIME_EPSILON && videoClipEnd(c) > clip.start + VIDEO_TIME_EPSILON);
+          if (inside) refuse(`${formatVideoSeconds(clip.start)} is inside clip "${inside.id}"; split it there first (split_clip), or insert at its start or end.`);
+          this.shift(track, clip.start, clip.duration);
+        } else this.fits(track, clip.start, clip.duration, /* @__PURE__ */ new Set(), `Clip "${clip.id}"`);
+        track.clips.push(clip);
+        track.clips.sort((a, b) => a.start - b.start);
+        return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
+      }
+      case "move_clip": {
+        const from = this.clip(e.clip);
+        this.unlocked(from.track);
+        const to = e.track !== void 0 ? this.track(e.track) : from.track;
+        this.unlocked(to);
+        if (to !== from.track) this.kindFits(to, from.clip);
+        const start = e.start ?? from.clip.start;
+        this.fits(to, start, from.clip.duration, /* @__PURE__ */ new Set([from.clip.id]), `Clip "${from.clip.id}"`);
+        from.clip.start = start;
+        if (to !== from.track) {
+          from.track.clips.splice(from.index, 1);
+          to.clips.push(from.clip);
+        }
+        to.clips.sort((a, b) => a.start - b.start);
+        return this.outcomes.push({ op: e.op, clip: from.clip.id, track: to.id });
+      }
+      case "trim_clip": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        const speed = videoClipSpeed(clip);
+        const end = videoClipEnd(clip);
+        const minimum = 1e3 / this.p.fps;
+        const assets = videoAssetMap(this.p);
+        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") {
+            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);
+            if (clip.in === 0) delete clip.in;
+          }
+          if (e.ripple) {
+            clip.duration -= delta;
+            this.shift(track, end, -delta, /* @__PURE__ */ new Set([clip.id]));
+          } else {
+            if (e.to < 0) refuse("A clip cannot start before 0.");
+            if (delta < 0) this.fits(track, e.to, -delta, /* @__PURE__ */ new Set([clip.id]), `Extending "${clip.id}"`);
+            clip.start = e.to;
+            clip.duration -= delta;
+          }
+        } else {
+          const duration = e.to - clip.start;
+          if (duration < minimum - VIDEO_TIME_EPSILON) refuse(`Trimming the end to ${formatVideoSeconds(e.to)} would leave "${clip.id}" shorter than a frame; it starts at ${formatVideoSeconds(clip.start)}.`);
+          if (clip.type === "media") {
+            const asset = assets.get(clip.asset);
+            const out = (clip.in ?? 0) + duration * speed;
+            if (asset?.duration !== void 0 && out > asset.duration + VIDEO_TIME_EPSILON)
+              refuse(`"${clip.id}" can end at most at ${formatVideoSeconds(clip.start + (asset.duration - (clip.in ?? 0)) / speed)}, where "${asset.id}" runs out.`);
+          }
+          if (e.ripple) this.shift(track, end, e.to - end, /* @__PURE__ */ new Set([clip.id]));
+          else if (e.to > end) this.fits(track, end, e.to - end, /* @__PURE__ */ new Set([clip.id]), `Extending "${clip.id}"`);
+          clip.duration = duration;
+        }
+        return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
+      }
+      case "split_clip": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        const end = videoClipEnd(clip);
+        const minimum = 1e3 / this.p.fps;
+        if (e.at < clip.start + minimum - VIDEO_TIME_EPSILON || e.at > end - minimum + VIDEO_TIME_EPSILON) refuse(`${formatVideoSeconds(e.at)} is not inside "${clip.id}" (${formatVideoSeconds(clip.start)}\u2013${formatVideoSeconds(end)}), at least a frame from either end.`);
+        const ids = this.p.tracks.flatMap((t) => t.clips.map((c) => c.id));
+        if (e.id !== void 0 && ids.includes(e.id)) refuse(`There is already a clip "${e.id}".`);
+        const id = e.id ?? freshId(`${clip.id}-`, ids);
+        const left = e.at - clip.start;
+        const right = { ...structuredClone(clip), id, start: e.at, duration: end - e.at };
+        delete right.transition;
+        delete right.fadeIn;
+        if (clip.type === "media") {
+          right.in = (clip.in ?? 0) + left * videoClipSpeed(clip);
+        }
+        clip.duration = left;
+        delete clip.fadeOut;
+        track.clips.push(right);
+        track.clips.sort((a, b) => a.start - b.start);
+        return this.outcomes.push({ op: e.op, clips: [clip.id, id], clip: id, track: track.id });
+      }
+      case "delete_clips": {
+        const found = [...new Set(e.clips)].map((id) => this.clip(id));
+        for (const f of found) this.unlocked(f.track);
+        for (const track of new Set(found.map((f) => f.track))) {
+          const gone = found.filter((f) => f.track === track).map((f) => f.clip);
+          track.clips = track.clips.filter((c) => !gone.includes(c));
+          if (e.ripple) for (const c of [...gone].sort((a, b) => b.start - a.start)) this.shift(track, videoClipEnd(c), -c.duration);
+        }
+        return this.outcomes.push({ op: e.op, clips: found.map((f) => f.clip.id) });
+      }
+      case "update_clip": {
+        const at = this.clip(e.clip);
+        this.unlocked(at.track);
+        const set = { ...e.set ?? {} };
+        for (const k of ["id", "type"]) if (k in set) refuse(`A clip's ${k} cannot be changed; delete it and add a new one.`);
+        for (const k of e.remove ?? []) if (!OPTIONAL_CLIP_FIELDS.includes(k)) refuse(`"${k}" cannot be removed; removable fields are ${OPTIONAL_CLIP_FIELDS.join(", ")}.`);
+        if ("speed" in set && (typeof set.speed !== "number" || !(set.speed > 0))) refuse('"speed" must be a number greater than 0 (1 = normal speed).');
+        if (at.clip.type === "media" && !("duration" in set)) {
+          const was = videoClipSpeed(at.clip);
+          const now = "speed" in set ? set.speed : e.remove?.includes("speed") ? 1 : was;
+          if (now !== was) set.duration = at.clip.duration * was / now;
+        }
+        const next = { ...at.clip, ...set };
+        for (const k of e.remove ?? []) delete next[k];
+        const clip = parseVideoClip(next, "set");
+        if (clip.type === "media" && clip.asset !== at.clip.asset) this.kindFits(at.track, clip);
+        if (clip.start !== at.clip.start || clip.duration !== at.clip.duration) this.fits(at.track, clip.start, clip.duration, /* @__PURE__ */ new Set([clip.id]), `Clip "${clip.id}"`);
+        at.track.clips[at.index] = clip;
+        at.track.clips.sort((a, b) => a.start - b.start);
+        return this.outcomes.push({ op: e.op, clip: clip.id, track: at.track.id });
+      }
+      case "set_transition": {
+        const { track, clip } = this.clip(e.clip);
+        this.unlocked(track);
+        if (e.transition === null) delete clip.transition;
+        else clip.transition = parseVideoTransition(e.transition, "transition");
+        return this.outcomes.push({ op: e.op, clip: clip.id, track: track.id });
+      }
+      case "close_gaps": {
+        const track = this.track(e.track);
+        this.unlocked(track);
+        let at = 0;
+        const moved = [];
+        for (const clip of sortedVideoClips(track)) {
+          if (clip.start >= (e.from ?? 0) - VIDEO_TIME_EPSILON && clip.start > at + VIDEO_TIME_EPSILON) {
+            clip.start = Math.max(at, e.from ?? 0);
+            moved.push(clip.id);
+          }
+          at = Math.max(at, videoClipEnd(clip));
+        }
+        return this.outcomes.push({ op: e.op, track: track.id, clips: moved });
+      }
+      case "add_marker": {
+        const markers = this.p.markers ??= [];
+        if (e.marker.id !== void 0 && markers.some((m) => m.id === e.marker.id)) refuse(`There is already a marker "${e.marker.id}".`);
+        const marker = parseVideoMarker({ ...e.marker, id: e.marker.id ?? freshId("m", markers.map((m) => m.id)) });
+        markers.push(marker);
+        markers.sort((a, b) => a.time - b.time);
+        return this.outcomes.push({ op: e.op, marker: marker.id });
+      }
+      case "update_marker": {
+        const markers = this.p.markers ?? [];
+        const i = markers.findIndex((m) => m.id === e.marker);
+        if (i < 0) refuse(`There is no marker ${namedWithSuggestion(e.marker, markers.map((m) => m.id))}.`);
+        if (e.set && "id" in e.set) refuse("A marker's id cannot be changed.");
+        const next = { ...markers[i], ...e.set };
+        for (const k of e.remove ?? []) delete next[k];
+        markers[i] = parseVideoMarker(next);
+        markers.sort((a, b) => a.time - b.time);
+        return this.outcomes.push({ op: e.op, marker: e.marker });
+      }
+      case "remove_marker": {
+        const markers = this.p.markers ?? [];
+        if (!markers.some((m) => m.id === e.marker)) refuse(`There is no marker ${namedWithSuggestion(e.marker, markers.map((m) => m.id))}.`);
+        this.p.markers = markers.filter((m) => m.id !== e.marker);
+        if (!this.p.markers.length) delete this.p.markers;
+        return this.outcomes.push({ op: e.op, marker: e.marker });
+      }
+      case "replace_project": {
+        this.p = parseVideoProject(e.project);
+        return this.outcomes.push({ op: e.op });
+      }
+      default:
+        refuse(`Unknown op ${namedWithSuggestion(String(e.op), VIDEO_EDIT_OPS)}; the ops are ${VIDEO_EDIT_OPS.join(", ")}.`);
+    }
+  }
+};
+function applyVideoEdits(project, edits) {
+  const list = Array.isArray(edits) ? edits : [edits];
+  if (!list.length) return { ok: true, project, issues: checkVideoProject(project), outcomes: [] };
+  const editor = new Editor(structuredClone(project));
+  for (let i = 0; i < list.length; i++) {
+    const edit = list[i];
+    try {
+      editor.run(edit);
+    } catch (error) {
+      const message = error.message;
+      return { ok: false, error: `${list.length > 1 ? `op ${i + 1} (${edit?.op}): ` : ""}${message}${/Nothing was changed\.$/.test(message) ? "" : " Nothing was changed."}` };
+    }
+  }
+  let next;
+  try {
+    next = parseVideoProject(editor.p);
+  } catch (error) {
+    return { ok: false, error: `${error.message} Nothing was changed.` };
+  }
+  const before = new Set(checkVideoProject(project).filter((i) => i.severity === "error").map(videoIssueKey));
+  const issues = checkVideoProject(next);
+  const added = issues.find((i) => i.severity === "error" && !before.has(videoIssueKey(i)));
+  if (added) return { ok: false, error: `That would leave an error: ${added.message} Nothing was changed.` };
+  if (JSON.stringify(next) === JSON.stringify(project)) return { ok: true, project, issues, outcomes: editor.outcomes };
+  return { ok: true, project: next, issues, outcomes: editor.outcomes };
+}
+
+// src/video-editor/evaluate.ts
+function placeVideoRect(frame, size, fit = "contain", transform = {}) {
+  let w = size.width;
+  let h = size.height;
+  if (fit === "fill") {
+    w = frame.width;
+    h = frame.height;
+  } else if (fit !== "none") {
+    const k = fit === "cover" ? Math.max(frame.width / w, frame.height / h) : Math.min(frame.width / w, frame.height / h);
+    w *= k;
+    h *= k;
+  }
+  const scale = transform?.scale ?? 1;
+  w *= scale;
+  h *= scale;
+  const cx = frame.width / 2 + (transform?.x ?? 0);
+  const cy = frame.height / 2 + (transform?.y ?? 0);
+  return { x: cx - w / 2, y: cy - h / 2, width: w, height: h };
+}
+function videoTextStyle(clip) {
+  return { text: clip.text, color: clip.color ?? "#ffffff", fontSize: clip.fontSize ?? 64, fontFamily: clip.fontFamily ?? "sans-serif", fontWeight: clip.fontWeight ?? 700, ...clip.background ? { background: clip.background } : {} };
+}
+function videoTitleFrame(project, clip) {
+  const layer = { clip: clip.id, track: "", type: "text", opacity: 1, rect: placeVideoRect(project, project, "fill", clip.transform), rotation: clip.transform?.rotation ?? 0, text: videoTextStyle(clip) };
+  return { time: clip.start, width: project.width, height: project.height, background: "rgba(0,0,0,0)", layers: [layer], audio: [] };
+}
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+function fadeGain(clip, time) {
+  let g = 1;
+  if (clip.fadeIn) g *= clamp01((time - clip.start) / clip.fadeIn);
+  if (clip.fadeOut) g *= clamp01((videoClipEnd(clip) - time) / clip.fadeOut);
+  return g;
+}
+function activeOnTrack(track, time) {
+  const out = [];
+  for (const clip of sortedVideoClips(track)) {
+    const before = clip.transition ? videoClipBefore(track, clip) : null;
+    const lead = before ? clip.transition.duration / 2 : 0;
+    const next = videoClipAfter(track, clip);
+    const tail = next?.transition ? next.transition.duration / 2 : 0;
+    if (time < clip.start - lead || time >= videoClipEnd(clip) + tail) continue;
+    const a = { clip };
+    if (lead && time < clip.start + lead) a.incoming = { progress: clamp01((time - (clip.start - lead)) / (2 * lead)), type: clip.transition.type, transition: clip.transition };
+    if (tail && time >= videoClipEnd(clip) - tail) a.outgoing = { progress: clamp01((time - (videoClipEnd(clip) - tail)) / (2 * tail)), type: next.transition.type, next };
+    out.push(a);
+  }
+  return out;
+}
+var sourceTimeAt = (clip, time) => clip.type === "media" ? (clip.in ?? 0) + (time - clip.start) * videoClipSpeed(clip) : 0;
+function videoFrameAt(project, time) {
+  const assets = videoAssetMap(project);
+  const layers = [];
+  const audio = [];
+  for (let ti = project.tracks.length - 1; ti >= 0; ti--) {
+    const track = project.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;
+      const fade = fadeGain(clip, Math.min(Math.max(time, clip.start), videoClipEnd(clip)));
+      const level = (t, into) => t.type === "dip" ? Math.abs(1 - 2 * t.progress) : into ? t.progress : 1 - t.progress;
+      const mix = (incoming ? level(incoming, true) : 1) * (outgoing ? level(outgoing, false) : 1);
+      const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
+      const sourceTime = sourceTimeAt(clip, time);
+      const audible = asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
+      if (audible && clip.type === "media" && !clip.muted && !track.muted) {
+        const gain = (clip.volume ?? 1) * (track.volume ?? 1) * fade * mix;
+        audio.push({ clip: clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeed(clip) });
+      }
+      if (track.kind !== "video" || track.hidden) continue;
+      if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
+      let opacity = (clip.opacity ?? 1) * fade;
+      let wipe;
+      let dip = null;
+      if (incoming) {
+        if (incoming.type === "crossfade") opacity *= incoming.progress;
+        else if (incoming.type === "wipe") wipe = { direction: incoming.transition.direction ?? "right", progress: incoming.progress };
+        else dip = { color: incoming.transition.color ?? "#000000", opacity: (1 - incoming.progress) * 2 };
+      }
+      if (outgoing?.type === "dip") dip = { color: outgoing.next.transition.color ?? "#000000", opacity: outgoing.progress * 2 };
+      const size = clip.type === "media" ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
+      const fit = clip.fit ?? (clip.type === "media" ? "contain" : "fill");
+      const rect = clip.type === "text" ? placeVideoRect(project, size, "fill", clip.transform) : placeVideoRect(project, size, fit, clip.transform);
+      const layer = { clip: clip.id, track: track.id, type: clip.type, opacity: clamp01(opacity), rect, rotation: clip.transform?.rotation ?? 0 };
+      if (wipe) layer.wipe = wipe;
+      if (clip.type === "media") Object.assign(layer, { asset: asset.id, assetKind: asset.kind, src: asset.src, sourceTime });
+      if (clip.type === "text") layer.text = videoTextStyle(clip);
+      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: clamp01(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 };
+}
+
+// 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);
+function videoWipeRect(rect, wipe) {
+  const { direction, progress } = wipe;
+  const w = rect.width * progress;
+  const h = rect.height * progress;
+  if (direction === "right") return { ...rect, width: w };
+  if (direction === "left") return { ...rect, x: rect.x + rect.width - w, width: w };
+  if (direction === "down") return { ...rect, height: h };
+  return { ...rect, y: rect.y + rect.height - h, height: h };
+}
+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 { rect } = layer;
+    const attrs = [];
+    if (layer.opacity < 1) attrs.push(`opacity="${n(layer.opacity)}"`);
+    if (layer.rotation) attrs.push(`transform="rotate(${n(layer.rotation)} ${n(rect.x + rect.width / 2)} ${n(rect.y + rect.height / 2)})"`);
+    if (layer.wipe) {
+      const r = videoWipeRect(rect, layer.wipe);
+      defs.push(`<clipPath id="w${i}"><rect x="${n(r.x)}" y="${n(r.y)}" width="${n(r.width)}" height="${n(r.height)}"/></clipPath>`);
+      attrs.push(`clip-path="url(#w${i})"`);
+    }
+    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")}"/>`;
+    else if (layer.type === "text" && layer.text) {
+      const t = layer.text;
+      const lines = t.text.split("\n");
+      const lh = t.fontSize * 1.2;
+      const cx = rect.x + rect.width / 2;
+      const cy = rect.y + rect.height / 2;
+      const top = cy - lh * (lines.length - 1) / 2;
+      if (t.background) {
+        const w = Math.max(...lines.map((l) => l.length)) * t.fontSize * 0.6 + t.fontSize;
+        const h = lh * lines.length + t.fontSize * 0.4;
+        inner += `<rect x="${n(cx - w / 2)}" y="${n(cy - h / 2)}" width="${n(w)}" height="${n(h)}" fill="${esc(t.background)}"/>`;
+      }
+      inner += `<text x="${n(cx)}" text-anchor="middle" dominant-baseline="central" font-family="${esc(t.fontFamily)}" font-size="${n(t.fontSize)}" font-weight="${t.fontWeight}" fill="${esc(t.color)}">${lines.map((l, k) => `<tspan x="${n(cx)}" y="${n(top + k * lh)}">${esc(l)}</tspan>`).join("")}</text>`;
+    } else {
+      const href = options.imageFor ? options.imageFor(layer, frame) : layer.assetKind === "image" ? layer.src ?? null : posters.get(layer.asset ?? "") ?? null;
+      if (href) inner = `<image href="${esc(href)}" ${box} preserveAspectRatio="none"/>`;
+      else {
+        const label = `${layer.asset ?? layer.clip} \xB7 ${formatVideoTimecode(layer.sourceTime ?? 0, options.fps ?? 30)}`;
+        const size = Math.max(10, Math.min(rect.height / 8, rect.width / Math.max(8, label.length * 0.6)));
+        inner = `<rect ${box} fill="#334155" stroke="#94a3b8" stroke-width="2"/><text x="${n(rect.x + rect.width / 2)}" y="${n(rect.y + rect.height / 2)}" text-anchor="middle" dominant-baseline="central" font-family="sans-serif" font-size="${n(size)}" fill="#e2e8f0">${esc(label)}</text>`;
+      }
+    }
+    body.push(attrs.length ? `<g ${attrs.join(" ")}>${inner}</g>` : inner);
+  });
+  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>`;
+}
+function videoProjectSvg(project, time, options = {}) {
+  return videoFrameToSvg(videoFrameAt(project, time), { fps: project.fps, ...options }, project.assets);
+}
+function videoContactSheetSvg(project, times, options = {}) {
+  const columns = options.columns ?? Math.ceil(Math.sqrt(times.length));
+  const w = options.width ?? 320;
+  const h = w * project.height / project.width;
+  const label = 18;
+  const gap = 8;
+  const rows = Math.ceil(times.length / columns);
+  const W = columns * w + (columns + 1) * gap;
+  const H = rows * (h + label) + (rows + 1) * gap;
+  const cells = times.map((t, i) => {
+    const x = gap + i % columns * (w + gap);
+    const y = gap + Math.floor(i / columns) * (h + label + gap);
+    const svg = videoProjectSvg(project, t, options).replace(/^<svg xmlns="http:\/\/www.w3.org\/2000\/svg"/, `<svg x="${n(x)}" y="${n(y)}" width="${n(w)}" height="${n(h)}"`).replace(/ width="[\d.]+" height="[\d.]+">/, ">");
+    return `${svg}<text x="${n(x)}" y="${n(y + h + 14)}" font-family="sans-serif" font-size="12" fill="#0f172a">${(t / 1e3).toFixed(2)} s \xB7 ${formatVideoTimecode(t, project.fps)}</text>`;
+  });
+  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(W)} ${n(H)}" width="${n(W)}" height="${n(H)}"><rect width="100%" height="100%" fill="#f8fafc"/>${cells.join("")}</svg>`;
+}
+function drawVideoFrame(ctx, frame, sourceFor, scale = 1) {
+  ctx.save();
+  ctx.setTransform(scale, 0, 0, scale, 0, 0);
+  ctx.globalAlpha = 1;
+  ctx.fillStyle = frame.background;
+  ctx.fillRect(0, 0, frame.width, frame.height);
+  for (const layer of frame.layers) {
+    const { rect } = layer;
+    ctx.save();
+    ctx.globalAlpha = layer.opacity;
+    if (layer.rotation) {
+      ctx.translate(rect.x + rect.width / 2, rect.y + rect.height / 2);
+      ctx.rotate(layer.rotation * Math.PI / 180);
+      ctx.translate(-(rect.x + rect.width / 2), -(rect.y + rect.height / 2));
+    }
+    if (layer.wipe) {
+      const r = videoWipeRect(rect, layer.wipe);
+      ctx.beginPath();
+      ctx.rect(r.x, r.y, r.width, r.height);
+      ctx.clip();
+    }
+    if (layer.type === "color") {
+      ctx.fillStyle = layer.color ?? "#000000";
+      ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+    } else if (layer.type === "text" && layer.text) {
+      const t = layer.text;
+      const lines = t.text.split("\n");
+      const lh = t.fontSize * 1.2;
+      const cx = rect.x + rect.width / 2;
+      const top = rect.y + rect.height / 2 - lh * (lines.length - 1) / 2;
+      ctx.font = `${t.fontWeight} ${t.fontSize}px ${t.fontFamily}`;
+      ctx.textAlign = "center";
+      ctx.textBaseline = "middle";
+      if (t.background) {
+        const w = Math.max(...lines.map((l) => ctx.measureText(l).width)) + t.fontSize;
+        const h = lh * lines.length + t.fontSize * 0.4;
+        ctx.fillStyle = t.background;
+        ctx.fillRect(cx - w / 2, rect.y + rect.height / 2 - h / 2, w, h);
+      }
+      ctx.fillStyle = t.color;
+      lines.forEach((l, k) => ctx.fillText(l, cx, top + k * lh));
+    } else {
+      const source = sourceFor(layer);
+      if (source) ctx.drawImage(source, rect.x, rect.y, rect.width, rect.height);
+      else {
+        ctx.fillStyle = "#334155";
+        ctx.fillRect(rect.x, rect.y, rect.width, rect.height);
+        ctx.strokeStyle = "#94a3b8";
+        ctx.lineWidth = 2;
+        ctx.strokeRect(rect.x, rect.y, rect.width, rect.height);
+      }
+    }
+    ctx.restore();
+  }
+  ctx.restore();
+}
+
+// src/video-editor/export.ts
+var reelName = (asset) => (asset?.name ?? asset?.id ?? "AX").replace(/\.[a-z0-9]+$/i, "").replace(/[^A-Za-z0-9]/g, "").toUpperCase().slice(0, 8) || "AX";
+function toVideoEdl(project, options = {}) {
+  const track = options.track !== void 0 ? project.tracks.find((t) => t.id === options.track) : [...project.tracks].reverse().find((t) => t.kind === "video");
+  if (!track) throw new Error(options.track !== void 0 ? `There is no track "${options.track}".` : "The project has no video track.");
+  const fps = project.fps;
+  const tc = (ms) => formatVideoTimecode(ms, fps);
+  const rec0 = options.recordStart ?? 36e5;
+  const assets = videoAssetMap(project);
+  const channel = track.kind === "video" ? "V" : "A";
+  const lines = [`TITLE: ${(options.title ?? project.name ?? "Untitled").toUpperCase()}`, "FCM: NON-DROP FRAME", ""];
+  let event = 0;
+  const num2 = () => String(++event).padStart(3, "0");
+  const sourceAt = (clip, time) => clip.type === "media" ? (clip.in ?? 0) + (time - clip.start) * videoClipSpeed(clip) : time - clip.start;
+  const row = (n2, reel, kind, srcIn, srcOut, recIn, recOut) => `${n2}  ${reel.padEnd(8)} ${channel.padEnd(5)} ${kind.padEnd(8)} ${tc(srcIn)} ${tc(srcOut)} ${tc(rec0 + recIn)} ${tc(rec0 + recOut)}`;
+  for (const clip of sortedVideoClips(track)) {
+    const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
+    const reel = clip.type === "media" ? reelName(asset) : "BL";
+    const end = videoClipEnd(clip);
+    const before = clip.transition ? videoClipBefore(track, clip) : null;
+    const half = before && clip.transition.type !== "dip" ? clip.transition.duration / 2 : 0;
+    const next = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition && c.transition.type !== "dip");
+    const recOut = next ? end - next.transition.duration / 2 : end;
+    const recIn = clip.start - half;
+    const n2 = num2();
+    if (before) {
+      const t = clip.transition;
+      const frames = String(Math.round(t.duration * fps / 1e3)).padStart(3, "0");
+      const outReel = before.type === "media" ? reelName(assets.get(before.asset)) : "BL";
+      const at = sourceAt(before, recIn);
+      lines.push(row(n2, outReel, "C", at, at, recIn, recIn));
+      lines.push(row(n2, reel, `${t.type === "wipe" ? "W001" : "D"}    ${frames}`, sourceAt(clip, recIn), sourceAt(clip, recOut), recIn, recOut));
+    } else lines.push(row(n2, reel, "C", sourceAt(clip, recIn), sourceAt(clip, recOut), recIn, recOut));
+    if (clip.type === "media" && videoClipSpeed(clip) !== 1) lines.push(`M2   ${reel.padEnd(8)} ${(videoClipSpeed(clip) * fps).toFixed(1).padStart(6)}      ${tc(sourceAt(clip, recIn))}`);
+    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}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+var sec = (ms) => String(Math.round(ms) / 1e3);
+var even = (v) => Math.max(2, 2 * Math.round(v / 2));
+var ffmpegFilterValue = (s) => s.replace(/[\\':%]/g, (c) => `\\${c}`).replace(/[\\'[\],;]/g, (c) => `\\${c}`);
+var color = (c) => {
+  const hex = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.exec(c);
+  if (!hex) return c.replace(/[^A-Za-z0-9@.]/g, "");
+  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, `'\\''`)}'`;
+function atempo(speed) {
+  const out = [];
+  let s = speed;
+  while (s > 2) {
+    out.push("atempo=2");
+    s /= 2;
+  }
+  while (s < 0.5) {
+    out.push("atempo=0.5");
+    s /= 0.5;
+  }
+  if (Math.abs(s - 1) > 1e-6) out.push(`atempo=${Math.round(s * 1e6) / 1e6}`);
+  return out;
+}
+function toVideoFfmpeg(project, options = {}) {
+  const notes = [];
+  const assets = videoAssetMap(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);
+  const H = even(project.height);
+  const fps = project.fps;
+  const inputs = [];
+  const graph = [`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;
+  let k = 0;
+  const input = (clip, asset, lead, tail) => {
+    const speed = videoClipSpeed(clip);
+    const src = options.resolve ? options.resolve(asset) : asset.src;
+    const span = clip.duration + lead + tail;
+    if (asset.kind === "image") inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", src]);
+    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 clip of sortedVideoClips(track)) {
+      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 (asset && asset.kind !== "audio" && track.kind === "video" && !track.hidden) index = input(clip, asset, lead, tail);
+      const audible = asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
+      if (audible && clip.type === "media" && !clip.muted && !track.muted) {
+        const ai = index ?? input(clip, asset, lead, tail);
+        const gain = (clip.volume ?? 1) * (track.volume ?? 1);
+        const chain2 = ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip)), `volume=${gain}`];
+        const before2 = clip.transition ? videoClipBefore(track, clip) : null;
+        if (lead) chain2.push(`afade=t=in:st=0:d=${sec(2 * lead)}`);
+        if (tail) chain2.push(`afade=t=out:st=${sec(span - 2 * tail)}:d=${sec(2 * tail)}`);
+        if (before2 && clip.transition.type === "dip") chain2.push(`afade=t=in:st=0:d=${sec(clip.transition.duration / 2)}`);
+        const after = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition?.type === "dip");
+        if (after) chain2.push(`afade=t=out:st=${sec(span - after.transition.duration / 2)}:d=${sec(after.transition.duration / 2)}`);
+        if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}`);
+        if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}`);
+        chain2.push(`adelay=${Math.round(t0)}:all=1`);
+        graph.push(`[${ai}:a]${chain2.join(",")}[a${audio.length}]`);
+        audio.push(`[a${audio.length}]`);
+      }
+      if (track.kind !== "video" || track.hidden) continue;
+      const enable = `enable='between(t,${sec(t0)},${sec(t0 + span)})'`;
+      const next = `v${k++}`;
+      if (clip.type === "text" && options.titleImage) {
+        inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", options.titleImage(clip, { width: project.width, height: project.height })]);
+        index = inputs.length - 1;
+      } else if (clip.type === "text") {
+        usesDrawtext = true;
+        const op = clip.opacity ?? 1;
+        const alpha = [String(op), clip.fadeIn ? `min(1,(t-${sec(clip.start)})/${sec(clip.fadeIn)})` : "", clip.fadeOut ? `min(1,(${sec(end)}-t)/${sec(clip.fadeOut)})` : ""].filter(Boolean).join("*");
+        const x = clip.transform?.x ?? 0;
+        const y = clip.transform?.y ?? 0;
+        const opts = [
+          `text=${ffmpegFilterValue(clip.text)}`,
+          options.fontFile ? `fontfile=${ffmpegFilterValue(options.fontFile)}` : `font=${ffmpegFilterValue(clip.fontFamily ?? "sans-serif")}`,
+          `fontsize=${Math.round((clip.fontSize ?? 64) * (clip.transform?.scale ?? 1))}`,
+          `fontcolor=${color(clip.color ?? "#ffffff")}`,
+          `x=(w-text_w)/2+${x}`,
+          `y=(h-text_h)/2+${y}`,
+          `alpha='${alpha}'`,
+          ...clip.background ? ["box=1", `boxcolor=${color(clip.background)}`, `boxborderw=${Math.round((clip.fontSize ?? 64) / 2)}`] : [],
+          `enable='between(t,${sec(clip.start)},${sec(end)})'`
+        ];
+        if (clip.transform?.rotation) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
+        graph.push(`[${cur}]drawtext=${opts.join(":")}[${next}]`);
+        cur = next;
+        continue;
+      }
+      const size = asset ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
+      const rect = clip.type === "text" ? { x: 0, y: 0, width: project.width, height: project.height } : placeVideoRect(project, size, clip.fit ?? (clip.type === "media" ? "contain" : "fill"), clip.transform);
+      const 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]`;
+        chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
+      }
+      chain.push("format=yuva420p");
+      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 (clip.transform?.rotation && clip.type !== "text") chain.push(`rotate=${clip.transform.rotation}*PI/180:c=none:ow=rotw(${clip.transform.rotation}*PI/180):oh=roth(${clip.transform.rotation}*PI/180)`);
+      chain.push(`setpts=PTS+${sec(t0)}/TB`);
+      const cx = rect.x + rect.width / 2;
+      const cy = rect.y + rect.height / 2;
+      graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[l${next}]`);
+      graph.push(`[${cur}][l${next}]overlay=x='${Math.round(cx)}-w/2':y='${Math.round(cy)}-h/2':eof_action=pass:${enable}[${next}]`);
+      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;
+      }
+    }
+  }
+  graph.push(`[${cur}]format=yuv420p[vout]`);
+  if (audio.length) graph.push(`${audio.join("")}amix=inputs=${audio.length}:normalize=0:duration=longest,apad,atrim=0:${sec(D)}[aout]`);
+  if (project.tracks.some((t) => t.clips.some((c) => c.type === "media" && assets.get(c.asset)?.kind === "video" && assets.get(c.asset)?.hasAudio === void 0)))
+    notes.push('Video assets are assumed to have sound; set "hasAudio": false on any that do not, or ffmpeg will stop at a missing audio stream.');
+  if (usesDrawtext) notes.push("Titles use drawtext, which needs an ffmpeg built with libfreetype (Homebrew's is not: check `ffmpeg -filters | grep drawtext`); pass titleImage to render them as images instead.");
+  const filterComplex = graph.join(";");
+  const args = [
+    "-y",
+    ...inputs.flat(),
+    "-filter_complex",
+    filterComplex,
+    "-map",
+    "[vout]",
+    ...audio.length ? ["-map", "[aout]", "-c:a", options.audioCodec ?? "aac"] : ["-an"],
+    "-c:v",
+    options.videoCodec ?? "libx264",
+    ...(options.videoCodec ?? "libx264") === "libx264" ? ["-crf", String(options.crf ?? 18), "-preset", "medium"] : [],
+    "-pix_fmt",
+    "yuv420p",
+    "-r",
+    String(fps),
+    "-t",
+    sec(D),
+    options.output ?? "output.mp4"
+  ];
+  return { args, command: ["ffmpeg", ...args].map(shellQuote).join(" "), filterComplex, duration: D, notes };
+}
+
+// src/video-editor/preview.ts
+var VideoPreviewEngine = class {
+  constructor(source, canvas, options = {}) {
+    this.source = source;
+    this.options = options;
+    this.canvas = canvas;
+    this.ctx = options.context !== void 0 ? options.context : canvas.getContext?.("2d") ?? null;
+    this.unsubscribe = source.subscribe(() => this.update());
+    this.update();
+  }
+  source;
+  options;
+  canvas;
+  ctx;
+  media = /* @__PURE__ */ new Map();
+  images = /* @__PURE__ */ new Map();
+  unsubscribe;
+  scheduled = false;
+  destroyed = false;
+  createMedia(kind) {
+    if (this.options.createMedia) return this.options.createMedia(kind);
+    const el = document.createElement(kind);
+    el.preload = "auto";
+    el.crossOrigin = "anonymous";
+    if (kind === "video") el.playsInline = true;
+    return el;
+  }
+  image(src) {
+    let img = this.images.get(src);
+    if (!img) {
+      img = this.options.createImage ? this.options.createImage() : new Image();
+      img.addEventListener("load", () => this.redraw());
+      img.src = src;
+      this.images.set(src, img);
+    }
+    return img;
+  }
+  entry(clip, src, kind) {
+    const existing = this.media.get(clip);
+    if (existing && existing.src === src) return existing;
+    if (existing) this.release(existing);
+    const media = this.createMedia(kind);
+    const onReady = () => this.redraw();
+    media.addEventListener("seeked", onReady);
+    media.addEventListener("loadeddata", onReady);
+    media.src = src;
+    const entry = { clip, src, media, onReady };
+    this.media.set(clip, entry);
+    return entry;
+  }
+  release(entry) {
+    entry.media.pause();
+    entry.media.removeEventListener("seeked", entry.onReady);
+    entry.media.removeEventListener("loadeddata", entry.onReady);
+    entry.media.removeAttribute?.("src");
+    entry.media.load?.();
+    this.media.delete(entry.clip);
+  }
+  /** 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 frame = videoFrameAt(project, time);
+    const tolerance = (this.options.tolerance ?? 200) / 1e3;
+    const active = /* @__PURE__ */ new Set();
+    const sync = (clip, src, kind, sourceTime, speed, gain) => {
+      const { media } = this.entry(clip, src, kind);
+      active.add(clip);
+      const target = sourceTime / 1e3;
+      if (Math.abs(media.playbackRate - speed) > 1e-6) media.playbackRate = speed;
+      if (gain === null) media.muted = true;
+      else {
+        media.muted = gain <= 0;
+        media.volume = Math.min(1, Math.max(0, gain));
+      }
+      if (playing) {
+        if (media.paused || Math.abs(media.currentTime - target) > tolerance) media.currentTime = target;
+        if (media.paused) void Promise.resolve(media.play()).catch(() => {
+        });
+      } else {
+        if (!media.paused) media.pause();
+        if (Math.abs(media.currentTime - target) > 1 / (2 * project.fps)) media.currentTime = target;
+      }
+    };
+    const sounding = new Map(frame.audio.map((a) => [a.clip, a]));
+    for (const layer of 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);
+      sounding.delete(layer.clip);
+    }
+    for (const a of sounding.values()) sync(a.clip, a.src, "audio", a.sourceTime, a.speed, a.gain);
+    for (const entry of [...this.media.values()]) if (!active.has(entry.clip)) this.release(entry);
+    this.draw(frame);
+  }
+  redraw() {
+    if (this.scheduled || this.destroyed) return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      if (!this.destroyed) this.draw(videoFrameAt(this.source.getState().project, this.source.getState().time));
+    });
+  }
+  sourceFor = (layer) => {
+    if (layer.assetKind === "image" && layer.src) {
+      const img = this.image(layer.src);
+      return img.complete ? img : null;
+    }
+    const entry = this.media.get(layer.clip);
+    return entry && entry.media.readyState >= 2 ? entry.media : null;
+  };
+  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 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;
+    if (this.canvas.height !== h) this.canvas.height = h;
+    drawVideoFrame(this.ctx, frame, this.sourceFor, resolution);
+    this.options.onFrame?.(frame);
+  }
+  /** Stops following the editor and releases every media element. */
+  destroy() {
+    this.destroyed = true;
+    this.unsubscribe();
+    for (const entry of [...this.media.values()]) this.release(entry);
+    this.images.clear();
+  }
+};
+
+// src/video-editor/controller.ts
+var VideoEditorController = class {
+  history;
+  player;
+  project;
+  issues;
+  selection = [];
+  readOnly;
+  error = null;
+  revision = 0;
+  applying = false;
+  onChange;
+  listeners = /* @__PURE__ */ new Set();
+  unsubscribers = [];
+  state;
+  constructor(options = {}) {
+    this.history = options.history ?? new HistoryManager();
+    this.project = options.project ? parseVideoProject(options.project) : createVideoProject();
+    this.issues = checkVideoProject(this.project);
+    this.readOnly = options.readOnly ?? false;
+    this.onChange = options.onChange;
+    this.player = new AnimationPlayer({ clock: options.clock, duration: () => videoProjectDuration(this.project), loop: "none" });
+    this.state = this.computeState();
+    this.connect();
+  }
+  connect() {
+    if (this.unsubscribers.length) return;
+    this.unsubscribers.push(
+      this.player.subscribe(() => this.notify()),
+      this.history.subscribe(() => {
+        if (!this.applying) this.notify();
+      })
+    );
+  }
+  /** Pauses and stops listening to the player and history. Subscribing again reconnects (React StrictMode). */
+  destroy() {
+    this.player.pause();
+    this.unsubscribers.splice(0).forEach((u) => u());
+  }
+  getState = () => this.state;
+  subscribe = (listener) => {
+    this.connect();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** The current project (immutable; edit through the controller). */
+  getProject() {
+    return this.project;
+  }
+  computeState() {
+    const p = this.player.getState();
+    const h = this.history.getState();
+    return {
+      project: this.project,
+      duration: videoProjectDuration(this.project),
+      time: p.time,
+      playing: p.playing,
+      loop: p.loop,
+      selection: this.selection,
+      current: videoClipsAt(this.project, p.time).map((c) => c.clip.id),
+      issues: this.issues,
+      readOnly: this.readOnly,
+      error: this.error,
+      canUndo: h.canUndo,
+      canRedo: h.canRedo,
+      undoLabel: h.undoName,
+      redoLabel: h.redoName,
+      revision: this.revision
+    };
+  }
+  notify() {
+    this.revision++;
+    this.state = this.computeState();
+    const state = this.state;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("[VideoEditorController] Error in state listener:", error);
+      }
+    });
+  }
+  setProject(project) {
+    this.applying = true;
+    try {
+      this.project = project;
+      this.issues = checkVideoProject(project);
+      const ids = new Set(project.tracks.flatMap((t) => t.clips.map((c) => c.id)));
+      if (this.selection.some((id) => !ids.has(id))) this.selection = this.selection.filter((id) => ids.has(id));
+      this.player.setDuration(() => videoProjectDuration(this.project));
+    } finally {
+      this.applying = false;
+    }
+    this.notify();
+    this.onChange?.(project);
+  }
+  commit(label, next) {
+    const before = this.project;
+    this.error = null;
+    if (next === before) {
+      this.notify();
+      return;
+    }
+    const command = {
+      name: label,
+      tag: "video-editor",
+      execute: () => this.setProject(next),
+      undo: () => this.setProject(before),
+      redo: () => this.setProject(next)
+    };
+    this.history.execute(command);
+  }
+  refuse(message) {
+    this.error = message;
+    this.notify();
+    return { ok: false, error: message };
+  }
+  /** Why edits are refused now, or `null` when they are allowed. */
+  readOnlyReason() {
+    return this.readOnly ? "The video project is read-only." : null;
+  }
+  /**
+   * Applies edits as one undo step, all or nothing (see `applyVideoEdits`). With `dryRun` it
+   * reports what would happen and changes nothing.
+   */
+  apply(edits, label = "Edit video", options = {}) {
+    const reason = this.readOnlyReason();
+    if (reason) return this.refuse(reason);
+    const result = applyVideoEdits(this.project, edits);
+    if (!result.ok) return options.dryRun ? result : this.refuse(result.error);
+    if (!options.dryRun) this.commit(label, result.project);
+    return result;
+  }
+  /** Opens a project (JSON or object). `clearHistory` drops the undo stack (opening a file); otherwise it is one undo step. */
+  load(project, options = {}) {
+    let parsed;
+    try {
+      parsed = parseVideoProject(project);
+    } catch (error) {
+      return this.refuse(error.message);
+    }
+    if (options.clearHistory) {
+      this.history.clear();
+      this.error = null;
+      this.selection = [];
+      this.setProject(parsed);
+      this.player.seek(0);
+      return { ok: true, project: parsed, issues: this.issues, outcomes: [{ op: "replace_project" }] };
+    }
+    return this.apply({ op: "replace_project", project: parsed }, "Replace project");
+  }
+  setReadOnly(readOnly) {
+    if (this.readOnly === readOnly) return;
+    this.readOnly = readOnly;
+    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)) ?? [];
+    let next;
+    if (options.add) {
+      next = [...this.selection];
+      for (const id of known) next = next.includes(id) ? next.filter((x) => x !== id) : [...next, id];
+    } else next = [...new Set(known)];
+    if (next.length === this.selection.length && next.every((id, i) => id === this.selection[i])) return;
+    this.selection = next;
+    this.notify();
+  }
+  play() {
+    this.player.play();
+  }
+  pause() {
+    this.player.pause();
+  }
+  toggle() {
+    this.player.toggle();
+  }
+  /** Moves the playhead (ms). */
+  seek(time) {
+    this.player.seek(time);
+  }
+  /** Moves the playhead by whole frames (negative steps back), pausing. */
+  step(frames) {
+    this.player.pause();
+    const fps = this.project.fps;
+    this.player.seek(Math.max(0, snapToVideoFrame(this.player.currentTime, fps) + frames * 1e3 / fps));
+  }
+  setLoop(loop) {
+    this.player.setLoop(loop);
+  }
+  undo() {
+    return this.history.undo();
+  }
+  redo() {
+    return this.history.redo();
+  }
+  /**
+   * `time` moved to the nearest clip edge, marker or the playhead within `threshold` ms (default:
+   * 8 frames), else to the nearest frame. Clips in `exclude` (the ones being dragged) are ignored.
+   */
+  snap(time, options = {}) {
+    const threshold = options.threshold ?? 8 * 1e3 / this.project.fps;
+    const points = videoSnapPoints(this.project, { exclude: options.exclude, playhead: options.playhead === false ? void 0 : this.player.currentTime });
+    const hit = snapVideoTime(time, points, threshold);
+    return hit.snapped !== null ? hit : { time: Math.max(0, snapToVideoFrame(time, this.project.fps)), snapped: null };
+  }
+  /** Splits the selected clips (or every clip) under the playhead there, as one undo step. */
+  splitAtPlayhead() {
+    const t = snapToVideoFrame(this.player.currentTime, this.project.fps);
+    const under = videoClipsAt(this.project, t).filter(({ clip }) => t > clip.start && t < videoClipEnd(clip));
+    const chosen = this.selection.length ? under.filter(({ clip }) => this.selection.includes(clip.id)) : under;
+    if (!chosen.length) return this.refuse("No clip is under the playhead to split.");
+    return this.apply(chosen.map(({ clip }) => ({ op: "split_clip", clip: clip.id, at: t })), "Split");
+  }
+  /** Deletes the selected clips; `ripple` closes the gaps they leave. */
+  deleteSelection(options = {}) {
+    if (!this.selection.length) return this.refuse("Select clips to delete first.");
+    return this.apply({ op: "delete_clips", clips: [...this.selection], ripple: options.ripple }, options.ripple ? "Ripple delete" : "Delete clips");
+  }
+  /** What plays at `time` (default: the playhead). */
+  frame(time = this.player.currentTime) {
+    return videoFrameAt(this.project, time);
+  }
+  /** The frame at `time` (default: the playhead) as SVG. */
+  toSvg(time = this.player.currentTime, options = {}) {
+    return videoProjectSvg(this.project, time, options);
+  }
+  /** The project as an ffmpeg command. */
+  toFfmpeg(options = {}) {
+    return toVideoFfmpeg(this.project, options);
+  }
+  /** One track as a CMX 3600 EDL. */
+  toEdl(options = {}) {
+    return toVideoEdl(this.project, options);
+  }
+};
+
+// src/video-editor/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var object = (properties, required = [], description) => ({
+  type: "object",
+  ...description ? { description } : {},
+  properties,
+  ...required.length ? { required } : {},
+  additionalProperties: false
+});
+var MS = (what) => ({ type: "number", minimum: 0, description: `${what}, in milliseconds.` });
+var CLIP_ID = { type: "string", minLength: 1, description: 'A clip id from get_video_project (e.g. "c1").' };
+var TRACK_ID = { type: "string", minLength: 1, description: 'A track id from get_video_project (e.g. "v1" or "a1").' };
+var ASSET_ID = { type: "string", minLength: 1, description: "An asset id from get_video_project." };
+var COLOR = (what) => ({ type: "string", minLength: 1, description: `${what}: a CSS colour such as "#ffcc00".` });
+var RIPPLE = { type: "boolean", description: "Push (or pull) the later clips on the same track along by the change, keeping the cuts after it in sync (default false: refuse if it would overlap)." };
+var TRANSFORM = object(
+  {
+    x: { type: "number", description: "Offset of the centre to the right of the frame's centre, in pixels (default 0)." },
+    y: { type: "number", description: "Offset of the centre below the frame's centre, in pixels (default 0)." },
+    scale: { type: "number", minimum: 0, description: "Size after fitting (1 = fitted size, default 1)." },
+    rotation: { type: "number", description: "Degrees clockwise (default 0)." }
+  },
+  [],
+  "Where the picture sits after it is fitted."
+);
+var TRANSITION = object(
+  {
+    type: { type: "string", enum: [...VIDEO_TRANSITION_TYPES], description: "crossfade (this clip fades up over the one before), dip (down into a colour and up out of it) or wipe (an edge travels across revealing this clip)." },
+    duration: { type: "number", exclusiveMinimum: 0, description: "Length in ms, centred on the cut. A crossfade or wipe needs half of it in media past the cut on both sides (handles); a dip needs none." },
+    color: COLOR("For dip: the colour passed through (default black)"),
+    direction: { type: "string", enum: [...VIDEO_WIPE_DIRECTIONS], description: "For wipe: the way the edge travels (default right)." }
+  },
+  ["type", "duration"],
+  "A transition from the clip that ends where this one starts on the same track."
+);
+var CLIP_COMMON = {
+  name: { type: "string", description: "A label for the clip." },
+  opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0\u20131 (default 1)." },
+  transform: TRANSFORM,
+  fit: { type: "string", enum: [...VIDEO_FITS], description: "How the picture fits the frame before the transform, as CSS object-fit (default contain for media, fill for colours)." },
+  fadeIn: MS("Fade up from nothing (picture and sound) over this long"),
+  fadeOut: MS("Fade down to nothing over this long")
+};
+var MEDIA_FIELDS = {
+  in: MS("Where in the source it starts (default 0)"),
+  speed: { type: "number", minimum: 0.05, maximum: 20, description: "Playback speed (default 1). Changing it keeps the stretch of source, so the clip gets shorter or longer." },
+  volume: { type: "number", minimum: 0, maximum: 4, description: "Gain (1 = unchanged, default 1)." },
+  muted: { type: "boolean", description: "Silence this clip (default false)." }
+};
+var TEXT_FIELDS = {
+  text: { type: "string", minLength: 1, description: `The title's text ("\\n" breaks lines).` },
+  color: COLOR("Text colour (default white)"),
+  fontSize: { type: "number", exclusiveMinimum: 0, description: "Pixels (default 64)." },
+  fontFamily: { type: "string", description: "CSS font family (default sans-serif)." },
+  fontWeight: { type: "number", minimum: 100, maximum: 1e3, description: "CSS weight (default 700)." },
+  background: COLOR("A box behind the text (default none)")
+};
+var PLACEMENT = {
+  id: { type: "string", minLength: 1, description: 'Id for the clip (default: a fresh one such as "c3").' },
+  start: MS("Where it starts on the timeline (default: the end of the track)"),
+  duration: { type: "number", exclusiveMinimum: 0, description: "Length on the timeline, in ms (default: the rest of the source for media, 5000 for stills, 3000 for titles and colours)." }
+};
+var NEW_CLIP = {
+  description: "The clip: media (a stretch of an asset), text (a title) or color (a solid fill).",
+  oneOf: [
+    object({ type: { const: "media", description: "A stretch of an asset." }, asset: ASSET_ID, ...PLACEMENT, ...CLIP_COMMON, ...MEDIA_FIELDS }, ["type", "asset"], "A media clip."),
+    object({ type: { const: "text", description: "A title over the picture." }, ...PLACEMENT, ...CLIP_COMMON, ...TEXT_FIELDS }, ["type", "text"], "A title."),
+    object({ type: { const: "color", description: "A solid colour filling the frame." }, color: COLOR("The fill"), ...PLACEMENT, ...CLIP_COMMON }, ["type", "color"], "A colour.")
+  ]
+};
+var SETTINGS = {
+  name: { type: "string", description: "Project name." },
+  width: { type: "integer", minimum: 16, maximum: 8192, description: "Frame width in pixels." },
+  height: { type: "integer", minimum: 16, maximum: 8192, description: "Frame height in pixels." },
+  fps: { type: "number", exclusiveMinimum: 0, maximum: 240, description: "Frames per second (e.g. 24, 25, 30, 60)." },
+  background: COLOR("What shows where no clip covers the frame (default black)")
+};
+var TRACK_FIELDS = {
+  name: { type: "string", description: "Track label." },
+  muted: { type: "boolean", description: "Silence every clip on it." },
+  hidden: { type: "boolean", description: "Leave its pictures out of the frame." },
+  locked: { type: "boolean", description: "Refuse edits to its clips." },
+  volume: { type: "number", minimum: 0, maximum: 4, description: "Gain for every clip on it (1 = unchanged)." }
+};
+var ASSET_FIELDS = {
+  src: { type: "string", minLength: 1, description: "URL, path or data URL the player and exporter can open." },
+  name: { type: "string", description: "Display name (e.g. the file name)." },
+  duration: { type: "number", exclusiveMinimum: 0, description: "Length of the source in ms (required to check trims of video and audio)." },
+  width: { type: "number", exclusiveMinimum: 0, description: "Pixel width (video and image; default the project width)." },
+  height: { type: "number", exclusiveMinimum: 0, description: "Pixel height." },
+  hasAudio: { type: "boolean", description: "For video: whether it has sound (default true)." },
+  poster: { type: "string", description: "For video: a still (URL) to show in rendered frames." }
+};
+var issueSummary = (issues) => ({
+  errors: issues.filter((i) => i.severity === "error").length,
+  warnings: issues.filter((i) => i.severity === "warning").length,
+  notes: issues.filter((i) => i.severity === "note").length,
+  lines: issues.map((i) => `${i.severity}: ${i.message}`)
+});
+function describeVideoProject(project) {
+  return {
+    ...project.name ? { name: project.name } : {},
+    width: project.width,
+    height: project.height,
+    fps: project.fps,
+    duration: videoProjectDuration(project),
+    ...project.background ? { background: project.background } : {},
+    assets: project.assets,
+    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.volume !== void 0 ? { volume: t.volume } : {},
+      clips: sortedVideoClips(t).map((c) => ({ ...c, end: videoClipEnd(c), ...c.type === "media" ? { source: videoClipSourceRange(c) } : {} }))
+    })),
+    markers: project.markers ?? []
+  };
+}
+function createVideoEditorToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (r) return typeof r === "string" ? r : "This video project is read-only.";
+    return controller.readOnlyReason();
+  };
+  const project = () => controller.getProject();
+  const outcome = (result, extra = {}) => {
+    if (!result.ok) throw new Error(result.error);
+    return { ...extra, duration: videoProjectDuration(result.project), issues: issueSummary(result.issues) };
+  };
+  const apply = (edits, label, extra) => {
+    const result = controller.apply(edits, label);
+    return outcome(result, result.ok && extra ? extra(result) : {});
+  };
+  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) } : {} };
+    }
+    return null;
+  };
+  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.",
+    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 } : {} };
+    }
+  };
+  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) and the sounds (clip, source time, gain after volumes, fades and transitions).",
+    inputSchema: object({ time: MS("Time from the start (default: the playhead)") }),
+    annotations: { title: "What plays at a moment", ...READ },
+    handler: ({ time }) => {
+      const frame = videoFrameAt(project(), time ?? controller.getState().time);
+      return { ...frame, timecode: formatVideoTimecode(frame.time, project().fps) };
+    }
+  };
+  const findGaps = {
+    name: "find_video_gaps",
+    title: "Find gaps",
+    description: "Lists empty stretches between clips (and before the first) on every track or one track, as { track, start, end } in ms. close_video_gaps removes them.",
+    inputSchema: object({ track: { ...TRACK_ID, description: "Only this track (default all)." } }),
+    annotations: { title: "Find gaps", ...READ },
+    handler: ({ track }) => {
+      if (track !== void 0 && !project().tracks.some((t) => t.id === track)) throw new Error(`There is no track "${track}"; the tracks are ${project().tracks.map((t) => `"${t.id}"`).join(", ")}.`);
+      return { gaps: findVideoGaps(project(), track) };
+    }
+  };
+  const checkProject = {
+    name: "check_video_project",
+    title: "Check the video project",
+    description: "Lists the project's problems, errors first, each with a code, the clip / track / asset it is about and how to fix it: missing assets, overlaps, clips past the end of their source, transitions without a cut or handles, fades longer than the clip, assets with no duration, unused assets.",
+    inputSchema: object({}),
+    annotations: { title: "Check the video project", ...READ },
+    handler: () => {
+      const issues = controller.getState().issues;
+      return { ...issueSummary(issues), issues };
+    }
+  };
+  const renderFrame = {
+    name: "render_video_frame",
+    title: "Render a frame",
+    description: 'Draws the project at one moment (or several, as one labelled contact sheet) to check the picture, without changing it: SVG by default, PNG (format "png") when the host can rasterize. Images and video posters are drawn; video without a poster shows as a labelled box with its source timecode.',
+    inputSchema: object({
+      time: MS("Time from the start (default: the playhead)"),
+      times: { type: "array", items: { type: "number", minimum: 0 }, minItems: 2, maxItems: 16, description: 'Several moments (ms) drawn as one contact sheet instead of "time".' },
+      columns: { type: "integer", minimum: 1, maximum: 8, description: "With times: frames a row (default about square)." },
+      format: { type: "string", enum: ["svg", "png"], description: "svg (default) or png (only when the host supports it)." }
+    }),
+    annotations: { title: "Render a frame", ...READ },
+    handler: async ({ time, times, columns, format = "svg" }) => {
+      const p = project();
+      const svg = times ? videoContactSheetSvg(p, times, columns ? { columns } : {}) : videoProjectSvg(p, time ?? controller.getState().time);
+      if (format === "png") {
+        if (!options.rasterize) throw new Error('This host cannot make PNG images; call render_video_frame with format "svg".');
+        const size = /viewBox="0 0 ([\d.]+) ([\d.]+)"/.exec(svg);
+        const image = await options.rasterize(svg, { width: Number(size[1]), height: Number(size[2]) });
+        return { content: [{ type: "image", data: image.data, mimeType: image.mimeType }] };
+      }
+      return { svg };
+    }
+  };
+  const exportFfmpeg = {
+    name: "export_video_ffmpeg",
+    title: "Export an ffmpeg command",
+    description: "Returns the ffmpeg command that renders the project to a file: { args (for spawn), command (one shell line), filterComplex, duration, notes on anything approximated }. Fails when the project has no clips.",
+    inputSchema: object({
+      output: { type: "string", minLength: 1, description: "Output file name (default output.mp4)." },
+      crf: { type: "integer", minimum: 0, maximum: 51, description: "x264 quality, lower is better (default 18)." }
+    }),
+    annotations: { title: "Export an ffmpeg command", ...READ },
+    handler: ({ output, crf }) => controller.toFfmpeg({ ...output ? { output } : {}, ...crf !== void 0 ? { crf } : {} })
+  };
+  const exportEdl = {
+    name: "export_video_edl",
+    title: "Export an EDL",
+    description: "Returns one track as a CMX 3600 edit decision list (text) for conforming in another editor: events with source and record timecode, dissolves, speed changes and clip names.",
+    inputSchema: object({
+      track: { ...TRACK_ID, description: "Track to export (default: the bottom video track)." },
+      title: { type: "string", description: "TITLE line (default: the project name)." }
+    }),
+    annotations: { title: "Export an EDL", ...READ },
+    handler: ({ track, title }) => ({ edl: controller.toEdl({ ...track ? { track } : {}, ...title ? { title } : {} }) })
+  };
+  const seek = {
+    name: "seek_video",
+    title: "Show a moment",
+    description: "Moves the playhead the person sees to a time, a clip's start or a marker, and plays or pauses. Does not change the project. Returns the playhead and the clips under it.",
+    inputSchema: object({
+      time: MS("Time from the start"),
+      clip: { ...CLIP_ID, description: 'Go to the start of this clip instead of "time".' },
+      marker: { type: "string", minLength: 1, description: 'Go to this marker instead of "time".' },
+      play: { type: "boolean", description: "true plays from there, false pauses (default: leave as is)." }
+    }),
+    annotations: { title: "Show a moment", ...WRITE_IDEMPOTENT },
+    handler: ({ time, clip, marker, play }) => {
+      const p = project();
+      if (clip !== void 0) {
+        const c = clipOut(p, clip);
+        if (!c) throw new Error(`There is no clip "${clip}".`);
+        controller.seek(c.start);
+      } else if (marker !== void 0) {
+        const m = (p.markers ?? []).find((x) => x.id === marker);
+        if (!m) throw new Error(`There is no marker "${marker}"; the markers are ${(p.markers ?? []).map((x) => `"${x.id}"`).join(", ") || "none"}.`);
+        controller.seek(m.time);
+      } else if (time !== void 0) controller.seek(time);
+      if (play === true) controller.play();
+      if (play === false) controller.pause();
+      const state = controller.getState();
+      return { time: state.time, timecode: formatVideoTimecode(state.time, p.fps), playing: state.playing, clips: state.current };
+    }
+  };
+  const setSettings = {
+    name: "set_video_settings",
+    title: "Change project settings",
+    description: "Sets the name, frame size, frame rate or background colour (one undo step). Returns the length and issues.",
+    inputSchema: object(SETTINGS),
+    annotations: { title: "Change project settings", ...WRITE_IDEMPOTENT },
+    handler: (args) => {
+      if (!Object.keys(args).length) throw new Error("Give at least one setting to change (name, width, height, fps, background).");
+      return apply({ op: "set_settings", ...args }, "Change settings");
+    }
+  };
+  const addAsset = {
+    name: "add_video_asset",
+    title: "Add media",
+    description: "Adds a video, audio or image file to the project so clips can use it (one undo step). Give the duration of video and audio so trims can be checked. Returns the asset id.",
+    inputSchema: object({ id: { type: "string", minLength: 1, description: "Id for it (default: from its name or file name)." }, kind: { type: "string", enum: ["video", "audio", "image"], description: "What it is." }, ...ASSET_FIELDS }, ["kind", "src"]),
+    annotations: { title: "Add media", ...WRITE },
+    handler: (asset) => apply({ op: "add_asset", asset }, "Add media", (r) => ({ asset: r.outcomes[0].asset }))
+  };
+  const updateAsset = {
+    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"] }, description: "Fields to clear." } }, ["asset"]),
+    annotations: { title: "Change media details", ...WRITE_IDEMPOTENT },
+    handler: ({ asset, set, remove }) => apply({ op: "update_asset", asset, set, remove }, "Change media", (r) => ({ asset: r.project.assets.find((a) => a.id === asset) }))
+  };
+  const removeAsset = {
+    name: "remove_video_asset",
+    title: "Remove media",
+    description: "Removes an asset no clip uses (one undo step); refused while clips use it, naming them. Returns the remaining asset ids.",
+    inputSchema: object({ asset: ASSET_ID }, ["asset"]),
+    annotations: { title: "Remove media", ...DESTRUCTIVE },
+    handler: ({ asset }) => apply({ op: "remove_asset", asset }, "Remove media", (r) => ({ removed: asset, assets: r.project.assets.map((a) => a.id) }))
+  };
+  const addTrack = {
+    name: "add_video_track",
+    title: "Add a track",
+    description: "Adds an empty video or audio track (one undo step). By default a video track goes on top (drawing over the others) and an audio track at the bottom. Returns its id and the track order.",
+    inputSchema: object({ kind: { type: "string", enum: ["video", "audio"], description: "Video (pictures, titles, colours) or audio." }, id: { type: "string", minLength: 1, description: 'Id (default "v2", "a2", \u2026).' }, at: { type: "integer", minimum: 0, description: "Position, 0 = top." }, ...TRACK_FIELDS }, ["kind"]),
+    annotations: { title: "Add a track", ...WRITE },
+    handler: ({ kind, id, at, ...fields }) => apply({ op: "add_track", track: { kind, ...id ? { id } : {}, ...fields }, at }, "Add track", (r) => ({ track: r.outcomes[0].track, tracks: r.project.tracks.map((t) => t.id) }))
+  };
+  const updateTrack = {
+    name: "update_video_track",
+    title: "Change a track",
+    description: "Renames, mutes, hides, locks or sets the volume of a track (one undo step). Returns the track's settings.",
+    inputSchema: object({ track: TRACK_ID, set: object(TRACK_FIELDS, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["name", "muted", "hidden", "locked", "volume"] }, description: "Fields to clear." } }, ["track"]),
+    annotations: { title: "Change a track", ...WRITE_IDEMPOTENT },
+    handler: ({ track, set, remove }) => apply({ op: "update_track", track, set, remove }, "Change track", (r) => {
+      const { clips, ...t } = r.project.tracks.find((x) => x.id === track);
+      return { track: { ...t, clips: clips.length } };
+    })
+  };
+  const removeTrack = {
+    name: "remove_video_track",
+    title: "Remove a track",
+    description: "Deletes a track and every clip on it (one undo step; refused when locked). Returns the clips removed with it.",
+    inputSchema: object({ track: TRACK_ID }, ["track"]),
+    annotations: { title: "Remove a track", ...DESTRUCTIVE },
+    handler: ({ track }) => apply({ op: "remove_track", track }, "Remove track", (r) => ({ removed: track, clips: r.outcomes[0].clips }))
+  };
+  const moveTrack = {
+    name: "move_video_track",
+    title: "Reorder a track",
+    description: "Moves a track to a new position (0 = top; an earlier video track draws over later ones). Returns the track order.",
+    inputSchema: object({ track: TRACK_ID, to: { type: "integer", minimum: 0, description: "New position, 0 = top." } }, ["track", "to"]),
+    annotations: { title: "Reorder a track", ...WRITE_IDEMPOTENT },
+    handler: ({ track, to }) => apply({ op: "move_track", track, to }, "Move track", (r) => ({ tracks: r.project.tracks.map((t) => t.id) }))
+  };
+  const addClip = {
+    name: "add_video_clip",
+    title: "Add a clip",
+    description: 'Puts a clip on a track (one undo step): media (a stretch of an asset from its "in" point), a title or a colour. With no start it goes at the end of the track; with ripple it is inserted at "start", pushing later clips along; otherwise an overlap is refused with the next free place. Returns the clip with its end and source range.',
+    inputSchema: object({ track: TRACK_ID, clip: NEW_CLIP, ripple: RIPPLE }, ["track", "clip"]),
+    annotations: { title: "Add a clip", ...WRITE },
+    handler: ({ track, clip, ripple }) => apply({ op: "add_clip", track, clip, ripple }, "Add clip", (r) => ({ clip: clipOut(r.project, r.outcomes[0].clip) }))
+  };
+  const moveClip = {
+    name: "move_video_clip",
+    title: "Move a clip",
+    description: "Moves a clip to a new start and/or another track of the same kind (one undo step). Refused if it would overlap another clip, naming it and the next free place. Returns the clip.",
+    inputSchema: object({ clip: CLIP_ID, start: MS("New start on the timeline (default: unchanged)"), track: { ...TRACK_ID, description: "Track to move it to (default: its own)." } }, ["clip"]),
+    annotations: { title: "Move a clip", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, start, track }) => {
+      if (start === void 0 && track === void 0) throw new Error('Give "start", "track" or both.');
+      return apply({ op: "move_clip", clip, start, track }, "Move clip", (r) => ({ clip: clipOut(r.project, clip) }));
+    }
+  };
+  const trimClip = {
+    name: "trim_video_clip",
+    title: "Trim a clip",
+    description: 'Moves one edge of a clip to a timeline time (one undo step): "start" also moves its source in point, "end" its out point. Refused past the ends of the source (the error says how far it can go) or below one frame. With ripple the clip keeps its start and the later clips on the track move by the change, so no gap or overlap opens. Returns the clip.',
+    inputSchema: object({ clip: CLIP_ID, edge: { type: "string", enum: ["start", "end"], description: "Which edge to move." }, to: MS("Where that edge goes on the timeline"), ripple: RIPPLE }, ["clip", "edge", "to"]),
+    annotations: { title: "Trim a clip", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, edge, to, ripple }) => apply({ op: "trim_clip", clip, edge, to, ripple }, "Trim clip", (r) => ({ clip: clipOut(r.project, clip) }))
+  };
+  const splitClip = {
+    name: "split_video_clip",
+    title: "Split a clip",
+    description: "Cuts a clip in two at a timeline time (at least a frame from either end), as one undo step. The left part keeps the id, fade in and transition; the right part gets a new id and the fade out. Returns both parts.",
+    inputSchema: object({ clip: CLIP_ID, at: MS("Where to cut, on the timeline"), id: { type: "string", minLength: 1, description: 'Id for the right part (default "<clip>-1").' } }, ["clip", "at"]),
+    annotations: { title: "Split a clip", ...WRITE },
+    handler: ({ clip, at, id }) => apply({ op: "split_clip", clip, at, id }, "Split clip", (r) => ({ left: clipOut(r.project, clip), right: clipOut(r.project, r.outcomes[0].clip) }))
+  };
+  const deleteClips = {
+    name: "delete_video_clips",
+    title: "Delete clips",
+    description: "Removes clips (one undo step). With ripple the later clips on each track move up to close the gaps. Returns the ids removed.",
+    inputSchema: object({ clips: { type: "array", items: CLIP_ID, minItems: 1, description: "Clip ids." }, ripple: { type: "boolean", description: "Close the gaps they leave (default false)." } }, ["clips"]),
+    annotations: { title: "Delete clips", ...DESTRUCTIVE },
+    handler: ({ clips, ripple }) => apply({ op: "delete_clips", clips, ripple }, ripple ? "Ripple delete" : "Delete clips", () => ({ removed: clips }))
+  };
+  const updateClip = {
+    name: "update_video_clip",
+    title: "Change a clip",
+    description: `Changes a clip's properties (one undo step): opacity, transform, fit, fades, name; for media volume, mute, 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.`,
+    inputSchema: object(
+      {
+        clip: CLIP_ID,
+        set: object({ ...CLIP_COMMON, ...MEDIA_FIELDS, asset: { ...ASSET_ID, description: "For media: play another asset (same in point)." }, ...TEXT_FIELDS, color: COLOR("Text colour, or a colour clip's fill") }, [], "Fields to replace (only those that fit the clip's type)."),
+        remove: { type: "array", items: { type: "string", enum: ["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", "in", "speed", "volume", "muted", "fontSize", "fontFamily", "fontWeight", "background"] }, description: "Fields to reset to their defaults." }
+      },
+      ["clip"]
+    ),
+    annotations: { title: "Change a clip", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, set, remove }) => {
+      const current = clipOut(project(), clip);
+      if (current && set) {
+        const allowed = /* @__PURE__ */ new Set(["name", "opacity", "transform", "fit", "fadeIn", "fadeOut", ...current.type === "media" ? ["in", "speed", "volume", "muted", "asset"] : 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(", ")}.`);
+      }
+      return apply({ op: "update_clip", clip, set, remove }, "Change clip", (r) => ({ clip: clipOut(r.project, clip) }));
+    }
+  };
+  const setTransition = {
+    name: "set_video_transition",
+    title: "Set a transition",
+    description: "Sets (or with null removes) the transition into a clip from the clip that ends where it starts on the same track (one undo step). A crossfade or wipe plays half before and half after the cut, so both clips need that much media past the cut; when they do not, the error says the longest that fits. Returns the clip.",
+    inputSchema: object({ clip: { ...CLIP_ID, description: "The incoming clip (the one after the cut)." }, transition: { anyOf: [TRANSITION, { type: "null" }], description: "The transition, or null to remove it." } }, ["clip", "transition"]),
+    annotations: { title: "Set a transition", ...WRITE_IDEMPOTENT },
+    handler: ({ clip, transition }) => apply({ op: "set_transition", clip, transition }, transition ? "Set transition" : "Remove transition", (r) => ({ clip: clipOut(r.project, clip) }))
+  };
+  const closeGaps = {
+    name: "close_video_gaps",
+    title: "Close gaps",
+    description: "Slides the clips on a track earlier so no gaps are left between them (from a time on, default the start), as one undo step. Returns the clips that moved.",
+    inputSchema: object({ track: TRACK_ID, from: MS("Only close gaps after this time (default 0)") }, ["track"]),
+    annotations: { title: "Close gaps", ...WRITE_IDEMPOTENT },
+    handler: ({ track, from }) => apply({ op: "close_gaps", track, from }, "Close gaps", (r) => ({ moved: r.outcomes[0].clips }))
+  };
+  const addMarker = {
+    name: "add_video_marker",
+    title: "Add a marker",
+    description: "Adds a named marker at a time (one undo step), e.g. a beat or a note for review. Clip edges snap to markers. Returns its id.",
+    inputSchema: object({ time: MS("Where it goes"), label: { type: "string", description: "What it marks." }, color: COLOR("Marker colour"), id: { type: "string", minLength: 1, description: 'Id (default "m1", "m2", \u2026).' } }, ["time"]),
+    annotations: { title: "Add a marker", ...WRITE },
+    handler: (marker) => apply({ op: "add_marker", marker }, "Add marker", (r) => ({ marker: r.outcomes[0].marker }))
+  };
+  const removeMarker = {
+    name: "remove_video_marker",
+    title: "Remove a marker",
+    description: "Removes a marker by id (one undo step). Returns the remaining markers.",
+    inputSchema: object({ marker: { type: "string", minLength: 1, description: "Marker id from get_video_project." } }, ["marker"]),
+    annotations: { title: "Remove a marker", ...DESTRUCTIVE },
+    handler: ({ marker }) => apply({ op: "remove_marker", marker }, "Remove marker", (r) => ({ markers: r.project.markers ?? [] }))
+  };
+  const EDIT_OP = {
+    type: "object",
+    description: `One edit: { "op": one of ${VIDEO_EDIT_OPS.filter((o) => o !== "replace_project").join(", ")}, \u2026its fields }. Fields match the single tools: add_clip { track, clip, ripple }, move_clip { clip, start, track }, trim_clip { clip, edge, to, ripple }, split_clip { clip, at, id }, delete_clips { clips, ripple }, update_clip { clip, set, remove }, set_transition { clip, transition }, close_gaps { track, from }, add_asset { asset }, update_asset { asset, set, remove }, remove_asset { asset }, add_track { track: { kind, id, \u2026 }, at }, update_track { track, set, remove }, remove_track { track }, move_track { track, to }, add_marker { marker: { time, label } }, update_marker { marker, set }, remove_marker { marker }, set_settings { name, width, height, fps, background }.`,
+    properties: { op: { type: "string", enum: VIDEO_EDIT_OPS.filter((o) => o !== "replace_project"), description: "Which edit." } },
+    required: ["op"]
+  };
+  const editVideo = {
+    name: "edit_video",
+    title: "Make several edits at once",
+    description: `Applies several edits in order as one undo step, all or nothing: if one fails nothing changes and the error names the op ("op 2 (trim_clip): \u2026"). Use it for a rough cut (assets, then clips) or anything that only makes sense together. Returns each op's outcome (the clip, clips, track, asset or marker it made or changed), the length and issues. With dry_run it only reports them.`,
+    inputSchema: object({ ops: { type: "array", items: EDIT_OP, minItems: 1, maxItems: 200, description: "Edits, applied in order." }, dry_run: { type: "boolean", description: "Check without applying (default false)." } }, ["ops"]),
+    annotations: { title: "Make several edits at once", ...WRITE },
+    handler: ({ ops, dry_run = false }) => {
+      if (ops.some((o) => o.op === "replace_project")) throw new Error("edit_video cannot replace the whole project; use the individual ops.");
+      const result = controller.apply(ops, "Edit video", { dryRun: dry_run });
+      return outcome(result, result.ok ? { outcomes: result.outcomes, ...dry_run ? { dry_run: true, hint: "Nothing was applied; call again without dry_run to apply." } : {} } : {});
+    }
+  };
+  const undo = {
+    name: "undo_video",
+    title: "Undo a video edit",
+    description: "Undoes the last edit. Returns whether something was undone and its label.",
+    inputSchema: object({}),
+    annotations: { title: "Undo a video edit", ...WRITE },
+    handler: () => {
+      const label = controller.getState().undoLabel;
+      const undone = controller.undo();
+      return { undone, ...undone ? { label } : {} };
+    }
+  };
+  const redo = {
+    name: "redo_video",
+    title: "Redo a video edit",
+    description: "Redoes the last undone edit. Returns whether something was redone and its label.",
+    inputSchema: object({}),
+    annotations: { title: "Redo a video edit", ...WRITE },
+    handler: () => {
+      const label = controller.getState().redoLabel;
+      const redone = controller.redo();
+      return { redone, ...redone ? { label } : {} };
+    }
+  };
+  const reads = [getProject, getFrame, findGaps, checkProject, renderFrame, exportFfmpeg, exportEdl, seek];
+  const writes = [setSettings, addAsset, updateAsset, removeAsset, addTrack, updateTrack, removeTrack, moveTrack, addClip, moveClip, trimClip, splitClip, deleteClips, updateClip, setTransition, closeGaps, addMarker, removeMarker, editVideo, undo, redo];
+  return {
+    id: options.id ?? "video",
+    namespace: options.namespace,
+    tools: () => readOnlyReason() ? reads : [...reads, ...writes],
+    subscribe: (notify) => {
+      let last = readOnlyReason();
+      return controller.subscribe(() => {
+        const now = readOnlyReason();
+        if (now !== last) {
+          last = now;
+          notify();
+        }
+      });
+    }
+  };
+}
+
+// src/video-editor/ui.ts
+var STEPS = [40, 100, 200, 500, 1e3, 2e3, 5e3, 1e4, 15e3, 3e4, 6e4, 12e4, 3e5, 6e5];
+function videoRulerTicks(duration, pxPerSecond, fps) {
+  const pxPerMs = pxPerSecond / 1e3;
+  const major = STEPS.find((s) => s * pxPerMs >= 80) ?? STEPS[STEPS.length - 1];
+  const minor = STEPS.slice().reverse().find((s) => s < major && major % s === 0 && s * pxPerMs >= 10);
+  const step = minor ?? major;
+  const ticks = [];
+  for (let t = 0; t <= duration + 1e-6; t += step) {
+    const isMajor = Math.abs(t / major - Math.round(t / major)) < 1e-9;
+    ticks.push({ time: t, x: t * pxPerMs, major: isMajor, ...isMajor ? { label: formatVideoTimecode(t, fps).replace(/^00:/, "") } : {} });
+  }
+  return ticks;
+}
+function videoClipTint(clip, asset) {
+  if (clip.type === "text") return "#a855f7";
+  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) {
+  if (clip.name) return clip.name;
+  if (clip.type === "text") return clip.text.split("\n")[0];
+  if (clip.type === "color") return clip.color;
+  const base = asset?.name ?? asset?.src.replace(/^.*[\\/]/, "") ?? clip.asset;
+  const speed = videoClipSpeed(clip);
+  return speed !== 1 ? `${base} (${Math.round(speed * 100)}%)` : base;
+}
+function planVideoClipDrag(project, input) {
+  const at = findVideoClip(project, input.clip);
+  if (!at) return null;
+  const { clip, track } = at;
+  const snap = input.snap ?? ((t) => t);
+  if (input.mode === "move") {
+    const raw = Math.max(0, clip.start + input.delta);
+    const head = snap(raw) - raw;
+    const tail = snap(raw + clip.duration) - (raw + clip.duration);
+    const shifts = [head, tail].filter((d) => Math.abs(d) > 1e-9);
+    const start = Math.max(0, raw + (shifts.length ? shifts.reduce((a, b) => Math.abs(b) < Math.abs(a) ? b : a) : 0));
+    const target = input.track ?? track.id;
+    const moved = Math.abs(start - clip.start) > 1e-6 || target !== track.id;
+    return { start, duration: clip.duration, track: target, edit: moved ? { op: "move_clip", clip: clip.id, start, ...target !== track.id ? { track: target } : {} } : null };
+  }
+  const minimum = 1e3 / project.fps;
+  if (input.mode === "trim-start") {
+    const to2 = Math.min(snap(Math.max(0, clip.start + input.delta)), videoClipEnd(clip) - minimum);
+    const changed2 = Math.abs(to2 - clip.start) > 1e-6;
+    const plan = input.ripple ? { start: clip.start, duration: clip.duration - (to2 - clip.start) } : { start: to2, duration: videoClipEnd(clip) - to2 };
+    return { ...plan, track: track.id, edit: changed2 ? { op: "trim_clip", clip: clip.id, edge: "start", to: to2, ...input.ripple ? { ripple: true } : {} } : null };
+  }
+  const to = Math.max(snap(videoClipEnd(clip) + input.delta), clip.start + minimum);
+  const changed = Math.abs(to - videoClipEnd(clip)) > 1e-6;
+  return { start: clip.start, duration: to - clip.start, track: track.id, edit: changed ? { op: "trim_clip", clip: clip.id, edge: "end", to, ...input.ripple ? { ripple: true } : {} } : null };
+}
+function videoDropTracks(project, clipId) {
+  const at = findVideoClip(project, clipId);
+  if (!at) return [];
+  return project.tracks.filter((t) => t.kind === at.track.kind && !t.locked).map((t) => t.id);
+}
+function videoAssetDropEdit(project, assetId, options = {}) {
+  const asset = videoAssetMap(project).get(assetId);
+  if (!asset) return null;
+  const kind = asset.kind === "audio" ? "audio" : "video";
+  const track = options.track ?? project.tracks.find((t) => t.kind === kind && !t.locked)?.id;
+  if (!track) return null;
+  return { op: "add_clip", track, clip: { type: "media", asset: asset.id, ...options.start !== void 0 ? { start: options.start } : {} }, ...options.ripple ? { ripple: true } : {} };
+}
+function videoAssetKindOf(typeOrName) {
+  const s = typeOrName.toLowerCase().replace(/[?#].*$/, "");
+  if (s.startsWith("video/") || /\.(mp4|m4v|mov|webm|ogv|mkv)$/.test(s)) return "video";
+  if (s.startsWith("audio/") || /\.(mp3|m4a|aac|wav|ogg|oga|flac|opus)$/.test(s)) return "audio";
+  if (s.startsWith("image/") || /\.(png|jpe?g|gif|webp|avif|svg|bmp)$/.test(s)) return "image";
+  return null;
+}
+function probeVideoMedia(src, kind, timeout = 15e3) {
+  return new Promise((resolve, reject) => {
+    if (typeof document === "undefined") return reject(new Error("Media can only be probed in a browser."));
+    const timer = setTimeout(() => reject(new Error(`"${src}" took too long to load.`)), timeout);
+    const done = (probe) => {
+      clearTimeout(timer);
+      resolve(probe);
+    };
+    const failed = () => {
+      clearTimeout(timer);
+      reject(new Error(`"${src}" could not be loaded as ${kind}.`));
+    };
+    if (kind === "image") {
+      const img = new Image();
+      img.onload = () => done({ kind, width: img.naturalWidth, height: img.naturalHeight });
+      img.onerror = failed;
+      img.src = src;
+      return;
+    }
+    const el = document.createElement(kind);
+    el.preload = "metadata";
+    el.onloadedmetadata = () => {
+      const duration = Number.isFinite(el.duration) ? Math.round(el.duration * 1e3) : void 0;
+      const v = el;
+      done({ kind, ...duration ? { duration } : {}, ...kind === "video" && v.videoWidth ? { width: v.videoWidth, height: v.videoHeight } : {} });
+    };
+    el.onerror = failed;
+    el.src = src;
+  });
+}
+export {
+  VIDEO_CLIP_TYPES,
+  VIDEO_DEFAULT_STILL_DURATION,
+  VIDEO_DEFAULT_TITLE_DURATION,
+  VIDEO_EDIT_OPS,
+  VIDEO_FITS,
+  VIDEO_ISSUE_CODES,
+  VIDEO_TIME_EPSILON,
+  VIDEO_TRANSITION_TYPES,
+  VIDEO_WIPE_DIRECTIONS,
+  VideoEditorController,
+  VideoPreviewEngine,
+  allVideoClipIds,
+  applyVideoEdits,
+  checkVideoProject,
+  createVideoEditorToolProvider,
+  createVideoProject,
+  describeVideoProject,
+  drawVideoFrame,
+  ffmpegFilterValue,
+  findVideoClip,
+  findVideoGaps,
+  formatVideoSeconds,
+  formatVideoTimecode,
+  nextFreeVideoSlot,
+  parseVideoAsset,
+  parseVideoClip,
+  parseVideoMarker,
+  parseVideoProject,
+  parseVideoTrack,
+  parseVideoTransform,
+  parseVideoTransition,
+  placeVideoRect,
+  planVideoClipDrag,
+  probeVideoMedia,
+  snapToVideoFrame,
+  snapVideoTime,
+  sortedVideoClips,
+  toVideoEdl,
+  toVideoFfmpeg,
+  videoAssetDropEdit,
+  videoAssetKindOf,
+  videoAssetMap,
+  videoClipAfter,
+  videoClipBefore,
+  videoClipEnd,
+  videoClipHandles,
+  videoClipLabel,
+  videoClipOverhang,
+  videoClipSourceRange,
+  videoClipSpeed,
+  videoClipTint,
+  videoClipsAt,
+  videoContactSheetSvg,
+  videoDropTracks,
+  videoFrameAt,
+  videoFrameDuration,
+  videoFrameToSvg,
+  videoFrames,
+  videoIssueKey,
+  videoOverlap,
+  videoProjectDuration,
+  videoProjectSvg,
+  videoRulerTicks,
+  videoSnapPoints,
+  videoTextStyle,
+  videoTitleFrame,
+  videoWipeRect
+};
+//# sourceMappingURL=index.js.map