working on the VideoChain queue system

database/pending/README.md

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

package.json

@@ -5,8 +5,10 @@
   "main": "src/index.mts",
   "scripts": {
     "start": "node --loader ts-node/esm src/index.mts",
-    "test": "node --loader ts-node/esm src/test.mts",
-    "test2": "node --loader ts-node/esm src/test2.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: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 .",
     "docker:run": "docker run -it -p 7860:7860 videochain-api"
@@ -17,8 +19,10 @@
     "@gradio/client": "^0.1.4",
     "@huggingface/inference": "^2.6.1",
     "@types/express": "^4.17.17",
+    "@types/ffmpeg-concat": "^1.1.2",
     "@types/uuid": "^9.0.2",
     "express": "^4.18.2",
+    "ffmpeg-concat": "^1.3.0",
     "fluent-ffmpeg": "^2.1.2",
     "fs-extra": "^11.1.1",
     "node-fetch": "^3.3.1",

src/database/constants.mts

@@ -0,0 +1,3 @@
+
+export const pendingTasksDirFilePath = './database/pending/'
+export const completedTasksDirFilePath = './database/completed/'

src/database/getCompletedTasks.mts

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

src/database/getPendingTasks.mts

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

src/database/getTask.mts

@@ -0,0 +1,23 @@
+import path from "node:path"
+
+import { completedTasksDirFilePath, pendingTasksDirFilePath } from "./constants.mts"
+import { readTask } from "./readTask.mts"
+
+export const getTask = async (id: string) => {
+  const taskFileName = `${id}.json`
+
+  const completedTaskFilePath = path.join(completedTasksDirFilePath, taskFileName)
+  const pendingTaskFilePath = path.join(pendingTasksDirFilePath, taskFileName)
+
+  try {
+    const completedTask = await readTask(completedTaskFilePath)
+    return completedTask
+  } catch (err) {
+    try {
+      const pendingTask = await readTask(pendingTaskFilePath)
+      return pendingTask
+    } catch (err) {
+      throw new Error(`couldn't find task ${id}`)
+    }
+  }
+}

src/database/readTask.mts

@@ -0,0 +1,12 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+
+import { VideoTask } from "../types.mts"
+
+export const readTask = async (taskFilePath: string): Promise<VideoTask> => {
+  const task = JSON.parse(
+    await fs.readFile(taskFilePath, 'utf8')
+  ) as VideoTask
+
+  return task
+}

src/database/readTasks.mts

@@ -0,0 +1,39 @@
+import path from "node:path"
+import { promises as fs } from "node:fs"
+
+import { VideoTask } from "../types.mts"
+import { readTask } from "./readTask.mts"
+
+
+export const readTasks = async (taskDirFilePath: string): Promise<VideoTask[]> => {
+
+  let tasksFiles: string[] = []
+  try {
+    const filesInDir = await fs.readdir(taskDirFilePath)
+
+    // we only keep valid files (in UUID.json format)
+    tasksFiles = filesInDir.filter(fileName => fileName.match(/[a-z0-9\-]\.json/i))
+  } catch (err) {
+    console.log(`failed to read tasks: ${err}`)
+  }
+
+  const tasks: VideoTask[] = []
+
+  for (const taskFileName in tasksFiles) {
+    const taskFilePath = path.join(taskDirFilePath, taskFileName)
+    try {
+      const task = await readTask(taskFilePath)
+      tasks.push(task)
+    } catch (parsingErr) {
+      console.log(`failed to read ${taskFileName}: ${parsingErr}`)
+      console.log(`deleting corrupted file ${taskFileName}`)
+      try {
+        await fs.unlink(taskFilePath)
+      } catch (unlinkErr) {
+        console.log(`failed to unlink ${taskFileName}: ${unlinkErr}`)
+      }
+    }
+  }
+
+  return tasks
+}

src/database/saveCompletedTask.mts

@@ -0,0 +1,13 @@
+import { promises as fs } from "node:fs"
+import path from "path"
+
+import { VideoTask } from "../types.mts"
+import { completedTasksDirFilePath, pendingTasksDirFilePath } from "./constants.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)
+}

src/database/savePendingTask.mts

@@ -0,0 +1,11 @@
+import { promises as fs } from "node:fs"
+import path from "path"
+
+import { VideoTask } from "../types.mts"
+import { pendingTasksDirFilePath } from "./constants.mts"
+
+export const savePendingTask = async (task: VideoTask) => {
+  const fileName = `${task.id}.json`
+  const filePath = path.join(pendingTasksDirFilePath, fileName)
+  await fs.writeFile(filePath, JSON.stringify(task, null, 2), "utf8")
+}

src/index.mts

@@ -1,112 +1,123 @@
-import { promises as fs } from "fs"
+import { createReadStream, promises as fs } from "fs"
 
 import express from "express"
 
-import { generateSeed } from "./services/generateSeed.mts"
-import { Job, ShotQuery } from "./types.mts"
-import { generateShot } from "./services/generateShot.mts"
+import { VideoTask, VideoSequenceRequest } from "./types.mts"
+import { requestToTask } from "./services/requestToTask.mts"
+import { savePendingTask } from "./database/savePendingTask.mts"
+import { getTask } from "./database/getTask.mts"
+import { main } from "./main.mts"
+
+main()
 
 const app = express()
 const port = 7860
 
 app.use(express.json())
 
-const queue: Job[] = []
-
-app.post("/shot", async (req, res) => {
-  const query = req.body as ShotQuery
-
-  const token = `${query.token || ""}`
+app.post("/", async (req, res) => {
+  const request = req.body as VideoSequenceRequest
+  
+  const token = `${request.token || ""}`
   if (token !== process.env.VS_SECRET_ACCESS_TOKEN) {
     console.log("couldn't find access token in the query")
-    res.write(JSON.stringify({ error: true, message: "access denied" }))
+    res.status(401)
+    res.write(JSON.stringify({ error: "invalid token" }))
     res.end()
     return
   }
 
-  const shotPrompt = `${query.shotPrompt || ""}`
-  if (shotPrompt.length < 5) {
-    res.write(JSON.stringify({ error: true, message: "prompt too short (must be at least 5 in length)" }))
+  let task: VideoTask = null
+
+  console.log(`creating task from request..`)
+  try {
+    task = await requestToTask(request)
+  } catch (err) {
+    console.error(`failed to create task: ${task}`)
+    res.status(400)
+    res.write(JSON.stringify({ error: "query seems to be malformed" }))
     res.end()
     return
   }
 
-  // optional video URL
-  // const inputVideo = `${req.query.inputVideo || ""}`
-
-  // optional background audio prompt
-  const backgroundAudioPrompt = `${query.backgroundAudioPrompt || ""}`
+  console.log(`saving task ${task.id}`)
+  try {
+    await savePendingTask(task)
+    res.status(200)
+    res.write(JSON.stringify(task))
+    res.end()
+  } catch (err) {
+    console.error(err)
+    res.status(500)
+    res.write(JSON.stringify({ error: "couldn't save the task" }))
+    res.end()
+  }
+})
 
-  // optional foreground audio prompt
-  const foregroundAudioPrompt = `${query.foregroundAudioPrompt || ""}`
+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()
+  } catch (err) {
+    console.error(err)
+    res.status(404)
+    res.write(JSON.stringify({ error: "couldn't find this task" }))
+    res.end()
+  }
+})
 
-  // optional seed
-  const defaultSeed = generateSeed()
-  const seedStr = Number(`${query.seed || defaultSeed}`)
-  const maybeSeed = Number(seedStr)
-  const seed = isNaN(maybeSeed) || ! isFinite(maybeSeed) ? defaultSeed : maybeSeed
-  
-  // in production we want those ON by default
-  const upscale = `${query.upscale || "true"}` === "true"
-  const interpolate = `${query.upscale || "true"}` === "true"
-  const noise = `${query.noise || "true"}` === "true"
+app.get("/video/:id\.mp4", async (req, res) => {
+  if (!req.params.id) {
+    res.status(400)
+    res.write(JSON.stringify({ error: "please provide a valid video id" }))
+    res.end()
+    return
+  }
 
+  let task: VideoTask = null
+
+  try {
+    task = await getTask(req.params.id)
+    console.log("returning result to user..")
+
+    const filePath = task.finalFilePath || task.tmpFilePath || ''
+    if (!filePath) {
+      res.status(400)
+      res.write(JSON.stringify({ error: "video exists, but cannot be previewed yet" }))
+      res.end()
+      return
+    }
+  } catch (err) {
+    res.status(404)
+    res.write(JSON.stringify({ error: "this video doesn't exist" }))
+    res.end()
+    return
+  }
 
-  const defaultDuration = 3
-  const maxDuration = 5
-  const durationStr = Number(`${query.duration || defaultDuration}`)
-  const maybeDuration = Number(durationStr)
-  const duration = Math.min(maxDuration, Math.max(1, isNaN(maybeDuration) || !isFinite(maybeDuration) ? defaultDuration : maybeDuration))
-  
-  const defaultSteps = 35
-  const stepsStr = Number(`${query.steps || defaultSteps}`)
-  const maybeSteps = Number(stepsStr)
-  const nbSteps = Math.min(60, Math.max(1, isNaN(maybeSteps) || !isFinite(maybeSteps) ? defaultSteps : maybeSteps))
+  // file path exists, let's try to read it
+  try {
+    // do we need this?
+    // res.status(200)
+    // res.setHeader("Content-Type", "media/mp4")
+    console.log(`creating a video read stream from ${filePath}`)
+    const stream = createReadStream(filePath)
   
-  // const frames per second
-  const defaultFps = 24
-  const fpsStr = Number(`${query.fps || defaultFps}`)
-  const maybeFps = Number(fpsStr)
-  const nbFrames = Math.min(60, Math.max(8, isNaN(maybeFps) || !isFinite(maybeFps) ? defaultFps : maybeFps))
-  
-  const defaultResolution = 576
-  const resolutionStr = Number(`${query.resolution || defaultResolution}`)
-  const maybeResolution = Number(resolutionStr)
-  const resolution = Math.min(1080, Math.max(256, isNaN(maybeResolution) || !isFinite(maybeResolution) ? defaultResolution : maybeResolution))
-  
-  const actorPrompt = `${query.actorPrompt || ""}`
-
-  const actorVoicePrompt = `${query.actorVoicePrompt || ""}`
-
-  const actorDialoguePrompt = `${query.actorDialoguePrompt || ""}`
-
-
-  const { filePath } = await generateShot({
-    seed,
-    actorPrompt,
-    shotPrompt,
-    backgroundAudioPrompt,
-    foregroundAudioPrompt,
-    actorDialoguePrompt,
-    actorVoicePrompt,
-    duration,
-    nbFrames,
-    resolution,
-    nbSteps,
-    upscale,
-    interpolate,
-    noise,
-  })
-
-  console.log(`generated video in ${filePath}`)
-
-  console.log("returning result to user..")
-
-  const buffer = await fs.readFile(filePath)
-
-  res.setHeader("Content-Type", "media/mp4")
-  res.setHeader("Content-Length", buffer.length)
-  res.end(buffer)
+    stream.on('close', () => {
+      console.log(`finished streaming the video`)
+      res.end()
+    })
+    
+    stream.pipe(res)
+  } catch (err) {
+    console.error(`failed to read the video file at ${filePath}: ${err}`)
+    res.status(500)
+    res.write(JSON.stringify({ error: "failed to read the video file" }))
+    res.end()
+  }
 })
 
 app.listen(port, () => { console.log(`Open http://localhost:${port}`) })

src/main.mts

@@ -0,0 +1,17 @@
+import { getPendingTasks } from "./database/getPendingTasks.mts"
+
+export const main = async () => {
+  const tasks = await getPendingTasks()
+  if (!tasks.length) {
+    setTimeout(() => {
+      main()
+    }, 500)
+    return
+  }
+
+  console.log(`there are ${tasks.length} pending tasks`)
+  
+  setTimeout(() => {
+    main()
+  }, 1000)
+}

src/services/processTask.mts

@@ -0,0 +1,5 @@
+import { VideoTask } from "../types.mts";
+
+export const processTask = async (task: VideoTask) => {
+  
+}

src/services/requestToTask.mts

@@ -0,0 +1,115 @@
+import { v4 as uuidv4 } from "uuid"
+
+// convert a request (which might be invalid)
+
+import { VideoSequenceRequest, VideoTask } from "../types.mts"
+import { generateSeed } from "./generateSeed.mts"
+import { getValidNumber } from "../utils/getValidNumber.mts"
+import { getValidResolution } from "../utils/getValidResolution.mts"
+
+// into a valid task
+export const requestToTask = async (request: VideoSequenceRequest): Promise<VideoTask> => {
+
+  const task: VideoTask = {
+    // ------------ VideoSequenceMeta -------------
+    id: uuidv4(),
+
+    // describe the whole movie
+    videoPrompt: `${request.sequence.videoPrompt || ''}`,
+
+    // describe the background audio (crowd, birds, wind, sea etc..)
+    backgroundAudioPrompt: `${request.sequence.backgroundAudioPrompt || ''}`,
+
+    // describe the foreground audio (cars revving, footsteps, objects breaking, explosion etc)
+    foregroundAudioPrompt: `${request.sequence.foregroundAudioPrompt || ''}`,
+
+    // describe the main actor visible in the shot (optional)
+    actorPrompt: `${request.sequence.actorPrompt || ''}`,
+
+    // describe the main actor voice (man, woman, old, young, amused, annoyed.. etc)
+    actorVoicePrompt: `${request.sequence.actorVoicePrompt || ''}`,
+
+    // describe the main actor dialogue line
+    actorDialoguePrompt: `${request.sequence.actorDialoguePrompt || ''}`,
+
+    seed: getValidNumber(request.sequence.seed, 0, 4294967295, generateSeed()),
+
+    upscale: request.sequence.upscale === true,
+
+    noise: request.sequence.noise === true,
+
+    steps: getValidNumber(request.sequence.steps, 1, 60, 35),
+
+    fps: getValidNumber(request.sequence.fps, 8, 60, 24),
+
+    resolution: getValidResolution(request.sequence.resolution),
+
+    outroTransition: 'staticfade',
+    outroDurationMs: 3000,
+
+    // ---------- VideoSequenceData ---------
+    nbCompletedShots: 0,
+    nbTotalShots: 0,
+    progressPercent: 0,
+    completedAt: null,
+    completed: false,
+    error: '',
+    tmpFilePath: '',
+    finalFilePath: '',
+
+    // ------- the VideoShot -----
+
+    shots: [],
+  }
+
+
+  // optional background audio prompt
+  const backgroundAudioPrompt = `${query.backgroundAudioPrompt || ""}`
+
+  // optional foreground audio prompt
+  const foregroundAudioPrompt = `${query.foregroundAudioPrompt || ""}`
+
+  // optional seed
+  const defaultSeed = generateSeed()
+  const seedStr = getValidNumber(Number(`${query.seed || defaultSeed}`)
+  const maybeSeed = Number(seedStr)
+  const seed = isNaN(maybeSeed) || ! isFinite(maybeSeed) ? defaultSeed : maybeSeed
+  
+  // in production we want those ON by default
+  const upscale = `${query.upscale || "true"}` === "true"
+  const interpolate = `${query.upscale || "true"}` === "true"
+  const noise = `${query.noise || "true"}` === "true"
+
+
+  const defaultDuration = 3
+  const maxDuration = 5
+  const durationStr = Number(`${query.duration || defaultDuration}`)
+  const maybeDuration = Number(durationStr)
+  const duration = Math.min(maxDuration, Math.max(1, isNaN(maybeDuration) || !isFinite(maybeDuration) ? defaultDuration : maybeDuration))
+  
+  const defaultSteps = 35
+  const stepsStr = Number(`${query.steps || defaultSteps}`)
+  const maybeSteps = Number(stepsStr)
+  const nbSteps = Math.min(60, Math.max(1, isNaN(maybeSteps) || !isFinite(maybeSteps) ? defaultSteps : maybeSteps))
+  
+  // const frames per second
+  const defaultFps = 24
+  const fpsStr = Number(`${query.fps || defaultFps}`)
+  const maybeFps = Number(fpsStr)
+  const nbFrames = Math.min(60, Math.max(8, isNaN(maybeFps) || !isFinite(maybeFps) ? defaultFps : maybeFps))
+  
+  const defaultResolution = 576
+  const resolutionStr = Number(`${query.resolution || defaultResolution}`)
+  const maybeResolution = Number(resolutionStr)
+  const resolution = Math.min(1080, Math.max(256, isNaN(maybeResolution) || !isFinite(maybeResolution) ? defaultResolution : maybeResolution))
+  
+  const actorPrompt = `${query.actorPrompt || ""}`
+
+  const actorVoicePrompt = `${query.actorVoicePrompt || ""}`
+
+  const actorDialoguePrompt = `${query.actorDialoguePrompt || ""}`
+
+
+
+  return task
+}

src/tests/checkStatus.mts

@@ -0,0 +1,14 @@
+import { videoId, server } from "./config.mts"
+
+console.log(`checking status of video ${videoId}`)
+const response = await fetch(`${server}/${videoId}`, {
+  method: "GET",
+  headers: {
+    "Accept": "application/json",
+  }
+});
+
+console.log('response:', response)
+const task = await response.json()
+
+console.log("task:", JSON.stringify(task, null, 2))

src/tests/config.mts

@@ -0,0 +1,3 @@
+export const server = "http://localhost:7860"
+
+export const videoId = "9a9009a5-b960-49a2-bed2-baf0423cc907"

src/{test.mts → tests/downloadVideo.mts}

@@ -1,23 +1,17 @@
 import { promises as fs } from "node:fs"
 
+import { videoId, server } from "./config.mts"
 
-console.log('generating shot..')
-const response = await fetch("http://localhost:7860/shot", {
-  method: "POST",
-  headers: {
-    "Accept": "application/json",
-    "Content-Type": "application/json"
-  },
-  body: JSON.stringify({
-    token: process.env.VS_SECRET_ACCESS_TOKEN,
-    shotPrompt: "video of a dancing cat"
-  })
+console.log(`trying to download video ${videoId}`)
+
+const response = await fetch(`${server}/${videoId}.mp4`, {
+  method: "GET",
 });
 
 console.log('response:', response)
 const buffer = await (response as any).buffer()
 
-fs.writeFile(`./test-juju.mp4`, buffer)
+fs.writeFile(`./${videoId}.mp4`, buffer)
 
 // if called from an API, we ùight want to use streams instead:
 // https://stackoverflow.com/questions/15713424/how-can-i-download-a-video-mp4-file-using-node-js

src/{test2.mts → tests/stuff.mts}

@@ -1,4 +1,4 @@
-import { generateAudio } from "./services/generateAudio.mts"
+import { generateAudio } from "../services/generateAudio.mts"
 
 
 console.log('generating background audio..')

src/tests/submitVideo.mts

@@ -0,0 +1,23 @@
+import { server, videoId } from "./config.mts"
+
+console.log('submitting a new video..')
+const response = await fetch(`${server}/`, {
+  method: "POST",
+  headers: {
+    "Accept": "application/json",
+    "Content-Type": "application/json"
+  },
+  body: JSON.stringify({
+    token: process.env.VS_SECRET_ACCESS_TOKEN,
+    sequence: {
+      id: videoId,
+    },
+    shots: []
+  })
+});
+
+
+console.log('response:', response)
+const task = await response.json()
+
+console.log("task:", JSON.stringify(task, null, 2))

src/types.mts

@@ -1,65 +1,233 @@
-export interface Shot {
-  shotId: string
-  index: number
-  lastGenerationAt: string
-  videoPrompt: string
-  audioPrompt: string
-  duration: number // no more than 3 (we don't have the ressources for it)
-  fps: number // typically 8, 12, 24
-}
+export type VideoTransition =
+  | 'dissolve'
+  | 'bookflip'
+  | 'bounce'
+  | 'bowtiehorizontal'
+  | 'bowtievertical'
+  | 'bowtiewithparameter'
+  | 'butterflywavescrawler'
+  | 'circlecrop'
+  | 'colourdistance'
+  | 'crazyparametricfun'
+  | 'crosszoom'
+  | 'directional'
+  | 'directionalscaled'
+  | 'doomscreentransition'
+  | 'dreamy'
+  | 'dreamyzoom'
+  | 'edgetransition'
+  | 'filmburn'
+  | 'filmburnglitchdisplace'
+  | 'glitchmemories'
+  | 'gridflip'
+  | 'horizontalclose'
+  | 'horizontalopen'
+  | 'invertedpagecurl'
+  | 'leftright'
+  | 'linearblur'
+  | 'mosaic'
+  | 'overexposure'
+  | 'polkadotscurtain'
+  | 'radial'
+  | 'rectangle'
+  | 'rectanglecrop'
+  | 'rolls'
+  | 'rotatescalevanish'
+  | 'simplezoom'
+  | 'simplezoomout'
+  | 'slides'
+  | 'staticfade'
+  | 'stereoviewer'
+  | 'swirl'
+  | 'tvstatic'
+  | 'topbottom'
+  | 'verticalclose'
+  | 'verticalopen'
+  | 'waterdrop'
+  | 'waterdropzoomincircles'
+  | 'zoomleftwipe'
+  | 'zoomrigthwipe'
+  | 'angular'
+  | 'burn'
+  | 'cannabisleaf'
+  | 'circle'
+  | 'circleopen'
+  | 'colorphase'
+  | 'coordfromin'
+  | 'crosshatch'
+  | 'crosswarp'
+  | 'cube'
+  | 'directionaleasing'
+  | 'directionalwarp'
+  | 'directionalwipe'
+  | 'displacement'
+  | 'doorway'
+  | 'fade'
+  | 'fadecolor'
+  | 'fadegrayscale'
+  | 'flyeye'
+  | 'heart'
+  | 'hexagonalize'
+  | 'kaleidoscope'
+  | 'luma'
+  | 'luminance_melt'
+  | 'morph'
+  | 'mosaic_transition'
+  | 'multiply_blend'
+  | 'perlin'
+  | 'pinwheel'
+  | 'pixelize'
+  | 'polar_function'
+  | 'powerkaleido'
+  | 'randomnoisex'
+  | 'randomsquares'
+  | 'ripple'
+  | 'rotatetransition'
+  | 'rotate_scale_fade'
+  | 'scalein'
+  | 'squareswire'
+  | 'squeeze'
+  | 'static_wipe'
+  | 'swap'
+  | 'tangentmotionblur'
+  | 'undulatingburnout'
+  | 'wind'
+  | 'windowblinds'
+  | 'windowslice'
+  | 'wipedown'
+  | 'wipeleft'
+  | 'wiperight'
+  | 'wipeup'
+  | 'x_axistranslation'
 
-export interface Sequence {
-  sequenceId: string
-  skip: boolean
-  lastGenerationAt: string
-  videoPrompt: string
-  audioPrompt: string
-  channel: string
-  tags: string[]
-  shots: Shot[]
+
+export interface VideoShotMeta {
+  // must be unique
+  id: string
+
+  shotPrompt: string
+  // inputVideo?: string
+
+  // describe the background audio (crowd, birds, wind, sea etc..)
+  backgroundAudioPrompt: string
+
+  // describe the foreground audio (cars revving, footsteps, objects breaking, explosion etc)
+  foregroundAudioPrompt: string
+
+  // describe the main actor visible in the shot (optional)
+  actorPrompt: string
+
+  // describe the main actor voice (man, woman, old, young, amused, annoyed.. etc)
+  actorVoicePrompt: string
+
+  // describe the main actor dialogue line
+  actorDialoguePrompt: string
+
+  seed: number
+  upscale: boolean
+
+  noise: boolean // add movie noise
+
+  durationMs: number // in milliseconds
+  steps: number
+
+  fps: number // 8, 12, 24, 30, 60
+
+  resolution: number // 256, 512, 576, 720, 1080
+
+  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 Database {
-  version: number
-  startAtShotId: string
-  sequences: Sequence[]
+
+export interface VideoShotData {
+  hasGeneratedVideo: boolean
+  hasUpscaledVideo: boolean
+  hasGeneratedBackgroundAudio: boolean
+  hasGeneratedForegroundAudio: boolean
+  hasGeneratedActor: boolean
+  hasInterpolatedVideo: boolean
+  hasAddedAudio: boolean
+  hasPostProcessedVideo: boolean
+  nbCompletedSteps: number
+  nbTotalSteps: number
+  progressPercent: number
+  completedAt: string
+  completed: boolean
+  error: string
+  tmpFilePath: string
+  finalFilePath: string
 }
 
+export type VideoShot = VideoShotMeta & VideoShotData
 
-export interface ShotQuery {
-  token: string
-  shotPrompt: string
-  // inputVideo?: string
+export interface VideoSequenceMeta {
+  // must be unique
+  id: string
+
+  // describe the whole movie
+  videoPrompt: string
 
   // describe the background audio (crowd, birds, wind, sea etc..)
-  backgroundAudioPrompt?: string
+  backgroundAudioPrompt: string
 
   // describe the foreground audio (cars revving, footsteps, objects breaking, explosion etc)
-  foregroundAudioPrompt?: string
+  foregroundAudioPrompt: string
 
   // describe the main actor visible in the shot (optional)
-  actorPrompt?: string
+  actorPrompt: string
 
   // describe the main actor voice (man, woman, old, young, amused, annoyed.. etc)
-  actorVoicePrompt?: string
+  actorVoicePrompt: string
 
   // describe the main actor dialogue line
-  actorDialoguePrompt?: string
+  actorDialoguePrompt: string
+
+  seed: number
+  upscale: boolean
+
+  noise: boolean // add movie noise
 
-  seed?: number
-  upscale?: boolean
+  steps: number
 
-  noise?: boolean // add movie noise
+  fps: number // 8, 12, 24, 30, 60
 
-  duration?: number
-  steps?: number
+  resolution: string // 256, 512, 576, 720, 1080
+
+  outroTransition: VideoTransition
+  outroDurationMs: number
+}
 
-  fps?: number // 8, 12, 24, 30, 60
 
-  resolution?: number // 256, 512, 576, 720, 1080
+export interface VideoSequenceData {
+  nbCompletedShots: number
+  nbTotalShots: number
+  progressPercent: number
+  completedAt: string
+  completed: boolean
+  error: string
+  tmpFilePath: string
+  finalFilePath: string
+}
+
+export type VideoSequence = VideoSequenceMeta & VideoSequenceData
+
+export type VideoSequenceRequest = {
+  token: string
+  sequence: VideoSequenceMeta
+  shots: VideoShotMeta[]
 }
 
-export interface Job {
-  startedAt: string
-  query: ShotQuery
+export type VideoTask = VideoSequence & {
+  shots: VideoShot[]
 }

src/utils/getValidNumber.mts

@@ -0,0 +1,10 @@
+export const getValidNumber = (something: any, minValue: number, maxValue: number, defaultValue: number) => {
+  const strValue = `${something || defaultValue}`
+  const numValue = Number(strValue)
+  const isValid = !isNaN(numValue) && isFinite(numValue)
+  if (!isValid) {
+    return defaultValue
+  }
+  return Math.max(minValue, Math.min(maxValue, numValue))
+ 
+}

src/utils/getValidResolution.mts

@@ -0,0 +1,15 @@
+import { getValidNumber } from "./getValidNumber.mts"
+
+export const getValidResolution = (something: any) => {
+  const strValue = `${something || ''}`
+  const chunks = strValue.split('x')
+  if (chunks.length < 2) {
+    throw new Error('Invalid resolution (should be written like "1280x720" etc)')
+  }
+
+  const [widthStr, heightStr] = chunks
+  const width = getValidNumber(widthStr, 256, 1280, 1280)
+  const height = getValidNumber(widthStr, 256, 720, 720)
+
+  return `${width}x${height}`
+}