@pixerate/editor 0.115.0 → 0.117.0

package/dist/video-editor/index.js

@@ -1,3 +1,125 @@
+import {
+  VIDEO_BLEND_MODES,
+  VIDEO_CLIP_ANIMATION_DURATION,
+  VIDEO_CLIP_ANIMATION_EFFECTS,
+  VIDEO_CLIP_TYPES,
+  VIDEO_EASE_NAMES,
+  VIDEO_FADE_CURVES,
+  VIDEO_FITS,
+  VIDEO_GRADE_CONTROLS,
+  VIDEO_GRADE_PRESETS,
+  VIDEO_GRADE_PRESET_NAMES,
+  VIDEO_KEYFRAME_LIMITS,
+  VIDEO_KEYFRAME_PROPERTIES,
+  VIDEO_LUT_MAX_SIZE,
+  VIDEO_PLACEMENT_MODES,
+  VIDEO_TIME_EPSILON,
+  VIDEO_TRANSFORM_PROPERTIES,
+  VIDEO_TRANSITION_TYPES,
+  VIDEO_WIPE_DIRECTIONS,
+  VideoLutCache,
+  allVideoClipIds,
+  allVideoTracks,
+  applyVideoGrade,
+  applyVideoLut,
+  applyVideoLutToPixels,
+  checkVideoTimeRemap,
+  drawVideoFrame,
+  ffmpegFilterValue,
+  findVideoClip,
+  findVideoGaps,
+  findVideoSequenceClip,
+  findVideoSequenceCycle,
+  formatVideoSeconds,
+  formatVideoTimecode,
+  formatVideoTimecodeFrames,
+  isVideoDropFrameRate,
+  isVideoKeyframes,
+  nextFreeVideoSlot,
+  normalizeVideoGrade,
+  normalizeVideoGradeLut,
+  parseVideoCubeLut,
+  parseVideoLoudnessMeasurement,
+  placeVideoRect,
+  removeVideoKey,
+  retimeVideoAnimatable,
+  setVideoKey,
+  snapToVideoFrame,
+  snapVideoTime,
+  sortVideoKeys,
+  sortedVideoClips,
+  splitVideoAnimatable,
+  toVideoEdl,
+  toVideoFfmpeg,
+  toVideoLoudnessMeasure,
+  videoAssetHasSound,
+  videoAssetMap,
+  videoClipAfter,
+  videoClipAnimated,
+  videoClipAnimationProperties,
+  videoClipAnimationSpans,
+  videoClipBefore,
+  videoClipEnd,
+  videoClipHandles,
+  videoClipOverhang,
+  videoClipSoundGain,
+  videoClipSourceRange,
+  videoClipSourceTime,
+  videoClipSpeed,
+  videoClipSpeedAt,
+  videoClipsAt,
+  videoContactSheetSvg,
+  videoEaseBezier,
+  videoEaseProgress,
+  videoFadeCurveGain,
+  videoFrameAt,
+  videoFrameDuration,
+  videoFrameLeafLayers,
+  videoFrameToSvg,
+  videoFrames,
+  videoFreezeFrameEdit,
+  videoGradeCssFilter,
+  videoGradeFfmpegFilters,
+  videoGradeGainsFilterId,
+  videoGradeLook,
+  videoGradePreset,
+  videoGradeStepMatrix,
+  videoGradeStepSvgValues,
+  videoGradeSteps,
+  videoGradeSvgDefs,
+  videoGradeSvgFilter,
+  videoHourFrames,
+  videoIrisRadius,
+  videoKeyframeBreakpoints,
+  videoKeyframeFfmpegExpr,
+  videoKeysOf,
+  videoLutFromFunction,
+  videoLutSvgApproximation,
+  videoLutSvgPrimitives,
+  videoLutToCube,
+  videoOverlap,
+  videoProjectDuration,
+  videoProjectSvg,
+  videoSequenceChildren,
+  videoSequenceDuration,
+  videoSequenceMap,
+  videoShellQuote,
+  videoSlowMotionRamp,
+  videoSnapPoints,
+  videoSpeedRampEdit,
+  videoSpeedRampKeys,
+  videoTextStyle,
+  videoTimeRemapBreakpoints,
+  videoTimeRemapSpan,
+  videoTimecodeFrames,
+  videoTitleFrame,
+  videoTrackSyncLocked,
+  videoTransformAt,
+  videoTransitionAudioCurve,
+  videoTransitionEase,
+  videoValueAt,
+  videoWipeRect
+} from "../chunk-IPFRWILU.js";
 import {
   namedWithSuggestion
 } from "../chunk-INZJALPY.js";
@@ -11,708 +133,6 @@ import "../chunk-AGR4P4UZ.js";
 import "../chunk-ZRJMJIQU.js";
 import "../chunk-TGD52FEZ.js";
 
-// src/video-editor/types.ts
-var VIDEO_FITS = ["contain", "cover", "fill", "none"];
-var VIDEO_TRANSITION_TYPES = ["crossfade", "dip", "wipe", "push", "slide", "iris"];
-var VIDEO_WIPE_DIRECTIONS = ["left", "right", "up", "down"];
-var videoTransitionAudioCurve = (t) => t.audioCurve ?? (t.type === "dip" ? "linear" : "equal-power");
-var VIDEO_BLEND_MODES = ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "add"];
-var VIDEO_CLIP_ANIMATION_EFFECTS = ["fade", "rise", "drop", "slide-left", "slide-right", "zoom", "pop"];
-var VIDEO_FADE_CURVES = ["linear", "equal-power", "s-curve", "exponential", "logarithmic"];
-var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
-var VIDEO_CLIP_TYPES = ["media", "text", "color", "sequence"];
-
-// src/video-editor/keyframes.ts
-var VIDEO_EASE_NAMES = ["linear", "hold", "ease-in", "ease-out", "ease-in-out"];
-var VIDEO_KEYFRAME_PROPERTIES = ["opacity", "volume", "x", "y", "scale", "rotation"];
-var VIDEO_TRANSFORM_PROPERTIES = ["x", "y", "scale", "rotation"];
-var VIDEO_KEYFRAME_LIMITS = {
-  opacity: { default: 1, min: 0, max: 1 },
-  volume: { default: 1, min: 0, max: 4 },
-  x: { default: 0 },
-  y: { default: 0 },
-  scale: { default: 1, min: 0 },
-  rotation: { default: 0 }
-};
-var NAMED = {
-  "ease-in": [0.42, 0, 1, 1],
-  "ease-out": [0, 0, 0.58, 1],
-  "ease-in-out": [0.42, 0, 0.58, 1]
-};
-var isVideoKeyframes = (v) => typeof v === "object" && v !== null && Array.isArray(v.keys);
-function videoEaseBezier(ease) {
-  if (ease === void 0 || ease === "linear" || ease === "hold") return null;
-  return Array.isArray(ease) ? ease : NAMED[ease];
-}
-var bez = (a, b, s) => 3 * a * (1 - s) * (1 - s) * s + 3 * b * (1 - s) * s * s + s * s * s;
-var bezSlope = (a, b, s) => 3 * a * (1 - s) * (1 - s) + 6 * (b - a) * (1 - s) * s + 3 * (1 - b) * s * s;
-function bezierParam(x1, x2, x) {
-  let s = x;
-  for (let i = 0; i < 8; i++) {
-    const err = bez(x1, x2, s) - x;
-    if (Math.abs(err) < 1e-7) return s;
-    const d = bezSlope(x1, x2, s);
-    if (Math.abs(d) < 1e-6) break;
-    s -= err / d;
-    if (s < 0 || s > 1) break;
-  }
-  let lo = 0;
-  let hi = 1;
-  s = x;
-  for (let i = 0; i < 60; i++) {
-    const v = bez(x1, x2, s);
-    if (Math.abs(v - x) < 1e-9) break;
-    if (v < x) lo = s;
-    else hi = s;
-    s = (lo + hi) / 2;
-  }
-  return s;
-}
-function videoEaseProgress(ease, p) {
-  if (p <= 0) return 0;
-  if (p >= 1) return ease === "hold" ? 0 : 1;
-  if (ease === "hold") return 0;
-  const b = videoEaseBezier(ease);
-  if (!b) return p;
-  return bez(b[1], b[3], bezierParam(b[0], b[2], p));
-}
-function keyBefore(keys, t) {
-  let lo = 0;
-  let hi = keys.length - 1;
-  if (t < keys[0].t) return -1;
-  while (lo < hi) {
-    const mid = lo + hi + 1 >> 1;
-    if (keys[mid].t <= t) lo = mid;
-    else hi = mid - 1;
-  }
-  return lo;
-}
-function videoValueAt(prop, clipTime, fallback = 0) {
-  if (prop === void 0) return fallback;
-  if (typeof prop === "number") return prop;
-  const { keys } = prop;
-  if (!keys.length) return fallback;
-  const i = keyBefore(keys, clipTime);
-  if (i < 0) return keys[0].v;
-  if (i >= keys.length - 1) return keys[keys.length - 1].v;
-  const a = keys[i];
-  const b = keys[i + 1];
-  if (a.ease === "hold") return a.v;
-  return a.v + (b.v - a.v) * videoEaseProgress(a.ease, (clipTime - a.t) / (b.t - a.t));
-}
-var videoKeysOf = (prop) => isVideoKeyframes(prop) ? prop.keys : [];
-function retimeVideoAnimatable(prop, dt, k = 1) {
-  if (!isVideoKeyframes(prop)) return prop;
-  return { keys: prop.keys.map((key) => ({ ...key, t: key.t * k + dt })) };
-}
-function splitEase(ease, p) {
-  if (ease === "hold") return ["hold", "hold"];
-  const b = videoEaseBezier(ease);
-  if (!b) return [ease, ease];
-  const s = bezierParam(b[0], b[2], p);
-  const lerp = (u, v, k) => [u[0] + (v[0] - u[0]) * k, u[1] + (v[1] - u[1]) * k];
-  const P0 = [0, 0];
-  const P1 = [b[0], b[1]];
-  const P2 = [b[2], b[3]];
-  const P3 = [1, 1];
-  const A = lerp(P0, P1, s);
-  const B = lerp(P1, P2, s);
-  const C = lerp(P2, P3, s);
-  const AB = lerp(A, B, s);
-  const BC = lerp(B, C, s);
-  const M = lerp(AB, BC, s);
-  const r = (v) => Math.round(v * 1e6) / 1e6;
-  const left = Math.abs(M[1]) < 1e-9 ? "linear" : [r(A[0] / M[0]), r(A[1] / M[1]), r(AB[0] / M[0]), r(AB[1] / M[1])];
-  const dx = 1 - M[0];
-  const dy = 1 - M[1];
-  const right = Math.abs(dy) < 1e-9 ? "linear" : [r((BC[0] - M[0]) / dx), r((BC[1] - M[1]) / dy), r((C[0] - M[0]) / dx), r((C[1] - M[1]) / dy)];
-  return [left, right];
-}
-function splitVideoAnimatable(prop, at) {
-  if (!isVideoKeyframes(prop)) return [prop, prop];
-  const keys = prop.keys;
-  const eps = 1e-6;
-  const v = videoValueAt(prop, at);
-  const i = keyBefore(keys, at);
-  const exact = i >= 0 && Math.abs(keys[i].t - at) < eps;
-  let leftEase;
-  let rightEase;
-  if (exact) rightEase = keys[i].ease;
-  else if (i >= 0 && i < keys.length - 1) {
-    const a = keys[i];
-    [leftEase, rightEase] = splitEase(a.ease, (at - a.t) / (keys[i + 1].t - a.t));
-  }
-  const before = keys.slice(0, exact ? i : i + 1).map((k) => ({ ...k }));
-  if (before.length && leftEase !== void 0) before[before.length - 1] = withEase(before[before.length - 1], leftEase);
-  const left = [...before, { t: at, v }];
-  const right = [withEase({ t: 0, v }, rightEase), ...keys.slice(i + 1).map((k) => ({ ...k, t: k.t - at }))];
-  return [{ keys: left }, { keys: right }];
-}
-var withEase = (key, ease) => {
-  const { ease: _old, ...rest } = key;
-  return ease === void 0 || ease === "linear" ? rest : { ...rest, ease };
-};
-function sortVideoKeys(keys) {
-  const sorted = [...keys].sort((a, b) => a.t - b.t);
-  for (let i = 1; i < sorted.length; i++) if (Math.abs(sorted[i].t - sorted[i - 1].t) < 1e-6) throw new Error(`Two keys are at ${sorted[i].t} ms; give each key its own time.`);
-  return sorted;
-}
-function setVideoKey(prop, key, fallback) {
-  const keys = isVideoKeyframes(prop) ? prop.keys.filter((k) => Math.abs(k.t - key.t) >= 1e-6) : [];
-  if (!isVideoKeyframes(prop)) {
-    const v = prop ?? fallback;
-    if (key.t !== 0) keys.push({ t: 0, v });
-  }
-  return { keys: sortVideoKeys([...keys, key]) };
-}
-function removeVideoKey(prop, t) {
-  const keys = prop.keys.filter((k) => Math.abs(k.t - t) >= 1e-6);
-  return keys.length ? { keys } : prop.keys[0].v;
-}
-var fmt = (v) => {
-  const r = Math.round(v * 1e4) / 1e4;
-  return Object.is(r, -0) ? "0" : String(r);
-};
-var signed = (v) => fmt(v).startsWith("-") ? fmt(v) : `+${fmt(v)}`;
-function videoKeyframeBreakpoints(prop, step) {
-  const { keys } = prop;
-  const points = [];
-  const holds = /* @__PURE__ */ new Set();
-  for (let i = 0; i < keys.length; i++) {
-    const a = keys[i];
-    points.push([a.t, a.v]);
-    const b = keys[i + 1];
-    if (!b) break;
-    if (a.ease === "hold") {
-      holds.add(points.length - 1);
-      continue;
-    }
-    if (!videoEaseBezier(a.ease)) continue;
-    const n2 = Math.max(1, Math.ceil((b.t - a.t) / step));
-    for (let k = 1; k < n2; k++) {
-      const t = a.t + (b.t - a.t) * k / n2;
-      points.push([t, videoValueAt(prop, t)]);
-    }
-  }
-  return { points, holds };
-}
-function videoKeyframeFfmpegExpr(prop, time, fallback, step) {
-  if (!isVideoKeyframes(prop)) return fmt(prop ?? fallback);
-  const { points, holds } = videoKeyframeBreakpoints(prop, step);
-  if (points.length === 1 || points.every(([, v]) => v === points[0][1])) return fmt(points[0][1]);
-  let expr = fmt(points[points.length - 1][1]);
-  for (let i = points.length - 2; i >= 0; i--) {
-    const [t0, v0] = points[i];
-    const [t1, v1] = points[i + 1];
-    const seg = holds.has(i) || v0 === v1 ? fmt(v0) : `${fmt(v0)}${signed((v1 - v0) / (t1 - t0))}*(${time}${signed(-t0)})`;
-    expr = `if(lt(${time},${fmt(t1)}),${seg},${expr})`;
-  }
-  return `if(lt(${time},${fmt(points[0][0])}),${fmt(points[0][1])},${expr})`;
-}
-
-// src/video-editor/lut.ts
-var VIDEO_LUT_MAX_SIZE = 129;
-function parseVideoCubeLut(text) {
-  let size = 0;
-  let size1 = 0;
-  let title;
-  const domainMin = [0, 0, 0];
-  const domainMax = [1, 1, 1];
-  let data = null;
-  let rows = 0;
-  const lines = text.split(/\r\n|\r|\n/);
-  const fail2 = (line, message) => {
-    throw new Error(`Line ${line + 1} of the .cube file: ${message}.`);
-  };
-  const numbers = (parts, line) => parts.map((p) => {
-    const v = Number(p);
-    if (!Number.isFinite(v)) fail2(line, `"${p}" is not a number`);
-    return v;
-  });
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].replace(/#.*/, "").trim();
-    if (!line) continue;
-    const parts = line.split(/\s+/);
-    const key = parts[0];
-    if (/^[A-Za-z]/.test(key)) {
-      if (rows) fail2(i, `"${key}" comes after the table; keywords go before it`);
-      if (key === "TITLE") title = line.slice(5).trim().replace(/^"|"$/g, "");
-      else if (key === "LUT_3D_SIZE") {
-        size = Number(parts[1]);
-        if (!Number.isInteger(size) || size < 2 || size > VIDEO_LUT_MAX_SIZE) fail2(i, `LUT_3D_SIZE must be a whole number from 2 to ${VIDEO_LUT_MAX_SIZE}, not "${parts[1] ?? ""}"`);
-      } else if (key === "LUT_1D_SIZE") size1 = Number(parts[1]) || 1;
-      else if (key === "DOMAIN_MIN" || key === "DOMAIN_MAX") {
-        const v2 = numbers(parts.slice(1), i);
-        if (v2.length !== 3) fail2(i, `${key} needs 3 numbers`);
-        (key === "DOMAIN_MIN" ? domainMin : domainMax).splice(0, 3, ...v2);
-      } else if (key === "LUT_3D_INPUT_RANGE") {
-        const v2 = numbers(parts.slice(1), i);
-        if (v2.length !== 2 || !(v2[1] > v2[0])) fail2(i, "LUT_3D_INPUT_RANGE needs a minimum and a larger maximum");
-        domainMin.fill(v2[0]);
-        domainMax.fill(v2[1]);
-      }
-      continue;
-    }
-    if (!size) fail2(i, size1 ? "this is a 1D LUT (LUT_1D_SIZE); only 3D LUTs (LUT_3D_SIZE) are supported" : "the table starts before LUT_3D_SIZE");
-    data ??= new Float32Array(size * size * size * 3);
-    const v = numbers(parts, i);
-    if (v.length !== 3) fail2(i, `a table row needs 3 numbers, not ${v.length}`);
-    if (rows >= size ** 3) fail2(i, `the table has more than the ${size ** 3} rows LUT_3D_SIZE ${size} needs`);
-    data.set(v, rows * 3);
-    rows++;
-  }
-  if (!size) throw new Error(size1 ? "The .cube file is a 1D LUT (LUT_1D_SIZE); only 3D LUTs (LUT_3D_SIZE) are supported." : "The .cube file has no LUT_3D_SIZE line, so it is not a 3D LUT.");
-  if (rows !== size ** 3) throw new Error(`The .cube file has ${rows} table rows; LUT_3D_SIZE ${size} needs ${size ** 3}.`);
-  for (let c = 0; c < 3; c++) if (!(domainMax[c] > domainMin[c])) throw new Error("The .cube file's DOMAIN_MAX must be larger than its DOMAIN_MIN on every channel.");
-  return { ...title ? { title } : {}, size, domainMin, domainMax, data };
-}
-function videoLutFromFunction(size, fn, title) {
-  const n2 = size - 1;
-  const data = new Float32Array(size ** 3 * 3);
-  let i = 0;
-  for (let b = 0; b < size; b++)
-    for (let g = 0; g < size; g++)
-      for (let r = 0; r < size; r++) {
-        data.set(fn([r / n2, g / n2, b / n2]), i);
-        i += 3;
-      }
-  return { ...title ? { title } : {}, size, domainMin: [0, 0, 0], domainMax: [1, 1, 1], data };
-}
-function videoLutToCube(lut) {
-  const f = (v) => (Math.round(v * 1e6) / 1e6).toString();
-  const head = [...lut.title ? [`TITLE "${lut.title.replace(/"/g, "'")}"`] : [], `LUT_3D_SIZE ${lut.size}`];
-  if (lut.domainMin.some((v) => v !== 0) || lut.domainMax.some((v) => v !== 1)) head.push(`DOMAIN_MIN ${lut.domainMin.map(f).join(" ")}`, `DOMAIN_MAX ${lut.domainMax.map(f).join(" ")}`);
-  const rows = [];
-  for (let i = 0; i < lut.data.length; i += 3) rows.push(`${f(lut.data[i])} ${f(lut.data[i + 1])} ${f(lut.data[i + 2])}`);
-  return `${head.join("\n")}
-${rows.join("\n")}
-`;
-}
-var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
-function applyVideoLut(lut, rgb, out = [0, 0, 0]) {
-  const { size, data, domainMin, domainMax } = lut;
-  const n2 = size - 1;
-  const x = clamp01((rgb[0] - domainMin[0]) / (domainMax[0] - domainMin[0])) * n2;
-  const y = clamp01((rgb[1] - domainMin[1]) / (domainMax[1] - domainMin[1])) * n2;
-  const z = clamp01((rgb[2] - domainMin[2]) / (domainMax[2] - domainMin[2])) * n2;
-  const r0 = Math.min(n2 - 1, Math.floor(x));
-  const g0 = Math.min(n2 - 1, Math.floor(y));
-  const b0 = Math.min(n2 - 1, Math.floor(z));
-  const fr = x - r0;
-  const fg = y - g0;
-  const fb = z - b0;
-  const sr = 3;
-  const sg = 3 * size;
-  const sb = 3 * size * size;
-  const o = r0 * sr + g0 * sg + b0 * sb;
-  let a, c, w0, w1, w2, w3;
-  if (fr > fg) {
-    if (fg > fb) [a, c, w0, w1, w2, w3] = [sr, sr + sg, 1 - fr, fr - fg, fg - fb, fb];
-    else if (fr > fb) [a, c, w0, w1, w2, w3] = [sr, sr + sb, 1 - fr, fr - fb, fb - fg, fg];
-    else [a, c, w0, w1, w2, w3] = [sb, sb + sr, 1 - fb, fb - fr, fr - fg, fg];
-  } else if (fb > fg) [a, c, w0, w1, w2, w3] = [sb, sb + sg, 1 - fb, fb - fg, fg - fr, fr];
-  else if (fb > fr) [a, c, w0, w1, w2, w3] = [sg, sg + sb, 1 - fg, fg - fb, fb - fr, fr];
-  else [a, c, w0, w1, w2, w3] = [sg, sg + sr, 1 - fg, fg - fr, fr - fb, fb];
-  const d = sr + sg + sb;
-  for (let k = 0; k < 3; k++) out[k] = clamp01(w0 * data[o + k] + w1 * data[o + a + k] + w2 * data[o + c + k] + w3 * data[o + d + k]);
-  return out;
-}
-function applyVideoLutToPixels(lut, data, strength = 1) {
-  const s = clamp01(strength);
-  if (!s) return;
-  const rgb = [0, 0, 0];
-  const out = [0, 0, 0];
-  for (let i = 0; i < data.length; i += 4) {
-    if (!data[i + 3]) continue;
-    rgb[0] = data[i] / 255;
-    rgb[1] = data[i + 1] / 255;
-    rgb[2] = data[i + 2] / 255;
-    applyVideoLut(lut, rgb, out);
-    for (let k = 0; k < 3; k++) data[i + k] = Math.round((rgb[k] + (out[k] - rgb[k]) * s) * 255);
-  }
-}
-var approximations = /* @__PURE__ */ new WeakMap();
-function videoLutSvgApproximation(lut) {
-  const cached = approximations.get(lut);
-  if (cached) return cached;
-  const points = 17;
-  const tables = [[], [], []];
-  for (let i = 0; i < points; i++) {
-    const v = i / (points - 1);
-    const out = applyVideoLut(lut, [v, v, v]);
-    for (let k = 0; k < 3; k++) tables[k].push(out[k]);
-  }
-  const curve = (k, v) => {
-    const x = clamp01(v) * (points - 1);
-    const i = Math.min(points - 2, Math.floor(x));
-    return tables[k][i] + (tables[k][i + 1] - tables[k][i]) * (x - i);
-  };
-  const ata = Array.from({ length: 4 }, () => [0, 0, 0, 0]);
-  const atb = Array.from({ length: 3 }, () => [0, 0, 0, 0]);
-  const grid = 9;
-  for (let b = 0; b < grid; b++)
-    for (let g = 0; g < grid; g++)
-      for (let r = 0; r < grid; r++) {
-        const x = [r / (grid - 1), g / (grid - 1), b / (grid - 1)];
-        const z = [curve(0, x[0]), curve(1, x[1]), curve(2, x[2]), 1];
-        const y = applyVideoLut(lut, x);
-        for (let i = 0; i < 4; i++) {
-          for (let j = 0; j < 4; j++) ata[i][j] += z[i] * z[j];
-          for (let k = 0; k < 3; k++) atb[k][i] += z[i] * y[k];
-        }
-      }
-  const matrix = atb.map((rhs) => solve4(ata, rhs));
-  const result = { tables, matrix };
-  approximations.set(lut, result);
-  return result;
-}
-function solve4(a, b) {
-  const m = a.map((row, i) => [...row, b[i]]);
-  for (let col = 0; col < 4; col++) {
-    let pivot = col;
-    for (let r = col + 1; r < 4; r++) if (Math.abs(m[r][col]) > Math.abs(m[pivot][col])) pivot = r;
-    if (Math.abs(m[pivot][col]) < 1e-12) continue;
-    [m[col], m[pivot]] = [m[pivot], m[col]];
-    for (let r = 0; r < 4; r++) {
-      if (r === col) continue;
-      const f = m[r][col] / m[col][col];
-      for (let c = col; c < 5; c++) m[r][c] -= f * m[col][c];
-    }
-  }
-  return m.map((row, i) => Math.abs(row[i]) < 1e-12 ? 0 : row[4] / row[i]);
-}
-var VideoLutCache = class {
-  constructor(loader = async (src) => {
-    const res = await fetch(src);
-    if (!res.ok) throw new Error(`${res.status} ${res.statusText}`.trim());
-    return res.text();
-  }) {
-    this.loader = loader;
-  }
-  loader;
-  ready = /* @__PURE__ */ new Map();
-  pending = /* @__PURE__ */ new Map();
-  failed = /* @__PURE__ */ new Map();
-  listeners = /* @__PURE__ */ new Set();
-  /** The LUT if loaded, without starting to load it. */
-  peek(src) {
-    return this.ready.get(src);
-  }
-  /** The LUT if loaded; otherwise `undefined`, and loading starts (once) unless it failed. */
-  get(src) {
-    const lut = this.ready.get(src);
-    if (!lut && !this.failed.has(src)) void this.load(src).catch(() => {
-    });
-    return lut;
-  }
-  /** Why loading a LUT failed, if it did. */
-  error(src) {
-    return this.failed.get(src);
-  }
-  /** The LUT, loading and reading it if needed. Rejects with a readable error. */
-  load(src) {
-    const ready = this.ready.get(src);
-    if (ready) return Promise.resolve(ready);
-    const failed = this.failed.get(src);
-    if (failed) return Promise.reject(new Error(failed));
-    let pending = this.pending.get(src);
-    if (!pending) {
-      pending = Promise.resolve().then(() => this.loader(src)).then((v) => typeof v === "string" ? parseVideoCubeLut(v) : v).then(
-        (lut) => {
-          this.pending.delete(src);
-          this.ready.set(src, lut);
-          this.emit();
-          return lut;
-        },
-        (e) => {
-          this.pending.delete(src);
-          const message = `The LUT "${src}" could not be read: ${e instanceof Error ? e.message : String(e)}`;
-          this.failed.set(src, message);
-          this.emit();
-          throw new Error(message);
-        }
-      );
-      this.pending.set(src, pending);
-    }
-    return pending;
-  }
-  /** Uses a LUT the host already has (`.cube` text or a parsed LUT), under `src`. */
-  set(src, lut) {
-    const parsed = typeof lut === "string" ? parseVideoCubeLut(lut) : lut;
-    this.ready.set(src, parsed);
-    this.failed.delete(src);
-    this.emit();
-    return parsed;
-  }
-  /** Forgets a failure so the next `get` tries again. */
-  retry(src) {
-    if (this.failed.delete(src)) this.emit();
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    return () => {
-      this.listeners.delete(fn);
-    };
-  }
-  emit() {
-    for (const l of [...this.listeners]) l();
-  }
-};
-
-// src/video-editor/grade.ts
-var VIDEO_GRADE_CONTROLS = [
-  { key: "exposure", label: "Exposure", min: -3, max: 3, step: 0.1, description: "Exposure in stops: +1 doubles every channel, -1 halves it (default 0)." },
-  { key: "contrast", label: "Contrast", min: -1, max: 1, step: 0.05, description: "Contrast around mid grey, -1 (flat grey) to 1 (twice as steep); default 0." },
-  { key: "saturation", label: "Saturation", min: -1, max: 1, step: 0.05, description: "Saturation, -1 (black and white) to 1 (twice as saturated); default 0." },
-  { key: "hue", label: "Hue", min: -180, max: 180, step: 1, description: "Hue rotation in degrees (default 0)." },
-  { key: "temperature", label: "Temperature", min: -1, max: 1, step: 0.05, description: "White balance, -1 (cool, bluer) to 1 (warm, more orange); default 0." },
-  { key: "tint", label: "Tint", min: -1, max: 1, step: 0.05, description: "White balance, -1 (greener) to 1 (more magenta); default 0." }
-];
-var VIDEO_GRADE_PRESETS = {
-  warm: { temperature: 0.4, saturation: 0.1 },
-  cool: { temperature: -0.4, tint: -0.05 },
-  punchy: { contrast: 0.25, saturation: 0.3 },
-  faded: { exposure: 0.15, contrast: -0.3, saturation: -0.3 },
-  "black-and-white": { saturation: -1, contrast: 0.15 },
-  "bleach-bypass": { saturation: -0.6, contrast: 0.4 },
-  "day-for-night": { exposure: -1.5, saturation: -0.4, temperature: -0.6 }
-};
-var VIDEO_GRADE_PRESET_NAMES = Object.keys(VIDEO_GRADE_PRESETS);
-var clampTo = (c, v) => Math.min(c.max, Math.max(c.min, v));
-function normalizeVideoGradeLut(lut) {
-  if (!lut || typeof lut.src !== "string" || !lut.src) return void 0;
-  const strength = typeof lut.strength === "number" && Number.isFinite(lut.strength) ? Math.round(Math.min(1, Math.max(0, lut.strength)) * 1e3) / 1e3 : 1;
-  if (!strength) return void 0;
-  return { src: lut.src, ...strength !== 1 ? { strength } : {}, ...lut.name ? { name: lut.name } : {} };
-}
-function normalizeVideoGrade(grade) {
-  if (!grade) return void 0;
-  const out = {};
-  for (const c of VIDEO_GRADE_CONTROLS) {
-    const v = grade[c.key];
-    if (typeof v === "number" && Number.isFinite(v) && v !== 0) out[c.key] = Math.round(clampTo(c, v) * 1e3) / 1e3;
-  }
-  const lut = normalizeVideoGradeLut(grade.lut);
-  if (lut) out.lut = lut;
-  return Object.keys(out).length ? out : void 0;
-}
-function videoGradePreset(name, amount = 1) {
-  const preset = VIDEO_GRADE_PRESETS[name];
-  if (!preset) throw new Error(`There is no grade preset "${name}"; the presets are ${VIDEO_GRADE_PRESET_NAMES.join(", ")}.`);
-  const k = Math.min(1, Math.max(0, amount));
-  return normalizeVideoGrade(Object.fromEntries(Object.entries(preset).map(([key, v]) => [key, v * k])));
-}
-function videoGradeLook(current, name, amount = 1) {
-  return normalizeVideoGrade({ ...videoGradePreset(name, amount), ...current?.lut ? { lut: current.lut } : {} });
-}
-function videoGradeSteps(grade) {
-  const g = normalizeVideoGrade(grade);
-  if (!g) return [];
-  const steps = [];
-  if (g.exposure) steps.push({ kind: "brightness", amount: 2 ** g.exposure });
-  if (g.contrast) steps.push({ kind: "contrast", amount: 1 + g.contrast });
-  if (g.saturation) steps.push({ kind: "saturate", amount: 1 + g.saturation });
-  if (g.hue) steps.push({ kind: "hue-rotate", degrees: g.hue });
-  if (g.temperature || g.tint) {
-    const t = g.temperature ?? 0;
-    steps.push({ kind: "gains", r: 1 + 0.25 * t, g: 1 - 0.25 * (g.tint ?? 0), b: 1 - 0.25 * t });
-  }
-  return steps;
-}
-function videoGradeStepMatrix(step) {
-  switch (step.kind) {
-    case "brightness":
-      return [
-        [step.amount, 0, 0, 0],
-        [0, step.amount, 0, 0],
-        [0, 0, step.amount, 0]
-      ];
-    case "contrast": {
-      const c = step.amount;
-      const o = 0.5 - 0.5 * c;
-      return [
-        [c, 0, 0, o],
-        [0, c, 0, o],
-        [0, 0, c, o]
-      ];
-    }
-    case "gains":
-      return [
-        [step.r, 0, 0, 0],
-        [0, step.g, 0, 0],
-        [0, 0, step.b, 0]
-      ];
-    case "saturate": {
-      const s = step.amount;
-      return [
-        [0.213 + 0.787 * s, 0.715 - 0.715 * s, 0.072 - 0.072 * s, 0],
-        [0.213 - 0.213 * s, 0.715 + 0.285 * s, 0.072 - 0.072 * s, 0],
-        [0.213 - 0.213 * s, 0.715 - 0.715 * s, 0.072 + 0.928 * s, 0]
-      ];
-    }
-    case "hue-rotate": {
-      const a = step.degrees * Math.PI / 180;
-      const cos = Math.cos(a);
-      const sin = Math.sin(a);
-      return [
-        [0.213 + cos * 0.787 - sin * 0.213, 0.715 - cos * 0.715 - sin * 0.715, 0.072 - cos * 0.072 + sin * 0.928, 0],
-        [0.213 - cos * 0.213 + sin * 0.143, 0.715 + cos * 0.285 + sin * 0.14, 0.072 - cos * 0.072 - sin * 0.283, 0],
-        [0.213 - cos * 0.213 - sin * 0.787, 0.715 - cos * 0.715 + sin * 0.715, 0.072 + cos * 0.928 + sin * 0.072, 0]
-      ];
-    }
-  }
-}
-function applyVideoGrade(grade, rgb, lut) {
-  let v = rgb.map((x) => x / 255);
-  for (const step of videoGradeSteps(grade)) {
-    const m = videoGradeStepMatrix(step);
-    v = m.map((row) => Math.min(1, Math.max(0, row[0] * v[0] + row[1] * v[1] + row[2] * v[2] + row[3])));
-  }
-  const setting = normalizeVideoGradeLut(grade?.lut);
-  if (setting && lut) {
-    const out = applyVideoLut(lut, v);
-    const s = setting.strength ?? 1;
-    v = v.map((x, k) => x + (out[k] - x) * s);
-  }
-  return v.map((x) => Math.round(x * 255));
-}
-var fmt2 = (v) => String(Math.round(v * 1e5) / 1e5);
-function videoGradeStepSvgValues(step) {
-  return videoGradeStepMatrix(step).map((row) => [row[0], row[1], row[2], 0, row[3]].map(fmt2).join(" ")).concat("0 0 0 1 0").join(" ");
-}
-function videoLutSvgPrimitives(lut, strength = 1) {
-  const { tables, matrix } = videoLutSvgApproximation(lut);
-  const table = (k) => tables[k].map(fmt2).join(" ");
-  const values = matrix.map((row) => [row[0], row[1], row[2], 0, row[3]].map(fmt2).join(" ")).concat("0 0 0 1 0").join(" ");
-  const s = Math.min(1, Math.max(0, strength));
-  return `<feComponentTransfer result="lutIn"><feFuncA type="identity"/></feComponentTransfer><feComponentTransfer><feFuncR type="table" tableValues="${table(0)}"/><feFuncG type="table" tableValues="${table(1)}"/><feFuncB type="table" tableValues="${table(2)}"/></feComponentTransfer><feColorMatrix type="matrix" values="${values}"/>` + (s < 1 ? `<feComposite in2="lutIn" operator="arithmetic" k1="0" k2="${fmt2(s)}" k3="${fmt2(1 - s)}" k4="0"/>` : "");
-}
-function videoGradeSvgFilter(id, grade, lut) {
-  const steps = videoGradeSteps(grade);
-  const setting = normalizeVideoGradeLut(grade?.lut);
-  return `<filter id="${id}" color-interpolation-filters="sRGB" x="0" y="0" width="100%" height="100%">${steps.map((s) => `<feColorMatrix type="matrix" values="${videoGradeStepSvgValues(s)}"/>`).join("")}${setting && lut ? videoLutSvgPrimitives(lut, setting.strength) : ""}</filter>`;
-}
-var videoGradeGainsFilterId = (step) => `pixerate-wb-${[step.r, step.g, step.b].map((v) => Math.round(v * 1e3)).join("-")}`;
-function videoGradeCssFilter(grade) {
-  return videoGradeSteps(grade).map((s) => s.kind === "brightness" ? `brightness(${fmt2(s.amount)})` : s.kind === "contrast" ? `contrast(${fmt2(s.amount)})` : s.kind === "saturate" ? `saturate(${fmt2(s.amount)})` : s.kind === "hue-rotate" ? `hue-rotate(${fmt2(s.degrees)}deg)` : `url(#${videoGradeGainsFilterId(s)})`).join(" ");
-}
-function videoGradeSvgDefs(grade) {
-  return videoGradeSteps(grade).filter((s) => s.kind === "gains").map((s) => {
-    const id = videoGradeGainsFilterId(s);
-    return { id, markup: `<filter id="${id}" color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="${videoGradeStepSvgValues(s)}"/></filter>` };
-  });
-}
-function videoGradeFfmpegFilters(grade) {
-  return videoGradeSteps(grade).map((step) => {
-    const m = videoGradeStepMatrix(step);
-    if (step.kind === "brightness" || step.kind === "contrast") {
-      const lut = (i) => `clip(val*${fmt2(m[i][i])}+${fmt2(m[i][3] * 255)},0,255)`;
-      return `lutrgb=r='${lut(0)}':g='${lut(1)}':b='${lut(2)}'`;
-    }
-    const k = ["r", "g", "b"];
-    return `colorchannelmixer=${m.flatMap((row, i) => row.slice(0, 3).map((v, j) => `${k[i]}${k[j]}=${fmt2(v)}`)).join(":")}`;
-  });
-}
-
-// src/video-editor/remap.ts
-function videoClipSourceTime(clip, clipTime) {
-  const base = clip.in ?? 0;
-  return clip.timeRemap ? base + videoValueAt(clip.timeRemap, clipTime, 0) : base + clipTime * (clip.speed ?? 1);
-}
-function videoClipSpeedAt(clip, clipTime) {
-  if (clip.type !== "media") return 1;
-  if (!clip.timeRemap) return clip.speed ?? 1;
-  const t = Math.min(Math.max(clipTime, 0), Math.max(0, clip.duration - 1));
-  return Math.max(0, videoClipSourceTime(clip, t + 1) - videoClipSourceTime(clip, t));
-}
-function videoSpeedRampKeys(segments) {
-  if (!segments.length) throw new Error("Give at least one stretch { duration, speed }.");
-  const keys = [];
-  let t = 0;
-  let v = 0;
-  segments.forEach((s, i) => {
-    if (!(s.duration > 0)) throw new Error(`Stretch ${i + 1} needs a duration above 0 ms.`);
-    for (const [name, x] of [["speed", s.speed], ["toSpeed", s.toSpeed]])
-      if (x !== void 0 && !(x >= 0 && x <= 20)) throw new Error(`Stretch ${i + 1}'s ${name} must be from 0 (a freeze) to 20; got ${x}.`);
-    const a = s.speed;
-    const b = s.toSpeed ?? s.speed;
-    const avg = (a + b) / 2;
-    let ease = "linear";
-    if (a !== b && avg > 0) {
-      ease = [1 / 3, 2 * a / (3 * (a + b)), 2 / 3, 1 - 2 * b / (3 * (a + b))].map((n2) => Math.round(n2 * 1e6) / 1e6);
-    }
-    keys.push({ t, v, ...ease === "linear" ? {} : { ease } });
-    t += s.duration;
-    v += avg * s.duration;
-  });
-  keys.push({ t, v });
-  return { keys: mergeLinear(keys), duration: t, source: v };
-}
-function mergeLinear(keys) {
-  const out = [keys[0]];
-  for (let i = 1; i < keys.length; i++) {
-    const prev = out[out.length - 1];
-    const k = keys[i];
-    const before = out.length > 1 ? out[out.length - 2] : null;
-    if (before && !before.ease && !prev.ease) {
-      const s1 = (prev.v - before.v) / (prev.t - before.t);
-      const s2 = (k.v - prev.v) / (k.t - prev.t);
-      if (Math.abs(s1 - s2) < 1e-9) {
-        out[out.length - 1] = k;
-        continue;
-      }
-    }
-    out.push(k);
-  }
-  return out;
-}
-function checkVideoTimeRemap(remap, path = "timeRemap") {
-  const { keys } = remap;
-  if (!keys.length) throw new Error(`${path} needs at least one key.`);
-  keys.forEach((k, i) => {
-    if (k.v < 0) throw new Error(`${path}.keys[${i}].v must be at least 0 (ms after the in point).`);
-    const next = keys[i + 1];
-    if (!next) return;
-    if (next.v < k.v - 1e-6) throw new Error(`${path}.keys[${i + 1}] goes back in the source (${next.v} ms after ${k.v} ms); a ramp only plays forwards, so make each value at least the one before.`);
-    if (!videoEaseBezier(k.ease)) return;
-    let prev = k.v;
-    for (let n2 = 1; n2 <= 32; n2++) {
-      const v = videoValueAt(remap, k.t + (next.t - k.t) * n2 / 32);
-      if (v < prev - 1e-3) throw new Error(`${path}.keys[${i}].ease overshoots, which would play backwards; use a curve that only moves forwards (or linear).`);
-      prev = v;
-    }
-  });
-}
-function videoTimeRemapSpan(remap) {
-  return { from: remap.keys[0].v, to: remap.keys[remap.keys.length - 1].v };
-}
-function videoTimeRemapBreakpoints(remap, step) {
-  const { points, holds } = videoKeyframeBreakpoints(remap, step);
-  const out = [];
-  points.forEach(([t, v], i) => {
-    out.push({ t, v });
-    if (holds.has(i) && points[i + 1]) out.push({ t: points[i + 1][0], v });
-  });
-  return out;
-}
-function videoSpeedRampEdit(clip, segments, ripple = true) {
-  const ramp = videoSpeedRampKeys(segments);
-  const offset = videoClipSourceTime(clip, 0) - (clip.in ?? 0);
-  return { op: "set_time_remap", clip: clip.id, keys: ramp.keys.map((k) => ({ ...k, v: k.v + offset })), duration: ramp.duration, ripple };
-}
-function videoFreezeFrameEdit(clip, at, duration, ripple = true) {
-  if (at < 0 || at > clip.duration) throw new Error(`${Math.round(at)} ms is outside clip "${clip.id}" (0\u2013${clip.duration} ms of clip time).`);
-  const remap = clip.timeRemap ?? { keys: [{ t: 0, v: 0 }, { t: clip.duration, v: clip.duration * (clip.speed ?? 1) }] };
-  const [left, right] = splitVideoAnimatable(remap, at);
-  const keys = [...left.keys.slice(0, -1), { ...left.keys[left.keys.length - 1], ease: "linear" }, ...right.keys.map((k) => ({ ...k, t: k.t + at + duration }))];
-  return { op: "set_time_remap", clip: clip.id, keys, duration: clip.duration + duration, ripple };
-}
-var videoSlowMotionRamp = (duration) => [
-  { duration: Math.max(1, duration / 2), speed: 1 },
-  { duration: 500, speed: 1, toSpeed: 0.3 },
-  { duration: 1500, speed: 0.3 }
-];
-
 // src/video-editor/parse.ts
 var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var fail = (path, what) => {
@@ -745,7 +165,7 @@ var compact = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !=
 function parseVideoEase(v, path) {
   if (v === void 0) return void 0;
   if (Array.isArray(v)) {
-    if (v.length !== 4 || !v.every((n2) => typeof n2 === "number" && Number.isFinite(n2))) fail(path, "must be four numbers [x1, y1, x2, y2] (CSS cubic-bezier)");
+    if (v.length !== 4 || !v.every((n) => typeof n === "number" && Number.isFinite(n))) fail(path, "must be four numbers [x1, y1, x2, y2] (CSS cubic-bezier)");
     if (v[0] < 0 || v[0] > 1 || v[2] < 0 || v[2] > 1) fail(path, "must have x1 and x2 between 0 and 1");
     return [v[0], v[1], v[2], v[3]];
   }
@@ -1026,258 +446,6 @@ function createVideoProject(options = {}) {
   });
 }
 
-// src/video-editor/timeline.ts
-var VIDEO_TIME_EPSILON = 0.5;
-var videoClipEnd = (clip) => clip.start + clip.duration;
-var videoTrackSyncLocked = (track) => track.syncLocked !== false;
-var videoClipSpeed = (clip) => clip.type === "media" ? clip.speed ?? 1 : 1;
-function videoClipSourceRange(clip) {
-  if (clip.type === "sequence") return { in: clip.in ?? 0, out: (clip.in ?? 0) + clip.duration };
-  if (clip.type !== "media") return null;
-  const start = clip.in ?? 0;
-  if (clip.timeRemap?.keys.length) return { in: start + clip.timeRemap.keys[0].v, out: start + clip.timeRemap.keys[clip.timeRemap.keys.length - 1].v };
-  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 isVideoDropFrameRate(fps) {
-  const nominal = Math.round(fps);
-  return (nominal === 30 || nominal === 60) && Math.abs(fps - nominal * 1e3 / 1001) < 5e-3;
-}
-var exactVideoRate = (fps) => {
-  const nominal = Math.round(fps);
-  return nominal !== fps && Math.abs(fps - nominal * 1e3 / 1001) < 5e-3 ? nominal * 1e3 / 1001 : fps;
-};
-var videoTimecodeFrames = (time, fps) => Math.max(0, Math.round(time * exactVideoRate(fps) / 1e3));
-function formatVideoTimecode(time, fps, dropFrame = isVideoDropFrameRate(fps)) {
-  return formatVideoTimecodeFrames(videoTimecodeFrames(time, fps), fps, dropFrame);
-}
-function formatVideoTimecodeFrames(frames, fps, dropFrame = isVideoDropFrameRate(fps)) {
-  const base = Math.round(fps);
-  let total = Math.max(0, Math.round(frames));
-  const drop = dropFrame && isVideoDropFrameRate(fps);
-  if (drop) {
-    const skip = base / 15;
-    const perMinute = base * 60 - skip;
-    const perTen = perMinute * 10 + skip;
-    const tens = Math.floor(total / perTen);
-    const rest = total % perTen;
-    total += skip * 9 * tens + (rest > skip ? skip * Math.floor((rest - skip) / perMinute) : 0);
-  }
-  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)}${drop ? ";" : ":"}${pad(ff)}`;
-}
-var videoHourFrames = (fps, dropFrame = isVideoDropFrameRate(fps)) => {
-  const base = Math.round(fps);
-  return dropFrame && isVideoDropFrameRate(fps) ? base * 3600 - base / 15 * 54 : base * 3600;
-};
-var formatVideoSeconds = (time) => `${(time / 1e3).toFixed(2)} s`;
-var videoAssetHasSound = (asset) => !!asset && (asset.kind === "audio" || asset.kind === "video" && asset.hasAudio !== false);
-function videoAssetMap(project) {
-  return new Map(project.assets.map((a) => [a.id, a]));
-}
-function videoSequenceMap(project) {
-  return new Map((project.sequences ?? []).map((q) => [q.id, q]));
-}
-function videoSequenceDuration(sequence) {
-  let end = 0;
-  for (const track of sequence.tracks) for (const clip of track.clips) end = Math.max(end, videoClipEnd(clip));
-  return end;
-}
-var videoSequenceChildren = (sequence) => [...new Set(sequence.tracks.flatMap((t) => t.clips.flatMap((c) => c.type === "sequence" ? [c.sequence] : [])))];
-function findVideoSequenceCycle(project, id) {
-  const sequences = videoSequenceMap(project);
-  const walk = (at, path) => {
-    const seq = sequences.get(at);
-    if (!seq) return null;
-    for (const child of videoSequenceChildren(seq)) {
-      if (child === id) return [...path, child];
-      if (path.includes(child)) continue;
-      const found = walk(child, [...path, child]);
-      if (found) return found;
-    }
-    return null;
-  };
-  return walk(id, [id]);
-}
-function allVideoTracks(project) {
-  return [...project.tracks.map((track) => ({ track })), ...(project.sequences ?? []).flatMap((q) => q.tracks.map((track) => ({ sequence: q.id, track })))];
-}
-function sortedVideoClips(track) {
-  return [...track.clips].sort((a, b) => a.start - b.start || a.duration - b.duration);
-}
-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 allVideoTracks(project).flatMap(({ track }) => track.clips.map((c) => c.id));
-}
-function findVideoSequenceClip(project, id) {
-  for (const sequence of project.sequences ?? [])
-    for (const track of sequence.tracks) {
-      const clip = track.clips.find((c) => c.id === id);
-      if (clip) return { sequence, track, clip };
-    }
-  return null;
-}
-function videoProjectDuration(project) {
-  let end = 0;
-  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, sequences) {
-  if (clip.type === "sequence") {
-    const seq = sequences?.get(clip.sequence);
-    const range2 = videoClipSourceRange(clip);
-    return { before: range2.in, after: seq ? Math.max(0, videoSequenceDuration(seq) - range2.out) : Infinity };
-  }
-  if (clip.type !== "media") return { before: Infinity, after: Infinity };
-  const asset = assets.get(clip.asset);
-  const speed = videoClipSpeed(clip);
-  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/clip-animation.ts
-var VIDEO_CLIP_ANIMATION_DURATION = 500;
-var EFFECTS = {
-  fade: { easeIn: "linear", easeOut: "linear" },
-  rise: { y: 0.06, easeIn: "ease-out", easeOut: "ease-in" },
-  drop: { y: -0.06, easeIn: "ease-out", easeOut: "ease-in" },
-  "slide-left": { x: 0.15, easeIn: "ease-out", easeOut: "ease-in" },
-  "slide-right": { x: -0.15, easeIn: "ease-out", easeOut: "ease-in" },
-  zoom: { scale: 0.6, easeIn: "ease-out", easeOut: "ease-in" },
-  // Overshoots past full size, then settles (a "back" curve).
-  pop: { scale: 0.3, easeIn: [0.34, 1.56, 0.64, 1], easeOut: [0.36, 0, 0.66, -0.56] }
-};
-var PROPS = ["opacity", "x", "y", "scale"];
-function videoClipAnimationProperties(animation) {
-  const spec = EFFECTS[animation.effect];
-  return PROPS.filter((p) => p === "opacity" || spec[p] !== void 0);
-}
-function videoClipAnimationSpans(clip) {
-  const a = clip.animateIn ? clip.animateIn.duration ?? VIDEO_CLIP_ANIMATION_DURATION : 0;
-  const b = clip.animateOut ? clip.animateOut.duration ?? VIDEO_CLIP_ANIMATION_DURATION : 0;
-  const k = a + b > clip.duration ? clip.duration / (a + b) : 1;
-  return { in: a * k, out: b * k };
-}
-function videoClipAnimated(clip, project) {
-  if (!clip.animateIn && !clip.animateOut) return clip;
-  const spans = videoClipAnimationSpans(clip);
-  const out = { ...clip, transform: { ...clip.transform } };
-  for (const prop of PROPS) {
-    const current = prop === "opacity" ? clip.opacity : clip.transform?.[prop];
-    if (isVideoKeyframes(current)) continue;
-    const base = current ?? (prop === "opacity" || prop === "scale" ? 1 : 0);
-    const away = (spec) => {
-      if (prop === "opacity") return 0;
-      const v = spec[prop];
-      if (v === void 0) return void 0;
-      return prop === "scale" ? base * v : base + v * (prop === "x" ? project.width : project.height);
-    };
-    const keys = [];
-    if (clip.animateIn) {
-      const spec = EFFECTS[clip.animateIn.effect];
-      const from = away(spec);
-      if (from !== void 0) keys.push({ t: 0, v: from, ease: spec.easeIn }, { t: spans.in, v: base });
-    }
-    if (clip.animateOut) {
-      const spec = EFFECTS[clip.animateOut.effect];
-      const to = away(spec);
-      if (to !== void 0) {
-        const start = clip.duration - spans.out;
-        if (!keys.length || keys[keys.length - 1].t < start) keys.push({ t: start, v: base, ease: spec.easeOut });
-        else keys[keys.length - 1] = { ...keys[keys.length - 1], ease: spec.easeOut };
-        keys.push({ t: clip.duration, v: to });
-      }
-    }
-    if (!keys.length) continue;
-    if (prop === "opacity") out.opacity = { keys };
-    else out.transform[prop] = { keys };
-  }
-  return out;
-}
-
 // src/video-editor/check.ts
 function videoClipKeyframes(clip) {
   const out = [
@@ -1455,7 +623,7 @@ var refuse = (message) => {
 };
 function freshId(prefix, taken) {
   const used = new Set(taken);
-  for (let n2 = 1; ; n2++) if (!used.has(`${prefix}${n2}`)) return `${prefix}${n2}`;
+  for (let n = 1; ; n++) if (!used.has(`${prefix}${n}`)) return `${prefix}${n}`;
 }
 var slug = (s) => s.replace(/^.*[\\/]/, "").replace(/\.[a-z0-9]+(\?.*)?$/i, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
 function mergeSpans(spans) {
@@ -1736,8 +904,8 @@ var Editor = class {
         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 n = this.p.tracks.filter((t) => t.kind === e.track.kind).length + 1;
+        const track = { name: `${e.track.kind === "video" ? "Video" : "Audio"} ${n}`, ...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);
@@ -2188,169 +1356,11 @@ function applyVideoEdits(project, edits) {
   return { ok: true, project: next, issues, outcomes: editor.outcomes };
 }
 
-// src/video-editor/evaluate.ts
-function videoTransformAt(transform, clipTime = 0) {
-  return { x: videoValueAt(transform?.x, clipTime, 0), y: videoValueAt(transform?.y, clipTime, 0), scale: videoValueAt(transform?.scale, clipTime, 1), rotation: videoValueAt(transform?.rotation, clipTime, 0) };
-}
-function placeVideoRect(frame, size, fit = "contain", transform = {}, clipTime = 0) {
-  let w = size.width;
-  let h = size.height;
-  if (fit === "fill") {
-    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 t = videoTransformAt(transform, clipTime);
-  w *= t.scale;
-  h *= t.scale;
-  const cx = frame.width / 2 + t.x;
-  const cy = frame.height / 2 + t.y;
-  return { x: cx - w / 2, y: cy - h / 2, width: w, height: h };
-}
-function videoTextStyle(clip) {
-  return { text: clip.text, color: clip.color ?? "#ffffff", fontSize: clip.fontSize ?? 64, fontFamily: clip.fontFamily ?? "sans-serif", fontWeight: clip.fontWeight ?? 700, ...clip.background ? { background: clip.background } : {} };
-}
-function videoTitleFrame(project, clip, clipTime = 0) {
-  const layer = { clip: clip.id, track: "", type: "text", opacity: 1, rect: placeVideoRect(project, project, "fill", clip.transform, clipTime), rotation: videoTransformAt(clip.transform, clipTime).rotation, text: videoTextStyle(clip) };
-  return { time: clip.start, width: project.width, height: project.height, background: "rgba(0,0,0,0)", layers: [layer], audio: [] };
-}
-var clamp012 = (v) => Math.min(1, Math.max(0, v));
-var videoTransitionEase = (progress) => (1 - Math.cos(Math.PI * clamp012(progress))) / 2;
-function videoFadeCurveGain(curve, x) {
-  const t = clamp012(x);
-  switch (curve) {
-    case "equal-power":
-      return Math.sin(t * Math.PI / 2);
-    case "s-curve":
-      return (1 - Math.cos(t * Math.PI)) / 2;
-    case "exponential":
-      return t * t * t;
-    case "logarithmic":
-      return 1 - (1 - t) * (1 - t);
-    default:
-      return t;
-  }
-}
-function fadeGain(clip, time, sound = false) {
-  let g = 1;
-  const shape = sound && (clip.type === "media" || clip.type === "sequence") ? clip : void 0;
-  if (clip.fadeIn) g *= videoFadeCurveGain(shape?.fadeInCurve, (time - clip.start) / clip.fadeIn);
-  if (clip.fadeOut) g *= videoFadeCurveGain(shape?.fadeOutCurve, (videoClipEnd(clip) - time) / clip.fadeOut);
-  return g;
-}
-function videoClipSoundGain(clip, clipTime) {
-  const volume = clip.type === "media" || clip.type === "sequence" ? videoValueAt(clip.volume, clipTime, 1) : 1;
-  return volume * fadeGain(clip, clip.start + Math.min(Math.max(clipTime, 0), clip.duration), true);
-}
-function activeOnTrack(track, time) {
-  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: clamp012((time - (clip.start - lead)) / (2 * lead)), type: clip.transition.type, transition: clip.transition };
-    if (tail && time >= videoClipEnd(clip) - tail) a.outgoing = { progress: clamp012((time - (videoClipEnd(clip) - tail)) / (2 * tail)), type: next.transition.type, next };
-    out.push(a);
-  }
-  return out;
-}
-var sourceTimeAt = (clip, time) => clip.type === "media" ? videoClipSourceTime(clip, time - clip.start) : 0;
-function videoFrameAt(project, time) {
-  const { layers, audio } = tracksAt(project, project.tracks, time, { assets: videoAssetMap(project), sequences: videoSequenceMap(project), within: [], prefix: "" });
-  return { time, width: project.width, height: project.height, background: project.background ?? "#000000", layers, audio };
-}
-function tracksAt(project, tracks, time, scope) {
-  const { assets, prefix } = scope;
-  const layers = [];
-  const audio = [];
-  for (let ti = tracks.length - 1; ti >= 0; ti--) {
-    const track = tracks[ti];
-    for (const { clip, incoming, outgoing } of activeOnTrack(track, time)) {
-      if (incoming?.type === "dip" && incoming.progress < 0.5) continue;
-      if (outgoing?.type === "dip" && outgoing.progress >= 0.5) continue;
-      const inside = Math.min(Math.max(time, clip.start), videoClipEnd(clip));
-      const fade = fadeGain(clip, inside);
-      const level = (t, transition, into) => videoFadeCurveGain(videoTransitionAudioCurve(transition), t.type === "dip" ? Math.abs(1 - 2 * t.progress) : into ? t.progress : 1 - t.progress);
-      const mix = (incoming ? level(incoming, incoming.transition, true) : 1) * (outgoing ? level(outgoing, outgoing.next.transition, false) : 1);
-      const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
-      const sourceTime = clip.type === "sequence" ? (clip.in ?? 0) + time - clip.start : sourceTimeAt(clip, time);
-      const clipTime = time - clip.start;
-      let nested = null;
-      if (clip.type === "sequence") {
-        const seq = scope.sequences.get(clip.sequence);
-        if (!seq || scope.within.includes(seq.id)) continue;
-        nested = tracksAt(project, seq.tracks, sourceTime, { ...scope, within: [...scope.within, seq.id], prefix: `${prefix}${clip.id}/` });
-      }
-      const audible = videoAssetHasSound(asset);
-      if (audible && clip.type === "media" && !clip.muted && !track.muted) {
-        const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fadeGain(clip, inside, true) * mix;
-        audio.push({ clip: prefix + clip.id, track: track.id, asset: asset.id, src: asset.src, sourceTime, gain, speed: videoClipSpeedAt(clip, clipTime) });
-      }
-      if (nested && clip.type === "sequence" && !clip.muted && !track.muted) {
-        const gain = videoValueAt(clip.volume, clipTime, 1) * (track.volume ?? 1) * fadeGain(clip, inside, true) * mix;
-        for (const a of nested.audio) audio.push({ ...a, gain: a.gain * gain });
-      }
-      if (track.kind !== "video" || track.hidden) continue;
-      if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
-      if (nested && !nested.layers.length) continue;
-      const shown = videoClipAnimated(clip, project);
-      let opacity = videoValueAt(shown.opacity, clipTime, 1) * fade;
-      let wipe;
-      let dip = null;
-      let iris;
-      let shift = 0;
-      let shiftDirection = "right";
-      if (incoming) {
-        if (incoming.type === "crossfade") opacity *= incoming.progress;
-        else if (incoming.type === "wipe") wipe = { direction: incoming.transition.direction ?? "right", progress: incoming.progress };
-        else if (incoming.type === "iris") iris = { progress: incoming.progress };
-        else if (incoming.type === "push" || incoming.type === "slide") {
-          shiftDirection = incoming.transition.direction ?? "right";
-          shift = videoTransitionEase(incoming.progress) - 1;
-        } 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 };
-      if (outgoing?.type === "push") {
-        shiftDirection = outgoing.next.transition.direction ?? "right";
-        shift = videoTransitionEase(outgoing.progress);
-      }
-      const size = clip.type === "media" ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
-      const fit = clip.fit ?? (clip.type === "media" || clip.type === "sequence" ? "contain" : "fill");
-      const placed = placeVideoRect(project, size, clip.type === "text" ? "fill" : fit, shown.transform, clipTime);
-      const across = shiftDirection === "left" || shiftDirection === "right";
-      const sign = shiftDirection === "left" || shiftDirection === "up" ? -1 : 1;
-      const rect = shift ? { ...placed, ...across ? { x: placed.x + sign * shift * project.width } : { y: placed.y + sign * shift * project.height } } : placed;
-      const layer = { clip: prefix + clip.id, track: track.id, type: clip.type, opacity: clamp012(opacity), rect, rotation: videoValueAt(shown.transform?.rotation, clipTime, 0) };
-      if (wipe) layer.wipe = wipe;
-      if (iris) layer.iris = iris;
-      if (clip.blend && clip.blend !== "normal") layer.blend = clip.blend;
-      const grade = normalizeVideoGrade(clip.grade);
-      if (grade) layer.grade = grade;
-      if (clip.type === "media") Object.assign(layer, { asset: asset.id, assetKind: asset.kind, src: asset.src, sourceTime });
-      if (clip.type === "sequence") Object.assign(layer, { sequence: clip.sequence, sourceTime, layers: nested.layers });
-      if (clip.type === "text") layer.text = videoTextStyle(clip);
-      if (clip.type === "color") layer.color = clip.color;
-      if (layer.opacity > 0) layers.push(layer);
-      if (dip && dip.opacity > 0) layers.push({ clip: `transition:${prefix}${incoming ? clip.id : outgoing.next.id}`, track: track.id, type: "color", color: dip.color, opacity: clamp012(dip.opacity), rect: { x: 0, y: 0, width: project.width, height: project.height }, rotation: 0 });
-    }
-  }
-  return { layers, audio };
-}
-function videoFrameLeafLayers(layers) {
-  return layers.flatMap((l) => l.layers ? videoFrameLeafLayers(l.layers) : [l]);
-}
-
 // src/video-editor/audio.ts
 var VIDEO_PEAK_BLOCK = 32;
 function buildVideoAudioPeaks(channels, sampleRate, blockSize = VIDEO_PEAK_BLOCK) {
   if (!(sampleRate > 0)) throw new Error("The sample rate must be above 0.");
-  const length = channels.reduce((n2, c) => Math.max(n2, c.length), 0);
+  const length = channels.reduce((n, c) => Math.max(n, c.length), 0);
   const blocks = Math.max(1, Math.ceil(length / blockSize));
   const level0 = new Float32Array(blocks * 2);
   for (let b = 0; b < blocks; b++) {
@@ -2371,12 +1381,12 @@ function buildVideoAudioPeaks(channels, sampleRate, blockSize = VIDEO_PEAK_BLOCK
   const levels = [level0];
   while (levels[levels.length - 1].length > 2) {
     const below = levels[levels.length - 1];
-    const n2 = below.length / 2;
-    const up = new Float32Array(Math.ceil(n2 / 4) * 2);
+    const n = below.length / 2;
+    const up = new Float32Array(Math.ceil(n / 4) * 2);
     for (let j = 0; j < up.length / 2; j++) {
       let lo = Infinity;
       let hi = -Infinity;
-      for (let i = 4 * j; i < Math.min(n2, 4 * j + 4); i++) {
+      for (let i = 4 * j; i < Math.min(n, 4 * j + 4); i++) {
         lo = Math.min(lo, below[2 * i]);
         hi = Math.max(hi, below[2 * i + 1]);
       }
@@ -2417,10 +1427,10 @@ function videoAudioPeakRange(peaks, from, to) {
   return min === Infinity ? { min: 0, max: 0 } : { min, max };
 }
 function videoAudioPeakSpans(peaks, from, to, columns) {
-  const n2 = Math.max(0, Math.floor(columns));
-  const out = new Float32Array(n2 * 2);
-  const step = (to - from) / Math.max(1, n2);
-  for (let c = 0; c < n2; c++) {
+  const n = Math.max(0, Math.floor(columns));
+  const out = new Float32Array(n * 2);
+  const step = (to - from) / Math.max(1, n);
+  for (let c = 0; c < n; c++) {
     const { min, max } = videoAudioPeakRange(peaks, from + c * step, from + (c + 1) * step);
     out[2 * c] = min;
     out[2 * c + 1] = max;
@@ -2428,12 +1438,12 @@ function videoAudioPeakSpans(peaks, from, to, columns) {
   return out;
 }
 function videoClipWaveform(clip, peaks, columns) {
-  const n2 = Math.max(0, Math.floor(columns));
-  const out = new Float32Array(n2 * 2);
+  const n = Math.max(0, Math.floor(columns));
+  const out = new Float32Array(n * 2);
   const speed = clip.speed ?? 1;
   const start = clip.in ?? 0;
-  const step = clip.duration / Math.max(1, n2);
-  for (let c = 0; c < n2; c++) {
+  const step = clip.duration / Math.max(1, n);
+  for (let c = 0; c < n; c++) {
     const { min, max } = videoAudioPeakRange(peaks, start + c * step * speed, start + (c + 1) * step * speed);
     const gain = videoClipSoundGain(clip, (c + 0.5) * step);
     out[2 * c] = min * gain;
@@ -2442,16 +1452,16 @@ function videoClipWaveform(clip, peaks, columns) {
   return out;
 }
 function videoWaveformPath(spans, width, height) {
-  const n2 = spans.length / 2;
-  if (!n2 || width <= 0 || height <= 0) return "";
+  const n = spans.length / 2;
+  if (!n || width <= 0 || height <= 0) return "";
   const mid = height / 2;
   const y = (v) => (mid - Math.max(-1, Math.min(1, v)) * mid).toFixed(1);
-  const x = (i) => ((i + 0.5) * (width / n2)).toFixed(1);
+  const x = (i) => ((i + 0.5) * (width / n)).toFixed(1);
   const floor = 0.5 / mid;
   const top = [];
   const bottom = [];
-  for (let i = 0; i < n2; i++) top.push(`${i ? "L" : "M"}${x(i)} ${y(Math.max(spans[2 * i + 1], floor))}`);
-  for (let i = n2 - 1; i >= 0; i--) bottom.push(`L${x(i)} ${y(Math.min(spans[2 * i], -floor))}`);
+  for (let i = 0; i < n; i++) top.push(`${i ? "L" : "M"}${x(i)} ${y(Math.max(spans[2 * i + 1], floor))}`);
+  for (let i = n - 1; i >= 0; i--) bottom.push(`L${x(i)} ${y(Math.min(spans[2 * i], -floor))}`);
   return `${top.join("")}${bottom.join("")}Z`;
 }
 function videoClipWaveformPath(clip, peaks, width, height) {
@@ -2708,7 +1718,7 @@ function summarizeVideoScopes(pixels, options = {}) {
   const w = videoLumaWaveform(pixels, { ...options, columns, levels: 256 });
   const waveform = Array.from({ length: w.columns }, (_, c) => {
     const counts = w.data.subarray(c * 256, c * 256 + 256);
-    const n2 = counts.reduce((a, b) => a + b, 0);
+    const n = counts.reduce((a, b) => a + b, 0);
     let lo = 0;
     while (lo < 255 && !counts[lo]) lo++;
     let hi = 255;
@@ -2717,7 +1727,7 @@ function summarizeVideoScopes(pixels, options = {}) {
     let median = 0;
     for (let i = 0; i < 256; i++) {
       seen += counts[i];
-      if (seen >= n2 / 2 && n2) {
+      if (seen >= n / 2 && n) {
         median = i;
         break;
       }
@@ -3027,7 +2037,7 @@ function videoTimelineTranscript(project, options = {}) {
   return out;
 }
 var normalizeVideoWord = (word) => word.toLowerCase().replace(/^[^\p{L}\p{N}']+|[^\p{L}\p{N}']+$/gu, "");
-var rangeOf = (words, i, n2) => ({ from: words[i].start, to: words[i + n2 - 1].end, text: words.slice(i, i + n2).map((w) => w.word).join(" ") });
+var rangeOf = (words, i, n) => ({ from: words[i].start, to: words[i + n - 1].end, text: words.slice(i, i + n).map((w) => w.word).join(" ") });
 function findVideoTranscriptText(words, query) {
   const q = query.split(/\s+/).map(normalizeVideoWord).filter(Boolean);
   if (!q.length) throw new Error("Search for at least one word.");
@@ -3101,679 +2111,6 @@ function videoWordAt(words, time) {
   return -1;
 }
 
-// src/video-editor/render.ts
-var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var n = (v) => String(Math.round(v * 100) / 100);
-var n4 = (v) => String(Math.round(v * 1e4) / 1e4);
-var videoIrisRadius = (frame, progress) => progress * Math.hypot(frame.width / 2, frame.height / 2);
-function videoWipeRect(rect, wipe) {
-  const { direction, progress } = wipe;
-  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 posters = new Map(assets.map((a) => [a.id, a.poster]));
-  const draw = (layers, prefix) => layers.map((layer, index) => {
-    const i = `${prefix}${index}`;
-    const { rect } = layer;
-    const attrs = [];
-    const style = [];
-    if (layer.opacity < 1) attrs.push(`opacity="${n(layer.opacity)}"`);
-    if (layer.blend) style.push(`mix-blend-mode:${layer.blend === "add" ? "plus-lighter" : layer.blend}`);
-    if (layer.layers) style.push("isolation:isolate");
-    if (style.length) attrs.push(`style="${style.join(";")}"`);
-    if (layer.grade) {
-      defs.push(videoGradeSvgFilter(`g${i}`, layer.grade, layer.grade.lut ? options.lutFor?.(layer.grade.lut.src) : null));
-      attrs.push(`filter="url(#g${i})"`);
-    }
-    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.layers) {
-      inner = `<g transform="translate(${n(rect.x)} ${n(rect.y)}) scale(${n4(rect.width / frame.width)} ${n4(rect.height / frame.height)})">${draw(layer.layers, `${i}-`)}</g>`;
-    } else if (layer.type === "color") inner = `<rect ${box} fill="${esc(layer.color ?? "#000000")}"/>`;
-    else if (layer.type === "text" && layer.text) {
-      const t = layer.text;
-      const lines = t.text.split("\n");
-      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>`;
-      }
-    }
-    let item = attrs.length ? `<g ${attrs.join(" ")}>${inner}</g>` : inner;
-    if (layer.iris) {
-      defs.push(`<clipPath id="i${i}"><circle cx="${n(frame.width / 2)}" cy="${n(frame.height / 2)}" r="${n(videoIrisRadius(frame, layer.iris.progress))}"/></clipPath>`);
-      item = `<g clip-path="url(#i${i})">${item}</g>`;
-    }
-    return item;
-  }).join("");
-  const body = draw(frame.layers, "");
-  return `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${n(frame.width)} ${n(frame.height)}" width="${n(frame.width)}" height="${n(frame.height)}">${defs.length ? `<defs>${defs.join("")}</defs>` : ""}<rect width="100%" height="100%" fill="${esc(frame.background)}"/>${body}</svg>`;
-}
-function videoProjectSvg(project, time, options = {}) {
-  return videoFrameToSvg(videoFrameAt(project, time), { fps: project.fps, ...options }, project.assets);
-}
-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 paintVideoLayer(ctx, frame, layer, sourceFor, options) {
-  const { rect } = layer;
-  if (layer.iris) {
-    ctx.beginPath();
-    ctx.arc(frame.width / 2, frame.height / 2, videoIrisRadius(frame, layer.iris.progress), 0, 2 * Math.PI);
-    ctx.clip();
-  }
-  if (layer.grade) {
-    const defs = videoGradeSvgDefs(layer.grade);
-    if (options.defineSvgFilter) for (const d of defs) options.defineSvgFilter(d.id, d.markup);
-    const css = videoGradeCssFilter(layer.grade);
-    ctx.filter = options.defineSvgFilter ? css || "none" : css.replace(/\s*url\([^)]*\)/g, "").trim() || "none";
-  }
-  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);
-    }
-  }
-}
-function drawVideoFrame(ctx, frame, sourceFor, scale = 1, options = {}) {
-  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);
-  drawVideoLayers(ctx, frame, frame.layers, sourceFor, scale, options, 0);
-  ctx.restore();
-}
-function drawVideoLayers(ctx, frame, layers, sourceFor, scale, options, depth) {
-  const cw = Math.max(1, Math.round(frame.width * scale));
-  const ch = Math.max(1, Math.round(frame.height * scale));
-  for (const layer of layers) {
-    let source = sourceFor;
-    if (layer.layers) {
-      const group = options.scratch?.(cw, ch, 2 * depth);
-      if (!group) {
-        drawVideoLayers(ctx, frame, layer.layers, sourceFor, scale, options, depth + 1);
-        continue;
-      }
-      const g = group.ctx;
-      g.save();
-      g.setTransform(1, 0, 0, 1, 0, 0);
-      g.clearRect(0, 0, cw, ch);
-      g.setTransform(scale, 0, 0, scale, 0, 0);
-      g.globalAlpha = 1;
-      g.globalCompositeOperation = "source-over";
-      drawVideoLayers(g, frame, layer.layers, sourceFor, scale, options, depth + 1);
-      g.restore();
-      source = (l) => l === layer ? group.canvas : sourceFor(l);
-    }
-    const setting = layer.grade?.lut;
-    const lut = setting ? options.lutFor?.(setting.src) : null;
-    const scratch = lut ? options.scratch?.(cw, ch, 2 * depth + 1) : null;
-    ctx.save();
-    ctx.setTransform(scale, 0, 0, scale, 0, 0);
-    if (lut && scratch) {
-      const s = scratch.ctx;
-      s.save();
-      s.setTransform(1, 0, 0, 1, 0, 0);
-      s.clearRect(0, 0, cw, ch);
-      s.setTransform(scale, 0, 0, scale, 0, 0);
-      s.globalAlpha = 1;
-      s.globalCompositeOperation = "source-over";
-      paintVideoLayer(s, frame, layer, source, options);
-      s.restore();
-      const img = s.getImageData(0, 0, cw, ch);
-      applyVideoLutToPixels(lut, img.data, setting.strength ?? 1);
-      s.putImageData(img, 0, 0);
-      ctx.setTransform(1, 0, 0, 1, 0, 0);
-      ctx.globalAlpha = layer.opacity;
-      if (layer.blend && layer.blend !== "normal") ctx.globalCompositeOperation = layer.blend === "add" ? "lighter" : layer.blend;
-      ctx.drawImage(scratch.canvas, 0, 0, cw, ch);
-    } else {
-      ctx.globalAlpha = layer.opacity;
-      if (layer.blend && layer.blend !== "normal") ctx.globalCompositeOperation = layer.blend === "add" ? "lighter" : layer.blend;
-      paintVideoLayer(ctx, frame, layer, source, options);
-    }
-    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 dropFrame = (options.dropFrame ?? true) && isVideoDropFrameRate(fps);
-  const tc = (ms) => formatVideoTimecode(ms, fps, dropFrame);
-  const rec0 = options.recordStart !== void 0 ? videoTimecodeFrames(options.recordStart, fps) : videoHourFrames(fps, dropFrame);
-  const rtc = (ms) => formatVideoTimecodeFrames(rec0 + videoTimecodeFrames(ms, fps), fps, dropFrame);
-  const assets = videoAssetMap(project);
-  const channel = track.kind === "video" ? "V" : "A";
-  const lines = [`TITLE: ${(options.title ?? project.name ?? "Untitled").toUpperCase()}`, `FCM: ${dropFrame ? "DROP FRAME" : "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)} ${rtc(recIn)} ${rtc(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 === "crossfade" || t.type === "dip" ? "D" : "W001"}    ${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}`);
-    if (clip.type === "sequence") lines.push(`* COMPOUND CLIP: ${clip.name ?? clip.sequence} (sequence ${clip.sequence} from ${tc(clip.in ?? 0)}, not flattened)`);
-    lines.push("");
-  }
-  return lines.join("\n");
-}
-function loudnormFilter(target = {}, measure = false) {
-  const I = target.integrated ?? -14;
-  const TP = target.truePeak ?? -1;
-  const LRA = target.range ?? 11;
-  if (!(I >= -70 && I <= -5)) throw new Error(`The loudness target must be between -70 and -5 LUFS (got ${I}); -14 suits streaming, -23 broadcast.`);
-  if (!(TP >= -9 && TP <= 0)) throw new Error(`The true peak ceiling must be between -9 and 0 dBTP (got ${TP}); -1 is usual.`);
-  if (!(LRA >= 1 && LRA <= 50)) throw new Error(`The loudness range must be between 1 and 50 LU (got ${LRA}).`);
-  const parts = [`loudnorm=I=${I}:TP=${TP}:LRA=${LRA}`];
-  const m = target.measured;
-  if (m && !measure) {
-    for (const [k, v] of Object.entries(m)) if (!Number.isFinite(v)) throw new Error(`The measured ${k} is not a number (${v}); measure again, or leave "measured" out for a one-pass normalisation.`);
-    parts.push(`measured_I=${m.integrated}:measured_TP=${m.truePeak}:measured_LRA=${m.range}:measured_thresh=${m.threshold}:offset=${m.offset}:linear=true`);
-  }
-  if (measure) parts.push("print_format=json");
-  return `${parts.join(":")},aresample=48000`;
-}
-function parseVideoLoudnessMeasurement(output) {
-  const blocks = output.match(/\{[^{}]*"input_i"[^{}]*\}/g);
-  if (!blocks) throw new Error("No loudness measurement found: pass the stderr of the command from toVideoLoudnessMeasure.");
-  const json = JSON.parse(blocks[blocks.length - 1]);
-  const n2 = (k) => Number(json[k]);
-  const m = { integrated: n2("input_i"), truePeak: n2("input_tp"), range: n2("input_lra"), threshold: n2("input_thresh"), offset: n2("target_offset") };
-  if (!Number.isFinite(m.integrated)) throw new Error("The mix is silent, so its loudness cannot be normalised.");
-  return m;
-}
-var sec = (ms) => String(Math.round(ms) / 1e3);
-var fmtMs = (v) => String(Math.round(v * 100) / 100);
-var FFMPEG_BLEND = {
-  multiply: "multiply",
-  screen: "screen",
-  overlay: "overlay",
-  darken: "darken",
-  lighten: "lighten",
-  "color-dodge": "dodge",
-  "color-burn": "burn",
-  "hard-light": "hardlight",
-  "soft-light": "softlight",
-  difference: "difference",
-  exclusion: "exclusion",
-  add: "addition"
-};
-var AFADE_CURVES = { linear: "tri", "equal-power": "qsin", "s-curve": "hsin", exponential: "cub", logarithmic: "ipar" };
-var afadeCurve = (curve) => curve && curve !== "linear" ? `:curve=${AFADE_CURVES[curve]}` : "";
-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 videoShellQuote = (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 = {}) {
-  return buildFfmpeg(project, options, false);
-}
-function toVideoLoudnessMeasure(project, options = {}) {
-  return buildFfmpeg(project, { ...options, loudness: { ...options.loudness, measured: void 0 } }, true);
-}
-function buildFfmpeg(project, options, measure) {
-  const notes = [];
-  const assets = videoAssetMap(project);
-  const sequences = videoSequenceMap(project);
-  const D = videoProjectDuration(project);
-  if (D <= 0) throw new Error("The project has no clips, so there is nothing to render.");
-  const W = even(project.width);
-  const H = even(project.height);
-  const fps = project.fps;
-  const inputs = [];
-  const graph = measure ? [] : [`color=c=${color(project.background ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(D)},format=yuva420p[base]`];
-  let usesDrawtext = false;
-  const animated = /* @__PURE__ */ new Set();
-  const ramped = /* @__PURE__ */ new Set();
-  const rampedPicture = (remap, lead, end) => {
-    const pts = videoTimeRemapBreakpoints(remap, 2e3 / fps);
-    const first = pts[0];
-    const last = pts[pts.length - 1];
-    const s = `(T*1000+${fmtMs(first.v)})`;
-    let e = fmtMs(last.t - first.t);
-    for (let i = pts.length - 2; i >= 0; i--) {
-      const a = pts[i];
-      const b = pts[i + 1];
-      if (b.v - a.v < 1e-6) continue;
-      e = `if(lt(${s},${fmtMs(b.v)}),${fmtMs(a.t - first.t)}+(${s}-${fmtMs(a.v)})*${fmtMs((b.t - a.t) / (b.v - a.v))},${e})`;
-    }
-    const before = lead + first.t;
-    const after = Math.max(0, end - last.t);
-    return ["setpts=PTS-STARTPTS", `setpts='(${e})/1000/TB'`, `fps=${fps}`, ...before > 0.5 || after > 0.5 ? [`tpad=start_mode=clone:start_duration=${sec(before)}:stop_mode=clone:stop_duration=${sec(after + 1e3 / fps)}`] : [`tpad=stop_mode=clone:stop_duration=${sec(1e3 / fps)}`], `trim=duration=${sec(lead + end)}`];
-  };
-  const rampedSound = (remap, input2, output, lead, end) => {
-    const pts = videoTimeRemapBreakpoints(remap, Math.max(80, 2e3 / fps));
-    const first = pts[0];
-    const last = pts[pts.length - 1];
-    const n2 = ak;
-    const fmtA = "aformat=sample_fmts=fltp:sample_rates=48000:channel_layouts=stereo";
-    const silence = (ms) => `anullsrc=r=48000:cl=stereo,atrim=duration=${sec(ms)},${fmtA}`;
-    const pieces = [];
-    const out = [];
-    const parts = [];
-    if (lead + first.t > 0.5) parts.push(silence(lead + first.t));
-    const played = [];
-    for (let i = 0; i + 1 < pts.length; i++) {
-      const dt = pts[i + 1].t - pts[i].t;
-      if (dt < 0.5) continue;
-      const speed = (pts[i + 1].v - pts[i].v) / dt;
-      if (speed < 0.1) parts.push(silence(dt));
-      else {
-        played.push({ from: pts[i].v - first.v, to: pts[i + 1].v - first.v, speed });
-        parts.push(`#${played.length - 1}`);
-      }
-    }
-    if (end - last.t > 0.5) parts.push(silence(end - last.t));
-    if (played.length) out.push(`[${input2}]asplit=${played.length}${played.map((_, k2) => `[r${n2}s${k2}]`).join("")}`);
-    parts.forEach((p, k2) => {
-      const label = `[r${n2}p${k2}]`;
-      if (p.startsWith("#")) {
-        const piece = played[Number(p.slice(1))];
-        out.push(`[r${n2}s${p.slice(1)}]atrim=start=${sec(piece.from)}:end=${sec(piece.to)},asetpts=PTS-STARTPTS,${atempo(piece.speed).join(",") || "anull"},${fmtA}${label}`);
-      } else out.push(`${p}${label}`);
-      pieces.push(label);
-    });
-    out.push(`${pieces.join("")}concat=n=${pieces.length}:v=0:a=1${output}`);
-    return out;
-  };
-  const blended = /* @__PURE__ */ new Set();
-  let k = 0;
-  const step = 2e3 / fps;
-  const expr = (prop, clipTime, fallback, what) => {
-    if (isVideoKeyframes(prop)) animated.add(what);
-    return videoKeyframeFfmpegExpr(prop, clipTime, fallback, step);
-  };
-  const input = (clip, asset, lead, tail) => {
-    const speed = videoClipSpeed(clip);
-    const src = options.resolve ? options.resolve(asset) : asset.src;
-    const span = clip.duration + lead + tail;
-    if (asset.kind === "image") inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", src]);
-    else if (clip.timeRemap) {
-      const { from, to } = videoTimeRemapSpan(clip.timeRemap);
-      inputs.push(["-ss", sec((clip.in ?? 0) + from), "-t", sec(to - from + 1e3 / fps), "-i", src]);
-    } else inputs.push(["-ss", sec((clip.in ?? 0) - lead * speed), "-t", sec(span * speed), "-i", src]);
-    return inputs.length - 1;
-  };
-  let ak = 0;
-  let q = 0;
-  const compose = (tracks, base, length, scope) => {
-    let cur2 = base;
-    const sounds = [];
-    for (const track of [...tracks].reverse()) {
-      for (const raw of sortedVideoClips(track)) {
-        const clip = videoClipAnimated(raw, project);
-        const { lead, tail } = videoClipOverhang(track, clip);
-        const t0 = clip.start - lead;
-        const span = clip.duration + lead + tail;
-        const end = videoClipEnd(clip);
-        const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
-        if (clip.type === "media" && !asset) {
-          notes.push(`Clip "${clip.id}" was left out: its asset "${clip.asset}" is missing.`);
-          continue;
-        }
-        const shows = scope.picture && track.kind === "video" && !track.hidden;
-        let compound = null;
-        if (clip.type === "sequence") {
-          const seq = sequences.get(clip.sequence);
-          if (!seq || scope.within.includes(seq.id)) {
-            notes.push(`Compound clip "${clip.id}" was left out: its sequence "${clip.sequence}" ${seq ? "contains itself" : "is missing"}.`);
-            continue;
-          }
-          const from = (clip.in ?? 0) - lead;
-          if (from < -0.5) notes.push(`Compound clip "${clip.id}"'s transition needs ${Math.round(-from)} ms of sequence "${seq.id}" before its start, which is not there; it shows nothing then.`);
-          const length2 = Math.max(videoSequenceDuration(seq), from + span);
-          const hears = scope.sound && !clip.muted && !track.muted;
-          const n2 = q++;
-          const nestedBase = shows ? `nb${n2}` : null;
-          if (nestedBase) graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(length2)},format=yuva420p[${nestedBase}]`);
-          const sub = compose(seq.tracks, nestedBase, length2, { within: [...scope.within, seq.id], picture: shows, sound: hears });
-          compound = { picture: null, sound: null };
-          if (sub.video) {
-            graph.push(`[${sub.video}]trim=start=${sec(Math.max(0, from))}:duration=${sec(span)},setpts=PTS-STARTPTS[sq${n2}]`);
-            compound.picture = `[sq${n2}]`;
-          }
-          if (sub.audio.length) {
-            graph.push(`${sub.audio.join("")}amix=inputs=${sub.audio.length}:normalize=0:duration=longest,apad,atrim=start=${sec(Math.max(0, from))}:end=${sec(from + span)}[sm${n2}]`);
-            compound.sound = `[sm${n2}]`;
-          }
-        }
-        let index;
-        if (shows && asset && asset.kind !== "audio") index = input(clip, asset, lead, tail);
-        const audible = clip.type === "sequence" ? !!compound?.sound : videoAssetHasSound(asset);
-        if (scope.sound && audible && (clip.type === "media" || clip.type === "sequence") && !clip.muted && !track.muted) {
-          const trackGain = track.volume ?? 1;
-          const volume = isVideoKeyframes(clip.volume) ? `volume='${trackGain}*(${expr(clip.volume, `(t*1000${lead ? `-${Math.round(lead)}` : ""})`, 1, "volume")})':eval=frame` : `volume=${(clip.volume ?? 1) * trackGain}`;
-          const ramp = clip.type === "media" ? clip.timeRemap : void 0;
-          const ai = compound ? -1 : index ?? input(clip, asset, lead, tail);
-          let source2 = compound?.sound ?? `[${ai}:a]`;
-          if (ramp) {
-            source2 = `[r${ak}]`;
-            graph.push(...rampedSound(ramp, `${ai}:a`, source2, lead, clip.duration + tail));
-            ramped.add("sound");
-          }
-          const chain2 = [...ramp ? [] : ["asetpts=PTS-STARTPTS", ...atempo(videoClipSpeed(clip))], volume];
-          const before2 = clip.transition ? videoClipBefore(track, clip) : null;
-          const next2 = sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition);
-          const inCurve = clip.transition ? afadeCurve(videoTransitionAudioCurve(clip.transition)) : "";
-          const outCurve = next2 ? afadeCurve(videoTransitionAudioCurve(next2.transition)) : "";
-          if (lead) chain2.push(`afade=t=in:st=0:d=${sec(2 * lead)}${inCurve}`);
-          if (tail) chain2.push(`afade=t=out:st=${sec(span - 2 * tail)}:d=${sec(2 * tail)}${outCurve}`);
-          if (before2 && clip.transition.type === "dip") chain2.push(`afade=t=in:st=0:d=${sec(clip.transition.duration / 2)}${inCurve}`);
-          if (next2?.transition.type === "dip") chain2.push(`afade=t=out:st=${sec(span - next2.transition.duration / 2)}:d=${sec(next2.transition.duration / 2)}${outCurve}`);
-          if (clip.fadeIn) chain2.push(`afade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}${afadeCurve(clip.fadeInCurve)}`);
-          if (clip.fadeOut) chain2.push(`afade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}${afadeCurve(clip.fadeOutCurve)}`);
-          chain2.push(`adelay=${Math.round(t0)}:all=1`);
-          graph.push(`${source2}${chain2.join(",")}[a${ak}]`);
-          sounds.push(`[a${ak++}]`);
-        }
-        if (!shows || compound && !compound.picture) continue;
-        const enable = `enable='between(t,${sec(t0)},${sec(t0 + span)})'`;
-        const next = `v${k++}`;
-        const onTimeline = `(t*1000-${Math.round(clip.start)})`;
-        const onChain = (v) => `(${v}*1000${lead ? `-${Math.round(lead)}` : ""})`;
-        const tf = clip.transform;
-        const moving = VIDEO_TRANSFORM_PROPERTIES.some((p) => isVideoKeyframes(tf?.[p]));
-        if (clip.type === "text" && options.titleImage) {
-          inputs.push(["-loop", "1", "-framerate", String(fps), "-t", sec(span), "-i", options.titleImage(moving ? { ...clip, transform: void 0 } : clip, { width: project.width, height: project.height })]);
-          index = inputs.length - 1;
-        } else if (clip.type === "text") {
-          usesDrawtext = true;
-          if (scope.within.length) notes.push(`Title "${clip.id}" is inside a compound clip and drawn with drawtext, which leaves the sequence's transparent areas transparent, so it shows only over pictures in the sequence; pass titleImage to draw it anywhere.`);
-          const op = isVideoKeyframes(clip.opacity) ? `clip(${expr(clip.opacity, onTimeline, 1, "opacity")},0,1)` : String(clip.opacity ?? 1);
-          const alpha = [op, clip.fadeIn ? `min(1,(t-${sec(clip.start)})/${sec(clip.fadeIn)})` : "", clip.fadeOut ? `min(1,(${sec(end)}-t)/${sec(clip.fadeOut)})` : ""].filter(Boolean).join("*");
-          const coord = (axis) => {
-            const v = tf?.[axis];
-            const base2 = `(${axis === "x" ? "w-text_w" : "h-text_h"})/2`;
-            return isVideoKeyframes(v) ? `${axis}='${base2}+(${expr(v, onTimeline, 0, "position")})'` : `${axis}=${base2}+${v ?? 0}`;
-          };
-          const fontSize = clip.fontSize ?? 64;
-          const opts = [
-            `text=${ffmpegFilterValue(clip.text)}`,
-            options.fontFile ? `fontfile=${ffmpegFilterValue(options.fontFile)}` : `font=${ffmpegFilterValue(clip.fontFamily ?? "sans-serif")}`,
-            isVideoKeyframes(tf?.scale) ? `fontsize='${fontSize}*(${expr(tf.scale, onTimeline, 1, "scale")})'` : `fontsize=${Math.round(fontSize * (tf?.scale ?? 1))}`,
-            `fontcolor=${color(clip.color ?? "#ffffff")}`,
-            coord("x"),
-            coord("y"),
-            `alpha='${alpha}'`,
-            ...clip.background ? ["box=1", `boxcolor=${color(clip.background)}`, `boxborderw=${Math.round((clip.fontSize ?? 64) / 2)}`] : [],
-            `enable='between(t,${sec(clip.start)},${sec(end)})'`
-          ];
-          if (tf?.rotation) notes.push(`Title "${clip.id}" is drawn without its rotation (drawtext cannot rotate).`);
-          if (videoGradeFfmpegFilters(clip.grade).length || normalizeVideoGradeLut(clip.grade?.lut)) notes.push(`Title "${clip.id}" is drawn without its grade (drawtext draws straight onto the picture); pass titleImage to grade titles.`);
-          if (clip.blend && clip.blend !== "normal") notes.push(`Title "${clip.id}" is drawn without its blend mode (drawtext draws straight onto the picture); pass titleImage to blend titles.`);
-          graph.push(`[${cur2}]drawtext=${opts.join(":")}[${next}]`);
-          cur2 = next;
-          continue;
-        }
-        const size = asset ? { width: asset.width ?? project.width, height: asset.height ?? project.height } : { width: project.width, height: project.height };
-        const placed = clip.type === "text" && !moving ? void 0 : tf;
-        const still = Object.fromEntries(Object.entries(placed ?? {}).filter(([, v]) => !isVideoKeyframes(v)));
-        const rect = placeVideoRect(project, size, clip.type === "text" ? "fill" : clip.fit ?? (clip.type === "media" || clip.type === "sequence" ? "contain" : "fill"), still);
-        const chain = [];
-        let source;
-        if (clip.type === "color") source = `color=c=${color(clip.color)}:s=${even(rect.width)}x${even(rect.height)}:r=${fps}:d=${sec(span)}`;
-        else if (compound?.picture) {
-          source = compound.picture;
-          chain.push(`scale=${even(rect.width)}:${even(rect.height)}`);
-        } else {
-          source = `[${index}:v]`;
-          if (clip.type === "media" && clip.timeRemap) chain.push(...rampedPicture(clip.timeRemap, lead, clip.duration + tail), `scale=${even(rect.width)}:${even(rect.height)}`);
-          else chain.push(`setpts=${videoClipSpeed(clip) !== 1 ? `(PTS-STARTPTS)/${videoClipSpeed(clip)}` : "PTS-STARTPTS"}`, `fps=${fps}`, `scale=${even(rect.width)}:${even(rect.height)}`);
-        }
-        const grade = videoGradeFfmpegFilters(clip.grade);
-        if (grade.length) chain.push("format=rgba", ...grade);
-        const lut = normalizeVideoGradeLut(clip.grade?.lut);
-        if (lut) {
-          chain.push("format=gbrap");
-          const path = options.resolveLut ? options.resolveLut(lut.src) : lut.src;
-          if (/^(blob|data|https?):/i.test(path)) notes.push(`ffmpeg's lut3d reads only local files, and clip "${clip.id}"'s LUT is "${path.slice(0, 80)}"; save it and pass resolveLut to give its path.`);
-          const file = ffmpegFilterValue(path);
-          const into2 = `q${next}`;
-          graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[${into2}]`);
-          const lut3d = `lut3d=file=${file}:interp=tetrahedral`;
-          if ((lut.strength ?? 1) >= 1) graph.push(`[${into2}]${lut3d}[r${next}]`);
-          else graph.push(`[${into2}]split[o${next}][p${next}]`, `[p${next}]${lut3d}[s${next}]`, `[s${next}][o${next}]blend=all_mode=normal:all_opacity=${lut.strength}[r${next}]`);
-          source = `[r${next}]`;
-          chain.length = 0;
-        }
-        chain.push("format=yuva420p");
-        if (isVideoKeyframes(clip.opacity)) chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='alpha(X,Y)*clip(${expr(clip.opacity, onChain("T"), 1, "opacity")},0,1)'`);
-        else if (clip.opacity !== void 0 && clip.opacity < 1) chain.push(`colorchannelmixer=aa=${clip.opacity}`);
-        if (clip.fadeIn) chain.push(`fade=t=in:st=${sec(lead)}:d=${sec(clip.fadeIn)}:alpha=1`);
-        if (clip.fadeOut) chain.push(`fade=t=out:st=${sec(lead + clip.duration - clip.fadeOut)}:d=${sec(clip.fadeOut)}:alpha=1`);
-        if (lead && clip.transition.type === "crossfade") chain.push(`fade=t=in:st=0:d=${sec(2 * lead)}:alpha=1`);
-        if (lead && clip.transition.type === "wipe") {
-          const d = sec(2 * lead);
-          const p = `min(1,T/${d})`;
-          const dir = clip.transition.direction ?? "right";
-          const test = dir === "right" ? `lt(X,W*${p})` : dir === "left" ? `gt(X,W*(1-${p}))` : dir === "down" ? `lt(Y,H*${p})` : `gt(Y,H*(1-${p}))`;
-          chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(${test},alpha(X,Y),0)'`);
-        }
-        if (lead && clip.transition.type === "iris") {
-          const r = videoIrisRadius({ width: W, height: H }, 1);
-          chain.push(`geq=lum='lum(X,Y)':cb='cb(X,Y)':cr='cr(X,Y)':a='if(lte(hypot(X+${Math.round(rect.x)}-${W / 2},Y+${Math.round(rect.y)}-${H / 2}),${Math.round(r)}*min(1,T/${sec(2 * lead)})),alpha(X,Y),0)'`);
-        }
-        const rotation = placed?.rotation;
-        if (isVideoKeyframes(rotation)) chain.push(`rotate=a='(${expr(rotation, onChain("t"), 0, "rotation")})*PI/180':c=black@0:ow='hypot(iw,ih)':oh=ow`);
-        else if (rotation) chain.push(`rotate=${rotation}*PI/180:c=black@0:ow=rotw(${rotation}*PI/180):oh=roth(${rotation}*PI/180)`);
-        if (isVideoKeyframes(placed?.scale)) {
-          const s = expr(placed.scale, onChain("t"), 1, "scale");
-          chain.push(`scale=w='max(2,trunc(iw*(${s})/2)*2)':h='max(2,trunc(ih*(${s})/2)*2)':eval=frame`);
-        }
-        chain.push(`setpts=PTS+${sec(t0)}/TB`);
-        const cx = rect.x + rect.width / 2;
-        const cy = rect.y + rect.height / 2;
-        const shifts = { x: [], y: [] };
-        const shiftBy = (direction, from, d, entering) => {
-          const dir = direction ?? "right";
-          const axis = dir === "left" || dir === "right" ? "x" : "y";
-          const size2 = axis === "x" ? W : H;
-          const sign = dir === "left" || dir === "up" ? -1 : 1;
-          const ease = `(1-cos(PI*clip((t-${sec(from)})/${sec(d)},0,1)))/2`;
-          shifts[axis].push(`${sign * size2}*(${ease}${entering ? "-1" : ""})`);
-        };
-        const into = lead ? clip.transition.type : void 0;
-        if (into === "push" || into === "slide") shiftBy(clip.transition.direction, clip.start - lead, 2 * lead, true);
-        const after = tail ? sortedVideoClips(track).find((c) => c !== clip && Math.abs(c.start - end) < 0.5 && c.transition) : void 0;
-        if (after?.transition.type === "push") shiftBy(after.transition.direction, end - tail, 2 * tail, false);
-        const at = (axis, c) => {
-          const v = placed?.[axis];
-          const extra = shifts[axis].map((s) => `+${s}`).join("");
-          return isVideoKeyframes(v) ? `${axis}='${Math.round(axis === "x" ? project.width / 2 : project.height / 2)}+(${expr(v, onTimeline, 0, "position")})-${axis === "x" ? "w" : "h"}/2${extra}'` : `${axis}='${Math.round(c)}-${axis === "x" ? "w" : "h"}/2${extra}'`;
-        };
-        graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[l${next}]`);
-        if (clip.blend && clip.blend !== "normal") {
-          graph.push(`color=c=black@0:s=${W}x${H}:r=${fps}:d=${sec(length)},format=yuva420p[t${next}]`);
-          const clear = scope.within.length > 0;
-          graph.push(`[t${next}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable},format=gbrap,split${clear ? `=3` : ""}[f${next}][g${next}]${clear ? `[h${next}]` : ""}`);
-          graph.push(`[${cur2}]format=gbrap,split${clear ? `=3` : ""}[c${next}][d${next}]${clear ? `[e${next}]` : ""}`);
-          const layerFirst = clip.blend === "color-dodge" || clip.blend === "color-burn";
-          graph.push(`${layerFirst ? `[f${next}][c${next}]` : `[c${next}][f${next}]`}blend=all_mode=${FFMPEG_BLEND[clip.blend]}[b${next}]`);
-          graph.push(`[g${next}]alphaextract[m${next}]`);
-          if (clear) {
-            graph.push(`[e${next}]alphaextract[ea${next}]`);
-            graph.push(`[b${next}][ea${next}]alphamerge[bb${next}]`);
-            graph.push(`[h${next}]format=gbrp[ho${next}]`);
-            graph.push(`[ho${next}][bb${next}]overlay=format=gbrp[bm${next}]`);
-            graph.push(`[bm${next}][m${next}]alphamerge[x${next}]`);
-          } else graph.push(`[b${next}][m${next}]alphamerge[x${next}]`);
-          graph.push(`[d${next}][x${next}]overlay=format=gbrp,format=yuva420p[${next}]`);
-          blended.add(clip.blend);
-        } else graph.push(`[${cur2}][l${next}]overlay=${at("x", cx)}:${at("y", cy)}:eof_action=pass:${enable}[${next}]`);
-        cur2 = next;
-        const before = clip.transition ? videoClipBefore(track, clip) : null;
-        if (before && clip.transition.type === "dip") {
-          const d = clip.transition.duration;
-          const dip = `d${k}`;
-          graph.push(`color=c=${color(clip.transition.color ?? "#000000")}:s=${W}x${H}:r=${fps}:d=${sec(d)},format=yuva420p,fade=t=in:st=0:d=${sec(d / 2)}:alpha=1,fade=t=out:st=${sec(d / 2)}:d=${sec(d / 2)}:alpha=1,setpts=PTS+${sec(clip.start - d / 2)}/TB[l${dip}]`);
-          graph.push(`[${cur2}][l${dip}]overlay=eof_action=pass:enable='between(t,${sec(clip.start - d / 2)},${sec(clip.start + d / 2)})'[${dip}]`);
-          cur2 = dip;
-        }
-      }
-    }
-    return { video: cur2, audio: sounds };
-  };
-  const top = compose(project.tracks, measure ? null : "base", D, { within: [], picture: !measure, sound: true });
-  const audio = top.audio;
-  const cur = top.video;
-  if (!measure) graph.push(`[${cur}]format=yuv420p[vout]`);
-  if (measure && !audio.length) throw new Error("Nothing on the timeline makes a sound, so there is no loudness to measure.");
-  const loudness = options.loudness || measure ? `,${loudnormFilter(options.loudness, measure)}` : "";
-  if (audio.length) graph.push(`${audio.join("")}amix=inputs=${audio.length}:normalize=0:duration=longest,apad,atrim=0:${sec(D)}${loudness}[aout]`);
-  if (options.loudness && !audio.length) notes.push("Nothing makes a sound, so there was no loudness to normalise.");
-  else if (options.loudness && !options.loudness.measured)
-    notes.push("Loudness is normalised in one pass, which adjusts the level as it goes; for a fixed gain that keeps the dynamics, run toVideoLoudnessMeasure first and pass its result as loudness.measured.");
-  if (allVideoTracks(project).some(({ track: t }) => t.clips.some((c) => c.type === "media" && assets.get(c.asset)?.kind === "video" && assets.get(c.asset)?.hasAudio === void 0)))
-    notes.push('Video assets are assumed to have sound; set "hasAudio": false on any that do not, or ffmpeg will stop at a missing audio stream.');
-  if (animated.size)
-    notes.push(`Keyframed ${[...animated].sort().join(", ")} ${animated.size > 1 ? "are" : "is"} rendered as straight lines between keys, with eased segments sampled every two frames${animated.has("scale") ? "; animated scale needs ffmpeg 5 or later (scale with eval=frame)" : ""}.`);
-  if (blended.has("soft-light")) notes.push("ffmpeg's soft-light blend uses a slightly different formula from the browser's, so the render can differ a little from the preview.");
-  if (ramped.has("sound")) notes.push("Sound through a speed ramp plays each stretch at its own speed, so a gliding change is heard in small steps (about every 80 ms), and freezes are silent.");
-  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(";");
-  if (measure) {
-    const args2 = ["-hide_banner", "-nostats", ...inputs.flat(), "-filter_complex", filterComplex, "-map", "[aout]", "-f", "null", "-"];
-    return { args: args2, command: ["ffmpeg", ...args2].map(videoShellQuote).join(" "), filterComplex, duration: D, notes };
-  }
-  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(videoShellQuote).join(" "), filterComplex, duration: D, notes };
-}
-
 // src/video-editor/proxy.ts
 var VIDEO_PROXY_SCALES = [0.5, 0.25];
 function videoAssetProxy(asset, scale) {
@@ -3884,7 +2221,7 @@ function planVideoPrefetch(project, time, options = {}) {
   return out;
 }
 function videoCacheEvictions(entries, options) {
-  let total = entries.reduce((n2, e) => n2 + e.bytes, 0);
+  let total = entries.reduce((n, e) => n + e.bytes, 0);
   if (total <= options.maxBytes) return [];
   const dir = options.direction ?? 1;
   const behind = options.behind ?? 2;
@@ -5038,7 +3375,7 @@ function describeVideoSequence(project, sequence, tracks = true) {
     id: sequence.id,
     ...sequence.name ? { name: sequence.name } : {},
     duration: videoSequenceDuration(sequence),
-    clipCount: sequence.tracks.reduce((n2, t) => n2 + t.clips.length, 0),
+    clipCount: sequence.tracks.reduce((n, t) => n + t.clips.length, 0),
     nests: videoSequenceChildren(sequence),
     usedBy: videoSequenceUsers(project, sequence.id),
     ...cycle ? { cycle } : {},
@@ -5627,7 +3964,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     annotations: { title: "Find filler words", ...READ },
     handler: ({ track, fillers }) => {
       const found = findVideoFillers(timelineWords(track), fillers);
-      return { fillers: found.map(RANGE_OUT), total: round(found.reduce((n2, r) => n2 + r.to - r.from, 0)) };
+      return { fillers: found.map(RANGE_OUT), total: round(found.reduce((n, r) => n + r.to - r.from, 0)) };
     }
   };
   const findPauses = {
@@ -5642,7 +3979,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
     annotations: { title: "Find pauses between words", ...READ },
     handler: ({ track, min, keep }) => {
       const found = findVideoTranscriptPauses(timelineWords(track), { min, keep, fps: project().fps });
-      return { pauses: found.map(RANGE_OUT), total: round(found.reduce((n2, r) => n2 + r.to - r.from, 0)) };
+      return { pauses: found.map(RANGE_OUT), total: round(found.reduce((n, r) => n + r.to - r.from, 0)) };
     }
   };
   const removeRanges = {
@@ -5958,7 +4295,7 @@ function createVideoEditorToolProvider(controller, options = {}) {
       const r = soundRange(args);
       const peaks = await controller.audioPeaks.load(r.asset);
       const silences = findVideoAudioSilences(peaks, r.toSource(r.from), r.toSource(r.to), { thresholdDb: args.thresholdDb, minDuration: args.minDuration }).map((x) => ({ start: round(r.toOut(x.start)), end: round(r.toOut(x.end)) }));
-      return { asset: r.asset.id, from: r.from, to: r.to, silences, total: round(silences.reduce((n2, x) => n2 + x.end - x.start, 0)) };
+      return { asset: r.asset.id, from: r.from, to: r.to, silences, total: round(silences.reduce((n, x) => n + x.end - x.start, 0)) };
     }
   };
   const pixelsAt = async (time) => {