Add sbe_id download flow & file_mode ffmpeg

Propagate a generated sbe_id across download flow and enable file-mode ffmpeg processing for server-side downloads. Changes include: generate and pass sbe_id from download portal into ffmpeg routes; add in-memory transcode job stores and endpoints to track job state in both download and showtime routers; implement temporary S3/ffmpeg-downloads storage, file probing via F_probe_v2(file_mode), and serving of completed downloads with range/headers handling; update ffmpeg command builder to support file inputs, header handling fixes, HLS detection improvements and various robustness fixes (error handling, logging, formatting). Also add S3 entries to .gitignore and several small cleanup tweaks in related routers and libs.

.gitignore

@@ -42,3 +42,8 @@ yarn-error.log*
 **/*.log
 package-lock.json
 **/*.bun
+
+S3
+/S3
+s3
+/s3

src/lib/ffmpeg.ts

@@ -20,8 +20,8 @@ const is_prod =
   APP_ENV === "prod" ||
   APP_ENV === "pre_prod";
 
-const ffmpeg_path = is_prod ? "ffmpeg" : (ffmpeg || "ffmpeg");
-const ffprobe_path = is_prod ? "ffprobe" : (ffprobe.path || "ffprobe");
+const ffmpeg_path = is_prod ? "ffmpeg" : ffmpeg || "ffmpeg";
+const ffprobe_path = is_prod ? "ffprobe" : ffprobe.path || "ffprobe";
 
 // const ffmpeg_path = ffmpeg || "";
 // const ffprobe_path = ffprobe.path;
@@ -223,24 +223,39 @@ async function F_probe_v2(arg0: {
   playback_url: URL;
   playback_type?: string;
   context?: Context;
+  file_mode?: {
+    path: string;
+  };
 }) {
-  const { playback_url, context } = arg0;
+  const { playback_url, context, file_mode } = arg0;
   let { playback_headers } = arg0;
 
-  const [E_, R_] = await NS_promise.F_catch_promise({
-    promise: NS_misc.F_test_connection({
-      url: playback_url,
-      headers: playback_headers
-    })
-  });
+  if (!playback_headers) {
+    playback_headers = {};
+  }
 
-  if (E_) {
-    const { status, message } = NS_error.F_collect_error_status_n_message({
-      ERR: E_
+  if (!playback_url && !file_mode?.path) {
+    throw Error("Invalid playback endpoint");
+  }
+
+  if (playback_url && !file_mode?.path) {
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: NS_misc.F_test_connection({
+        url: playback_url,
+        headers: playback_headers
+      })
     });
 
-    if (["522", "510", "502", "503", "404", "410"].includes(`${status}`))
-      throw E_;
+    if (E_) {
+      const { status, message } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
+
+      if (
+        ["522", "510", "502", "503", "404", "410", "429"].includes(`${status}`)
+      )
+        throw E_;
+    }
   }
 
   const controller = new AbortController();
@@ -349,10 +364,10 @@ async function F_probe_v2(arg0: {
     }
   }
 
-  add_headers_if_needed();
+  if (!file_mode) add_headers_if_needed();
 
   // add the input flag and URL
-  command.push("-i", playback_url.href);
+  command.push("-i", file_mode?.path || playback_url.href);
 
   console.log("[PROBE CMD]", command, "\n");
 
@@ -1000,6 +1015,7 @@ async function F_build_ffmpeg_command_v3(arg0: {
   probe_data: T_Probe;
   output_format: "ts" | "mp4" | "mkv";
   live: string;
+  file_mode?: boolean;
 }) {
   const {
     playback_url,
@@ -1009,11 +1025,13 @@ async function F_build_ffmpeg_command_v3(arg0: {
     subtitles,
     probe_data,
     output_format,
-    live, playback_type
+    live,
+    playback_type,
+    file_mode
   } = arg0;
 
   let { playback_headers } = arg0;
-  
+
   // -------------------------------
   // Logging options
   // -------------------------------
@@ -1081,11 +1099,11 @@ async function F_build_ffmpeg_command_v3(arg0: {
         obj: playback_headers
       });
 
-      // if (ua) command.push("-user_agent", ua);
-      // if (ref) command.push("-referer", ref);
+      if (ua) command.push("-user_agent", ua);
+      if (ref) command.push("-referer", ref);
 
       const other_headers = Object.entries(playback_headers)
-        .filter(([k]) => !["user-agentx", "refererx"].includes(k.toLowerCase()))
+        .filter(([k]) => !["user-agent", "referer"].includes(k.toLowerCase()))
         .map(([k, v]) => `${k}: ${v}`)
         .join("\r\n");
 
@@ -1097,7 +1115,6 @@ async function F_build_ffmpeg_command_v3(arg0: {
 
   add_headers_if_needed();
 
-  // command.push("-http_persistent", "0");
   // command.push("-http_multiple", "0");
   // command.push("-analyzeduration", "10M");
   // command.push("-probesize", "10M");
@@ -1107,7 +1124,12 @@ async function F_build_ffmpeg_command_v3(arg0: {
   command.push("-fflags", "+discardcorrupt+genpts+nobuffer");
   command.push("-err_detect", "ignore_err");
 
-  if(playback_type === 'hls' || (typeof probe_data.format_name === 'string' && probe_data.format_name.includes("hls"))) {
+  if (
+    playback_type === "hls" ||
+    (typeof playback_type === "string" && playback_type.includes("hls")) ||
+    (typeof probe_data.format_name === "string" &&
+      probe_data.format_name.includes("hls"))
+  ) {
     command.push("-http_persistent", "1");
   }
 
@@ -1347,16 +1369,13 @@ async function F_build_ffmpeg_command_v3(arg0: {
 
   /* OUTPUT FORMAT & FLAGS */
 
-  // if (live === "stream") {
-  //   command.push("-f", "ismv");
-  // } else {
-  command.push("-f", output_format === "ts" ? "mpegts" : output_format);
-  // }
+  if (live === "stream") {
+    command.push("-f", "ismv");
+  } else {
+    command.push("-f", output_format === "ts" ? "mpegts" : output_format);
+  }
 
-  command.push(
-    "-avoid_negative_ts",
-    "make_zero"
-  );
+  command.push("-avoid_negative_ts", "make_zero");
 
   if (live === "stream") {
     // command.push("-use_wallclock_as_timestamps", "1");
@@ -1364,7 +1383,7 @@ async function F_build_ffmpeg_command_v3(arg0: {
 
   command.push("-fps_mode", "passthrough");
 
-  if (is_net_src) {
+  if (is_net_src && !file_mode) {
     // command.push("-movflags", "frag_keyframe+empty_moov+default_base_moof");
     command.push("-movflags", "frag_keyframe+dash+delay_moov");
   } else {
@@ -1458,7 +1477,6 @@ function F_stderr_data_read(arg0: { output: string }) {
 }
 
 function F_format_duration(seconds?: number): string {
-
   if (typeof seconds !== "number") {
     return "";
   }
@@ -1469,7 +1487,7 @@ function F_format_duration(seconds?: number): string {
   const mins = Math.floor((seconds % 3600) / 60);
   const secs = Math.floor(seconds % 60);
 
-  let data = '';
+  let data = "";
 
   if (hrs > 0) {
     data = `${hrs}:${mins.toString().padStart(2, "0")}:${secs

src/sub-router/ffmpeg.ts

@@ -22,6 +22,7 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
       let playback_headers = body?.playback_headers;
       let gen = body?.gen;
       let playback_type = body?.playback_type;
+      const sbe_id = body?.sbe_id;
 
       const REQ0 = request.url;
       const REQ_ORIGIN = (ctx as any).publicOrigin || new URL(REQ0).origin;
@@ -67,7 +68,8 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
         promise: NS_ffmpeg.F_probe_v2({
           playback_url: new URL(playback),
           context: ctx,
-          playback_headers, playback_type
+          playback_headers,
+          playback_type
         })
       });
 
@@ -173,6 +175,14 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
         output_destination = `${output_destination}.${output_format}`;
       }
 
+      if (
+        !playback_type &&
+        probe_data &&
+        typeof probe_data.format_name === "string"
+      ) {
+        playback_type = probe_data.format_name;
+      }
+
       const data = {
         playback,
         playback_headers,
@@ -182,7 +192,9 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
         subtitles: subtitles_ary,
         out_mime,
         probe_data,
-        progress_update_endpoint, playback_type
+        progress_update_endpoint,
+        playback_type,
+        sbe_id
       };
 
       const data_str = devalue.stringify(data);
@@ -241,6 +253,14 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
             }
           })
         ),
+        sbe_id: t.Optional(
+          t.String({
+            minLength: 1,
+            error() {
+              return "Invalid sbe id";
+            }
+          })
+        ),
         gen: t.Optional(
           t.Object(
             {

src/sub-router/showtime.ts

@@ -2,15 +2,30 @@ import { Context, Elysia, t } from "elysia";
 import createError from "http-errors";
 import { Subprocess } from "bun";
 import { PassThrough } from "node:stream";
+import node_fs from "node:fs";
 import { NS_misc } from "../lib/misc";
 import * as devalue from "devalue";
 import { NS_promise } from "../lib/promise";
 import { NS_ffmpeg } from "../lib/ffmpeg";
 import { NS_error } from "../lib/error";
 import { redis } from "../lib/upstash";
+import { NS_routes_c } from "../../../../../packages/lib/helpers/client/route";
+import path from "node:path";
 
 const APP_ENV = process.env.APP_ENV;
 
+// Define the job type
+type T_TranscodeJob = {
+  status: "in-progress" | "done" | "failed";
+  tmp_path?: string | null;
+  created_at: number;
+  error?: string;
+  percent?: number;
+};
+
+// Create the store (module level)
+const transcode_jobs = new Map<string, T_TranscodeJob>();
+
 const sub_router = new Elysia({ prefix: "/showtime" })
 
   .get(
@@ -171,7 +186,9 @@ async function F_handle_process(arg0: {
     subtitles,
     out_mime,
     probe_data,
-    progress_update_endpoint, playback_type
+    progress_update_endpoint,
+    playback_type,
+    sbe_id
   } = start_data;
 
   const REQ0 = request.url;
@@ -207,38 +224,19 @@ async function F_handle_process(arg0: {
     output_format = "mp4";
   }
 
-  const is_network_source = true;
+  const is_network_source = is_valid_playback_url;
 
   if (!out_mime) {
     out_mime = (() => {
       switch (output_format) {
         case "mp4":
-          {
-            return "video/mp4";
-          }
-
-          break;
-
+          return "video/mp4";
         case "mkv":
-          {
-            return "video/x-matroska";
-          }
-
-          break;
-
+          return "video/x-matroska";
         case "ts":
-          {
-            return "video/mp2t";
-          }
-
-          break;
-
+          return "video/mp2t";
         default:
-          {
-            return "video/mp4";
-          }
-
-          break;
+          return "video/mp4";
       }
     })();
   }
@@ -330,6 +328,99 @@ async function F_handle_process(arg0: {
     return start_data;
   }
 
+  // -------------------------------
+  // Determine if download mode
+  // -------------------------------
+  const is_download = live === "download" && sbe_id;
+
+  const job_id = is_download ? `${sbe_id}-${output_destination}` : undefined;
+
+  const in_factory = (() => {
+    if (!job_id) return;
+    const current_job = transcode_jobs.get(job_id);
+    if (!current_job) return;
+
+    const job_status = current_job.status;
+    const failed = job_status === "failed";
+    const done = job_status === "done";
+    const in_progress = job_status === "in-progress";
+
+    if (failed) {
+      transcode_jobs.delete(job_id);
+      return;
+    }
+
+    return true;
+  })();
+
+  if (in_factory && job_id) {
+    const current_job = transcode_jobs.get(job_id);
+    const job_status = current_job?.status;
+
+    switch (job_status) {
+      case "in-progress":
+        {
+          const percent = current_job?.percent;
+          const percentage = typeof percent === "number" ? `${percent} %` : "";
+
+          return percentage
+            ? `ENGINE PROGRESS: ${percentage}`
+            : "ENGINE PROCESSING ...";
+        }
+        break;
+
+      case "done":
+        {
+          const file_path = current_job?.tmp_path;
+          const _ = await serve_download({ file_path, job_id, ctx, request });
+          if (_) return _;
+        }
+
+        break;
+    }
+  }
+
+  const tmpDir = path.join(
+    process.cwd(),
+    "S3",
+    "ffmpeg-downloads",
+    `${sbe_id}`
+  );
+
+  let tmp_download_path: string | null | undefined = await (async () => {
+    if (!is_download) return;
+    try {
+      // await Bun.mkdir(tmpDir, { recursive: true }).catch(() => {});
+
+      node_fs.mkdirSync(tmpDir, { recursive: true });
+
+      const tmpPath = path.join(tmpDir, `${Date.now()}-${output_destination}`);
+
+      console.log("\n", tmpPath, "\n");
+
+      return tmpPath;
+    } catch (e) {}
+  })();
+
+  const file_mode = is_download && tmp_download_path;
+
+  if (file_mode) {
+    const found_file = await find_latest_valid_file({
+      sbe_id,
+      output_destination
+    });
+
+    if (typeof found_file === "string" && found_file) {
+      const _ = await serve_download({
+        file_path: found_file,
+        job_id,
+        ctx,
+        request
+      });
+      if (_) return _;
+    }
+  }
+
   // -------------------------------
   // Setup abort handling
   // -------------------------------
@@ -339,9 +430,219 @@ async function F_handle_process(arg0: {
 
   function kill_controller() {
     controller.abort();
+    // Cleanup temp file if user aborts mid-transcode
+    if (tmp_download_path) {
+      const _ = `${tmp_download_path}`;
+      let try_again = 0;
+
+      delete_self();
+
+      function delete_self() {
+        if (try_again > 3) return;
+
+        node_fs.promises.unlink(_).catch((e) => {
+          setTimeout(() => {
+            delete_self();
+            try_again++;
+          }, 1_000);
+        });
+      }
+
+      task_failed();
+    }
+
     console.log("[CONTROLLER] Request aborted");
   }
 
+  function task_failed() {
+    (() => {
+      if (!job_id) return;
+
+      const current_job = transcode_jobs.get(job_id);
+
+      if (!current_job) {
+        transcode_jobs.set(job_id, {
+          status: "failed",
+          tmp_path: tmp_download_path,
+          created_at: Date.now()
+        });
+      } else {
+        transcode_jobs.set(job_id, {
+          ...current_job,
+          status: "failed"
+        });
+      }
+    })();
+  }
+
+  function task_finished() {
+    (() => {
+      if (!job_id) return;
+
+      const current_job = transcode_jobs.get(job_id);
+
+      if (!current_job) {
+        transcode_jobs.set(job_id, {
+          status: "done",
+          tmp_path: tmp_download_path,
+          created_at: Date.now()
+        });
+      } else {
+        transcode_jobs.set(job_id, {
+          ...current_job,
+          status: "done"
+        });
+      }
+    })();
+  }
+
+  function task_processing(arg0: { percent: number }) {
+    const { percent } = arg0;
+
+    (() => {
+      if (!job_id) return;
+
+      const current_job = transcode_jobs.get(job_id);
+
+      if (!current_job) {
+        transcode_jobs.set(job_id, {
+          status: "in-progress",
+          tmp_path: tmp_download_path,
+          percent,
+          created_at: Date.now()
+        });
+      } else {
+        transcode_jobs.set(job_id, {
+          ...current_job,
+          status: "in-progress",
+          percent
+        });
+      }
+    })();
+  }
+
+  async function serve_download(arg0: {
+    file_path: string | null | undefined;
+    job_id?: string;
+    ctx: any;
+    request: Request;
+  }) {
+    const { file_path, job_id, ctx, request } = arg0;
+
+    if (!file_path) {
+      return;
+    }
+
+    const file = Bun.file(file_path);
+    const exists = await file.exists();
+
+    if (!exists) {
+      if (job_id) transcode_jobs.delete(job_id);
+      return;
+    }
+    const file_size = file.size;
+
+    if (!file_size || file_size <= 0) return;
+
+    ctx.set.headers["content-disposition"] =
+      `attachment; filename="${output_destination}"`;
+    ctx.set.headers["cache-control"] = "no-cache";
+    ctx.set.headers["accept-ranges"] = "bytes";
+
+    const range_header = request.headers.get("range");
+
+    // if (range_header) {
+    //   const match = range_header.match(/^bytes=(\d*)-(\d*)$/i);
+    //   if (match) {
+    //     const start = match[1] ? parseInt(match[1], 10) : 0;
+    //     const end = match[2]
+    //       ? Math.min(parseInt(match[2], 10), file_size - 1)
+    //       : file_size - 1;
+
+    //     if (start > end || start >= file_size) {
+    //       ctx.set.status = 416;
+    //       ctx.set.headers["content-range"] = `bytes */${file_size}`;
+    //       return "Range Not Satisfiable";
+    //     }
+
+    //     ctx.set.status = 206;
+    //     ctx.set.headers["content-range"] = `bytes ${start}-${end}/${file_size}`;
+    //     ctx.set.headers["content-length"] = String(end - start + 1);
+    //     return file.slice(start, end + 1);
+    //   }
+    // }
+
+    return file;
+  }
+
+  // ── helper (module level) ───────
+  async function find_latest_valid_file(arg0: {
+    sbe_id: string;
+    output_destination: string;
+  }): Promise<string | null | undefined> {
+    const { sbe_id, output_destination } = arg0;
+
+    const dir = path.join(process.cwd(), "S3", "ffmpeg-downloads", `${sbe_id}`);
+
+    try {
+      const entries = await node_fs.promises.readdir(dir);
+
+      // keep only files that contain output_destination in the name
+      const matches = entries.filter((f) => f.includes(output_destination));
+
+      if (!matches.length) return null;
+
+      // sort descending by the timestamp prefix (e.g. "1714000000000-video.mp4")
+      matches.sort((a, b) => {
+        const ts_a = parseInt(a.split("-")[0]) || 0;
+        const ts_b = parseInt(b.split("-")[0]) || 0;
+        return ts_b - ts_a; // latest first
+      });
+
+      // return the first one that exists and is not corrupted
+      const virgin_file = await (async () => {
+        for (const filename of matches) {
+          const full_path = path.join(dir, filename);
+
+          try {
+            const stat = await node_fs.promises.stat(full_path);
+            if (!(stat.size > 0)) {
+              node_fs.promises.unlink(full_path).catch(() => {});
+              continue;
+            }
+
+            const [E_, R_] = await NS_promise.F_catch_promise({
+              promise: NS_ffmpeg.F_probe_v2({
+                playback_url: new URL("http://localhost:0000/"),
+                context: ctx as any,
+                file_mode: {
+                  path: full_path
+                }
+              })
+            });
+
+            if (R_ && R_.probe_data) {
+              return full_path;
+            }
+
+            if (E_) {
+              node_fs.promises.unlink(full_path).catch(() => {});
+            }
+          } catch (e) {
+            continue;
+          }
+        }
+      })();
+
+      if (virgin_file) {
+        return virgin_file;
+      }
+    } catch (e) {
+      // dir doesn't exist yet or unreadable
+      return null;
+    }
+  }
+
   if (abort_signal) {
     if (abort_signal.aborted) {
       kill_controller();
@@ -372,16 +673,22 @@ async function F_handle_process(arg0: {
     subtitles: subtitles_ary,
     has_tcp_progress: tcp_progress,
     is_net_src: is_network_source,
-    playback_headers: playback_headers, playback_type
+    playback_headers: playback_headers,
+    playback_type,
+    file_mode: file_mode
   });
 
   if (tcp_progress) {
     commands.push("-progress", progress_feedback_url!.trim());
   } else {
-    commands.push("-progress", "pipe:2"); // progress goes to stderr, for fd3 use "pipe:3"
+    commands.push("-progress", "pipe:2");
   }
 
-  commands.push("-y", "pipe:1");
+  if (file_mode) {
+    commands.push("-y", tmp_download_path);
+  } else {
+    commands.push("-y", "pipe:1");
+  }
 
   if (ops === "cmd") {
     return {
@@ -394,11 +701,14 @@ async function F_handle_process(arg0: {
   // -------------------------------
   if (is_network_source) {
     /* ----------  set response headers  ---------- */
-    ctx.set.headers["content-type"] = out_mime;
+    if (!tmp_download_path) ctx.set.headers["content-type"] = out_mime;
     ctx.set.headers["cache-control"] = "no-cache";
-    if (live === "download") {
-      ctx.set.headers["content-disposition"] =
-        `attachment; filename="${output_destination}"`;
+
+    if (is_download) {
+      if (!tmp_download_path) {
+        ctx.set.headers["content-disposition"] =
+          `attachment; filename="${output_destination}"`;
+      }
     }
     if (probe_data.duration) {
       ctx.set.headers["X-Content-Duration'"] = probe_data.duration;
@@ -424,6 +734,17 @@ async function F_handle_process(arg0: {
   const bun_proc = (() => {
     let proc: Subprocess<"ignore" | "pipe", "pipe", "pipe">;
 
+    if (file_mode) {
+      proc = Bun.spawn([NS_ffmpeg.ffmpeg_path, ...commands], {
+        stdout: "pipe",
+        stderr: "pipe",
+        stdin: "pipe",
+        signal: controller.signal
+      });
+
+      return proc;
+    }
+
     try {
       // Try with extra pipe (fd:3)
       proc = Bun.spawn([NS_ffmpeg.ffmpeg_path, ...commands], {
@@ -472,6 +793,8 @@ async function F_handle_process(arg0: {
   const original_filesize =
     probe_data && NS_ffmpeg.F_format_size(probe_data?.size);
 
+  let schemed_data: any = null;
+
   // capture stderr for  errors/warnings/misc
   (async () => {
     for await (const chunk of bun_proc.stderr) {
@@ -480,7 +803,7 @@ async function F_handle_process(arg0: {
       if (!log) continue;
 
       // console.log(log, "\n");
-      
+
       if (log.toLowerCase().includes("error") || log.startsWith("[error]")) {
         console.error("[ffmpeg log ERROR]", log, "\n");
         logged_proc_errors.push(log);
@@ -526,19 +849,26 @@ async function F_handle_process(arg0: {
 
       if (progress_update && Object.keys(progress_update).length > 0) {
         (() => {
-          if(progress_update.video_duration && !progress_update.f_video_duration) {
+          if (
+            progress_update.video_duration &&
+            !(progress_update as any).f_video_duration
+          ) {
             let _: any = progress_update.video_duration;
-            if(typeof progress_update.video_duration !== 'string' && typeof progress_update.video_duration !== 'number') {
-              return
+            if (
+              typeof progress_update.video_duration !== "string" &&
+              typeof progress_update.video_duration !== "number"
+            ) {
+              return;
             }
 
-            if(typeof progress_update.video_duration === 'string') {
-              _ = parseFloat(progress_update.video_duration)
+            if (typeof progress_update.video_duration === "string") {
+              _ = parseFloat(progress_update.video_duration);
             }
 
-            progress_update.f_video_duration = NS_ffmpeg.F_format_duration(_);
+            (progress_update as any).f_video_duration =
+              NS_ffmpeg.F_format_duration(_);
           }
-        })()
+        })();
 
         if (APP_ENV === "dev") {
           console.log("[ffmpeg PROGRESS]:", { progress_update }, "\n");
@@ -554,6 +884,19 @@ async function F_handle_process(arg0: {
           ...(play_title ? { play_title } : {})
         };
 
+        schemed_data = progress_update;
+
+        (() => {
+          const percent = (progress_update as any)?.percentage;
+          if (percent && parseFloat(`${percent}`)) {
+            task_processing({ percent: parseFloat(`${percent}`) });
+
+            if (parseFloat(`${percent}`) >= 100) {
+              task_finished();
+            }
+          }
+        })();
+
         // forward progress update to websocket clients
         if (
           progress_update_endpoint &&
@@ -592,6 +935,42 @@ async function F_handle_process(arg0: {
   const passthrough = new PassThrough();
 
   (async () => {
+    if (file_mode) {
+      try {
+        const reader = bun_proc.stdout.getReader();
+        const decoder = new TextDecoder();
+
+        while (true) {
+          kill_controller_timeout();
+          (() => {
+            if (!job_id) return;
+            transcode_jobs.set(job_id, {
+              status: "in-progress",
+              tmp_path: tmp_download_path,
+              created_at: Date.now()
+            });
+          })();
+
+          const { done, value } = await reader.read();
+          if (done) {
+            console.log("\n");
+            console.log(
+              `FFMPEG finished -> ${schemed_data?.current_filesize} ${tmp_download_path}`,
+              "\n"
+            );
+            break;
+          }
+
+          // if (APP_ENV === "dev") {
+          //   console.log(`FFMPEG STDOUT: ${decoder.decode(value)}`);
+          // }
+        }
+      } catch (e) {
+        console.error("Error reading stdout:", e);
+      }
+      return;
+    }
+
     try {
       for await (const chunk of bun_proc.stdout) {
         kill_controller_timeout(); // first byte → cancel
@@ -601,9 +980,15 @@ async function F_handle_process(arg0: {
       passthrough.end();
     } catch (e) {
       passthrough.destroy(e as Error);
+      task_failed();
     }
   })();
 
+  if (file_mode) {
+    // return "Compile started, check your output folder: " + tmp_download_path;
+    return `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
+  }
+
   bun_proc.exited.then((code: number) => {
     kill_controller_timeout();
 
@@ -614,7 +999,10 @@ async function F_handle_process(arg0: {
     }
 
     if (code === 0) {
-      console.log(`FFmpeg finished -> ${output_destination}`, "\n");
+      console.log(
+        `FFMPEG finished -> ${schemed_data?.current_filesize} ${output_destination}`,
+        "\n"
+      );
     } else {
       console.warn(
         `FFmpeg exited with code: ${code}`,