vargai 0.4.0-alpha75 → 0.4.0-alpha77

package/package.json

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

package/src/react/renderers/utils.ts

@@ -85,7 +85,13 @@ function serializeValue(v: unknown): string {
     return v;
   }
   if (v instanceof Uint8Array) {
-    return Buffer.from(v).toString("base64");
+    // Hash binary data instead of base64-encoding to keep cache keys small.
+    // Raw base64 can produce 65-110KB strings for audio segments, exceeding
+    // Upstash Redis' 32KB key size limit.
+    return `uint8:${v.byteLength}:${Bun.hash(v).toString(16)}`;
+  }
+  if (isVargElement(v)) {
+    return `element:${computeCacheKey(v).join(":")}`;
   }
   if (Array.isArray(v)) {
     return `[${v.map(serializeValue).join(",")}]`;
@@ -128,7 +134,7 @@ export function computeCacheKey(element: VargElement): CacheKeyPart[] {
     } else if (v === null || v === undefined) {
       key.push(k, v);
     } else if (v instanceof Uint8Array) {
-      key.push(k, Buffer.from(v).toString("base64"));
+      key.push(k, `uint8:${v.byteLength}:${Bun.hash(v).toString(16)}`);
     } else if (isVargElement(v)) {
       key.push(k, ...computeCacheKey(v));
     } else if (Array.isArray(v) || typeof v === "object") {

package/src/react/resolve.ts

@@ -221,6 +221,10 @@ async function sliceSegments(
  *
  * Adds a small safety padding (50ms) to capture any trailing silence
  * that exists in the original audio beyond the segment boundary.
+ *
+ * Routes through the FFmpegBackend when available (local or cloud/Rendi),
+ * falling back to a direct local `ffmpeg` shell command only when no
+ * backend exists (top-level `await` outside render()).
  */
 const SLICE_PADDING_S = 0.05; // 50ms safety padding
 
@@ -234,18 +238,45 @@ async function sliceAudio(
   const suffix = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
   const outPath = `/tmp/varg-segment-${suffix}.mp3`;
 
-  const inputPath = ctx?.backend
-    ? await ctx.backend.resolvePath(file)
-    : await file.toTempFile();
+  if (ctx?.backend) {
+    // Use the backend abstraction (works for both local ffmpeg and cloud/Rendi).
+    // -ss goes in input options (before -i for fast seek).
+    const result = await ctx.backend.run({
+      inputs: [{ path: file, options: ["-ss", String(start)] }],
+      outputArgs: [
+        "-t",
+        String(duration),
+        "-acodec",
+        "libmp3lame",
+        "-q:a",
+        "2",
+      ],
+      outputPath: outPath,
+    });
+
+    // Rendi returns a URL, local backend returns a file path.
+    if (result.output.type === "url") {
+      const response = await fetch(result.output.url);
+      return new Uint8Array(await response.arrayBuffer());
+    }
+    const sliced = await Bun.file(result.output.path).arrayBuffer();
+    try {
+      await Bun.file(result.output.path).delete?.();
+    } catch {
+      /* ignore cleanup errors */
+    }
+    return new Uint8Array(sliced);
+  }
 
-  // -ss before -i for fast seek, then re-encode for sample-accurate cut
+  // Fallback: no backend (top-level `await` outside render()) — use local ffmpeg directly.
+  const inputPath = await file.toTempFile();
   await $`ffmpeg -y -ss ${start} -i ${inputPath} -t ${duration} -acodec libmp3lame -q:a 2 ${outPath}`.quiet();
 
   const sliced = await Bun.file(outPath).arrayBuffer();
   try {
     await Bun.file(outPath).delete?.();
   } catch {
-    /* ignore */
+    /* ignore cleanup errors */
   }
   return new Uint8Array(sliced);
 }