vargai 0.4.0-alpha77 → 0.4.0-alpha79

package/package.json

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

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

@@ -419,6 +419,8 @@ interface TimedTextLayer {
   layer: TextLayer;
   startTime: number;
   duration: number;
+  transitionInDuration: number;
+  transitionOutDuration: number;
 }
 
 function collectTextLayers(clips: ProcessedClip[]): TimedTextLayer[] {
@@ -429,12 +431,19 @@ function collectTextLayers(clips: ProcessedClip[]): TimedTextLayer[] {
     const clip = clips[i];
     if (!clip) continue;
 
+    const transitionInDuration =
+      i > 0 ? (clips[i - 1]?.transition.duration ?? 0) : 0;
+    const transitionOutDuration =
+      i < clips.length - 1 ? clip.transition.duration : 0;
+
     for (const layer of clip.layers) {
       if (layer && isTextOverlayLayer(layer)) {
         textLayers.push({
           layer: layer as TextLayer,
           startTime: currentTime,
           duration: clip.duration,
+          transitionInDuration,
+          transitionOutDuration,
         });
       }
     }
@@ -845,13 +854,23 @@ export async function editly(config: EditlyConfig): Promise<EditlyResult> {
       const timedLayer = textLayers[i];
       if (!timedLayer) continue;
 
-      const { layer, startTime, duration } = timedLayer;
+      const {
+        layer,
+        startTime,
+        duration,
+        transitionInDuration,
+        transitionOutDuration,
+      } = timedLayer;
       const outputLabel = `vwithtext${i}`;
 
+      // Shrink text visibility to avoid overlap during transitions
+      const effectiveStart = startTime + transitionInDuration;
+      const effectiveStop = startTime + duration - transitionOutDuration;
+
       const timedLayerWithEnable = {
         ...layer,
-        start: layer.start ?? startTime,
-        stop: layer.stop ?? startTime + duration,
+        start: layer.start != null ? layer.start + startTime : effectiveStart,
+        stop: layer.stop != null ? layer.stop + startTime : effectiveStop,
       };
 
       if (layer.type === "title") {

package/src/ai-sdk/providers/fal.ts

@@ -145,11 +145,21 @@ const VIDEO_MODELS: Record<string, { t2v: string; i2v: string }> = {
     t2v: "xai/grok-imagine-video/text-to-video",
     i2v: "xai/grok-imagine-video/image-to-video",
   },
+  // Sora 2 - OpenAI's video model via fal (t2v + i2v, with audio)
+  "sora-2": {
+    t2v: "fal-ai/sora-2/text-to-video",
+    i2v: "fal-ai/sora-2/image-to-video",
+  },
+  "sora-2-pro": {
+    t2v: "fal-ai/sora-2/text-to-video/pro",
+    i2v: "fal-ai/sora-2/image-to-video/pro",
+  },
 };
 
 // Video edit models - video-to-video editing
 const VIDEO_EDIT_MODELS: Record<string, string> = {
   "grok-imagine-edit": "xai/grok-imagine-video/edit-video",
+  "sora-2-remix": "fal-ai/sora-2/video-to-video/remix",
 };
 
 // Motion control models - video-to-video with motion transfer
@@ -183,6 +193,9 @@ const IMAGE_MODELS: Record<string, string> = {
   "qwen-image-2/edit": "fal-ai/qwen-image-2/edit",
   "qwen-image-2-pro": "fal-ai/qwen-image-2/pro/text-to-image",
   "qwen-image-2-pro/edit": "fal-ai/qwen-image-2/pro/edit",
+  // Grok Imagine Image - xAI text-to-image and image editing
+  "grok-imagine-image": "xai/grok-imagine-image",
+  "grok-imagine-image/edit": "xai/grok-imagine-image/edit",
   // Qwen Image Edit 2511 Multiple Angles - camera angle adjustment
   "qwen-angles": "fal-ai/qwen-image-edit-2511-multiple-angles",
   // Recraft V4 Pro - text-to-image
@@ -479,6 +492,7 @@ class FalVideoModel implements VideoModelV3 {
     const isKlingV26 = this.modelId === "kling-v2.6";
     const isLtx2 = this.modelId === "ltx-2-19b-distilled";
     const isGrokImagine = this.modelId === "grok-imagine";
+    const isSora2 = this.modelId === "sora-2" || this.modelId === "sora-2-pro";
 
     const fileHashes = await computeFileHashes(files as ImageModelV3File[]);
 
@@ -591,6 +605,23 @@ class FalVideoModel implements VideoModelV3 {
         if (!input.resolution) {
           input.resolution = "720p";
         }
+      } else if (isSora2) {
+        // Sora 2: only supports 4, 8, 12, 16, 20 second durations
+        const allowedDurations = [4, 8, 12, 16, 20];
+        const d = duration ?? 4;
+        if (!allowedDurations.includes(d)) {
+          warnings.push({
+            type: "other",
+            message: `Sora 2 only supports durations: ${allowedDurations.join(", ")}s. Got ${d}s, defaulting to 4s.`,
+          });
+          input.duration = 4;
+        } else {
+          input.duration = d;
+        }
+        // Disable video deletion so generated video URLs remain accessible
+        if (input.delete_video === undefined) {
+          input.delete_video = false;
+        }
       } else {
         input.duration = duration ?? 5;
       }

package/src/react/renderers/utils.ts

@@ -1,5 +1,6 @@
 import { existsSync, statSync } from "node:fs";
 import { resolve } from "node:path";
+import { ResolvedElement } from "../resolved-element";
 import type { VargElement, VargNode } from "../types";
 
 export function resolvePath(path: string): string {
@@ -84,11 +85,22 @@ function serializeValue(v: unknown): string {
     }
     return v;
   }
+  // Never put raw binary data in cache keys — use semantic identity instead.
+  // Audio segments can be 48-110KB; base64-encoding them would exceed
+  // Upstash Redis' 32KB key size limit.
   if (v instanceof Uint8Array) {
-    // 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)}`;
+    return `uint8:${v.byteLength}`;
+  }
+  // ResolvedElement (e.g. a speech segment used as Video audio input):
+  // serialize by content identity (type + text + duration), not binary data.
+  if (v instanceof ResolvedElement) {
+    const parts = [v.type];
+    for (const child of v.children) {
+      if (typeof child === "string") parts.push(child);
+    }
+    if (v.meta.duration) parts.push(String(v.meta.duration));
+    if (v.meta.file?.url) parts.push(v.meta.file.url);
+    return `resolved(${parts.join(",")})`;
   }
   if (isVargElement(v)) {
     return `element:${computeCacheKey(v).join(":")}`;
@@ -97,6 +109,12 @@ function serializeValue(v: unknown): string {
     return `[${v.map(serializeValue).join(",")}]`;
   }
   if (v && typeof v === "object") {
+    // Skip File-like objects with binary data — use URL if available
+    if ("_data" in v && "_mediaType" in v) {
+      const url = (v as { _url?: string | null })._url;
+      const mediaType = (v as { _mediaType: string })._mediaType;
+      return url ? `file(${url})` : `file(${mediaType})`;
+    }
     const entries = Object.entries(v)
       .map(([key, val]) => `${key}:${serializeValue(val)}`)
       .join(",");
@@ -134,7 +152,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, `uint8:${v.byteLength}:${Bun.hash(v).toString(16)}`);
+      key.push(k, `uint8:${v.byteLength}`);
     } else if (isVargElement(v)) {
       key.push(k, ...computeCacheKey(v));
     } else if (Array.isArray(v) || typeof v === "object") {

package/src/react/resolve.ts

@@ -187,6 +187,12 @@ async function sliceSegments(
     descriptors.map(async (desc) => {
       const bytes = await sliceAudio(fullFile, desc.start, desc.end);
       const segmentFile = File.fromBuffer(bytes, "audio/mpeg");
+      // Upload segment to storage so downstream cache keys use the URL
+      // instead of serializing raw audio bytes (which can exceed Redis key limits).
+      const ctx = getResolveContext();
+      if (ctx?.storage) {
+        await segmentFile.upload(ctx.storage);
+      }
 
       // Rebase word timings relative to the segment's sliced audio (t=0)
       const segmentWords = allWords