ok! now, time to debug and build the frontend..

.gitignore

@@ -3,7 +3,5 @@ node_modules
 *.bin
 .DS_Store
 .venv
-./database/completed/*.json
-./database/pending/*.json
 *.mp4
 sandbox

database/pending/README.md

@@ -1 +0,0 @@
-Completed tasks go here

package.json

@@ -7,7 +7,7 @@
     "start": "node --loader ts-node/esm src/index.mts",
     "test:submitVideo": "node --loader ts-node/esm src/tests/submitVideo.mts",
     "test:checkStatus": "node --loader ts-node/esm src/tests/checkStatus.mts",
-    "test:downloadVideo": "node --loader ts-node/esm src/tests/downloadVideo.mts",
+    "test:downloadFileToTmp": "node --loader ts-node/esm src/tests/downloadFileToTmp.mts",
     "test:stuff": "node --loader ts-node/esm src/stuff.mts",
     "docker": "npm run docker:build && npm run docker:run",
     "docker:build": "docker build -t videochain-api .",

src/config.mts

@@ -6,9 +6,9 @@ export const tasksDirPath = path.join(storagePath, "tasks")
 export const pendingTasksDirFilePath = path.join(tasksDirPath, "pending")
 export const completedTasksDirFilePath =  path.join(tasksDirPath, "completed")
 
-export const videosDirPath = path.join(storagePath, "videos")
-export const pendingVideosDirFilePath = path.join(videosDirPath, "pending")
-export const completedVideosDirFilePath =  path.join(videosDirPath, "completed")
+export const filesDirPath = path.join(storagePath, "files")
+export const pendingFilesDirFilePath = path.join(filesDirPath, "pending")
+export const completedFilesDirFilePath =  path.join(filesDirPath, "completed")
 
 export const shotFormatVersion = 1
 export const sequenceFormatVersion = 1

src/index.mts

@@ -1,12 +1,15 @@
-import { createReadStream, promises as fs } from "fs"
+import { createReadStream, existsSync } from "node:fs"
+import path from "node:path"
 
 import express from "express"
 
 import { VideoTask, VideoSequenceRequest } from "./types.mts"
 import { parseVideoRequest } from "./utils/parseVideoRequest.mts"
-import { savePendingTask } from "./database/savePendingTask.mts"
-import { getTask } from "./database/getTask.mts"
+import { savePendingTask } from "./scheduler/savePendingTask.mts"
+import { getTask } from "./scheduler/getTask.mts"
 import { main } from "./main.mts"
+import { completedFilesDirFilePath } from "./config.mts"
+import { deleteTask } from "./scheduler/deleteTask.mts"
 
 main()
 
@@ -57,8 +60,6 @@ app.post("/", async (req, res) => {
 app.get("/:id", async (req, res) => {
   try {
     const task = await getTask(req.params.id)
-    delete task.finalFilePath
-    delete task.tmpFilePath
     res.status(200)
     res.write(JSON.stringify(task))
     res.end()
@@ -70,6 +71,30 @@ app.get("/:id", async (req, res) => {
   }
 })
 
+app.delete("/:id", async (req, res) => {
+  let task: VideoTask = null
+  try {
+    task = await getTask(req.params.id)
+  } catch (err) {
+    console.error(err)
+    res.status(404)
+    res.write(JSON.stringify({ error: "couldn't find this task" }))
+    res.end()
+  }
+
+  try {
+    await deleteTask(task)
+    res.status(200)
+    res.write(JSON.stringify({ success: true }))
+    res.end()
+  } catch (err) {
+    console.error(err)
+    res.status(500)
+    res.write(JSON.stringify({ success: false, error: "failed to delete the task" }))
+    res.end()
+  }
+})
+
 app.get("/video/:id\.mp4", async (req, res) => {
   if (!req.params.id) {
     res.status(400)
@@ -89,8 +114,11 @@ app.get("/video/:id\.mp4", async (req, res) => {
     return
   }
 
+  const completedFilePath = path.join(completedFilesDirFilePath, task.fileName)
 
-  const filePath = task.finalFilePath || task.tmpFilePath || ''
+  // note: we DON'T want to use the pending file path, as there may be operations on it
+  // (ie. a process might be busy writing stuff to it)
+  const filePath = existsSync(completedFilePath) ? completedFilePath : ""
   if (!filePath) {
     res.status(400)
     res.write(JSON.stringify({ error: "video exists, but cannot be previewed yet" }))

src/initFolders.mts

@@ -0,0 +1,12 @@
+import { tasksDirPath, pendingTasksDirFilePath, completedTasksDirFilePath, filesDirPath, pendingFilesDirFilePath, completedFilesDirFilePath } from "./config.mts"
+import { createDirIfNeeded } from "./utils/createDirIfNeeded.mts"
+
+export const initFolders = () => {
+  console.log(`initializing folders..`)
+  createDirIfNeeded(tasksDirPath)
+  createDirIfNeeded(pendingTasksDirFilePath)
+  createDirIfNeeded(completedTasksDirFilePath)
+  createDirIfNeeded(filesDirPath)
+  createDirIfNeeded(pendingFilesDirFilePath)
+  createDirIfNeeded(completedFilesDirFilePath)
+}

src/main.mts

@@ -1,7 +1,11 @@
-import { getPendingTasks } from "./database/getPendingTasks.mts"
-import { processTask } from "./services/processTask.mts"
+import { initFolders } from "./initFolders.mts"
+import { getPendingTasks } from "./scheduler/getPendingTasks.mts"
+import { processTask } from "./scheduler/processTask.mts"
+
+initFolders()
 
 export const main = async () => {
+
   const tasks = await getPendingTasks()
   if (!tasks.length) {
     setTimeout(() => {

src/{services → production}/addAudioToVideo.mts

@@ -5,6 +5,8 @@ import tmpDir from "temp-dir"
 import { v4 as uuidv4 } from "uuid"
 
 import ffmpeg from "fluent-ffmpeg"
+import { pendingFilesDirFilePath } from "../config.mts"
+import { moveFile } from "../utils/moveFile.mts"
 
 export const addAudioToVideo = async (
   videoFileName: string,
@@ -17,14 +19,12 @@ export const addAudioToVideo = async (
   * 2.0: amplify the audio to 200% of original volume (double volume - might cause clipping)
   */
   volume: number = 1.0
-): Promise<string> => {
-  
-  const tempOutputFilePath = `${uuidv4()}.mp4`
-  const videoFilePath = path.resolve(tmpDir, videoFileName)
+) => {
+  const tempOutputFilePath = path.join(tmpDir, `${uuidv4()}.mp4`)
   const audioFilePath = path.resolve(tmpDir, audioFileName)
 
   await new Promise((resolve, reject) => {
-    ffmpeg(videoFilePath)
+    ffmpeg(videoFileName)
       .input(audioFilePath)
       .audioFilters({ filter: 'volume', options: volume }) // add audio filter for volume
       .outputOptions("-c:v copy")  // use video copy codec
@@ -39,7 +39,5 @@ export const addAudioToVideo = async (
   })
 
   // Now we want to replace the original video file with the new file that has been created
-  await fs.rename(tempOutputFilePath, videoFilePath)
-
-  return videoFileName
+  await moveFile(tempOutputFilePath, videoFileName)
 };

src/production/assembleShots.mts

@@ -0,0 +1,53 @@
+import path from "node:path"
+
+import concat from 'ffmpeg-concat'
+
+import { VideoShot } from '../types.mts'
+import { pendingFilesDirFilePath } from "../config.mts"
+
+export const assembleShots = async (shots: VideoShot[], fileName: string) => {
+
+  if (!Array.isArray(shots) || shots.length < 2) {
+    throw new Error(`need at least 2 shots`)
+  }
+
+  const transitions = [
+    {
+      name: 'circleOpen',
+      duration: 1000,
+    },
+    {
+      name: 'crossWarp',
+      duration: 800,
+    },
+    {
+      name: 'directionalWarp',
+      duration: 800,
+      // pass custom params to a transition
+      params: { direction: [1, -1] },
+    },
+    /*
+    {
+      name: 'squaresWire',
+      duration: 2000,
+    },
+    */
+  ]
+
+  const videoFilePath = path.join(pendingFilesDirFilePath, fileName)
+
+  const shotFilesPaths = shots.map(shot => path.join(
+    pendingFilesDirFilePath,
+    shot.fileName
+  ))
+
+  await concat({
+    output: videoFilePath,
+    videos: shotFilesPaths,
+    transitions: shotFilesPaths
+      .slice(0, shotFilesPaths.length - 1)
+      .map(
+        (vid) => transitions[Math.floor(Math.random() * transitions.length)]
+      ),
+  })
+}

src/{services → production}/generateAudio.mts

@@ -1,5 +1,11 @@
+import path from "node:path"
+
+import { v4 as uuidv4 } from "uuid"
+import tmpDir from "temp-dir"
 import puppeteer from "puppeteer"
-import { downloadVideo } from "./downloadVideo.mts"
+
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
+import { moveFileFromTmpToPending } from "../utils/moveFileFromTmpToPending.mts"
 
 const instances: string[] = [
   process.env.VS_AUDIO_GENERATION_SPACE_API_URL
@@ -42,15 +48,11 @@ export async function generateAudio(prompt: string, audioFileName: string) {
   const audioRemoteUrl = await page.$$eval("a[download]", el => el.map(x => x.getAttribute("href"))[0])
 
 
-  console.log({
-    audioRemoteUrl,
-  })
-
-
-  // console.log("downloading file from space..")
-  console.log(`- downloading ${audioFileName} from ${audioRemoteUrl}`)
-
-  await downloadVideo(audioRemoteUrl, audioFileName)
+  // it is always a good idea to download to a tmp dir before saving to the pending dir
+  // because there is always a risk that the download will fail
+  
+  const tmpFileName = `${uuidv4()}.mp4`
 
-  return audioFileName
+  await downloadFileToTmp(audioRemoteUrl, tmpFileName)
+  await moveFileFromTmpToPending(tmpFileName, audioFileName)
 }

src/{services → production}/generateAudioLegacy.mts

@@ -1,6 +1,6 @@
 import { client } from '@gradio/client'
 
-import { generateSeed } from "./generateSeed.mts"
+import { generateSeed } from "../utils/generateSeed.mts"
 
 const instances: string[] = [
   process.env.VS_AUDIO_GENERATION_SPACE_API_URL

src/{services → production}/generateShot.mts

@@ -3,12 +3,12 @@ import path from "node:path"
 import { v4 as uuidv4 } from "uuid"
 import tmpDir from "temp-dir"
 
-import { downloadVideo } from "./downloadVideo.mts"
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
 import { generateAudio } from "./generateAudio.mts"
 import { generateVideo } from "./generateVideo.mts"
 import { upscaleVideo } from "./upscaleVideo.mts"
 import { generateVoice } from "./generateVoice.mts"
-import { generateSeed } from "./generateSeed.mts"
+import { generateSeed } from "../utils/generateSeed.mts"
 import { mergeAudio } from "./mergeAudio.mts"
 import { addAudioToVideo } from "./addAudioToVideo.mts"
 import { interpolateVideo } from "./interpolateVideo.mts"
@@ -106,7 +106,7 @@ export const generateShot = async ({
 
   console.log("downloading video..")
 
-  const videoFileName = await downloadVideo(generatedVideoUrl, shotFileName)
+  const videoFileName = await downloadFileToTmp(generatedVideoUrl, shotFileName)
 
   if (upscale) {
     console.log("upscaling video..")
@@ -135,7 +135,7 @@ export const generateShot = async ({
     const interpolationSteps = 3
     const interpolatedFramesPerSecond = 24
     await interpolateVideo(
-      videoFileName,
+      task,
       interpolationSteps,
       interpolatedFramesPerSecond
     )
@@ -194,7 +194,7 @@ export const generateShot = async ({
       audioFileName = foregroundAudioFileName
     }
 
-    await addAudioToVideo(videoFileName, audioFileName)
+    await addAudioToVideo(task, audioFileName)
   }
 
   console.log("returning result to user..")

src/{services → production}/generateVideo.mts

@@ -1,7 +1,7 @@
 import { client } from "@gradio/client"
 
 
-import { generateSeed } from "./generateSeed.mts"
+import { generateSeed } from "../utils/generateSeed.mts"
 
 const instances: string[] = [
   process.env.VS_VIDEO_GENERATION_SPACE_API_URL

src/{services → production}/generateVoice.mts

@@ -1,6 +1,6 @@
 import puppeteer from "puppeteer"
 
-import { downloadVideo } from "./downloadVideo.mts"
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
 
 const instances: string[] = [
   process.env.VS_VOICE_GENERATION_SPACE_API_URL
@@ -50,7 +50,7 @@ export async function generateVoice(prompt: string, voiceFileName: string) {
 
   console.log(`- downloading ${voiceFileName} from ${voiceRemoteUrl}`)
 
-  await downloadVideo(voiceRemoteUrl, voiceFileName)
+  await downloadFileToTmp(voiceRemoteUrl, voiceFileName)
 
   return voiceFileName
 }

src/{services → production}/interpolateVideo.mts

@@ -1,17 +1,20 @@
 import path from "node:path"
 
-import puppeteer from "puppeteer"
+import { v4 as uuidv4 } from "uuid"
 import tmpDir from "temp-dir"
-import { downloadVideo } from "./downloadVideo.mts"
+import puppeteer from "puppeteer"
+
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
+import { pendingFilesDirFilePath } from "../config.mts"
+import { moveFileFromTmpToPending } from "../utils/moveFileFromTmpToPending.mts"
 
 const instances: string[] = [
   process.env.VS_VIDEO_INTERPOLATION_SPACE_API_URL
 ]
 
-
 // TODO we should use an inference endpoint instead
 export async function interpolateVideo(fileName: string, steps: number, fps: number) {
-  const inputFilePath = path.join(tmpDir, fileName)
+  const inputFilePath = path.join(pendingFilesDirFilePath, fileName)
 
   console.log(`interpolating ${fileName}`)
   console.log(`warning: interpolateVideo parameter "${steps}" is ignored!`)
@@ -47,7 +50,11 @@ export async function interpolateVideo(fileName: string, steps: number, fps: num
 
   const interpolatedFileUrl = await page.$$eval('a[download="interpolated_result.mp4"]', el => el.map(x => x.getAttribute("href"))[0])
 
-  await downloadVideo(interpolatedFileUrl, fileName)
+  // it is always a good idea to download to a tmp dir before saving to the pending dir
+  // because there is always a risk that the download will fail
+
+  const tmpFileName = `${uuidv4()}.mp4`
 
-  return fileName
+  await downloadFileToTmp(interpolatedFileUrl, tmpFileName)
+  await moveFileFromTmpToPending(tmpFileName, fileName)
 }

src/{services → production}/interpolateVideoLegacy.mts

@@ -5,7 +5,7 @@ import { Blob } from "buffer"
 import { client } from "@gradio/client"
 import tmpDir from "temp-dir"
 
-import { downloadVideo } from './downloadVideo.mts'
+import { downloadFileToTmp } from '../utils/downloadFileToTmp.mts'
 
 const instances: string[] = [
   process.env.VS_VIDEO_INTERPOLATION_SPACE_API_URL
@@ -35,5 +35,5 @@ export const interpolateVideo = async (fileName: string, steps: number, fps: num
   const { orig_name, data: remoteFilePath } = data
   const remoteUrl = `${instance}/file=${remoteFilePath}`
   console.log("remoteUrl:", remoteUrl)
-  await downloadVideo(remoteUrl, fileName)
+  await downloadFileToTmp(remoteUrl, fileName)
 }

src/{services → production}/postInterpolation.mts

@@ -1,11 +1,11 @@
 import path from "node:path"
-import fs from "node:fs"
 
 import { v4 as uuidv4 } from "uuid"
 import tmpDir from "temp-dir"
 import ffmpeg from "fluent-ffmpeg"
+import { moveFileFromTmpToPending } from "../utils/moveFileFromTmpToPending.mts"
 
-export const postInterpolation = async (fileName: string, duration: number, nbFrames: number): Promise<string> => {
+export const postInterpolation = async (fileName: string, durationMs: number, nbFrames: number): Promise<string> => {
   return new Promise((resolve,reject) => {
 
     const tmpFileName = `${uuidv4()}.mp4`
@@ -13,15 +13,20 @@ export const postInterpolation = async (fileName: string, duration: number, nbFr
     const filePath = path.join(tmpDir, fileName)
     const tmpFilePath = path.join(tmpDir, tmpFileName)
 
-
     ffmpeg.ffprobe(filePath, function(err, metadata) {
       if (err) { reject(err); return; }
       
+      const durationInSec = durationMs / 1000
 
-      const currentVideoDuration = metadata.format.duration
-
+      const currentVideoDurationInSec = metadata.format.duration
+      
+      console.log(`target duration in sec: ${currentVideoDurationInSec}s`)
+    
+      console.log(`target duration in sec: ${durationInSec}s (${durationMs}ms)`)
+    
       // compute a ratio ex. 0.3 = 30% of the total length
-      const durationRatio = currentVideoDuration / duration
+      const durationRatio = currentVideoDurationInSec / durationInSec
+      console.log(`durationRatio: ${durationRatio} (${Math.round(durationRatio % 100)}%)`)
 
     ffmpeg(filePath)
 
@@ -40,12 +45,7 @@ export const postInterpolation = async (fileName: string, duration: number, nbFr
 
       .save(tmpFilePath)
       .on("end", async () => {
-        await fs.promises.copyFile(tmpFilePath, filePath)
-        try {
-          await fs.promises.unlink(tmpFilePath)
-        } catch (err) {
-          console.log("failed to cleanup (no big deal..)")
-        }
+        await moveFileFromTmpToPending(tmpFileName, fileName)
 
         resolve(fileName)
       })

src/{services → production}/upscaleVideo.mts

@@ -1,9 +1,12 @@
-import path from 'node:path'
-import fs from 'node:fs'
+import path from "node:path"
 
-import tmpDir from 'temp-dir'
-import puppeteer from 'puppeteer'
-import { downloadVideo } from './downloadVideo.mts'
+import { v4 as uuidv4 } from "uuid"
+import tmpDir from "temp-dir"
+import puppeteer from "puppeteer"
+
+import { downloadFileToTmp } from '../utils/downloadFileToTmp.mts'
+import { pendingFilesDirFilePath } from '../config.mts'
+import { moveFileFromTmpToPending } from "../utils/moveFileFromTmpToPending.mts"
 
 const instances: string[] = [
   process.env.VS_VIDEO_UPSCALE_SPACE_API_URL
@@ -28,7 +31,7 @@ export async function upscaleVideo(fileName: string, prompt: string) {
   const promptField = await page.$('textarea')
   await promptField.type(prompt)
 
-  const inputFilePath = path.join(tmpDir, fileName)
+  const inputFilePath = path.join(pendingFilesDirFilePath, fileName)
   // console.log(`local file to upscale: ${inputFilePath}`)
   
   await new Promise(r => setTimeout(r, 3000))
@@ -59,24 +62,11 @@ export async function upscaleVideo(fileName: string, prompt: string) {
 
   const upscaledFileUrl = await page.$$eval('a[download="xl_result.mp4"]', el => el.map(x => x.getAttribute("href"))[0])
 
-  // console.log('downloading upscaled image from:', upscaledFileUrl)
-
-  const tmpFileName = `${fileName}_xl`
-
-  // console.log('downloading file from space..')
-  console.log(`- downloading ${fileName} from ${upscaledFileUrl}`)
-
-  await downloadVideo(upscaledFileUrl, tmpFileName)
-
-  const tmpFilePath = path.join(tmpDir, tmpFileName)
-  const filePath = path.join(tmpDir, fileName)
-
-  await fs.promises.copyFile(tmpFilePath, filePath)
-  try {
-    await fs.promises.unlink(tmpFilePath)
-  } catch (err) {
-    console.log('failed to cleanup (no big deal..)')
-  }
+  // it is always a good idea to download to a tmp dir before saving to the pending dir
+  // because there is always a risk that the download will fail
+  
+  const tmpFileName = `${uuidv4()}.mp4`
 
-  return fileName
+  await downloadFileToTmp(upscaledFileUrl, tmpFileName)
+  await moveFileFromTmpToPending(tmpFileName, fileName)
 }

src/scheduler/deleteTask.mts

@@ -0,0 +1,33 @@
+
+import { existsSync, promises as fs } from "node:fs"
+import path from "node:path"
+
+import tmpDir from "temp-dir"
+
+import { VideoTask } from "../types.mts"
+import { completedTasksDirFilePath, completedFilesDirFilePath, pendingTasksDirFilePath, pendingFilesDirFilePath } from "../config.mts"
+import { deleteFileIfExists } from "../utils/deleteFileIfExists.mts"
+
+
+export const deleteTask = async (task: VideoTask) => {
+  const taskFileName = `${task.id}.json`
+  const videoFileName = task.fileName
+  
+  // .mp4 files
+  const tmpFilePath = path.join(tmpDir, videoFileName)
+  const pendingVideoPath = path.join(pendingFilesDirFilePath, videoFileName)
+  const completedVideoPath = path.join(completedFilesDirFilePath, videoFileName)
+
+  // .json files
+  const pendingTaskPath = path.join(pendingTasksDirFilePath, taskFileName)
+  const completedTaskPath = path.join(completedTasksDirFilePath, taskFileName)
+
+  await deleteFileIfExists(tmpFilePath)
+  await deleteFileIfExists(pendingVideoPath)
+  await deleteFileIfExists(completedVideoPath)
+  await deleteFileIfExists(pendingTaskPath)
+  await deleteFileIfExists(completedTaskPath)
+
+  // TODO: we didn't delete any audio file!
+  console.log(`note: we didn't delete any audio file!`)
+}

src/{database → scheduler}/getCompletedTasks.mts

@@ -1,5 +1,5 @@
 import { VideoTask } from "../types.mts"
-import { completedTasksDirFilePath } from "./constants.mts"
+import { completedTasksDirFilePath } from "../config.mts"
 import { readTasks } from "./readTasks.mts"
 
 export const getCompletedTasks = async (): Promise<VideoTask[]> => {

src/{database → scheduler}/getPendingTasks.mts

@@ -1,5 +1,5 @@
 import { VideoTask } from "../types.mts"
-import { pendingTasksDirFilePath } from "./constants.mts"
+import { pendingTasksDirFilePath } from "../config.mts"
 import { readTasks } from "./readTasks.mts"
 
 export const getPendingTasks = async (): Promise<VideoTask[]> => {

src/{database → scheduler}/getTask.mts

@@ -1,6 +1,6 @@
 import path from "node:path"
 
-import { completedTasksDirFilePath, pendingTasksDirFilePath } from "./constants.mts"
+import { completedTasksDirFilePath, pendingTasksDirFilePath } from "../config.mts"
 import { readTask } from "./readTask.mts"
 
 export const getTask = async (id: string) => {

src/scheduler/processTask.mts

@@ -0,0 +1,246 @@
+import { saveCompletedTask } from "./saveCompletedTask.mts"
+import { savePendingTask } from "./savePendingTask.mts"
+import { updatePendingTask } from "./updatePendingTask.mts"
+import { VideoShot, VideoTask } from "../types.mts"
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
+import { generateVideo } from "../production/generateVideo.mts"
+import { copyVideoFromTmpToPending } from "../utils/copyVideoFromTmpToPending.mts"
+import { copyVideoFromTmpToCompleted } from "../utils/copyVideoFromTmpToCompleted.mts"
+import { upscaleVideo } from "../production/upscaleVideo.mts"
+import { interpolateVideo } from "../production/interpolateVideo.mts"
+import { postInterpolation } from "../production/postInterpolation.mts"
+import { moveVideoFromPendingToCompleted } from "../utils/moveVideoFromPendingToCompleted.mts"
+import { assembleShots } from "../production/assembleShots.mts"
+
+export const processTask = async (task: VideoTask) => {
+  console.log(`processing video task ${task.id}`)
+
+  // something isn't right, the task is already completed
+  if (task.completed) {
+    console.log(`video task ${task.id} is already completed`)
+    await saveCompletedTask(task)
+    return
+  }
+
+  for (const shot of task.shots) {
+    // skip shots completed previously
+    if (shot.completed) {
+      continue
+    }
+
+    console.log(`need to complete shot ${shot.id}`)
+
+
+    // currenty we cannot generate too many frames at once,
+    // otherwise the upscaler will have trouble
+
+    // so for now, we fix it to 24 frames
+    // const nbFramesForBaseModel = Math.min(3, Math.max(1, Math.round(duration))) * 8
+    const nbFramesForBaseModel = 24
+
+    if (!shot.hasGeneratedPreview) {
+      console.log("generating a preview of the final result..")
+      let generatedPreviewVideoUrl = ""
+      try {
+        generatedPreviewVideoUrl = await generateVideo(shot.shotPrompt, {
+          seed: shot.seed,
+          nbFrames: nbFramesForBaseModel,
+          nbSteps: 10, // for the preview, we only give a rough approximation
+        })
+
+        console.log("downloading preview video..")
+
+        // download to /tmp
+        await downloadFileToTmp(generatedPreviewVideoUrl, shot.fileName)
+
+        // NO NEED to copy from /tmp to /data/pending
+        // await copyVideoFromTmpToPending(shot.fileName)
+
+        // copy from /tmp to /data/completed
+        await copyVideoFromTmpToCompleted(shot.fileName)
+
+        shot.hasGeneratedPreview = true
+        shot.nbCompletedSteps++
+
+        await updatePendingTask(task)
+
+      } catch (err) {
+        console.error(`failed to generate preview for shot ${shot.id} (${err})`)
+        // something is wrong, let's put the whole thing back into the queue
+        task.error = `failed to generate preview for shot ${shot.id} (will try again later)`
+        await updatePendingTask(task)
+        break
+      }
+
+    }
+
+    if (!shot.hasGeneratedVideo) {
+      console.log("generating primordial pixel soup (raw video)..")
+      let generatedVideoUrl = ""
+
+
+      const nbFramesForBaseModel = 24
+
+      try {
+        generatedVideoUrl = await generateVideo(shot.shotPrompt, {
+          seed: shot.seed,
+          nbFrames: nbFramesForBaseModel,
+          nbSteps: shot.steps,
+        })
+
+        console.log("downloading video..")
+
+        await downloadFileToTmp(generatedVideoUrl, shot.fileName)
+
+        await copyVideoFromTmpToPending(shot.fileName)
+
+        shot.hasGeneratedVideo = true
+        shot.nbCompletedSteps++
+
+        await updatePendingTask(task)
+
+      } catch (err) {
+        console.error(`failed to generate shot ${shot.id} (${err})`)
+        // something is wrong, let's put the whole thing back into the queue
+        task.error = `failed to generate shot ${shot.id} (will try again later)`
+        await updatePendingTask(task)
+        break
+      }
+
+    }
+
+    if (!shot.hasUpscaledVideo) {
+      console.log("upscaling video..")
+      try {
+        await upscaleVideo(shot.fileName, shot.shotPrompt)
+
+        shot.hasUpscaledVideo = true
+        shot.nbCompletedSteps++
+
+        await updatePendingTask(task)
+      } catch (err) {
+        console.error(`failed to upscale shot ${shot.id} (${err})`)
+        // something is wrong, let's put the whole thing back into the queue
+        task.error = `failed to upscale shot ${shot.id} (will try again later)`
+        await updatePendingTask(task)
+        break
+      }
+    }
+
+    if (!shot.hasInterpolatedVideo) {
+      console.log("interpolating video..")
+      // ATTENTION 1:
+      // the interpolation step always create a SLOW MOTION video
+      // it means it can last a lot longer (eg. 2x, 3x, 4x.. longer)
+      // than the duration generated by the original video model
+  
+      // ATTENTION 2:
+      // the interpolation step generates videos in 910x512!
+  
+      // ATTENTION 3:
+      // the interpolation step parameters are currently not passed to the space,
+      // so changing those two variables below will have no effect!
+      const interpolationSteps = 3
+      const interpolatedFramesPerSecond = 24
+      console.log('creating slow-mo video (910x512 @ 24 FPS)')
+      try {
+        await interpolateVideo(
+          shot.fileName,
+          interpolationSteps,
+          interpolatedFramesPerSecond
+        )
+
+        shot.hasInterpolatedVideo = true
+        shot.nbCompletedSteps++
+
+        await updatePendingTask(task)
+
+      } catch (err) {
+        console.error(`failed to interpolate shot ${shot.id} (${err})`)
+        // something is wrong, let's put the whole thing back into the queue
+        task.error = `failed to interpolate shot ${shot.id} (will try again later)`
+        await updatePendingTask(task)
+        break
+      }
+    }
+
+      
+    if (!shot.hasPostProcessedVideo) {
+      console.log("post-processing video..")
+     
+    // with our current interpolation settings, the 3 seconds video generated by the model
+    // become a 7 seconds video, at 24 FPS
+  
+    // so we want to scale it back to the desired duration length
+    // also, as a last trick we want to upscale it (without AI) and add some FXs
+    console.log('performing final scaling (1280x720 @ 24 FPS)')
+
+      try {
+        await postInterpolation(shot.fileName, shot.durationMs, shot.fps)
+    
+        shot.hasPostProcessedVideo = true
+        shot.nbCompletedSteps++
+
+        await updatePendingTask(task)
+
+      } catch (err) {
+        console.error(`failed to post-process shot ${shot.id} (${err})`)
+        // something is wrong, let's put the whole thing back into the queue
+        task.error = `failed to post-process shot ${shot.id} (will try again later)`
+        await updatePendingTask(task)
+        break
+      }
+    }
+
+    shot.completed = true
+    shot.completedAt = new Date().toISOString()
+    task.nbCompletedShots++
+
+    await updatePendingTask(task)
+  }
+
+  console.log(`end of the loop:`)
+  console.log(`nb completed shots: ${task.nbCompletedShots}`)
+  
+  if (task.nbCompletedShots === task.nbTotalShots) {
+    console.log(`we have completed the whole video sequence!`)
+    console.log(`assembling the video..`)
+
+    if (task.nbTotalShots === 1) {
+      console.log(`we only have one shot, so this gonna be easy`)
+      task.hasAssembledVideo = true
+
+      // the shot become the final movie
+      await moveVideoFromPendingToCompleted(task.shots[0].fileName, task.fileName)
+
+      await updatePendingTask(task)
+    }
+
+    if (!task.hasAssembledVideo) {
+      console.log(`assembling the ${task.shots.length} shots together (might take a while)`)
+      try {
+        await assembleShots(task.shots, task.fileName)
+        console.log(`finished assembling the ${task.shots.length} shots together!`)
+
+        await moveVideoFromPendingToCompleted(task.fileName)
+
+        task.hasAssembledVideo = true
+
+        await updatePendingTask(task)
+      } catch (err) {
+        console.error(`failed to assemble the shots together (${err})`)
+        // something is wrong, let's put the whole thing back into the queue
+        task.error = `failed to assemble the shots together (will try again later)`
+        await updatePendingTask(task)
+        return
+      }
+    }
+
+    task.completed = true
+    task.completedAt = new Date().toISOString()
+    await updatePendingTask(task)
+
+    console.log(`moving task to completed tasks..`)
+    await saveCompletedTask(task)
+  }
+}

src/{database → scheduler}/saveCompletedTask.mts

@@ -3,11 +3,11 @@ import path from "path"
 
 import { VideoTask } from "../types.mts"
 import { completedTasksDirFilePath, pendingTasksDirFilePath } from "../config.mts"
+import { moveFile } from "../utils/moveFile.mts"
 
 export const saveCompletedTask = async (task: VideoTask) => {
   const fileName = `${task.id}.json`
   const pendingFilePath = path.join(pendingTasksDirFilePath, fileName)
   const completedFilePath = path.join(completedTasksDirFilePath, fileName)
-  await fs.writeFile(completedFilePath, JSON.stringify(task, null, 2), "utf8")
-  await fs.unlink(pendingFilePath)
+  await moveFile(pendingFilePath, completedFilePath)
 }

src/services/processTask.mts

@@ -1,68 +0,0 @@
-import { saveCompletedTask } from "../database/saveCompletedTask.mts";
-import { savePendingTask } from "../database/savePendingTask.mts";
-import { updatePendingTask } from "../database/updatePendingTask.mts";
-import { VideoTask } from "../types.mts";
-import { downloadVideo } from "./downloadVideo.mts";
-import { generateVideo } from "./generateVideo.mts";
-
-export const processTask = async (task: VideoTask) => {
-  console.log(`processing video task ${task.id}`)
-
-  // something isn't right, the task is already completed
-  if (task.completed) {
-    console.log(`video task ${task.id} is already completed`)
-    await saveCompletedTask(task)
-    return
-  }
-
-  let nbCompletedShots = 0
-  for (const shot of task.shots) {
-    // skip completed shots
-    if (shot.completed) {
-      nbCompletedShots++
-      continue
-    }
-
-    console.log(`need to complete shot ${shot.id}`)
-
-    const shotFileName = `${shot.id}.mp4`
-
-    if (!shot.hasGeneratedVideo) {
-      console.log("generating primordial pixel soup (raw video)..")
-      let generatedVideoUrl = ""
-
-      // currenty we cannot generate too many frames at once,
-      // otherwise the upscaler will have trouble
-
-      // so for now, we fix it to 24 frames
-      // const nbFramesForBaseModel = Math.min(3, Math.max(1, Math.round(duration))) * 8
-      const nbFramesForBaseModel = 24
-
-      try {
-        generatedVideoUrl = await generateVideo(shot.shotPrompt, {
-          seed: shot.seed,
-          nbFrames: nbFramesForBaseModel,
-          nbSteps: shot.steps,
-        })
-
-        console.log("downloading video..")
-
-        await downloadVideo(generatedVideoUrl, shotFileName)
-
-      } catch (err) {
-        // something is wrong, let's put the whole thing back into the queue
-        task.error = `failed to generate shot ${shot.id} (will try again later)`
-        await updatePendingTask(task)
-        break
-      }
-
-      
-    }
-
-    if (!shot.hasUpscaledVideo) {
-
-    }
-
-  }
-
-}

src/types.mts

@@ -102,9 +102,6 @@ export type VideoTransition =
 
 
 export interface VideoShotMeta {
-  // must be unique
-  id: string
-
   shotPrompt: string
   // inputVideo?: string
 
@@ -135,24 +132,20 @@ export interface VideoShotMeta {
 
   introTransition: VideoTransition
   introDurationMs: number // in milliseconds
-
-  // for internal use
-  hasGeneratedVideo: boolean
-  hasUpscaledVideo: boolean
-  hasGeneratedBackgroundAudio: boolean
-  hasGeneratedForegroundAudio: boolean
-  hasGeneratedActor: boolean
-  hasInterpolatedVideo: boolean
-  hasAddedAudio: boolean
-  hasPostProcessedVideo: boolean
 }
 
 
 export interface VideoShotData {
+  // must be unique
+  id: string
+
+  fileName: string
 
   // used to check compatibility
   version: number
 
+  // for internal use
+  hasGeneratedPreview: boolean
   hasGeneratedVideo: boolean
   hasUpscaledVideo: boolean
   hasGeneratedBackgroundAudio: boolean
@@ -167,14 +160,11 @@ export interface VideoShotData {
   completedAt: string
   completed: boolean
   error: string
-  filePath: string
 }
 
 export type VideoShot = VideoShotMeta & VideoShotData
 
 export interface VideoSequenceMeta {
-  // must be unique
-  id: string
 
   // describe the whole movie
   videoPrompt: string
@@ -198,7 +188,7 @@ export interface VideoSequenceMeta {
 
   noise: boolean // add movie noise
 
-  steps: number
+  steps: number // between 10 and 50
 
   fps: number // 8, 12, 24, 30, 60
 
@@ -210,17 +200,21 @@ export interface VideoSequenceMeta {
 
 
 export interface VideoSequenceData {
+  // must be unique
+  id: string
+  
+  fileName: string
 
   // used to check compatibility
   version: number
 
+  hasAssembledVideo: boolean
   nbCompletedShots: number
   nbTotalShots: number
   progressPercent: number
   completedAt: string
   completed: boolean
   error: string
-  filePath: string
 }
 
 export type VideoSequence = VideoSequenceMeta & VideoSequenceData

src/utils/copyVideoFromPendingToCompleted.mts

@@ -0,0 +1,15 @@
+import path from "node:path"
+import { promises as fs } from "node:fs"
+
+import { completedTasksDirFilePath, pendingFilesDirFilePath } from "../config.mts"
+
+export const copyVideoFromPendingToCompleted = async (pendingFileName: string, completedFileName?: string) => {
+  if (!completedFileName) {
+    completedFileName = pendingFileName
+  }
+  const pendingFilePath = path.join(pendingFilesDirFilePath, pendingFileName)
+  const completedFilePath = path.join(completedTasksDirFilePath, completedFileName)
+
+  await fs.copyFile(pendingFilePath, completedFilePath)
+  console.log(`copied file from ${pendingFilePath} to ${completedFilePath}`)
+}

src/utils/copyVideoFromTmpToCompleted.mts

@@ -0,0 +1,20 @@
+import path from "node:path"
+import { promises as fs } from "node:fs"
+
+import tmpDir from "temp-dir"
+import { completedFilesDirFilePath } from "../config.mts"
+
+// a function to copy a video to the completed video directory
+// this implementation is safe to use on a Hugging Face Space
+// for instance when copying from one disk to another
+// (we cannot use fs.rename in that case)
+export const copyVideoFromTmpToCompleted = async (tmpFileName: string, completedFileName?: string) => {
+  if (!completedFileName) {
+    completedFileName = tmpFileName
+  }
+  const tmpFilePath = path.join(tmpDir, tmpFileName)
+  const completedFilePath = path.join(completedFilesDirFilePath, completedFileName)
+
+  await fs.copyFile(tmpFilePath, completedFilePath)
+  console.log(`copied file from ${tmpFilePath} to ${completedFilePath}`)
+}

src/utils/copyVideoFromTmpToPending.mts

@@ -0,0 +1,21 @@
+import path from "node:path"
+import { promises as fs } from "node:fs"
+
+import tmpDir from "temp-dir"
+import { pendingFilesDirFilePath } from "../config.mts"
+import { moveFile } from "./moveFile.mts"
+
+// a function to copy a video to the pending video directory
+// this implementation is safe to use on a Hugging Face Space
+// for instance when copying from one disk to another
+// (we cannot use fs.rename in that case)
+export const copyVideoFromTmpToPending = async (tmpFileName: string, pendingFileName?: string) => {
+  if (!pendingFileName) {
+    pendingFileName = tmpFileName
+  }
+  const tmpFilePath = path.join(tmpDir, tmpFileName)
+  const pendingFilePath = path.join(pendingFilesDirFilePath, pendingFileName)
+
+  await fs.copyFile(tmpFilePath, pendingFilePath)
+  console.log(`copied file from ${tmpFilePath} to ${pendingFilePath}`)
+}

src/utils/createDirIfNeeded.mts

@@ -0,0 +1,7 @@
+import { existsSync, mkdirSync } from "node:fs"
+
+export const createDirIfNeeded = (dirPath: string) => {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true })
+  }
+}

src/utils/deleteFileIfExists.mts

@@ -0,0 +1,13 @@
+import { existsSync, promises as fs } from "node:fs"
+
+export const deleteFileIfExists = async (filePath: string) => {
+  if (existsSync(filePath)) {
+    try {
+      await fs.unlink(filePath)
+      return true
+    } catch (err) {
+      console.log(`failed to delete file ${filePath}`)
+    }
+  }
+  return false
+}

src/{services/downloadVideo.mts → utils/downloadFileToTmp.mts}

@@ -1,17 +1,18 @@
-import path from 'node:path'
-import fs from 'node:fs'
-import { pendingVideosDirFilePath } from '../config.mts'
+import path from "node:path"
+import fs from "node:fs"
 
-export const downloadVideo = async (remoteUrl: string, fileName: string): Promise<string> => {
+import tmpDir from "temp-dir"
 
-  const filePath = path.resolve(pendingVideosDirFilePath, fileName)
+export const downloadFileToTmp = async (remoteUrl: string, fileName: string) => {
+
+  const filePath = path.resolve(tmpDir, fileName)
 
   const controller = new AbortController()
   const timeoutId = setTimeout(() => controller.abort(), 15 * 60 * 60 * 1000) // 15 minutes
 
   // TODO finish the timeout?
 
-  // download the video
+  // download the file
   const response = await fetch(remoteUrl, {
     signal: controller.signal
   })
@@ -23,6 +24,4 @@ export const downloadVideo = async (remoteUrl: string, fileName: string): Promis
     filePath,
     Buffer.from(arrayBuffer)
   )
-
-  return fileName
 }

src/utils/moveFile.mts

@@ -0,0 +1,15 @@
+import { promises as fs } from "node:fs"
+
+// a function to move a file
+// this implementation is safe to use on a Hugging Face Space
+// for instance when copying from one disk to another
+// (we cannot use fs.rename in that case)
+export const moveFile = async (sourceFilePath: string, targetFilePath: string) => {
+  await fs.copyFile(sourceFilePath, targetFilePath)
+  console.log(`moved file from ${sourceFilePath} to ${targetFilePath}`)
+  try {
+    await fs.unlink(sourceFilePath)
+  } catch (err) {
+    console.log("moveFile: failed to cleanup (no big deal..)")
+  }
+}

src/utils/moveFileFromTmpToPending.mts

@@ -0,0 +1,18 @@
+import path from "node:path"
+import tmpDir from "temp-dir"
+import { pendingFilesDirFilePath } from "../config.mts"
+import { moveFile } from "./moveFile.mts"
+
+// a function to move a file to the pending file directory
+// this implementation is safe to use on a Hugging Face Space
+// for instance when copying from one disk to another
+// (we cannot use fs.rename in that case)
+export const moveFileFromTmpToPending = async (tmpFileName: string, pendingFileName?: string) => {
+  if (!pendingFileName) {
+    pendingFileName = tmpFileName
+  }
+  const tmpFilePath = path.join(tmpDir, tmpFileName)
+  const pendingFilePath = path.join(pendingFilesDirFilePath, pendingFileName)
+
+  await moveFile(tmpFilePath, pendingFilePath)
+}

src/utils/moveVideoFromPendingToCompleted.mts

@@ -0,0 +1,14 @@
+import path from "path"
+
+import { completedFilesDirFilePath, pendingFilesDirFilePath } from "../config.mts"
+import { moveFile } from "./moveFile.mts"
+
+export const moveVideoFromPendingToCompleted = async (pendingFileName: string, completedFileName?: string) => {
+  if (!completedFileName) {
+    completedFileName = pendingFileName
+  }
+  const pendingFilePath = path.join(pendingFilesDirFilePath, pendingFileName)
+  const completedFilePath = path.join(completedFilesDirFilePath, completedFileName)
+
+  await moveFile(pendingFilePath, completedFilePath)
+}

src/utils/moveVideoFromTmpToCompleted.mts

@@ -0,0 +1,18 @@
+import path from "node:path"
+import tmpDir from "temp-dir"
+import { completedFilesDirFilePath } from "../config.mts"
+import { moveFile } from "./moveFile.mts"
+
+// a function to move a video to the completed video directory
+// this implementation is safe to use on a Hugging Face Space
+// for instance when copying from one disk to another
+// (we cannot use fs.rename in that case)
+export const moveVideoFromTmpToCompleted = async (tmpFileName: string, completedFileName?: string) => {
+  if (!completedFileName) {
+    completedFileName = tmpFileName
+  }
+  const tmpFilePath = path.join(tmpDir, tmpFileName)
+  const completedFilePath = path.join(completedFilesDirFilePath, completedFileName)
+
+  await moveFile(tmpFilePath, completedFilePath)
+}

src/utils/parseShotRequest.mts

@@ -3,14 +3,17 @@ import { v4 as uuidv4 } from "uuid"
 // convert a request (which might be invalid)
 
 import { VideoSequence, VideoShot, VideoShotMeta } from "../types.mts"
-import { generateSeed } from "../services/generateSeed.mts"
+import { generateSeed } from "./generateSeed.mts"
 import { getValidNumber } from "./getValidNumber.mts"
-import { shotFormatVersion } from "../database/constants.mts"
+import { shotFormatVersion } from "../config.mts"
 
 export const parseShotRequest = async (sequence: VideoSequence, maybeShotMeta: VideoShotMeta): Promise<VideoShot> => {
+  // we don't want people to input their own ID or we might have trouble,
+  // such as people attempting to use a non-UUID, a file path (to hack us), etc
+  const id = uuidv4()
 
   const shot: VideoShot = {
-    id: maybeShotMeta.id || uuidv4(),
+    id,
 
     shotPrompt: `${maybeShotMeta.shotPrompt || ""}`,
 
@@ -39,7 +42,7 @@ export const parseShotRequest = async (sequence: VideoSequence, maybeShotMeta: V
     durationMs: getValidNumber(maybeShotMeta.durationMs, 0, 6000, 3000),
     
     // a video sequence CAN HAVE inconsistent iteration steps
-    steps: getValidNumber(maybeShotMeta.steps || sequence.steps, 1, 60, 35),
+    steps: getValidNumber(maybeShotMeta.steps || sequence.steps, 10, 50, 35),
 
     // a video sequence MUST HAVE consistent frames per second
     fps: getValidNumber(sequence.fps, 8, 60, 24),
@@ -54,6 +57,8 @@ export const parseShotRequest = async (sequence: VideoSequence, maybeShotMeta: V
     // for internal use
 
     version: shotFormatVersion,
+    fileName: `${id}.mp4`,
+    hasGeneratedPreview: false,
     hasGeneratedVideo: false,
     hasUpscaledVideo: false,
     hasGeneratedBackgroundAudio: false,
@@ -77,7 +82,6 @@ export const parseShotRequest = async (sequence: VideoSequence, maybeShotMeta: V
     completedAt: '',
     completed: false,
     error: '',
-    filePath: '',
   }
 
   return shot

src/utils/parseVideoRequest.mts

@@ -3,18 +3,21 @@ import { v4 as uuidv4 } from "uuid"
 // convert a request (which might be invalid)
 
 import { VideoSequenceRequest, VideoTask } from "../types.mts"
-import { generateSeed } from "../services/generateSeed.mts"
 import { getValidNumber } from "./getValidNumber.mts"
 import { getValidResolution } from "./getValidResolution.mts"
 import { parseShotRequest } from "./parseShotRequest.mts"
-import { sequenceFormatVersion } from "../database/constants.mts"
+import { generateSeed } from "./generateSeed.mts"
+import { sequenceFormatVersion } from "../config.mts"
 
 
 export const parseVideoRequest = async (request: VideoSequenceRequest): Promise<VideoTask> => {
+  // we don't want people to input their own ID or we might have trouble,
+  // such as people attempting to use a non-UUID, a file path (to hack us), etc
+  const id = uuidv4()
 
   const task: VideoTask = {
     // ------------ VideoSequenceMeta -------------
-    id: uuidv4(),
+    id,
 
     // describe the whole movie
     videoPrompt: `${request.sequence.videoPrompt || ''}`,
@@ -38,7 +41,7 @@ export const parseVideoRequest = async (request: VideoSequenceRequest): Promise<
 
     noise: request.sequence.noise === true,
 
-    steps: getValidNumber(request.sequence.steps, 1, 60, 35),
+    steps: getValidNumber(request.sequence.steps, 10, 50, 35),
 
     fps: getValidNumber(request.sequence.fps, 8, 60, 24),
 
@@ -49,13 +52,15 @@ export const parseVideoRequest = async (request: VideoSequenceRequest): Promise<
 
     // ---------- VideoSequenceData ---------
     version: sequenceFormatVersion,
+    fileName: `${id}.mp4`,
+    hasAssembledVideo: false,
     nbCompletedShots: 0,
     nbTotalShots: 0,
     progressPercent: 0,
     completedAt: null,
     completed: false,
     error: '',
-    filePath: '',
+
 
     // ------- the VideoShot -----