Proxima: forward method/body; refactor showtime

Forward decoded proxy commands (method and upstream_payload) through proxima proxy handlers (backend Hono/Elysia and Cloudflare worker) so upstream requests can use POST bodies and custom methods. Add handling for base64-embedded payloads (b64.base and b64.data) in download.portal.helper and include b64 metadata in the ffmpeg response. Refactor showtime route into a reusable F_handle_process function, add a POST /:live endpoint, tighten parameter validation, and support ops (cmd/raw/decode). Add a test /baz7 route, bump several cloudflare_worker dev/deps versions, and comment out the Wrangler build command. These changes enable proxying of POST payloads and improve maintainability of the showtime processing logic.

src/sub-router/ffmpeg.ts

@@ -198,7 +198,11 @@ const sub_router = new Elysia({ prefix: "/ffmpeg" })
       return {
         follow: url_o.href,
         ...data,
-        metadata: R_.metadata
+        metadata: R_.metadata,
+        b64: {
+          base: new URL(`/showtime/${live}`, REQ_ORIGIN).toString(),
+          data: data_b64
+        }
       };
     },
     {

src/sub-router/showtime.ts

@@ -10,536 +10,595 @@ import { NS_error } from "../lib/error";
 
 const APP_ENV = process.env.APP_ENV;
 
-const sub_router = new Elysia({ prefix: "/showtime" }).get(
-  "/:live/:data",
-  async (ctx) => {
-    const { params, query, request, status } = ctx;
-    let { live, data } = params;
-    let { ops } = query;
-
-    const start_data = (() => {
-      try {
-        let raw: any = data;
-        const is_encoded = NS_misc.isUrlEncoded(data);
-
-        if (is_encoded) {
-          raw = decodeURIComponent(data);
-        }
-
-        // // Add back padding if needed
-        // let data_b64 = raw;
-        //
-        // while (data_b64.length % 4) {
-        //   data_b64 += "=";
-        // }
-        // data_b64 = data_b64.replace(/-/g, "+").replace(/_/g, "/");
-        // raw = Buffer.from(data_b64, "base64").toString("utf8");
-
-        raw = Buffer.from(raw, "base64").toString("utf8");
-
-        raw = devalue.parse(raw);
-
-        return raw;
-      } catch (error: unknown) {
-        console.error(error);
-        return;
-      }
-    })();
-
-    if (
-      !start_data ||
-      typeof start_data !== "object" ||
-      Array.isArray(start_data)
-    ) {
-      throw createError(400, "Please provide valid start data");
+const sub_router = new Elysia({ prefix: "/showtime" })
+
+  .get(
+    "/:live/:data",
+    async (ctx) => {
+      const { params, query, request, status } = ctx;
+      let { live, data } = params;
+      let { ops } = query;
+
+      return await F_handle_process({ data, request, ops, ctx, live });
+    },
+    {
+      params: t.Object({
+        live: t.Union([t.Literal("download"), t.Literal("stream")], {
+          error() {
+            return "Invalid live operation, must be one of: download, stream";
+          }
+        }),
+        data: t.String({
+          minLength: 1,
+          error() {
+            return "Invalid process data, Expected string";
+          }
+        })
+      }),
+      query: t.Object({
+        raw: t.Optional(
+          t.Number({
+            minimum: 0,
+            maximum: 1,
+            error: () => "Invalid raw, Expected binary boolean"
+          })
+        ),
+        ops: t.Optional(
+          t.Union([t.Literal("cmd"), t.Literal("raw"), t.Literal("decode")], {
+            error() {
+              return "Invalid operation, must be one of: cmd, raw, decode";
+            }
+          })
+        )
+      })
     }
-
-    if (ops === "decode") {
-      return start_data;
+  )
+
+  .post(
+    "/:live",
+    async (ctx) => {
+      const { params, query, body, request, status } = ctx;
+      let { live } = params;
+      let { ops } = query;
+      let { data } = body;
+
+      return await F_handle_process({ data, request, ops, ctx, live });
+    },
+    {
+      params: t.Object({
+        live: t.Union([t.Literal("download"), t.Literal("stream")], {
+          error() {
+            return "Invalid live operation, must be one of: download, stream";
+          }
+        })
+      }),
+      query: t.Object({
+        raw: t.Optional(
+          t.Number({
+            minimum: 0,
+            maximum: 1,
+            error: () => "Invalid raw, Expected binary boolean"
+          })
+        ),
+        ops: t.Optional(
+          t.Union([t.Literal("cmd"), t.Literal("raw"), t.Literal("decode")], {
+            error() {
+              return "Invalid operation, must be one of: cmd, raw, decode";
+            }
+          })
+        )
+      }),
+      body: t.Object({
+        data: t.String({
+          minLength: 1,
+          error() {
+            return "Invalid process data, Expected string";
+          }
+        })
+      })
     }
+  );
+
+async function F_handle_process(arg0: {
+  data: string;
+  live: string;
+  ops?: string;
+  request: Request;
+  ctx: any;
+}) {
+  const { data, ops, request, ctx, live } = arg0;
+
+  const start_data = (() => {
+    try {
+      let raw: any = data;
+      const is_encoded = NS_misc.isUrlEncoded(data);
+
+      if (is_encoded) {
+        raw = decodeURIComponent(data);
+      }
 
-    let {
-      playback: playback_url,
-      playback_headers,
-      output_format,
-      output_destination,
-      progress_feedback_url,
-      subtitles,
-      out_mime,
-      probe_data,
-      progress_update_endpoint
-    } = start_data;
+      // // Add back padding if needed
+      // let data_b64 = raw;
+      //
+      // while (data_b64.length % 4) {
+      //   data_b64 += "=";
+      // }
+      // data_b64 = data_b64.replace(/-/g, "+").replace(/_/g, "/");
+      // raw = Buffer.from(data_b64, "base64").toString("utf8");
 
-    const REQ0 = request.url;
-    const REQ_ORIGIN = (ctx as any).publicOrigin || new URL(REQ0).origin;
+      raw = Buffer.from(raw, "base64").toString("utf8");
 
-    const is_valid_playback_url = (() => {
-      const is_encoded = NS_misc.isUrlEncoded(playback_url);
+      raw = devalue.parse(raw);
 
-      if (!is_encoded) playback_url = encodeURI(playback_url);
+      return raw;
+    } catch (error: unknown) {
+      console.error(error);
+      return;
+    }
+  })();
+
+  if (
+    !start_data ||
+    typeof start_data !== "object" ||
+    Array.isArray(start_data)
+  ) {
+    throw createError(400, "Please provide valid start data");
+  }
 
-      return NS_misc.isValidUrlFormat(playback_url);
-    })();
+  if (ops === "decode") {
+    return start_data;
+  }
 
-    const is_valid_progress_feedback_url = (() => {
-      if (!progress_feedback_url) return;
+  let {
+    playback: playback_url,
+    playback_headers,
+    output_format,
+    output_destination,
+    progress_feedback_url,
+    subtitles,
+    out_mime,
+    probe_data,
+    progress_update_endpoint
+  } = start_data;
 
-      const is_encoded = NS_misc.isUrlEncoded(progress_feedback_url);
+  const REQ0 = request.url;
+  const REQ_ORIGIN = (ctx as any).publicOrigin || new URL(REQ0).origin;
 
-      if (!is_encoded) progress_feedback_url = encodeURI(progress_feedback_url);
+  const is_valid_playback_url = (() => {
+    const is_encoded = NS_misc.isUrlEncoded(playback_url);
 
-      return NS_misc.isValidUrlFormat(progress_feedback_url);
-    })();
+    if (!is_encoded) playback_url = encodeURI(playback_url);
 
-    if (!is_valid_playback_url) {
-      throw createError(400, "Please provide a valid playback URL");
-    }
+    return NS_misc.isValidUrlFormat(playback_url);
+  })();
 
-    if (!is_valid_playback_url) {
-      throw createError(400, "Please provide a valid playback URL");
-    }
+  const is_valid_progress_feedback_url = (() => {
+    if (!progress_feedback_url) return;
 
-    if (!output_format) {
-      output_format = "mp4";
-    }
+    const is_encoded = NS_misc.isUrlEncoded(progress_feedback_url);
 
-    const is_network_source = true;
+    if (!is_encoded) progress_feedback_url = encodeURI(progress_feedback_url);
 
-    if (!out_mime) {
-      out_mime = (() => {
-        switch (output_format) {
-          case "mp4":
-            {
-              return "video/mp4";
-            }
+    return NS_misc.isValidUrlFormat(progress_feedback_url);
+  })();
 
-            break;
-
-          case "mkv":
-            {
-              return "video/x-matroska";
-            }
-
-            break;
-
-          case "ts":
-            {
-              return "video/mp2t";
-            }
-
-            break;
+  if (!is_valid_playback_url) {
+    throw createError(400, "Please provide a valid playback URL");
+  }
 
-          default:
-            {
-              return "video/mp4";
-            }
+  if (!is_valid_playback_url) {
+    throw createError(400, "Please provide a valid playback URL");
+  }
 
-            break;
-        }
-      })();
-    }
+  if (!output_format) {
+    output_format = "mp4";
+  }
 
-    if (!output_destination) {
-      output_destination = `video-${Date.now()}.${output_format}`.trim();
-    }
+  const is_network_source = true;
 
-    if (!output_destination.endsWith(`.${output_format}`)) {
-      output_destination = `${output_destination}.${output_format}`;
-    }
+  if (!out_mime) {
+    out_mime = (() => {
+      switch (output_format) {
+        case "mp4":
+          {
+            return "video/mp4";
+          }
 
-    const tcp_progress = is_valid_progress_feedback_url ? true : false;
+          break;
 
-    const subtitles_ary = (() => {
-      if (!subtitles) return;
+        case "mkv":
+          {
+            return "video/x-matroska";
+          }
 
-      const _ = (() => {
-        if (typeof subtitles === "string") {
-          try {
-            const data = JSON.parse(subtitles);
+          break;
 
-            if (typeof data === "object") return data;
-          } catch (error: unknown) {
-            return;
+        case "ts":
+          {
+            return "video/mp2t";
           }
-        }
 
-        return subtitles;
-      })();
+          break;
 
-      if (typeof _ === "object") {
-        if (!Array.isArray(_)) {
-          return [_];
-        }
+        default:
+          {
+            return "video/mp4";
+          }
 
-        return _;
+          break;
       }
     })();
+  }
 
-    start_data.subtitles = subtitles_ary;
+  if (!output_destination) {
+    output_destination = `video-${Date.now()}.${output_format}`.trim();
+  }
 
-    playback_headers = (() => {
-      if (!playback_headers) {
-        return {};
-      }
+  if (!output_destination.endsWith(`.${output_format}`)) {
+    output_destination = `${output_destination}.${output_format}`;
+  }
 
-      if (
-        typeof playback_headers === "object" &&
-        !Array.isArray(playback_headers)
-      ) {
-        return playback_headers;
-      }
+  const tcp_progress = is_valid_progress_feedback_url ? true : false;
+
+  const subtitles_ary = (() => {
+    if (!subtitles) return;
 
-      if (typeof playback_headers === "string") {
+    const _ = (() => {
+      if (typeof subtitles === "string") {
         try {
-          const data = JSON.parse(playback_headers);
+          const data = JSON.parse(subtitles);
 
-          if (typeof data === "object" && !Array.isArray(data)) {
-            return data;
-          }
-        } catch (error: unknown) {}
+          if (typeof data === "object") return data;
+        } catch (error: unknown) {
+          return;
+        }
       }
 
-      return {};
+      return subtitles;
     })();
 
-    if (typeof probe_data !== "object" || Array.isArray(probe_data)) {
-      const [E_, R_] = await NS_promise.F_catch_promise({
-        promise: NS_ffmpeg.F_probe_v2({
-          playback_url: new URL(playback_url),
-          context: ctx as any,
-          playback_headers
-        })
-      });
-
-      if (E_ || !R_) {
-        const { status, message } = NS_error.F_collect_error_status_n_message({
-          ERR: E_
-        });
-
-        throw createError(status, message);
+    if (typeof _ === "object") {
+      if (!Array.isArray(_)) {
+        return [_];
       }
 
-      probe_data = R_.probe_data;
+      return _;
     }
+  })();
+
+  start_data.subtitles = subtitles_ary;
 
-    if (ops === "raw") {
-      return start_data;
+  playback_headers = (() => {
+    if (!playback_headers) {
+      return {};
     }
 
-    // -------------------------------
-    // Setup abort handling
-    // -------------------------------
-    const abort_signal = ctx?.request.signal;
+    if (
+      typeof playback_headers === "object" &&
+      !Array.isArray(playback_headers)
+    ) {
+      return playback_headers;
+    }
 
-    const controller = new AbortController();
+    if (typeof playback_headers === "string") {
+      try {
+        const data = JSON.parse(playback_headers);
 
-    function kill_controller() {
-      controller.abort();
-      console.log("[CONTROLLER] Request aborted");
+        if (typeof data === "object" && !Array.isArray(data)) {
+          return data;
+        }
+      } catch (error: unknown) {}
     }
 
-    if (abort_signal) {
-      if (abort_signal.aborted) {
-        kill_controller();
-      } else {
-        abort_signal.addEventListener(
-          "abort",
-          () => {
-            kill_controller();
-          },
-          {
-            once: true
-          }
-        );
-      }
-    }
+    return {};
+  })();
 
-    console.log("\n", "PINGING FFMPEG NOW", "\n");
-
-    // -------------------------------
-    // Build commands
-    // -------------------------------
-    const commands = await NS_ffmpeg.F_build_ffmpeg_command_v3({
-      playback_url: new URL(playback_url),
-      context: ctx as any,
-      output_format,
-      live,
-      probe_data,
-      subtitles: subtitles_ary,
-      has_tcp_progress: tcp_progress,
-      is_net_src: is_network_source,
-      playback_headers: playback_headers
+  if (typeof probe_data !== "object" || Array.isArray(probe_data)) {
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: NS_ffmpeg.F_probe_v2({
+        playback_url: new URL(playback_url),
+        context: ctx as any,
+        playback_headers
+      })
     });
 
-    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"
+    if (E_ || !R_) {
+      const { status, message } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
+
+      throw createError(status, message);
     }
 
-    commands.push("-y", "pipe:1");
+    probe_data = R_.probe_data;
+  }
+
+  if (ops === "raw") {
+    return start_data;
+  }
+
+  // -------------------------------
+  // Setup abort handling
+  // -------------------------------
+  const abort_signal = ctx?.request.signal;
+
+  const controller = new AbortController();
+
+  function kill_controller() {
+    controller.abort();
+    console.log("[CONTROLLER] Request aborted");
+  }
 
-    if (ops === "cmd") {
-      return {
-        commands
-      };
+  if (abort_signal) {
+    if (abort_signal.aborted) {
+      kill_controller();
+    } else {
+      abort_signal.addEventListener(
+        "abort",
+        () => {
+          kill_controller();
+        },
+        {
+          once: true
+        }
+      );
     }
+  }
 
-    // -------------------------------
-    // network response headers
-    // -------------------------------
-    if (is_network_source) {
-      /* ----------  set response headers  ---------- */
-      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(probe_data.duration) {
-        ctx.set.headers["X-Content-Duration'"] = probe_data.duration;
-      }
+  console.log("\n", "PINGING FFMPEG NOW", "\n");
+
+  // -------------------------------
+  // Build commands
+  // -------------------------------
+  const commands = await NS_ffmpeg.F_build_ffmpeg_command_v3({
+    playback_url: new URL(playback_url),
+    context: ctx as any,
+    output_format,
+    live,
+    probe_data,
+    subtitles: subtitles_ary,
+    has_tcp_progress: tcp_progress,
+    is_net_src: is_network_source,
+    playback_headers: playback_headers
+  });
+
+  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("-y", "pipe:1");
+
+  if (ops === "cmd") {
+    return {
+      commands
+    };
+  }
+
+  // -------------------------------
+  // network response headers
+  // -------------------------------
+  if (is_network_source) {
+    /* ----------  set response headers  ---------- */
+    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 (probe_data.duration) {
+      ctx.set.headers["X-Content-Duration'"] = probe_data.duration;
+    }
+  }
 
-    let t: Timer | undefined;
+  let t: Timer | undefined;
 
-    t = setTimeout(kill_controller, NS_ffmpeg.TIMEOUT_MS);
+  t = setTimeout(kill_controller, NS_ffmpeg.TIMEOUT_MS);
 
-    function kill_controller_timeout() {
-      if (t) {
-        clearTimeout(t);
-        t = undefined;
-      }
+  function kill_controller_timeout() {
+    if (t) {
+      clearTimeout(t);
+      t = undefined;
     }
+  }
 
-    // -------------------------------
-    // spawn
-    // -------------------------------
-    console.log("[FFMPEG CMD]", commands, "\n");
+  // -------------------------------
+  // spawn
+  // -------------------------------
+  console.log("[FFMPEG CMD]", commands, "\n");
+
+  const bun_proc = (() => {
+    let proc: Subprocess<"ignore" | "pipe", "pipe", "pipe">;
+
+    try {
+      // Try with extra pipe (fd:3)
+      proc = Bun.spawn([NS_ffmpeg.ffmpeg_path, ...commands], {
+        stdout: "pipe", // video info, stream mapping
+        stderr: "pipe", // normal logs, warnings, errors
+        stdin: "pipe",
+        stdio: ["ignore", "pipe", "pipe", "pipe"] /* 👈 add fd:3 */,
+        signal: controller.signal
+      });
 
-    const bun_proc = (() => {
-      let proc: Subprocess<"ignore" | "pipe", "pipe", "pipe">;
+      (proc as any).extraPipe = true; // custom flag so we know later
+    } catch (err) {
+      console.warn(
+        "[Spawn FFmpeg] Failed to create extra pipe, falling back to stderr:",
+        err
+      );
+
+      // Fallback: no pipe:3
+      proc = Bun.spawn([NS_ffmpeg.ffmpeg_path, ...commands], {
+        stdout: "pipe", // video info, stream mapping
+        stderr: "pipe", // normal logs, warnings, errors
+        stdin: "pipe",
+        signal: controller.signal
+      });
 
-      try {
-        // Try with extra pipe (fd:3)
-        proc = Bun.spawn([NS_ffmpeg.ffmpeg_path, ...commands], {
-          stdout: "pipe", // video info, stream mapping
-          stderr: "pipe", // normal logs, warnings, errors
-          stdin: "pipe",
-          stdio: ["ignore", "pipe", "pipe", "pipe"] /* 👈 add fd:3 */,
-          signal: controller.signal
-        });
-
-        (proc as any).extraPipe = true; // custom flag so we know later
-      } catch (err) {
-        console.warn(
-          "[Spawn FFmpeg] Failed to create extra pipe, falling back to stderr:",
-          err
-        );
+      (proc as any).extraPipe = false;
+    }
 
-        // Fallback: no pipe:3
-        proc = Bun.spawn([NS_ffmpeg.ffmpeg_path, ...commands], {
-          stdout: "pipe", // video info, stream mapping
-          stderr: "pipe", // normal logs, warnings, errors
-          stdin: "pipe",
-          signal: controller.signal
-        });
+    return proc;
+  })();
 
-        (proc as any).extraPipe = false;
-      }
+  const logged_proc_errors: string[] = [];
 
-      return proc;
-    })();
+  const has_pipe_3 = (bun_proc as any).extraPipe && bun_proc.stdio[3];
 
-    const logged_proc_errors: string[] = [];
+  // log progress
+  const decoder = new TextDecoder();
+  let stderrBuffer = ""; // Buffer for incomplete lines
 
-    const has_pipe_3 = (bun_proc as any).extraPipe && bun_proc.stdio[3];
+  // capture progress from fd:3
+  if (has_pipe_3) {
+  }
 
-    // log progress
-    const decoder = new TextDecoder();
-    let stderrBuffer = ""; // Buffer for incomplete lines
+  let video_duration =
+    probe_data && NS_ffmpeg.F_format_duration(probe_data?.duration);
+  const original_filesize =
+    probe_data && NS_ffmpeg.F_format_size(probe_data?.size);
+
+  // capture stderr for  errors/warnings/misc
+  (async () => {
+    for await (const chunk of bun_proc.stderr) {
+      const log = decoder.decode(chunk).trim();
+
+      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);
+        continue;
+      } else if (log.toLowerCase().includes("failed")) {
+        console.error("[ffmpeg log FAIL]", log, "\n");
+        logged_proc_errors.push(log);
+        continue;
+      }
 
-    // capture progress from fd:3
-    if (has_pipe_3) {
-    }
+      let progress_update = NS_ffmpeg.F_stderr_data_read({ output: log });
 
-    let video_duration =
-      probe_data && NS_ffmpeg.F_format_duration(probe_data?.duration);
-    const original_filesize =
-      probe_data && NS_ffmpeg.F_format_size(probe_data?.size);
-
-    // capture stderr for  errors/warnings/misc
-    (async () => {
-      for await (const chunk of bun_proc.stderr) {
-        const log = decoder.decode(chunk).trim();
-
-        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);
-          continue;
-        } else if (log.toLowerCase().includes("failed")) {
-          console.error("[ffmpeg log FAIL]", log, "\n");
-          logged_proc_errors.push(log);
-          continue;
+      if (!parseInt(`${progress_update?.current_out_time}`)) {
+        if (progress_update.video_duration && !probe_data.duration) {
+          probe_data.duration = progress_update.video_duration;
+          video_duration = NS_ffmpeg.F_format_duration(probe_data.duration);
         }
+        (progress_update as any) = undefined;
+      } else {
+        const total_duration = probe_data?.duration || 0;
+        const current_time = progress_update.current_out_time;
+        const current_size_bytes = progress_update.current_size_bytes;
+
+        progress_update.video_duration = total_duration;
+        (progress_update as any).percentage = Math.min(
+          parseFloat(((current_time / total_duration) * 100).toFixed(2)),
+          100
+        );
 
-        let progress_update = NS_ffmpeg.F_stderr_data_read({ output: log });
+        (progress_update as any).f_video_duration = video_duration;
+        (progress_update as any).f_current_out_time =
+          NS_ffmpeg.F_format_duration(current_time);
+        (progress_update as any).original_filesize = original_filesize;
+        (progress_update as any).current_filesize =
+          NS_ffmpeg.F_format_size(current_size_bytes);
+      }
 
-        if (!parseInt(`${progress_update?.current_out_time}`)) {
-          if (progress_update.video_duration && !probe_data.duration) {
-            probe_data.duration = progress_update.video_duration;
-            video_duration = NS_ffmpeg.F_format_duration(probe_data.duration);
-          }
-          (progress_update as any) = undefined;
-        } else {
-          const total_duration = probe_data?.duration || 0;
-          const current_time = progress_update.current_out_time;
-          const current_size_bytes = progress_update.current_size_bytes;
-
-          progress_update.video_duration = total_duration;
-          (progress_update as any).percentage = Math.min(
-            parseFloat(((current_time / total_duration) * 100).toFixed(2)),
-            100
-          );
-
-          (progress_update as any).f_video_duration = video_duration;
-          (progress_update as any).f_current_out_time =
-            NS_ffmpeg.F_format_duration(current_time);
-          (progress_update as any).original_filesize = original_filesize;
-          (progress_update as any).current_filesize =
-            NS_ffmpeg.F_format_size(current_size_bytes);
+      if (APP_ENV === "dev") {
+        if (!progress_update || !(Object.keys(progress_update).length > 0)) {
+          // console.log(`[ffmpeg log] ${log}`, "\n");
         }
+      }
 
+      if (progress_update && Object.keys(progress_update).length > 0) {
         if (APP_ENV === "dev") {
-          if (!progress_update || !(Object.keys(progress_update).length > 0)) {
-            // console.log(`[ffmpeg log] ${log}`, "\n");
-          }
+          console.log("[ffmpeg PROGRESS]:", { progress_update }, "\n");
         }
 
-        if (progress_update && Object.keys(progress_update).length > 0) {
-          if (APP_ENV === "dev") {
-            console.log("[ffmpeg PROGRESS]:", { progress_update }, "\n");
-          }
+        const ws_client_id = ctx.request.headers.get("x-ws-client-id");
 
-          const ws_client_id = ctx.request.headers.get("x-ws-client-id");
-
-          const play_title = ctx.request.headers.get("x-play-title");
-
-          const forward_progress = {
-            filename: output_destination,
-            ...progress_update,
-            ...(play_title ? { play_title } : {})
-          };
-
-          // forward progress update to websocket clients
-          if (
-            progress_update_endpoint &&
-            NS_misc.isValidUrlFormat(progress_update_endpoint)
-          ) {
-            try {
-              fetch(progress_update_endpoint, {
-                method: "POST",
-                headers: {
-                  "Content-Type": "application/json"
-                },
-                body: JSON.stringify(forward_progress)
-              });
-            } catch (e) {}
-          }
+        const play_title = ctx.request.headers.get("x-play-title");
 
-          if (ctx && ctx.request?.headers) {
-            // const ws_clients = NS_websockets.ws_clients;
-            // if (ws_client_id && ws_clients) {
-            //   const target = ws_clients.get(ws_client_id);
-            //   target?.send(
-            //     JSON.stringify({
-            //       type: `${
-            //         live === "download" ? "DOWNLOAD" : "STREAM"
-            //       } PROGRESS`,
-            //       data: forward_progress
-            //     })
-            //   );
-            // }
-          }
+        const forward_progress = {
+          filename: output_destination,
+          ...progress_update,
+          ...(play_title ? { play_title } : {})
+        };
+
+        // forward progress update to websocket clients
+        if (
+          progress_update_endpoint &&
+          NS_misc.isValidUrlFormat(progress_update_endpoint)
+        ) {
+          try {
+            fetch(progress_update_endpoint, {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify(forward_progress)
+            });
+          } catch (e) {}
+        }
+
+        if (ctx && ctx.request?.headers) {
+          // const ws_clients = NS_websockets.ws_clients;
+          // if (ws_client_id && ws_clients) {
+          //   const target = ws_clients.get(ws_client_id);
+          //   target?.send(
+          //     JSON.stringify({
+          //       type: `${
+          //         live === "download" ? "DOWNLOAD" : "STREAM"
+          //       } PROGRESS`,
+          //       data: forward_progress
+          //     })
+          //   );
+          // }
         }
       }
-    })();
+    }
+  })();
 
-    // stream mode
-    const passthrough = new PassThrough();
+  // stream mode
+  const passthrough = new PassThrough();
 
-    (async () => {
-      try {
-        for await (const chunk of bun_proc.stdout) {
-          kill_controller_timeout(); // first byte → cancel
+  (async () => {
+    try {
+      for await (const chunk of bun_proc.stdout) {
+        kill_controller_timeout(); // first byte → cancel
 
-          passthrough.write(chunk);
-        }
-        passthrough.end();
-      } catch (e) {
-        passthrough.destroy(e as Error);
+        passthrough.write(chunk);
       }
-    })();
+      passthrough.end();
+    } catch (e) {
+      passthrough.destroy(e as Error);
+    }
+  })();
 
-    bun_proc.exited.then((code: number) => {
-      kill_controller_timeout();
+  bun_proc.exited.then((code: number) => {
+    kill_controller_timeout();
 
-      if (code !== 0 && !passthrough.destroyed) {
-        passthrough.destroy(new Error(`FFmpeg exited with code ${code}`));
-      } else if (!passthrough.destroyed) {
-        passthrough.end();
-      }
+    if (code !== 0 && !passthrough.destroyed) {
+      passthrough.destroy(new Error(`FFmpeg exited with code ${code}`));
+    } else if (!passthrough.destroyed) {
+      passthrough.end();
+    }
 
-      if (code === 0) {
-        console.log(`FFmpeg finished -> ${output_destination}`, "\n");
-      } else {
-        console.warn(
-          `FFmpeg exited with code: ${code}`,
-          "\n",
-          "[ffmpeg log ERRORS]",
-          logged_proc_errors,
-          "\n"
-        );
-      }
-    });
+    if (code === 0) {
+      console.log(`FFmpeg finished -> ${output_destination}`, "\n");
+    } else {
+      console.warn(
+        `FFmpeg exited with code: ${code}`,
+        "\n",
+        "[ffmpeg log ERRORS]",
+        logged_proc_errors,
+        "\n"
+      );
+    }
+  });
 
-    return passthrough;
-  },
-  {
-    params: t.Object({
-      live: t.Union([t.Literal("download"), t.Literal("stream")], {
-        error() {
-          return "Invalid live operation, must be one of: download, stream";
-        }
-      }),
-      data: t.String({
-        minLength: 1,
-        error() {
-          return "Invalid process data, Expected string";
-        }
-      })
-    }),
-    query: t.Object({
-      raw: t.Optional(
-        t.Number({
-          minimum: 0,
-          maximum: 1,
-          error: () => "Invalid raw, Expected binary boolean"
-        })
-      ),
-      ops: t.Optional(
-        t.Union([t.Literal("cmd"), t.Literal("raw"), t.Literal("decode")], {
-          error() {
-            return "Invalid operation, must be one of: cmd, raw, decode";
-          }
-        })
-      )
-    })
-  }
-);
+  return passthrough;
+}
 
 export const ShowtimeRouter = sub_router;