vargai 0.4.0-alpha31 → 0.4.0-alpha33

package/package.json

@@ -69,7 +69,7 @@
     "vargai": "^0.4.0-alpha11",
     "zod": "^4.2.1"
   },
-  "version": "0.4.0-alpha31",
+  "version": "0.4.0-alpha33",
   "exports": {
     ".": "./src/index.ts",
     "./ai": "./src/ai-sdk/index.ts",

package/src/ai-sdk/providers/editly/backends/index.ts

@@ -0,0 +1,7 @@
+export { LocalBackend, localBackend } from "./local";
+export type {
+  FFmpegBackend,
+  FFmpegRunOptions,
+  FFmpegRunResult,
+  VideoInfo,
+} from "./types";

package/src/ai-sdk/providers/editly/backends/local.ts

@@ -0,0 +1,65 @@
+import { $ } from "bun";
+import type {
+  FFmpegBackend,
+  FFmpegRunOptions,
+  FFmpegRunResult,
+  VideoInfo,
+} from "./types";
+
+const FFMPEG_COMMON_ARGS = ["-hide_banner", "-loglevel", "error"];
+
+export class LocalBackend implements FFmpegBackend {
+  readonly name = "local";
+
+  async ffprobe(input: string): Promise<VideoInfo> {
+    const result =
+      await $`ffprobe -v error -show_entries stream=width,height,r_frame_rate,codec_type -show_entries format=duration -of json ${input}`.json();
+
+    const videoStream = result.streams?.find(
+      (s: { codec_type: string }) => s.codec_type === "video",
+    );
+    const parsedDuration = parseFloat(result.format?.duration ?? "0");
+    const duration = Number.isFinite(parsedDuration) ? parsedDuration : 0;
+
+    let fps: number | undefined;
+    const framerateStr: string | undefined = videoStream?.r_frame_rate;
+    if (framerateStr) {
+      const parts = framerateStr.split("/").map(Number);
+      const num = parts[0];
+      const den = parts[1];
+      if (den && den > 0 && num) fps = num / den;
+    }
+
+    return {
+      duration,
+      width: videoStream?.width,
+      height: videoStream?.height,
+      fps,
+      framerateStr,
+    };
+  }
+
+  async run(options: FFmpegRunOptions): Promise<FFmpegRunResult> {
+    const { args, outputPath, verbose } = options;
+
+    const ffmpegArgs = [
+      ...FFMPEG_COMMON_ARGS.slice(0, 2),
+      verbose ? "info" : "error",
+      ...args,
+    ];
+
+    if (verbose) {
+      console.log("ffmpeg", ffmpegArgs.join(" "));
+    }
+
+    const result = await $`ffmpeg ${ffmpegArgs}`.quiet();
+
+    if (result.exitCode !== 0) {
+      throw new Error(`ffmpeg failed with exit code ${result.exitCode}`);
+    }
+
+    return { output: { type: "file", path: outputPath } };
+  }
+}
+
+export const localBackend = new LocalBackend();

package/src/ai-sdk/providers/editly/backends/types.ts

@@ -0,0 +1,54 @@
+/**
+ * FFmpeg backend abstraction for dependency injection
+ * Allows switching between local ffmpeg and cloud services like Rendi
+ */
+
+import type { VideoInfo } from "../types";
+
+/**
+ * Represents the result of running ffprobe
+ */
+export type { VideoInfo };
+
+/**
+ * FFmpeg execution options
+ */
+export interface FFmpegRunOptions {
+  /** ffmpeg arguments (without the 'ffmpeg' command itself) */
+  args: string[];
+  /** List of input file paths (local or URLs) */
+  inputs: string[];
+  /** Output file path */
+  outputPath: string;
+  /** Enable verbose logging */
+  verbose?: boolean;
+}
+
+export type FFmpegOutput =
+  | { type: "file"; path: string }
+  | { type: "url"; url: string };
+
+export interface FFmpegRunResult {
+  output: FFmpegOutput;
+}
+
+/**
+ * Backend interface for ffmpeg/ffprobe execution
+ */
+export interface FFmpegBackend {
+  /** Backend name for identification */
+  readonly name: string;
+
+  /**
+   * Run ffprobe to get media file info
+   * @param input - File path (local) or URL
+   */
+  ffprobe(input: string): Promise<VideoInfo>;
+
+  /**
+   * Run ffmpeg command
+   * @param options - Execution options including args, inputs, and output path
+   * @returns Result with optional URL for cloud backends
+   */
+  run(options: FFmpegRunOptions): Promise<FFmpegRunResult>;
+}

package/src/ai-sdk/providers/editly/editly.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 import { existsSync, unlinkSync } from "node:fs";
-import { ffprobe } from "./ffmpeg";
+import { localBackend } from "./backends/local";
 import { editly } from "./index";
 
 const VIDEO_1 = "output/sora-landscape.mp4";
@@ -9,6 +9,8 @@ const VIDEO_TALKING = "output/workflow-talking-synced.mp4";
 const IMAGE_SQUARE = "media/replicate-forest.png";
 const IMAGE_PORTRAIT = "media/madi-portrait.png";
 
+const ffprobe = localBackend.ffprobe;
+
 describe("editly", () => {
   test("requires outPath", async () => {
     await expect(

package/src/ai-sdk/providers/editly/index.ts

@@ -1,5 +1,4 @@
-import { $ } from "bun";
-import { ffprobe, multipleOf2 } from "./ffmpeg";
+import { type FFmpegBackend, localBackend } from "./backends";
 import {
   getImageOverlayFilter,
   getImageOverlayPositionFilter,
@@ -18,6 +17,7 @@ import type {
   Clip,
   DetachedAudioLayer,
   EditlyConfig,
+  EditlyResult,
   ImageOverlayLayer,
   Layer,
   NewsTitleLayer,
@@ -28,6 +28,7 @@ import type {
   VideoLayer,
 } from "./types";
 
+export * from "./backends";
 export * from "./types";
 
 const DEFAULT_DURATION = 4;
@@ -36,12 +37,22 @@ const DEFAULT_FPS = 30;
 const DEFAULT_WIDTH = 1280;
 const DEFAULT_HEIGHT = 720;
 
-async function getVideoDuration(path: string): Promise<number> {
-  const info = await ffprobe(path);
+function multipleOf2(n: number): number {
+  return Math.round(n / 2) * 2;
+}
+
+async function getVideoDuration(
+  path: string,
+  backend: FFmpegBackend,
+): Promise<number> {
+  const info = await backend.ffprobe(path);
   return info.duration;
 }
 
-async function getFirstVideoInfo(clips: Clip[]): Promise<{
+async function getFirstVideoInfo(
+  clips: Clip[],
+  backend: FFmpegBackend,
+): Promise<{
   width?: number;
   height?: number;
   fps?: number;
@@ -49,7 +60,7 @@ async function getFirstVideoInfo(clips: Clip[]): Promise<{
   for (const clip of clips) {
     for (const layer of clip.layers) {
       if (layer.type === "video") {
-        const info = await ffprobe((layer as VideoLayer).path);
+        const info = await backend.ffprobe((layer as VideoLayer).path);
         return { width: info.width, height: info.height, fps: info.fps };
       }
     }
@@ -72,6 +83,7 @@ function applyLayerDefaults(
 async function processClips(
   clips: Clip[],
   defaults: EditlyConfig["defaults"],
+  backend: FFmpegBackend,
 ): Promise<ProcessedClip[]> {
   const processed: ProcessedClip[] = [];
   const defaultDuration = defaults?.duration ?? DEFAULT_DURATION;
@@ -86,7 +98,7 @@ async function processClips(
     for (const layer of layers) {
       if (layer.type === "video" && !clip.duration) {
         const videoLayer = layer as VideoLayer;
-        const videoDuration = await getVideoDuration(videoLayer.path);
+        const videoDuration = await getVideoDuration(videoLayer.path, backend);
         const cutFrom = videoLayer.cutFrom ?? 0;
         const cutTo = videoLayer.cutTo ?? videoDuration;
         duration = cutTo - cutFrom;
@@ -522,7 +534,7 @@ function buildAudioFilter(
   };
 }
 
-export async function editly(config: EditlyConfig): Promise<void> {
+export async function editly(config: EditlyConfig): Promise<EditlyResult> {
   const {
     outPath,
     clips: clipsIn,
@@ -539,11 +551,17 @@ export async function editly(config: EditlyConfig): Promise<void> {
     fast,
   } = config;
 
+  const backend: FFmpegBackend = config.backend ?? localBackend;
+
+  if (verbose) {
+    console.log(`[editly] using backend: ${backend.name}`);
+  }
+
   if (!clipsIn || clipsIn.length === 0) {
     throw new Error("At least one clip is required");
   }
 
-  const firstVideoInfo = await getFirstVideoInfo(clipsIn);
+  const firstVideoInfo = await getFirstVideoInfo(clipsIn, backend);
   let width = config.width ?? firstVideoInfo.width ?? DEFAULT_WIDTH;
   let height = config.height ?? firstVideoInfo.height ?? DEFAULT_HEIGHT;
   const fps = config.fps ?? firstVideoInfo.fps ?? DEFAULT_FPS;
@@ -561,7 +579,7 @@ export async function editly(config: EditlyConfig): Promise<void> {
     console.log(`Output: ${width}x${height} @ ${fps}fps`);
   }
 
-  const clips = await processClips(clipsIn, defaults);
+  const clips = await processClips(clipsIn, defaults, backend);
 
   const continuousVideoOverlays = collectContinuousVideoOverlays(clips);
   const imageOverlays = collectImageOverlays(clips);
@@ -862,13 +880,18 @@ export async function editly(config: EditlyConfig): Promise<void> {
     console.log("\nFilter complex:\n", filterComplex.split(";").join(";\n"));
   }
 
-  const result = await $`ffmpeg ${ffmpegArgs}`.quiet();
+  const result = await backend.run({
+    args: ffmpegArgs,
+    inputs: allInputs,
+    outputPath: outPath,
+    verbose,
+  });
 
-  if (result.exitCode !== 0) {
-    throw new Error(`ffmpeg failed with exit code ${result.exitCode}`);
+  if (result.output.type === "file" && verbose) {
+    console.log(`Output: ${result.output.path}`);
   }
 
-  console.log(`Output: ${outPath}`);
+  return { output: result.output };
 }
 
 export default editly;

package/src/ai-sdk/providers/editly/rendi/editly-with-rendi-backend.test.ts

@@ -0,0 +1,335 @@
+/**
+ * Rendi backend tests - same as editly.test.ts but uses cloud ffmpeg
+ *
+ * NOTE: Free tier has 4 commands/min rate limit. Run tests individually:
+ *   bun test src/ai-sdk/providers/editly/rendi/editly-with-rendi-backend.test.ts -t "merges two"
+ */
+
+import { describe, expect, test } from "bun:test";
+import { $ } from "bun";
+import { editly } from "../index";
+import { createRendiBackend } from ".";
+
+const shouldRunRendiTests =
+  !!process.env.RENDI_INTEGRATION_TESTS && !!process.env.RENDI_API_KEY;
+
+const VIDEO_1 = "https://s3.varg.ai/test-media/sora-landscape.mp4";
+const VIDEO_2 = "https://s3.varg.ai/test-media/simpsons-scene.mp4";
+const VIDEO_TALKING =
+  "https://s3.varg.ai/test-media/workflow-talking-synced.mp4";
+const IMAGE_SQUARE = "https://s3.varg.ai/test-media/replicate-forest.png";
+
+const rendi = shouldRunRendiTests ? createRendiBackend() : (null as never);
+
+async function saveResult(
+  result: {
+    output: { type: "url"; url: string } | { type: "file"; path: string };
+  },
+  outPath: string,
+) {
+  expect(result.output.type).toBe("url");
+  if (result.output.type === "url") {
+    expect(result.output.url).toMatch(/^https:\/\//);
+    const res = await fetch(result.output.url);
+    if (!res.ok) throw new Error(`Failed to download: ${res.status}`);
+
+    const dir = outPath.split("/").slice(0, -1).join("/");
+    await $`mkdir -p ${dir}`.quiet();
+
+    const bytes = await res.arrayBuffer();
+    await Bun.write(outPath, bytes);
+
+    const written = Bun.file(outPath);
+    if (!(await written.exists()) || written.size === 0) {
+      throw new Error(`Failed to write output file: ${outPath}`);
+    }
+    console.log(`Output: ${outPath}`);
+  }
+}
+
+describe.skipIf(!shouldRunRendiTests)("editly (rendi backend)", () => {
+  test("merges two videos with fade transition", async () => {
+    const outPath = "output/rendi/merge.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      clips: [
+        {
+          layers: [{ type: "video", path: VIDEO_1 }],
+          transition: { name: "fade", duration: 0.5 },
+        },
+        {
+          layers: [{ type: "video", path: VIDEO_2 }],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("picture-in-picture (pip)", async () => {
+    const outPath = "output/rendi/pip.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            { type: "video", path: VIDEO_1 },
+            {
+              type: "video",
+              path: VIDEO_2,
+              width: "30%",
+              height: "30%",
+              left: "68%",
+              top: "2%",
+            },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("image ken burns preserves aspect ratio", async () => {
+    const outPath = "output/rendi/ken-burns.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            {
+              type: "image",
+              path: IMAGE_SQUARE,
+              zoomDirection: "in",
+              zoomAmount: 0.1,
+              resizeMode: "contain",
+            },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("subtitle layer", async () => {
+    const outPath = "output/rendi/subtitle.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            { type: "video", path: VIDEO_1 },
+            {
+              type: "subtitle",
+              text: "This is a subtitle at the bottom",
+            },
+          ],
+        },
+        {
+          duration: 3,
+          layers: [
+            { type: "video", path: VIDEO_2 },
+            {
+              type: "subtitle",
+              text: "Another subtitle with custom colors",
+              textColor: "yellow",
+              backgroundColor: "blue@0.8",
+            },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("news-title layer", async () => {
+    const outPath = "output/rendi/news-title.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            { type: "video", path: VIDEO_1 },
+            {
+              type: "news-title",
+              text: "BREAKING NEWS: Something important happened",
+              backgroundColor: "red",
+            },
+          ],
+        },
+        {
+          duration: 3,
+          layers: [
+            { type: "video", path: VIDEO_2 },
+            {
+              type: "news-title",
+              text: "TOP STORY",
+              backgroundColor: "blue",
+              position: "top",
+            },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("keepSourceAudio preserves original video audio", async () => {
+    const outPath = "output/rendi/keep-audio.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      keepSourceAudio: true,
+      clips: [
+        {
+          layers: [
+            { type: "video", path: VIDEO_TALKING },
+            { type: "subtitle", text: "Original audio should play" },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("keepSourceAudio with cutFrom stays in sync", async () => {
+    const outPath = "output/rendi/keep-audio-cut.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1280,
+      height: 720,
+      fps: 30,
+      keepSourceAudio: true,
+      clips: [
+        {
+          layers: [
+            { type: "video", path: VIDEO_TALKING, cutFrom: 2, cutTo: 6 },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("contain-blur resize mode for video", async () => {
+    const outPath = "output/rendi/contain-blur.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1080,
+      height: 1920,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            { type: "video", path: VIDEO_1, resizeMode: "contain-blur" },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("video overlay with cropPosition", async () => {
+    const outPath = "output/rendi/crop-position.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1080,
+      height: 1920,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            { type: "fill-color", color: "#000000" },
+            {
+              type: "video",
+              path: VIDEO_1,
+              width: 1080,
+              height: 960,
+              left: 0,
+              top: 0,
+              resizeMode: "cover",
+              cropPosition: "top",
+            },
+            {
+              type: "video",
+              path: VIDEO_2,
+              width: 1080,
+              height: 960,
+              left: 0,
+              top: 960,
+              resizeMode: "cover",
+              cropPosition: "bottom",
+            },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+
+  test("portrait 9:16 image with zoompan cover mode", async () => {
+    const outPath = "output/rendi/portrait-zoompan.mp4";
+    const result = await editly({
+      outPath,
+      backend: rendi,
+      width: 1080,
+      height: 1920,
+      fps: 30,
+      clips: [
+        {
+          duration: 3,
+          layers: [
+            {
+              type: "image",
+              path: IMAGE_SQUARE,
+              zoomDirection: "in",
+              zoomAmount: 0.1,
+              resizeMode: "cover",
+            },
+          ],
+        },
+      ],
+    });
+
+    await saveResult(result, outPath);
+  }, 120000);
+});

package/src/ai-sdk/providers/editly/rendi/index.ts

@@ -0,0 +1,277 @@
+import type {
+  FFmpegBackend,
+  FFmpegRunOptions,
+  FFmpegRunResult,
+  VideoInfo,
+} from "../backends/types";
+
+const RENDI_API_BASE = "https://api.rendi.dev/v1";
+const POLL_INTERVAL_MS = 2000;
+const MAX_POLL_ATTEMPTS = 300;
+const DEFAULT_MAX_COMMAND_SECONDS = 60;
+
+interface RendiCommandResponse {
+  command_id: string;
+}
+
+interface RendiStoredFile {
+  file_id: string;
+  storage_url: string | null;
+  status: string;
+  duration?: number;
+  width?: number;
+  height?: number;
+  frame_rate?: number;
+}
+
+interface RendiStatusResponse {
+  command_id: string;
+  status: "QUEUED" | "PROCESSING" | "SUCCESS" | "FAILED";
+  error_message?: string;
+  output_files?: Record<string, RendiStoredFile>;
+}
+
+export class RendiBackend implements FFmpegBackend {
+  readonly name = "rendi";
+  private apiKey: string;
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey ?? process.env.RENDI_API_KEY ?? "";
+    if (!this.apiKey) {
+      throw new Error("RENDI_API_KEY is required for Rendi backend");
+    }
+  }
+
+  async ffprobe(input: string): Promise<VideoInfo> {
+    const inputUrl = this.ensureUrl(input);
+
+    const submitResponse = await fetch(`${RENDI_API_BASE}/run-ffmpeg-command`, {
+      method: "POST",
+      headers: {
+        "X-API-KEY": this.apiKey,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        input_files: { in_1: inputUrl },
+        output_files: { out_1: "probe.mp4" },
+        ffmpeg_command: "-i {{in_1}} -c copy {{out_1}}",
+        max_command_run_seconds: DEFAULT_MAX_COMMAND_SECONDS,
+      }),
+    });
+
+    if (!submitResponse.ok) {
+      throw new Error(`Rendi ffprobe failed: ${submitResponse.status}`);
+    }
+
+    const { command_id } =
+      (await submitResponse.json()) as RendiCommandResponse;
+
+    let attempts = 0;
+    while (attempts < MAX_POLL_ATTEMPTS) {
+      const statusResponse = await fetch(
+        `${RENDI_API_BASE}/commands/${command_id}`,
+        { headers: { "X-API-KEY": this.apiKey } },
+      );
+
+      if (!statusResponse.ok) {
+        throw new Error(`Rendi ffprobe poll failed: ${statusResponse.status}`);
+      }
+
+      const status = (await statusResponse.json()) as RendiStatusResponse;
+
+      if (status.status === "SUCCESS") {
+        const output = status.output_files?.out_1;
+        if (!output) {
+          throw new Error("rendi ffprobe completed but no output metadata");
+        }
+        return {
+          duration: output.duration ?? 0,
+          width: output.width,
+          height: output.height,
+          fps: output.frame_rate,
+        };
+      }
+
+      if (status.status === "FAILED") {
+        throw new Error(`Rendi ffprobe failed: ${status.error_message}`);
+      }
+
+      await this.sleep(POLL_INTERVAL_MS);
+      attempts++;
+    }
+
+    throw new Error("Rendi ffprobe timed out");
+  }
+
+  async run(options: FFmpegRunOptions): Promise<FFmpegRunResult> {
+    const { args, inputs, outputPath, verbose } = options;
+
+    const uniqueInputs = [...new Set(inputs)];
+    const inputUrls = uniqueInputs.map((input) => this.ensureUrl(input));
+
+    const inputFiles: Record<string, string> = {};
+    const pathToPlaceholder = new Map<string, string>();
+
+    for (let i = 0; i < uniqueInputs.length; i++) {
+      const placeholder = `in_${i + 1}`;
+      inputFiles[placeholder] = inputUrls[i]!;
+      pathToPlaceholder.set(uniqueInputs[i]!, `{{${placeholder}}}`);
+    }
+
+    const commandArgs = args.map((arg) => {
+      if (arg === outputPath) {
+        return "{{out_1}}";
+      }
+      const placeholder = pathToPlaceholder.get(arg);
+      if (placeholder) {
+        return placeholder;
+      }
+      let result = arg;
+      for (const [url, ph] of pathToPlaceholder) {
+        if (result.includes(url)) {
+          result = result.replaceAll(url, ph);
+        }
+      }
+      return result;
+    });
+
+    const filteredArgs = this.stripInternalFlags(commandArgs);
+    const ffmpegCommand = this.buildCommandString(filteredArgs);
+
+    const outputFilename = outputPath?.split("/").pop() ?? "output.mp4";
+    const finalCommand = ffmpegCommand.includes("{{out_1}}")
+      ? ffmpegCommand
+      : ffmpegCommand.replace(/[^\s]+\.\w+$/, "{{out_1}}");
+
+    if (verbose) {
+      console.log("[rendi] input_files:", inputFiles);
+      console.log("[rendi] ffmpeg_command:", finalCommand);
+    }
+
+    const submitResponse = await fetch(`${RENDI_API_BASE}/run-ffmpeg-command`, {
+      method: "POST",
+      headers: {
+        "X-API-KEY": this.apiKey,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        input_files: inputFiles,
+        output_files: { out_1: outputFilename },
+        ffmpeg_command: finalCommand,
+        max_command_run_seconds: DEFAULT_MAX_COMMAND_SECONDS,
+      }),
+    });
+
+    if (!submitResponse.ok) {
+      const errorText = await submitResponse.text();
+      throw new Error(
+        `Rendi submit failed: ${submitResponse.status} - ${errorText}`,
+      );
+    }
+
+    const { command_id } =
+      (await submitResponse.json()) as RendiCommandResponse;
+
+    if (verbose) {
+      console.log("[rendi] command_id:", command_id);
+    }
+
+    let attempts = 0;
+    while (attempts < MAX_POLL_ATTEMPTS) {
+      const statusResponse = await fetch(
+        `${RENDI_API_BASE}/commands/${command_id}`,
+        {
+          headers: { "X-API-KEY": this.apiKey },
+        },
+      );
+
+      if (!statusResponse.ok) {
+        throw new Error(`Rendi poll failed: ${statusResponse.status}`);
+      }
+
+      const status = (await statusResponse.json()) as RendiStatusResponse;
+
+      if (verbose && attempts % 5 === 0) {
+        console.log("[rendi] status:", status.status);
+      }
+
+      if (status.status === "SUCCESS") {
+        const outputFile = status.output_files?.out_1;
+        if (!outputFile?.storage_url) {
+          throw new Error("Rendi completed but no output URL found");
+        }
+
+        if (verbose) {
+          console.log("[rendi] output url:", outputFile.storage_url);
+        }
+
+        return { output: { type: "url", url: outputFile.storage_url } };
+      }
+
+      if (status.status === "FAILED") {
+        throw new Error(
+          `Rendi command failed: ${status.error_message ?? "Unknown error"}`,
+        );
+      }
+
+      await this.sleep(POLL_INTERVAL_MS);
+      attempts++;
+    }
+
+    throw new Error("Rendi command timed out");
+  }
+
+  private ensureUrl(input: string): string {
+    if (input.startsWith("http://") || input.startsWith("https://")) {
+      return input;
+    }
+    throw new Error(`Rendi backend requires URLs, got local path: ${input}`);
+  }
+
+  private stripInternalFlags(args: string[]): string[] {
+    const filtered: string[] = [];
+    let skipNext = false;
+
+    for (const arg of args) {
+      if (skipNext) {
+        skipNext = false;
+        continue;
+      }
+
+      if (arg === "-hide_banner") continue;
+      if (arg === "-y") continue;
+      if (arg === "-loglevel") {
+        skipNext = true;
+        continue;
+      }
+
+      filtered.push(arg);
+    }
+
+    return filtered;
+  }
+
+  private buildCommandString(args: string[]): string {
+    return args
+      .map((arg) => {
+        if (arg.startsWith("-") || arg.startsWith("{{")) {
+          return arg;
+        }
+        if (arg.includes(" ") || arg.includes(":") || arg.includes("'")) {
+          return `"${arg.replace(/"/g, '\\"')}"`;
+        }
+        return arg;
+      })
+      .join(" ");
+  }
+
+  private sleep(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+export function createRendiBackend(apiKey?: string): RendiBackend {
+  return new RendiBackend(apiKey);
+}
+
+export type { FFmpegBackend } from "../backends/types";

package/src/ai-sdk/providers/editly/rendi/rendi.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+import { createRendiBackend } from ".";
+
+const hasRendiKey = !!process.env.RENDI_API_KEY;
+
+describe.skipIf(!hasRendiKey)("rendi backend", () => {
+  test("ffprobe remote file", async () => {
+    const backend = createRendiBackend();
+    const info = await backend.ffprobe(
+      "https://storage.rendi.dev/sample/big_buck_bunny_720p_5sec_intro.mp4",
+    );
+
+    expect(info.duration).toBeGreaterThan(0);
+    expect(info.width).toBe(1280);
+    expect(info.height).toBe(720);
+  }, 30000);
+
+  test("run simple ffmpeg command", async () => {
+    const backend = createRendiBackend();
+
+    const result = await backend.run({
+      args: [
+        "-i",
+        "https://storage.rendi.dev/sample/big_buck_bunny_720p_5sec_intro.mp4",
+        "-t",
+        "2",
+        "-c:v",
+        "libx264",
+        "-preset",
+        "ultrafast",
+        "-y",
+        "output.mp4",
+      ],
+      inputs: [
+        "https://storage.rendi.dev/sample/big_buck_bunny_720p_5sec_intro.mp4",
+      ],
+      outputPath: "output.mp4",
+      verbose: true,
+    });
+
+    expect(result.output.type).toBe("url");
+    if (result.output.type === "url") {
+      expect(result.output.url).toMatch(/^https:\/\//);
+    }
+  }, 120000);
+});

package/src/ai-sdk/providers/editly/types.ts

@@ -1,6 +1,8 @@
 // Types from original editly (https://github.com/mifi/editly)
 // Adapted for pure ffmpeg implementation (no fabric/canvas/gl dependencies)
 
+import type { FFmpegBackend } from "./backends";
+
 export type OriginX = "left" | "center" | "right";
 export type OriginY = "top" | "center" | "bottom";
 export type SizeValue = number | `${number}%` | `${number}px`;
@@ -327,6 +329,16 @@ export interface EditlyConfig {
   enableFfmpegLog?: boolean;
   /** End output when shortest stream ends (video or audio) */
   shortest?: boolean;
+  /** FFmpeg backend for execution (defaults to local ffmpeg) */
+  backend?: FFmpegBackend;
+}
+
+export type EditlyOutput =
+  | { type: "file"; path: string }
+  | { type: "url"; url: string };
+
+export interface EditlyResult {
+  output: EditlyOutput;
 }
 
 // Internal types used by our implementation

package/src/react/renderers/burn-captions.ts

@@ -0,0 +1,107 @@
+import { localBackend } from "@/ai-sdk/providers/editly";
+import type {
+  FFmpegBackend,
+  FFmpegOutput,
+} from "../../ai-sdk/providers/editly/backends/types";
+import { uploadBuffer } from "../../providers/storage";
+
+/**
+ * Resolves an FFmpegOutput to a string path/URL, uploading local files if needed.
+ *
+ * - URL input → returns URL as-is
+ * - File input + shouldUpload=false → returns local path
+ * - File input + shouldUpload=true → uploads to storage, returns URL
+ */
+async function resolveInputPathMaybeUpload(
+  input: FFmpegOutput,
+  options: { shouldUpload: boolean },
+): Promise<string> {
+  if (input.type === "url") return input.url;
+  if (!options.shouldUpload) return input.path;
+
+  const buffer = await Bun.file(input.path).arrayBuffer();
+  return uploadBuffer(
+    buffer,
+    `tmp/${Date.now()}-${input.path.split("/").pop()}`,
+    "application/octet-stream",
+  );
+}
+
+export interface CaptionOverlayOptions {
+  video: FFmpegOutput;
+  assPath: string;
+  outputPath: string;
+  backend?: FFmpegBackend;
+  verbose?: boolean;
+}
+
+/**
+ * Burns ASS subtitle captions onto a video using FFmpeg.
+ *
+ * {@link burnCaptions} composites the subtitle file directly into the video frames,
+ * producing a new video with hardcoded captions. Supports both local and cloud
+ * FFmpeg backends - when using a cloud backend, input files are automatically
+ * uploaded to storage.
+ *
+ * @param options - Configuration for the caption burn operation
+ * @param options.video - Source video as {@link FFmpegOutput} (file path or URL)
+ * @param options.assPath - Path to the ASS subtitle file to burn
+ * @param options.outputPath - Destination path for the output video (defaults to "output.mp4")
+ * @param options.backend - Optional {@link FFmpegBackend} for cloud processing; uses local FFmpeg if omitted
+ * @param options.verbose - Enable verbose FFmpeg logging
+ *
+ * @returns Promise resolving to {@link FFmpegOutput} containing the path or URL of the captioned video
+ *
+ * @throws May throw if FFmpeg execution fails, input files are missing, or upload fails for cloud backends
+ *
+ * @example
+ * ```ts
+ * const result = await burnCaptions({
+ *   video: { type: "file", path: "input.mp4" },
+ *   assPath: "captions.ass",
+ *   outputPath: "output-with-captions.mp4",
+ * });
+ * ```
+ */
+export async function burnCaptions(
+  options: CaptionOverlayOptions,
+): Promise<FFmpegOutput> {
+  const { video, assPath, outputPath = "output.mp4", verbose } = options;
+  const captions: FFmpegOutput = { type: "file", path: assPath };
+
+  const isCloud = options.backend !== undefined;
+
+  const videoInput = await resolveInputPathMaybeUpload(video, {
+    shouldUpload: isCloud,
+  });
+  const assInput = await resolveInputPathMaybeUpload(captions, {
+    shouldUpload: isCloud,
+  });
+
+  const backend = options.backend ?? localBackend;
+
+  // FFmpeg filter syntax requires escaping backslashes and colons
+  const escapedAssPath = assInput.replace(/\\/g, "\\\\").replace(/:/g, "\\:");
+
+  const result = await backend.run({
+    args: [
+      "-i",
+      videoInput,
+      "-vf",
+      `subtitles=${escapedAssPath}`,
+      "-crf",
+      "18",
+      "-preset",
+      "fast",
+      "-c:a",
+      "copy",
+      "-y",
+      outputPath,
+    ],
+    inputs: [videoInput, assInput],
+    outputPath,
+    verbose,
+  });
+
+  return result.output;
+}

package/src/react/renderers/render.ts

@@ -14,6 +14,7 @@ import type {
   Layer,
   VideoLayer,
 } from "../../ai-sdk/providers/editly/types";
+
 import type {
   CaptionsProps,
   ClipProps,
@@ -25,6 +26,7 @@ import type {
   SpeechProps,
   VargElement,
 } from "../types";
+import { burnCaptions } from "./burn-captions";
 import { renderCaptions } from "./captions";
 import { renderClip } from "./clip";
 import type { RenderContext } from "./context";
@@ -271,7 +273,7 @@ export async function renderRoot(
   const editlyTaskId = addTask(progress, "editly", "ffmpeg");
   startTask(progress, editlyTaskId);
 
-  await editly({
+  const editlyResult = await editly({
     outPath: tempOutPath,
     width: ctx.width,
     height: ctx.height,
@@ -280,27 +282,50 @@ export async function renderRoot(
     audioTracks: audioTracks.length > 0 ? audioTracks : undefined,
     shortest: props.shortest,
     verbose: options.verbose,
+    backend: options.backend,
   });
 
   completeTask(progress, editlyTaskId);
 
+  let output = editlyResult.output;
+
   if (hasCaptions && captionsResult) {
     const captionsTaskId = addTask(progress, "captions", "ffmpeg");
     startTask(progress, captionsTaskId);
 
-    const { $ } = await import("bun");
-    await $`ffmpeg -y -i ${tempOutPath} -vf "ass=${captionsResult.assPath}" -crf 18 -preset slow -c:a copy ${finalOutPath}`.quiet();
+    output = await burnCaptions({
+      video: output,
+      assPath: captionsResult.assPath,
+      outputPath: finalOutPath,
+      backend: options.backend,
+      verbose: options.verbose,
+    });
+
+    if (!options.backend) {
+      ctx.tempFiles.push(tempOutPath);
+    }
 
-    ctx.tempFiles.push(tempOutPath);
     completeTask(progress, captionsTaskId);
   }
 
+  let finalBuffer: ArrayBuffer;
+  if (output.type === "url") {
+    const res = await fetch(output.url);
+    if (!res.ok)
+      throw new Error(`Failed to download final render: ${res.status}`);
+    finalBuffer = await res.arrayBuffer();
+    if (options.output) {
+      await Bun.write(options.output, finalBuffer);
+    }
+  } else {
+    finalBuffer = await Bun.file(output.path).arrayBuffer();
+  }
+
   if (!options.quiet && mode === "preview" && placeholderCount.total > 0) {
     console.log(
       `\x1b[36mℹ preview mode: ${placeholderCount.total} placeholders used (${placeholderCount.images} images, ${placeholderCount.videos} videos)\x1b[0m`,
     );
   }
 
-  const result = await Bun.file(finalOutPath).arrayBuffer();
-  return new Uint8Array(result);
+  return new Uint8Array(finalBuffer);
 }

package/src/react/types.ts

@@ -1,4 +1,5 @@
 import type { ImageModelV3, SpeechModelV3 } from "@ai-sdk/provider";
+import type { FFmpegBackend } from "@/ai-sdk/providers/editly/backends";
 import type { MusicModelV3 } from "../ai-sdk/music-model";
 import type {
   CropPosition,
@@ -260,6 +261,7 @@ export interface RenderOptions {
   verbose?: boolean;
   mode?: RenderMode;
   defaults?: DefaultModels;
+  backend?: FFmpegBackend;
 }
 
 export interface ElementPropsMap {

package/src/ai-sdk/providers/editly/ffmpeg.ts

@@ -1,60 +0,0 @@
-import { $ } from "bun";
-import type { VideoInfo } from "./types";
-
-const FFMPEG_COMMON_ARGS = ["-hide_banner", "-loglevel", "error"];
-
-export async function ffmpeg(
-  args: string[],
-  options?: { stdin?: "pipe" | "ignore"; stdout?: "pipe" | "inherit" },
-): Promise<{ stdout: Buffer; exitCode: number }> {
-  const proc = Bun.spawn(["ffmpeg", ...FFMPEG_COMMON_ARGS, ...args], {
-    stdin: options?.stdin ?? "ignore",
-    stdout: options?.stdout === "inherit" ? "inherit" : "pipe",
-    stderr: "inherit",
-  });
-
-  const stdout =
-    options?.stdout === "inherit"
-      ? Buffer.alloc(0)
-      : Buffer.from(await new Response(proc.stdout).arrayBuffer());
-  const exitCode = await proc.exited;
-
-  return { stdout, exitCode };
-}
-
-export async function ffprobe(path: string): Promise<VideoInfo> {
-  const result =
-    await $`ffprobe -v error -show_entries stream=width,height,r_frame_rate,codec_type -show_entries format=duration -of json ${path}`.json();
-
-  const videoStream = result.streams?.find(
-    (s: { codec_type: string }) => s.codec_type === "video",
-  );
-  const duration = parseFloat(result.format?.duration ?? "0");
-
-  let fps: number | undefined;
-  const framerateStr: string | undefined = videoStream?.r_frame_rate;
-  if (framerateStr) {
-    const parts = framerateStr.split("/").map(Number);
-    const num = parts[0];
-    const den = parts[1];
-    if (den && den > 0 && num) fps = num / den;
-  }
-
-  return {
-    duration,
-    width: videoStream?.width,
-    height: videoStream?.height,
-    fps,
-    framerateStr,
-  };
-}
-
-export async function readDuration(path: string): Promise<number> {
-  const result =
-    await $`ffprobe -v error -show_entries format=duration -of default=noprint_wrappers=1:nokey=1 ${path}`.text();
-  return parseFloat(result.trim());
-}
-
-export function multipleOf2(n: number): number {
-  return Math.round(n / 2) * 2;
-}