ok, I think it works now

src/config.mts

@@ -13,7 +13,7 @@ export const completedFilesDirFilePath =  path.join(filesDirPath, "completed")
 
 // this is a semi-persistent storage (we want to renew it from time to time)
 export const cacheDirPath = path.join(storagePath, "cache")
-export const renderedDirFilePath = path.join(filesDirPath, "rendered")
+export const renderedDirFilePath = path.join(cacheDirPath, "rendered")
 
 export const shotFormatVersion = 1
 export const sequenceFormatVersion = 1

src/index.mts

@@ -51,14 +51,22 @@ app.post("/render", async (req, res) => {
     return
   }
 
-  try {
-    const cached = await loadRenderedSceneFromCache(request)
-    const cachedJson = JSON.stringify(cached)
-    res.status(200)
-    res.write(cachedJson)
-    res.end()
-  } catch (err) {
-    // move along
+  if (request.cache === "use") {
+    console.log("client requested to use the cache")
+    try {
+      const cached = await loadRenderedSceneFromCache(request)
+      const cachedJson = JSON.stringify(cached)
+      console.log(`request ${request} is in cache!`)
+      res.status(200)
+      res.write(cachedJson)
+      res.end()
+      return
+    } catch (err) {
+      console.log("request not found in cache: "+ err)
+      // move along
+    }
+  } else if (request.cache === "renew") {
+    console.log("client requested to renew the cache")
   }
 
   let response: RenderedScene = {
@@ -112,12 +120,16 @@ app.get("/render/:renderId", async (req, res) => {
   }
 
   try {
+    // we still try to search for it in the cache
     const cached = await loadRenderedSceneFromCache(undefined, renderId)
     const cachedJson = JSON.stringify(cached)
+    console.log(`request ${renderId} is already in cache, so we return that`)
     res.status(200)
     res.write(cachedJson)
     res.end()
+    return
   } catch (err) {
+    // console.log("renderId not found in cache: "+ err)
     // move along
   }
 
@@ -130,6 +142,7 @@ app.get("/render/:renderId", async (req, res) => {
     segments: []
   }
 
+  // console.log("going to render the scene!")
   try {
     response = await getRenderedScene(renderId)
   } catch (err) {

src/initFolders.mts

@@ -4,7 +4,9 @@ import {
   completedMetadataDirFilePath,
   filesDirPath,
   pendingFilesDirFilePath,
-  completedFilesDirFilePath
+  completedFilesDirFilePath,
+  cacheDirPath,
+  renderedDirFilePath
 } from "./config.mts"
 import { createDirIfNeeded } from "./utils/createDirIfNeeded.mts"
 
@@ -16,4 +18,6 @@ export const initFolders = () => {
   createDirIfNeeded(filesDirPath)
   createDirIfNeeded(pendingFilesDirFilePath)
   createDirIfNeeded(completedFilesDirFilePath)
+  createDirIfNeeded(cacheDirPath)
+  createDirIfNeeded(renderedDirFilePath)
 }

src/production/generateVideo.mts

@@ -32,7 +32,10 @@ export const generateVideo = async (prompt: string, options?: {
   
 
   try {
-    const seed = options?.seed || generateSeed()
+
+    // we treat 0 as meaning "random seed"
+    const seed = (options?.seed ? options.seed : 0) || generateSeed()
+
     const nbFrames = options?.nbFrames || 24 // we can go up to 48 frames, but then upscaling quill require too much memory!
     const nbSteps = options?.nbSteps || 35
 

src/production/renderPipeline.mts

@@ -7,6 +7,7 @@ import { renderImageSegmentation } from "./renderImageSegmentation.mts"
 import { renderVideoSegmentation } from "./renderVideoSegmentation.mts"
 import { upscaleImage } from "../utils/upscaleImage.mts"
 import { renderImageUpscaling } from "./renderImageUpscaling.mts"
+import { saveRenderedSceneToCache } from "../utils/saveRenderedSceneToCache.mts"
 
 export async function renderPipeline(request: RenderRequest, response: RenderedScene) {
   const isVideo = request?.nbFrames > 1
@@ -67,4 +68,23 @@ export async function renderPipeline(request: RenderRequest, response: RenderedS
 
   response.status = "completed"
   response.error = ""
+
+  if (!request.cache || request.cache === "ignore") {
+    console.log("client asked to not use the cache in the rendering pipeline")
+    return
+  }
+
+  console.log("client asked this for cache: "+request.cache)
+
+  try {
+    // since the request is now completed we cache it
+    await saveRenderedSceneToCache(request, response)
+    console.log("successfully saved to cache")
+
+    // we don't really need to remove it from the in-memory cache 
+    // (the cache queue in src/production/renderScene.mts)
+    // since this cache queue has already an automatic pruning
+  } catch (err) {
+    console.error(`failed to save to cache, but no big deal: ${err}`)
+  }
 }

src/production/renderScene.mts

@@ -8,7 +8,7 @@ import { getValidBoolean } from "../utils/getValidBoolean.mts"
 
 const cache: Record<string, RenderedScene> = {}
 const cacheQueue: string[] = []
-const maxCacheSize = 1000
+const maxCacheSize = 2000
 
 export async function renderScene(request: RenderRequest): Promise<RenderedScene> {
   // const key = getCacheKey(scene)

src/types.mts

@@ -271,6 +271,8 @@ export type Video = VideoSequence & {
 
 export type ProjectionMode = 'cartesian' | 'spherical'
 
+export type CacheMode = "use" | "renew" | "ignore"
+
 export interface RenderRequest {
   prompt: string
 
@@ -300,7 +302,7 @@ export interface RenderRequest {
 
   projection: ProjectionMode
 
-  useCache: boolean
+  cache: CacheMode
 }
 
 export interface ImageSegmentationRequest {

src/utils/generateImage.mts

@@ -1,6 +1,7 @@
 import { HfInference } from "@huggingface/inference"
-import { getValidNumber } from "./getValidNumber.mts";
-import { generateSeed } from "./generateSeed.mts";
+
+import { getValidNumber } from "./getValidNumber.mts"
+import { generateSeed } from "./generateSeed.mts"
 
 const hf = new HfInference(process.env.VC_HF_API_TOKEN)
 
@@ -18,7 +19,10 @@ export async function generateImage(options: {
     throw new Error("missing prompt")
   }
   const negativePrompt = options?.negativePrompt || ""
-  const seed = getValidNumber(options?.seed, 0, 2147483647, generateSeed())
+
+  // we treat 0 as meaning "random seed"
+  const seed = (options?.seed ? options.seed : 0) || generateSeed()
+
   const width = getValidNumber(options?.width, 256, 1024, 512)
   const height = getValidNumber(options?.height, 256, 1024, 512)
   const nbSteps = getValidNumber(options?.nbSteps, 5, 50, 25)

src/utils/generateImageSDXL.mts

@@ -25,7 +25,10 @@ export async function generateImageSDXLAsBase64(options: {
     throw new Error("missing prompt")
   }
   const negativePrompt = options?.negativePrompt || ""
-  const seed = getValidNumber(options?.seed, 0, 2147483647, generateSeed())
+  
+  // we treat 0 as meaning "random seed"
+  const seed = (options?.seed ? options.seed : 0) || generateSeed()
+
   const width = getValidNumber(options?.width, 256, 1024, 512)
   const height = getValidNumber(options?.height, 256, 1024, 512)
   const nbSteps = getValidNumber(options?.nbSteps, 5, 100, 20)

src/utils/generateImageSDXL360.mts

@@ -25,7 +25,10 @@ export async function generateImageSDXL360AsBase64(options: {
     throw new Error("missing prompt")
   }
   const negativePrompt = options?.negativePrompt || ""
-  const seed = getValidNumber(options?.seed, 0, 2147483647, generateSeed())
+  
+  // we treat 0 as meaning "random seed"
+  const seed = (options?.seed ? options.seed : 0) || generateSeed()
+
   const width = getValidNumber(options?.width, 256, 1024, 512)
   const height = getValidNumber(options?.height, 256, 1024, 512)
   const nbSteps = getValidNumber(options?.nbSteps, 5, 100, 20)

src/utils/hashRequest.mts

@@ -0,0 +1,23 @@
+import { RenderRequest } from "../types.mts"
+import { computeSha256 } from "./computeSha256.mts"
+
+export function hashRequest(request: RenderRequest) {
+
+  // we ignore the commands associated to cache and stuff
+  const hashable = {
+    prompt: request.prompt,
+    segmentation: request.segmentation,
+    actionnables: request.actionnables,
+    nbFrames: request.actionnables,
+    nbSteps: request.actionnables,
+    seed: request.actionnables,
+    width: request.actionnables,
+    height: request.actionnables,
+    projection: request.actionnables,
+  }
+
+  const requestJson = JSON.stringify(hashable)
+  const hash = computeSha256(requestJson)
+
+  return hash
+}

src/utils/loadRenderedSceneFromCache.mts

@@ -3,7 +3,7 @@ import path from "node:path"
 
 import { RenderRequest, RenderedScene } from "../types.mts"
 import { renderedDirFilePath } from "../config.mts"
-import { computeSha256 } from "./computeSha256.mts"
+import { hashRequest } from "./hashRequest.mts"
 
 export async function loadRenderedSceneFromCache(request?: RenderRequest, id?: string): Promise<RenderedScene> {
   
@@ -11,8 +11,8 @@ export async function loadRenderedSceneFromCache(request?: RenderRequest, id?: s
 
   if (request?.prompt) {
     try {
-      const requestJson = JSON.stringify(request)
-      const hash = computeSha256(requestJson)
+      // note: this hashing function ignores the commands associated to cache and stuff
+      const hash = hashRequest(request)
       pattern = `hash_${hash}`
     } catch (err) {
     }
@@ -24,10 +24,12 @@ export async function loadRenderedSceneFromCache(request?: RenderRequest, id?: s
     throw new Error("invalid request or id")
   }
 
-  for (const cachedFile of await fs.readdir(renderedDirFilePath)) {
+  // console.log("pattern to find: " + pattern)
 
+  for (const cachedFile of await fs.readdir(renderedDirFilePath)) {
+    // console.log("evaluating " + cachedFile)
     if (cachedFile.includes(pattern)) {
-
+      // console.log("matched with " + cachedFile)
       const cacheFilePath = path.join(renderedDirFilePath, cachedFile)
 
       const scene = JSON.parse(
@@ -46,5 +48,5 @@ export async function loadRenderedSceneFromCache(request?: RenderRequest, id?: s
     }
   }
 
-  throw new Error("couldn't find a cached scene with id entry")
+  throw new Error(`couldn't find a cache file for pattern ${pattern}`)
 }

src/utils/moveVideoFromTmpToCompleted.mts

@@ -1,5 +1,7 @@
 import path from "node:path"
+
 import tmpDir from "temp-dir"
+
 import { completedFilesDirFilePath } from "../config.mts"
 import { moveFile } from "./moveFile.mts"
 

src/utils/parseRenderRequest.mts

@@ -5,13 +5,18 @@ import { getValidNumber } from "./getValidNumber.mts"
 
 export function parseRenderRequest(request: RenderRequest) {
 
+  console.log("parseRenderRequest: "+JSON.stringify(request, null, 2))
   try {
     request.nbFrames = getValidNumber(request.nbFrames, 1, 24, 16)
 
     const isVideo = request?.nbFrames === 1
 
-    // important: we need a consistent seed for our multiple rendering passes
-    request.seed = getValidNumber(request.seed, 0, 2147483647, generateSeed())
+    // note that we accept a seed of 0
+    // (this ensure we are able to cache the whote request by signing it)
+    request.seed = getValidNumber(request.seed, 0, 2147483647, 0)
+
+    // but obviously we will treat 0 as the random seed at a later stage
+
     request.nbSteps = getValidNumber(request.nbSteps, 5, 50, 10)
 
     if (isVideo) {
@@ -22,9 +27,11 @@ export function parseRenderRequest(request: RenderRequest) {
       request.height = getValidNumber(request.height, 256, 720, 320)
     }
 
-    request.useCache = getValidBoolean(request.useCache, false)
+    request.cache = request?.cache || "ignore"
   } catch (err) {
     console.error(`failed to parse the render request: ${err}`)
   }
+
+  console.log("parsed request: "+JSON.stringify(request, null, 2))
   return request
 }

src/utils/saveRenderedSceneToCache.mts

@@ -4,18 +4,19 @@ import path from "node:path"
 import { RenderRequest, RenderedScene } from "../types.mts"
 import { renderedDirFilePath } from "../config.mts"
 
-import { computeSha256 } from "./computeSha256.mts"
+import { hashRequest } from "./hashRequest.mts"
 
 export async function saveRenderedSceneToCache(
   request: RenderRequest,
   scene: RenderedScene
 ): Promise<RenderedScene> {
+  // console.log("saveRenderedSceneToCache")
   if (scene.status !== "completed") {
     throw new Error("sorry, it only makes sense to cache a *completed* scene, not a pending or failed one.")
   }
 
-  const requestJson = JSON.stringify(request)
-  const hash = computeSha256(requestJson)
+  //note: this hashing function ignores the commands associated to cache and stuff
+  const hash = hashRequest(request)
   const id = scene.renderId
 
   const cacheFileName = `hash_${hash}_id_${id}.json`
@@ -23,7 +24,19 @@ export async function saveRenderedSceneToCache(
 
   const renderedSceneJson = JSON.stringify(scene)
 
+  /*
+  console.log({
+    request,
+    hash,
+    id,
+    cacheFileName,
+    cacheFilePath,
+    scene
+  })
+  */
+
   await fs.writeFile(cacheFilePath, renderedSceneJson, "utf8")
+  console.log(`saved result to cache`)
 
   return scene
 }