@pixerate/editor 0.160.0 → 0.162.0

package/dist/{chunk-SSCL7QQ4.js → chunk-XDCFJEU7.js}

@@ -7,7 +7,7 @@ import {
   r2,
   sameChartSelection,
   summarizeChartSeries
-} from "./chunk-R3QY7PPL.js";
+} from "./chunk-DTSTNRPH.js";
 import {
   CHART_TYPE_LABELS,
   DEFAULT_CHART_PALETTE,
@@ -27,7 +27,7 @@ import {
   parseChartValue,
   shadeChartColor,
   uniqueChartSeriesId
-} from "./chunk-H5XX4KHB.js";
+} from "./chunk-HLOKB7WW.js";
 import {
   parseCsv,
   parseTsv

package/dist/{chunk-IQ6KKXOU.js → chunk-YN4AYYBJ.js}

@@ -19,9 +19,11 @@ 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_MASK_SHAPES = ["rectangle", "ellipse", "linear", "polygon"];
 var VIDEO_FADE_CURVES = ["linear", "equal-power", "s-curve", "exponential", "logarithmic"];
+var VIDEO_ADJUSTMENT_SCOPES = ["underneath", "all", "track"];
 var VIDEO_PLACEMENT_MODES = ["refuse", "overwrite", "insert"];
-var VIDEO_CLIP_TYPES = ["media", "text", "color", "sequence", "effect"];
+var VIDEO_CLIP_TYPES = ["media", "text", "color", "sequence", "effect", "adjustment"];
 
 // src/video-editor/keyframes.ts
 var VIDEO_EASE_NAMES = ["linear", "hold", "ease-in", "ease-out", "ease-in-out"];
@@ -318,9 +320,25 @@ function applyVideoLut(lut, rgb, out = [0, 0, 0]) {
   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) {
+function videoSkinToneWeight(r, g, b) {
+  const R = r * 255;
+  const G = g * 255;
+  const B = b * 255;
+  const y = 0.299 * R + 0.587 * G + 0.114 * B;
+  if (y < 20 || y > 250) return 0;
+  const cb = 128 - 0.168736 * R - 0.331264 * G + 0.5 * B;
+  const cr = 128 + 0.5 * R - 0.418688 * G - 0.081312 * B;
+  const d = Math.hypot((cb - 108) / 20, (cr - 154) / 18);
+  let w = d <= 1 ? 1 : d >= 1.5 ? 0 : 1 - smooth((d - 1) / 0.5);
+  if (y < 40) w *= (y - 20) / 20;
+  else if (y > 235) w *= (250 - y) / 15;
+  return w;
+}
+var smooth = (t) => t * t * (3 - 2 * t);
+function applyVideoLutToPixels(lut, data, strength = 1, preserveSkinTones = 0) {
   const s = clamp01(strength);
   if (!s) return;
+  const skin = clamp01(preserveSkinTones);
   const rgb = [0, 0, 0];
   const out = [0, 0, 0];
   for (let i = 0; i < data.length; i += 4) {
@@ -329,7 +347,8 @@ function applyVideoLutToPixels(lut, data, strength = 1) {
     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);
+    const k = skin ? s * (1 - skin * videoSkinToneWeight(rgb[0], rgb[1], rgb[2])) : s;
+    for (let c = 0; c < 3; c++) data[i + c] = Math.round((rgb[c] + (out[c] - rgb[c]) * k) * 255);
   }
 }
 var approximations = /* @__PURE__ */ new WeakMap();
@@ -484,7 +503,8 @@ 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 } : {} };
+  const skin = typeof lut.preserveSkinTones === "number" && Number.isFinite(lut.preserveSkinTones) ? Math.round(Math.min(1, Math.max(0, lut.preserveSkinTones)) * 1e3) / 1e3 : 0;
+  return { src: lut.src, ...strength !== 1 ? { strength } : {}, ...lut.name ? { name: lut.name } : {}, ...skin ? { preserveSkinTones: skin } : {} };
 }
 function normalizeVideoGrade(grade) {
   if (!grade) return void 0;
@@ -572,7 +592,7 @@ function applyVideoGrade(grade, rgb, lut) {
   const setting = normalizeVideoGradeLut(grade?.lut);
   if (setting && lut) {
     const out = applyVideoLut(lut, v);
-    const s = setting.strength ?? 1;
+    const s = (setting.strength ?? 1) * (1 - (setting.preserveSkinTones ?? 0) * videoSkinToneWeight(v[0], v[1], v[2]));
     v = v.map((x, k) => x + (out[k] - x) * s);
   }
   return v.map((x) => Math.round(x * 255));
@@ -717,6 +737,7 @@ var videoSlowMotionRamp = (duration) => [
 // src/video-editor/timeline.ts
 var VIDEO_TIME_EPSILON = 0.5;
 var videoClipEnd = (clip) => clip.start + clip.duration;
+var videoClipTypeLabel = (clip) => ({ text: "title", color: "colour", effect: "effect clip", adjustment: "adjustment clip", sequence: "compound clip", media: "media clip" })[clip.type];
 var videoTrackSyncLocked = (track) => track.syncLocked !== false;
 var videoClipSpeed = (clip) => clip.type === "media" ? clip.speed ?? 1 : 1;
 function videoClipSourceRange(clip) {
@@ -966,6 +987,84 @@ function videoClipAnimated(clip, project) {
   return out;
 }
 
+// src/video-editor/mask.ts
+var VIDEO_MASK_DEFAULTS = { x: 0.5, y: 0.5, width: 0.5, height: 0.5, rotation: 0, feather: 0, cornerRadius: 0 };
+var ELLIPSE_SEGMENTS = 64;
+var CORNER_SEGMENTS = 8;
+function normalizeVideoClipMask(mask) {
+  const d = VIDEO_MASK_DEFAULTS;
+  const finite = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+  return {
+    shape: mask.shape,
+    x: finite(mask.x, d.x),
+    y: finite(mask.y, d.y),
+    width: Math.max(0, finite(mask.width, d.width)),
+    height: Math.max(0, finite(mask.height, d.height)),
+    rotation: finite(mask.rotation, d.rotation),
+    feather: Math.max(0, finite(mask.feather, d.feather)),
+    cornerRadius: Math.min(1, Math.max(0, finite(mask.cornerRadius, d.cornerRadius))),
+    inverted: mask.inverted === true,
+    ...mask.points ? { points: mask.points } : {}
+  };
+}
+function videoMaskPolygon(mask, rect) {
+  const m = normalizeVideoClipMask(mask);
+  const cx = rect.x + m.x * rect.width;
+  const cy = rect.y + m.y * rect.height;
+  const a = m.rotation * Math.PI / 180;
+  const cos = Math.cos(a);
+  const sin = Math.sin(a);
+  const turn = (dx, dy) => [cx + dx * cos - dy * sin, cy + dx * sin + dy * cos];
+  if (m.shape === "linear") {
+    const R = 4 * (Math.hypot(rect.width, rect.height) + Math.hypot(cx - rect.x, cy - rect.y)) + 1;
+    return [turn(-R, 0), turn(R, 0), turn(R, -R), turn(-R, -R)];
+  }
+  if (m.shape === "polygon") {
+    return (m.points ?? []).map((p) => turn((p.x - m.x) * rect.width, (p.y - m.y) * rect.height));
+  }
+  const hw = m.width * rect.width / 2;
+  const hh = m.height * rect.height / 2;
+  if (m.shape === "ellipse") {
+    return Array.from({ length: ELLIPSE_SEGMENTS }, (_, i) => {
+      const t = i / ELLIPSE_SEGMENTS * 2 * Math.PI;
+      return turn(hw * Math.cos(t), hh * Math.sin(t));
+    });
+  }
+  const r = m.cornerRadius * Math.min(hw, hh);
+  if (r <= 0) return [turn(-hw, -hh), turn(hw, -hh), turn(hw, hh), turn(-hw, hh)];
+  const corners = [
+    [-hw + r, -hh + r, Math.PI],
+    [hw - r, -hh + r, 1.5 * Math.PI],
+    [hw - r, hh - r, 0],
+    [-hw + r, hh - r, 0.5 * Math.PI]
+  ];
+  const out = [];
+  for (const [x, y, start] of corners)
+    for (let i = 0; i <= CORNER_SEGMENTS; i++) {
+      const t = start + i / CORNER_SEGMENTS * (Math.PI / 2);
+      out.push(turn(x + r * Math.cos(t), y + r * Math.sin(t)));
+    }
+  return out;
+}
+function videoLayerMask(mask, rect) {
+  const m = normalizeVideoClipMask(mask);
+  return { points: videoMaskPolygon(mask, rect), feather: m.feather, inverted: m.inverted };
+}
+function videoMaskSvgPath(mask) {
+  const n2 = (v) => String(Math.round(v * 100) / 100);
+  return mask.points.map(([x, y], i) => `${i ? "L" : "M"}${n2(x)} ${n2(y)}`).join("") + "Z";
+}
+function videoMaskContains(mask, x, y) {
+  let inside = false;
+  const p = mask.points;
+  for (let i = 0, j = p.length - 1; i < p.length; j = i++) {
+    const [xi, yi] = p[i];
+    const [xj, yj] = p[j];
+    if (yi > y !== yj > y && x < (xj - xi) * (y - yi) / (yj - yi) + xi) inside = !inside;
+  }
+  return mask.inverted ? !inside : inside;
+}
+
 // src/video-editor/evaluate.ts
 function videoEffectValuesAt(values, clipTime) {
   const out = {};
@@ -1050,8 +1149,9 @@ function videoFrameAt(project, time) {
 }
 function tracksAt(project, tracks, time, scope) {
   const { assets, prefix } = scope;
-  const layers = [];
+  let layers = [];
   const audio = [];
+  const deferred = [];
   for (let ti = tracks.length - 1; ti >= 0; ti--) {
     const track = tracks[ti];
     for (const { clip, incoming, outgoing } of activeOnTrack(track, time)) {
@@ -1081,6 +1181,7 @@ function tracksAt(project, tracks, time, scope) {
       }
       if (track.kind !== "video" || track.hidden) continue;
       if (clip.type === "media" && (!asset || asset.kind === "audio")) continue;
+      if (clip.type === "adjustment" && !normalizeVideoGrade(clip.grade) && !clip.mask && !(clip.effects ?? []).some((e) => e.enabled !== false)) continue;
       if (nested && !nested.layers.length) continue;
       const shown = videoClipAnimated(clip, project);
       let opacity = videoValueAt(shown.opacity, clipTime, 1) * fade;
@@ -1124,6 +1225,22 @@ function tracksAt(project, tracks, time, scope) {
       if (clip.type === "effect") layer.generator = { effect: clip.effect, ...clip.name ? { name: clip.name } : {}, values: videoEffectValuesAt(clip.values, clipTime), time: Math.max(0, clipTime) };
       const effects = (clip.effects ?? []).filter((e) => e.enabled !== false).map((e) => ({ id: e.id, effect: e.effect, ...e.name ? { name: e.name } : {}, opacity: clamp012(videoValueAt(e.opacity, clipTime, 1)), values: videoEffectValuesAt(e.values, clipTime), time: clipTime })).filter((e) => e.opacity > 0);
       if (effects.length) layer.effects = effects;
+      if (clip.type === "adjustment") {
+        layer.rect = { x: 0, y: 0, width: project.width, height: project.height };
+        layer.rotation = 0;
+        const adjScope = clip.scope ?? "underneath";
+        layer.adjustment = { scope: adjScope, ...clip.targetTrack ? { track: clip.targetTrack } : {} };
+        if (clip.mask) layer.mask = videoLayerMask(clip.mask, layer.rect);
+        const keepBase = layer.opacity < 1 || !!layer.blend || !!layer.mask || !!layer.wipe || !!layer.iris;
+        if (layer.opacity <= 0) continue;
+        if (adjScope === "underneath") {
+          if (!layers.length) continue;
+          layer.layers = keepBase ? [...layers] : layers.splice(0);
+          layers.push(layer);
+        } else deferred.push({ layer, keepBase });
+        continue;
+      }
+      if (clip.mask) layer.mask = videoLayerMask(clip.mask, layer.rect);
       if (effectIn) {
         const before = videoClipBefore(track, clip);
         const i = before ? layers.findIndex((l) => l.clip === prefix + before.id && l.track === track.id) : -1;
@@ -1135,6 +1252,22 @@ function tracksAt(project, tracks, time, scope) {
       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 });
     }
   }
+  for (const { layer, keepBase } of deferred) {
+    if (layer.adjustment.scope === "all") {
+      if (!layers.length) continue;
+      layer.layers = [...layers];
+      layers = keepBase ? [...layers, layer] : [layer];
+      continue;
+    }
+    const target = layer.adjustment.track;
+    const first = layers.findIndex((l) => l.track === target);
+    if (first < 0) continue;
+    let last = first;
+    while (last + 1 < layers.length && layers[last + 1].track === target) last++;
+    const run = layers.slice(first, last + 1);
+    layer.layers = run;
+    layers = [...layers.slice(0, first), ...keepBase ? run : [], layer, ...layers.slice(last + 1)];
+  }
   return { layers, audio };
 }
 function videoLayersWithoutTransitionEffects(layers) {
@@ -1166,7 +1299,7 @@ function videoClipEffectUses(clip) {
 }
 var videoLayersUseEffects = (layers) => layers.some((l) => !!(l.effects?.length || l.generator || l.transitionEffect || l.layers && videoLayersUseEffects(l.layers)));
 var videoEffectFrameTime = (time, fps) => Math.floor(time * fps / 1e3 + 1e-6) * 1e3 / fps;
-var PLACEMENT = /* @__PURE__ */ new Set(["opacity", "rect", "rotation", "blend", "wipe", "iris", "grade", "track"]);
+var PLACEMENT = /* @__PURE__ */ new Set(["opacity", "rect", "rotation", "blend", "wipe", "iris", "grade", "track", "mask"]);
 var round = (_k, v) => typeof v === "number" ? Math.round(v * 100) / 100 : v;
 function videoEffectLayerKey(layer, width, height) {
   const content = layer.transitionEffect ? layer : Object.fromEntries(Object.entries(layer).filter(([k]) => !PLACEMENT.has(k)));
@@ -1459,6 +1592,14 @@ function videoFrameToSvg(frame, options = {}, assets = []) {
         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>`;
       }
     }
+    if (layer.mask) {
+      const m = layer.mask;
+      const blur = m.feather > 0 ? `<filter id="mf${i}" x="-50%" y="-50%" width="200%" height="200%"><feGaussianBlur stdDeviation="${n(m.feather / 2)}"/></filter>` : "";
+      if (blur) defs.push(blur);
+      const shape = `<path d="${videoMaskSvgPath(m)}" fill="${m.inverted ? "black" : "white"}"${blur ? ` filter="url(#mf${i})"` : ""}/>`;
+      defs.push(`<mask id="m${i}" maskUnits="userSpaceOnUse" x="-100000" y="-100000" width="200000" height="200000">${m.inverted ? '<rect x="-100000" y="-100000" width="200000" height="200000" fill="white"/>' : ""}${shape}</mask>`);
+      inner = `<g mask="url(#m${i})">${inner}</g>`;
+    }
     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>`);
@@ -1489,6 +1630,18 @@ function videoContactSheetSvg(project, times, options = {}) {
   });
   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 applyVideoMask(g, mask, scale) {
+  if (!g.moveTo || !g.lineTo || !g.closePath || !g.fill || mask.points.length < 3) return false;
+  g.globalAlpha = 1;
+  g.globalCompositeOperation = mask.inverted ? "destination-out" : "destination-in";
+  g.filter = mask.feather > 0 ? `blur(${Math.max(0.5, mask.feather * scale / 2)}px)` : "none";
+  g.fillStyle = "#000000";
+  g.beginPath();
+  mask.points.forEach(([x, y], i) => i ? g.lineTo(x, y) : g.moveTo(x, y));
+  g.closePath();
+  g.fill();
+  return true;
+}
 function paintVideoLayer(ctx, frame, layer, sourceFor, options) {
   const { rect } = layer;
   if (layer.iris) {
@@ -1696,10 +1849,10 @@ function drawVideoLayers(ctx, frame, layers, sourceFor, scale, options, depth, s
     }
     const setting = layer.grade?.lut;
     const lut = setting ? options.lutFor?.(setting.src) : null;
-    const scratch = lut ? options.scratch?.(cw, ch, 2 * depth + 1) : null;
+    const scratch = lut || layer.mask ? options.scratch?.(cw, ch, 2 * depth + 1) : null;
     ctx.save();
     ctx.setTransform(scale, 0, 0, scale, 0, 0);
-    if (lut && scratch) {
+    if (scratch) {
       const s = scratch.ctx;
       s.save();
       s.setTransform(1, 0, 0, 1, 0, 0);
@@ -1709,9 +1862,23 @@ function drawVideoLayers(ctx, frame, layers, sourceFor, scale, options, depth, s
       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);
+      if (lut) {
+        const img = s.getImageData(0, 0, cw, ch);
+        applyVideoLutToPixels(lut, img.data, setting.strength ?? 1, setting.preserveSkinTones ?? 0);
+        s.putImageData(img, 0, 0);
+      }
+      if (layer.mask) {
+        s.save();
+        s.setTransform(scale, 0, 0, scale, 0, 0);
+        const { rect } = layer;
+        if (layer.rotation) {
+          s.translate(rect.x + rect.width / 2, rect.y + rect.height / 2);
+          s.rotate(layer.rotation * Math.PI / 180);
+          s.translate(-(rect.x + rect.width / 2), -(rect.y + rect.height / 2));
+        }
+        applyVideoMask(s, layer.mask, scale);
+        s.restore();
+      }
       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;
@@ -1778,6 +1945,7 @@ function toVideoEdl(project, options = {}) {
   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)) {
+    if (clip.type === "adjustment") continue;
     const asset = clip.type === "media" ? assets.get(clip.asset) : void 0;
     const reel = clip.type === "media" ? reelName(asset) : "BL";
     const end = videoClipEnd(clip);
@@ -1810,6 +1978,27 @@ function toVideoEdl(project, options = {}) {
 function videoFfmpegUnsupportedEffects(project) {
   return allVideoTracks(project).filter(({ track }) => track.kind === "video" && !track.hidden).flatMap(({ track }) => track.clips.flatMap(videoClipEffectUses)).filter((u) => u.enabled);
 }
+function videoFfmpegUnsupportedFeatures(project) {
+  const out = [];
+  for (const { track } of allVideoTracks(project)) {
+    if (track.kind !== "video" || track.hidden) continue;
+    for (const clip of track.clips) {
+      if (clip.mask) out.push(`clip "${clip.id}" has a mask`);
+      if (clip.type !== "adjustment") continue;
+      const why = [];
+      if ((clip.scope ?? "underneath") === "track") why.push("changes one track only");
+      if (clip.opacity !== void 0 && clip.opacity !== 1) why.push("is not at full opacity");
+      if (clip.fadeIn || clip.fadeOut) why.push("fades");
+      if (clip.blend && clip.blend !== "normal") why.push("blends");
+      if (clip.transition) why.push("has a transition");
+      if (clip.animateIn || clip.animateOut) why.push("is animated");
+      const lut = normalizeVideoGradeLut(clip.grade?.lut);
+      if (lut && (lut.strength ?? 1) < 1) why.push("mixes its LUT at part strength");
+      if (why.length) out.push(`adjustment clip "${clip.id}" ${why.join(", ")}`);
+    }
+  }
+  return out;
+}
 function loudnormFilter(target = {}, measure = false) {
   const I = target.integrated ?? -14;
   const TP = target.truePeak ?? -1;
@@ -1902,6 +2091,13 @@ function buildFfmpeg(project, options, measure) {
       );
     }
   }
+  if (!measure && !frames) {
+    const features = videoFfmpegUnsupportedFeatures(project);
+    if (features.length)
+      throw new Error(
+        `ffmpeg's filters cannot draw ${features.slice(0, 5).join("; ")}${features.length > 5 ? "; ..." : ""}. Render the picture frame by frame with renderVideoFrameExact (the preview's drawing) to PNGs or raw RGBA and pass them as frames: { input: "frames/%06d.png" }; ffmpeg still mixes the sound. Or remove the mask, or keep adjustment clips to a full-opacity grade over what is underneath or the whole frame.`
+      );
+  }
   if (frames) {
     if (frames.format === "rawvideo") inputs.push(["-f", "rawvideo", "-pix_fmt", "rgba", "-s", `${W}x${H}`, "-framerate", String(fps), "-i", frames.input]);
     else inputs.push(["-framerate", String(fps), "-i", frames.input]);
@@ -1981,11 +2177,33 @@ function buildFfmpeg(project, options, measure) {
   };
   let ak = 0;
   let q = 0;
+  const adjust = (cur2, clip) => {
+    const enable = `enable='between(t,${sec(clip.start)},${sec(videoClipEnd(clip))})'`;
+    const steps = videoGradeFfmpegFilters(clip.grade).map((f) => `${f}:${enable}`);
+    const lut = normalizeVideoGradeLut(clip.grade?.lut);
+    if (lut) {
+      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 adjustment clip "${clip.id}"'s LUT is "${path.slice(0, 80)}"; save it and pass resolveLut to give its path.`);
+      steps.push("format=gbrap", `lut3d=file=${ffmpegFilterValue(path)}:interp=tetrahedral:${enable}`);
+      if (lut.preserveSkinTones) notes.push(`Adjustment clip "${clip.id}"'s LUT protects skin tones in the preview, which ffmpeg's lut3d cannot; render frames with renderVideoFrameExact to keep it.`);
+    }
+    if (!steps.length) return cur2;
+    const next = `adj${k++}`;
+    graph.push(`[${cur2}]format=rgba,${steps.join(",")},format=yuva420p[${next}]`);
+    return next;
+  };
   const compose = (tracks, base, length, scope) => {
     let cur2 = base;
     const sounds = [];
+    const adjustAll = [];
     for (const track of [...tracks].reverse()) {
       for (const raw of sortedVideoClips(track)) {
+        if (raw.type === "adjustment") {
+          if (!scope.picture || track.kind !== "video" || track.hidden) continue;
+          if ((raw.scope ?? "underneath") === "all") adjustAll.push(raw);
+          else if (cur2) cur2 = adjust(cur2, raw);
+          continue;
+        }
         const clip = videoClipAnimated(raw, project);
         const { lead, tail } = videoClipOverhang(track, clip);
         const t0 = clip.start - lead;
@@ -2116,6 +2334,7 @@ function buildFfmpeg(project, options, measure) {
           const into2 = `q${next}`;
           graph.push(`${source.startsWith("[") ? source : `${source},`}${chain.join(",")}[${into2}]`);
           const lut3d = `lut3d=file=${file}:interp=tetrahedral`;
+          if (lut.preserveSkinTones) notes.push(`Clip "${clip.id}"'s LUT protects skin tones in the preview, which ffmpeg's lut3d cannot; render frames with renderVideoFrameExact to keep it.`);
           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}]`;
@@ -2196,6 +2415,7 @@ function buildFfmpeg(project, options, measure) {
         }
       }
     }
+    for (const clip of adjustAll) if (cur2) cur2 = adjust(cur2, clip);
     return { video: cur2, audio: sounds };
   };
   const top = compose(project.tracks, measure || frames ? null : "base", D, { within: [], picture: !measure && !frames, sound: true });
@@ -2250,7 +2470,9 @@ export {
   videoTransitionAudioCurve,
   VIDEO_BLEND_MODES,
   VIDEO_CLIP_ANIMATION_EFFECTS,
+  VIDEO_MASK_SHAPES,
   VIDEO_FADE_CURVES,
+  VIDEO_ADJUSTMENT_SCOPES,
   VIDEO_PLACEMENT_MODES,
   VIDEO_CLIP_TYPES,
   VIDEO_EASE_NAMES,
@@ -2274,6 +2496,7 @@ export {
   videoLutFromFunction,
   videoLutToCube,
   applyVideoLut,
+  videoSkinToneWeight,
   applyVideoLutToPixels,
   videoLutSvgApproximation,
   VideoLutCache,
@@ -2305,6 +2528,7 @@ export {
   videoSlowMotionRamp,
   VIDEO_TIME_EPSILON,
   videoClipEnd,
+  videoClipTypeLabel,
   videoTrackSyncLocked,
   videoClipSpeed,
   videoClipSourceRange,
@@ -2343,6 +2567,12 @@ export {
   videoClipAnimationProperties,
   videoClipAnimationSpans,
   videoClipAnimated,
+  VIDEO_MASK_DEFAULTS,
+  normalizeVideoClipMask,
+  videoMaskPolygon,
+  videoLayerMask,
+  videoMaskSvgPath,
+  videoMaskContains,
   videoEffectValuesAt,
   videoTransformAt,
   placeVideoRect,
@@ -2374,6 +2604,7 @@ export {
   renderVideoFrameExact,
   toVideoEdl,
   videoFfmpegUnsupportedEffects,
+  videoFfmpegUnsupportedFeatures,
   parseVideoLoudnessMeasurement,
   ffmpegFilterValue,
   videoShellQuote,