vargai 0.4.0-alpha55 → 0.4.0-alpha57

package/.env.example

@@ -0,0 +1,33 @@
+# fal.ai api key
+FAL_API_KEY=fal_xxx
+
+# higgsfield credentials
+HIGGSFIELD_API_KEY=hf_xxx
+HIGGSFIELD_SECRET=secret_xxx
+
+# elevenlabs api key
+ELEVENLABS_API_KEY=el_xxx
+
+# groq api key (ultra-fast whisper transcription)
+GROQ_API_KEY=gsk_xxx
+
+# fireworks api key (word-level transcription with timestamps)
+FIREWORKS_API_KEY=fw_xxx
+
+# cloudflare r2 / s3 storage
+CLOUDFLARE_R2_API_URL=https://xxx.r2.cloudflarestorage.com
+CLOUDFLARE_ACCESS_KEY_ID=xxx
+CLOUDFLARE_ACCESS_SECRET=xxx
+CLOUDFLARE_R2_BUCKET=m
+
+# replicate (optional)
+REPLICATE_API_TOKEN=r8_xxx
+
+# apify (web scraping actors)
+APIFY_TOKEN=apify_api_xxx
+
+# decart ai (real-time & batch video/image)
+DECART_API_KEY=decart_xxx
+
+# together ai (fast flux-schnell, no queue)
+TOGETHER_API_KEY=together_xxx

package/package.json

@@ -70,7 +70,7 @@
     "zod": "^4.2.1"
   },
   "sideEffects": false,
-  "version": "0.4.0-alpha55",
+  "version": "0.4.0-alpha57",
   "exports": {
     ".": "./src/index.ts",
     "./ai": "./src/ai-sdk/index.ts",

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

@@ -1,3 +1,4 @@
+import sharp from "sharp";
 import { File } from "../../../file";
 import type { StorageProvider } from "../../../storage/types";
 import type {
@@ -122,7 +123,7 @@ export class RendiBackend implements FFmpegBackend {
   }
 
   async run(options: FFmpegRunOptions): Promise<FFmpegRunResult> {
-    const {
+    let {
       inputs,
       filterComplex,
       videoFilter,
@@ -131,11 +132,19 @@ export class RendiBackend implements FFmpegBackend {
       verbose,
     } = options;
 
+    // Synthetic-only commands (e.g. fill-color, gradient clips) produce a
+    // filterComplex that uses lavfi sources like `color=...` with zero file
+    // inputs.  Rendi requires at least one input_file, so we upload a tiny
+    // 1×1 transparent PNG as a dummy input that ffmpeg silently ignores
+    // (the filterComplex never references [0:v]).
     if (!inputs || inputs.length === 0) {
-      throw new Error(
-        "Rendi backend requires at least one input file. " +
-          "Ensure your render contains media elements (Video, Image, etc.) with valid sources.",
-      );
+      if (!filterComplex) {
+        throw new Error(
+          "Rendi backend requires at least one input file or a filterComplex with synthetic sources.",
+        );
+      }
+      const dummyUrl = await this.getOrCreateDummyInput();
+      inputs = [dummyUrl];
     }
 
     const inputFiles: Record<string, string> = {};
@@ -283,6 +292,31 @@ export class RendiBackend implements FFmpegBackend {
     return file.upload(this.storage);
   }
 
+  /** Cached URL of the 1×1 dummy PNG so we upload it at most once per backend instance. */
+  private dummyInputUrl: string | null = null;
+
+  /**
+   * Generate a 1×1 transparent PNG via sharp, upload it to storage, and cache
+   * the URL.  Used as a placeholder input for Rendi when the ffmpeg command
+   * has only synthetic (lavfi) sources and no real file inputs.
+   */
+  private async getOrCreateDummyInput(): Promise<string> {
+    if (this.dummyInputUrl) return this.dummyInputUrl;
+    const png = await sharp({
+      create: {
+        width: 1,
+        height: 1,
+        channels: 4,
+        background: { r: 0, g: 0, b: 0, alpha: 0 },
+      },
+    })
+      .png()
+      .toBuffer();
+    const key = "internal/rendi-dummy-1x1.png";
+    this.dummyInputUrl = await this.storage.upload(png, key, "image/png");
+    return this.dummyInputUrl;
+  }
+
   private buildCommandString(args: string[]): string {
     return args
       .map((arg) => {

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

@@ -10,9 +10,19 @@ const mockStorage: StorageProvider = {
   },
 };
 
+/** Mock storage that accepts uploads and returns a predictable URL. */
+const uploadableStorage: StorageProvider = {
+  async upload(_data: Uint8Array, key: string) {
+    return `https://mock-storage.test/${key}`;
+  },
+};
+
 describe("rendi backend validation", () => {
-  test("throws error when inputs array is empty", async () => {
-    const backend = createRendiBackend({ storage: mockStorage });
+  test("throws when inputs empty and no filterComplex", async () => {
+    const backend = createRendiBackend({
+      apiKey: "test-key",
+      storage: mockStorage,
+    });
 
     await expect(
       backend.run({
@@ -20,11 +30,16 @@ describe("rendi backend validation", () => {
         outputArgs: ["-c:v", "libx264"],
         outputPath: "output.mp4",
       }),
-    ).rejects.toThrow("Rendi backend requires at least one input file");
+    ).rejects.toThrow(
+      "Rendi backend requires at least one input file or a filterComplex",
+    );
   });
 
-  test("throws error when inputs is undefined", async () => {
-    const backend = createRendiBackend({ storage: mockStorage });
+  test("throws when inputs undefined and no filterComplex", async () => {
+    const backend = createRendiBackend({
+      apiKey: "test-key",
+      storage: mockStorage,
+    });
 
     await expect(
       backend.run({
@@ -32,7 +47,28 @@ describe("rendi backend validation", () => {
         outputArgs: ["-c:v", "libx264"],
         outputPath: "output.mp4",
       }),
-    ).rejects.toThrow("Rendi backend requires at least one input file");
+    ).rejects.toThrow(
+      "Rendi backend requires at least one input file or a filterComplex",
+    );
+  });
+
+  test("generates dummy input when inputs empty but filterComplex present", async () => {
+    // The run() call will still fail at the Rendi API fetch (no real server),
+    // but it should NOT throw the "requires at least one input" error.
+    // It should get past the validation and fail at the network call.
+    const backend = createRendiBackend({
+      apiKey: "test-key",
+      storage: uploadableStorage,
+    });
+
+    await expect(
+      backend.run({
+        inputs: [],
+        filterComplex: "color=c=#1a1a2e:s=1080x1920:d=5:r=30[color0]",
+        outputArgs: ["-map", "[color0]", "-c:v", "libx264"],
+        outputPath: "output.mp4",
+      }),
+    ).rejects.toThrow(/Rendi submit failed|fetch/);
   });
 });
 

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

@@ -3,28 +3,17 @@ 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
+ * Resolves an FFmpegOutput to a string path/URL via the backend.
+ * Local backend returns local paths; cloud backends upload and return URLs.
  */
 async function resolveInputPathMaybeUpload(
   input: FFmpegOutput,
-  options: { shouldUpload: boolean },
+  backend: FFmpegBackend,
 ): 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",
-  );
+  return backend.resolvePath(input.path);
 }
 
 export interface CaptionOverlayOptions {
@@ -69,22 +58,15 @@ export async function burnCaptions(
   const { video, assPath, outputPath = "output.mp4", verbose } = options;
   const captions: FFmpegOutput = { type: "file", path: assPath };
 
-  // Resolve backend first so we can check if it's cloud or local
-  // TODO: This is a hack - we should abstract backend capabilities (e.g., supportsLocalPaths)
-  // instead of checking the name directly. For now, we assume "local" is the only local backend.
   const backend = options.backend ?? localBackend;
-  const isCloud = backend.name !== "local";
 
-  const videoInput = await resolveInputPathMaybeUpload(video, {
-    shouldUpload: isCloud,
-  });
-  const assInput = await resolveInputPathMaybeUpload(captions, {
-    shouldUpload: isCloud,
-  });
+  const videoInput = await resolveInputPathMaybeUpload(video, backend);
+  const assInput = await resolveInputPathMaybeUpload(captions, backend);
 
   // For cloud backends (Rendi): pass raw URL so replaceWithPlaceholders() can match
   // and replace with {{in_X}} placeholder. Rendi downloads inputs and provides local paths.
   // For local backend: escape for FFmpeg filter syntax (backslashes and colons)
+  const isCloud = backend.name !== "local";
   const subtitlesPath = isCloud
     ? assInput
     : assInput.replace(/\\/g, "\\\\").replace(/:/g, "\\:");

package/src/react/renderers/packshot/blinking-button.ts

@@ -4,7 +4,6 @@ import type {
   FFmpegBackend,
   FFmpegOutput,
 } from "../../../ai-sdk/providers/editly/backends/types";
-import { uploadBuffer } from "../../../providers/storage";
 
 export interface BlinkingButtonOptions {
   text: string;
@@ -107,18 +106,15 @@ function oscExpr(tv: string, P: number): string {
 }
 
 /**
- * Resolve a local file path to a URL for cloud backends.
+ * Resolve a local file path to a string path/URL via the backend.
  * Local backend: returns the path as-is.
- * Cloud backend: uploads the file and returns the URL.
+ * Cloud backend (Rendi): uploads via its StorageProvider and returns the URL.
  */
 async function resolvePathForBackend(
   localPath: string,
   backend: FFmpegBackend,
 ): Promise<string> {
-  if (backend.name === "local") return localPath;
-  const buffer = await Bun.file(localPath).arrayBuffer();
-  const key = `tmp/${Date.now()}-${localPath.split("/").pop()}`;
-  return uploadBuffer(buffer, key, "image/png");
+  return backend.resolvePath(localPath);
 }
 
 // ─── Main ────────────────────────────────────────────────────────────────────

package/src/react/renderers/packshot.ts

@@ -1,5 +1,8 @@
 import { editly } from "../../ai-sdk/providers/editly";
-import type { FFmpegOutput } from "../../ai-sdk/providers/editly/backends/types";
+import type {
+  FFmpegBackend,
+  FFmpegOutput,
+} from "../../ai-sdk/providers/editly/backends/types";
 import type {
   Clip,
   ImageOverlayLayer,
@@ -9,27 +12,21 @@ import type {
   SizeValue,
   TitleLayer,
 } from "../../ai-sdk/providers/editly/types";
-import { uploadBuffer } from "../../providers/storage";
 import type { PackshotProps, VargElement } from "../types";
 import type { RenderContext } from "./context";
 import { renderImage } from "./image";
 import { createBlinkingButton } from "./packshot/blinking-button";
 
 /**
- * Resolve an FFmpegOutput to a string path/URL, uploading local files for cloud backends.
+ * Resolve an FFmpegOutput to a string path/URL via the backend.
+ * Local backend returns local paths; cloud backends upload and return URLs.
  */
 async function resolveInputMaybeUpload(
   input: FFmpegOutput,
-  shouldUpload: boolean,
+  backend: FFmpegBackend,
 ): Promise<string> {
   if (input.type === "url") return input.url;
-  if (!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",
-  );
+  return backend.resolvePath(input.path);
 }
 
 /**
@@ -207,12 +204,11 @@ export async function renderPackshot(
     );
 
     // Composite button overlay at correct position on base video via backend
-    const isCloud = ctx.backend.name !== "local";
     const baseInput = await resolveInputMaybeUpload(
       { type: "file", path: basePath },
-      isCloud,
+      ctx.backend,
     );
-    const btnInput = await resolveInputMaybeUpload(btn.output, isCloud);
+    const btnInput = await resolveInputMaybeUpload(btn.output, ctx.backend);
 
     const finalPath = `/tmp/varg-packshot-final-${Date.now()}.mp4`;