diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000000000000000000000000000000000000..56611752ac822de651a144907c93a58542e3e29c
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,6 @@
+
+
+to  allow multiple videos to be processed a the same time:
+
+[ ] yield from the loop at each step
+[ ] random processing of videos
diff --git a/package-lock.json b/package-lock.json
index 371a39370edea3f54ad06230fedc079c11fab7a2..6fb19e7250b36ac6c008a036dfa76987162e0902 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -14,15 +14,19 @@
         "@types/express": "^4.17.17",
         "@types/ffmpeg-concat": "^1.1.2",
         "@types/uuid": "^9.0.2",
+        "eventsource-parser": "^1.0.0",
         "express": "^4.18.2",
         "ffmpeg-concat": "^1.3.0",
         "fluent-ffmpeg": "^2.1.2",
         "fs-extra": "^11.1.1",
+        "gpt-tokens": "^1.1.1",
         "node-fetch": "^3.3.1",
+        "openai": "^3.3.0",
         "puppeteer": "^20.8.0",
         "temp-dir": "^3.0.0",
         "ts-node": "^10.9.1",
-        "uuid": "^9.0.0"
+        "uuid": "^9.0.0",
+        "yaml": "^2.3.1"
       }
     },
     "node_modules/@babel/code-frame": {
@@ -686,6 +690,14 @@
       "resolved": "https://registry.npmjs.org/aws4/-/aws4-1.12.0.tgz",
       "integrity": "sha512-NmWvPnx0F1SfrQbYwOi7OeaNGokp9XhzNioJ/CSBs8Qa4vxug81mhJEAVZwxXuBmYB5KDRfMq/F3RR0BIU7sWg=="
     },
+    "node_modules/axios": {
+      "version": "0.26.1",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-0.26.1.tgz",
+      "integrity": "sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==",
+      "dependencies": {
+        "follow-redirects": "^1.14.8"
+      }
+    },
     "node_modules/b4a": {
       "version": "1.6.4",
       "resolved": "https://registry.npmjs.org/b4a/-/b4a-1.6.4.tgz",
@@ -1222,6 +1234,11 @@
         "ms": "2.0.0"
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.4.3.tgz",
+      "integrity": "sha512-VBBaLc1MgL5XpzgIP7ny5Z6Nx3UrRkIViUkPUdtl9aya5amy3De1gsUUSB1g3+3sExYNjCAsAznmukyxCb1GRA=="
+    },
     "node_modules/decompress-response": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",
@@ -1479,6 +1496,14 @@
         "node": ">= 0.6"
       }
     },
+    "node_modules/eventsource-parser": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-1.0.0.tgz",
+      "integrity": "sha512-9jgfSCa3dmEme2ES3mPByGXfgZ87VbP97tng1G2nWwWx6bV2nYxm2AWCrbQjXToSe+yYlqaZNtxffR9IeQr95g==",
+      "engines": {
+        "node": ">=14.18"
+      }
+    },
     "node_modules/execa": {
       "version": "0.10.0",
       "resolved": "https://registry.npmjs.org/execa/-/execa-0.10.0.tgz",
@@ -1772,6 +1797,25 @@
         "node": ">=0.8.0"
       }
     },
+    "node_modules/follow-redirects": {
+      "version": "1.15.2",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.2.tgz",
+      "integrity": "sha512-VQLG33o04KaQ8uYi2tVNbdrWp1QWxNNea+nmIB4EVM28v0hmP17z7aG1+wAkNzVq4KeXTq3221ye5qTJP91JwA==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/foreground-child": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/foreground-child/-/foreground-child-3.1.1.tgz",
@@ -2218,6 +2262,16 @@
         "through2": "^0.6.3"
       }
     },
+    "node_modules/gpt-tokens": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/gpt-tokens/-/gpt-tokens-1.1.1.tgz",
+      "integrity": "sha512-fB1u0ZH7PywF9FByfWCqn6Hpp3so/pFUmk3AiV4QlOskr57LK8Ds3YJOjdemWKRGJQ+2pT9ikt++Eb+/et9gTQ==",
+      "dependencies": {
+        "decimal.js": "^10.4.3",
+        "js-tiktoken": "^1.0.7",
+        "openai": "^3.3.0"
+      }
+    },
     "node_modules/graceful-fs": {
       "version": "4.2.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
@@ -2609,6 +2663,14 @@
       "resolved": "https://registry.npmjs.org/jpeg-js/-/jpeg-js-0.4.4.tgz",
       "integrity": "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg=="
     },
+    "node_modules/js-tiktoken": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/js-tiktoken/-/js-tiktoken-1.0.7.tgz",
+      "integrity": "sha512-biba8u/clw7iesNEWLOLwrNGoBP2lA+hTaBLs/D45pJdUPFXyxD6nhcDVtADChghv4GgyAiMKYMiRx7x6h7Biw==",
+      "dependencies": {
+        "base64-js": "^1.5.1"
+      }
+    },
     "node_modules/js-tokens": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
@@ -3349,6 +3411,28 @@
         "wrappy": "1"
       }
     },
+    "node_modules/openai": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/openai/-/openai-3.3.0.tgz",
+      "integrity": "sha512-uqxI/Au+aPRnsaQRe8CojU0eCR7I0mBiKjD3sNMzY6DaC1ZVrc85u98mtJW6voDug8fgGN+DIZmTDxTthxb7dQ==",
+      "dependencies": {
+        "axios": "^0.26.0",
+        "form-data": "^4.0.0"
+      }
+    },
+    "node_modules/openai/node_modules/form-data": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
+      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
     "node_modules/optionator": {
       "version": "0.8.3",
       "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.8.3.tgz",
@@ -5059,6 +5143,14 @@
       "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",
       "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
     },
+    "node_modules/yaml": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.3.1.tgz",
+      "integrity": "sha512-2eHWfjaoXgTBC2jNM1LRef62VQa0umtvRiDSk6HSzW7RvS5YtkabJrwYLLEKWBc8a5U2PTSCs+dJjUTJdlHsWQ==",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/yargs": {
       "version": "17.7.1",
       "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.1.tgz",
diff --git a/package.json b/package.json
index 1b1b3540288999a7558c687b6f65575e499d9c89..fbc9036c1e77383a478aa50d9da65de44058fcb0 100644
--- a/package.json
+++ b/package.json
@@ -21,14 +21,18 @@
     "@types/express": "^4.17.17",
     "@types/ffmpeg-concat": "^1.1.2",
     "@types/uuid": "^9.0.2",
+    "eventsource-parser": "^1.0.0",
     "express": "^4.18.2",
     "ffmpeg-concat": "^1.3.0",
     "fluent-ffmpeg": "^2.1.2",
     "fs-extra": "^11.1.1",
+    "gpt-tokens": "^1.1.1",
     "node-fetch": "^3.3.1",
+    "openai": "^3.3.0",
     "puppeteer": "^20.8.0",
     "temp-dir": "^3.0.0",
     "ts-node": "^10.9.1",
-    "uuid": "^9.0.0"
+    "uuid": "^9.0.0",
+    "yaml": "^2.3.1"
   }
 }
diff --git a/src/config.mts b/src/config.mts
index 7d5dd34f0bcb119b200b631ed1dd156465a57982..f21d34b4c1b644004a0c4459f683f7cd3115be8d 100644
--- a/src/config.mts
+++ b/src/config.mts
@@ -2,9 +2,9 @@ import path from "node:path"
 
 export const storagePath = `${process.env.VC_STORAGE_PATH || './sandbox'}`
 
-export const tasksDirPath = path.join(storagePath, "tasks")
-export const pendingTasksDirFilePath = path.join(tasksDirPath, "pending")
-export const completedTasksDirFilePath =  path.join(tasksDirPath, "completed")
+export const metadataDirPath = path.join(storagePath, "metadata")
+export const pendingMetadataDirFilePath = path.join(metadataDirPath, "pending")
+export const completedMetadataDirFilePath =  path.join(metadataDirPath, "completed")
 
 export const filesDirPath = path.join(storagePath, "files")
 export const pendingFilesDirFilePath = path.join(filesDirPath, "pending")
diff --git a/src/data/all_words.json b/src/data/all_words.json
index 8f40dbabf69752152a716a6f081e00efff8b7a95..b69d06ee89b2b62c9c501efaa5229cf5d6e70509 100644
--- a/src/data/all_words.json
+++ b/src/data/all_words.json
@@ -4269,7 +4269,7 @@
     "tank",
     "tap",
     "target",
-    "task",
+    "video",
     "taste",
     "tax",
     "tea",
diff --git a/src/data/good_words.json b/src/data/good_words.json
index 0ab3beb34f8305deff7b4e93b9656a22f327c216..7c36f2b3dc848f1c7f7216e7f4db26403b13fea9 100644
--- a/src/data/good_words.json
+++ b/src/data/good_words.json
@@ -4259,7 +4259,7 @@
     "tank",
     "tap",
     "target",
-    "task",
+    "video",
     "taste",
     "tax",
     "tea",
diff --git a/src/index.mts b/src/index.mts
index 8e475cb4ef0aa10888bb4d1da6a633876d7993bc..551a47a765b69c74e32ccd963d0a2a8e310b5d10 100644
--- a/src/index.mts
+++ b/src/index.mts
@@ -4,17 +4,21 @@ import path from "node:path"
 import { validate as uuidValidate } from "uuid"
 import express from "express"
 
-import { VideoTask, VideoTaskRequest } from "./types.mts"
+import { Video, VideoStatus, VideoAPIRequest } from "./types.mts"
 import { parseVideoRequest } from "./utils/parseVideoRequest.mts"
-import { savePendingTask } from "./scheduler/savePendingTask.mts"
-import { getTask } from "./scheduler/getTask.mts"
+import { savePendingVideo } from "./scheduler/savePendingVideo.mts"
+import { getVideo } from "./scheduler/getVideo.mts"
 import { main } from "./main.mts"
 import { completedFilesDirFilePath } from "./config.mts"
-import { deleteTask } from "./scheduler/deleteTask.mts"
-import { getPendingTasks } from "./scheduler/getPendingTasks.mts"
+import { markVideoAsToDelete } from "./scheduler/markVideoAsToDelete.mts"
+import { markVideoAsToAbort } from "./scheduler/markVideoAsToAbort.mts"
+import { markVideoAsToPause } from "./scheduler/markVideoAsToPause.mts"
+import { markVideoAsPending } from "./scheduler/markVideoAsPending.mts"
+import { getPendingVideos } from "./scheduler/getPendingVideos.mts"
 import { hasValidAuthorization } from "./utils/hasValidAuthorization.mts"
-import { getAllTasksForOwner } from "./scheduler/getAllTasksForOwner.mts"
+import { getAllVideosForOwner } from "./scheduler/getAllVideosForOwner.mts"
 import { initFolders } from "./initFolders.mts"
+import { sortVideosByYoungestFirst } from "./utils/sortVideosByYoungestFirst.mts"
 
 initFolders()
 // to disable all processing (eg. to debug)
@@ -26,8 +30,8 @@ const port = 7860
 
 app.use(express.json())
 
-app.post("/", async (req, res) => {
-  const request = req.body as VideoTaskRequest
+app.post("/:ownerId", async (req, res) => {
+  const request = req.body as VideoAPIRequest
 
   if (!hasValidAuthorization(req.headers)) {
     console.log("Invalid authorization")
@@ -37,68 +41,45 @@ app.post("/", async (req, res) => {
     return
   }
   
-  let task: VideoTask = null
+  const ownerId = req.params.ownerId
 
-  console.log(`creating task from request..`)
-  console.log(`request: `, JSON.stringify(request))
-  try {
-    task = await parseVideoRequest(request)
-  } catch (err) {
-    console.error(`failed to create task: ${task} (${err})`)
+  if (!uuidValidate(ownerId)) {
+    console.error("invalid owner id")
     res.status(400)
-    res.write(JSON.stringify({ error: "query seems to be malformed" }))
+    res.write(JSON.stringify({ error: `invalid owner id` }))
     res.end()
     return
   }
 
-  console.log(`saving task ${task.id}`)
+  let video: Video = null
+
+  console.log(`creating video from request..`)
+  console.log(`request: `, JSON.stringify(request))
   try {
-    await savePendingTask(task)
-    res.status(200)
-    res.write(JSON.stringify(task))
-    res.end()
+    video = await parseVideoRequest(ownerId, request)
   } catch (err) {
-    console.error(err)
-    res.status(500)
-    res.write(JSON.stringify({ error: "couldn't save the task" }))
-    res.end()
-  }
-})
-
-// only get the tasks for a specific owner
-app.get("/owner/:ownerId", async (req, res) => {
-  if (!hasValidAuthorization(req.headers)) {
-    console.log("Invalid authorization")
-    res.status(401)
-    res.write(JSON.stringify({ error: "invalid token" }))
-    res.end()
-    return
-  }
-
-  const ownerId = req.params.ownerId
-
-  if (!uuidValidate(ownerId)) {
-    console.error("invalid owner id")
+    console.error(`failed to create video: ${video} (${err})`)
     res.status(400)
-    res.write(JSON.stringify({ error: `invalid owner id` }))
+    res.write(JSON.stringify({ error: "query seems to be malformed" }))
     res.end()
     return
   }
 
+  console.log(`saving video ${video.id}`)
   try {
-    const tasks = await getAllTasksForOwner(ownerId)
+    await savePendingVideo(video)
     res.status(200)
-    res.write(JSON.stringify(tasks, null, 2))
+    res.write(JSON.stringify(video))
     res.end()
   } catch (err) {
     console.error(err)
     res.status(500)
-    res.write(JSON.stringify({ error: `couldn't get the tasks for owner ${ownerId}` }))
+    res.write(JSON.stringify({ error: "couldn't save the video" }))
     res.end()
   }
 })
 
-app.get("/download/:id\.mp4", async (req, res) => {
+app.get("/:ownerId/:videoId\.mp4", async (req, res) => {
     
   /*
   for simplicity, let's skip auth when fetching videos
@@ -113,7 +94,7 @@ app.get("/download/:id\.mp4", async (req, res) => {
   }
   */
 
-  const [ownerId, videoId] = `${req.params.id}`.split("_")
+  const ownerId = req.params.ownerId
 
   if (!uuidValidate(ownerId)) {
     console.error("invalid owner id")
@@ -123,6 +104,7 @@ app.get("/download/:id\.mp4", async (req, res) => {
     return
   }
 
+  const videoId = req.params.videoId
 
   if (!uuidValidate(videoId)) {
     console.error("invalid video id")
@@ -132,9 +114,9 @@ app.get("/download/:id\.mp4", async (req, res) => {
     return
   }
 
-  let task: VideoTask = null
+  let video: Video = null
   try {
-    task = await getTask(ownerId, videoId)
+    video = await getVideo(ownerId, videoId)
     console.log(`returning video ${videoId} to owner ${ownerId}`)
   } catch (err) {
     res.status(404)
@@ -143,7 +125,7 @@ app.get("/download/:id\.mp4", async (req, res) => {
     return
   }
 
-  const completedFilePath = path.join(completedFilesDirFilePath, task.fileName)
+  const completedFilePath = path.join(completedFilesDirFilePath, video.fileName)
 
   // 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)
@@ -177,8 +159,9 @@ app.get("/download/:id\.mp4", async (req, res) => {
   }
 })
 
-// get all pending tasks
-app.get("/", async (req, res) => {
+// get metadata (json)
+app.get("/:ownerId/:videoId", async (req, res) => {
+    
   if (!hasValidAuthorization(req.headers)) {
     console.log("Invalid authorization")
     res.status(401)
@@ -187,20 +170,106 @@ app.get("/", async (req, res) => {
     return
   }
 
+  const ownerId = req.params.ownerId
+
+  if (!uuidValidate(ownerId)) {
+    console.error("invalid owner id")
+    res.status(400)
+    res.write(JSON.stringify({ error: `invalid owner id` }))
+    res.end()
+    return
+  }
+
+  const videoId = req.params.videoId
+
+  if (!uuidValidate(videoId)) {
+    console.error("invalid video id")
+    res.status(400)
+    res.write(JSON.stringify({ error: `invalid video id` }))
+    res.end()
+    return
+  }
+
   try {
-    const tasks = await getPendingTasks()
+    const video = await getVideo(ownerId, videoId)
     res.status(200)
-    res.write(JSON.stringify(tasks, null, 2))
+    res.write(JSON.stringify(video))
+    res.end()
+  } catch (err) {
+    console.error(err)
+    res.status(404)
+    res.write(JSON.stringify({ error: "couldn't find this video" }))
+    res.end()
+  }
+})
+
+// only get the videos for a specific owner
+app.get("/:ownerId", async (req, res) => {
+  if (!hasValidAuthorization(req.headers)) {
+    console.log("Invalid authorization")
+    res.status(401)
+    res.write(JSON.stringify({ error: "invalid token" }))
+    res.end()
+    return
+  }
+
+  const ownerId = req.params.ownerId
+
+  if (!uuidValidate(ownerId)) {
+    console.error(`invalid owner d ${ownerId}`)
+    res.status(400)
+    res.write(JSON.stringify({ error: `invalid owner id ${ownerId}` }))
+    res.end()
+    return
+  }
+
+  try {
+    const videos = await getAllVideosForOwner(ownerId)
+    sortVideosByYoungestFirst(videos)
+    res.status(200)
+    res.write(JSON.stringify(videos, null, 2))
+    res.end()
+  } catch (err) {
+    console.error(err)
+    res.status(500)
+    res.write(JSON.stringify({ error: `couldn't get the videos for owner ${ownerId}` }))
+    res.end()
+  }
+})
+
+// get all pending videos - this is for admin usage only
+app.get("/", async (req, res) => {
+  if (!hasValidAuthorization(req.headers)) {
+    // this is what users will see in the space - but no need to show something scary
+    console.log("Invalid authorization")
+    res.status(200)
+    res.write(`<html><head></head><body>
+This space is the REST API used by VideoChain UI:<br/>
+<a href="https://jbilcke-hf-videochain-ui.hf.space" target="_blank">https://jbilcke-hf-videochain-ui.hf.space</a>
+    </body></html>`)
+    res.end()
+    // res.status(401)
+    // res.write(JSON.stringify({ error: "invalid token" }))
+    // res.end()
+    return
+  }
+
+  try {
+    const videos = await getPendingVideos()
+    res.status(200)
+    res.write(JSON.stringify(videos, null, 2))
     res.end()
   } catch (err) {
     console.error(err)
     res.status(500)
-    res.write(JSON.stringify({ error: "couldn't get the tasks" }))
+    res.write(JSON.stringify({ error: "couldn't get the videos" }))
     res.end()
   }
 })
 
-app.get("/:id", async (req, res) => {
+
+// edit a video
+app.patch("/:ownerId/:videoId", async (req, res) => {
     
   if (!hasValidAuthorization(req.headers)) {
     console.log("Invalid authorization")
@@ -210,38 +279,113 @@ app.get("/:id", async (req, res) => {
     return
   }
 
-  const [ownerId, videoId] = `${req.params.id}`.split("_")
+  const ownerId = req.params.ownerId
 
   if (!uuidValidate(ownerId)) {
-    console.error("invalid owner id")
+    console.error(`invalid owner id ${ownerId}`)
     res.status(400)
-    res.write(JSON.stringify({ error: `invalid owner id` }))
+    res.write(JSON.stringify({ error: `invalid owner id ${ownerId}` }))
     res.end()
     return
   }
 
+  const videoId = req.params.videoId
 
   if (!uuidValidate(videoId)) {
-    console.error("invalid video id")
+    console.error(`invalid video id ${videoId}`)
     res.status(400)
-    res.write(JSON.stringify({ error: `invalid video id` }))
+    res.write(JSON.stringify({ error: `invalid video id ${videoId}` }))
     res.end()
     return
   }
 
+  let status: VideoStatus = "unknown"
   try {
-    const task = await getTask(ownerId, videoId)
-    res.status(200)
-    res.write(JSON.stringify(task))
-    res.end()
+    const request = req.body as { status: VideoStatus }
+    if (['pending', 'abort', 'delete', 'pause'].includes(request.status)) {
+      status = request.status
+    } else {
+      throw new Error(`invalid video status "${request.status}"`)
+    }
   } catch (err) {
-    console.error(err)
-    res.status(404)
-    res.write(JSON.stringify({ error: "couldn't find this task" }))
+    console.error(`invalid parameter (${err})`)
+    res.status(401)
+    res.write(JSON.stringify({ error: `invalid parameter (${err})` }))
     res.end()
+    return
+  }
+
+  switch (status) {
+    case 'delete': 
+      try {
+        await markVideoAsToDelete(ownerId, videoId)
+        console.log(`deleting video ${videoId}`)
+        res.status(200)
+        res.write(JSON.stringify({ success: true }))
+        res.end()
+      } catch (err) {
+        console.error(`failed to delete video ${videoId} (${err})`)
+        res.status(500)
+        res.write(JSON.stringify({ error: `failed to delete video ${videoId}` }))
+        res.end()
+      }
+      break
+
+    case 'abort': 
+      try {
+        await markVideoAsToAbort(ownerId, videoId)
+        console.log(`aborted video ${videoId}`)
+        res.status(200)
+        res.write(JSON.stringify({ success: true }))
+        res.end()
+      } catch (err) {
+        console.error(`failed to abort video ${videoId} (${err})`)
+        res.status(500)
+        res.write(JSON.stringify({ error: `failed to abort video ${videoId}` }))
+        res.end()
+      }
+      break
+
+    case 'pause': 
+      try {
+        await markVideoAsToPause(ownerId, videoId)
+        console.log(`paused video ${videoId}`)
+        res.status(200)
+        res.write(JSON.stringify({ success: true }))
+        res.end()
+      } catch (err) {
+        console.error(`failed to pause video ${videoId} (${err})`)
+        res.status(500)
+        res.write(JSON.stringify({ error: `failed to pause video ${videoId}` }))
+        res.end()
+      }
+      break
+    
+    case 'pending': 
+      try {
+        await markVideoAsPending(ownerId, videoId)
+        console.log(`unpausing video ${videoId}`)
+        res.status(200)
+        res.write(JSON.stringify({ success: true }))
+        res.end()
+      } catch (err) {
+        console.error(`failed to unpause video ${videoId} (${err})`)
+        res.status(500)
+        res.write(JSON.stringify({ error: `failed to unpause video ${videoId}` }))
+        res.end()
+      }
+      break
+
+    default:
+      console.log(`unsupported status ${status}`)
+      res.status(401)
+      res.write(JSON.stringify({ error: `unsupported status ${status}` }))
+      res.end()
   }
 })
 
+// delete a video - this is legacy, we should use other functions instead
+/*
 app.delete("/:id", async (req, res) => {
     
   if (!hasValidAuthorization(req.headers)) {
@@ -270,27 +414,32 @@ app.delete("/:id", async (req, res) => {
     return
   }
 
-  let task: VideoTask = null
+  // ecurity note: we always check the existence if the video first
+  // that's because we are going to delete all the associated files with a glob,
+  // so we must be sure the id is not a system path or something ^^
+  let video: Video = null
   try {
-    task = await getTask(ownerId, videoId)
+    video = await getVideo(ownerId, videoId)
   } catch (err) {
     console.error(err)
     res.status(404)
-    res.write(JSON.stringify({ error: "couldn't find this task" }))
+    res.write(JSON.stringify({ error: "couldn't find this video" }))
     res.end()
+    return
   }
 
   try {
-    await deleteTask(task)
+    await markVideoAsToDelete(ownerId, videoId)
     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.write(JSON.stringify({ success: false, error: "failed to delete the video" }))
     res.end()
   }
 })
+*/
 
 app.listen(port, () => { console.log(`Open http://localhost:${port}`) })
\ No newline at end of file
diff --git a/src/initFolders.mts b/src/initFolders.mts
index 6642a088ff4fa7b9448b363cc4389c4442e22374..525220a9f413a43b19db42341a5c1d795e0766fc 100644
--- a/src/initFolders.mts
+++ b/src/initFolders.mts
@@ -1,11 +1,18 @@
-import { tasksDirPath, pendingTasksDirFilePath, completedTasksDirFilePath, filesDirPath, pendingFilesDirFilePath, completedFilesDirFilePath } from "./config.mts"
+import {
+  metadataDirPath,
+  pendingMetadataDirFilePath,
+  completedMetadataDirFilePath,
+  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(metadataDirPath)
+  createDirIfNeeded(pendingMetadataDirFilePath)
+  createDirIfNeeded(completedMetadataDirFilePath)
   createDirIfNeeded(filesDirPath)
   createDirIfNeeded(pendingFilesDirFilePath)
   createDirIfNeeded(completedFilesDirFilePath)
diff --git a/src/llm/enrichVideoSpecsUsingLLM.mts b/src/llm/enrichVideoSpecsUsingLLM.mts
new file mode 100644
index 0000000000000000000000000000000000000000..c4df0ac751c006c49abaa6a8482fbd6f579d9876
--- /dev/null
+++ b/src/llm/enrichVideoSpecsUsingLLM.mts
@@ -0,0 +1,79 @@
+import { ChatCompletionRequestMessage } from "openai"
+
+import { Video, VideoAPIRequest } from "../types.mts"
+import { generateYAML } from "./openai/generateYAML.mts"
+import { HallucinatedVideoRequest, OpenAIErrorResponse } from "./types.mts"
+import { getQueryChatMessages } from "../preproduction/prompts.mts"
+import { getValidNumber } from "../utils/getValidNumber.mts"
+
+
+export const enrichVideoSpecsUsingLLM = async (video: Video): Promise<Video> => {
+
+  const messages: ChatCompletionRequestMessage[] = getQueryChatMessages(video.videoPrompt)
+  
+  const defaultValue = {} as unknown as HallucinatedVideoRequest
+
+  // console.log("enrichVideoSpecsUsingLLM: messages = ", messages)
+
+  let hallucinatedVideo: HallucinatedVideoRequest
+
+
+  const referenceShot = video.shots[0]
+  video.shots = []
+  // console.log("referenceShot:", referenceShot)
+  
+  try {
+    hallucinatedVideo = await generateYAML<HallucinatedVideoRequest>(
+      messages,
+      defaultValue
+    )
+    console.log("enrichVideoSpecsUsingLLM: hallucinatedVideo = ", hallucinatedVideo)
+  } catch (err) {
+
+    let error: OpenAIErrorResponse = err?.response?.data?.error as unknown as OpenAIErrorResponse
+    if (!error) {
+      error = { message: `${err || ""}` } as unknown as OpenAIErrorResponse
+    }
+    
+    console.error(JSON.stringify(error, null, 2))
+    throw new Error(`failed to call the LLM: ${error.message}`)
+  }
+
+  // const video = JSON.parse(JSON.stringify(referenceVideo)) as Video
+
+  // TODO here we should make some verifications and perhaps even some conversions
+  // betwen the LLM response and the actual format used in a videoRequest
+  video.backgroundAudioPrompt = hallucinatedVideo.backgroundAudioPrompt || video.backgroundAudioPrompt
+  video.foregroundAudioPrompt = hallucinatedVideo.foregroundAudioPrompt || video.foregroundAudioPrompt
+  video.actorPrompt = hallucinatedVideo.actorPrompt || video.actorPrompt
+  video.actorVoicePrompt = hallucinatedVideo.actorVoicePrompt || video.actorVoicePrompt
+
+  video.noise = typeof hallucinatedVideo.noise !== "undefined"
+    ? (`${hallucinatedVideo.noise || ""}`.toLowerCase() === "true")
+    : video.noise
+  
+  video.noiseAmount = typeof hallucinatedVideo.noiseAmount !== "undefined"
+    ? getValidNumber(hallucinatedVideo.noiseAmount, 0, 10, 2)
+    : video.noiseAmount
+
+  video.outroDurationMs = typeof hallucinatedVideo.outroDurationMs !== "undefined"
+    ? getValidNumber(hallucinatedVideo.outroDurationMs, 0, 3000, 500)
+    : video.outroDurationMs
+
+  const hallucinatedShots = Array.isArray(hallucinatedVideo.shots) ? hallucinatedVideo.shots : []
+
+
+  for (const hallucinatedShot of hallucinatedShots) {
+    const shot = JSON.parse(JSON.stringify(referenceShot))
+    shot.shotPrompt = hallucinatedShot.shotPrompt || shot.shotPrompt
+    shot.environmentPrompt = hallucinatedShot.environmentPrompt || shot.environmentPrompt
+    shot.photographyPrompt = hallucinatedShot.photographyPrompt || shot.photographyPrompt
+    shot.actionPrompt = hallucinatedShot.actionPrompt || shot.actionPrompt
+    shot.foregroundAudioPrompt = hallucinatedShot.foregroundAudioPrompt || shot.foregroundAudioPrompt
+    video.shots.push(shot)
+  }
+
+  console.log("enrichVideoSpecsUsingLLM: video = ", video)
+
+  return video
+}
\ No newline at end of file
diff --git a/src/llm/openai/createChatCompletion.mts b/src/llm/openai/createChatCompletion.mts
new file mode 100644
index 0000000000000000000000000000000000000000..46117f4d7153908c7e47bb1dfc9d6b693095a4e7
--- /dev/null
+++ b/src/llm/openai/createChatCompletion.mts
@@ -0,0 +1,105 @@
+import { ChatCompletionRequestMessage } from "openai"
+import { GPTTokens } from "gpt-tokens"
+
+import { openai } from "./openai.mts"
+import { runModerationCheck } from "./runModerationCheck.mts"
+import { getUserContent } from "./getUserContent.mts"
+import { getTextPrompt } from "./getTextPrompt.mts"
+
+export const createChatCompletion = async (
+  messages: ChatCompletionRequestMessage[],
+  model = "gpt-4"
+): Promise<string> => {
+  // this is the part added by the user, and the one we need to check against the moderation API
+  const userContent = getUserContent(messages)
+
+  const check = await runModerationCheck(userContent)
+
+  if (check.flagged) {
+    console.error("Thoughtcrime: content flagged by the AI police", {
+      userContent,
+      moderationResult: check,
+    })
+    return "Thoughtcrime: content flagged by the AI police"
+  }
+
+  const rawPrompt = getTextPrompt(messages)
+
+
+  // for doc: https://www.npmjs.com/package/gpt-tokens
+  const usageInfo = new GPTTokens({
+    // Plus enjoy a 25% cost reduction for input tokens on GPT-3.5 Turbo (0.0015 per 1K input tokens)
+    plus    : false,
+    model   : "gpt-4",
+    messages: messages as any,
+  })
+
+  console.table({
+    "Tokens prompt": usageInfo.promptUsedTokens,
+    "Tokens completion": usageInfo.completionUsedTokens,
+    "Tokens total": usageInfo.usedTokens,
+  })
+
+  // Price USD:  0.000298
+  console.log("Price USD: ", usageInfo.usedUSD)
+
+  // const tokenLimit = 4000
+
+  const maxTokens = 4000 - usageInfo.promptUsedTokens
+
+  console.log("maxTokens:", maxTokens)
+  /*
+  console.log("settings:", {
+    tokenLimit,
+    promptLength: rawPrompt.length,
+    promptTokenLengh: rawPrompt.length / 1.9,
+    maxTokens
+  })
+
+  console.log("createChatCompletion(): raw prompt length:", rawPrompt.length)
+  console.log(
+    `createChatCompletion(): requesting ${maxTokens} of the ${tokenLimit} tokens availables`
+  )
+  */
+
+  console.log("query:", {
+    model,
+    // messages,
+    user: "Anonymous User",
+    temperature: 0.7,
+    max_tokens: maxTokens,
+    // stop: preset.stop?.length ? preset.stop : undefined,
+  })
+
+  const response = await openai.createChatCompletion({
+    model,
+    messages,
+    // TODO use the Hugging Face Login username here
+    user: "Anonymous User",
+    temperature: 0.7,
+
+    // 30 tokens is about 120 characters
+    // we don't want more, as it will take longer to respond
+    max_tokens: maxTokens,
+    // stop: preset.stop?.length ? preset.stop : undefined,
+  })
+
+  const { choices } = response.data
+
+  if (!choices.length) {
+    console.log("createChatCompletion(): no choice found in the LLM response..")
+    return ""
+  }
+  const firstChoice = choices[0]
+
+  if (firstChoice?.message?.role !== "assistant") {
+    console.log(
+      "createChatCompletion(): something went wrong, the model imagined the user response?!"
+    )
+    return ""
+  }
+
+  console.log("createChatCompletion(): response", firstChoice.message.content)
+
+  return firstChoice.message.content || ""
+}
\ No newline at end of file
diff --git a/src/llm/openai/createChatCompletionStream.mts b/src/llm/openai/createChatCompletionStream.mts
new file mode 100644
index 0000000000000000000000000000000000000000..b4c9c4c9c30cd01e2bf19350b0802e1d9303947b
--- /dev/null
+++ b/src/llm/openai/createChatCompletionStream.mts
@@ -0,0 +1,66 @@
+import { ChatCompletionRequestMessage } from "openai"
+
+import { openai } from "./openai.mts"
+import { streamCompletion } from "./stream.mts"
+import { getTextPrompt } from "./getTextPrompt.mts"
+
+export const createChatCompletionStream = async (
+  messages: ChatCompletionRequestMessage[],
+  model: string,
+  onMessage: (message: string) => Promise<void>,
+  onEnd = () => Promise<void>
+) => {
+  try {
+    const rawPrompt = getTextPrompt(messages)
+
+    const tokenLimit = 4096 // 8000
+
+    const maxTokens = Math.round(tokenLimit - rawPrompt.length / 1.9)
+
+    const completion = await openai.createCompletion({
+      model,
+      prompt: messages,
+      temperature: 0.7,
+      max_tokens: Math.min(30, maxTokens),
+      stream: true,
+    })
+
+    for await (const message of streamCompletion(completion as any)) {
+      try {
+        const parsed = JSON.parse(message)
+        const { text } = parsed.choices[0]
+
+        try {
+          await onMessage(text)
+        } catch (err) {
+          console.error(
+            'Could not process stream message (callback failed)',
+            message,
+            err
+          )
+        }
+      } catch (error) {
+        console.error('Could not JSON parse stream message', message, error)
+      }
+    }
+    try {
+      await onEnd()
+    } catch (err) {
+      console.error('onEnd callback failed', err)
+    }
+  } catch (error: any) {
+    if (error.code) {
+      try {
+        const parsed = JSON.parse(error.body)
+        console.error('An error occurred during OpenAI request: ', parsed)
+      } catch (error) {
+        console.error(
+          'An error occurred during OpenAI request (invalid json): ',
+          error
+        )
+      }
+    } else {
+      console.error('An error occurred during OpenAI request', error)
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/llm/openai/generateYAML.mts b/src/llm/openai/generateYAML.mts
new file mode 100644
index 0000000000000000000000000000000000000000..d85d146a19b136b21aa481b9e7e30b22471e1d04
--- /dev/null
+++ b/src/llm/openai/generateYAML.mts
@@ -0,0 +1,42 @@
+import { ChatCompletionRequestMessage } from "openai"
+import { parse } from "yaml"
+
+import { createChatCompletion } from "./createChatCompletion.mts"
+
+export const generateYAML = async <T,>(messages: ChatCompletionRequestMessage[] = [], defaultValue?: T): Promise<T> => {
+
+  const defaultResult = defaultValue || ({} as T)
+
+  if (!messages.length) {
+    return defaultResult
+  }
+
+  const output = await createChatCompletion(messages)
+
+  let raw = ""
+
+  // cleanup any remains of the markdown response
+  raw = output.split("```")[0]
+
+  // remove any remaining `
+  const input = raw.replaceAll("`", "")
+
+  try {
+    const obj = parse(input) as T
+
+    if (obj === null || typeof obj === undefined) {
+      throw new Error("couldn't parse YAML")
+    }
+
+    return obj
+  } catch (err) {
+    // just in case, we also try JSON!
+    const obj = JSON.parse(input) as T
+
+    if (obj === null || typeof obj === undefined) {
+      throw new Error("couldn't parse JSON")
+    }
+
+    return obj
+  }
+}
\ No newline at end of file
diff --git a/src/llm/openai/getTextPrompt.mts b/src/llm/openai/getTextPrompt.mts
new file mode 100644
index 0000000000000000000000000000000000000000..ed9e426379b1383e203bb40b9307a0d1bbddb370
--- /dev/null
+++ b/src/llm/openai/getTextPrompt.mts
@@ -0,0 +1,4 @@
+import { ChatCompletionRequestMessage } from "openai"
+
+export const getTextPrompt = (prompt: ChatCompletionRequestMessage[]) =>
+  prompt.reduce((acc, item) => acc.concat(item.content), "") || ""
\ No newline at end of file
diff --git a/src/llm/openai/getUserContent.mts b/src/llm/openai/getUserContent.mts
new file mode 100644
index 0000000000000000000000000000000000000000..e9f3b819ad1172d00c6790b7d81b8d884e32b894
--- /dev/null
+++ b/src/llm/openai/getUserContent.mts
@@ -0,0 +1,7 @@
+import { ChatCompletionRequestMessage } from "openai"
+
+export const getUserContent = (prompt: ChatCompletionRequestMessage[]) =>
+  prompt
+    .filter((message) => message.role === "user")
+    .map((message) => message.content)
+    .join("\n")
\ No newline at end of file
diff --git a/src/llm/openai/openai.mts b/src/llm/openai/openai.mts
new file mode 100644
index 0000000000000000000000000000000000000000..267d0ed85f94d8885e3a7ac214ca835499ceeef1
--- /dev/null
+++ b/src/llm/openai/openai.mts
@@ -0,0 +1,7 @@
+import { Configuration, OpenAIApi } from "openai"
+
+export const openai = new OpenAIApi(
+  new Configuration({
+    apiKey: process.env.VC_OPENAI_API_KEY
+  })
+)
\ No newline at end of file
diff --git a/src/llm/openai/runModerationCheck.mts b/src/llm/openai/runModerationCheck.mts
new file mode 100644
index 0000000000000000000000000000000000000000..81a2a16f22237a79fe08857bf867c123444195cd
--- /dev/null
+++ b/src/llm/openai/runModerationCheck.mts
@@ -0,0 +1,30 @@
+import {
+  CreateModerationResponseResultsInnerCategories,
+  CreateModerationResponseResultsInnerCategoryScores,
+} from "openai"
+
+import { openai } from "./openai.mts"
+
+export const runModerationCheck = async (
+  input = ''
+): Promise<{
+  categories?: CreateModerationResponseResultsInnerCategories
+  category_scores?: CreateModerationResponseResultsInnerCategoryScores
+  flagged: boolean
+}> => {
+  if (!input || !input.length) {
+    console.log(`skipping moderation check as input length is too shot`)
+    return {
+      flagged: false,
+    }
+  }
+
+  const response = await openai.createModeration({ input })
+  const { results } = response.data
+
+  if (!results.length) {
+    throw new Error(`failed to call the moderation endpoint`)
+  }
+
+  return results[0]
+}
\ No newline at end of file
diff --git a/src/llm/openai/stream.mts b/src/llm/openai/stream.mts
new file mode 100644
index 0000000000000000000000000000000000000000..1d852777b7a03bb446e64de54a242c49af010340
--- /dev/null
+++ b/src/llm/openai/stream.mts
@@ -0,0 +1,35 @@
+import { Readable } from "node:stream"
+
+async function* chunksToLines(
+  chunksAsync: AsyncIterable<Buffer>
+): AsyncIterable<string> {
+  let previous = ""
+  for await (const chunk of chunksAsync) {
+    const bufferChunk = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+    previous += bufferChunk
+    let eolIndex
+    while ((eolIndex = previous.indexOf("\n")) >= 0) {
+      // line includes the EOL
+      const line = previous.slice(0, eolIndex + 1).trimEnd()
+      if (line === "data: [DONE]") break
+      if (line.startsWith("data: ")) yield line
+      previous = previous.slice(eolIndex + 1)
+    }
+  }
+}
+
+async function* linesToMessages(
+  linesAsync: AsyncIterable<string>
+): AsyncIterable<string> {
+  for await (const line of linesAsync) {
+    const message = line.substring("data :".length)
+
+    yield message
+  }
+}
+
+export async function* streamCompletion(
+  stream: Readable
+): AsyncGenerator<string, void, undefined> {
+  yield* linesToMessages(chunksToLines(stream))
+}
\ No newline at end of file
diff --git a/src/llm/types.mts b/src/llm/types.mts
new file mode 100644
index 0000000000000000000000000000000000000000..9d91432c9c87ee2420d0dba0cced14ecbc7552e5
--- /dev/null
+++ b/src/llm/types.mts
@@ -0,0 +1,25 @@
+// note: this has to exactly match what is in the prompt, in ../preproduction/prompts.mts
+export interface HallucinatedVideoRequest {
+  backgroundAudioPrompt: string; // describe the background audio (crowd, birds, wind, sea etc..)
+  foregroundAudioPrompt: string; // describe the foreground audio (cars revving, footsteps, objects breaking, explosion etc)
+  actorPrompt: string; // describe the physical look of the main actor visible in the shot (man, woman, old, young, hair, glasses, clothes etc)
+  actorVoicePrompt: string; // describe the main actor voice (man, woman, old, young, amused, annoyed.. etc)
+  noise: boolean; // whether to apply movie noise or not
+  noiseAmount: number; // (integer) the amount of ffmpeg noise (film grain) to apply. 0 is none, 10 is a lot
+  outroDurationMs: number; // in milliseconds. An outro generally only lasts between 0 and 3000 (3s)
+  
+  shots: Array<{
+    shotPrompt: string; // describe the main elements of a shot, in excruciating details. You must include ALL those parameters: characters, shot story, what is happening. How they look, the textures, the expressions, their clothes. The color, materials and style of clothes. 
+    environmentPrompt: string; // describe the environment, in excruciating details. You must include ALL those parameters: Lights, atmosphere and weather (misty, dust, clear, rain, snow..). Time of the day and hour of the day. Furnitures, their shape, style, era. The materials used for each object. The global time period, time of the day, era. Explain if anything is moving in the backgroung.
+    photographyPrompt: string; // describe the photography, in excruciating details. You must include ALL those parameters: Camera angle, position and movement. Type of shot and angle. Lighting. Mood. Settings. Tint of the lights. Position of the sun or moon. Shadows and their direction. Camera shutter speed, blur, bokeh, aperture.
+    actionPrompt: string; // describe the dynamics of a shot, in excruciating details. You must include ALL those parameters: What is happening, who and what is moving. Which entity are in movements. What are the directions, starting and ending position. At which speed entities or objects are moving. Is there motion blur, slow motion, timelapse etc.
+    foregroundAudioPrompt: string; // describe the sounds in a concise way (eg. ringing bells, underwater sound and whistling dolphin, cat mewong etc),
+  }>
+}
+
+export interface OpenAIErrorResponse {
+  message: string
+  type: string
+  param: any
+  code: any
+}
\ No newline at end of file
diff --git a/src/main.mts b/src/main.mts
index f07706ea572bba6bf3e282f6e894f521b3a7fc44..1d8e45e549ec984df0230ee820b8d24917515519 100644
--- a/src/main.mts
+++ b/src/main.mts
@@ -1,22 +1,26 @@
 import { initFolders } from "./initFolders.mts"
-import { getPendingTasks } from "./scheduler/getPendingTasks.mts"
-import { processTask } from "./scheduler/processTask.mts"
+import { getPendingVideos } from "./scheduler/getPendingVideos.mts"
+import { processVideo } from "./scheduler/processVideo.mts"
+import { sortPendingVideosByLeastCompletedFirst } from "./utils/sortPendingVideosByLeastCompletedFirst.mts"
 
 export const main = async () => {
 
-  const tasks = await getPendingTasks()
-  if (!tasks.length) {
+  const videos = await getPendingVideos()
+  if (!videos.length) {
     setTimeout(() => {
       main()
     }, 500)
     return
   }
 
-  console.log(`there are ${tasks.length} pending tasks`)
-  for (const task of tasks) {
-    await processTask(task)
+  console.log(`there are ${videos.length} pending videos`)
+
+  sortPendingVideosByLeastCompletedFirst(videos)
+
+  for (const video of videos) {
+    await processVideo(video)
   }
-  console.log(`processed ${tasks.length} tasks`)
+  console.log(`processed ${videos.length} videos`)
 
   setTimeout(() => {
     main()
diff --git a/src/preproduction/mocks.mts b/src/preproduction/mocks.mts
new file mode 100644
index 0000000000000000000000000000000000000000..abf07d3e1c0de9afa6e83c596fbfad08c06edf62
--- /dev/null
+++ b/src/preproduction/mocks.mts
@@ -0,0 +1,36 @@
+import { Video, VideoShot } from "../types.mts"
+
+export const mockShots: VideoShot[] = [
+  {
+    "shotPrompt": "In the extreme wide shot, a flock of ducks is converging on the Central Park, coming from multiple directions. Their feathers are glossy and clean, casting off varying degrees of green, brown and white",
+    "environmentPrompt": "Central Park at sunrise, the park looks slightly misty, the sky is tinged with shades of pink and orange as the day breaks. There's dew on the grass, and the leaves on trees are rustling in the light breeze",
+    "photographyPrompt": "Eye-level shot with a slight tilt in the camera, capturing the panorama of the park. There's natural lighting, sun just rising. The camera zooms out to capture the ducks entering the park. Shutter speed is slow to capture the movement of ducks",
+    "actionPrompt": "Large groups of ducks waddle into the park from various directions, some fly in groups, landing on the pond with small splashes. Movement is slow, slightly sped up to depict the invasion",
+    "foregroundAudioPrompt": "A symphony of soft quacking and rustling feathers",
+  },
+  {
+    "shotPrompt": "In the medium shot, a group of ducks are by the pond, pecking at the ground and frolicking in the water. One male mallard is particularly captivating with its emerald green head and healthy body",
+    "environmentPrompt": "It's a sunny spring day in Central Park. The pond is surrounded by lush, green vegetation and dappled with sunlight filtering through the leaves",
+    "photographyPrompt": "Low angle shot near the water level, the camera moves in a crane shot to capture ducks in action, and the camera's aperture is partially open. Natural sunlight creates playful shadows",
+    "actionPrompt": "Ducks are pecking at the ground, dabbling at the water's edge and frolicking in the pond. The camera tracks a particularly majestic mallard navigating through the pond",
+    "foregroundAudioPrompt": "Sounds of ducks quacking and splashing in the water"
+  },
+  {
+    "shotPrompt": "Close-up shot of a mother duck with ducklings following her in a line on the grass and into the water",
+    "environmentPrompt": "Central Park, by one of the smaller ponds, surrounded by green trees. Sun is high up giving off warm, radiant light",
+    "photographyPrompt": "High angle shot, focusing on the line of ducklings following their mother. The camera follows the ducklings. The setting is bright and clear with sun illuminating the ducklings",
+    "actionPrompt": "Mother duck is leading her ducklings from the grass into the water, the ducklings obediently follow, creating a neat line. The whole scene feels peaceful",
+    "foregroundAudioPrompt": "Ducklings' high pitched chirping, soft lapping of water at the edge of the pond"
+  }
+] as any
+
+export const mock: Video = {
+  "backgroundAudioPrompt": "City ambience mixed with the rustling leaves and the chirping birds in the park",
+  "foregroundAudioPrompt": "Rustling feathers, soft quacking, flapping wings, occasional splash in the pond",
+  "actorPrompt": "Main actors are ducks - a variety of breeds, mostly mallards: males with glossy green heads and females in mottled brown; all plump, medium-sized waterfowl",
+  "actorVoicePrompt": "Soft, low pitched quacking of adult ducks and higher pitched chirping of ducklings",
+  "noise": true,
+  "noiseAmount": 2,
+  "outroDurationMs": 1500,
+  "shots": mockShots
+} as any
\ No newline at end of file
diff --git a/src/preproduction/prompts.mts b/src/preproduction/prompts.mts
new file mode 100644
index 0000000000000000000000000000000000000000..bcaab6af54576a84071b54b49d0a59c1d668b2e5
--- /dev/null
+++ b/src/preproduction/prompts.mts
@@ -0,0 +1,119 @@
+
+
+// types of movie shots: https://www.nfi.edu/types-of-film-shots/
+
+import { ChatCompletionRequestMessage } from "openai"
+
+export const getQueryChatMessages = (sceneDescription: string): ChatCompletionRequestMessage[] => {
+  return [
+  {
+    role: "system",
+    name: "moviemaking_rules",
+    content: `# Context
+You are an AI Movie Director Assistant, and you need to help generating input requests (movie "specs") for an automated movie generation API.
+The format expected by the API must be in YAML. The TypeScript schema for this YAML file is:
+\`\`\`typescript
+{
+  backgroundAudioPrompt: string; // describe the background audio (crowd, birds, wind, sea etc..)
+  foregroundAudioPrompt: string; // describe the foreground audio (cars revving, footsteps, objects breaking, explosion etc)
+  actorPrompt: string; // describe the physical look of the main actor visible in the shot (man, woman, old, young, hair, glasses, clothes etc)
+  actorVoicePrompt: string; // describe the main actor voice (man, woman, old, young, amused, annoyed.. etc)
+  noise: boolean; // whether to apply movie noise or not
+  noiseAmount: number; // (integer) the amount of noise (film grain) to apply. This is mapped from the FFmpeg filter (0 is none, 10 is already a lot)
+  outroDurationMs: number; // in milliseconds. An outro generally only lasts between 0 and 3000 (3s)
+  shots: Array<{
+    shotPrompt: string; // describe the main elements of a shot, in excruciating details. You must include ALL those parameters: characters, shot story, what is happening. How they look, the textures, the expressions, their clothes. The color, materials and style of clothes. 
+    environmentPrompt: string; // describe the environment, in excruciating details. You must include ALL those parameters: Lights, atmosphere and weather (misty, dust, clear, rain, snow..). Time of the day and hour of the day. Furnitures, their shape, style, era. The materials used for each object. The global time period, time of the day, era. Explain if anything is moving in the backgroung.
+    photographyPrompt: string; // describe the photography, in excruciating details. You must include ALL those parameters: Camera angle, position and movement. Type of shot and angle. Lighting. Mood. Settings. Tint of the lights. Position of the sun or moon. Shadows and their direction. Camera shutter speed, blur, bokeh, aperture.
+    actionPrompt: string; // describe the dynamics of a shot, in excruciating details. You must include ALL those parameters: What is happening, who and what is moving. Which entity are in movements. What are the directions, starting and ending position. At which speed entities or objects are moving. Is there motion blur, slow motion, timelapse etc.
+    foregroundAudioPrompt: string; // describe the sounds in a concise way (eg. ringing bells, underwater sound and whistling dolphin, cat mewong etc),
+  }>
+}
+\`\`\`
+# Guidelines
+You will generate 3 shots by default, unless more or less are specified.
+Is it crucial to repeat the elements consituting a sequence of multiple shots verbatim from one shot to another.
+For instance, you will have to repeat exactly what a character or background look like, how they are dressed etc.
+This will ensure consistency from one scene to another.
+## Creating a movie
+Here are some guidelines regarding film-making:
+- The distance your subject is to the camera impacts how the audience feels about them.
+- Subject will appear largest in a close-up or choker shot and smallest in a wide or long shot.
+- Camera movement is a technique for changing the relationship between the subject and the camera frame, controlling the delivery of the narrative. It helps to give additional meaning to what’s happening on the screen.
+- Do not hesitate to combine types of shots with camera movement shots and camera position (angle) shots.
+## Shots
+Single shot: where the shot only captures one subject.
+Two shot: which has only two characters.
+Three shot: when three characters are in the frame.
+Point-of-view shot (POV): shows the scene from the point of view of one of the characters, makes the audience feel that they are there seeing what the character is seeing.
+Over-the-shoulder shot (OTS): shows the subject from behind the shoulder of another character.
+Over-the-hip (OTH) shot, in which the camera is placed on the hip of one character and the focus is on the subject.
+Reverse angle shot: which is approximately 180 degrees opposite the previous shot.
+Reaction shot: which shows the character’s reaction to the previous shot.
+Weather shot: where the subject of the filming is the weather.
+Extreme wide shot/extreme long shot: used to show the subject and the entire area of the environment they are in.
+Wide shot/long shot: used to focus on the subject while still showing the scene the subject is in.
+Medium shot: shows the subject from the knees up, and is often referred to as the 3/4 shot.
+Medium close-up shot: The subject fills the frame. It is somewhere between a medium close-up and a close-up.
+Close-up shot: shows emotions and detailed reactions, with the subject filling the entire frame.
+Choker shot: shows the subject’s face from just above the eyebrows to just below the mouth and is between a close-up and an extreme close-up.
+Extreme close-up shot: shows the detail of an object, such as one a character is handling, or a person, such as just their eyes or moving lips.
+Full shot: similar to a wide shot except that it focuses on the character in the frame, showing them from head to toe.
+Cowboy shot: similar to the medium shot except that the character is shown from the hips or waist up.
+Establishing shot: a long shot at the beginning of a scene that shows objects, buildings, and other elements of a setting from a distance to establish where the next sequence of events takes place.
+## Camera angles
+Eye-level shot: This is when the camera is placed at the same height as the eyes of the characters.
+Low angle shot: This shot frames the subject from a low height, often used to emphasize differences in power between characters.
+Aerial shot/helicopter shot: Taken from way up high, this shot is usually from a drone or helicopter to establish the expanse of the surrounding landscape.
+High angle shot: This is when the subject is framed with the camera looking down at them.
+Birds-eye-view shot/overhead shot: This is a shot taken from way above the subject, usually including a significant amount of the surrounding environment to create a sense of scale or movement.
+Shoulder-level shot: This is where the camera is approximately the same height as the character’s shoulders.
+Hip-level shot: The camera is approximately at the height of the character’s hips.
+Knee-level shot: The camera is approximately at the same level as the character’s knees.
+Ground-level shot: When the height of the camera is at ground level with the character, this shot captures what’s happening on the ground the character is standing on.
+Dutch-angle/tilt shot: This is where the camera is tilted to the side.
+Cut-in shot: This type of shot cuts into the action on the screen to offer a different view of something happening in this main scene.
+Cutaway shot: As a shot that cuts away from the main action on the screen, it’s used to focus on secondary action and add more information for greater understanding for the audience.
+Master shot: A long shot that captures most or all of the action happening in a scene.
+Deep focus: A shot that keeps everything on the screen in sharp focus, including the foreground, background, and middle ground.
+Locked-down shot: With this shot, the camera is fixed in one position and the action continues off-screen.
+## Camera movements
+Zoom Shot: involves changing the focal length of the lens to zoom in or out during filming.
+Pan shot:  involves moving the camera from side to side to show something to the audience or help them better follow the sequence of events.
+Tilt shot: similar to a pan shot, except moving the camera up and down.
+Dolly shot: the camera is attached to a dolly that moves on tracks and can possibly move up and down.
+Truck shot: you move the entire camera on a fixed point and the motion goes from side to side.
+Pedestal shot: the entire camera is moved vertically, not just the angle of view, and is often combined with panning and/or tilting.
+Static/fixed shot: where there is no camera movement, and the shot emphasizes the movement of the subject in the environment.
+Arc shot: where the camera moves in an arc pattern around the subject to give the audience a better perspective of their surroundings.
+Crab shot: a less-common version of tracking a subject where the dolly the camera is on goes sideways.
+Dolly zoom shot: the position of the camera and focal length are changed simultaneously.
+Whip pan shot/swish pan shot: used to create a blur as you pan from one shot to the next.
+Tracking shot: the camera follows the subject, either from behind or at their side, moving with them.
+Whip tilt shot: used to create a blur panning from one shot to the next vertically.
+Bridging shot: denotes a shift in place or time.
+## Focus
+Focus pull: focus the lens to keep the subject within an acceptable focus range.
+Rack focus: focus is more aggressively shifted from subject A to subject B.
+Tilt-shift: parts of the image are in focus while other parts are out of focus.
+Deep focus: both the subject and the environment are in focus.
+Shallow focus: subject is crisp and in focus while the background is out of focus.
+## Camera angles
+High-angle
+Low-angle
+Over-the-shoulder
+Bird’s eye
+Dutch angle/tilt`
+  },
+  {
+    role: "user",
+    name: "movie_director",
+    content: `# Task
+Please generate the movie spec YAML based on the following description:
+${sceneDescription}.
+# YAML
+\`\`\`
+`
+  },
+]
+}
\ No newline at end of file
diff --git a/src/production/generateShot.mts b/src/production/generateShot.mts
index dea19f4daea6c1febc9eedf860a03bb89d32efc1..2b823040541dcac357932153ed06680d036de9ff 100644
--- a/src/production/generateShot.mts
+++ b/src/production/generateShot.mts
@@ -135,7 +135,7 @@ export const generateShot = async ({
     const interpolationSteps = 3
     const interpolatedFramesPerSecond = 24
     await interpolateVideo(
-      task,
+      video,
       interpolationSteps,
       interpolatedFramesPerSecond
     )
@@ -194,7 +194,7 @@ export const generateShot = async ({
       audioFileName = foregroundAudioFileName
     }
 
-    await addAudioToVideo(task, audioFileName)
+    await addAudioToVideo(video, audioFileName)
   }
 
   console.log("returning result to user..")
diff --git a/src/scheduler/deleteTask.mts b/src/scheduler/deleteTask.mts
deleted file mode 100644
index d8131c4ed55dc3713817215c46e935656f3d50c7..0000000000000000000000000000000000000000
--- a/src/scheduler/deleteTask.mts
+++ /dev/null
@@ -1,33 +0,0 @@
-
-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.ownerId}_${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!`)
-}
\ No newline at end of file
diff --git a/src/scheduler/deleteVideo.mts b/src/scheduler/deleteVideo.mts
new file mode 100644
index 0000000000000000000000000000000000000000..ad192dd55828fe6b9a85b09bbcaa16d6f4f407be
--- /dev/null
+++ b/src/scheduler/deleteVideo.mts
@@ -0,0 +1,28 @@
+import tmpDir from "temp-dir"
+import { validate as uuidValidate } from "uuid"
+
+import { completedMetadataDirFilePath, completedFilesDirFilePath, pendingMetadataDirFilePath, pendingFilesDirFilePath } from "../config.mts"
+import { deleteFilesWithName } from "../utils/deleteAllFilesWith.mts"
+
+
+// note: we make sure ownerId and videoId are *VALID*
+// otherwise an attacker could try to delete important files!
+export const deleteVideo = async (ownerId: string, videoId?: string) => {
+  if (!uuidValidate(ownerId)) {
+    throw new Error(`fatal error: ownerId ${ownerId} is invalid!`)
+  }
+
+  if (videoId && !uuidValidate(videoId)) {
+    throw new Error(`fatal error: videoId ${videoId} is invalid!`)
+  }
+  const id = videoId ? `${ownerId}_${videoId}` : ownerId
+
+  // this should delete everything, including audio files
+  // however we still have some temporary files with a name that is unique:
+  // we should probably rename those
+  await deleteFilesWithName(tmpDir, id)
+  await deleteFilesWithName(completedMetadataDirFilePath, id)
+  await deleteFilesWithName(completedFilesDirFilePath, id)
+  await deleteFilesWithName(pendingMetadataDirFilePath, id)
+  await deleteFilesWithName(pendingFilesDirFilePath, id)
+}
diff --git a/src/scheduler/getAllTasksForOwner.mts b/src/scheduler/getAllTasksForOwner.mts
deleted file mode 100644
index 3fd56ec8881f8909efd26e97f9e9059ee2780809..0000000000000000000000000000000000000000
--- a/src/scheduler/getAllTasksForOwner.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { VideoTask } from "../types.mts"
-import { getCompletedTasks } from "./getCompletedTasks.mts"
-import { getPendingTasks } from "./getPendingTasks.mts"
-
-export const getAllTasksForOwner = async (ownerId: string): Promise<VideoTask[]> => {
-  const pendingTasks = await getPendingTasks(ownerId)
-  const completedTasks = await getCompletedTasks(ownerId)
-  return [...pendingTasks, ...completedTasks]
-}
\ No newline at end of file
diff --git a/src/scheduler/getAllVideosForOwner.mts b/src/scheduler/getAllVideosForOwner.mts
new file mode 100644
index 0000000000000000000000000000000000000000..aeaacf04d70d7c3c5d1ca3764cb5eaefe339000b
--- /dev/null
+++ b/src/scheduler/getAllVideosForOwner.mts
@@ -0,0 +1,9 @@
+import { Video } from "../types.mts"
+import { getCompletedVideos } from "./getCompletedVideos.mts"
+import { getPendingVideos } from "./getPendingVideos.mts"
+
+export const getAllVideosForOwner = async (ownerId: string): Promise<Video[]> => {
+  const pendingVideos = await getPendingVideos(ownerId)
+  const completedVideos = await getCompletedVideos(ownerId)
+  return [...pendingVideos, ...completedVideos]
+}
\ No newline at end of file
diff --git a/src/scheduler/getCompletedTasks.mts b/src/scheduler/getCompletedTasks.mts
deleted file mode 100644
index 6ae3ec54aa62e987d402d45b62e4a3a652a1055d..0000000000000000000000000000000000000000
--- a/src/scheduler/getCompletedTasks.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { VideoTask } from "../types.mts"
-import { completedTasksDirFilePath } from "../config.mts"
-import { readTasks } from "./readTasks.mts"
-
-export const getCompletedTasks = async (ownerId?: string): Promise<VideoTask[]> => {
-  const completedTasks = await readTasks(completedTasksDirFilePath, ownerId)
-
-  return completedTasks
-}
\ No newline at end of file
diff --git a/src/scheduler/getCompletedVideos.mts b/src/scheduler/getCompletedVideos.mts
new file mode 100644
index 0000000000000000000000000000000000000000..47d67a54dc047ad27b6e0a89ab8bf9b2395203fd
--- /dev/null
+++ b/src/scheduler/getCompletedVideos.mts
@@ -0,0 +1,9 @@
+import { Video } from "../types.mts"
+import { completedMetadataDirFilePath } from "../config.mts"
+import { readVideoMetadataFiles } from "./readVideoMetadataFiles.mts"
+
+export const getCompletedVideos = async (ownerId?: string): Promise<Video[]> => {
+  const completedVideos = await readVideoMetadataFiles(completedMetadataDirFilePath, ownerId)
+
+  return completedVideos
+}
\ No newline at end of file
diff --git a/src/scheduler/getPendingTasks.mts b/src/scheduler/getPendingTasks.mts
deleted file mode 100644
index f6f4b2dbe1926dd45a2759eee435f9f972669332..0000000000000000000000000000000000000000
--- a/src/scheduler/getPendingTasks.mts
+++ /dev/null
@@ -1,9 +0,0 @@
-import { VideoTask } from "../types.mts"
-import { pendingTasksDirFilePath } from "../config.mts"
-import { readTasks } from "./readTasks.mts"
-
-export const getPendingTasks = async (ownerId?: string): Promise<VideoTask[]> => {
-  const pendingTasks = await readTasks(pendingTasksDirFilePath, ownerId)
-
-  return pendingTasks
-}
\ No newline at end of file
diff --git a/src/scheduler/getPendingVideos.mts b/src/scheduler/getPendingVideos.mts
new file mode 100644
index 0000000000000000000000000000000000000000..ee3b6206910ddc64fbfbd72a528814a1bc7b8f06
--- /dev/null
+++ b/src/scheduler/getPendingVideos.mts
@@ -0,0 +1,9 @@
+import { Video } from "../types.mts"
+import { pendingMetadataDirFilePath } from "../config.mts"
+import { readVideoMetadataFiles } from "./readVideoMetadataFiles.mts"
+
+export const getPendingVideos = async (ownerId?: string): Promise<Video[]> => {
+  const pendingVideos = await readVideoMetadataFiles(pendingMetadataDirFilePath, ownerId)
+
+  return pendingVideos
+}
\ No newline at end of file
diff --git a/src/scheduler/getTask.mts b/src/scheduler/getTask.mts
deleted file mode 100644
index 80aac021e416824972080e0cb78e584f31b6a69b..0000000000000000000000000000000000000000
--- a/src/scheduler/getTask.mts
+++ /dev/null
@@ -1,23 +0,0 @@
-import path from "node:path"
-
-import { completedTasksDirFilePath, pendingTasksDirFilePath } from "../config.mts"
-import { readTask } from "./readTask.mts"
-
-export const getTask = async (ownerId: string, videoId: string) => {
-  const taskFileName = `${ownerId}_${videoId}.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 video task ${videoId} for owner ${ownerId}`)
-    }
-  }
-}
\ No newline at end of file
diff --git a/src/scheduler/getVideo.mts b/src/scheduler/getVideo.mts
new file mode 100644
index 0000000000000000000000000000000000000000..0603c9af44e312db4f7c520fd4f6c358ea4d7ce4
--- /dev/null
+++ b/src/scheduler/getVideo.mts
@@ -0,0 +1,23 @@
+import path from "node:path"
+
+import { completedMetadataDirFilePath, pendingMetadataDirFilePath } from "../config.mts"
+import { readVideoMetadataFile } from "./readVideoMetadataFile.mts"
+
+export const getVideo = async (ownerId: string, videoId: string) => {
+  const videoFileName = `${ownerId}_${videoId}.json`
+
+  const completedVideoMetadataFilePath = path.join(completedMetadataDirFilePath, videoFileName)
+  const pendingVideoMetadataFilePath = path.join(pendingMetadataDirFilePath, videoFileName)
+
+  try {
+    const completedVideo = await readVideoMetadataFile(completedVideoMetadataFilePath)
+    return completedVideo
+  } catch (err) {
+    try {
+      const pendingVideo= await readVideoMetadataFile(pendingVideoMetadataFilePath)
+      return pendingVideo
+    } catch (err) {
+      throw new Error(`couldn't find video ${videoId} for owner ${ownerId}`)
+    }
+  }
+}
\ No newline at end of file
diff --git a/src/scheduler/getVideoStatus.mts b/src/scheduler/getVideoStatus.mts
new file mode 100644
index 0000000000000000000000000000000000000000..85ea782f9e7743c7f7febed77595a9d33cfbecbf
--- /dev/null
+++ b/src/scheduler/getVideoStatus.mts
@@ -0,0 +1,13 @@
+import { Video, VideoStatus } from "../types.mts"
+
+import { getVideo } from "./getVideo.mts"
+
+export const getVideoStatus = async (video: Video): Promise<VideoStatus> => {
+  try {
+    const { status } = await getVideo(video.ownerId, video.id)
+    return status
+  } catch (err) {
+    console.log(`failed to get the video status.. weird`)
+  }
+  return "unknown"
+}
\ No newline at end of file
diff --git a/src/scheduler/markVideoAsPending.mts b/src/scheduler/markVideoAsPending.mts
new file mode 100644
index 0000000000000000000000000000000000000000..499e0ece8d6475ab9726f6213da9f39e3792596a
--- /dev/null
+++ b/src/scheduler/markVideoAsPending.mts
@@ -0,0 +1,25 @@
+import { updatePendingVideo } from "./updatePendingVideo.mts"
+import { getVideo } from "./getVideo.mts"
+
+export const markVideoAsPending = async (ownerId: string, videoId: string) => {
+  try {
+    const video = await getVideo(ownerId, videoId)
+    if (video.status === "abort" ) {
+      // actually, if we wanted to, we could ressurect it..
+      console.log(`cannot mark video as pending: video ${videoId} is aborted`)
+    } else if (video.status === "completed") {
+      console.log(`video ${videoId} is already completed`)
+    } else if (video.status === "delete") {
+      console.log(`cannot mark video as pending: video ${videoId} is marked for deletion`)
+    } else if (video.status === "pending") {
+      console.log(`video ${videoId} is already pending`)
+    } {
+      video.status = "pending"
+      await updatePendingVideo(video)
+      return true
+    }
+  } catch (err) {
+    console.error(`failed to mark video as pending ${videoId}`)
+  }
+  return false
+}
\ No newline at end of file
diff --git a/src/scheduler/markVideoAsToAbort.mts b/src/scheduler/markVideoAsToAbort.mts
new file mode 100644
index 0000000000000000000000000000000000000000..06f98011604d1cb14c2a727dfe76ff3632d1b7dc
--- /dev/null
+++ b/src/scheduler/markVideoAsToAbort.mts
@@ -0,0 +1,22 @@
+import { updatePendingVideo } from "./updatePendingVideo.mts"
+import { getVideo } from "./getVideo.mts"
+
+export const markVideoAsToAbort = async (ownerId: string, videoId: string) => {
+  try {
+    const video = await getVideo(ownerId, videoId)
+    if (video.status === "abort" ) {
+      console.log(`video ${videoId} is already aborted`)
+    } else if (video.status === "delete") {
+      console.log(`cannot abort: video ${videoId} is marked for deletion`)
+    }  else if (video.status === "completed") {
+      console.log(`cannot abort: video ${videoId} is completed`)
+    } {
+      video.status = "abort"
+      await updatePendingVideo(video)
+      return true
+    }
+  } catch (err) {
+    console.error(`failed to abort video ${videoId}`)
+  }
+  return false
+}
\ No newline at end of file
diff --git a/src/scheduler/markVideoAsToDelete.mts b/src/scheduler/markVideoAsToDelete.mts
new file mode 100644
index 0000000000000000000000000000000000000000..98531e979067b4f5e39797debfb3321bbf07bfde
--- /dev/null
+++ b/src/scheduler/markVideoAsToDelete.mts
@@ -0,0 +1,23 @@
+import { updatePendingVideo } from "./updatePendingVideo.mts"
+import { getVideo } from "./getVideo.mts"
+import { deleteVideo } from "./deleteVideo.mts"
+
+export const markVideoAsToDelete = async (ownerId: string, videoId: string) => {
+  try {
+    const video = await getVideo(ownerId, videoId)
+    if (video.status === "delete" ) {
+      console.log(`video ${videoId} is already marked for deletion`)
+    } else if (video.status === "completed" ) {
+      console.log(`video ${videoId} is completed: we can delete immediately`)
+      await deleteVideo(ownerId, videoId)
+      return true
+    } else {
+      video.status = "delete"
+      await updatePendingVideo(video)
+      return true
+    }
+  } catch (err) {
+    console.error(`failed to delete video ${videoId}`)
+  }
+  return false
+}
\ No newline at end of file
diff --git a/src/scheduler/markVideoAsToPause.mts b/src/scheduler/markVideoAsToPause.mts
new file mode 100644
index 0000000000000000000000000000000000000000..581f39138425a440c459148b1cc37d00eb2627a1
--- /dev/null
+++ b/src/scheduler/markVideoAsToPause.mts
@@ -0,0 +1,24 @@
+import { updatePendingVideo } from "./updatePendingVideo.mts"
+import { getVideo } from "./getVideo.mts"
+
+export const markVideoAsToPause = async (ownerId: string, videoId: string) => {
+  try {
+    const video = await getVideo(ownerId, videoId)
+    if (video.status === "abort" ) {
+      console.log(`cannot pause: video ${videoId} is being aborted`)
+    } else if (video.status === "completed") {
+      console.log(`cannot pause: video ${videoId} is completed`)
+    } else if (video.status === "delete") {
+      console.log(`cannot pause: video ${videoId} is marked for deletion`)
+    } else if (video.status === "pause") {
+      console.log(`video ${videoId} is already paused`)
+    } {
+      video.status = "pause"
+      await updatePendingVideo(video)
+      return true
+    }
+  } catch (err) {
+    console.error(`failed to mark video as paused ${videoId}`)
+  }
+  return false
+}
\ No newline at end of file
diff --git a/src/scheduler/processTask.mts b/src/scheduler/processVideo.mts
similarity index 59%
rename from src/scheduler/processTask.mts
rename to src/scheduler/processVideo.mts
index badf2e46f0620286875d7f755c50fc2ae4754f9b..55343229f6add1b8ae77640b6ea229e150857872 100644
--- a/src/scheduler/processTask.mts
+++ b/src/scheduler/processVideo.mts
@@ -1,44 +1,49 @@
 import { v4 as uuidv4 } from "uuid"
 
-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 { Video } from "../types.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"
-import { copyVideoFromPendingToCompleted } from "../utils/copyVideoFromPendingToCompleted.mts"
 import { generateAudio } from "../production/generateAudio.mts"
-import { mergeAudio } from "../production/mergeAudio.mts"
 import { addAudioToVideo } from "../production/addAudioToVideo.mts"
 
-export const processTask = async (task: VideoTask) => {
-  console.log(`processing video task ${task.id}`)
+import { downloadFileToTmp } from "../utils/downloadFileToTmp.mts"
+import { copyVideoFromTmpToPending } from "../utils/copyVideoFromTmpToPending.mts"
+import { copyVideoFromPendingToCompleted } from "../utils/copyVideoFromPendingToCompleted.mts"
 
-  // 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
-  }
+import { saveAndCheckIfNeedToStop } from "./saveAndCheckIfNeedToStop.mts"
+import { enrichVideoSpecsUsingLLM } from "../llm/enrichVideoSpecsUsingLLM.mts"
+
+export const processVideo = async (video: Video) => {
 
-  // always count 1 more step, for the final assembly
+  // just a an additional precaution, for consistency and robustness
+  if (["pause", "completed", "abort", "delete"].includes(video.status)) { return }
 
-  let nbTotalSteps = 1
+  console.log(`processing video video ${video.id}`)
 
-  for (const shot of task.shots) {
+  // always count 2 more steps: 1 for the LLM, 1 for the final assembly
+
+  let nbTotalSteps = 2
+
+  for (const shot of video.shots) {
     nbTotalSteps += shot.nbTotalSteps
   }
 
   let nbCompletedSteps = 0
 
-  for (const shot of task.shots) {
+  if (!video.hasGeneratedSpecs) {
+    await enrichVideoSpecsUsingLLM(video)
+
+    nbCompletedSteps++
+    video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+
+    if (await saveAndCheckIfNeedToStop(video)) { return }
+  }
+
+  for (const shot of video.shots) {
     nbCompletedSteps += shot.nbCompletedSteps
 
     // skip shots completed previously
@@ -56,6 +61,8 @@ export const processTask = async (task: VideoTask) => {
     // const nbFramesForBaseModel = Math.min(3, Math.max(1, Math.round(duration))) * 8
     const nbFramesForBaseModel = 24
 
+    if (await saveAndCheckIfNeedToStop(video)) { return }
+
     if (!shot.hasGeneratedPreview) {
       console.log("generating a preview of the final result..")
       let generatedPreviewVideoUrl = ""
@@ -73,21 +80,20 @@ export const processTask = async (task: VideoTask) => {
 
         await copyVideoFromTmpToPending(shot.fileName)
 
-        await copyVideoFromPendingToCompleted(shot.fileName, task.fileName)
+        await copyVideoFromPendingToCompleted(shot.fileName, video.fileName)
 
         shot.hasGeneratedPreview = true
         shot.nbCompletedSteps++
         nbCompletedSteps++
         shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-        task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
-
-        await updatePendingTask(task)
+        video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
 
+        if (await saveAndCheckIfNeedToStop(video)) { return }
       } 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)
+        video.error = `failed to generate preview for shot ${shot.id} (will try again later)`
+        if (await saveAndCheckIfNeedToStop(video)) { return }
         break
       }
 
@@ -117,16 +123,17 @@ export const processTask = async (task: VideoTask) => {
         shot.nbCompletedSteps++
         nbCompletedSteps++
         shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-        task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+        video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
 
-        await copyVideoFromPendingToCompleted(shot.fileName, task.fileName)
+        await copyVideoFromPendingToCompleted(shot.fileName, video.fileName)
 
-        await updatePendingTask(task)
+        if (await saveAndCheckIfNeedToStop(video)) { return }
       } 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)
+        video.error = `failed to generate shot ${shot.id} (will try again later)`
+        if (await saveAndCheckIfNeedToStop(video)) { return }
+
         break
       }
 
@@ -141,16 +148,18 @@ export const processTask = async (task: VideoTask) => {
         shot.nbCompletedSteps++
         nbCompletedSteps++
         shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-        task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+        video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
 
-        await copyVideoFromPendingToCompleted(shot.fileName, task.fileName)
+        await copyVideoFromPendingToCompleted(shot.fileName, video.fileName)
+
+        if (await saveAndCheckIfNeedToStop(video)) { return }
 
-        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)
+        video.error = `failed to upscale shot ${shot.id} (will try again later)`
+        if (await saveAndCheckIfNeedToStop(video)) { return }
+
         break
       }
     }
@@ -182,17 +191,17 @@ export const processTask = async (task: VideoTask) => {
         shot.nbCompletedSteps++
         nbCompletedSteps++
         shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-        task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+        video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
 
-        await copyVideoFromPendingToCompleted(shot.fileName, task.fileName)
+        await copyVideoFromPendingToCompleted(shot.fileName, video.fileName)
 
-        await updatePendingTask(task)
+        if (await saveAndCheckIfNeedToStop(video)) { return }
 
       } 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)
+        video.error = `failed to interpolate shot ${shot.id} (will try again later)`
+        if (await saveAndCheckIfNeedToStop(video)) { return }
         break
       }
     }
@@ -215,22 +224,22 @@ export const processTask = async (task: VideoTask) => {
         shot.nbCompletedSteps++
         nbCompletedSteps++
         shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-        task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+        video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
 
-        await copyVideoFromPendingToCompleted(shot.fileName, task.fileName)
+        await copyVideoFromPendingToCompleted(shot.fileName, video.fileName)
 
-        await updatePendingTask(task)
+        if (await saveAndCheckIfNeedToStop(video)) { return }
       } 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)
+        video.error = `failed to post-process shot ${shot.id} (will try again later)`
+        if (await saveAndCheckIfNeedToStop(video)) { return }
         break
       }
     }
 
 
-    let foregroundAudioFileName = `${task.ownerId}_${task.id}_${shot.id}_${uuidv4()}.m4a`
+    let foregroundAudioFileName = `${video.ownerId}_${video.id}_${shot.id}_${uuidv4()}.m4a`
 
     if (!shot.hasGeneratedForegroundAudio) {
       if (shot.foregroundAudioPrompt) {
@@ -243,19 +252,19 @@ export const processTask = async (task: VideoTask) => {
           shot.nbCompletedSteps++
           nbCompletedSteps++
           shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-          task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+          video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
 
           await addAudioToVideo(shot.fileName, foregroundAudioFileName)
 
-          await copyVideoFromPendingToCompleted(shot.fileName, task.fileName)
+          await copyVideoFromPendingToCompleted(shot.fileName, video.fileName)
 
-          await updatePendingTask(task)
+          if (await saveAndCheckIfNeedToStop(video)) { return }
 
         } catch (err) {
           console.error(`failed to generate foreground audio for ${shot.id} (${err})`)
           // something is wrong, let's put the whole thing back into the queue
-          task.error = `failed to generate foreground audio ${shot.id} (will try again later)`
-          await updatePendingTask(task)
+          video.error = `failed to generate foreground audio ${shot.id} (will try again later)`
+          if (await saveAndCheckIfNeedToStop(video)) { return }
           break
         }
       } else {
@@ -263,8 +272,8 @@ export const processTask = async (task: VideoTask) => {
         shot.nbCompletedSteps++
         nbCompletedSteps++
         shot.progressPercent = Math.round((shot.nbCompletedSteps / shot.nbTotalSteps) * 100)
-        task.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
-        await updatePendingTask(task)
+        video.progressPercent = Math.round((nbCompletedSteps / nbTotalSteps) * 100)
+        if (await saveAndCheckIfNeedToStop(video)) { return }
       }
     }
 
@@ -272,56 +281,54 @@ export const processTask = async (task: VideoTask) => {
     shot.completedAt = new Date().toISOString()
     shot.progressPercent = 100
 
-    task.nbCompletedShots++
+    video.nbCompletedShots++
 
-    await updatePendingTask(task)
+    if (await saveAndCheckIfNeedToStop(video)) { return }
   }
 
   console.log(`end of the loop:`)
-  console.log(`nb completed shots: ${task.nbCompletedShots}`)
-  console.log(`len of the shot array: ${task.shots.length}`)
+  console.log(`nb completed shots: ${video.nbCompletedShots}`)
+  console.log(`len of the shot array: ${video.shots.length}`)
   
-  if (task.nbCompletedShots === task.shots.length) {
-    console.log(`we have completed the whole video sequence!`)
-    console.log(`assembling the video..`)
+  // now time to check the end game
 
-    if (task.shots.length === 1) {
+  if (video.nbCompletedShots === video.shots.length) {
+    console.log(`we have generated each individual shot!`)
+    console.log(`assembling the fonal..`)
+
+    if (!video.hasAssembledVideo) {
+
+    if (video.shots.length === 1) {
       console.log(`we only have one shot, so this gonna be easy`)
-      task.hasAssembledVideo = true
+      video.hasAssembledVideo = true
 
       // the single shot (so, the first) becomes the final movie
-      await moveVideoFromPendingToCompleted(task.shots[0].fileName, task.fileName)
-
-      await updatePendingTask(task)
-    }
+      await copyVideoFromPendingToCompleted(video.shots[0].fileName, video.fileName)
 
-    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!`)
+      if (await saveAndCheckIfNeedToStop(video)) { return }
+    } else {
+        console.log(`assembling ${video.shots.length} shots together, might take a while`)
+        try {
+          await assembleShots(video.shots, video.fileName)
+          console.log(`finished assembling the ${video.shots.length} shots together!`)
 
-        await moveVideoFromPendingToCompleted(task.fileName)
+          await copyVideoFromPendingToCompleted(video.fileName)
 
-        task.hasAssembledVideo = true
+          video.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
+          if (await saveAndCheckIfNeedToStop(video)) { return }
+        } catch (err) {
+          console.error(`failed to assemble the shots together (${err})`)
+          // something is wrong, let's put the whole thing back into the queue
+          video.error = `failed to assemble the shots together (will try again later)`
+          if (await saveAndCheckIfNeedToStop(video)) { return }
+          return
+        }
       }
     }
 
     nbCompletedSteps++
-    task.progressPercent = 100
-    task.completed = true
-    task.completedAt = new Date().toISOString()
-    await updatePendingTask(task)
-
-    console.log(`moving task to completed tasks..`)
-    await saveCompletedTask(task)
+    video.completed = true
+    if (await saveAndCheckIfNeedToStop(video)) { return }
   }
 }
\ No newline at end of file
diff --git a/src/scheduler/readTask.mts b/src/scheduler/readTask.mts
deleted file mode 100644
index 8ed8f4bb16129364f44d240ff1db8b5a21290da7..0000000000000000000000000000000000000000
--- a/src/scheduler/readTask.mts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { promises as fs } from "node:fs"
-
-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
-}
diff --git a/src/scheduler/readTasks.mts b/src/scheduler/readTasks.mts
deleted file mode 100644
index 4c3e15c894b6e24d7f73432c5af33f2b62d23d47..0000000000000000000000000000000000000000
--- a/src/scheduler/readTasks.mts
+++ /dev/null
@@ -1,45 +0,0 @@
-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, ownerId?: string): Promise<VideoTask[]> => {
-
-  let tasksFiles: string[] = []
-  try {
-    const filesInDir = await fs.readdir(taskDirFilePath)
-    // console.log("filesInDir:", filesInDir)
-
-    // we only keep valid files (in UUID.json format)
-    tasksFiles = filesInDir.filter(fileName =>
-      fileName.match(/[a-z0-9\-_]\.json/i) && (ownerId ? fileName.includes(ownerId): true)
-    )
-
-    // console.log("tasksfiles:", tasksFiles)
-  } catch (err) {
-    console.log(`failed to read tasks: ${err}`)
-  }
-
-  const tasks: VideoTask[] = []
-
-  for (const taskFileName of tasksFiles) {
-    // console.log("taskFileName:", taskFileName)
-    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
-}
diff --git a/src/scheduler/readVideoMetadataFile.mts b/src/scheduler/readVideoMetadataFile.mts
new file mode 100644
index 0000000000000000000000000000000000000000..bc580fc53711fd3becdd4f51af630fa1fb1c6564
--- /dev/null
+++ b/src/scheduler/readVideoMetadataFile.mts
@@ -0,0 +1,11 @@
+import { promises as fs } from "node:fs"
+
+import { Video } from "../types.mts"
+
+export const readVideoMetadataFile = async (videoMetadataFilePath: string): Promise<Video> => {
+  const video = JSON.parse(
+    await fs.readFile(videoMetadataFilePath, 'utf8')
+  ) as Video
+
+  return video
+}
diff --git a/src/scheduler/readVideoMetadataFiles.mts b/src/scheduler/readVideoMetadataFiles.mts
new file mode 100644
index 0000000000000000000000000000000000000000..e383995f8dd4967fdd20c34613e93958ad2b5c85
--- /dev/null
+++ b/src/scheduler/readVideoMetadataFiles.mts
@@ -0,0 +1,44 @@
+import path from "node:path"
+import { promises as fs } from "node:fs"
+
+import { Video } from "../types.mts"
+import { readVideoMetadataFile } from "./readVideoMetadataFile.mts"
+
+export const readVideoMetadataFiles = async (videoMetadataDirFilePath: string, ownerId?: string): Promise<Video[]> => {
+
+  let videosMetadataFiles: string[] = []
+  try {
+    const filesInDir = await fs.readdir(videoMetadataDirFilePath)
+    // console.log("filesInDir:", filesInDir)
+
+    // we only keep valid files (in UUID.json format)
+    videosMetadataFiles = filesInDir.filter(fileName =>
+      fileName.match(/[a-z0-9\-_]\.json/i) && (ownerId ? fileName.includes(ownerId): true)
+    )
+
+    // console.log("videosfiles:", videosFiles)
+  } catch (err) {
+    console.log(`failed to read videos: ${err}`)
+  }
+
+  const videos: Video[] = []
+
+  for (const videoMetadataFileName of videosMetadataFiles) {
+    // console.log("videoFileName:", videoFileName)
+    const videoMetadataFilePath = path.join(videoMetadataDirFilePath, videoMetadataFileName)
+    try {
+      const videoMetadata = await readVideoMetadataFile(videoMetadataFilePath)
+      videos.push(videoMetadata)
+    } catch (parsingErr) {
+      console.log(`failed to read ${videoMetadataFileName}: ${parsingErr}`)
+      console.log(`deleting corrupted file ${videoMetadataFileName}`)
+      try {
+        await fs.unlink(videoMetadataFilePath)
+      } catch (unlinkErr) {
+        console.log(`failed to unlink ${videoMetadataFileName}: ${unlinkErr}`)
+      }
+    }
+  }
+
+  return videos
+}
diff --git a/src/scheduler/saveAndCheckIfNeedToStop.mts b/src/scheduler/saveAndCheckIfNeedToStop.mts
new file mode 100644
index 0000000000000000000000000000000000000000..be1648546b033537a7cdff3d362f2c300481639a
--- /dev/null
+++ b/src/scheduler/saveAndCheckIfNeedToStop.mts
@@ -0,0 +1,68 @@
+import { Video } from "../types.mts"
+import { deleteVideo } from "./deleteVideo.mts"
+import { getVideoStatus } from "./getVideoStatus.mts"
+import { saveCompletedVideo } from "./saveCompletedVideo.mts"
+import { updatePendingVideo } from "./updatePendingVideo.mts"
+
+export const saveAndCheckIfNeedToStop = async (video: Video): Promise<boolean> => {
+  
+  const status = await getVideoStatus(video)
+  const isToDelete =  status === "delete"
+  const isToAbort = status === "abort"
+  const isToPause = status === "pause"
+
+  // well, normally no other process is supported to mark a video as "completed"
+  // while we are busy processing it
+  // but maybe in the future, we can afford to waste procesing power to do the "who goes faster"..?
+  // const isCompleted = status === "completed"
+  
+  const mustStop = isToAbort || isToPause || isToDelete
+
+  // deletion is the most priority check, as we just need to ignore all the rest
+  if (isToDelete) {
+    await deleteVideo(video.ownerId, video.id)
+    return mustStop
+  }
+
+  // then we give priority to the pending video: maybe it is done?
+  if (video.completed) {
+    console.log(`video ${video.id} is completed!`)
+    video.progressPercent = 100
+    video.completedAt = new Date().toISOString()
+    video.status = "completed"
+    await updatePendingVideo(video)
+    await saveCompletedVideo(video)
+    return mustStop
+  }
+
+
+  if (isToPause) {
+    console.log(`we've been requested to pause the video`)
+    video.status = "pause"
+    await updatePendingVideo(video)
+    return mustStop
+  }
+  
+  if (isToAbort) {
+    console.log(`we've been requested to cancel the video`)
+    
+    // we are not going to update the percentage, because we want to keep the
+    // info that we aborted mid-course
+    video.completed = true
+
+    // watch what we do here: we mark the video as completed
+    // that's because "abort" is a temporary status
+    video.status = "completed"
+
+    video.completedAt = new Date().toISOString()
+    await updatePendingVideo(video)
+    await saveCompletedVideo(video)
+
+    return mustStop
+  }
+
+  await updatePendingVideo(video)
+  
+  // tell the loop if it should be aborted or not
+  return mustStop
+}
diff --git a/src/scheduler/saveCompletedTask.mts b/src/scheduler/saveCompletedTask.mts
deleted file mode 100644
index 1a1c81c72b9c0e3b8fac9215e88a8fa44aa1b584..0000000000000000000000000000000000000000
--- a/src/scheduler/saveCompletedTask.mts
+++ /dev/null
@@ -1,12 +0,0 @@
-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.ownerId}_${task.id}.json`
-  const pendingFilePath = path.join(pendingTasksDirFilePath, fileName)
-  const completedFilePath = path.join(completedTasksDirFilePath, fileName)
-  await moveFile(pendingFilePath, completedFilePath)
-}
\ No newline at end of file
diff --git a/src/scheduler/saveCompletedVideo.mts b/src/scheduler/saveCompletedVideo.mts
new file mode 100644
index 0000000000000000000000000000000000000000..4cd54eafa5721e187f1f500fa42b99e71e83a2e1
--- /dev/null
+++ b/src/scheduler/saveCompletedVideo.mts
@@ -0,0 +1,12 @@
+import path from "path"
+
+import { Video } from "../types.mts"
+import { completedMetadataDirFilePath, pendingMetadataDirFilePath } from "../config.mts"
+import { moveFile } from "../utils/moveFile.mts"
+
+export const saveCompletedVideo = async (video: Video) => {
+  const metadataFileName = `${video.ownerId}_${video.id}.json`
+  const pendingMetadataFilePath = path.join(pendingMetadataDirFilePath, metadataFileName)
+  const completedMetadataFilePath = path.join(completedMetadataDirFilePath, metadataFileName)
+  await moveFile(pendingMetadataFilePath, completedMetadataFilePath)
+}
\ No newline at end of file
diff --git a/src/scheduler/savePendingTask.mts b/src/scheduler/savePendingTask.mts
deleted file mode 100644
index 6d9247f1d8344d911332107f2ea97dedb62eef31..0000000000000000000000000000000000000000
--- a/src/scheduler/savePendingTask.mts
+++ /dev/null
@@ -1,11 +0,0 @@
-import { promises as fs } from "node:fs"
-import path from "path"
-
-import { VideoTask } from "../types.mts"
-import { pendingTasksDirFilePath } from "../config.mts"
-
-export const savePendingTask = async (task: VideoTask) => {
-  const fileName = `${task.ownerId}_${task.id}.json`
-  const filePath = path.join(pendingTasksDirFilePath, fileName)
-  await fs.writeFile(filePath, JSON.stringify(task, null, 2), "utf8")
-}
\ No newline at end of file
diff --git a/src/scheduler/savePendingVideo.mts b/src/scheduler/savePendingVideo.mts
new file mode 100644
index 0000000000000000000000000000000000000000..da4f91025b7023bd284cd93e0d36a4b8934f7477
--- /dev/null
+++ b/src/scheduler/savePendingVideo.mts
@@ -0,0 +1,11 @@
+import { promises as fs } from "node:fs"
+import path from "path"
+
+import { Video } from "../types.mts"
+import { pendingMetadataDirFilePath } from "../config.mts"
+
+export const savePendingVideo = async (video: Video) => {
+  const fileName = `${video.ownerId}_${video.id}.json`
+  const filePath = path.join(pendingMetadataDirFilePath, fileName)
+  await fs.writeFile(filePath, JSON.stringify(video, null, 2), "utf8")
+}
\ No newline at end of file
diff --git a/src/scheduler/updatePendingTask.mts b/src/scheduler/updatePendingTask.mts
deleted file mode 100644
index f3ee8f63b59b98200bd965dd5bba705ecb1c52b0..0000000000000000000000000000000000000000
--- a/src/scheduler/updatePendingTask.mts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { promises as fs } from "node:fs"
-import path from "path"
-
-import { VideoTask } from "../types.mts"
-import { pendingTasksDirFilePath } from "../config.mts"
-
-export const updatePendingTask = async (task: VideoTask) => {
-  try {
-    const fileName = `${task.ownerId}_${task.id}.json`
-    const filePath = path.join(pendingTasksDirFilePath, fileName)
-    await fs.writeFile(filePath, JSON.stringify(task, null, 2), "utf8")
-  } catch (err) {
-    console.error(`Failed to update the task. Probably an issue with the serialized object or the file system: ${err}`)
-    // we do not forward the exception, there is no need
-    // we will just try again the job later (even if it means losing a bit of data)
-  }
-}
\ No newline at end of file
diff --git a/src/scheduler/updatePendingVideo.mts b/src/scheduler/updatePendingVideo.mts
new file mode 100644
index 0000000000000000000000000000000000000000..276c4b0bcf935e3b343a7441e55f1b25bbcdae63
--- /dev/null
+++ b/src/scheduler/updatePendingVideo.mts
@@ -0,0 +1,17 @@
+import { promises as fs } from "node:fs"
+import path from "path"
+
+import { Video } from "../types.mts"
+import { pendingMetadataDirFilePath } from "../config.mts"
+
+export const updatePendingVideo = async (video: Video) => {
+  try {
+    const fileName = `${video.ownerId}_${video.id}.json`
+    const filePath = path.join(pendingMetadataDirFilePath, fileName)
+    await fs.writeFile(filePath, JSON.stringify(video, null, 2), "utf8")
+  } catch (err) {
+    console.error(`Failed to update the video. Probably an issue with the serialized object or the file system: ${err}`)
+    // we do not forward the exception, there is no need
+    // we will just try again the job later (even if it means losing a bit of data)
+  }
+}
\ No newline at end of file
diff --git a/src/tests/checkStatus.mts b/src/tests/checkStatus.mts
index b14154494992048a8340707821b31695b869cedb..90529ffd4649e89c81e1f7c9a34dbb9975fe7374 100644
--- a/src/tests/checkStatus.mts
+++ b/src/tests/checkStatus.mts
@@ -9,6 +9,6 @@ const response = await fetch(`${server}/${videoId}`, {
 });
 
 console.log('response:', response)
-const task = await response.json()
+const video = await response.json()
 
-console.log("task:", JSON.stringify(task, null, 2))
+console.log("video:", JSON.stringify(video, null, 2))
diff --git a/src/tests/submitVideo.mts b/src/tests/submitVideo.mts
index e38c3dc1e7741eb084a61326ff87f1a54e8bff45..d87a59a1d01105d62215f374a6c6afbf621fe47a 100644
--- a/src/tests/submitVideo.mts
+++ b/src/tests/submitVideo.mts
@@ -18,6 +18,6 @@ const response = await fetch(`${server}/`, {
 
 
 console.log('response:', response)
-const task = await response.json()
+const video = await response.json()
 
-console.log("task:", JSON.stringify(task, null, 2))
+console.log("video:", JSON.stringify(video, null, 2))
diff --git a/src/types.mts b/src/types.mts
index ca5e9b93c56b07d4302c2a5e888903fbf6f3de05..51dbdc551e82440a93104ceb937927b305e5f790 100644
--- a/src/types.mts
+++ b/src/types.mts
@@ -1,3 +1,13 @@
+
+export type VideoStatus =
+  | 'pending'
+  | 'abort' // this is an order (the video might still being processed by a task)
+  | 'delete' // this is an order (the video might still being processed by a task)
+  | 'pause' // this is an order (the video might still being processed by a task)
+  | 'completed'
+  | 'unknown'
+
+
 export type VideoTransition =
   | 'dissolve'
   | 'bookflip'
@@ -105,6 +115,15 @@ export interface VideoShotMeta {
   shotPrompt: string
   // inputVideo?: string
 
+  // background, weather, lights, time of the day, etc
+  environmentPrompt: string
+
+  // camera parameters, angle, type of shot etc
+  photographyPrompt: string
+
+  // dynamic elements of the scene, movement etc
+  actionPrompt: string
+
   // describe the background audio (crowd, birds, wind, sea etc..)
   backgroundAudioPrompt: string
 
@@ -120,6 +139,8 @@ export interface VideoShotMeta {
   // describe the main actor dialogue line
   actorDialoguePrompt: string
 
+
+
   seed: number
   noise: boolean // add movie noise
   noiseAmount: number // noise strength (default is 2, and 10 is very visible)
@@ -139,6 +160,8 @@ export interface VideoShotMeta {
 export interface VideoShotData {
   // must be unique
   id: string
+  sequenceId: string
+  ownerId: string
 
   fileName: string
 
@@ -158,6 +181,7 @@ export interface VideoShotData {
   nbCompletedSteps: number
   nbTotalSteps: number
   progressPercent: number
+  createdAt: string
   completedAt: string
   completed: boolean
   error: string
@@ -212,9 +236,13 @@ export interface VideoSequenceData {
   // used to check compatibility
   version: number
 
+  status: VideoStatus
+
+  hasGeneratedSpecs: boolean
   hasAssembledVideo: boolean
   nbCompletedShots: number
   progressPercent: number
+  createdAt: string
   completedAt: string
   completed: boolean
   error: string
@@ -222,13 +250,21 @@ export interface VideoSequenceData {
 
 export type VideoSequence = VideoSequenceMeta & VideoSequenceData
 
-export type VideoTaskRequest = Partial<{
+export type VideoStatusRequest = {
+  status: VideoStatus
+}
+
+export type GenericAPIResponse = {
+  success?: boolean
+  error?: string
+}
+
+export type VideoAPIRequest = Partial<{
   prompt: string
-  ownerId: string // to uniquely identify where the video come from
   sequence: Partial<VideoSequenceMeta>
   shots: Array<Partial<VideoShotMeta>>
 }>
 
-export type VideoTask = VideoSequence & {
+export type Video = VideoSequence & {
   shots: VideoShot[]
-}
\ No newline at end of file
+}
diff --git a/src/utils/debouncePromise.mts b/src/utils/debouncePromise.mts
new file mode 100644
index 0000000000000000000000000000000000000000..351fa5d73bef677362da68761605774b80c87e95
--- /dev/null
+++ b/src/utils/debouncePromise.mts
@@ -0,0 +1,66 @@
+/*
+
+Here's how you can use the `debouncePromise` function:
+
+```typescript
+async function fetchData(query: string): Promise<string> {
+  // Simulating an API call
+  return new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(`Results for ${query}`);
+    }, 500);
+  });
+}
+
+const debouncedFetchData = debouncePromise(fetchData, 300);
+
+(async () => {
+  try {
+    console.log(await debouncedFetchData("query 1")); // This will be ignored
+    console.log(await debouncedFetchData("query 2")); // This will be ignored
+    console.log(await debouncedFetchData("query 3")); // This will return "Results for query 3"
+  } catch (error) {
+    console.error(error);
+  }
+})();
+```
+
+The `debouncePromise` function takes a Promise-based function `func` and a `wait` time as its arguments.
+It returns a debounced version of the given function that, when called multiple times within the specified wait time, will only execute the last call.
+*/
+
+type DebouncedFunction<T extends any[], R> = ((...args: T) => R) & {
+  clear: () => void
+}
+
+export function debouncePromise<T extends any[], R>(
+  func: (...args: T) => Promise<R>,
+  wait: number
+): DebouncedFunction<T, Promise<R | undefined>> {
+  let timeout: NodeJS.Timeout | undefined
+
+  const debounced = (...args: T) => {
+    return new Promise<R | undefined>((resolve, reject) => {
+      if (timeout) {
+        clearTimeout(timeout)
+      }
+
+      timeout = setTimeout(async () => {
+        try {
+          const result = await func(...args)
+          resolve(result)
+        } catch (error) {
+          reject(error)
+        }
+      }, wait)
+    })
+  }
+
+  debounced.clear = () => {
+    if (timeout) {
+      clearTimeout(timeout)
+    }
+  }
+
+  return debounced
+}
\ No newline at end of file
diff --git a/src/utils/debounceSync.mts b/src/utils/debounceSync.mts
new file mode 100644
index 0000000000000000000000000000000000000000..5edf30c4a528d8813cbd2ab3f9e0006202b71fd4
--- /dev/null
+++ b/src/utils/debounceSync.mts
@@ -0,0 +1,59 @@
+type DebouncedFunctionSync<T extends any[], R> = ((...args: T) => R) & {
+  clear: () => void
+}
+
+/**
+ * Example usage:
+ * ```typescript
+ *   function fetchDataSync(query: string): string {
+ *     return `Results for ${query}`;
+ *   }
+ *
+ *   const debouncedFetchDataSync = debounceSync(fetchDataSync, 300);
+ *
+ *   try {
+ *    console.log(debouncedFetchDataSync("query 1")); // This will be ignored
+ *     console.log(debouncedFetchDataSync("query 2")); // This will be ignored
+ *     console.log(debouncedFetchDataSync("query 3")); // This will return "Results for query 3"
+ *   } catch (error) {
+ *     console.error(error);
+ *   }
+ * ```
+ *
+ * Note that the synchronous version of the debounce function will return
+ * the result of the last function call or `undefined` if the function was
+ * not called within the specified wait time. You should also be aware that
+ * this synchronous version may cause blocking if the debounced function
+ * takes a long time to execute.
+ *
+ * @param func
+ * @param wait
+ * @returns
+ */
+export function debounceSync<T extends any[], R>(
+  func: (...args: T) => R,
+  wait: number
+): DebouncedFunctionSync<T, R | undefined> {
+  let timeout: NodeJS.Timeout | undefined
+
+  const debounced = (...args: T): R | undefined => {
+    if (timeout) {
+      clearTimeout(timeout)
+    }
+
+    let result: R | undefined
+    timeout = setTimeout(() => {
+      result = func(...args)
+    }, wait)
+
+    return result
+  }
+
+  debounced.clear = () => {
+    if (timeout) {
+      clearTimeout(timeout)
+    }
+  }
+
+  return debounced
+}
\ No newline at end of file
diff --git a/src/utils/deleteAllFilesWith.mts b/src/utils/deleteAllFilesWith.mts
new file mode 100644
index 0000000000000000000000000000000000000000..811d7285f209221561092eac225d4e55d55e8fc8
--- /dev/null
+++ b/src/utils/deleteAllFilesWith.mts
@@ -0,0 +1,15 @@
+import { promises as fs } from "node:fs"
+import path from "node:path"
+
+export const deleteFilesWithName = async (dir: string, name: string) => {
+  for (const file of await fs.readdir(dir)) {
+    if (file.includes(name)) {
+      const filePath = path.join(dir, file)
+      try {
+        await fs.unlink(filePath)
+      } catch (err) {
+        console.error(`failed to unlink file in ${filePath}: ${err}`)
+      }
+    }
+  }
+}
diff --git a/src/utils/parseShotRequest.mts b/src/utils/parseShotRequest.mts
index d60cb8c7240a059541e928e2145f6725e2a69ee4..e91c4a7be574884d2b94c41a7095930b7bbb6ae8 100644
--- a/src/utils/parseShotRequest.mts
+++ b/src/utils/parseShotRequest.mts
@@ -14,9 +14,20 @@ export const parseShotRequest = async (sequence: VideoSequence, maybeShotMeta: P
 
   const shot: VideoShot = {
     id,
+    sequenceId: sequence.id,
+    ownerId: sequence.ownerId,
 
     shotPrompt: `${maybeShotMeta.shotPrompt || ""}`,
 
+    // background, weather, lights, time of the day, etc
+    environmentPrompt: `${maybeShotMeta.environmentPrompt || ""}`,
+
+    // camera parameters, angle, type of shot etc
+    photographyPrompt: `${maybeShotMeta.photographyPrompt || ""}`,
+
+    // dynamic elements of the scene, movement etc
+    actionPrompt: `${maybeShotMeta.actionPrompt || ""}`,
+
     // describe the background audio (crowd, birds, wind, sea etc..)
     backgroundAudioPrompt: `${maybeShotMeta.backgroundAudioPrompt || ""}`,
 
@@ -79,6 +90,7 @@ export const parseShotRequest = async (sequence: VideoSequence, maybeShotMeta: P
     // - post-processing
     nbTotalSteps: 5,
     progressPercent: 0,
+    createdAt: new Date().toISOString(),
     completedAt: '',
     completed: false,
     error: '',
diff --git a/src/utils/parseVideoRequest.mts b/src/utils/parseVideoRequest.mts
index fb5c0108bf6fb048723c022259bf45efb40fa377..ec0d33619dcfea2b6a3b7eadfb8dc0fc912db6b4 100644
--- a/src/utils/parseVideoRequest.mts
+++ b/src/utils/parseVideoRequest.mts
@@ -3,7 +3,7 @@ import { HfInference } from "@huggingface/inference"
 
 // convert a request (which might be invalid)
 
-import { VideoTaskRequest, VideoTask, VideoShotMeta } from "../types.mts"
+import { VideoAPIRequest, Video } from "../types.mts"
 import { getValidNumber } from "./getValidNumber.mts"
 import { getValidResolution } from "./getValidResolution.mts"
 import { parseShotRequest } from "./parseShotRequest.mts"
@@ -13,7 +13,7 @@ import { sequenceFormatVersion } from "../config.mts"
 // const hfi = new HfInference(process.env._VC_HF_API_TOKEN)
 // const hf = hfi.endpoint(process.env.VC_INFERENCE_ENDPOINT_URL)
 
-export const parseVideoRequest = async (request: VideoTaskRequest): Promise<VideoTask> => {
+export const parseVideoRequest = async (ownerId: string, request: VideoAPIRequest): Promise<Video> => {
   // 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()
@@ -26,25 +26,18 @@ export const parseVideoRequest = async (request: VideoTaskRequest): Promise<Vide
     }
     request.shots = [{
       shotPrompt: request.prompt,
+      environmentPrompt: "",
+      photographyPrompt: "",
+      actionPrompt: "",
     }]
   }
 
-  // more or less check that we have a UUID
-  // (I think we can also have an exact match over length === 34)
-  if (uuidValidate(request.ownerId)) {
-    console.log("we have a valid owner:", request.ownerId)
-      // TODO: use llama2 to populate this!
-    request.ownerId
-  } else {
-    request.ownerId = uuidv4()
-  }
-
   // console.log("continuing..")
-  const task: VideoTask = {
+  const video: Video = {
     // ------------ VideoSequenceMeta -------------
     id,
 
-    ownerId: request.ownerId,
+    ownerId,
 
     // describe the whole movie
     videoPrompt: `${request.sequence.videoPrompt || ''}`,
@@ -80,10 +73,13 @@ export const parseVideoRequest = async (request: VideoTaskRequest): Promise<Vide
 
     // ---------- VideoSequenceData ---------
     version: sequenceFormatVersion,
-    fileName: `${request.ownerId}_${id}.mp4`,
+    fileName: `${ownerId}_${id}.mp4`,
+    status: "pending",
     hasAssembledVideo: false,
+    hasGeneratedSpecs: false,
     nbCompletedShots: 0,
     progressPercent: 0,
+    createdAt: new Date().toISOString(),
     completedAt: null,
     completed: false,
     error: '',
@@ -101,13 +97,13 @@ export const parseVideoRequest = async (request: VideoTaskRequest): Promise<Vide
   for (const maybeShot of maybeShots) {
     // console.log("trying shot", maybeShot)
     try {
-      const shot = await parseShotRequest(task, maybeShot)
-      task.shots.push(shot)
+      const shot = await parseShotRequest(video, maybeShot)
+      video.shots.push(shot)
     } catch (err) {
       console.log(`error parsing shot: `, maybeShot)
     }
 
   }
 
-  return task
+  return video
 }
\ No newline at end of file
diff --git a/src/utils/randomShuffle.mts b/src/utils/randomShuffle.mts
new file mode 100644
index 0000000000000000000000000000000000000000..545b80d310ece84f114acd0dbdcf223d12e2c094
--- /dev/null
+++ b/src/utils/randomShuffle.mts
@@ -0,0 +1,8 @@
+export function randomShuffle<T>(array: T[]): T[] { 
+  for (let i = array.length - 1; i > 0; i--) { 
+    const j = Math.floor(Math.random() * (i + 1));
+    [array[i], array[j]] = [array[j], array[i]];
+  } 
+
+  return array
+}; 
\ No newline at end of file
diff --git a/src/utils/sleep.mts b/src/utils/sleep.mts
new file mode 100644
index 0000000000000000000000000000000000000000..2885c6e75c0dc415c9eaf71beabac7461eee5588
--- /dev/null
+++ b/src/utils/sleep.mts
@@ -0,0 +1,6 @@
+export const sleep = async (durationInMs: number) =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(true)
+    }, durationInMs)
+  })
\ No newline at end of file
diff --git a/src/utils/sortPendingVideosByLeastCompletedFirst.mts b/src/utils/sortPendingVideosByLeastCompletedFirst.mts
new file mode 100644
index 0000000000000000000000000000000000000000..501da60bcbbf6898e545da5f977e9c1f31049bd8
--- /dev/null
+++ b/src/utils/sortPendingVideosByLeastCompletedFirst.mts
@@ -0,0 +1,6 @@
+import { Video } from "../types.mts"
+
+export function sortPendingVideosByLeastCompletedFirst(videos: Video[]): Video[] {
+  videos.sort((a: Video, b: Video) => a.progressPercent - b.progressPercent)
+  return videos
+}
\ No newline at end of file
diff --git a/src/utils/sortVideosByYoungestFirst.mts b/src/utils/sortVideosByYoungestFirst.mts
new file mode 100644
index 0000000000000000000000000000000000000000..d509b46eea17233919ab11f3bb1677aa2ac6e6eb
--- /dev/null
+++ b/src/utils/sortVideosByYoungestFirst.mts
@@ -0,0 +1,7 @@
+import { Video } from "../types.mts"
+
+// used by the API, to return latest videos at the top
+export function sortVideosByYoungestFirst(videos: Video[]) {
+  videos.sort((a: Video, b: Video) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
+  return videos
+}
\ No newline at end of file
diff --git a/src/utils/streamToBuffer.mts b/src/utils/streamToBuffer.mts
new file mode 100644
index 0000000000000000000000000000000000000000..d92f1eca663f457de10599d01a5eaec2bd98b89d
--- /dev/null
+++ b/src/utils/streamToBuffer.mts
@@ -0,0 +1,21 @@
+export const streamToBuffer = (
+  stream: NodeJS.ReadWriteStream
+): Promise<Buffer> => {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = []
+    stream.on("data", (chunk: Buffer) => {
+      // console.log("Received chunk with length:"", chunk.length)
+      chunks.push(chunk)
+    })
+    stream.on("error", reject)
+    stream.on("end", () => {
+      /*
+      console.log(
+        "Stream ended, total buffer length:",
+        Buffer.concat(chunks).length
+      )
+      */
+      resolve(Buffer.concat(chunks))
+    })
+  })
+}
\ No newline at end of file
diff --git a/tsconfig.json b/tsconfig.json
index 13a5896b2590d7796ce53e1b93c8c88fae142728..26d982ff3736ba8ddba75d56da6d2b75d26606c7 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -6,7 +6,7 @@
     "module": "nodenext",
     "noEmit": true,
     "allowImportingTsExtensions": true,
-    "target": "es2017"
+    "target": "es2022"
   },
   "include": ["**/*.ts", "**/*.mts"],
 }
\ No newline at end of file