cursedbelt 2.7.0 → 3.0.0

package/src/core/media/ffmpeg.ts

@@ -1,162 +0,0 @@
-// 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

@@ -1,41 +0,0 @@
-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

@@ -1,58 +0,0 @@
-// 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

@@ -1,105 +0,0 @@
-// cursedbelt/media-core — 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

@@ -1,46 +0,0 @@
-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

@@ -1,40 +0,0 @@
-// 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

@@ -1,140 +0,0 @@
-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');
-  });
-});