cursedbelt-core 1.0.0

package/src/core/media/ffmpeg.ts

@@ -0,0 +1,162 @@
+// Pure ffmpeg/ffprobe argument builders + output parsers. No Bun.spawn, no I/O — the ONE
+// source of truth for ffmpeg argv construction, shared by the Bun server adapter
+// (`server/media-bun/video.ts` spawns these against native ffmpeg) and the browser editor
+// (`react/media` executes the same argv against ffmpeg.wasm). Unit tested without ffmpeg.
+
+import type { VideoFormat, VideoProgressEvent, VideoQuality, VideoTrimSpec } from './types';
+
+/** Codec + rate-control plan for an output container at a quality preset. */
+export interface VideoCodecPlan {
+  videoCodec: string;
+  audioCodec: string;
+  /** Constant Rate Factor — lower is higher quality (x264 ~18 visually lossless). */
+  crf: number;
+  preset: string;
+  /** Container-specific extra output flags (e.g. faststart for mp4). */
+  extraOutputArgs: string[];
+}
+
+const X264_CRF: Record<VideoQuality, number> = { high: 18, medium: 23, low: 28 };
+const VP9_CRF: Record<VideoQuality, number> = { high: 24, medium: 31, low: 37 };
+
+/**
+ * Resolve the codec plan for a trim. mp4 → H.264/AAC (universal playback) with
+ * `+faststart` so the moov atom is up front (web streaming); webm → VP9/Opus.
+ */
+export function videoCodecPlan(
+  format: VideoFormat = 'mp4',
+  quality: VideoQuality = 'medium',
+): VideoCodecPlan {
+  if (format === 'webm') {
+    return {
+      videoCodec: 'libvpx-vp9',
+      audioCodec: 'libopus',
+      crf: VP9_CRF[quality],
+      preset: 'good',
+      extraOutputArgs: ['-b:v', '0', '-row-mt', '1'],
+    };
+  }
+  return {
+    videoCodec: 'libx264',
+    audioCodec: 'aac',
+    crf: X264_CRF[quality],
+    preset: 'fast',
+    // yuv420p = broad decoder compatibility; faststart = progressive web playback.
+    extraOutputArgs: ['-pix_fmt', 'yuv420p', '-movflags', '+faststart'],
+  };
+}
+
+/**
+ * Build the ffmpeg argv (without the `ffmpeg` binary) for a re-encoding trim.
+ * Uses accurate input seeking (`-ss` before `-i`, accurate when transcoding) plus
+ * `-t duration` so the clip is exactly `end - start` long regardless of keyframes.
+ */
+export function buildTrimArgs(spec: VideoTrimSpec): string[] {
+  const plan = videoCodecPlan(spec.format, spec.quality);
+  const duration = Math.max(0, spec.endSeconds - spec.startSeconds);
+  return [
+    '-hide_banner',
+    '-nostdin',
+    '-y',
+    '-ss',
+    String(spec.startSeconds),
+    '-i',
+    spec.inputPath,
+    '-t',
+    String(duration),
+    '-c:v',
+    plan.videoCodec,
+    '-preset',
+    plan.preset,
+    '-crf',
+    String(plan.crf),
+    '-c:a',
+    plan.audioCodec,
+    ...plan.extraOutputArgs,
+    spec.outputPath,
+  ];
+}
+
+/** ffprobe argv for `probeMedia` — quiet JSON with streams + format. */
+export function buildProbeArgs(inputPath: string): string[] {
+  return ['-v', 'quiet', '-print_format', 'json', '-show_streams', '-show_format', inputPath];
+}
+
+/** ffmpeg argv to grab a single frame at `atSeconds` and write it to `output`. */
+export function buildThumbnailArgs(inputPath: string, atSeconds: number, output: string): string[] {
+  return [
+    '-hide_banner',
+    '-nostdin',
+    '-y',
+    '-ss',
+    String(Math.max(0, atSeconds)),
+    '-i',
+    inputPath,
+    '-frames:v',
+    '1',
+    '-q:v',
+    '3',
+    output,
+  ];
+}
+
+/** Parse an ffmpeg `HH:MM:SS.ss` (or bare seconds) timestamp into seconds. */
+export function ffmpegTimeToSeconds(time: string): number {
+  const t = time.trim();
+  if (t === 'N/A' || t === '') return Number.NaN;
+  const parts = t.split(':');
+  if (parts.length === 1) return Number.parseFloat(parts[0]);
+  let seconds = 0;
+  for (const part of parts) seconds = seconds * 60 + Number.parseFloat(part);
+  return seconds;
+}
+
+const TIME_RE = /time=\s*([0-9:.]+)/;
+
+/**
+ * Parse one line/chunk of ffmpeg stderr into a progress event. ffmpeg emits
+ * `frame=… time=00:00:03.00 …` (carriage-return-updated). Returns an `encode`
+ * event with a clamped percent when `totalSeconds` is known, else just the phase;
+ * `null` when the line carries no timestamp.
+ */
+export function parseFfmpegProgress(
+  line: string,
+  totalSeconds?: number,
+): VideoProgressEvent | null {
+  const m = TIME_RE.exec(line);
+  if (!m) return null;
+  const elapsed = ffmpegTimeToSeconds(m[1]);
+  if (!Number.isFinite(elapsed)) return null;
+  if (totalSeconds && totalSeconds > 0) {
+    const pct = Math.min(100, Math.max(0, (elapsed / totalSeconds) * 100));
+    return { phase: 'encode', progressPercent: Math.round(pct) };
+  }
+  return { phase: 'encode' };
+}
+
+export interface ProbeResult {
+  width: number;
+  height: number;
+  durationSeconds: number;
+  format: string;
+}
+
+/** Shape of the bits of ffprobe JSON we read. */
+interface FfprobeJson {
+  streams?: Array<{ codec_type?: string; width?: number; height?: number; duration?: string }>;
+  format?: { duration?: string; format_name?: string };
+}
+
+/** Extract width/height/duration/format from parsed ffprobe JSON. */
+export function parseFfprobe(json: FfprobeJson): ProbeResult {
+  const streams = json.streams ?? [];
+  const video = streams.find((s) => s.codec_type === 'video');
+  const durationStr = json.format?.duration ?? video?.duration ?? '';
+  const durationSeconds = durationStr ? Number.parseFloat(durationStr) : Number.NaN;
+  return {
+    width: video?.width ?? 0,
+    height: video?.height ?? 0,
+    durationSeconds: Number.isFinite(durationSeconds) ? durationSeconds : 0,
+    format: json.format?.format_name ?? '',
+  };
+}

package/src/core/media/format.spec.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  clampQuality,
+  imageFormatToExtension,
+  imageFormatToMime,
+  mimeToImageFormat,
+  pickThumbnailFormat,
+} from './format';
+
+describe('format helpers', () => {
+  test('mime + extension lookup', () => {
+    expect(imageFormatToMime('jpeg')).toBe('image/jpeg');
+    expect(imageFormatToMime('webp')).toBe('image/webp');
+    expect(imageFormatToExtension('jpeg')).toBe('jpg');
+    expect(imageFormatToExtension('avif')).toBe('avif');
+  });
+
+  test('mimeToImageFormat is forgiving', () => {
+    expect(mimeToImageFormat('image/jpeg')).toBe('jpeg');
+    expect(mimeToImageFormat('image/jpg')).toBe('jpeg');
+    expect(mimeToImageFormat('IMAGE/PNG')).toBe('png');
+    expect(mimeToImageFormat('application/octet-stream')).toBeUndefined();
+    expect(mimeToImageFormat(undefined)).toBeUndefined();
+  });
+
+  test('clampQuality coerces to a 1..100 integer with a fallback', () => {
+    expect(clampQuality(80)).toBe(80);
+    expect(clampQuality(0)).toBe(1);
+    expect(clampQuality(250)).toBe(100);
+    expect(clampQuality(72.6)).toBe(73);
+    expect(clampQuality(undefined)).toBe(80);
+    expect(clampQuality(undefined, 60)).toBe(60);
+    expect(clampQuality(Number.NaN, 50)).toBe(50);
+  });
+
+  test('thumbnail format prefers webp, png when alpha matters', () => {
+    expect(pickThumbnailFormat()).toBe('webp');
+    expect(pickThumbnailFormat({ hasAlpha: false })).toBe('webp');
+    expect(pickThumbnailFormat({ hasAlpha: true })).toBe('png');
+  });
+});

package/src/core/media/format.ts

@@ -0,0 +1,58 @@
+// Pure format helpers — MIME/extension lookup, quality clamping, thumbnail-format
+// selection. No npm deps; shared by the server adapter, the React layer, and tests.
+
+import type { ImageOutputFormat } from './types';
+
+export const IMAGE_OUTPUT_FORMATS: readonly ImageOutputFormat[] = ['jpeg', 'png', 'webp', 'avif'];
+
+const IMAGE_MIME: Record<ImageOutputFormat, string> = {
+  jpeg: 'image/jpeg',
+  png: 'image/png',
+  webp: 'image/webp',
+  avif: 'image/avif',
+};
+
+const IMAGE_EXT: Record<ImageOutputFormat, string> = {
+  jpeg: 'jpg',
+  png: 'png',
+  webp: 'webp',
+  avif: 'avif',
+};
+
+export function imageFormatToMime(format: ImageOutputFormat): string {
+  return IMAGE_MIME[format];
+}
+
+export function imageFormatToExtension(format: ImageOutputFormat): string {
+  return IMAGE_EXT[format];
+}
+
+/** Best-effort MIME → output format (e.g. `image/jpeg` → `jpeg`). */
+export function mimeToImageFormat(mime: string | undefined): ImageOutputFormat | undefined {
+  if (!mime) return undefined;
+  const m = mime.toLowerCase();
+  if (m.includes('jpeg') || m.includes('jpg')) return 'jpeg';
+  if (m.includes('png')) return 'png';
+  if (m.includes('webp')) return 'webp';
+  if (m.includes('avif')) return 'avif';
+  return undefined;
+}
+
+/**
+ * Clamp an image quality to a sane 1–100 integer. A missing/NaN/out-of-range value
+ * falls back to `fallback` (default 80), so a malformed spec never yields a 0-quality
+ * (blank) or >100 (sharp-throwing) encode.
+ */
+export function clampQuality(quality: number | undefined, fallback = 80): number {
+  if (quality == null || !Number.isFinite(quality)) return fallback;
+  return Math.min(100, Math.max(1, Math.round(quality)));
+}
+
+/**
+ * The thumbnail encode format: webp by default (small + wide support); png when
+ * transparency must survive (the source already has alpha). Keeps thumbnail policy
+ * in one tested place rather than scattered across server handlers.
+ */
+export function pickThumbnailFormat(opts?: { hasAlpha?: boolean }): ImageOutputFormat {
+  return opts?.hasAlpha ? 'png' : 'webp';
+}

package/src/core/media/index.ts

@@ -0,0 +1,105 @@
+// cursedbelt-core/media — pure, dependency-free media contract + utilities shared by
+// the Bun server adapter (`src/server/media-bun`), the React components
+// (`cursedbelt/react/media`), and any consuming app/test. No React, no Bun, no npm
+// dep — the same module loads identically everywhere.
+
+export { type FloodFillBGOptions, floodFillBGS } from './bgRemoval';
+export {
+  buildProbeArgs,
+  buildThumbnailArgs,
+  buildTrimArgs,
+  ffmpegTimeToSeconds,
+  type ProbeResult,
+  parseFfmpegProgress,
+  parseFfprobe,
+  type VideoCodecPlan,
+  videoCodecPlan,
+} from './ffmpeg';
+export {
+  clampQuality,
+  IMAGE_OUTPUT_FORMATS,
+  imageFormatToExtension,
+  imageFormatToMime,
+  mimeToImageFormat,
+  pickThumbnailFormat,
+} from './format';
+export {
+  isAudioItem,
+  isImageItem,
+  isVideoItem,
+  mediaItemAspect,
+  mediaItemDimensions,
+} from './mediaItem';
+export {
+  buildAtempoChain,
+  buildTimelineRenderPlan,
+  DEFAULT_NORMALIZE,
+  type FfmpegCommand,
+  type NormalizeSpec,
+  type RenderPlanFile,
+  speedFilters,
+  type TimelineRenderOptions,
+  type TimelineRenderPlan,
+} from './renderPlan';
+export {
+  closeMask,
+  createRegionSegmenter,
+  DEFAULT_CLOSE_RADIUS,
+  DEFAULT_TOLERANCE,
+  dilateMask,
+  downscaleRgba,
+  erodeMask,
+  fitWorkingSize,
+  type ImageSegmenter,
+  type SegmentOptions,
+  type SegmentPrompt,
+  type SegmentSource,
+  sensitivityToTolerance,
+  upscaleMask,
+} from './segment';
+export { formatBytes } from './size';
+export {
+  type ClampTrimOptions,
+  clampTrimRange,
+  formatTimecode,
+  type TrimRange,
+  trimDurationSeconds,
+} from './trim';
+export type {
+  GalleryMedia,
+  GalleryPhoto,
+  ImageOperation,
+  ImageOutputFormat,
+  ImagePipelineSpec,
+  MediaItem,
+  MediaKind,
+  MediaKindFilter,
+  PlayableVideo,
+  ProcessingStatus,
+  VideoFormat,
+  VideoProgressEvent,
+  VideoQuality,
+  VideoTrimSpec,
+} from './types';
+export { DEFAULT_UPLOAD_CHUNK_SIZE, MAX_SINGLE_UPLOAD_BYTES } from './uploadLimits';
+export {
+  assertValidImagePipelineSpec,
+  assertValidVideoTrimSpec,
+  type ValidationResult,
+  validateImagePipelineSpec,
+  validateVideoTrimSpec,
+} from './validate';
+
+// Marking sections of a video to CUT OUT. Framework-free on purpose: the dialog
+// (`react/media/VideoCutEditor`), the app route that refuses an unexecutable list and the
+// binary-server job that runs it all read the same rules from here.
+export {
+  cutListProblem,
+  cutSeconds,
+  cutTimecode,
+  keptSeconds,
+  keptSegments,
+  MIN_CUT_SECONDS,
+  normalizeCuts,
+  type VideoCut,
+} from './videoCuts';

package/src/core/media/mediaItem.spec.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from 'bun:test';
+import {
+  isAudioItem,
+  isImageItem,
+  isVideoItem,
+  mediaItemAspect,
+  mediaItemDimensions,
+} from './mediaItem';
+import type { MediaItem } from './types';
+
+const item = (over: Partial<MediaItem> = {}): MediaItem => ({
+  id: '1',
+  type: 'image',
+  url: '/downloads/1',
+  name: 'one',
+  ...over,
+});
+
+describe('mediaItem helpers', () => {
+  test('kind predicates', () => {
+    expect(isImageItem(item({ type: 'image' }))).toBe(true);
+    expect(isVideoItem(item({ type: 'video' }))).toBe(true);
+    expect(isAudioItem(item({ type: 'audio' }))).toBe(true);
+    expect(isVideoItem(item({ type: 'image' }))).toBe(false);
+  });
+
+  test('uses intrinsic dimensions when present', () => {
+    expect(mediaItemDimensions(item({ width: 800, height: 600 }))).toEqual({
+      width: 800,
+      height: 600,
+    });
+    expect(mediaItemAspect(item({ width: 800, height: 600 }))).toBeCloseTo(4 / 3, 5);
+  });
+
+  test('falls back per-kind when dimensions are missing', () => {
+    expect(mediaItemDimensions(item({ type: 'image' }))).toEqual({ width: 4, height: 3 });
+    expect(mediaItemDimensions(item({ type: 'video' }))).toEqual({ width: 16, height: 9 });
+    expect(mediaItemAspect(item({ type: 'video' }))).toBeCloseTo(16 / 9, 5);
+  });
+
+  test('zero/partial dimensions fall back to the per-kind default ratio', () => {
+    // Neither both-positive → image default 4:3.
+    expect(mediaItemAspect(item({ type: 'image', width: 0, height: 0 }))).toBeCloseTo(4 / 3, 5);
+    expect(mediaItemAspect(item({ type: 'image', width: 10, height: 0 }))).toBeCloseTo(4 / 3, 5);
+  });
+});

package/src/core/media/mediaItem.ts

@@ -0,0 +1,40 @@
+// Pure MediaItem helpers — kind predicates + dimension/aspect resolution. The React
+// catalogue maps items to layout photos through these, so the "what size is this
+// thumbnail" logic is tested here, not buried in a component.
+
+import type { MediaItem } from './types';
+
+export const isImageItem = (item: MediaItem): boolean => item.type === 'image';
+export const isVideoItem = (item: MediaItem): boolean => item.type === 'video';
+export const isAudioItem = (item: MediaItem): boolean => item.type === 'audio';
+
+/** Default cell shape when an item carries no intrinsic dimensions. */
+const FALLBACK_DIMS: Record<MediaItem['type'], { width: number; height: number }> = {
+  image: { width: 4, height: 3 },
+  video: { width: 16, height: 9 },
+  audio: { width: 1, height: 1 },
+};
+
+/**
+ * Resolve renderable dimensions for an item. Real `width`/`height` win; otherwise a
+ * per-kind default (4:3 image, 16:9 video, 1:1 audio) keeps the justified/masonry
+ * layout from collapsing a dimensionless item to zero height.
+ */
+export function mediaItemDimensions(item: MediaItem): { width: number; height: number } {
+  if (isPositive(item.width) && isPositive(item.height)) {
+    return { width: item.width, height: item.height };
+  }
+  return FALLBACK_DIMS[item.type];
+}
+
+/** width / height (clamped to a sane range), falling back to `fallback` (default 1). */
+export function mediaItemAspect(item: MediaItem, fallback = 1): number {
+  const { width, height } = mediaItemDimensions(item);
+  if (!isPositive(width) || !isPositive(height)) return fallback;
+  const ratio = width / height;
+  return Number.isFinite(ratio) && ratio > 0 ? ratio : fallback;
+}
+
+function isPositive(n: number | undefined): n is number {
+  return typeof n === 'number' && Number.isFinite(n) && n > 0;
+}

package/src/core/media/renderPlan.spec.ts

@@ -0,0 +1,140 @@
+import { describe, expect, test } from 'bun:test';
+import type { TimelineClip, TimelineTrack } from 'cwip/timeline';
+import {
+  buildAtempoChain,
+  buildTimelineRenderPlan,
+  DEFAULT_NORMALIZE,
+  speedFilters,
+} from './renderPlan';
+
+const clip = (partial: Partial<TimelineClip> & { id: string }): TimelineClip => ({
+  name: partial.id,
+  sourceAssetId: 'a1',
+  trackIn: 0,
+  trackOut: 10,
+  timelineStart: 0,
+  timelineEnd: 10,
+  speed: 1,
+  volume: 1,
+  ...partial,
+});
+
+const track = (id: string, type: 'video' | 'audio', clips: TimelineClip[]): TimelineTrack => ({
+  id,
+  name: id,
+  type,
+  clips,
+});
+
+const FILES = { a1: 'a1.mp4', a2: 'a2.mov', m1: 'music.mp3' };
+
+describe('buildAtempoChain / speedFilters', () => {
+  test('chains beyond the 0.5–2.0 window', () => {
+    expect(buildAtempoChain(1.5)).toBe('atempo=1.5000');
+    expect(buildAtempoChain(4)).toBe('atempo=2.0,atempo=2.0000');
+    expect(buildAtempoChain(0.25)).toBe('atempo=0.5,atempo=0.5000');
+  });
+
+  test('speed 1 needs no filters', () => {
+    expect(speedFilters(1)).toBeNull();
+    expect(speedFilters(2)?.video).toBe('setpts=0.500000*PTS');
+  });
+});
+
+describe('buildTimelineRenderPlan', () => {
+  test('single-source trim+split plan: chunks then copy-concat straight to output', () => {
+    const tracks = [
+      track('v1', 'video', [
+        clip({ id: 'c1', trackIn: 2, trackOut: 6, timelineStart: 0, timelineEnd: 4 }),
+        clip({ id: 'c2', trackIn: 8, trackOut: 12, timelineStart: 4, timelineEnd: 8 }),
+      ]),
+    ];
+    const plan = buildTimelineRenderPlan(tracks, { assetFileNames: FILES });
+    expect(plan.commands).toHaveLength(3);
+    const [chunk1, chunk2, concat] = plan.commands;
+    expect(chunk1.args).toContain('-ss');
+    expect(chunk1.args[chunk1.args.indexOf('-ss') + 1]).toBe('2');
+    expect(chunk1.args[chunk1.args.indexOf('-to') + 1]).toBe('6');
+    expect(chunk2.args[chunk2.args.indexOf('-i') + 1]).toBe('a1.mp4');
+    // normalize spec is embedded in the -vf chain
+    const vf = chunk1.args[chunk1.args.indexOf('-vf') + 1];
+    expect(vf).toContain(`scale=${DEFAULT_NORMALIZE.width}:${DEFAULT_NORMALIZE.height}`);
+    expect(vf).toContain(`fps=${DEFAULT_NORMALIZE.fps}`);
+    // concat is stream-copy to the FINAL output (no audio mix step needed)
+    expect(concat.args).toContain('concat');
+    expect(concat.args).toContain('copy');
+    expect(concat.outputName).toBe('output.mp4');
+    expect(plan.files[0].text).toBe("file 'csrp_v0.mp4'\nfile 'csrp_v1.mp4'");
+    expect(plan.totalEncodeSeconds).toBe(8);
+    expect(plan.requiredAssetIds).toEqual(['a1']);
+    // intermediates: 2 chunks + concat list — never the output
+    expect(plan.intermediateNames).not.toContain('output.mp4');
+  });
+
+  test('speed + volume land in the filter chains and shorten the encode weight', () => {
+    const tracks = [
+      track('v1', 'video', [
+        clip({ id: 'c1', trackOut: 8, timelineEnd: 4, speed: 2, volume: 0.5 }),
+      ]),
+    ];
+    const plan = buildTimelineRenderPlan(tracks, { assetFileNames: FILES });
+    const chunk = plan.commands[0];
+    const vf = chunk.args[chunk.args.indexOf('-vf') + 1];
+    const af = chunk.args[chunk.args.indexOf('-af') + 1];
+    expect(vf).toContain('setpts=0.500000*PTS');
+    expect(af).toContain('atempo=2.0000');
+    expect(af).toContain('volume=0.500');
+    expect(chunk.encodeSeconds).toBe(4); // 8 source seconds at 2×
+  });
+
+  test('multi-source + audio track: silent bed, adelay offsets, amix under the lane', () => {
+    const tracks = [
+      track('v1', 'video', [
+        clip({ id: 'c1' }),
+        clip({ id: 'c2', sourceAssetId: 'a2', timelineStart: 10, timelineEnd: 20 }),
+      ]),
+      track('t-audio', 'audio', [
+        clip({ id: 'm1', sourceAssetId: 'm1', trackOut: 8, timelineStart: 2.5, timelineEnd: 10.5 }),
+      ]),
+    ];
+    const plan = buildTimelineRenderPlan(tracks, {
+      assetFileNames: FILES,
+      assetHasAudio: { a2: false },
+    });
+    // v-chunk for the silent source pulls in an anullsrc bed + explicit maps
+    const silentChunk = plan.commands[1];
+    expect(silentChunk.args.join(' ')).toContain('anullsrc');
+    expect(silentChunk.args).toContain('0:v:0');
+    // the mix step delays the music to 2500ms and amixes 2 inputs
+    const mix = plan.commands.at(-1);
+    const filter = mix?.args[mix.args.indexOf('-filter_complex') + 1];
+    expect(filter).toContain('adelay=2500|2500');
+    expect(filter).toContain('amix=inputs=2:duration=first');
+    expect(mix?.outputName).toBe('output.mp4');
+    // the intermediate lane is cleaned up, output is not
+    expect(plan.intermediateNames).toContain('csrp_lane.mp4');
+    expect(plan.requiredAssetIds).toEqual(['a1', 'a2', 'm1']);
+  });
+
+  test('fails loudly on an unmapped asset and an empty video lane', () => {
+    expect(() =>
+      buildTimelineRenderPlan([track('v1', 'video', [clip({ id: 'c1', sourceAssetId: 'nope' })])], {
+        assetFileNames: FILES,
+      }),
+    ).toThrow(/no file name mapped/);
+    expect(() =>
+      buildTimelineRenderPlan([track('v1', 'video', [])], { assetFileNames: FILES }),
+    ).toThrow(/no video clips/);
+  });
+
+  test('webm format flows through the codec plan and chunk extensions', () => {
+    const tracks = [track('v1', 'video', [clip({ id: 'c1' })])];
+    const plan = buildTimelineRenderPlan(tracks, {
+      assetFileNames: FILES,
+      format: 'webm',
+      outputName: 'out.webm',
+    });
+    expect(plan.commands[0].outputName).toBe('csrp_v0.webm');
+    expect(plan.commands[0].args).toContain('libvpx-vp9');
+  });
+});