Update server.js

server.js

@@ -56,28 +56,80 @@ app.post('/render', async (req, res) => {
                 webpackOverride: (config) => config,
             });
 
+            // --- STABILITY: Pre-download Assets ---
+            // To prevent "server sent no data" timeouts and reduce RAM usage,
+            // we download all assets to disk BEFORE starting the render.
+
+            const fs = await import('fs');
+            const { pipeline } = await import('stream/promises');
+            const { createWriteStream } = await import('fs');
+
+            // Helper: Robust Downloader with Retries
+            const downloadAsset = async (url, destPath, retries = 3) => {
+                for (let i = 0; i < retries; i++) {
+                    try {
+                        const response = await fetch(url);
+                        if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+                        if (!response.body) throw new Error(`No body for ${url}`);
+
+                        await pipeline(response.body, createWriteStream(destPath));
+                        return; // Success
+                    } catch (err) {
+                        console.warn(`[Download] Attempt ${i + 1} failed for ${url}: ${err.message}`);
+                        if (i === retries - 1) throw err; // Throw on last failure
+                        await new Promise(r => setTimeout(r, 2000 * (i + 1))); // Backoff
+                    }
+                }
+            };
+
+            const tempDir = join(tmpdir(), `remotion-${randomUUID()}`);
+            await mkdir(tempDir, { recursive: true });
+
+            console.log(`[Render] Pre-downloading assets to ${tempDir}...`);
+
+            // Iterate scenes and download assets
+            const localScenes = await Promise.all(scenes.map(async (scene, idx) => {
+                const newScene = { ...scene };
+
+                // 1. Audio
+                if (scene.audio_url) {
+                    const audioExt = scene.audio_url.split('.').pop().split('?')[0] || 'mp3';
+                    const localAudioPath = join(tempDir, `audio_${idx}.${audioExt}`);
+                    await downloadAsset(scene.audio_url, localAudioPath);
+                    newScene.audio_url = `file://${localAudioPath}`;
+                }
+
+                // 2. Video / Image
+                if (scene.image_url) {
+                    // Check if it's a video (likely from Pexels/Supabase)
+                    const isVideo = scene.media_type === 'video' || scene.image_url.includes('.mp4');
+
+                    const ext = isVideo ? 'mp4' : 'jpg'; // Default extension if unknown
+                    const localMediaPath = join(tempDir, `visual_${idx}.${ext}`);
+
+                    await downloadAsset(scene.image_url, localMediaPath);
+                    newScene.image_url = `file://${localMediaPath}`;
+                }
+
+                return newScene;
+            }));
+
+            console.log(`[Render] Assets downloaded. Starting engine...`);
+
+            // --------------------------------------
+
             const composition = await selectComposition({
                 serveUrl: bundleLocation,
                 id: 'Main',
-                inputProps: { scenes, settings },
+                inputProps: { scenes: localScenes, settings }, // Use LOCAL scenes
                 chromiumOptions: { executablePath: process.env.CHROME_BIN },
             });
 
-            const tempDir = join(tmpdir(), `remotion-${randomUUID()}`);
-            await mkdir(tempDir, { recursive: true });
             const outputPath = join(tempDir, 'output.mp4');
 
             const os = await import('os');
             const cpuCount = os.cpus().length;
-            console.log(`[Render] Detected ${cpuCount} CPUs. Using all cores for rendering.`);
-
-            // Tuning for CPU Only
-            // Remotion is CPU-bound. Concurrency = CPU Cores is usually good, 
-            // but we leave 1 core for OS/Orchestration.
-            const safeConcurrency = 1;
-            console.log(`[Render] Requesting concurrency: ${safeConcurrency} (Host has ${cpuCount})`);
-
-            let lastLog = 0;
+            console.log(`[Render] Detected ${cpuCount} CPUs.`);
 
             await renderMedia({
                 composition,
@@ -87,24 +139,20 @@ app.post('/render', async (req, res) => {
                 outputLocation: outputPath,
                 imageFormat: 'jpeg',
                 jpegQuality: 80,
-                inputProps: { scenes, settings },
+                inputProps: { scenes: localScenes, settings }, // Use LOCAL scenes
                 chromiumOptions: {
                     executablePath: process.env.CHROME_BIN || '/usr/bin/google-chrome-stable',
                     enableMultiProcessRendering: true,
                     args: ['--no-sandbox', '--disable-dev-shm-usage', '--disable-software-rasterizer']
                 },
+                // STRICT CONCURRENCY FOR STABILITY
                 concurrency: 1,
                 disallowParallelEncoding: false,
-                timeoutInMilliseconds: 300000, // 5 minutes timeout for slow downloads
                 onProgress: ({ progress }) => {
                     const percent = Math.round(progress * 100);
-                    // Log every 1%
-                    if (percent - lastLog >= 1 || percent === 100) {
-                        console.log(`[Render] Progress: ${percent}%`);
-                        lastLog = percent;
-                    }
+                    // Log to console (Supabase doesn't need realtime logs, just status)
+                    if (percent % 10 === 0) console.log(`[Render] Progress: ${percent}%`);
                 },
-                // Default software encoder (libx264) is robust and decent speed on high CPU
             });
 
             console.log(`[Render] Render complete. Uploading to Supabase...`);
@@ -115,7 +163,7 @@ app.post('/render', async (req, res) => {
             const fileName = `${projectId}/video-${Date.now()}.mp4`;
             const { data: uploadData, error: uploadError } = await supabase
                 .storage
-                .from('projects') // Assuming 'projects' bucket exists
+                .from('projects')
                 .upload(fileName, videoBuffer, {
                     contentType: 'video/mp4',
                     upsert: true