CHANGES

src/sub-router/showtime-v2.ts

@@ -45,6 +45,11 @@ const APP_ORIGIN = () =>
 const HF_BUCKET_NAME = () =>
   NS_runtime.ENV_VAR_DB?.HF_BUCKET_NAME || process.env.HF_BUCKET_NAME;
 
+const is_dev = (() => {
+  // return false;
+  return APP_ENV() === "dev";
+})();
+
 const sub_router = new Elysia({ prefix: "/showtimeV2" }).get(
   "/delivery/:data_key",
   async (ctx) => {
@@ -55,11 +60,6 @@ const sub_router = new Elysia({ prefix: "/showtimeV2" }).get(
     const REQ0 = new URL(request.url);
     const REQ_ORIGIN = (ctx as any).publicOrigin || REQ0.origin;
 
-    const is_dev = (() => {
-      // return false;
-      return APP_ENV() === "dev";
-    })();
-
     const metadata = await (async () => {
       try {
         if (is_dev) {
@@ -85,1242 +85,1288 @@ const sub_router = new Elysia({ prefix: "/showtimeV2" }).get(
       return metadata;
     }
 
-    const {
-      playback,
-      probe_metadata,
-      output_destination,
-      sbe_id,
-      delivery_mode,
-      delivery_format,
-      out_mime,
-      progress_update_endpoint,
-      subtitles
-    } = metadata as T_delivery_payload;
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: handle_data({
+        data_key,
+        metadata,
+        REQ0,
+        REQ_ORIGIN,
+        ctx: ctx as any,
+        ops
+      })
+    });
 
-    const is_download_mode = delivery_mode === "download";
-    const is_stream_mode = delivery_mode === "stream";
+    if (E_) {
+      const { message, status } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
 
-    if (!is_download_mode && !is_stream_mode) {
-      return ctx.status(400, "Unsupported delivery mode");
+      return ctx.status(status, message);
     }
 
-    const clean_metadata = NS_ffmpeg_v2.F_scan_raw_probe_metadata({
-      metadata: probe_metadata
-    });
-
-    const picture_quality = (() => {
-      const _ = playback.picture_quality;
+    return R_;
+  },
+  {
+    params: t.Object({
+      data_key: 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"),
+            t.Literal("just_check")
+          ],
+          {
+            error() {
+              return "Invalid operation, must be one of: cmd, raw, decode";
+            }
+          }
+        )
+      )
+    })
+  }
+);
 
-      if (typeof _ !== "string") {
-        return "";
-      }
+export const ShowtimeV2Router = sub_router;
+export const ShowtimeV2RouterHandlePayload = handle_data;
+
+async function handle_data(arg0: {
+  data_key: string;
+  metadata: T_delivery_payload;
+  REQ0: URL;
+  REQ_ORIGIN: string;
+  ctx: Context;
+  ops?: string;
+  throw_error?: boolean;
+}) {
+  const { data_key, metadata, REQ0, REQ_ORIGIN, ctx, ops, throw_error } = arg0;
 
-      return _.trim().split(" ").join("");
-    })();
+  const {
+    playback,
+    probe_metadata,
+    output_destination,
+    sbe_id,
+    delivery_mode,
+    delivery_format,
+    out_mime,
+    progress_update_endpoint,
+    subtitles
+  } = metadata as T_delivery_payload;
 
-    const sbe_s_e = (() => {
-      const _ = metadata.sbe_s_e;
+  const is_download_mode = delivery_mode === "download";
+  const is_stream_mode = delivery_mode === "stream";
 
-      if (typeof _ !== "string" || _.toLowerCase().includes("nan")) {
-        return;
-      }
+  if (!is_download_mode && !is_stream_mode) {
+    const message = "Unsupported delivery mode";
 
-      return _.trim().split(" ").join("");
-    })();
+    if (throw_error) throw Error(JSON.stringify(message));
 
-    const qLevel = (() => {
-      if (
-        typeof metadata.qLevel === "string" &&
-        metadata.qLevel.trim().length > 0
-      ) {
-        return metadata.qLevel.trim();
-      }
+    return ctx.status(400, message);
+  }
 
-      const _ = NS_ffmpeg_v2.F_get_qLevel({
-        metadata: probe_metadata
-      });
+  const clean_metadata = NS_ffmpeg_v2.F_scan_raw_probe_metadata({
+    metadata: probe_metadata
+  });
 
-      return _;
-    })();
+  const picture_quality = (() => {
+    const _ = playback.picture_quality;
 
-    const ws = (() => {
-      const is_https = new URL(REQ_ORIGIN).protocol === "https:";
+    if (typeof _ !== "string") {
+      return "";
+    }
 
-      const ws_protocol = is_https ? "wss" : "ws";
+    return _.trim().split(" ").join("");
+  })();
 
-      const _ = `${ws_protocol}://${REQ0.host}/ws`;
+  const sbe_s_e = (() => {
+    const _ = metadata.sbe_s_e;
 
-      const data = {
-        connect: _,
-        channel: data_key
-      };
+    if (typeof _ !== "string" || _.toLowerCase().includes("nan")) {
+      return;
+    }
 
-      return data;
-    })();
+    return _.trim().split(" ").join("");
+  })();
 
-    const output_destination_clean = NS_misc.cleanNameV2(output_destination);
+  const qLevel = (() => {
+    if (
+      typeof metadata.qLevel === "string" &&
+      metadata.qLevel.trim().length > 0
+    ) {
+      return metadata.qLevel.trim();
+    }
 
-    const clean_file_id =
-      `${picture_quality}-${output_destination_clean}`.toLowerCase();
+    const _ = NS_ffmpeg_v2.F_get_qLevel({
+      metadata: probe_metadata
+    });
 
-    const job_id = `${sbe_id}-${clean_file_id}`;
+    return _;
+  })();
 
-    const file_id = `${Date.now()}-${clean_file_id}`;
+  const ws = (() => {
+    const is_https = new URL(REQ_ORIGIN).protocol === "https:";
 
-    const cache_folder = `cache/${sbe_id}`;
+    const ws_protocol = is_https ? "wss" : "ws";
 
-    const S3Dir = path.join(STORAGE_ROOT(), `${cache_folder}`);
+    const _ = `${ws_protocol}://${REQ0.host}/ws`;
 
-    // same key the disk flow uploads to, so the seed lookup finds either one
-    const bucket_file_path = `${cache_folder}/${file_id}`;
+    const data = {
+      connect: _,
+      channel: data_key
+    };
 
-    // const dl_to_s3 = is_dev || IS_RENDER_COM();
-    const dl_to_s3 = IS_RENDER_COM();
+    return data;
+  })();
 
-    // S3 PIPE: only download mode pipes to S3, stream mode always goes to the client
-    const use_s3_pipe = is_download_mode && dl_to_s3;
+  const output_destination_clean = NS_misc.cleanNameV2(output_destination);
 
-    // S3 PIPE: fail fast instead of finding out after ffmpeg has started
-    if (use_s3_pipe && (!S3() || !HF_BUCKET_NAME())) {
-      return ctx.status(500, "S3 bucket is not configured");
-    }
+  const clean_file_id =
+    `${picture_quality}-${output_destination_clean}`.toLowerCase();
 
-    const file_with_path = (() => {
-      if (!is_download_mode || use_s3_pipe) return;
+  const job_id = `${sbe_id}-${clean_file_id}`;
 
-      try {
-        node_fs.mkdirSync(S3Dir, { recursive: true });
+  const file_id = `${Date.now()}-${clean_file_id}`;
 
-        return path.join(S3Dir, file_id);
-      } catch (e) {}
-    })();
+  const cache_folder = `cache/${sbe_id}`;
 
-    if (is_download_mode && !use_s3_pipe && !file_with_path) {
-      return ctx.status(500, "Could not prepare the output directory");
-    }
+  const S3Dir = path.join(STORAGE_ROOT(), `${cache_folder}`);
 
-    const MAX_ATTEMPTS = 2;
+  // same key the disk flow uploads to, so the seed lookup finds either one
+  const bucket_file_path = `${cache_folder}/${file_id}`;
 
-    const MAX_LOG_LINES = 200;
+  // const dl_to_s3 = is_dev || IS_RENDER_COM();
+  const dl_to_s3 = IS_RENDER_COM();
 
-    const err_message = (err: unknown) =>
-      NS_error.F_collect_error_message({ ERR: err }).message;
+  // S3 PIPE: only download mode pipes to S3, stream mode always goes to the client
+  const use_s3_pipe = is_download_mode && dl_to_s3;
 
-    const live = {
-      percent: 0,
-      size: "",
-      failed: false,
-      done: false,
-      launched: false,
-      user_aborted: false,
-      last_push: 0
-    };
+  // S3 PIPE: fail fast instead of finding out after ffmpeg has started
+  if (use_s3_pipe && (!S3() || !HF_BUCKET_NAME())) {
+    const message = "S3 bucket is not configured";
 
-    let flags: string[] = [];
-    let progress_data: Record<string, any> | undefined = undefined;
-    let seek_size_bytes = 0;
-    let logged_proc_errors: string[] = [];
-    let logged_proc_info: string[] = [];
-    let has_subs = false;
-    let local_cleaned = false;
-    let attempt = 0;
-    let watchdog: ReturnType<typeof setTimeout> | undefined = undefined;
+    if (throw_error) throw Error(JSON.stringify(message));
 
-    let error_429 = false;
-    let error_end_of_file = false;
-    let error_403 = false;
+    return ctx.status(500, message);
+  }
 
-    let claimed = false;
+  const file_with_path = (() => {
+    if (!is_download_mode || use_s3_pipe) return;
 
-    // S3 PIPE: state of the current attempt's upload
-    type S3Outcome = { success: true } | { success: false; error: unknown };
+    try {
+      node_fs.mkdirSync(S3Dir, { recursive: true });
 
-    let s3_attempt:
-      | { upload: Upload; done: Promise<S3Outcome>; counter: Transform }
-      | undefined = undefined;
+      return path.join(S3Dir, file_id);
+    } catch (e) {}
+  })();
 
-    let s3_bytes = 0;
+  if (is_download_mode && !use_s3_pipe && !file_with_path) {
+    const message = "Could not prepare the output directory";
 
-    let controller = new AbortController();
-    const abort_signal = ctx?.request.signal;
+    if (throw_error) throw Error(JSON.stringify(message));
 
-    const on_request_abort = () => {
-      live.user_aborted = true;
+    return ctx.status(500, "Could not prepare the output directory");
+  }
 
-      kill_controller("client aborted");
-    };
+  const MAX_ATTEMPTS = 2;
 
-    const detach_request_abort = () => {
-      abort_signal?.removeEventListener("abort", on_request_abort);
-    };
+  const MAX_LOG_LINES = 200;
 
-    if (abort_signal?.aborted) {
-      return;
-    }
+  const err_message = (err: unknown) =>
+    NS_error.F_collect_error_message({ ERR: err }).message;
 
-    abort_signal?.addEventListener("abort", on_request_abort, { once: true });
+  const live = {
+    percent: 0,
+    size: "",
+    failed: false,
+    done: false,
+    launched: false,
+    user_aborted: false,
+    last_push: 0
+  };
 
-    const passthrough = is_stream_mode ? new PassThrough() : undefined;
+  let flags: string[] = [];
+  let progress_data: Record<string, any> | undefined = undefined;
+  let seek_size_bytes = 0;
+  let logged_proc_errors: string[] = [];
+  let logged_proc_info: string[] = [];
+  let has_subs = false;
+  let local_cleaned = false;
+  let attempt = 0;
+  let watchdog: ReturnType<typeof setTimeout> | undefined = undefined;
 
-    try {
-      const current_job = transcode_jobs.get(job_id);
-
-      if (current_job?.status === "running") {
-        const percent = current_job?.percent;
-        const uploading = current_job?.uploading;
-        const percentage = typeof percent === "number" ? `${percent} %` : "";
-        const transcoded_size = current_job?.transcoded_size;
-        const progress_endpoint =
-          current_job?.progress_endpoint || progress_update_endpoint;
-
-        const message = percentage
-          ? `ENGINE PROGRESS: ${percentage}`
-          : "ENGINE PROCESSING ...";
-
-        // if(!uploading) 
-          return {
-          processing: true,
-          message,
-          percent,
-          transcoded_size,
-          track_process: progress_endpoint,
-          file: output_destination,
-          job_id,
-          output_destination,
-          qLevel,
-          picture_quality,
-          ws,
-          flags: current_job.flags,
-          logs: current_job.logs,
-          ...(ops === "just_check" ? { passed: true } : {})
-        };
-      }
+  let error_429 = false;
+  let error_end_of_file = false;
+  let error_403 = false;
 
-      if (current_job?.status === "failed") {
-        const logs = current_job?.logs;
+  let claimed = false;
 
-        if (logs) id_log_errors({ logs });
+  // S3 PIPE: state of the current attempt's upload
+  type S3Outcome = { success: true } | { success: false; error: unknown };
 
-        transcode_jobs.delete(job_id);
+  let s3_attempt:
+    | { upload: Upload; done: Promise<S3Outcome>; counter: Transform }
+    | undefined = undefined;
 
-        if (ops === "just_check") {
-          return {
-            passed: false,
-            delivery: output_destination,
-            track_process: progress_update_endpoint,
-            ws,
-            flags: current_job.flags,
-            logs: current_job?.logs
-          };
-        }
+  let s3_bytes = 0;
 
-        // run ffprobe to see if playback still valid
-        const _ = await ping_probe({ playback });
+  let controller = new AbortController();
+  const abort_signal = ctx?.request.signal;
 
-        if (!_?.success) {
-          throw new Error("Something went wrong: with probe");
-        }
-      }
+  const on_request_abort = () => {
+    live.user_aborted = true;
 
-      // check/serve seeded file
-      const seed_file = await (async () => {
-        if (ops === "cmd") {
-          return;
-        }
+    kill_controller("client aborted");
+  };
 
-        const _ = current_job?.db_metadata?.stream_link;
+  const detach_request_abort = () => {
+    abort_signal?.removeEventListener("abort", on_request_abort);
+  };
 
-        if (_) {
-          return current_job.db_metadata;
-        }
+  if (abort_signal?.aborted) {
+    return;
+  }
 
-        const __ = await wide_search_runner({ document: true });
-
-        return __;
-      })();
-
-      if (seed_file) {
-        const file_size_bytes = parseFloat(`${seed_file?.size}`);
-
-        const percent = 100;
-        const transcoded_size = file_size_bytes
-          ? NS_ffmpeg_v2.F_format_size(file_size_bytes)
-          : current_job?.transcoded_size;
-        const progress_endpoint =
-          current_job?.progress_endpoint || progress_update_endpoint;
-
-        if (!current_job?.db_metadata?.stream_link) {
-          record_task_info({
-            job_id,
-            file_with_path: file_with_path || "",
-            status: "done",
-            info: {
-              title: output_destination,
-              percent,
-              transcoded_size,
-              ...("stream_link" in seed_file && seed_file.stream_link
-                ? { db_metadata: seed_file }
-                : {})
-            }
-          });
-        }
+  abort_signal?.addEventListener("abort", on_request_abort, { once: true });
 
-        if (ops === "just_check") {
-          return {
-            passed: true,
-            ready: true,
-            percent,
-            transcoded_size,
-            output_destination,
-            flags: current_job?.flags,
-            logs: current_job?.logs,
-            ...(seed_file && "stream_link" in seed_file && seed_file.stream_link
-              ? { stream_link: seed_file.stream_link }
-              : {}),
-            track_process: progress_endpoint,
-            ws
-          };
-        }
+  const passthrough = is_stream_mode ? new PassThrough() : undefined;
 
-        // handle direct file or url redirect
-        if (seed_file && "stream_link" in seed_file && seed_file.stream_link) {
-          const stream_link = new URL(seed_file.stream_link);
-          stream_link.searchParams.set("download", "true");
-
-          const [E_, R_] = await NS_promise.F_catch_promise({
-            promise: (async () => {
-              const cloudflare =
-                await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
-
-              if (!cloudflare.available) return;
-
-              const _ = await NS_pack_proxima.F_handle_pack_encode({
-                base: new URL(cloudflare.available),
-                payload: {
-                  endpoint: stream_link.toString(),
-                  commands: {
-                    response_headers: {
-                      set: {
-                        "content-disposition": `attachment; filename="${output_destination}"`
-                      }
-                    },
-                    use_h_version: true
-                  }
-                }
-              });
+  try {
+    const current_job = transcode_jobs.get(job_id);
 
-              return { proxy_url: _ };
-            })()
-          });
+    if (current_job?.status === "running") {
+      const percent = current_job?.percent;
+      const uploading = current_job?.uploading;
+      const percentage = typeof percent === "number" ? `${percent} %` : "";
+      const transcoded_size = current_job?.transcoded_size;
+      const progress_endpoint =
+        current_job?.progress_endpoint || progress_update_endpoint;
 
-          const new_stream_link =
-            (R_ as any)?.proxy_url || stream_link.toString();
+      const message = percentage
+        ? `ENGINE PROGRESS: ${percentage}`
+        : "ENGINE PROCESSING ...";
 
-          // 302, not 301: the link is proxied/temporary and browsers cache 301s
-          return ctx.redirect(new_stream_link, 302);
-        } else {
-          // if seed is file set headers
-          construct_response_headers({
-            is_download: true
-          });
+      // if(!uploading)
+      return {
+        processing: true,
+        message,
+        percent,
+        transcoded_size,
+        track_process: progress_endpoint,
+        file: output_destination,
+        job_id,
+        output_destination,
+        qLevel,
+        picture_quality,
+        ws,
+        flags: current_job.flags,
+        logs: current_job.logs,
+        ...(ops === "just_check" ? { passed: true } : {})
+      };
+    }
 
-          return seed_file;
-        }
-      }
+    if (current_job?.status === "failed") {
+      const logs = current_job?.logs;
 
-      // -------------------------------
-      // Build flags
-      // -------------------------------
-      const CMD = await F_cmd({ subs: !error_end_of_file });
+      if (logs) id_log_errors({ logs });
 
-      flags = CMD.flags;
+      transcode_jobs.delete(job_id);
 
       if (ops === "just_check") {
-        // run ffprobe to see if playback still valid
-        const _ = await ping_probe({ playback });
-
-        if (_.success) {
-          return {
-            passed: true,
-            sbe_id,
-            delivery: output_destination,
-            qLevel,
-            picture_quality,
-            track_process: progress_update_endpoint,
-            ws,
-            flags
-          };
-        }
-
         return {
           passed: false,
           delivery: output_destination,
           track_process: progress_update_endpoint,
-          flags
+          ws,
+          flags: current_job.flags,
+          logs: current_job?.logs
         };
       }
 
-      if (ops === "cmd") {
-        return {
-          cmd: flags
-        };
+      // run ffprobe to see if playback still valid
+      const _ = await ping_probe({ playback });
+
+      if (!_?.success) {
+        throw new Error("Something went wrong: with probe");
       }
+    }
 
-      // the client gave up while we were preparing
-      if (controller.signal.aborted) {
+    // check/serve seeded file
+    const seed_file = await (async () => {
+      if (ops === "cmd") {
         return;
       }
 
-      // -------------------------------
-      // network response headers
-      // -------------------------------
-      construct_response_headers({
-        is_streaming: is_stream_mode
-      });
+      const _ = current_job?.db_metadata?.stream_link;
 
-      NS_Misc.console.log({
-        ENV: "dev",
-        _browser: false,
-        _log: ["[FFMPEG FLAGS]", flags, "\n"]
-      });
+      if (_) {
+        return current_job.db_metadata;
+      }
+
+      const __ = await wide_search_runner({ document: true });
 
-      claimed = true;
+      return __;
+    })();
+
+    if (seed_file) {
+      const file_size_bytes = parseFloat(`${seed_file?.size}`);
 
-      // -------------------------------
-      // spawn
-      // -------------------------------
-      if (!is_stream_mode) {
+      const percent = 100;
+      const transcoded_size = file_size_bytes
+        ? NS_ffmpeg_v2.F_format_size(file_size_bytes)
+        : current_job?.transcoded_size;
+      const progress_endpoint =
+        current_job?.progress_endpoint || progress_update_endpoint;
+
+      if (!current_job?.db_metadata?.stream_link) {
         record_task_info({
           job_id,
           file_with_path: file_with_path || "",
-          status: "running",
+          status: "done",
           info: {
             title: output_destination,
-            ws,
-            progress_endpoint: progress_update_endpoint,
-            flags
+            percent,
+            transcoded_size,
+            ...("stream_link" in seed_file && seed_file.stream_link
+              ? { db_metadata: seed_file }
+              : {})
           }
         });
       }
 
-      run({ ii: 0 });
+      if (ops === "just_check") {
+        return {
+          passed: true,
+          ready: true,
+          percent,
+          transcoded_size,
+          output_destination,
+          flags: current_job?.flags,
+          logs: current_job?.logs,
+          ...(seed_file && "stream_link" in seed_file && seed_file.stream_link
+            ? { stream_link: seed_file.stream_link }
+            : {}),
+          track_process: progress_endpoint,
+          ws
+        };
+      }
+
+      // handle direct file or url redirect
+      if (seed_file && "stream_link" in seed_file && seed_file.stream_link) {
+        const stream_link = new URL(seed_file.stream_link);
+        stream_link.searchParams.set("download", "true");
+
+        const [E_, R_] = await NS_promise.F_catch_promise({
+          promise: (async () => {
+            const cloudflare =
+              await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
+
+            if (!cloudflare.available) return;
+
+            const _ = await NS_pack_proxima.F_handle_pack_encode({
+              base: new URL(cloudflare.available),
+              payload: {
+                endpoint: stream_link.toString(),
+                commands: {
+                  response_headers: {
+                    set: {
+                      "content-disposition": `attachment; filename="${output_destination}"`
+                    }
+                  },
+                  use_h_version: true
+                }
+              }
+            });
+
+            return { proxy_url: _ };
+          })()
+        });
+
+        const new_stream_link =
+          (R_ as any)?.proxy_url || stream_link.toString();
 
-      live.launched = true;
+        // 302, not 301: the link is proxied/temporary and browsers cache 301s
+        return ctx.redirect(new_stream_link, 302);
+      } else {
+        // if seed is file set headers
+        construct_response_headers({
+          is_download: true
+        });
 
-      if (is_stream_mode) {
-        return passthrough;
+        return seed_file;
       }
+    }
 
-      // download mode: the job lives on its own from here on
-      detach_request_abort();
+    // -------------------------------
+    // Build flags
+    // -------------------------------
+    const CMD = await F_cmd({ subs: !error_end_of_file });
+
+    flags = CMD.flags;
+
+    if (ops === "just_check") {
+      // run ffprobe to see if playback still valid
+      const _ = await ping_probe({ playback });
+
+      if (_.success) {
+        return {
+          passed: true,
+          sbe_id,
+          delivery: output_destination,
+          qLevel,
+          picture_quality,
+          track_process: progress_update_endpoint,
+          ws,
+          flags
+        };
+      }
 
-      const message = `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
+      return {
+        passed: false,
+        delivery: output_destination,
+        track_process: progress_update_endpoint,
+        flags
+      };
+    }
 
+    if (ops === "cmd") {
       return {
-        message,
-        title: output_destination,
-        ws,
-        track_process: progress_update_endpoint
+        cmd: flags
       };
-    } finally {
-      // any early return or throw above means ffmpeg was never started
-      if (!live.launched) {
-        detach_request_abort();
+    }
 
-        // drop our claim, but never touch another request's job or a done/failed record
-        if (claimed && transcode_jobs.get(job_id)?.status === "running") {
-          transcode_jobs.delete(job_id);
-        }
-      }
+    // the client gave up while we were preparing
+    if (controller.signal.aborted) {
+      return;
     }
 
-    // ---------- ffmpeg lifecycle (hoisted) ----------
+    // -------------------------------
+    // network response headers
+    // -------------------------------
+    construct_response_headers({
+      is_streaming: is_stream_mode
+    });
 
-    /**
-     * Starts (or restarts) ffmpeg. Never throws, failures go through fail().
-     */
-    async function run(arg0: {
-      ii: number;
-      keep_subs?: boolean;
-      logs?: string[];
-    }) {
-      const { ii, keep_subs, logs } = arg0;
+    NS_Misc.console.log({
+      ENV: "dev",
+      _browser: false,
+      _log: ["[FFMPEG FLAGS]", flags, "\n"]
+    });
 
-      if (ii >= MAX_ATTEMPTS) return;
+    claimed = true;
 
-      try {
-        if (logs) id_log_errors({ logs });
+    // -------------------------------
+    // spawn
+    // -------------------------------
+    if (!is_stream_mode) {
+      record_task_info({
+        job_id,
+        file_with_path: file_with_path || "",
+        status: "running",
+        info: {
+          title: output_destination,
+          ws,
+          progress_endpoint: progress_update_endpoint,
+          flags
+        }
+      });
+    }
 
-        if (ii > 0) {
-          const _CMD = await F_cmd({ subs: keep_subs });
+    run({ ii: 0 });
 
-          flags = _CMD.flags;
+    live.launched = true;
 
-          if (controller.signal.aborted) controller = new AbortController();
+    if (is_stream_mode) {
+      return passthrough;
+    }
 
-          progress_data = undefined;
-          seek_size_bytes = 0;
-          live.percent = 0;
-          live.size = "";
-          local_cleaned = false;
-        }
+    // download mode: the job lives on its own from here on
+    detach_request_abort();
 
-        start_ffmpeg({ ii });
-      } catch (err) {
-        console.warn("spawn run error:", err, "\n");
+    const message = `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
 
-        fail([err_message(err)]);
+    return {
+      message,
+      title: output_destination,
+      ws,
+      track_process: progress_update_endpoint
+    };
+  } finally {
+    // any early return or throw above means ffmpeg was never started
+    if (!live.launched) {
+      detach_request_abort();
+
+      // drop our claim, but never touch another request's job or a done/failed record
+      if (claimed && transcode_jobs.get(job_id)?.status === "running") {
+        transcode_jobs.delete(job_id);
       }
     }
+  }
 
-    function start_ffmpeg(arg0: { ii: number }) {
-      const { ii } = arg0;
+  // ---------- ffmpeg lifecycle (hoisted) ----------
 
-      const my_attempt = ++attempt;
+  /**
+   * Starts (or restarts) ffmpeg. Never throws, failures go through fail().
+   */
+  async function run(arg0: {
+    ii: number;
+    keep_subs?: boolean;
+    logs?: string[];
+  }) {
+    const { ii, keep_subs, logs } = arg0;
 
-      let settled = false;
+    if (ii >= MAX_ATTEMPTS) return;
 
-      logged_proc_errors = [];
-      logged_proc_info = [];
+    try {
+      if (logs) id_log_errors({ logs });
 
-      const push_log = (arr: string[], line: string) => {
-        arr.push(line);
+      if (ii > 0) {
+        const _CMD = await F_cmd({ subs: keep_subs });
 
-        if (arr.length > MAX_LOG_LINES) {
-          arr.splice(0, arr.length - MAX_LOG_LINES);
-        }
-      };
+        flags = _CMD.flags;
 
-      let counter: Transform | undefined;
+        if (controller.signal.aborted) controller = new AbortController();
 
-      if (use_s3_pipe) {
-        s3_bytes = 0;
+        progress_data = undefined;
+        seek_size_bytes = 0;
+        live.percent = 0;
+        live.size = "";
+        local_cleaned = false;
+      }
 
-        const c = new Transform({
-          transform(chunk, _enc, cb) {
-            s3_bytes += chunk.length;
+      start_ffmpeg({ ii });
+    } catch (err) {
+      console.warn("spawn run error:", err, "\n");
 
-            cb(null, chunk);
-          }
-        });
+      fail([err_message(err)]);
+    }
+  }
 
-        c.on("error", () => {}); // real errors surface through `done`
+  function start_ffmpeg(arg0: { ii: number }) {
+    const { ii } = arg0;
 
-        const upload = NS_bucket.makeS3Upload({
-          key: bucket_file_path,
-          body: c,
-          ContentType: out_mime
-        });
+    const my_attempt = ++attempt;
 
-        const done: Promise<S3Outcome> = upload.done().then(
-          () => ({ success: true as const }),
-          (error) => {
-            console.warn("S3:ERROR", bucket_file_path, error, "\n");
+    let settled = false;
 
-            // the upload died, ffmpeg's output has nowhere to go: stop it
-            if (my_attempt === attempt) kill_controller("bucket upload failed");
+    logged_proc_errors = [];
+    logged_proc_info = [];
 
-            return { success: false as const, error };
-          }
-        );
+    const push_log = (arr: string[], line: string) => {
+      arr.push(line);
 
-        s3_attempt = { upload, done, counter: c };
-        counter = c;
+      if (arr.length > MAX_LOG_LINES) {
+        arr.splice(0, arr.length - MAX_LOG_LINES);
       }
+    };
 
-      // watchdog: kill ffmpeg if it never produces any output
-      set_t_timeout();
+    let counter: Transform | undefined;
 
-      const proc = spawn(NS_ffmpeg_v2.ffmpeg_path, flags, {
-        signal: controller.signal
-      });
+    if (use_s3_pipe) {
+      s3_bytes = 0;
 
-      if (passthrough) proc.stdout.pipe(passthrough);
+      const c = new Transform({
+        transform(chunk, _enc, cb) {
+          s3_bytes += chunk.length;
 
-      if (counter) {
-        proc.stdout.on("error", () => {}); // EPIPE if the upload is torn down
-        proc.stdout.pipe(counter);
-      }
+          cb(null, chunk);
+        }
+      });
 
-      proc.stderr.on("data", (data) => {
-        if (my_attempt !== attempt) return;
+      c.on("error", () => {}); // real errors surface through `done`
 
-        kill_controller_timeout();
+      const upload = NS_bucket.makeS3Upload({
+        key: bucket_file_path,
+        body: c,
+        ContentType: out_mime
+      });
 
-        const log = data.toString().trim();
+      const done: Promise<S3Outcome> = upload.done().then(
+        () => ({ success: true as const }),
+        (error) => {
+          console.warn("S3:ERROR", bucket_file_path, error, "\n");
 
-        if (is_dev) console.log("💠", log, "\n");
+          // the upload died, ffmpeg's output has nowhere to go: stop it
+          if (my_attempt === attempt) kill_controller("bucket upload failed");
 
-        if (!log) return;
+          return { success: false as const, error };
+        }
+      );
 
-        push_log(logged_proc_info, log);
+      s3_attempt = { upload, done, counter: c };
+      counter = c;
+    }
 
-        if (
-          NS_ffmpeg_v2.proc_error_pattern().some((pattern) => pattern.test(log))
-        ) {
-          push_log(logged_proc_errors, log);
+    // watchdog: kill ffmpeg if it never produces any output
+    set_t_timeout();
 
-          return;
-        }
+    const proc = spawn(NS_ffmpeg_v2.ffmpeg_path, flags, {
+      signal: controller.signal
+    });
 
-        const parsed = F_stderr_parse_progress({
-          stderr_line: log,
-          full_duration: parseFloat(`${probe_metadata.format.duration}`),
-          seek_size_bytes
-        });
+    if (passthrough) proc.stdout.pipe(passthrough);
 
-        if (!parsed || !Object.keys(parsed).length) return;
+    if (counter) {
+      proc.stdout.on("error", () => {}); // EPIPE if the upload is torn down
+      proc.stdout.pipe(counter);
+    }
 
-        progress_data = parsed;
+    proc.stderr.on("data", (data) => {
+      if (my_attempt !== attempt) return;
 
-        seek_size_bytes = parseFloat(`${parsed.size_bytes}`) || 0;
+      kill_controller_timeout();
 
-        live.size = parsed.size || live.size;
+      const log = data.toString().trim();
 
-        // S3 PIPE: ffmpeg's own size can be N/A on a pipe, the counter is exact
-        if (use_s3_pipe && s3_bytes > 0) {
-          live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
-        }
+      if (is_dev) console.log("💠", log, "\n");
 
-        if (typeof parsed.percent === "number") {
-          live.percent = Math.min(99, parsed.percent);
-        }
+      if (!log) return;
 
-        push_progress({});
-      });
+      push_log(logged_proc_info, log);
 
-      proc.on("close", (code) => settle({ code }));
+      if (
+        NS_ffmpeg_v2.proc_error_pattern().some((pattern) => pattern.test(log))
+      ) {
+        push_log(logged_proc_errors, log);
 
-      proc.on("error", (err) => {
-        console.error("⚠️❌ FFmpeg spawn error:", err, "\n");
+        return;
+      }
 
-        if (proc.pid === undefined) settle({ code: null, err });
+      const parsed = F_stderr_parse_progress({
+        stderr_line: log,
+        full_duration: parseFloat(`${probe_metadata.format.duration}`),
+        seek_size_bytes
       });
 
-      function settle(arg0: { code: number | null; err?: Error }) {
-        if (settled) return;
+      if (!parsed || !Object.keys(parsed).length) return;
 
-        settled = true;
+      progress_data = parsed;
 
-        kill_controller_timeout();
+      seek_size_bytes = parseFloat(`${parsed.size_bytes}`) || 0;
 
-        on_ffmpeg_end({ ii, ...arg0 }).catch((e) => {
-          console.warn("on_ffmpeg_end error:", e, "\n");
+      live.size = parsed.size || live.size;
 
-          fail([err_message(e)]);
-        });
+      // S3 PIPE: ffmpeg's own size can be N/A on a pipe, the counter is exact
+      if (use_s3_pipe && s3_bytes > 0) {
+        live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
       }
-    }
 
-    async function on_ffmpeg_end(arg0: {
-      ii: number;
-      code: number | null;
-      err?: Error;
-    }) {
-      const { ii, code, err } = arg0;
+      if (typeof parsed.percent === "number") {
+        live.percent = Math.min(99, parsed.percent);
+      }
 
-      // S3 PIPE: the upload finishes just after ffmpeg's stdout closes. Wait
-      // for it, success needs BOTH ffmpeg and the upload to have succeeded.
-      const s3_result = s3_attempt ? await s3_attempt.done : undefined;
+      push_progress({});
+    });
 
-      const percent = progress_data?.percent;
+    proc.on("close", (code) => settle({ code }));
 
-      const failure_reason = (() => {
-        if (err) return `FFmpeg could not start: ${err.message}`;
+    proc.on("error", (err) => {
+      console.error("⚠️❌ FFmpeg spawn error:", err, "\n");
 
-        if (s3_result && !s3_result.success) {
-          return `Bucket upload failed: ${err_message(s3_result.error)}`;
-        }
+      if (proc.pid === undefined) settle({ code: null, err });
+    });
 
-        if (code !== 0) {
-          return controller.signal.aborted
-            ? "FFmpeg was stopped (timeout or abort)"
-            : `FFmpeg exited with code ${code}`;
-        }
+    function settle(arg0: { code: number | null; err?: Error }) {
+      if (settled) return;
 
-        if (typeof percent === "number" && percent > 0 && percent < 90) {
-          return "Incomplete media data";
-        }
-      })();
+      settled = true;
 
-      if (failure_reason) {
-        console.error(`⚠️❌ ${failure_reason}`, "\n");
-        console.error("Error details:", logged_proc_errors, "\n");
+      kill_controller_timeout();
 
-        // S3 PIPE: a truncated media is still "playable", so the half-written object must go. Wait for the delete: a retry reuses the same key.
-        await abort_s3_upload();
+      on_ffmpeg_end({ ii, ...arg0 }).catch((e) => {
+        console.warn("on_ffmpeg_end error:", e, "\n");
 
-        cleanup_local();
+        fail([err_message(e)]);
+      });
+    }
+  }
 
-        const will_retry =
-          is_download_mode && !live.user_aborted && ii + 1 < MAX_ATTEMPTS;
+  async function on_ffmpeg_end(arg0: {
+    ii: number;
+    code: number | null;
+    err?: Error;
+  }) {
+    const { ii, code, err } = arg0;
 
-        if (will_retry) {
-          let i = ii + 1;
+    // S3 PIPE: the upload finishes just after ffmpeg's stdout closes. Wait
+    // for it, success needs BOTH ffmpeg and the upload to have succeeded.
+    const s3_result = s3_attempt ? await s3_attempt.done : undefined;
 
-          if (is_dev) console.log(`WILL RETRY: ${i}`, "\n");
+    const percent = progress_data?.percent;
 
-          run({
-            ii: i,
-            keep_subs: F_keep_subs(),
-            logs: logged_proc_info
-          });
+    const failure_reason = (() => {
+      if (err) return `FFmpeg could not start: ${err.message}`;
 
-          return;
-        }
+      if (s3_result && !s3_result.success) {
+        return `Bucket upload failed: ${err_message(s3_result.error)}`;
+      }
 
-        fail([failure_reason, ...logged_proc_errors]);
+      if (code !== 0) {
+        return controller.signal.aborted
+          ? "FFmpeg was stopped (timeout or abort)"
+          : `FFmpeg exited with code ${code}`;
+      }
 
-        return;
+      if (typeof percent === "number" && percent > 0 && percent < 90) {
+        return "Incomplete media data";
       }
+    })();
 
-      NS_Misc.console.log({
-        ENV: "all",
-        _browser: false,
-        _log: [
-          `🏁 FFMPEG finished: (${percent}) -> ${progress_data?.size} ${file_with_path || output_destination}`,
-          "\n"
-        ]
-      });
+    if (failure_reason) {
+      console.error(`⚠️❌ ${failure_reason}`, "\n");
+      console.error("Error details:", logged_proc_errors, "\n");
 
-      if (is_stream_mode) {
-        // finish_done();
+      // S3 PIPE: a truncated media is still "playable", so the half-written object must go. Wait for the delete: a retry reuses the same key.
+      await abort_s3_upload();
 
-        return;
-      }
+      cleanup_local();
 
-      await deliver_download();
-    }
+      const will_retry =
+        is_download_mode && !live.user_aborted && ii + 1 < MAX_ATTEMPTS;
 
-    /**
-     * ffmpeg finished successfully.
-      S3 pipe: the object is already in the bucket.
-      Disk: upload the local file, then delete it whether the upload worked or not.
-    */
-    async function deliver_download() {
-      if (use_s3_pipe) {
-        s3_attempt = undefined;
+      if (will_retry) {
+        let i = ii + 1;
 
-        live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
-
-        live.percent = 99;
-        push_progress({ force: true });
+        if (is_dev) console.log(`WILL RETRY: ${i}`, "\n");
 
-        await document_and_finish();
+        run({
+          ii: i,
+          keep_subs: F_keep_subs(),
+          logs: logged_proc_info
+        });
 
         return;
       }
 
-      if (!file_with_path) {
-        fail(["No local output file"]);
+      fail([failure_reason, ...logged_proc_errors]);
 
-        return;
-      }
+      return;
+    }
 
-      if (is_dev) {
-        finish_done();
+    NS_Misc.console.log({
+      ENV: "all",
+      _browser: false,
+      _log: [
+        `🏁 FFMPEG finished: (${percent}) -> ${progress_data?.size} ${file_with_path || output_destination}`,
+        "\n"
+      ]
+    });
 
-        return;
-      }
+    if (is_stream_mode) {
+      // finish_done();
 
-      live.percent = 99;
-      push_progress({ force: true, uploading: true });
+      return;
+    }
 
-      let uploaded = false;
+    await deliver_download();
+  }
 
-      try {
-        uploaded = await upload_with_retry({ file_with_path });
-      } catch (e) {
-        console.warn("bucket upload error:", e, "\n");
-      } finally {
-        cleanup_local();
-      }
+  /**
+   * ffmpeg finished successfully.
+    S3 pipe: the object is already in the bucket.
+    Disk: upload the local file, then delete it whether the upload worked or not.
+  */
+  async function deliver_download() {
+    if (use_s3_pipe) {
+      s3_attempt = undefined;
 
-      if (!uploaded) {
-        fail(["Bucket upload failed"]);
+      live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
 
-        return;
-      }
+      live.percent = 99;
+      push_progress({ force: true });
 
       await document_and_finish();
+
+      return;
     }
 
-    async function document_and_finish() {
-      // document file
-      await wide_search_runner({
-        document: true,
-        skip: {
-          local: true,
-          db: true
-        }
-      }).catch(() => {});
+    if (!file_with_path) {
+      fail(["No local output file"]);
+
+      return;
+    }
 
+    if (is_dev) {
       finish_done();
+
+      return;
     }
 
-    async function upload_with_retry(arg0: { file_with_path: string }) {
-      const { file_with_path } = arg0;
+    live.percent = 99;
+    push_progress({ force: true, uploading: true });
 
-      if (typeof file_with_path !== "string" || !file_with_path.trim().length) {
-        return false;
-      }
+    let uploaded = false;
 
-      const delays = [0, 2000, 5000];
+    try {
+      uploaded = await upload_with_retry({ file_with_path });
+    } catch (e) {
+      console.warn("bucket upload error:", e, "\n");
+    } finally {
+      cleanup_local();
+    }
 
-      for (let i = 0; i < delays.length; i++) {
-        if (delays[i]) await Bun.sleep(delays[i]!);
+    if (!uploaded) {
+      fail(["Bucket upload failed"]);
 
-        const r = await NS_bucket.upload_to_bucket({
-          job_id,
-          bucket_path: bucket_file_path,
-          file_with_path,
-          REQ0,
-          skip: { probe: i > 0 }
-        });
+      return;
+    }
 
-        if (r?.success) return true;
+    await document_and_finish();
+  }
 
-        if (r && !r.success && r.reason === "probe") return false;
+  async function document_and_finish() {
+    // document file
+    await wide_search_runner({
+      document: true,
+      skip: {
+        local: true,
+        db: true
       }
+    }).catch(() => {});
+
+    finish_done();
+  }
 
+  async function upload_with_retry(arg0: { file_with_path: string }) {
+    const { file_with_path } = arg0;
+
+    if (typeof file_with_path !== "string" || !file_with_path.trim().length) {
       return false;
     }
 
-    /*
-      S3 PIPE: tears down the current attempt's upload and deletes whatever
-      reached the bucket. Idempotent, and safe when there is no upload.
-    */
-    async function abort_s3_upload() {
-      const a = s3_attempt;
+    const delays = [0, 2000, 5000];
 
-      if (!a) return;
+    for (let i = 0; i < delays.length; i++) {
+      if (delays[i]) await Bun.sleep(delays[i]!);
 
-      s3_attempt = undefined;
+      const r = await NS_bucket.upload_to_bucket({
+        job_id,
+        bucket_path: bucket_file_path,
+        file_with_path,
+        REQ0,
+        skip: { probe: i > 0 }
+      });
 
-      a.counter.destroy();
+      if (r?.success) return true;
 
-      await NS_bucket.delete_self_s3({
-        key: bucket_file_path,
-        upload_in: a.upload,
-        done: a.done
-      });
+      if (r && !r.success && r.reason === "probe") return false;
     }
 
-    // ---------- reporting (hoisted) ----------
+    return false;
+  }
 
-    function relay_endpoint(data: Record<string, any>) {
-      if (!progress_update_endpoint) return;
+  /*
+    S3 PIPE: tears down the current attempt's upload and deletes whatever
+    reached the bucket. Idempotent, and safe when there is no upload.
+  */
+  async function abort_s3_upload() {
+    const a = s3_attempt;
 
-      try {
-        relay_progress_info({
-          endpoint: new URL(progress_update_endpoint),
-          progress_data: data
-        });
-      } catch {}
-    }
+    if (!a) return;
 
-    function push_progress(arg0: { force?: boolean, uploading?: boolean }) {
-      if (live.done || live.failed || is_stream_mode) return;
+    s3_attempt = undefined;
 
-      // each push hits the store, the websocket and an outbound HTTP relay,
-      // so cap it. Completion always goes through finish_done.
-      const now = Date.now();
+    a.counter.destroy();
 
-      if (!arg0.force && now - live.last_push < 1500) return;
+    await NS_bucket.delete_self_s3({
+      key: bucket_file_path,
+      upload_in: a.upload,
+      done: a.done
+    });
+  }
 
-      live.last_push = now;
+  // ---------- reporting (hoisted) ----------
 
-      record_task_info({
-        job_id,
-        file_with_path: file_with_path || "",
-        status: "running",
-        info: {
-          uploading: arg0.uploading,
-          title: output_destination,
-          percent: live.percent,
-          transcoded_size: live.size,
-          progress_endpoint: progress_update_endpoint,
-          ws,
-          flags,
-          log_errors: logged_proc_errors,
-          logs: logged_proc_info
-        }
+  function relay_endpoint(data: Record<string, any>) {
+    if (!progress_update_endpoint) return;
+
+    try {
+      relay_progress_info({
+        endpoint: new URL(progress_update_endpoint),
+        progress_data: data
       });
+    } catch {}
+  }
+
+  function push_progress(arg0: { force?: boolean; uploading?: boolean }) {
+    if (live.done || live.failed || is_stream_mode) return;
+
+    // each push hits the store, the websocket and an outbound HTTP relay,
+    // so cap it. Completion always goes through finish_done.
+    const now = Date.now();
+
+    if (!arg0.force && now - live.last_push < 1500) return;
+
+    live.last_push = now;
 
-      const data = {
-        ...progress_data,
+    record_task_info({
+      job_id,
+      file_with_path: file_with_path || "",
+      status: "running",
+      info: {
         uploading: arg0.uploading,
+        title: output_destination,
         percent: live.percent,
-        size: live.size || progress_data?.size,
-        filename: output_destination,
-        location: `${REQ0.origin}/${REQ0.pathname}`,
+        transcoded_size: live.size,
+        progress_endpoint: progress_update_endpoint,
+        ws,
+        flags,
         log_errors: logged_proc_errors,
         logs: logged_proc_info
-      };
+      }
+    });
 
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status: "running",
-          data
-        }
-      });
+    const data = {
+      ...progress_data,
+      uploading: arg0.uploading,
+      percent: live.percent,
+      size: live.size || progress_data?.size,
+      filename: output_destination,
+      location: `${REQ0.origin}/${REQ0.pathname}`,
+      log_errors: logged_proc_errors,
+      logs: logged_proc_info
+    };
 
-      relay_endpoint(data);
-    }
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status: "running",
+        data
+      }
+    });
 
-    function finish_done() {
-      if (live.done || live.failed || is_stream_mode) return;
+    relay_endpoint(data);
+  }
 
-      live.done = true;
-      live.percent = 100;
+  function finish_done() {
+    if (live.done || live.failed || is_stream_mode) return;
 
-      record_task_info({
-        job_id,
-        file_with_path: file_with_path || "",
-        status: "done",
-        info: {
-          title: output_destination,
-          percent: 100,
-          transcoded_size: live.size || progress_data?.size,
-          progress_endpoint: progress_update_endpoint,
-          flags,
-          log_errors: logged_proc_errors,
-          logs: logged_proc_info
-        }
-      });
+    live.done = true;
+    live.percent = 100;
 
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status: "done",
-          filename: output_destination,
-          logs: logged_proc_info
-        }
-      });
-
-      relay_endpoint({
+    record_task_info({
+      job_id,
+      file_with_path: file_with_path || "",
+      status: "done",
+      info: {
+        title: output_destination,
         percent: 100,
-        filename: output_destination,
-        location: `${REQ0.origin}/${REQ0.pathname}`,
+        transcoded_size: live.size || progress_data?.size,
+        progress_endpoint: progress_update_endpoint,
+        flags,
         log_errors: logged_proc_errors,
         logs: logged_proc_info
-      });
+      }
+    });
 
-      if (is_download_mode) {
-        transcode_jobs.delete(job_id);
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status: "done",
+        filename: output_destination,
+        logs: logged_proc_info
       }
+    });
+
+    relay_endpoint({
+      percent: 100,
+      filename: output_destination,
+      location: `${REQ0.origin}/${REQ0.pathname}`,
+      log_errors: logged_proc_errors,
+      logs: logged_proc_info
+    });
+
+    if (is_download_mode) {
+      transcode_jobs.delete(job_id);
     }
+  }
 
-    function fail(logs: string[]) {
-      if (live.failed || live.done || is_stream_mode) return;
+  function fail(logs: string[]) {
+    if (live.failed || live.done || is_stream_mode) return;
 
-      live.failed = true;
+    live.failed = true;
 
-      record_task_info({
-        job_id,
-        file_with_path: file_with_path || "",
-        status: "failed",
-        info: {
-          title: output_destination,
-          ws,
-          error: logs.join(" | "),
-          log_errors: logged_proc_errors,
-          logs: logged_proc_info
-        }
-      });
+    record_task_info({
+      job_id,
+      file_with_path: file_with_path || "",
+      status: "failed",
+      info: {
+        title: output_destination,
+        ws,
+        error: logs.join(" | "),
+        log_errors: logged_proc_errors,
+        logs: logged_proc_info
+      }
+    });
 
-      relay_progress_info_ws({
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
         channel: data_key,
-        payload: {
-          channel: data_key,
-          status: "failed",
-          filename: output_destination,
-          logs: logged_proc_info
-        }
-      });
-
-      relay_endpoint({
         status: "failed",
         filename: output_destination,
-        location: `${REQ0.origin}/${REQ0.pathname}`,
-        log_errors: logged_proc_errors,
         logs: logged_proc_info
-      });
+      }
+    });
 
-      passthrough?.destroy(new Error(logs[0] || "failed"));
+    relay_endpoint({
+      status: "failed",
+      filename: output_destination,
+      location: `${REQ0.origin}/${REQ0.pathname}`,
+      log_errors: logged_proc_errors,
+      logs: logged_proc_info
+    });
 
-      cleanup_local();
+    passthrough?.destroy(new Error(logs[0] || "failed"));
 
-      // S3 PIPE: covers failures that did not come through on_ffmpeg_end
-      // (spawn/run errors). A no-op when the upload was already torn down.
-      abort_s3_upload().catch((e) => console.warn("abort_s3_upload:", e));
-    }
+    cleanup_local();
 
-    // ---------- helpers (hoisted) ----------
+    // S3 PIPE: covers failures that did not come through on_ffmpeg_end
+    // (spawn/run errors). A no-op when the upload was already torn down.
+    abort_s3_upload().catch((e) => console.warn("abort_s3_upload:", e));
+  }
 
-    /**
-     * Deletes the local output file. Safe to call from every exit path: it
-     * only runs once per attempt. Skipped in dev, where the local file is the
-     * store. No-op in S3 pipe mode, there is no local file.
-     */
-    function cleanup_local() {
-      if (!file_with_path || local_cleaned) return;
+  // ---------- helpers (hoisted) ----------
 
-      if (is_dev && live.done) return;
+  /**
+   * Deletes the local output file. Safe to call from every exit path: it
+   * only runs once per attempt. Skipped in dev, where the local file is the
+   * store. No-op in S3 pipe mode, there is no local file.
+   */
+  function cleanup_local() {
+    if (!file_with_path || local_cleaned) return;
 
-      local_cleaned = true;
+    if (is_dev && live.done) return;
 
-      NS_bucket.delete_self({ try_count: 0, file_with_path });
-    }
+    local_cleaned = true;
 
-    function kill_controller(reason: string) {
-      controller.abort();
+    NS_bucket.delete_self({ try_count: 0, file_with_path });
+  }
 
-      console.log(`[CONTROLLER] aborted: ${reason}`);
-    }
+  function kill_controller(reason: string) {
+    controller.abort();
 
-    function set_t_timeout() {
-      kill_controller_timeout();
+    console.log(`[CONTROLLER] aborted: ${reason}`);
+  }
 
-      watchdog = setTimeout(
-        () => kill_controller("no output from ffmpeg"),
-        NS_ffmpeg_v2.TIMEOUT_MS
-      );
-    }
+  function set_t_timeout() {
+    kill_controller_timeout();
 
-    function kill_controller_timeout() {
-      if (watchdog) {
-        clearTimeout(watchdog);
-        watchdog = undefined;
-      }
+    watchdog = setTimeout(
+      () => kill_controller("no output from ffmpeg"),
+      NS_ffmpeg_v2.TIMEOUT_MS
+    );
+  }
+
+  function kill_controller_timeout() {
+    if (watchdog) {
+      clearTimeout(watchdog);
+      watchdog = undefined;
     }
+  }
 
-    function id_log_errors(arg0: { logs: string[] }) {
-      const { logs } = arg0;
+  function id_log_errors(arg0: { logs: string[] }) {
+    const { logs } = arg0;
 
-      if (!Array.isArray(logs)) {
-        return;
-      }
+    if (!Array.isArray(logs)) {
+      return;
+    }
 
-      const has = (needle: string) => {
-        return logs.some((xx) =>
-          xx.toString().toLowerCase().includes(needle.toLowerCase())
-        );
-      };
+    const has = (needle: string) => {
+      return logs.some((xx) =>
+        xx.toString().toLowerCase().includes(needle.toLowerCase())
+      );
+    };
 
-      if (has("http error 429 too many requests")) {
-        error_429 = true;
-      }
+    if (has("http error 429 too many requests")) {
+      error_429 = true;
+    }
 
-      if (has("failed too many times, skipping")) {
-        error_429 = true;
-      }
+    if (has("failed too many times, skipping")) {
+      error_429 = true;
+    }
 
-      if (has("error opening input: end of file")) {
-        error_end_of_file = true;
-      }
+    if (has("error opening input: end of file")) {
+      error_end_of_file = true;
+    }
 
-      if (has("error opening input files: server returned 403 forbidden")) {
-        error_403 = true;
-      }
+    if (has("error opening input files: server returned 403 forbidden")) {
+      error_403 = true;
+    }
 
-      if (has("http error 404 not found")) {
-        error_403 = true;
-      }
+    if (has("http error 404 not found")) {
+      error_403 = true;
     }
+  }
 
-    // keep subtitles unless one of THEIR urls caused the end-of-file error
-    function F_keep_subs() {
-      if (!logged_proc_info.length || !subtitles?.length) {
-        return true;
-      }
+  // keep subtitles unless one of THEIR urls caused the end-of-file error
+  function F_keep_subs() {
+    if (!logged_proc_info.length || !subtitles?.length) {
+      return true;
+    }
 
-      const eof_lines = logged_proc_info
-        .map((xx) => xx.toString().toLowerCase())
-        .filter((xx) => xx.includes("error opening input: end of file"));
+    const eof_lines = logged_proc_info
+      .map((xx) => xx.toString().toLowerCase())
+      .filter((xx) => xx.includes("error opening input: end of file"));
 
-      if (!eof_lines.length) {
-        return true;
-      }
+    if (!eof_lines.length) {
+      return true;
+    }
 
-      const sub_failed = subtitles.some((sub) => {
-        const url = sub.url.toString().toLowerCase();
+    const sub_failed = subtitles.some((sub) => {
+      const url = sub.url.toString().toLowerCase();
 
-        return eof_lines.some((line) => line.includes(url));
-      });
+      return eof_lines.some((line) => line.includes(url));
+    });
 
-      return !sub_failed;
-    }
+    return !sub_failed;
+  }
 
-    async function F_cmd(arg0: { subs?: boolean }) {
-      const { subs } = arg0;
+  async function F_cmd(arg0: { subs?: boolean }) {
+    const { subs } = arg0;
 
-      const new_playback = await (async () => {
-        if ((!error_429 && !error_403) || playback.url.includes("/proxima")) {
-          return playback;
-        }
+    const new_playback = await (async () => {
+      if ((!error_429 && !error_403) || playback.url.includes("/proxima")) {
+        return playback;
+      }
 
-        // get_hf_sia_proxy
-        const R_ = IS_HF()
-          ? await NS_scrape_post_processing_helper.get_cloudflare_proxy({})
-          : await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
+      // get_hf_sia_proxy
+      const R_ = IS_HF()
+        ? await NS_scrape_post_processing_helper.get_cloudflare_proxy({})
+        : await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
 
-        if (!R_) return playback;
+      if (!R_) return playback;
 
-        const proxy_base = R_.available || R_.fallback;
+      const proxy_base = R_.available || R_.fallback;
 
-        if (NS_routes_c.F_is_url(proxy_base)) {
-          const _ = await NS_pack_proxima.F_handle_pack_encode({
-            base: proxy_base,
-            payload: {
-              endpoint: playback.url,
-              commands: {
-                use_h_version: true,
-                redirect_origin: true,
-                headers: playback.headers
-              }
+      if (NS_routes_c.F_is_url(proxy_base)) {
+        const _ = await NS_pack_proxima.F_handle_pack_encode({
+          base: proxy_base,
+          payload: {
+            endpoint: playback.url,
+            commands: {
+              use_h_version: true,
+              redirect_origin: true,
+              headers: playback.headers
             }
-          });
+          }
+        });
 
-          if (_) {
-            const __ = { ...playback };
+        if (_) {
+          const __ = { ...playback };
 
-            __.url = _.toString();
+          __.url = _.toString();
 
-            delete __.headers;
+          delete __.headers;
 
-            return __;
-          }
+          return __;
         }
+      }
 
-        return playback;
-      })();
-
-      has_subs = subs === false ? false : true;
-
-      const data = await NS_ffmpeg_v2.F_build_ffmpeg_flags_t1({
-        playback: new_playback,
-        subtitles: subs === false ? undefined : subtitles,
-        probe_metadata,
-        delivery_format,
-        delivery_mode,
-        output_destination: file_with_path || "",
-        flash_ping: false,
-        dl_to_s3: use_s3_pipe
-      });
+      return playback;
+    })();
 
-      return data;
-    }
+    has_subs = subs === false ? false : true;
+
+    const data = await NS_ffmpeg_v2.F_build_ffmpeg_flags_t1({
+      playback: new_playback,
+      subtitles: subs === false ? undefined : subtitles,
+      probe_metadata,
+      delivery_format,
+      delivery_mode,
+      output_destination: file_with_path || "",
+      flash_ping: false,
+      dl_to_s3: use_s3_pipe
+    });
 
-    function construct_response_headers(arg0: {
-      is_download?: boolean;
-      is_streaming?: boolean;
-    }) {
-      const { is_streaming, is_download } = arg0;
+    return data;
+  }
 
-      /* ----------  set response headers  ---------- */
-      if (is_download || is_streaming) {
-        ctx.set.headers["content-type"] = out_mime;
-      }
+  function construct_response_headers(arg0: {
+    is_download?: boolean;
+    is_streaming?: boolean;
+  }) {
+    const { is_streaming, is_download } = arg0;
 
-      ctx.set.headers["cache-control"] = "no-cache";
+    /* ----------  set response headers  ---------- */
+    if (is_download || is_streaming) {
+      ctx.set.headers["content-type"] = out_mime;
+    }
 
-      if (is_download) {
-        ctx.set.headers["content-disposition"] =
-          `attachment; filename="${output_destination}"`;
+    ctx.set.headers["cache-control"] = "no-cache";
 
-        ctx.set.headers["accept-ranges"] = "bytes";
-      }
+    if (is_download) {
+      ctx.set.headers["content-disposition"] =
+        `attachment; filename="${output_destination}"`;
 
-      if (clean_metadata?.format?.duration) {
-        ctx.set.headers["X-Content-Duration"] = clean_metadata.format?.duration;
-      }
+      ctx.set.headers["accept-ranges"] = "bytes";
     }
 
-    async function wide_search_runner(arg0: {
-      skip?: {
-        local?: boolean;
-        db?: boolean;
-        bucket?: boolean;
-      };
-      document: boolean;
-    }) {
-      const { skip, document } = arg0;
-
-      if (!is_download_mode) return;
+    if (clean_metadata?.format?.duration) {
+      ctx.set.headers["X-Content-Duration"] = clean_metadata.format?.duration;
+    }
+  }
 
-      const [E_, R_] = await NS_promise.F_catch_promise({
-        promise: NS_showtime_v2_helper.find_seed_file({
-          sbe_id,
-          output_destination: {
-            og: output_destination,
-            clean: output_destination_clean,
-            file_with_path
-          },
-          picture_quality,
-          qLevel,
-          sbe_s_e,
-          cache_folder,
-          file_id: clean_file_id,
-          job_id,
-          S3Dir,
-          cleanup_corruption: true,
-          document,
-          ideal_runtime: playback.ideal_runtime,
-          skip,
-          has_subs
-        })
-      });
+  async function wide_search_runner(arg0: {
+    skip?: {
+      local?: boolean;
+      db?: boolean;
+      bucket?: boolean;
+    };
+    document: boolean;
+  }) {
+    const { skip, document } = arg0;
+
+    if (!is_download_mode) return;
+
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: NS_showtime_v2_helper.find_seed_file({
+        sbe_id,
+        output_destination: {
+          og: output_destination,
+          clean: output_destination_clean,
+          file_with_path
+        },
+        picture_quality,
+        qLevel,
+        sbe_s_e,
+        cache_folder,
+        file_id: clean_file_id,
+        job_id,
+        S3Dir,
+        cleanup_corruption: true,
+        document,
+        ideal_runtime: playback.ideal_runtime,
+        skip,
+        has_subs
+      })
+    });
 
-      if (R_ && "stream_link" in R_ && R_.stream_link) {
-        if (!NS_misc.isValidUrlFormat(R_.stream_link)) {
-          return;
-        }
+    if (R_ && "stream_link" in R_ && R_.stream_link) {
+      if (!NS_misc.isValidUrlFormat(R_.stream_link)) {
+        return;
       }
-
-      return R_;
     }
-  },
-  {
-    params: t.Object({
-      data_key: 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"),
-            t.Literal("just_check")
-          ],
-          {
-            error() {
-              return "Invalid operation, must be one of: cmd, raw, decode";
-            }
-          }
-        )
-      )
-    })
-  }
-);
 
-export const ShowtimeV2Router = sub_router;
+    return R_;
+  }
+}
 
 function F_stderr_parse_progress(arg0: {
   stderr_line: string;

src/sub-router/showtime.ts

@@ -31,6 +31,7 @@ import { NS_error } from "@x/core/client/error.ts";
 import type { Upload } from "@aws-sdk/lib-storage";
 import { NS_routes_c } from "@x/core/client/route.ts";
 import { NS_files } from "@x/core/server/files.ts";
+import { StreamRouterHandlePayload } from "./stream";
 
 const APP_ACCOUNT_ABC = () =>
   NS_runtime.ENV_VAR_DB?.APP_ACCOUNT_ABC || process.env.APP_ACCOUNT_ABC;
@@ -46,6 +47,11 @@ const APP_ORIGIN = () =>
 const HF_BUCKET_NAME = () =>
   NS_runtime.ENV_VAR_DB?.HF_BUCKET_NAME || process.env.HF_BUCKET_NAME;
 
+const is_dev = (() => {
+  // return false;
+  return APP_ENV() === "dev";
+})();
+
 const sub_router = new Elysia({ prefix: "/showtimeV2" }).get(
   "/delivery/:data_key",
   async (ctx) => {
@@ -56,11 +62,6 @@ const sub_router = new Elysia({ prefix: "/showtimeV2" }).get(
     const REQ0 = new URL(request.url);
     const REQ_ORIGIN = (ctx as any).publicOrigin || REQ0.origin;
 
-    const is_dev = (() => {
-      // return false;
-      return APP_ENV() === "dev";
-    })();
-
     const metadata = await (async () => {
       try {
         if (is_dev) {
@@ -86,1492 +87,1551 @@ const sub_router = new Elysia({ prefix: "/showtimeV2" }).get(
       return metadata;
     }
 
-    const {
-      playback,
-      probe_metadata,
-      output_destination,
-      sbe_id,
-      delivery_mode,
-      delivery_format,
-      out_mime,
-      progress_update_endpoint,
-      subtitles,
-      fMP4
-    } = metadata as T_delivery_payload;
-
-    const is_download_mode = delivery_mode === "download";
-    const is_stream_mode = delivery_mode === "stream";
-
-    if (!is_download_mode && !is_stream_mode) {
-      return ctx.status(400, "Unsupported delivery mode");
-    }
-
-    const clean_metadata = NS_ffmpeg_v2.F_scan_raw_probe_metadata({
-      metadata: probe_metadata
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: handle_data({
+        data_key,
+        metadata,
+        REQ0,
+        REQ_ORIGIN,
+        ctx: ctx as any,
+        ops
+      })
     });
 
-    const picture_quality = (() => {
-      const _ = playback.picture_quality;
-
-      if (typeof _ !== "string") {
-        return "";
-      }
-
-      return _.trim().split(" ").join("");
-    })();
-
-    const sbe_s_e = (() => {
-      const _ = metadata.sbe_s_e;
+    if (E_) {
+      const { message, status } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
 
-      if (typeof _ !== "string" || _.toLowerCase().includes("nan")) {
-        return;
-      }
+      return ctx.status(status, message);
+    }
 
-      return _.trim().split(" ").join("");
-    })();
+    return R_;
+  },
+  {
+    params: t.Object({
+      data_key: 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"),
+            t.Literal("just_check")
+          ],
+          {
+            error() {
+              return "Invalid operation, must be one of: cmd, raw, decode";
+            }
+          }
+        )
+      )
+    })
+  }
+);
 
-    const qLevel = (() => {
-      if (
-        typeof metadata.qLevel === "string" &&
-        metadata.qLevel.trim().length > 0
-      ) {
-        return metadata.qLevel.trim();
-      }
+export const ShowtimeV2Router = sub_router;
+export const ShowtimeV2RouterHandlePayload = handle_data;
+
+async function handle_data(arg0: {
+  data_key: string;
+  metadata: T_delivery_payload;
+  REQ0: URL;
+  REQ_ORIGIN: string;
+  ctx: Context;
+  ops?: string;
+  throw_error?: boolean;
+}) {
+  const { data_key, metadata, REQ0, REQ_ORIGIN, ctx, ops, throw_error } = arg0;
+
+  const {
+    playback,
+    probe_metadata,
+    output_destination,
+    sbe_id,
+    delivery_mode,
+    delivery_format,
+    out_mime,
+    progress_update_endpoint,
+    subtitles,
+    fMP4
+  } = metadata as T_delivery_payload;
+
+  const is_download_mode = delivery_mode === "download";
+  const is_stream_mode = delivery_mode === "stream";
+
+  if (!is_download_mode && !is_stream_mode) {
+    const message = "Unsupported delivery mode";
+
+    if (throw_error) throw Error(JSON.stringify(message));
+
+    return ctx.status(400, message);
+  }
 
-      const _ = NS_ffmpeg_v2.F_get_qLevel({
-        metadata: probe_metadata
-      });
+  const clean_metadata = NS_ffmpeg_v2.F_scan_raw_probe_metadata({
+    metadata: probe_metadata
+  });
 
-      return _;
-    })();
+  const picture_quality = (() => {
+    const _ = playback.picture_quality;
 
-    const ws = (() => {
-      const is_https = new URL(REQ_ORIGIN).protocol === "https:";
+    if (typeof _ !== "string") {
+      return "";
+    }
 
-      const ws_protocol = is_https ? "wss" : "ws";
+    return _.trim().split(" ").join("");
+  })();
 
-      const _ = `${ws_protocol}://${REQ0.host}/ws`;
+  const sbe_s_e = (() => {
+    const _ = metadata.sbe_s_e;
 
-      const data = {
-        connect: _,
-        channel: data_key
-      };
+    if (typeof _ !== "string" || _.toLowerCase().includes("nan")) {
+      return;
+    }
 
-      return data;
-    })();
+    return _.trim().split(" ").join("");
+  })();
 
-    const output_destination_clean = NS_misc.cleanNameV2(output_destination);
+  const qLevel = (() => {
+    if (
+      typeof metadata.qLevel === "string" &&
+      metadata.qLevel.trim().length > 0
+    ) {
+      return metadata.qLevel.trim();
+    }
 
-    const clean_file_id =
-      `${picture_quality}-${output_destination_clean}`.toLowerCase();
+    const _ = NS_ffmpeg_v2.F_get_qLevel({
+      metadata: probe_metadata
+    });
 
-    const job_id = `${sbe_id}-${clean_file_id}`;
+    return _;
+  })();
 
-    const file_id = `${Date.now()}-${clean_file_id}`;
+  const ws = (() => {
+    const is_https = new URL(REQ_ORIGIN).protocol === "https:";
 
-    const cache_folder = `cache/${sbe_id}`;
+    const ws_protocol = is_https ? "wss" : "ws";
 
-    const S3Dir = path.join(STORAGE_ROOT(), `${cache_folder}`);
+    const _ = `${ws_protocol}://${REQ0.host}/ws`;
 
-    const bucket_file_path = `${cache_folder}/${file_id}`;
+    const data = {
+      connect: _,
+      channel: data_key
+    };
 
-    // TWO STEP: on HF an HLS -> mp4 delivery goes through the bucket twice
-    let two_step =
-      IS_HF() &&
-      is_download_mode &&
-      delivery_format === "mp4" &&
-      playback.type === "hls";
+    return data;
+  })();
 
-    const dl_to_s3 = IS_RENDER_COM() || two_step;
+  const output_destination_clean = NS_misc.cleanNameV2(output_destination);
 
-    let use_s3_pipe = is_download_mode && dl_to_s3;
+  const clean_file_id =
+    `${picture_quality}-${output_destination_clean}`.toLowerCase();
 
-    if (use_s3_pipe && (!S3() || !HF_BUCKET_NAME())) {
-      return ctx.status(500, "S3 bucket is not configured");
-    }
+  const job_id = `${sbe_id}-${clean_file_id}`;
 
-    // TWO STEP: the intermediate object lives OUTSIDE cache_folder, so the seed
-    // lookup never mistakes it for a finished file
-    const ts_key = (() => {
-      const _ = NS_files.F_get_file_extension({
-        filename: file_id,
-        return_new_filename: true
-      });
+  const file_id = `${Date.now()}-${clean_file_id}`;
 
-      return `tmp/${sbe_id}/${_.new_filename || file_id}.ts`;
-    })();
+  const cache_folder = `cache/${sbe_id}`;
 
-    const PHASES = {
-      single: { from: 0, to: 99, label: "Processing" },
-      ts: { from: 0, to: 60, label: "Step 1/2: fetching video" },
-      mp4: { from: 60, to: 99, label: "Step 2/2: converting to MP4" }
-    } as const;
+  const S3Dir = path.join(STORAGE_ROOT(), `${cache_folder}`);
 
-    type Phase = keyof typeof PHASES;
+  const bucket_file_path = `${cache_folder}/${file_id}`;
 
-    let phase: Phase = two_step ? "ts" : "single";
+  // TWO STEP: on HF an HLS -> mp4 delivery goes through the bucket twice
+  let two_step =
+    IS_HF() &&
+    is_download_mode &&
+    delivery_format === "mp4" &&
+    playback.type === "hls";
 
-    const xc = REQ0.searchParams.has("xc");
+  const dl_to_s3 = IS_RENDER_COM() || two_step;
 
-    (() => {
-      const i_x = REQ0.searchParams.get("i_x");
+  let use_s3_pipe = is_download_mode && dl_to_s3;
 
-      if (!NS_routes_c.F_is_url(i_x)) return;
+  if (use_s3_pipe && (!S3() || !HF_BUCKET_NAME())) {
+    const message = "S3 bucket is not configured";
 
-      phase = "mp4";
+    if (throw_error) throw Error(JSON.stringify(message));
 
-      playback.url = i_x!;
-      playback.headers = undefined;
-      playback.type = "video";
-      (playback as any).i_x = true;
-      use_s3_pipe = false;
-    })();
+    return ctx.status(500, message);
+  }
 
-    const current_key = () => (phase === "ts" ? ts_key : bucket_file_path);
-    const current_mime = () => (phase === "ts" ? "video/mp2t" : out_mime);
+  // TWO STEP: the intermediate object lives OUTSIDE cache_folder, so the seed
+  // lookup never mistakes it for a finished file
+  const ts_key = (() => {
+    const _ = NS_files.F_get_file_extension({
+      filename: file_id,
+      return_new_filename: true
+    });
 
-    // phase-local percent (0-100) -> overall percent, never above 99
-    const to_overall = (phase_pct: number) => {
-      const p = PHASES[phase];
+    return `tmp/${sbe_id}/${_.new_filename || file_id}.ts`;
+  })();
 
-      return Math.min(
-        99,
-        Math.max(p.from, p.from + (phase_pct / 100) * (p.to - p.from))
-      );
-    };
+  const PHASES = {
+    single: { from: 0, to: 99, label: "Processing" },
+    ts: { from: 0, to: 60, label: "Step 1/2: fetching video" },
+    mp4: { from: 60, to: 99, label: "Step 2/2: converting to MP4" }
+  } as const;
 
-    const _file_with_path = () => {
-      try {
-        node_fs.mkdirSync(S3Dir, { recursive: true });
+  type Phase = keyof typeof PHASES;
 
-        return path.join(S3Dir, file_id);
-      } catch (e) {}
-    };
+  let phase: Phase = two_step ? "ts" : "single";
 
-    let file_with_path = (() => {
-      if (!is_download_mode || use_s3_pipe) return;
+  const xc = REQ0.searchParams.has("xc");
 
-      return _file_with_path();
-    })();
+  (() => {
+    const i_x = REQ0.searchParams.get("i_x");
 
-    if (is_download_mode && !use_s3_pipe && !file_with_path) {
-      return ctx.status(500, "Could not prepare the output directory");
-    }
+    if (!NS_routes_c.F_is_url(i_x)) return;
 
-    const MAX_ATTEMPTS = 2;
+    phase = "mp4";
 
-    const MAX_LOG_LINES = 200;
+    playback.url = i_x!;
+    playback.headers = undefined;
+    playback.type = "video";
+    (playback as any).i_x = true;
+    use_s3_pipe = false;
+  })();
 
-    const err_message = (err: unknown) =>
-      NS_error.F_collect_error_message({ ERR: err }).message;
+  const current_key = () => (phase === "ts" ? ts_key : bucket_file_path);
+  const current_mime = () => (phase === "ts" ? "video/mp2t" : out_mime);
 
-    const live = {
-      percent: 0,
-      size: "",
-      failed: false,
-      done: false,
-      launched: false,
-      user_aborted: false,
-      last_push: 0
-    };
+  // phase-local percent (0-100) -> overall percent, never above 99
+  const to_overall = (phase_pct: number) => {
+    const p = PHASES[phase];
 
-    let flags: string[] = [];
-    let progress_data: Record<string, any> | undefined = undefined;
-    let seek_size_bytes = 0;
-    let logged_proc_errors: string[] = [];
-    let logged_proc_info: string[] = [];
-    let has_subs = false;
-    let local_cleaned = false;
-    let attempt = 0;
-    let watchdog: ReturnType<typeof setTimeout> | undefined = undefined;
-
-    let error_429 = false;
-    let error_end_of_file = false;
-    let error_403 = false;
-
-    let claimed = false;
-
-    // S3 PIPE: state of the current attempt's upload
-    type S3Outcome = { success: true } | { success: false; error: unknown };
-
-    type S3Attempt = {
-      key: string;
-      upload: Upload;
-      done: Promise<S3Outcome>;
-      counter: Transform;
-    };
+    return Math.min(
+      99,
+      Math.max(p.from, p.from + (phase_pct / 100) * (p.to - p.from))
+    );
+  };
 
-    let s3_attempt: S3Attempt | undefined = undefined;
+  const _file_with_path = () => {
+    try {
+      node_fs.mkdirSync(S3Dir, { recursive: true });
 
-    // TWO STEP: the finished .ts upload, kept until step 2 is done so it can be deleted
-    let ts_attempt: S3Attempt | undefined = undefined;
+      return path.join(S3Dir, file_id);
+    } catch (e) {}
+  };
 
-    let s3_bytes = 0;
+  let file_with_path = (() => {
+    if (!is_download_mode || use_s3_pipe) return;
 
-    let controller = new AbortController();
-    const abort_signal = ctx?.request.signal;
+    return _file_with_path();
+  })();
 
-    const on_request_abort = () => {
-      live.user_aborted = true;
+  if (is_download_mode && !use_s3_pipe && !file_with_path) {
+    const message = "Could not prepare the output directory";
 
-      kill_controller("client aborted");
-    };
+    if (throw_error) throw Error(JSON.stringify(message));
 
-    const detach_request_abort = () => {
-      abort_signal?.removeEventListener("abort", on_request_abort);
-    };
+    return ctx.status(500, message);
+  }
 
-    if (abort_signal?.aborted) {
-      return;
-    }
+  const MAX_ATTEMPTS = 2;
 
-    abort_signal?.addEventListener("abort", on_request_abort, { once: true });
+  const MAX_LOG_LINES = 200;
 
-    const passthrough = is_stream_mode ? new PassThrough() : undefined;
+  const err_message = (err: unknown) =>
+    NS_error.F_collect_error_message({ ERR: err }).message;
 
-    try {
-      const current_job = (() => {
-        const _ = transcode_jobs.get(job_id);
+  const live = {
+    percent: 0,
+    size: "",
+    failed: false,
+    done: false,
+    launched: false,
+    user_aborted: false,
+    last_push: 0
+  };
 
-        if (!_ || xc) return;
+  let flags: string[] = [];
+  let progress_data: Record<string, any> | undefined = undefined;
+  let seek_size_bytes = 0;
+  let logged_proc_errors: string[] = [];
+  let logged_proc_info: string[] = [];
+  let has_subs = false;
+  let local_cleaned = false;
+  let attempt = 0;
+  let watchdog: ReturnType<typeof setTimeout> | undefined = undefined;
 
-        return _;
-      })();
+  let error_429 = false;
+  let error_end_of_file = false;
+  let error_403 = false;
 
-      if (current_job?.status === "running") {
-        const percent = current_job?.percent;
-        const percentage = typeof percent === "number" ? `${percent} %` : "";
-        const transcoded_size = current_job?.transcoded_size;
-        const progress_endpoint =
-          current_job?.progress_endpoint || progress_update_endpoint;
+  let claimed = false;
 
-        const message = percentage
-          ? `ENGINE PROGRESS: ${percentage}`
-          : "ENGINE PROCESSING ...";
+  // S3 PIPE: state of the current attempt's upload
+  type S3Outcome = { success: true } | { success: false; error: unknown };
 
-        return {
-          ...(ops === "just_check" ? { passed: true } : {}),
-          processing: true,
-          message,
-          percent,
-          transcoded_size,
-          // TWO STEP: lets a re-polling client show which step is running
-          phase: current_job?.phase,
-          stage: current_job?.stage,
-          track_process: progress_endpoint,
-          file: output_destination,
-          job_id,
-          output_destination,
-          qLevel,
-          picture_quality,
-          ws,
-          flags: current_job.flags,
-          logs: current_job.logs
-        };
-      }
+  type S3Attempt = {
+    key: string;
+    upload: Upload;
+    done: Promise<S3Outcome>;
+    counter: Transform;
+  };
 
-      if (current_job?.status === "failed") {
-        const logs = current_job?.logs;
+  let s3_attempt: S3Attempt | undefined = undefined;
 
-        if (logs) id_log_errors({ logs });
+  // TWO STEP: the finished .ts upload, kept until step 2 is done so it can be deleted
+  let ts_attempt: S3Attempt | undefined = undefined;
 
-        transcode_jobs.delete(job_id);
+  let s3_bytes = 0;
 
-        if (ops === "just_check") {
-          return {
-            passed: false,
-            delivery: output_destination,
-            track_process: progress_update_endpoint,
-            ws,
-            flags: current_job.flags,
-            logs: current_job?.logs
-          };
-        }
+  let controller = new AbortController();
+  const abort_signal = ctx?.request.signal;
 
-        const _ = await ping_probe({ playback });
+  const on_request_abort = () => {
+    live.user_aborted = true;
 
-        if (!_?.success) {
-          throw new Error("Something went wrong: with probe");
-        }
-      }
+    kill_controller("client aborted");
+  };
 
-      // check/serve seeded file
-      const seed_file = await (async () => {
-        if (ops === "cmd") {
-          return;
-        }
+  const detach_request_abort = () => {
+    abort_signal?.removeEventListener("abort", on_request_abort);
+  };
 
-        const _ = current_job?.db_metadata?.stream_link;
+  if (abort_signal?.aborted) {
+    return;
+  }
 
-        if (_) {
-          return current_job.db_metadata;
-        }
+  abort_signal?.addEventListener("abort", on_request_abort, { once: true });
 
-        const __ = await wide_search_runner({ document: true });
+  const passthrough = is_stream_mode ? new PassThrough() : undefined;
 
-        return __;
-      })();
-
-      if (seed_file) {
-        const file_size_bytes = parseFloat(`${seed_file?.size}`);
-
-        const percent = 100;
-        const transcoded_size = file_size_bytes
-          ? NS_ffmpeg_v2.F_format_size(file_size_bytes)
-          : current_job?.transcoded_size;
-        const progress_endpoint =
-          current_job?.progress_endpoint || progress_update_endpoint;
-
-        if (!current_job?.db_metadata?.stream_link) {
-          record_task_info({
-            job_id,
-            file_with_path: file_with_path || "",
-            status: "done",
-            info: {
-              title: output_destination,
-              percent,
-              transcoded_size,
-              ...("stream_link" in seed_file && seed_file.stream_link
-                ? { db_metadata: seed_file }
-                : {})
-            }
-          });
-        }
+  try {
+    const current_job = (() => {
+      const _ = transcode_jobs.get(job_id);
 
-        if (ops === "just_check") {
-          return {
-            passed: true,
-            ready: true,
-            percent,
-            transcoded_size,
-            output_destination,
-            flags: current_job?.flags,
-            logs: current_job?.logs,
-            ...(seed_file && "stream_link" in seed_file && seed_file.stream_link
-              ? { stream_link: seed_file.stream_link }
-              : {}),
-            track_process: progress_endpoint,
-            ws
-          };
-        }
+      if (!_ || xc) return;
 
-        // handle direct file or url redirect
-        if (seed_file && "stream_link" in seed_file && seed_file.stream_link) {
-          const stream_link = new URL(seed_file.stream_link);
-          stream_link.searchParams.set("download", "true");
-
-          const [E_, R_] = await NS_promise.F_catch_promise({
-            promise: (async () => {
-              const cloudflare =
-                await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
-
-              if (!cloudflare.available) return;
-
-              const _ = await NS_pack_proxima.F_handle_pack_encode({
-                base: new URL(cloudflare.available),
-                payload: {
-                  endpoint: stream_link.toString(),
-                  commands: {
-                    response_headers: {
-                      set: {
-                        "content-disposition": `attachment; filename="${output_destination}"`
-                      }
-                    },
-                    use_h_version: true
-                  }
-                }
-              });
+      return _;
+    })();
 
-              return { proxy_url: _ };
-            })()
-          });
+    if (current_job?.status === "running") {
+      const percent = current_job?.percent;
+      const percentage = typeof percent === "number" ? `${percent} %` : "";
+      const transcoded_size = current_job?.transcoded_size;
+      const progress_endpoint =
+        current_job?.progress_endpoint || progress_update_endpoint;
 
-          const new_stream_link =
-            (R_ as any)?.proxy_url || stream_link.toString();
+      const message = percentage
+        ? `ENGINE PROGRESS: ${percentage}`
+        : "ENGINE PROCESSING ...";
 
-          // 302, not 301: the link is proxied/temporary and browsers cache 301s
-          return ctx.redirect(new_stream_link, 302);
-        } else {
-          // if seed is file set headers
-          construct_response_headers({
-            is_download: true
-          });
+      return {
+        ...(ops === "just_check" ? { passed: true } : {}),
+        processing: true,
+        message,
+        percent,
+        transcoded_size,
+        // TWO STEP: lets a re-polling client show which step is running
+        phase: current_job?.phase,
+        stage: current_job?.stage,
+        track_process: progress_endpoint,
+        file: output_destination,
+        job_id,
+        output_destination,
+        qLevel,
+        picture_quality,
+        ws,
+        flags: current_job.flags,
+        logs: current_job.logs
+      };
+    }
 
-          return seed_file;
-        }
-      }
+    if (current_job?.status === "failed") {
+      const logs = current_job?.logs;
 
-      // -------------------------------
-      // Build flags
-      // -------------------------------
-      // (two_step: these are the step 1 flags, step 2 flags are built when it starts)
-      const CMD = await F_cmd({ subs: !error_end_of_file });
+      if (logs) id_log_errors({ logs });
 
-      flags = CMD.flags;
+      transcode_jobs.delete(job_id);
 
       if (ops === "just_check") {
-        const _ = await ping_probe({ playback });
-
-        if (_.success) {
-          return {
-            passed: true,
-            sbe_id,
-            delivery: output_destination,
-            qLevel,
-            picture_quality,
-            track_process: progress_update_endpoint,
-            ws,
-            flags
-          };
-        }
-
         return {
           passed: false,
           delivery: output_destination,
           track_process: progress_update_endpoint,
-          flags
+          ws,
+          flags: current_job.flags,
+          logs: current_job?.logs
         };
       }
 
-      if (ops === "cmd") {
-        return {
-          cmd: flags
-        };
+      const _ = await ping_probe({ playback });
+
+      if (!_?.success) {
+        throw new Error("Something went wrong: with probe");
       }
+    }
 
-      // the client gave up while we were preparing
-      if (controller.signal.aborted) {
+    // check/serve seeded file
+    const seed_file = await (async () => {
+      if (ops === "cmd") {
         return;
       }
 
-      // -------------------------------
-      // network response headers
-      // -------------------------------
-      construct_response_headers({
-        is_streaming: is_stream_mode
-      });
+      const _ = current_job?.db_metadata?.stream_link;
 
-      NS_Misc.console.log({
-        ENV: "dev",
-        _browser: false,
-        _log: ["[FFMPEG FLAGS]", flags, "\n"]
-      });
+      if (_) {
+        return current_job.db_metadata;
+      }
+
+      const __ = await wide_search_runner({ document: true });
+
+      return __;
+    })();
+
+    if (seed_file) {
+      const file_size_bytes = parseFloat(`${seed_file?.size}`);
 
-      claimed = true;
+      const percent = 100;
+      const transcoded_size = file_size_bytes
+        ? NS_ffmpeg_v2.F_format_size(file_size_bytes)
+        : current_job?.transcoded_size;
+      const progress_endpoint =
+        current_job?.progress_endpoint || progress_update_endpoint;
 
-      // -------------------------------
-      // spawn
-      // -------------------------------
-      if (!is_stream_mode) {
+      if (!current_job?.db_metadata?.stream_link) {
         record_task_info({
           job_id,
           file_with_path: file_with_path || "",
-          status: "running",
+          status: "done",
           info: {
             title: output_destination,
-            ws,
-            progress_endpoint: progress_update_endpoint,
-            ...(two_step ? { phase, stage: PHASES[phase].label } : {}),
-            flags
+            percent,
+            transcoded_size,
+            ...("stream_link" in seed_file && seed_file.stream_link
+              ? { db_metadata: seed_file }
+              : {})
           }
         });
       }
 
-      if (two_step && !(playback as any).i_x) {
-        const [E_, R_] = await NS_promise.F_catch_fetch({
-          parse: "json",
-          promise: fetch(
-            (() => {
-              const _ = new URL(`/stream/delivery/${data_key}`, REQ_ORIGIN);
+      if (ops === "just_check") {
+        return {
+          passed: true,
+          ready: true,
+          percent,
+          transcoded_size,
+          output_destination,
+          flags: current_job?.flags,
+          logs: current_job?.logs,
+          ...(seed_file && "stream_link" in seed_file && seed_file.stream_link
+            ? { stream_link: seed_file.stream_link }
+            : {}),
+          track_process: progress_endpoint,
+          ws
+        };
+      }
 
-              _.searchParams.set("x_i", job_id);
-              _.searchParams.set("xc", "");
+      // handle direct file or url redirect
+      if (seed_file && "stream_link" in seed_file && seed_file.stream_link) {
+        const stream_link = new URL(seed_file.stream_link);
+        stream_link.searchParams.set("download", "true");
+
+        const [E_, R_] = await NS_promise.F_catch_promise({
+          promise: (async () => {
+            const cloudflare =
+              await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
+
+            if (!cloudflare.available) return;
+
+            const _ = await NS_pack_proxima.F_handle_pack_encode({
+              base: new URL(cloudflare.available),
+              payload: {
+                endpoint: stream_link.toString(),
+                commands: {
+                  response_headers: {
+                    set: {
+                      "content-disposition": `attachment; filename="${output_destination}"`
+                    }
+                  },
+                  use_h_version: true
+                }
+              }
+            });
 
-              return _;
-            })()
-          )
+            return { proxy_url: _ };
+          })()
         });
 
-        if (E_ || !R_) {
-          if (fMP4) {
-            phase = "single";
-            two_step = false;
-            use_s3_pipe = false;
-          }
+        const new_stream_link =
+          (R_ as any)?.proxy_url || stream_link.toString();
 
-          run({
-            ii: 0,
-            ...(fMP4 ? { keep_subs: true, rebuild: true } : {})
-          });
-        }
+        // 302, not 301: the link is proxied/temporary and browsers cache 301s
+        return ctx.redirect(new_stream_link, 302);
       } else {
-        run({
-          ii: 0,
-          ...((playback as any).i_x ? { keep_subs: true, rebuild: true } : {})
+        // if seed is file set headers
+        construct_response_headers({
+          is_download: true
         });
+
+        return seed_file;
       }
+    }
 
-      live.launched = true;
+    // -------------------------------
+    // Build flags
+    // -------------------------------
+    // (two_step: these are the step 1 flags, step 2 flags are built when it starts)
+    const CMD = await F_cmd({ subs: !error_end_of_file });
 
-      if (is_stream_mode) {
-        return passthrough;
-      }
+    flags = CMD.flags;
 
-      // download mode: the job lives on its own from here on
-      detach_request_abort();
+    if (ops === "just_check") {
+      const _ = await ping_probe({ playback });
 
-      const message = `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
+      if (_.success) {
+        return {
+          passed: true,
+          sbe_id,
+          delivery: output_destination,
+          qLevel,
+          picture_quality,
+          track_process: progress_update_endpoint,
+          ws,
+          flags
+        };
+      }
 
       return {
-        message,
-        title: output_destination,
-        ws,
-        track_process: progress_update_endpoint
+        passed: false,
+        delivery: output_destination,
+        track_process: progress_update_endpoint,
+        flags
       };
-    } finally {
-      // any early return or throw above means ffmpeg was never started
-      if (!live.launched) {
-        detach_request_abort();
-
-        // drop our claim, but never touch another request's job or a done/failed record
-        if (claimed && transcode_jobs.get(job_id)?.status === "running") {
-          transcode_jobs.delete(job_id);
-        }
-      }
     }
 
-    // ---------- ffmpeg lifecycle (hoisted) ----------
-
-    /**
-     * Starts (or restarts) ffmpeg. Never throws, failures go through fail().
-     * `rebuild` forces new flags even on the first attempt of a phase
-     * (step 2 needs flags that are different from step 1).
-     */
-    async function run(arg0: {
-      ii: number;
-      keep_subs?: boolean;
-      logs?: string[];
-      rebuild?: boolean;
-    }) {
-      const { ii, keep_subs, logs, rebuild } = arg0;
-
-      if (ii >= MAX_ATTEMPTS) return;
-
-      try {
-        if (logs) id_log_errors({ logs });
+    if (ops === "cmd") {
+      return {
+        cmd: flags
+      };
+    }
 
-        if (ii > 0 || rebuild) {
-          const _CMD = await F_cmd({ subs: keep_subs });
+    // the client gave up while we were preparing
+    if (controller.signal.aborted) {
+      return;
+    }
 
-          flags = _CMD.flags;
+    // -------------------------------
+    // network response headers
+    // -------------------------------
+    construct_response_headers({
+      is_streaming: is_stream_mode
+    });
 
-          NS_Misc.console.log({
-            ENV: "dev",
-            _browser: false,
-            _log: [`[FFMPEG FLAGS] ${ii}::${rebuild}`, flags, "\n"]
-          });
+    NS_Misc.console.log({
+      ENV: "dev",
+      _browser: false,
+      _log: ["[FFMPEG FLAGS]", flags, "\n"]
+    });
 
-          if (controller.signal.aborted) controller = new AbortController();
+    claimed = true;
 
-          progress_data = undefined;
-          seek_size_bytes = 0;
-          live.percent = PHASES[phase].from;
-          live.size = "";
-          local_cleaned = false;
+    // -------------------------------
+    // spawn
+    // -------------------------------
+    if (!is_stream_mode) {
+      record_task_info({
+        job_id,
+        file_with_path: file_with_path || "",
+        status: "running",
+        info: {
+          title: output_destination,
+          ws,
+          progress_endpoint: progress_update_endpoint,
+          ...(two_step ? { phase, stage: PHASES[phase].label } : {}),
+          flags
         }
-
-        start_ffmpeg({ ii });
-      } catch (err) {
-        console.warn("spawn run error:", err, "\n");
-
-        fail([err_message(err)]);
-      }
+      });
     }
 
-    function start_ffmpeg(arg0: { ii: number }) {
-      const { ii } = arg0;
+    if (two_step && !(playback as any).i_x) {
+      const _ = new URL(`/stream/delivery/${data_key}`, REQ_ORIGIN);
 
-      const my_attempt = ++attempt;
+      _.searchParams.set("x_i", job_id);
+      _.searchParams.set("xc", "");
 
-      let settled = false;
+      // const [E_, R_] = await NS_promise.F_catch_fetch({
+      //   parse: "json",
+      //   promise: fetch(
+      //     (() => {
+      //       return _;
+      //     })()
+      //   )
+      // });
 
-      logged_proc_errors = [];
-      logged_proc_info = [];
+      const [E_, R_] = await NS_promise.F_catch_promise({
+        promise: StreamRouterHandlePayload({
+          data_key,
+          metadata,
+          REQ0: _,
+          REQ_ORIGIN,
+          ctx: ctx as any,
+          throw_error: true
+        })
+      });
 
-      const push_log = (arr: string[], line: string) => {
-        arr.push(line);
+      console.log("E_, R_", E_, R_);
 
-        if (arr.length > MAX_LOG_LINES) {
-          arr.splice(0, arr.length - MAX_LOG_LINES);
+      if (E_ || !R_) {
+        if (fMP4) {
+          phase = "single";
+          two_step = false;
+          use_s3_pipe = false;
         }
-      };
 
-      let counter: Transform | undefined;
+        run({
+          ii: 0,
+          ...(fMP4 ? { keep_subs: true, rebuild: true } : {})
+        });
+      }
+    } else {
+      run({
+        ii: 0,
+        ...((playback as any).i_x ? { keep_subs: true, rebuild: true } : {})
+      });
+    }
 
-      if (use_s3_pipe) {
-        s3_bytes = 0;
+    live.launched = true;
 
-        // TWO STEP: step 1 uploads the .ts, step 2 the mp4
-        const key = current_key();
+    if (is_stream_mode) {
+      return passthrough;
+    }
 
-        const c = new Transform({
-          transform(chunk, _enc, cb) {
-            s3_bytes += chunk.length;
+    // download mode: the job lives on its own from here on
+    detach_request_abort();
 
-            cb(null, chunk);
-          }
-        });
+    const message = `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
 
-        c.on("error", () => {}); // real errors surface through `done`
+    return {
+      message,
+      title: output_destination,
+      ws,
+      track_process: progress_update_endpoint
+    };
+  } finally {
+    // any early return or throw above means ffmpeg was never started
+    if (!live.launched) {
+      detach_request_abort();
 
-        const upload = NS_bucket.makeS3Upload({
-          key,
-          body: c,
-          ContentType: current_mime()
-        });
+      // drop our claim, but never touch another request's job or a done/failed record
+      if (claimed && transcode_jobs.get(job_id)?.status === "running") {
+        transcode_jobs.delete(job_id);
+      }
+    }
+  }
 
-        const done: Promise<S3Outcome> = upload.done().then(
-          () => ({ success: true as const }),
-          (error) => {
-            console.warn("S3:ERROR", key, error, "\n");
+  // ---------- ffmpeg lifecycle (hoisted) ----------
 
-            // the upload died, ffmpeg's output has nowhere to go: stop it
-            if (my_attempt === attempt) kill_controller("bucket upload failed");
+  /**
+   * Starts (or restarts) ffmpeg. Never throws, failures go through fail().
+   * `rebuild` forces new flags even on the first attempt of a phase
+   * (step 2 needs flags that are different from step 1).
+   */
+  async function run(arg0: {
+    ii: number;
+    keep_subs?: boolean;
+    logs?: string[];
+    rebuild?: boolean;
+  }) {
+    const { ii, keep_subs, logs, rebuild } = arg0;
 
-            return { success: false as const, error };
-          }
-        );
+    if (ii >= MAX_ATTEMPTS) return;
 
-        s3_attempt = { key, upload, done, counter: c };
-        counter = c;
-      }
+    try {
+      if (logs) id_log_errors({ logs });
 
-      // watchdog: kill ffmpeg if it never produces any output
-      set_t_timeout();
+      if (ii > 0 || rebuild) {
+        const _CMD = await F_cmd({ subs: keep_subs });
 
-      const proc = spawn(NS_ffmpeg_v2.ffmpeg_path, flags, {
-        signal: controller.signal
-      });
+        flags = _CMD.flags;
 
-      if (passthrough) proc.stdout.pipe(passthrough);
+        NS_Misc.console.log({
+          ENV: "dev",
+          _browser: false,
+          _log: [`[FFMPEG FLAGS] ${ii}::${rebuild}`, flags, "\n"]
+        });
 
-      if (counter) {
-        proc.stdout.on("error", () => {}); // EPIPE if the upload is torn down
-        proc.stdout.pipe(counter);
-      }
+        if (controller.signal.aborted) controller = new AbortController();
 
-      proc.stderr.on("data", (data) => {
-        if (my_attempt !== attempt) return;
+        progress_data = undefined;
+        seek_size_bytes = 0;
+        live.percent = PHASES[phase].from;
+        live.size = "";
+        local_cleaned = false;
+      }
 
-        kill_controller_timeout();
+      start_ffmpeg({ ii });
+    } catch (err) {
+      console.warn("spawn run error:", err, "\n");
 
-        const log = data.toString().trim();
+      fail([err_message(err)]);
+    }
+  }
 
-        if (is_dev) console.log("💠", log, "\n");
+  function start_ffmpeg(arg0: { ii: number }) {
+    const { ii } = arg0;
 
-        if (!log) return;
+    const my_attempt = ++attempt;
 
-        push_log(logged_proc_info, log);
+    let settled = false;
 
-        if (
-          NS_ffmpeg_v2.proc_error_pattern().some((pattern) => pattern.test(log))
-        ) {
-          push_log(logged_proc_errors, log);
+    logged_proc_errors = [];
+    logged_proc_info = [];
 
-          return;
-        }
+    const push_log = (arr: string[], line: string) => {
+      arr.push(line);
 
-        const parsed = F_stderr_parse_progress({
-          stderr_line: log,
-          full_duration: parseFloat(`${probe_metadata.format.duration}`),
-          seek_size_bytes
-        });
+      if (arr.length > MAX_LOG_LINES) {
+        arr.splice(0, arr.length - MAX_LOG_LINES);
+      }
+    };
 
-        if (!parsed || !Object.keys(parsed).length) return;
+    let counter: Transform | undefined;
 
-        progress_data = parsed;
+    if (use_s3_pipe) {
+      s3_bytes = 0;
 
-        seek_size_bytes = parseFloat(`${parsed.size_bytes}`) || 0;
+      // TWO STEP: step 1 uploads the .ts, step 2 the mp4
+      const key = current_key();
 
-        live.size = parsed.size || live.size;
+      const c = new Transform({
+        transform(chunk, _enc, cb) {
+          s3_bytes += chunk.length;
 
-        // S3 PIPE: ffmpeg's own size can be N/A on a pipe, the counter is exact
-        if (use_s3_pipe && s3_bytes > 0) {
-          live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
+          cb(null, chunk);
         }
+      });
 
-        if (typeof parsed.percent === "number") {
-          // TWO STEP: map this phase's 0-100 onto its share of the overall bar
-          live.percent = to_overall(parsed.percent);
-        }
+      c.on("error", () => {}); // real errors surface through `done`
 
-        push_progress({});
+      const upload = NS_bucket.makeS3Upload({
+        key,
+        body: c,
+        ContentType: current_mime()
       });
 
-      proc.on("close", (code) => settle({ code }));
+      const done: Promise<S3Outcome> = upload.done().then(
+        () => ({ success: true as const }),
+        (error) => {
+          console.warn("S3:ERROR", key, error, "\n");
 
-      proc.on("error", (err) => {
-        console.error("⚠️❌ FFmpeg spawn error:", err, "\n");
+          // the upload died, ffmpeg's output has nowhere to go: stop it
+          if (my_attempt === attempt) kill_controller("bucket upload failed");
 
-        if (proc.pid === undefined) settle({ code: null, err });
-      });
+          return { success: false as const, error };
+        }
+      );
 
-      function settle(arg0: { code: number | null; err?: Error }) {
-        if (settled) return;
+      s3_attempt = { key, upload, done, counter: c };
+      counter = c;
+    }
 
-        settled = true;
+    // watchdog: kill ffmpeg if it never produces any output
+    set_t_timeout();
 
-        kill_controller_timeout();
+    const proc = spawn(NS_ffmpeg_v2.ffmpeg_path, flags, {
+      signal: controller.signal
+    });
 
-        on_ffmpeg_end({ ii, ...arg0 }).catch((e) => {
-          console.warn("on_ffmpeg_end error:", e, "\n");
+    if (passthrough) proc.stdout.pipe(passthrough);
 
-          fail([err_message(e)]);
-        });
-      }
+    if (counter) {
+      proc.stdout.on("error", () => {}); // EPIPE if the upload is torn down
+      proc.stdout.pipe(counter);
     }
 
-    async function on_ffmpeg_end(arg0: {
-      ii: number;
-      code: number | null;
-      err?: Error;
-    }) {
-      const { ii, code, err } = arg0;
+    proc.stderr.on("data", (data) => {
+      if (my_attempt !== attempt) return;
 
-      // S3 PIPE: the upload finishes just after ffmpeg's stdout closes. Wait
-      // for it, success needs BOTH ffmpeg and the upload to have succeeded.
-      const s3_result = s3_attempt ? await s3_attempt.done : undefined;
+      kill_controller_timeout();
 
-      const percent = progress_data?.percent;
+      const log = data.toString().trim();
 
-      const failure_reason: string | undefined = (() => {
-        if (err) return `FFmpeg could not start: ${err.message}`;
+      if (is_dev) console.log("💠", log, "\n");
 
-        if (s3_result && !s3_result.success) {
-          return `Bucket upload failed: ${err_message(s3_result.error)}`;
-        }
+      if (!log) return;
 
-        if (code !== 0) {
-          return controller.signal.aborted
-            ? "FFmpeg was stopped (timeout or abort)"
-            : `FFmpeg exited with code ${code}`;
-        }
+      push_log(logged_proc_info, log);
 
-        if (typeof percent === "number" && percent > 0 && percent < 90) {
-          return "Incomplete media data";
-        }
-      })();
+      if (
+        NS_ffmpeg_v2.proc_error_pattern().some((pattern) => pattern.test(log))
+      ) {
+        push_log(logged_proc_errors, log);
 
-      if (failure_reason) {
-        console.error(`⚠️❌ [${phase}] ${failure_reason}`, "\n");
-        console.error("Error details:", logged_proc_errors, "\n");
+        return;
+      }
 
-        // S3 PIPE: a truncated media is still "playable", so the half-written object must go. Wait for the delete: a retry reuses the same key.
-        await abort_s3_upload();
+      const parsed = F_stderr_parse_progress({
+        stderr_line: log,
+        full_duration: parseFloat(`${probe_metadata.format.duration}`),
+        seek_size_bytes
+      });
 
-        cleanup_local();
+      if (!parsed || !Object.keys(parsed).length) return;
 
-        // TWO STEP: retries are per phase, `ii` starts again at 0 in step 2
-        const will_retry =
-          is_download_mode && !live.user_aborted && ii + 1 < MAX_ATTEMPTS;
+      progress_data = parsed;
 
-        if (will_retry) {
-          let i = ii + 1;
+      seek_size_bytes = parseFloat(`${parsed.size_bytes}`) || 0;
 
-          if (is_dev) console.log(`WILL RETRY [${phase}]: ${i}`, "\n");
+      live.size = parsed.size || live.size;
 
-          run({
-            ii: i,
-            keep_subs: F_keep_subs(),
-            logs: logged_proc_info
-          });
+      // S3 PIPE: ffmpeg's own size can be N/A on a pipe, the counter is exact
+      if (use_s3_pipe && s3_bytes > 0) {
+        live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
+      }
 
-          return;
-        }
+      if (typeof parsed.percent === "number") {
+        // TWO STEP: map this phase's 0-100 onto its share of the overall bar
+        live.percent = to_overall(parsed.percent);
+      }
 
-        fail([failure_reason, ...logged_proc_errors]);
+      push_progress({});
+    });
 
-        return;
-      }
+    proc.on("close", (code) => settle({ code }));
+
+    proc.on("error", (err) => {
+      console.error("⚠️❌ FFmpeg spawn error:", err, "\n");
+
+      if (proc.pid === undefined) settle({ code: null, err });
+    });
+
+    function settle(arg0: { code: number | null; err?: Error }) {
+      if (settled) return;
+
+      settled = true;
+
+      kill_controller_timeout();
+
+      on_ffmpeg_end({ ii, ...arg0 }).catch((e) => {
+        console.warn("on_ffmpeg_end error:", e, "\n");
 
-      NS_Misc.console.log({
-        ENV: "all",
-        _browser: false,
-        _log: [
-          `🏁 FFMPEG finished [${phase}]: (${percent}) -> ${progress_data?.size} ${file_with_path || output_destination}`,
-          "\n"
-        ]
+        fail([err_message(e)]);
       });
+    }
+  }
 
-      if (is_stream_mode) {
-        // finish_done();
+  async function on_ffmpeg_end(arg0: {
+    ii: number;
+    code: number | null;
+    err?: Error;
+  }) {
+    const { ii, code, err } = arg0;
 
-        return;
+    // S3 PIPE: the upload finishes just after ffmpeg's stdout closes. Wait
+    // for it, success needs BOTH ffmpeg and the upload to have succeeded.
+    const s3_result = s3_attempt ? await s3_attempt.done : undefined;
+
+    const percent = progress_data?.percent;
+
+    const failure_reason: string | undefined = (() => {
+      if (err) return `FFmpeg could not start: ${err.message}`;
+
+      if (s3_result && !s3_result.success) {
+        return `Bucket upload failed: ${err_message(s3_result.error)}`;
       }
 
-      // TWO STEP: the .ts is in the bucket, now convert it to mp4
-      if (two_step && phase === "ts") {
-        await begin_mp4_phase();
+      if (code !== 0) {
+        return controller.signal.aborted
+          ? "FFmpeg was stopped (timeout or abort)"
+          : `FFmpeg exited with code ${code}`;
+      }
 
-        return;
+      if (typeof percent === "number" && percent > 0 && percent < 90) {
+        return "Incomplete media data";
       }
+    })();
 
-      await deliver_download();
-    }
+    if (failure_reason) {
+      console.error(`⚠️❌ [${phase}] ${failure_reason}`, "\n");
+      console.error("Error details:", logged_proc_errors, "\n");
 
-    /**
-     * TWO STEP: step 1 finished, the .ts object is in the bucket. Start step 2,
-     * which reads that object and uploads the mp4.
-     */
-    async function begin_mp4_phase() {
-      // an empty .ts would only produce an empty mp4
-      if (s3_bytes <= 0) {
-        fail(["Step 1 produced an empty file"]);
+      // S3 PIPE: a truncated media is still "playable", so the half-written object must go. Wait for the delete: a retry reuses the same key.
+      await abort_s3_upload();
+
+      cleanup_local();
+
+      // TWO STEP: retries are per phase, `ii` starts again at 0 in step 2
+      const will_retry =
+        is_download_mode && !live.user_aborted && ii + 1 < MAX_ATTEMPTS;
+
+      if (will_retry) {
+        let i = ii + 1;
+
+        if (is_dev) console.log(`WILL RETRY [${phase}]: ${i}`, "\n");
+
+        run({
+          ii: i,
+          keep_subs: F_keep_subs(),
+          logs: logged_proc_info
+        });
 
         return;
       }
 
-      // keep the upload around so the temporary object can be deleted at the end
-      ts_attempt = s3_attempt;
-      s3_attempt = undefined;
+      fail([failure_reason, ...logged_proc_errors]);
 
-      phase = "mp4";
+      return;
+    }
 
-      // subtitle/proxy errors seen while fetching the HLS source say nothing
-      // about step 2
-      error_end_of_file = false;
+    NS_Misc.console.log({
+      ENV: "all",
+      _browser: false,
+      _log: [
+        `🏁 FFMPEG finished [${phase}]: (${percent}) -> ${progress_data?.size} ${file_with_path || output_destination}`,
+        "\n"
+      ]
+    });
 
-      live.percent = PHASES.mp4.from;
-      live.size = "";
+    if (is_stream_mode) {
+      // finish_done();
 
-      // tell clients the second step started
-      push_progress({ force: true });
+      return;
+    }
 
-      use_s3_pipe = false;
-      file_with_path = _file_with_path();
+    // TWO STEP: the .ts is in the bucket, now convert it to mp4
+    if (two_step && phase === "ts") {
+      await begin_mp4_phase();
 
-      await run({ ii: 0, keep_subs: true, rebuild: true });
+      return;
     }
 
-    /**
-     * ffmpeg finished successfully.
-     * S3 pipe: the object is already in the bucket.
-     * Disk: upload the local file, then delete it whether the upload worked or not.
-     */
-    async function deliver_download() {
-      if (use_s3_pipe) {
-        s3_attempt = undefined;
+    await deliver_download();
+  }
 
-        live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
+  /**
+   * TWO STEP: step 1 finished, the .ts object is in the bucket. Start step 2,
+   * which reads that object and uploads the mp4.
+   */
+  async function begin_mp4_phase() {
+    // an empty .ts would only produce an empty mp4
+    if (s3_bytes <= 0) {
+      fail(["Step 1 produced an empty file"]);
 
-        live.percent = 99;
-        push_progress({ force: true });
+      return;
+    }
 
-        if (two_step && phase === "mp4") await delete_ts_temp();
+    // keep the upload around so the temporary object can be deleted at the end
+    ts_attempt = s3_attempt;
+    s3_attempt = undefined;
 
-        await document_and_finish();
+    phase = "mp4";
 
-        return;
-      }
+    // subtitle/proxy errors seen while fetching the HLS source say nothing
+    // about step 2
+    error_end_of_file = false;
 
-      if (!file_with_path) {
-        fail(["No local output file"]);
+    live.percent = PHASES.mp4.from;
+    live.size = "";
 
-        return;
-      }
+    // tell clients the second step started
+    push_progress({ force: true });
 
-      if (is_dev) {
-        finish_done();
-        return;
-      }
+    use_s3_pipe = false;
+    file_with_path = _file_with_path();
 
-      live.percent = 99;
-      push_progress({ force: true, uploading: true });
+    await run({ ii: 0, keep_subs: true, rebuild: true });
+  }
 
-      let uploaded = false;
+  /**
+   * ffmpeg finished successfully.
+   * S3 pipe: the object is already in the bucket.
+   * Disk: upload the local file, then delete it whether the upload worked or not.
+   */
+  async function deliver_download() {
+    if (use_s3_pipe) {
+      s3_attempt = undefined;
 
-      try {
-        uploaded = await upload_with_retry({ file_with_path });
-      } catch (e) {
-        console.warn("bucket upload error:", e, "\n");
-      } finally {
-        if (two_step && phase === "mp4") delete_ts_temp();
-        cleanup_local();
-      }
+      live.size = NS_ffmpeg_v2.F_format_size(s3_bytes) || live.size;
 
-      if (!uploaded) {
-        fail(["Bucket upload failed"]);
+      live.percent = 99;
+      push_progress({ force: true });
 
-        return;
-      }
+      if (two_step && phase === "mp4") await delete_ts_temp();
 
       await document_and_finish();
+
+      return;
     }
 
-    async function document_and_finish() {
-      // document file
-      await wide_search_runner({
-        document: true,
-        skip: {
-          local: true,
-          db: true
-        }
-      }).catch(() => {});
+    if (!file_with_path) {
+      fail(["No local output file"]);
 
+      return;
+    }
+
+    if (is_dev) {
       finish_done();
+      return;
     }
 
-    async function upload_with_retry(arg0: { file_with_path: string }) {
-      const { file_with_path } = arg0;
+    live.percent = 99;
+    push_progress({ force: true, uploading: true });
 
-      if (typeof file_with_path !== "string" || !file_with_path.trim().length) {
-        return false;
-      }
+    let uploaded = false;
 
-      const delays = [0, 2000, 5000];
+    try {
+      uploaded = await upload_with_retry({ file_with_path });
+    } catch (e) {
+      console.warn("bucket upload error:", e, "\n");
+    } finally {
+      if (two_step && phase === "mp4") delete_ts_temp();
+      cleanup_local();
+    }
 
-      for (let i = 0; i < delays.length; i++) {
-        if (delays[i]) await Bun.sleep(delays[i]!);
+    if (!uploaded) {
+      fail(["Bucket upload failed"]);
 
-        const r = await NS_bucket.upload_to_bucket({
-          job_id,
-          bucket_path: bucket_file_path,
-          file_with_path,
-          REQ0,
-          skip: { probe: i > 0 }
-        });
+      return;
+    }
 
-        if (r?.success) return true;
+    await document_and_finish();
+  }
 
-        if (r && !r.success && r.reason === "probe") return false;
+  async function document_and_finish() {
+    // document file
+    await wide_search_runner({
+      document: true,
+      skip: {
+        local: true,
+        db: true
       }
+    }).catch(() => {});
 
+    finish_done();
+  }
+
+  async function upload_with_retry(arg0: { file_with_path: string }) {
+    const { file_with_path } = arg0;
+
+    if (typeof file_with_path !== "string" || !file_with_path.trim().length) {
       return false;
     }
 
-    /*
-      S3 PIPE: tears down the current attempt's upload and deletes whatever
-      reached the bucket under ITS key. Idempotent, and safe when there is no upload.
-    */
-    async function abort_s3_upload() {
-      const a = s3_attempt;
+    const delays = [0, 2000, 5000];
 
-      if (!a) return;
+    for (let i = 0; i < delays.length; i++) {
+      if (delays[i]) await Bun.sleep(delays[i]!);
 
-      s3_attempt = undefined;
+      const r = await NS_bucket.upload_to_bucket({
+        job_id,
+        bucket_path: bucket_file_path,
+        file_with_path,
+        REQ0,
+        skip: { probe: i > 0 }
+      });
 
-      a.counter.destroy();
+      if (r?.success) return true;
 
-      await NS_bucket.delete_self_s3({
-        key: a.key,
-        upload_in: a.upload,
-        done: a.done
-      });
+      if (r && !r.success && r.reason === "probe") return false;
     }
 
-    /*
-      TWO STEP: deletes the temporary .ts object. Best effort, never throws.
-    */
-    async function delete_ts_temp() {
-      if ((playback as any).i_x) return;
+    return false;
+  }
 
-      const a = ts_attempt;
+  /*
+    S3 PIPE: tears down the current attempt's upload and deletes whatever
+    reached the bucket under ITS key. Idempotent, and safe when there is no upload.
+  */
+  async function abort_s3_upload() {
+    const a = s3_attempt;
 
-      if (!a) return;
+    if (!a) return;
 
-      ts_attempt = undefined;
+    s3_attempt = undefined;
 
-      NS_Misc.console.log({
-        ENV: "all",
-        _browser: false,
-        _log: [`🧹: ${a.key}`, "\n"]
-      });
+    a.counter.destroy();
 
-      try {
-        await NS_bucket.delete_self_s3({
-          key: a.key,
-          upload_in: a.upload,
-          done: a.done
-        });
-      } catch (e) {
-        console.warn("delete_ts_temp:", e, "\n");
-      }
-    }
+    await NS_bucket.delete_self_s3({
+      key: a.key,
+      upload_in: a.upload,
+      done: a.done
+    });
+  }
 
-    // ---------- reporting (hoisted) ----------
+  /*
+    TWO STEP: deletes the temporary .ts object. Best effort, never throws.
+  */
+  async function delete_ts_temp() {
+    if ((playback as any).i_x) return;
 
-    function relay_endpoint(data: Record<string, any>) {
-      if (!progress_update_endpoint) return;
+    const a = ts_attempt;
 
-      try {
-        relay_progress_info({
-          endpoint: new URL(progress_update_endpoint),
-          progress_data: data
-        });
-      } catch {}
-    }
+    if (!a) return;
 
-    function push_progress(arg0: { force?: boolean; uploading?: boolean }) {
-      if (live.done || live.failed || is_stream_mode) return;
+    ts_attempt = undefined;
 
-      // each push hits the store, the websocket and an outbound HTTP relay,
-      // so cap it. Completion always goes through finish_done.
-      const now = Date.now();
+    NS_Misc.console.log({
+      ENV: "all",
+      _browser: false,
+      _log: [`🧹: ${a.key}`, "\n"]
+    });
 
-      if (!arg0.force && now - live.last_push < 1500) return;
+    try {
+      await NS_bucket.delete_self_s3({
+        key: a.key,
+        upload_in: a.upload,
+        done: a.done
+      });
+    } catch (e) {
+      console.warn("delete_ts_temp:", e, "\n");
+    }
+  }
 
-      live.last_push = now;
+  // ---------- reporting (hoisted) ----------
 
-      // TWO STEP: which step the user is looking at
-      const step_info = two_step ? { phase, stage: PHASES[phase].label } : {};
+  function relay_endpoint(data: Record<string, any>) {
+    if (!progress_update_endpoint) return;
 
-      record_task_info({
-        job_id,
-        file_with_path: file_with_path || "",
-        status: "running",
-        info: {
-          uploading: arg0.uploading,
-          ...step_info,
-          title: output_destination,
-          percent: live.percent,
-          transcoded_size: live.size,
-          progress_endpoint: progress_update_endpoint,
-          ws,
-          flags,
-          log_errors: logged_proc_errors,
-          logs: logged_proc_info
-        }
+    try {
+      relay_progress_info({
+        endpoint: new URL(progress_update_endpoint),
+        progress_data: data
       });
+    } catch {}
+  }
+
+  function push_progress(arg0: { force?: boolean; uploading?: boolean }) {
+    if (live.done || live.failed || is_stream_mode) return;
+
+    // each push hits the store, the websocket and an outbound HTTP relay,
+    // so cap it. Completion always goes through finish_done.
+    const now = Date.now();
+
+    if (!arg0.force && now - live.last_push < 1500) return;
+
+    live.last_push = now;
+
+    // TWO STEP: which step the user is looking at
+    const step_info = two_step ? { phase, stage: PHASES[phase].label } : {};
 
-      const data = {
-        ...progress_data,
+    record_task_info({
+      job_id,
+      file_with_path: file_with_path || "",
+      status: "running",
+      info: {
         uploading: arg0.uploading,
         ...step_info,
+        title: output_destination,
         percent: live.percent,
-        size: live.size || progress_data?.size,
-        filename: output_destination,
-        location: `${REQ0.origin}/${REQ0.pathname}`,
+        transcoded_size: live.size,
+        progress_endpoint: progress_update_endpoint,
+        ws,
+        flags,
         log_errors: logged_proc_errors,
         logs: logged_proc_info
-      };
-
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status: "running",
-          data
-        }
-      });
+      }
+    });
 
-      relay_endpoint(data);
-    }
+    const data = {
+      ...progress_data,
+      uploading: arg0.uploading,
+      ...step_info,
+      percent: live.percent,
+      size: live.size || progress_data?.size,
+      filename: output_destination,
+      location: `${REQ0.origin}/${REQ0.pathname}`,
+      log_errors: logged_proc_errors,
+      logs: logged_proc_info
+    };
 
-    function finish_done() {
-      if (live.done || live.failed || is_stream_mode) return;
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status: "running",
+        data
+      }
+    });
 
-      live.done = true;
-      live.percent = 100;
+    relay_endpoint(data);
+  }
 
-      record_task_info({
-        job_id,
-        file_with_path: file_with_path || "",
-        status: "done",
-        info: {
-          title: output_destination,
-          percent: 100,
-          transcoded_size: live.size || progress_data?.size,
-          progress_endpoint: progress_update_endpoint,
-          flags,
-          log_errors: logged_proc_errors,
-          logs: logged_proc_info
-        }
-      });
+  function finish_done() {
+    if (live.done || live.failed || is_stream_mode) return;
 
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status: "done",
-          filename: output_destination,
-          logs: logged_proc_info
-        }
-      });
+    live.done = true;
+    live.percent = 100;
 
-      relay_endpoint({
+    record_task_info({
+      job_id,
+      file_with_path: file_with_path || "",
+      status: "done",
+      info: {
+        title: output_destination,
         percent: 100,
-        filename: output_destination,
-        location: `${REQ0.origin}/${REQ0.pathname}`,
+        transcoded_size: live.size || progress_data?.size,
+        progress_endpoint: progress_update_endpoint,
+        flags,
         log_errors: logged_proc_errors,
         logs: logged_proc_info
-      });
+      }
+    });
 
-      if (is_download_mode) {
-        transcode_jobs.delete(job_id);
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status: "done",
+        filename: output_destination,
+        logs: logged_proc_info
       }
+    });
+
+    relay_endpoint({
+      percent: 100,
+      filename: output_destination,
+      location: `${REQ0.origin}/${REQ0.pathname}`,
+      log_errors: logged_proc_errors,
+      logs: logged_proc_info
+    });
+
+    if (is_download_mode) {
+      transcode_jobs.delete(job_id);
     }
+  }
 
-    function fail(logs: string[]) {
-      if (live.failed || live.done || is_stream_mode) return;
+  function fail(logs: string[]) {
+    if (live.failed || live.done || is_stream_mode) return;
 
-      live.failed = true;
+    live.failed = true;
 
-      record_task_info({
-        job_id,
-        file_with_path: file_with_path || "",
-        status: "failed",
-        info: {
-          title: output_destination,
-          ws,
-          // TWO STEP: say which step broke
-          ...(two_step ? { phase, stage: PHASES[phase].label } : {}),
-          error: logs.join(" | "),
-          log_errors: logged_proc_errors,
-          logs: logged_proc_info
-        }
-      });
+    record_task_info({
+      job_id,
+      file_with_path: file_with_path || "",
+      status: "failed",
+      info: {
+        title: output_destination,
+        ws,
+        // TWO STEP: say which step broke
+        ...(two_step ? { phase, stage: PHASES[phase].label } : {}),
+        error: logs.join(" | "),
+        log_errors: logged_proc_errors,
+        logs: logged_proc_info
+      }
+    });
 
-      relay_progress_info_ws({
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
         channel: data_key,
-        payload: {
-          channel: data_key,
-          status: "failed",
-          filename: output_destination,
-          logs: logged_proc_info
-        }
-      });
-
-      relay_endpoint({
         status: "failed",
-        ...(two_step ? { phase } : {}),
         filename: output_destination,
-        location: `${REQ0.origin}/${REQ0.pathname}`,
-        log_errors: logged_proc_errors,
         logs: logged_proc_info
-      });
+      }
+    });
 
-      passthrough?.destroy(new Error(logs[0] || "failed"));
+    relay_endpoint({
+      status: "failed",
+      ...(two_step ? { phase } : {}),
+      filename: output_destination,
+      location: `${REQ0.origin}/${REQ0.pathname}`,
+      log_errors: logged_proc_errors,
+      logs: logged_proc_info
+    });
 
-      cleanup_local();
+    passthrough?.destroy(new Error(logs[0] || "failed"));
 
-      // S3 PIPE: covers failures that did not come through on_ffmpeg_end
-      // (spawn/run errors). A no-op when the upload was already torn down.
-      abort_s3_upload().catch((e) => console.warn("abort_s3_upload:", e));
+    cleanup_local();
 
-      // TWO STEP: a failure in step 2 leaves the finished .ts behind: remove it
-      delete_ts_temp().catch(() => {});
-    }
+    // S3 PIPE: covers failures that did not come through on_ffmpeg_end
+    // (spawn/run errors). A no-op when the upload was already torn down.
+    abort_s3_upload().catch((e) => console.warn("abort_s3_upload:", e));
 
-    // ---------- helpers (hoisted) ----------
+    // TWO STEP: a failure in step 2 leaves the finished .ts behind: remove it
+    delete_ts_temp().catch(() => {});
+  }
 
-    /**
-     * Deletes the local output file. Safe to call from every exit path: it
-     * only runs once per attempt. Skipped in dev, where the local file is the
-     * store. No-op in S3 pipe mode, there is no local file.
-     */
-    function cleanup_local() {
-      if (!file_with_path || local_cleaned) return;
+  // ---------- helpers (hoisted) ----------
 
-      if (is_dev && live.done) return;
+  /**
+   * Deletes the local output file. Safe to call from every exit path: it
+   * only runs once per attempt. Skipped in dev, where the local file is the
+   * store. No-op in S3 pipe mode, there is no local file.
+   */
+  function cleanup_local() {
+    if (!file_with_path || local_cleaned) return;
 
-      local_cleaned = true;
+    if (is_dev && live.done) return;
 
-      NS_bucket.delete_self({ try_count: 0, file_with_path });
-    }
+    local_cleaned = true;
 
-    function kill_controller(reason: string) {
-      controller.abort();
+    NS_bucket.delete_self({ try_count: 0, file_with_path });
+  }
 
-      console.log(`[CONTROLLER] aborted: ${reason}`);
-    }
+  function kill_controller(reason: string) {
+    controller.abort();
 
-    function set_t_timeout() {
-      kill_controller_timeout();
+    console.log(`[CONTROLLER] aborted: ${reason}`);
+  }
 
-      watchdog = setTimeout(
-        () => kill_controller("no output from ffmpeg"),
-        NS_ffmpeg_v2.TIMEOUT_MS
-      );
+  function set_t_timeout() {
+    kill_controller_timeout();
+
+    watchdog = setTimeout(
+      () => kill_controller("no output from ffmpeg"),
+      NS_ffmpeg_v2.TIMEOUT_MS
+    );
+  }
+
+  function kill_controller_timeout() {
+    if (watchdog) {
+      clearTimeout(watchdog);
+      watchdog = undefined;
     }
+  }
 
-    function kill_controller_timeout() {
-      if (watchdog) {
-        clearTimeout(watchdog);
-        watchdog = undefined;
-      }
+  function id_log_errors(arg0: { logs: string[] }) {
+    const { logs } = arg0;
+
+    if (!Array.isArray(logs)) {
+      return;
     }
 
-    function id_log_errors(arg0: { logs: string[] }) {
-      const { logs } = arg0;
+    const has = (needle: string) => {
+      return logs.some((xx) =>
+        xx.toString().toLowerCase().includes(needle.toLowerCase())
+      );
+    };
 
-      if (!Array.isArray(logs)) {
-        return;
-      }
+    if (has("http error 429 too many requests")) {
+      error_429 = true;
+    }
 
-      const has = (needle: string) => {
-        return logs.some((xx) =>
-          xx.toString().toLowerCase().includes(needle.toLowerCase())
-        );
-      };
+    if (has("failed too many times, skipping")) {
+      error_429 = true;
+    }
 
-      if (has("http error 429 too many requests")) {
-        error_429 = true;
-      }
+    if (has("error opening input: end of file")) {
+      error_end_of_file = true;
+    }
 
-      if (has("failed too many times, skipping")) {
-        error_429 = true;
-      }
+    if (has("error opening input files: server returned 403 forbidden")) {
+      error_403 = true;
+    }
 
-      if (has("error opening input: end of file")) {
-        error_end_of_file = true;
-      }
+    if (has("http error 404 not found")) {
+      error_403 = true;
+    }
+  }
 
-      if (has("error opening input files: server returned 403 forbidden")) {
-        error_403 = true;
-      }
+  // keep subtitles unless one of THEIR urls caused the end-of-file error
+  function F_keep_subs() {
+    if (!logged_proc_info.length || !subtitles?.length) {
+      return true;
+    }
 
-      if (has("http error 404 not found")) {
-        error_403 = true;
-      }
+    const eof_lines = logged_proc_info
+      .map((xx) => xx.toString().toLowerCase())
+      .filter((xx) => xx.includes("error opening input: end of file"));
+
+    if (!eof_lines.length) {
+      return true;
     }
 
-    // keep subtitles unless one of THEIR urls caused the end-of-file error
-    function F_keep_subs() {
-      if (!logged_proc_info.length || !subtitles?.length) {
-        return true;
-      }
+    const sub_failed = subtitles.some((sub) => {
+      const url = sub.url.toString().toLowerCase();
 
-      const eof_lines = logged_proc_info
-        .map((xx) => xx.toString().toLowerCase())
-        .filter((xx) => xx.includes("error opening input: end of file"));
+      return eof_lines.some((line) => line.includes(url));
+    });
 
-      if (!eof_lines.length) {
-        return true;
-      }
+    return !sub_failed;
+  }
 
-      const sub_failed = subtitles.some((sub) => {
-        const url = sub.url.toString().toLowerCase();
+  /**
+   * Sends a playback through the cloudflare proxy (used for the 403/429
+   * fallback and for private bucket urls). Returns the input unchanged when
+   * no proxy is available.
+   */
+  async function proxy_playback(p: T_playback): Promise<T_playback> {
+    // get_hf_sia_proxy
+    const R_ = IS_HF()
+      ? await NS_scrape_post_processing_helper.get_cloudflare_proxy({})
+      : await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
 
-        return eof_lines.some((line) => line.includes(url));
-      });
+    if (!R_) return p;
 
-      return !sub_failed;
-    }
+    const proxy_base = R_.available || R_.fallback;
 
-    /**
-     * Sends a playback through the cloudflare proxy (used for the 403/429
-     * fallback and for private bucket urls). Returns the input unchanged when
-     * no proxy is available.
-     */
-    async function proxy_playback(p: T_playback): Promise<T_playback> {
-      // get_hf_sia_proxy
-      const R_ = IS_HF()
-        ? await NS_scrape_post_processing_helper.get_cloudflare_proxy({})
-        : await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
-
-      if (!R_) return p;
-
-      const proxy_base = R_.available || R_.fallback;
-
-      if (NS_routes_c.F_is_url(proxy_base)) {
-        const _ = await NS_pack_proxima.F_handle_pack_encode({
-          base: proxy_base,
-          payload: {
-            endpoint: p.url,
-            commands: {
-              use_h_version: true,
-              redirect_origin: true,
-              headers: p.headers
-            }
+    if (NS_routes_c.F_is_url(proxy_base)) {
+      const _ = await NS_pack_proxima.F_handle_pack_encode({
+        base: proxy_base,
+        payload: {
+          endpoint: p.url,
+          commands: {
+            use_h_version: true,
+            redirect_origin: true,
+            headers: p.headers
           }
-        });
+        }
+      });
 
-        if (_) {
-          const __ = { ...p };
+      if (_) {
+        const __ = { ...p };
 
-          __.url = _.toString();
+        __.url = _.toString();
 
-          delete __.headers;
+        delete __.headers;
 
-          return __;
-        }
+        return __;
       }
-
-      return p;
     }
 
-    /**
-     * TWO STEP: the playback ffmpeg reads in step 2, i.e. the .ts object that
-     * step 1 left in the bucket.
-     *
-     * The HLS source's headers (user agent, referer, ...) are deliberately NOT
-     * carried over, they do not belong on a bucket request.
-     */
-    async function ts_playback(): Promise<T_playback> {
-      if ((playback as any).i_x) {
-        return playback;
-      }
-
-      const { url, headers } = NS_bucket.bucket_file_url({ key: ts_key });
-
-      const p = { ...playback, url, headers, type: "video" } as T_playback;
+    return p;
+  }
 
-      // private bucket: let the proxy attach the auth header. ffmpeg would send
-      // it to the CDN host the bucket redirects to as well, which rejects it.
-      return headers ? await proxy_playback(p) : p;
+  /**
+   * TWO STEP: the playback ffmpeg reads in step 2, i.e. the .ts object that
+   * step 1 left in the bucket.
+   *
+   * The HLS source's headers (user agent, referer, ...) are deliberately NOT
+   * carried over, they do not belong on a bucket request.
+   */
+  async function ts_playback(): Promise<T_playback> {
+    if ((playback as any).i_x) {
+      return playback;
     }
 
-    async function F_cmd(arg0: { subs?: boolean }) {
-      const { subs } = arg0;
-
-      // TWO STEP, step 2: input is the .ts in the bucket, output is the mp4 on
-      // stdout (delivery_mode "stream" is what your old "s3" mode mapped to)
-      if (phase === "mp4") {
-        has_subs = subs === false ? false : true;
-
-        return await NS_ffmpeg_v2.F_build_ffmpeg_flags_t1({
-          playback: await ts_playback(),
-          subtitles: subs === false ? undefined : subtitles,
-          probe_metadata,
-          delivery_format,
-          delivery_mode: "download",
-          output_destination: file_with_path || "",
-          flash_ping: false,
-          dl_to_s3: false
-        });
-      }
+    const { url, headers } = NS_bucket.bucket_file_url({ key: ts_key });
 
-      const new_playback = await (async () => {
-        if ((!error_429 && !error_403) || playback.url.includes("/proxima")) {
-          return playback;
-        }
+    const p = { ...playback, url, headers, type: "video" } as T_playback;
 
-        return await proxy_playback(playback);
-      })();
+    // private bucket: let the proxy attach the auth header. ffmpeg would send
+    // it to the CDN host the bucket redirects to as well, which rejects it.
+    return headers ? await proxy_playback(p) : p;
+  }
+
+  async function F_cmd(arg0: { subs?: boolean }) {
+    const { subs } = arg0;
 
-      // TWO STEP: a .ts cannot carry mov_text subtitles, they are added in step 2
-      has_subs = two_step ? false : subs === false ? false : true;
+    // TWO STEP, step 2: input is the .ts in the bucket, output is the mp4 on
+    // stdout (delivery_mode "stream" is what your old "s3" mode mapped to)
+    if (phase === "mp4") {
+      has_subs = subs === false ? false : true;
 
-      const data = await NS_ffmpeg_v2.F_build_ffmpeg_flags_t1({
-        playback: new_playback,
-        subtitles: two_step || subs === false ? undefined : subtitles,
+      return await NS_ffmpeg_v2.F_build_ffmpeg_flags_t1({
+        playback: await ts_playback(),
+        subtitles: subs === false ? undefined : subtitles,
         probe_metadata,
-        delivery_format: two_step ? "ts" : delivery_format,
-        delivery_mode,
+        delivery_format,
+        delivery_mode: "download",
         output_destination: file_with_path || "",
         flash_ping: false,
-        dl_to_s3: use_s3_pipe
+        dl_to_s3: false
       });
-
-      return data;
     }
 
-    function construct_response_headers(arg0: {
-      is_download?: boolean;
-      is_streaming?: boolean;
-    }) {
-      const { is_streaming, is_download } = arg0;
-
-      /* ----------  set response headers  ---------- */
-      if (is_download || is_streaming) {
-        ctx.set.headers["content-type"] = out_mime;
+    const new_playback = await (async () => {
+      if ((!error_429 && !error_403) || playback.url.includes("/proxima")) {
+        return playback;
       }
 
-      ctx.set.headers["cache-control"] = "no-cache";
+      return await proxy_playback(playback);
+    })();
 
-      if (is_download) {
-        ctx.set.headers["content-disposition"] =
-          `attachment; filename="${output_destination}"`;
+    // TWO STEP: a .ts cannot carry mov_text subtitles, they are added in step 2
+    has_subs = two_step ? false : subs === false ? false : true;
 
-        ctx.set.headers["accept-ranges"] = "bytes";
-      }
+    const data = await NS_ffmpeg_v2.F_build_ffmpeg_flags_t1({
+      playback: new_playback,
+      subtitles: two_step || subs === false ? undefined : subtitles,
+      probe_metadata,
+      delivery_format: two_step ? "ts" : delivery_format,
+      delivery_mode,
+      output_destination: file_with_path || "",
+      flash_ping: false,
+      dl_to_s3: use_s3_pipe
+    });
 
-      if (clean_metadata?.format?.duration) {
-        ctx.set.headers["X-Content-Duration"] = clean_metadata.format?.duration;
-      }
-    }
+    return data;
+  }
 
-    async function wide_search_runner(arg0: {
-      skip?: {
-        local?: boolean;
-        db?: boolean;
-        bucket?: boolean;
-      };
-      document: boolean;
-    }) {
-      const { skip, document } = arg0;
+  function construct_response_headers(arg0: {
+    is_download?: boolean;
+    is_streaming?: boolean;
+  }) {
+    const { is_streaming, is_download } = arg0;
 
-      if (!is_download_mode) return;
+    /* ----------  set response headers  ---------- */
+    if (is_download || is_streaming) {
+      ctx.set.headers["content-type"] = out_mime;
+    }
 
-      const [E_, R_] = await NS_promise.F_catch_promise({
-        promise: NS_showtime_v2_helper.find_seed_file({
-          sbe_id,
-          output_destination: {
-            og: output_destination,
-            clean: output_destination_clean,
-            file_with_path
-          },
-          picture_quality,
-          qLevel,
-          sbe_s_e,
-          cache_folder,
-          file_id: clean_file_id,
-          job_id,
-          S3Dir,
-          cleanup_corruption: true,
-          document,
-          ideal_runtime: playback.ideal_runtime,
-          skip,
-          has_subs
-        })
-      });
+    ctx.set.headers["cache-control"] = "no-cache";
 
-      if (R_ && "stream_link" in R_ && R_.stream_link) {
-        if (!NS_misc.isValidUrlFormat(R_.stream_link)) {
-          return;
-        }
-      }
+    if (is_download) {
+      ctx.set.headers["content-disposition"] =
+        `attachment; filename="${output_destination}"`;
 
-      return R_;
+      ctx.set.headers["accept-ranges"] = "bytes";
+    }
+
+    if (clean_metadata?.format?.duration) {
+      ctx.set.headers["X-Content-Duration"] = clean_metadata.format?.duration;
     }
-  },
-  {
-    params: t.Object({
-      data_key: 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"),
-            t.Literal("just_check")
-          ],
-          {
-            error() {
-              return "Invalid operation, must be one of: cmd, raw, decode";
-            }
-          }
-        )
-      )
-    })
   }
-);
 
-export const ShowtimeV2Router = sub_router;
+  async function wide_search_runner(arg0: {
+    skip?: {
+      local?: boolean;
+      db?: boolean;
+      bucket?: boolean;
+    };
+    document: boolean;
+  }) {
+    const { skip, document } = arg0;
+
+    if (!is_download_mode) return;
+
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: NS_showtime_v2_helper.find_seed_file({
+        sbe_id,
+        output_destination: {
+          og: output_destination,
+          clean: output_destination_clean,
+          file_with_path
+        },
+        picture_quality,
+        qLevel,
+        sbe_s_e,
+        cache_folder,
+        file_id: clean_file_id,
+        job_id,
+        S3Dir,
+        cleanup_corruption: true,
+        document,
+        ideal_runtime: playback.ideal_runtime,
+        skip,
+        has_subs
+      })
+    });
+
+    if (R_ && "stream_link" in R_ && R_.stream_link) {
+      if (!NS_misc.isValidUrlFormat(R_.stream_link)) {
+        return;
+      }
+    }
+
+    return R_;
+  }
+}
 
 function F_stderr_parse_progress(arg0: {
   stderr_line: string;

src/sub-router/stream.ts

@@ -25,6 +25,7 @@ import { NS_showtime_v2_helper } from "../lib/dl-showtime-helper";
 import { once } from "node:events";
 import { NS_Misc } from "@x/core/client/misc.ts";
 import { NS_bucket } from "../lib/bucket";
+import { ShowtimeV2RouterHandlePayload } from "./showtime";
 
 type Range = { offset: number; length: number };
 type Init = { url: string; key: Key; range?: Range };
@@ -93,1012 +94,1061 @@ const sub_router = new Elysia({ prefix: "/stream" }).get(
       return metadata;
     }
 
-    const { playback, probe_metadata, sbe_id, progress_update_endpoint } =
-      metadata as T_delivery_payload;
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: handle_data({
+        data_key,
+        metadata,
+        REQ0,
+        REQ_ORIGIN,
+        ctx: ctx as any,
+        ops
+      })
+    });
 
-    let { output_destination, delivery_mode, delivery_format, out_mime } =
-      metadata as T_delivery_payload;
+    if (E_) {
+      const { message, status } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
 
-    const x_i = REQ0.searchParams.get("x_i");
-    const xc = REQ0.searchParams.has("xc");
+      return ctx.status(status, message);
+    }
 
-    const two_step = x_i && x_i.length ? true : false;
+    return R_;
+  },
+  {
+    params: t.Object({
+      data_key: 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"),
+            t.Literal("just_check")
+          ],
+          {
+            error() {
+              return "Invalid operation, must be one of: cmd, raw, decode";
+            }
+          }
+        )
+      )
+    })
+  }
+);
 
-    const picture_quality = (() => {
-      const _ = playback.picture_quality;
+export const StreamRouter = sub_router;
+export const StreamRouterHandlePayload = handle_data;
+
+async function handle_data(arg0: {
+  data_key: string;
+  metadata: T_delivery_payload;
+  REQ0: URL;
+  REQ_ORIGIN: string;
+  ctx: Context;
+  ops?: string;
+  throw_error?: boolean;
+}) {
+  const { data_key, metadata, REQ0, REQ_ORIGIN, ctx, ops, throw_error } = arg0;
 
-      if (typeof _ !== "string") {
-        return "";
-      }
+  const { playback, probe_metadata, sbe_id, progress_update_endpoint } =
+    metadata;
 
-      return _.trim().split(" ").join("");
-    })();
+  let { output_destination, delivery_mode, delivery_format, out_mime } =
+    metadata;
 
-    const sbe_s_e = (() => {
-      const _ = metadata.sbe_s_e;
+  const x_i = REQ0.searchParams.get("x_i");
+  const xc = REQ0.searchParams.has("xc");
 
-      if (typeof _ !== "string" || _.toLowerCase().includes("nan")) {
-        return;
-      }
+  const two_step = x_i && x_i.length ? true : false;
 
-      return _.trim().split(" ").join("");
-    })();
+  const picture_quality = (() => {
+    const _ = playback.picture_quality;
 
-    const qLevel = (() => {
-      if (
-        typeof metadata.qLevel === "string" &&
-        metadata.qLevel.trim().length > 0
-      ) {
-        return metadata.qLevel.trim();
-      }
+    if (typeof _ !== "string") {
+      return "";
+    }
 
-      const _ = NS_ffmpeg_v2.F_get_qLevel({
-        metadata: probe_metadata
-      });
+    return _.trim().split(" ").join("");
+  })();
 
-      return _;
-    })();
+  const sbe_s_e = (() => {
+    const _ = metadata.sbe_s_e;
 
-    const ws = (() => {
-      const is_https = new URL(REQ_ORIGIN).protocol === "https:";
+    if (typeof _ !== "string" || _.toLowerCase().includes("nan")) {
+      return;
+    }
 
-      const ws_protocol = is_https ? "wss" : "ws";
+    return _.trim().split(" ").join("");
+  })();
 
-      const _ = `${ws_protocol}://${REQ0.host}/ws`;
+  const qLevel = (() => {
+    if (
+      typeof metadata.qLevel === "string" &&
+      metadata.qLevel.trim().length > 0
+    ) {
+      return metadata.qLevel.trim();
+    }
 
-      const data = {
-        connect: _,
-        channel: data_key
-      };
+    const _ = NS_ffmpeg_v2.F_get_qLevel({
+      metadata: probe_metadata
+    });
 
-      return data;
-    })();
+    return _;
+  })();
+
+  const ws = (() => {
+    const is_https = new URL(REQ_ORIGIN).protocol === "https:";
 
-    let segments: Segment[] | undefined = undefined;
+    const ws_protocol = is_https ? "wss" : "ws";
 
-    let active_playback = playback;
-    let proxied = false;
-    let init: Init | undefined = undefined;
+    const _ = `${ws_protocol}://${REQ0.host}/ws`;
 
-    const PHASES = {
-      single: { from: 0, to: 99, label: "Processing" },
-      ts: { from: 0, to: 60, label: "Step 1/2: fetching video" },
-      mp4: { from: 60, to: 99, label: "Step 2/2: converting to MP4" }
-    } as const;
+    const data = {
+      connect: _,
+      channel: data_key
+    };
 
-    type Phase = keyof typeof PHASES;
+    return data;
+  })();
 
-    let phase: Phase = "single";
+  let segments: Segment[] | undefined = undefined;
 
-    out_mime = "video/mp2t";
-    delivery_format = "ts";
+  let active_playback = playback;
+  let proxied = false;
+  let init: Init | undefined = undefined;
 
-    try {
-      const seg_error = await get_segments({ _playback: playback });
+  const PHASES = {
+    single: { from: 0, to: 99, label: "Processing" },
+    ts: { from: 0, to: 60, label: "Step 1/2: fetching video" },
+    mp4: { from: 60, to: 99, label: "Step 2/2: converting to MP4" }
+  } as const;
 
-      if (seg_error) {
-        return ctx.status(422, seg_error);
-      }
-    } catch (error) {
-      throw error;
-    }
+  type Phase = keyof typeof PHASES;
 
-    await (async () => {
-      if (!two_step) return;
+  let phase: Phase = "single";
 
-      delivery_mode = "s3";
+  out_mime = "video/mp2t";
+  delivery_format = "ts";
 
-      phase = "ts";
-    })();
+  try {
+    const seg_error = await get_segments({ _playback: playback });
 
-    if (delivery_mode !== "s3") {
-      return ctx.status(400, "Unsupported delivery mode or format");
+    if (seg_error) {
+      if (throw_error) throw Error(JSON.stringify(seg_error));
+
+      return ctx.status(422, seg_error);
     }
+  } catch (error) {
+    throw error;
+  }
 
-    const ext_key = (() => {
-      const _ = NS_files.F_get_file_extension({
-        filename: output_destination,
-        return_new_filename: true
-      });
+  await (async () => {
+    if (!two_step) return;
 
-      return `${_.new_filename}.${delivery_format}`;
-    })();
+    delivery_mode = "s3";
 
-    output_destination = ext_key;
+    phase = "ts";
+  })();
 
-    const output_destination_clean = NS_misc.cleanNameV2(output_destination);
+  if (delivery_mode !== "s3") {
+    const message = "Unsupported delivery mode or format";
 
-    const clean_file_id = (() => {
-      return `${picture_quality}-${output_destination_clean}`.toLowerCase();
-    })();
+    if (throw_error) throw Error(JSON.stringify(message));
+    return ctx.status(400, message);
+  }
 
-    const job_id = x_i || `${sbe_id}-${clean_file_id}`;
+  const ext_key = (() => {
+    const _ = NS_files.F_get_file_extension({
+      filename: output_destination,
+      return_new_filename: true
+    });
 
-    const file_id = `${Date.now()}-${clean_file_id}`;
+    return `${_.new_filename}.${delivery_format}`;
+  })();
 
-    const cache_folder = two_step ? `cacheStream/${sbe_id}` : `cache/${sbe_id}`;
+  output_destination = ext_key;
 
-    const bucket_file_path = (() => {
-      const _ = `${cache_folder}/${file_id}`;
+  const output_destination_clean = NS_misc.cleanNameV2(output_destination);
 
-      return _;
-    })();
+  const clean_file_id = (() => {
+    return `${picture_quality}-${output_destination_clean}`.toLowerCase();
+  })();
 
-    const MAX_RETRIES = 3;
-
-    const err_message = (err: unknown) =>
-      NS_error.F_collect_error_message({ ERR: err }).message;
-
-    // -------------------------------
-    // Shared job state
-    // -------------------------------
-    // one object that the segment and S3 callbacks write to, so neither one wipes out the other's numbers
-    const live = {
-      percent: 0,
-      size: "",
-      failed: false,
-      done: false,
-      launched: false,
-      last_push: 0 // throttle for push_progress
-    };
+  const job_id = x_i || `${sbe_id}-${clean_file_id}`;
 
-    // bumped on every (re)start so callbacks from an older attempt can be ignored
-    let attempt = 0;
+  const file_id = `${Date.now()}-${clean_file_id}`;
 
-    // -------------------------------
-    // Setup abort handling
-    // -------------------------------
-    // The request signal only matters until the job has launched. After we answered the client the job runs in the background, and a client disconnect must not kill it.
-    let controller = new AbortController();
+  const cache_folder = two_step ? `cacheStream/${sbe_id}` : `cache/${sbe_id}`;
 
-    const abort_signal = ctx?.request.signal;
+  const bucket_file_path = (() => {
+    const _ = `${cache_folder}/${file_id}`;
 
-    const on_request_abort = () => kill_controller({ cleanup_files: true });
+    return _;
+  })();
 
-    const detach_request_abort = () =>
-      abort_signal?.removeEventListener("abort", on_request_abort);
+  const MAX_RETRIES = 3;
+
+  const err_message = (err: unknown) =>
+    NS_error.F_collect_error_message({ ERR: err }).message;
+
+  // -------------------------------
+  // Shared job state
+  // -------------------------------
+  // one object that the segment and S3 callbacks write to, so neither one wipes out the other's numbers
+  const live = {
+    percent: 0,
+    size: "",
+    failed: false,
+    done: false,
+    launched: false,
+    last_push: 0 // throttle for push_progress
+  };
 
-    if (abort_signal?.aborted) {
-      kill_controller({ cleanup_files: true });
+  // bumped on every (re)start so callbacks from an older attempt can be ignored
+  let attempt = 0;
 
-      return;
-    }
+  // -------------------------------
+  // Setup abort handling
+  // -------------------------------
+  // The request signal only matters until the job has launched. After we answered the client the job runs in the background, and a client disconnect must not kill it.
+  let controller = new AbortController();
 
-    abort_signal?.addEventListener("abort", on_request_abort, { once: true });
+  const abort_signal = ctx?.request.signal;
 
-    let error_429 = false;
-    let error_403 = false;
+  const on_request_abort = () => kill_controller({ cleanup_files: true });
 
-    // true once THIS request recorded the "running" claim for job_id
-    let claimed = false;
+  const detach_request_abort = () =>
+    abort_signal?.removeEventListener("abort", on_request_abort);
 
-    // phase-local percent (0-100) -> overall percent, never above 99
-    function to_overall(phase_pct: number) {
-      const p = PHASES[phase];
+  if (abort_signal?.aborted) {
+    kill_controller({ cleanup_files: true });
 
-      return Math.min(
-        99,
-        Math.max(p.from, p.from + (phase_pct / 100) * (p.to - p.from))
-      );
-    }
+    return;
+  }
 
-    try {
-      const current_job = (() => {
-        const _ = transcode_jobs.get(job_id);
+  abort_signal?.addEventListener("abort", on_request_abort, { once: true });
 
-        if (!_ || xc) return;
+  let error_429 = false;
+  let error_403 = false;
 
-        return _;
-      })();
+  // true once THIS request recorded the "running" claim for job_id
+  let claimed = false;
 
-      if (current_job?.status === "running") {
-        const percent = current_job?.percent;
-        const percentage = typeof percent === "number" ? `${percent} %` : "";
-        const transcoded_size = current_job?.transcoded_size;
-        const progress_endpoint =
-          current_job?.progress_endpoint || progress_update_endpoint;
+  // phase-local percent (0-100) -> overall percent, never above 99
+  function to_overall(phase_pct: number) {
+    const p = PHASES[phase];
 
-        const message = percentage
-          ? `ENGINE PROGRESS: ${percentage}`
-          : "ENGINE PROCESSING ...";
+    return Math.min(
+      99,
+      Math.max(p.from, p.from + (phase_pct / 100) * (p.to - p.from))
+    );
+  }
 
-        return {
-          processing: true,
-          message,
-          percent,
-          transcoded_size,
-          // TWO STEP: lets a re-polling client show which step is running
-          phase: current_job?.phase,
-          stage: current_job?.stage,
-          track_process: progress_endpoint,
-          file: output_destination,
-          job_id,
-          output_destination,
-          qLevel,
-          picture_quality,
-          ws,
-          flags: current_job.flags,
-          logs: current_job.logs,
-          ...(ops === "just_check" ? { passed: true } : {})
-        };
-      }
+  try {
+    const current_job = (() => {
+      const _ = transcode_jobs.get(job_id);
 
-      if (current_job?.status === "failed") {
-        const logs = current_job?.logs;
+      if (!_ || xc) return;
 
-        if (logs) id_log_errors({ logs });
+      return _;
+    })();
 
-        if (ops === "just_check") {
-          return {
-            passed: false,
-            delivery: output_destination,
-            track_process: progress_update_endpoint,
-            ws,
-            flags: current_job.flags,
-            logs: current_job?.logs
-          };
-        }
+    if (current_job?.status === "running") {
+      const percent = current_job?.percent;
+      const percentage = typeof percent === "number" ? `${percent} %` : "";
+      const transcoded_size = current_job?.transcoded_size;
+      const progress_endpoint =
+        current_job?.progress_endpoint || progress_update_endpoint;
 
-        transcode_jobs.delete(job_id);
+      const message = percentage
+        ? `ENGINE PROGRESS: ${percentage}`
+        : "ENGINE PROCESSING ...";
 
-        const probe_playback = await new_playback();
+      return {
+        processing: true,
+        message,
+        percent,
+        transcoded_size,
+        // TWO STEP: lets a re-polling client show which step is running
+        phase: current_job?.phase,
+        stage: current_job?.stage,
+        track_process: progress_endpoint,
+        file: output_destination,
+        job_id,
+        output_destination,
+        qLevel,
+        picture_quality,
+        ws,
+        flags: current_job.flags,
+        logs: current_job.logs,
+        ...(ops === "just_check" ? { passed: true } : {})
+      };
+    }
 
-        const _ = await ping_probe({ playback: probe_playback });
+    if (current_job?.status === "failed") {
+      const logs = current_job?.logs;
 
-        if (!_.success) {
-          throw new Error("Something went wrong: with probe");
-        }
-      }
+      if (logs) id_log_errors({ logs });
 
-      const seed_file = await (async () => {
-        if (ops === "cmd") {
-          return;
-        }
+      if (ops === "just_check") {
+        return {
+          passed: false,
+          delivery: output_destination,
+          track_process: progress_update_endpoint,
+          ws,
+          flags: current_job.flags,
+          logs: current_job?.logs
+        };
+      }
 
-        const _ = current_job?.db_metadata?.stream_link;
+      transcode_jobs.delete(job_id);
 
-        if (_) {
-          return current_job.db_metadata;
-        }
+      const probe_playback = await new_playback();
 
-        const __ = await wide_search_runner({
-          document: true,
-          i_x: two_step ? true : false,
-          skip: { local: true }
-        });
+      const _ = await ping_probe({ playback: probe_playback });
 
-        return __;
-      })();
+      if (!_.success) {
+        throw new Error("Something went wrong: with probe");
+      }
+    }
 
-      // wide search runner >> seed
-      const _ = await (async () => {
-        if (!seed_file) return;
-
-        const file_size_bytes = parseFloat(`${seed_file?.size}`);
-
-        const percent = 100;
-        const transcoded_size = file_size_bytes
-          ? NS_ffmpeg_v2.F_format_size(file_size_bytes)
-          : current_job?.transcoded_size;
-        const progress_endpoint =
-          current_job?.progress_endpoint || progress_update_endpoint;
-
-        if (!current_job?.db_metadata?.stream_link) {
-          record_task_info({
-            job_id,
-            status: "done",
-            info: {
-              title: output_destination,
-              percent,
-              transcoded_size,
-              ...("stream_link" in seed_file && seed_file.stream_link
-                ? { db_metadata: seed_file }
-                : {})
-            }
-          });
-        }
+    const seed_file = await (async () => {
+      if (ops === "cmd") {
+        return;
+      }
 
-        const _ =
-          seed_file && "stream_link" in seed_file && seed_file.stream_link;
+      const _ = current_job?.db_metadata?.stream_link;
 
-        if (two_step && _) {
-          return {};
-        }
+      if (_) {
+        return current_job.db_metadata;
+      }
 
-        const new_stream_link = await (async () => {
-          if (!_) {
-            return;
-          }
+      const __ = await wide_search_runner({
+        document: true,
+        i_x: two_step ? true : false,
+        skip: { local: true }
+      });
 
-          const stream_link = new URL(seed_file.stream_link);
-          stream_link.searchParams.set("download", "true");
-
-          const [E_, R_] = await NS_promise.F_catch_promise({
-            promise: (async () => {
-              const cloudflare =
-                await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
-
-              if (!cloudflare.available) return;
-
-              const _ = await NS_pack_proxima.F_handle_pack_encode({
-                base: new URL(cloudflare.available),
-                payload: {
-                  endpoint: stream_link.toString(),
-                  commands: {
-                    response_headers: {
-                      set: {
-                        "content-disposition": `attachment; filename="${output_destination}"`
-                      }
-                    },
-                    use_h_version: true
-                  }
-                }
-              });
+      return __;
+    })();
 
-              return { proxy_url: _ };
-            })()
-          });
+    // wide search runner >> seed
+    const _ = await (async () => {
+      if (!seed_file) return;
 
-          const new_stream_link =
-            (R_ as any)?.proxy_url.toString() || stream_link.toString();
+      const file_size_bytes = parseFloat(`${seed_file?.size}`);
 
-          return new_stream_link;
-        })();
+      const percent = 100;
+      const transcoded_size = file_size_bytes
+        ? NS_ffmpeg_v2.F_format_size(file_size_bytes)
+        : current_job?.transcoded_size;
+      const progress_endpoint =
+        current_job?.progress_endpoint || progress_update_endpoint;
 
-        if (ops === "just_check") {
-          return {
-            passed: true,
-            ready: true,
+      if (!current_job?.db_metadata?.stream_link) {
+        record_task_info({
+          job_id,
+          status: "done",
+          info: {
+            title: output_destination,
             percent,
             transcoded_size,
-            output_destination,
-            flags: current_job?.flags,
-            logs: current_job?.logs,
-            ...(new_stream_link ? { stream_link: new_stream_link } : {}),
-            track_process: progress_endpoint
-          };
-        }
+            ...("stream_link" in seed_file && seed_file.stream_link
+              ? { db_metadata: seed_file }
+              : {})
+          }
+        });
+      }
 
-        if (new_stream_link) return ctx.redirect(new_stream_link, 302);
-      })();
+      const _ =
+        seed_file && "stream_link" in seed_file && seed_file.stream_link;
 
-      if (_) {
-        return _;
+      if (two_step && _) {
+        return {};
       }
 
-      let _playback = await new_playback();
+      const new_stream_link = await (async () => {
+        if (!_) {
+          return;
+        }
 
-      claimed = true;
+        const stream_link = new URL(seed_file.stream_link);
+        stream_link.searchParams.set("download", "true");
 
-      record_task_info({
-        job_id,
-        status: "running",
+        const [E_, R_] = await NS_promise.F_catch_promise({
+          promise: (async () => {
+            const cloudflare =
+              await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
 
-        info: {
-          title: output_destination,
-          ws,
-          progress_endpoint: progress_update_endpoint
-        }
-      });
+            if (!cloudflare.available) return;
 
-      // the client gave up while we were resolving the playlist
-      if (controller.signal.aborted) {
-        return;
-      }
+            const _ = await NS_pack_proxima.F_handle_pack_encode({
+              base: new URL(cloudflare.available),
+              payload: {
+                endpoint: stream_link.toString(),
+                commands: {
+                  response_headers: {
+                    set: {
+                      "content-disposition": `attachment; filename="${output_destination}"`
+                    }
+                  },
+                  use_h_version: true
+                }
+              }
+            });
+
+            return { proxy_url: _ };
+          })()
+        });
+
+        const new_stream_link =
+          (R_ as any)?.proxy_url.toString() || stream_link.toString();
+
+        return new_stream_link;
+      })();
 
       if (ops === "just_check") {
         return {
           passed: true,
-          segments,
-          playback: _playback
+          ready: true,
+          percent,
+          transcoded_size,
+          output_destination,
+          flags: current_job?.flags,
+          logs: current_job?.logs,
+          ...(new_stream_link ? { stream_link: new_stream_link } : {}),
+          track_process: progress_endpoint
         };
       }
 
-      spawn({ retry: 0 });
+      if (new_stream_link) return ctx.redirect(new_stream_link, 302);
+    })();
 
-      const message = `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
+    if (_) {
+      return _;
+    }
 
-      live.launched = true;
+    let _playback = await new_playback();
 
-      detach_request_abort();
+    claimed = true;
 
-      return {
-        message,
+    record_task_info({
+      job_id,
+      status: "running",
+
+      info: {
         title: output_destination,
         ws,
-        track_process: progress_update_endpoint
+        progress_endpoint: progress_update_endpoint
+      }
+    });
+
+    // the client gave up while we were resolving the playlist
+    if (controller.signal.aborted) {
+      return;
+    }
+
+    if (ops === "just_check") {
+      return {
+        passed: true,
+        segments,
+        playback: _playback
       };
+    }
 
-      /*
-        Starts (or restarts) the download -> upload pipeline.
-      */
-      async function spawn(arg0: { retry: number }) {
-        const { retry } = arg0;
+    spawn({ retry: 0 });
 
-        if (retry >= MAX_RETRIES) return;
+    const message = `COMPILER ENGINE started, this may take a while. ${progress_update_endpoint ? `check process -> ${progress_update_endpoint}` : "check back later"}`;
 
-        try {
-          if (retry === 0) {
-            if (controller.signal.aborted) return;
-          } else {
-            const next_playback = await new_playback();
+    live.launched = true;
 
-            if (next_playback === _playback) return;
+    detach_request_abort();
 
-            _playback = next_playback;
+    return {
+      message,
+      title: output_destination,
+      ws,
+      track_process: progress_update_endpoint
+    };
 
-            controller.abort();
-            controller = new AbortController();
+    /*
+      Starts (or restarts) the download -> upload pipeline.
+    */
+    async function spawn(arg0: { retry: number }) {
+      const { retry } = arg0;
 
-            live.done = false;
-            live.failed = false;
-            live.percent = 0;
-            live.size = "";
+      if (retry >= MAX_RETRIES) return;
 
-            const res = await get_segments({ _playback });
+      try {
+        if (retry === 0) {
+          if (controller.signal.aborted) return;
+        } else {
+          const next_playback = await new_playback();
 
-            if (res?.error) {
-              fail([res.error]);
+          if (next_playback === _playback) return;
 
-              return;
-            }
-          }
+          _playback = next_playback;
 
-          const current_segments = segments;
+          controller.abort();
+          controller = new AbortController();
 
-          if (!current_segments?.length) {
-            fail(["No segments to upload"]);
+          live.done = false;
+          live.failed = false;
+          live.percent = 0;
+          live.size = "";
+
+          const res = await get_segments({ _playback });
+
+          if (res?.error) {
+            fail([res.error]);
 
             return;
           }
+        }
 
-          const my_attempt = ++attempt;
-          const stale = () => my_attempt !== attempt;
+        const current_segments = segments;
 
-          const bytes = segmentStream({
-            segments: current_segments,
-            init,
-            headers: _playback.headers || {},
-            concurrency: 6,
-            ac: controller,
-            onError: (arg0) => {
-              if (is_dev) console.error("💠", JSON.stringify(arg0), "\n");
+        if (!current_segments?.length) {
+          fail(["No segments to upload"]);
 
-              if (stale()) return;
+          return;
+        }
 
-              fail([err_message(arg0.err)]);
-            },
-            onSegment: (arg0) => {
-              if (is_dev) console.log("💠", JSON.stringify(arg0), "\n");
+        const my_attempt = ++attempt;
+        const stale = () => my_attempt !== attempt;
 
-              if (stale()) return;
+        const bytes = segmentStream({
+          segments: current_segments,
+          init,
+          headers: _playback.headers || {},
+          concurrency: IS_HF() ? 12 : 6,
+          ac: controller,
+          onError: (arg0) => {
+            if (is_dev) console.error("💠", JSON.stringify(arg0), "\n");
 
-              live.percent = arg0.percent;
+            if (stale()) return;
 
-              push_progress({ size: live.size, percent: live.percent });
-            }
-          });
+            fail([err_message(arg0.err)]);
+          },
+          onSegment: (arg0) => {
+            if (is_dev) console.log("💠", JSON.stringify(arg0), "\n");
 
-          putStreamWriter({
-            stream: bytes,
-            ContentType: out_mime,
-            key: bucket_file_path,
-            segmentsTotal: current_segments.length,
-            ac: controller,
-            onError: (arg0) => {
-              if (is_dev) console.error("💠", JSON.stringify(arg0), "\n");
+            if (stale()) return;
 
-              if (stale()) return;
+            live.percent = arg0.percent;
 
-              fail([err_message(arg0.err)]);
-            },
-            onProgress: (s) => {
-              if (is_dev) console.log("💠", JSON.stringify(arg0), "\n");
+            push_progress({ size: live.size, percent: live.percent });
+          }
+        });
 
-              if (stale()) return;
+        putStreamWriter({
+          stream: bytes,
+          ContentType: out_mime,
+          key: bucket_file_path,
+          segmentsTotal: current_segments.length,
+          ac: controller,
+          onError: (arg0) => {
+            if (is_dev) console.error("💠", JSON.stringify(arg0), "\n");
 
-              live.size = s.size || live.size;
+            if (stale()) return;
 
-              if (s.state === "running") {
-                push_progress({ size: live.size, percent: live.percent });
-              }
+            fail([err_message(arg0.err)]);
+          },
+          onProgress: (s) => {
+            if (is_dev) console.log("💠", JSON.stringify(arg0), "\n");
+
+            if (stale()) return;
+
+            live.size = s.size || live.size;
+
+            if (s.state === "running") {
+              push_progress({ size: live.size, percent: live.percent });
             }
-          }).then(
-            (r) => {
-              if (stale()) return;
-
-              live.done = true;
-              live.size = NS_files.F_format_size(r.bytes) || live.size;
-              live.percent = 100;
-
-              push_done({ size: live.size });
-
-              try {
-                // document file
-                (async () => {
-                  const _ = await wide_search_runner({
-                    document: two_step ? false : true,
-                    i_x: two_step ? true : false,
-                    skip: {
-                      local: true,
-                      db: true
-                    }
-                  });
-                })();
-
-                NS_Misc.console.log({
-                  ENV: "all",
-                  _browser: false,
-                  _log: [
-                    `🏁 SEG STREAM finished [${phase}]: (${live.percent} %) -> ${live.size} -> ${output_destination}`,
-                    "\n"
-                  ]
+          }
+        }).then(
+          (r) => {
+            if (stale()) return;
+
+            live.done = true;
+            live.size = NS_files.F_format_size(r.bytes) || live.size;
+            live.percent = 100;
+
+            push_done({ size: live.size });
+
+            try {
+              // document file
+              (async () => {
+                const _ = await wide_search_runner({
+                  document: two_step ? false : true,
+                  i_x: two_step ? true : false,
+                  skip: {
+                    local: true,
+                    db: true
+                  }
                 });
-              } catch (e) {
-                console.warn("post-done step failed:", e);
-              }
-            },
-            (err) => {
-              if (stale()) return;
+              })();
+
+              NS_Misc.console.log({
+                ENV: "all",
+                _browser: false,
+                _log: [
+                  `🏁 SEG STREAM finished [${phase}]: (${live.percent} %) -> ${live.size} -> ${output_destination}`,
+                  "\n"
+                ]
+              });
+            } catch (e) {
+              console.warn("post-done step failed:", e);
+            }
+          },
+          (err) => {
+            if (stale()) return;
 
-              console.warn("RUN ERROR:", err);
+            console.warn("RUN ERROR:", err);
 
-              fail([err_message(err)]);
+            fail([err_message(err)]);
 
-              spawn({ retry: retry + 1 });
-            }
-          );
-        } catch (err) {
-          console.warn("spawn error:", err);
+            spawn({ retry: retry + 1 });
+          }
+        );
+      } catch (err) {
+        console.warn("spawn error:", err);
 
-          fail([err_message(err)]);
-        }
+        fail([err_message(err)]);
       }
-    } finally {
-      if (!live.launched) {
-        detach_request_abort();
+    }
+  } finally {
+    if (!live.launched) {
+      detach_request_abort();
 
-        if (claimed && transcode_jobs.get(job_id)?.status === "running") {
-          transcode_jobs.delete(job_id);
-        }
+      if (claimed && transcode_jobs.get(job_id)?.status === "running") {
+        transcode_jobs.delete(job_id);
       }
     }
+  }
 
-    /*
-        Returns the playback to use. Switches to the proxy only after a
-        403/429, only once, and returns the SAME object when there is nothing new to try (callers compare by reference).
-      */
-    async function new_playback() {
-      if (
-        (!error_429 && !error_403) ||
-        proxied ||
-        playback.url.toString().includes("/proxima")
-      ) {
-        return active_playback;
-      }
+  /*
+      Returns the playback to use. Switches to the proxy only after a
+      403/429, only once, and returns the SAME object when there is nothing new to try (callers compare by reference).
+    */
+  async function new_playback() {
+    if (
+      (!error_429 && !error_403) ||
+      proxied ||
+      playback.url.toString().includes("/proxima")
+    ) {
+      return active_playback;
+    }
 
-      const R_ = await NS_scrape_post_processing_helper.get_cloudflare_proxy(
-        {}
-      );
+    const R_ = await NS_scrape_post_processing_helper.get_cloudflare_proxy({});
 
-      if (!R_) return playback;
+    if (!R_) return playback;
 
-      const proxy_base = R_.available || R_.fallback;
+    const proxy_base = R_.available || R_.fallback;
 
-      if (NS_routes_c.F_is_url(proxy_base)) {
-        const _ = await NS_pack_proxima.F_handle_pack_encode({
-          base: proxy_base,
-          payload: {
-            endpoint: playback.url.toString(),
-            commands: {
-              use_h_version: true,
-              redirect_origin: true,
-              headers: playback.headers
-            }
+    if (NS_routes_c.F_is_url(proxy_base)) {
+      const _ = await NS_pack_proxima.F_handle_pack_encode({
+        base: proxy_base,
+        payload: {
+          endpoint: playback.url.toString(),
+          commands: {
+            use_h_version: true,
+            redirect_origin: true,
+            headers: playback.headers
           }
-        });
+        }
+      });
 
-        if (_) {
-          const __ = { ...playback };
+      if (_) {
+        const __ = { ...playback };
 
-          __.url = _.toString();
+        __.url = _.toString();
 
-          delete __.headers;
+        delete __.headers;
 
-          proxied = true;
-          active_playback = __;
+        proxied = true;
+        active_playback = __;
 
-          return __;
-        }
+        return __;
       }
-
-      return active_playback;
     }
 
-    async function get_segments(arg0: {
-      _playback: T_delivery_payload["playback"];
-    }): Promise<{ error: string } | undefined> {
-      let { _playback } = arg0;
+    return active_playback;
+  }
 
-      const resolve = () =>
-        NS_promise.F_catch_promise({
-          promise: resolveMediaPlaylist({
-            url: _playback.url,
-            headers: _playback.headers || {}
-          })
-        });
+  async function get_segments(arg0: {
+    _playback: T_delivery_payload["playback"];
+  }): Promise<{ error: string } | undefined> {
+    let { _playback } = arg0;
 
-      let [E_, R_] = await resolve();
+    const resolve = () =>
+      NS_promise.F_catch_promise({
+        promise: resolveMediaPlaylist({
+          url: _playback.url,
+          headers: _playback.headers || {}
+        })
+      });
 
-      if (E_ || !R_) {
-        const { message, status } = NS_error.F_collect_error_status_n_message({
-          ERR: E_
-        });
+    let [E_, R_] = await resolve();
 
-        id_log_errors({ logs: [message] });
+    if (E_ || !R_) {
+      const { message, status } = NS_error.F_collect_error_status_n_message({
+        ERR: E_
+      });
 
-        if (error_403 || error_429) {
-          _playback = await new_playback();
+      id_log_errors({ logs: [message] });
 
-          [E_, R_] = await resolve();
+      if (error_403 || error_429) {
+        _playback = await new_playback();
 
-          if (E_ || !R_) {
-            const { message, status } =
-              NS_error.F_collect_error_status_n_message({
-                ERR: E_
-              });
+        [E_, R_] = await resolve();
 
-            fail([message]);
+        if (E_ || !R_) {
+          const { message, status } = NS_error.F_collect_error_status_n_message(
+            {
+              ERR: E_
+            }
+          );
 
-            throw NS_error.F_create_error({ status, message });
-          }
-        } else {
           fail([message]);
 
           throw NS_error.F_create_error({ status, message });
         }
+      } else {
+        fail([message]);
+
+        throw NS_error.F_create_error({ status, message });
       }
+    }
 
-      const { url, text, separate_audio } = R_!;
+    const { url, text, separate_audio } = R_!;
 
-      const media = parseMedia({ text, base: url });
+    const media = parseMedia({ text, base: url });
 
-      if (!media.segments.length) {
-        return { error: "No segments found" };
-      }
-
-      if (!media.ended) {
-        return { error: "Live playlists are not supported" };
-      }
+    if (!media.segments.length) {
+      return { error: "No segments found" };
+    }
 
-      if (media.initUrl || media?.init?.url) {
-        if (!two_step) {
-          // return { error: "fMP4/CMAF needs remuxing, not supported" };
-        }
+    if (!media.ended) {
+      return { error: "Live playlists are not supported" };
+    }
 
-        out_mime = "video/mp4";
-        delivery_format = "mp4";
+    if (media.initUrl || media?.init?.url) {
+      if (!two_step) {
+        // return { error: "fMP4/CMAF needs remuxing, not supported" };
       }
 
-      if (media.init) {
-        // what is still NOT possible without ffmpeg
-        if (media.init_changes) {
-          return {
-            error:
-              "Playlist switches init segments (discontinuity), needs remuxing"
-          };
-        }
-      }
+      out_mime = "video/mp4";
+      delivery_format = "mp4";
+    }
 
-      if (separate_audio) {
-        return { error: "Audio is a separate track, needs muxing" };
+    if (media.init) {
+      // what is still NOT possible without ffmpeg
+      if (media.init_changes) {
+        return {
+          error:
+            "Playlist switches init segments (discontinuity), needs remuxing"
+        };
       }
+    }
 
-      init = media.init;
-      segments = media.segments;
+    if (separate_audio) {
+      return { error: "Audio is a separate track, needs muxing" };
     }
 
-    // ---------- helpers (hoisted) ----------
+    init = media.init;
+    segments = media.segments;
+  }
 
-    function id_log_errors(arg0: { logs: string[] }) {
-      const { logs } = arg0;
+  // ---------- helpers (hoisted) ----------
 
-      if (!Array.isArray(logs)) {
-        return;
-      }
+  function id_log_errors(arg0: { logs: string[] }) {
+    const { logs } = arg0;
 
-      logs.forEach((xx) => {
-        const _ = xx.toString().toLowerCase();
-
-        if (
-          _.includes(
-            "Error opening input files: Server returned 403 Forbidden".toLowerCase()
-          ) ||
-          _.includes("Fetch failed: status: 403".toLowerCase()) ||
-          _.includes("Segment failed (403)".toLowerCase()) ||
-          _.includes("Segment failed (404)".toLowerCase()) ||
-          _.includes("http error 404 not found".toLowerCase())
-        ) {
-          error_403 = true;
-        }
-
-        if (
-          _.includes("HTTP error 429 Too Many Requests".toLowerCase()) ||
-          _.includes("Fetch failed: status: 429".toLowerCase()) ||
-          _.includes("Segment failed (429)".toLowerCase()) ||
-          _.includes("failed too many times, skipping".toLowerCase())
-        ) {
-          error_429 = true;
-        }
-      });
+    if (!Array.isArray(logs)) {
+      return;
     }
 
-    function fail(logs: string[]) {
-      if (live.failed || live.done) return;
+    logs.forEach((xx) => {
+      const _ = xx.toString().toLowerCase();
 
-      live.failed = true;
+      if (
+        _.includes(
+          "Error opening input files: Server returned 403 Forbidden".toLowerCase()
+        ) ||
+        _.includes("Fetch failed: status: 403".toLowerCase()) ||
+        _.includes("Segment failed (403)".toLowerCase()) ||
+        _.includes("Segment failed (404)".toLowerCase()) ||
+        _.includes("http error 404 not found".toLowerCase())
+      ) {
+        error_403 = true;
+      }
 
-      id_log_errors({ logs: logs });
+      if (
+        _.includes("HTTP error 429 Too Many Requests".toLowerCase()) ||
+        _.includes("Fetch failed: status: 429".toLowerCase()) ||
+        _.includes("Segment failed (429)".toLowerCase()) ||
+        _.includes("failed too many times, skipping".toLowerCase())
+      ) {
+        error_429 = true;
+      }
+    });
+  }
 
-      push_failed({ logs, size: live.size });
-    }
+  function fail(logs: string[]) {
+    if (live.failed || live.done) return;
 
-    function push_failed(arg0: { size?: string; logs: string[] }) {
-      const { size, logs } = arg0,
-        percent = live.percent,
-        title = output_destination,
-        transcoded_size = size || live.size || "",
-        status = "failed";
+    live.failed = true;
 
-      record_task_info({
-        job_id,
-        status,
-        info: {
-          title,
-          percent: percent && two_step ? to_overall(percent) : percent,
-          transcoded_size,
-          ws,
-          ...(two_step ? { phase, stage: PHASES[phase].label } : {}),
-          logs
-        }
-      });
+    id_log_errors({ logs: logs });
 
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status,
-          title,
-          percent: percent && two_step ? to_overall(percent) : percent,
-          transcoded_size,
-          logs
-        }
-      });
+    push_failed({ logs, size: live.size });
+  }
 
-      relay_progress_info({
-        endpoint: progress_update_endpoint
-          ? new URL(progress_update_endpoint)
-          : undefined,
-        progress_data: {
-          status,
-          title,
-          percent: percent && two_step ? to_overall(percent) : percent,
-          ...(two_step ? { phase } : {}),
-          location: `${REQ0.origin}/${REQ0.pathname}`,
-          logs
-        }
-      });
-    }
+  function push_failed(arg0: { size?: string; logs: string[] }) {
+    const { size, logs } = arg0,
+      percent = live.percent,
+      title = output_destination,
+      transcoded_size = size || live.size || "",
+      status = "failed";
+
+    record_task_info({
+      job_id,
+      status,
+      info: {
+        title,
+        percent: percent && two_step ? to_overall(percent) : percent,
+        transcoded_size,
+        ws,
+        ...(two_step ? { phase, stage: PHASES[phase].label } : {}),
+        logs
+      }
+    });
 
-    function push_done(arg0: { size?: string }) {
-      const { size } = arg0,
-        percent = 100,
-        title = output_destination,
-        transcoded_size = size || live.size || "",
-        status = "done";
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status,
+        title,
+        percent: percent && two_step ? to_overall(percent) : percent,
+        transcoded_size,
+        logs
+      }
+    });
 
-      record_task_info({
-        job_id,
+    relay_progress_info({
+      endpoint: progress_update_endpoint
+        ? new URL(progress_update_endpoint)
+        : undefined,
+      progress_data: {
         status,
-        info: {
-          title,
-          percent: percent && two_step ? to_overall(percent) : percent,
-          transcoded_size,
-          progress_endpoint: progress_update_endpoint
-        }
-      });
+        title,
+        percent: percent && two_step ? to_overall(percent) : percent,
+        ...(two_step ? { phase } : {}),
+        location: `${REQ0.origin}/${REQ0.pathname}`,
+        logs
+      }
+    });
+  }
 
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status,
-          data: {
-            status,
-            title,
-            percent: percent && two_step ? to_overall(percent) : percent,
-            transcoded_size
-          }
-        }
-      });
+  function push_done(arg0: { size?: string }) {
+    const { size } = arg0,
+      percent = 100,
+      title = output_destination,
+      transcoded_size = size || live.size || "",
+      status = "done";
+
+    record_task_info({
+      job_id,
+      status,
+      info: {
+        title,
+        percent: percent && two_step ? to_overall(percent) : percent,
+        transcoded_size,
+        progress_endpoint: progress_update_endpoint
+      }
+    });
 
-      relay_progress_info({
-        endpoint: progress_update_endpoint
-          ? new URL(progress_update_endpoint)
-          : undefined,
-        progress_data: {
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status,
+        data: {
           status,
-          percent: percent && two_step ? to_overall(percent) : percent,
           title,
-          location: `${REQ0.origin}/${REQ0.pathname}`
+          percent: percent && two_step ? to_overall(percent) : percent,
+          transcoded_size
         }
-      });
-    }
+      }
+    });
 
-    function push_progress(arg0: { size: string; percent?: number }) {
-      if (live.done || live.failed) return;
+    relay_progress_info({
+      endpoint: progress_update_endpoint
+        ? new URL(progress_update_endpoint)
+        : undefined,
+      progress_data: {
+        status,
+        percent: percent && two_step ? to_overall(percent) : percent,
+        title,
+        location: `${REQ0.origin}/${REQ0.pathname}`
+      }
+    });
+  }
 
-      const now = Date.now();
+  function push_progress(arg0: { size: string; percent?: number }) {
+    if (live.done || live.failed) return;
 
-      if (now - live.last_push < 1500) return;
+    const now = Date.now();
 
-      live.last_push = now;
+    if (now - live.last_push < 1500) return;
 
-      const { size, percent } = arg0,
-        transcoded_size = size || live.size || "",
-        status = "running";
+    live.last_push = now;
 
-      const step_info = two_step ? { phase, stage: PHASES[phase].label } : {};
+    const { size, percent } = arg0,
+      transcoded_size = size || live.size || "",
+      status = "running";
 
-      record_task_info({
-        job_id,
-        status,
-        info: {
-          title: output_destination,
-          percent: percent && two_step ? to_overall(percent) : percent,
-          transcoded_size,
-          ...step_info,
-          progress_endpoint: progress_update_endpoint,
-          ws
-        }
-      });
+    const step_info = two_step ? { phase, stage: PHASES[phase].label } : {};
 
-      const data = {
-        status,
+    record_task_info({
+      job_id,
+      status,
+      info: {
         title: output_destination,
         percent: percent && two_step ? to_overall(percent) : percent,
         transcoded_size,
         ...step_info,
-        location: `${REQ0.origin}/${REQ0.pathname}`
-      };
+        progress_endpoint: progress_update_endpoint,
+        ws
+      }
+    });
 
-      relay_progress_info_ws({
-        channel: data_key,
-        payload: {
-          channel: data_key,
-          status,
-          data
-        }
-      });
+    const data = {
+      status,
+      title: output_destination,
+      percent: percent && two_step ? to_overall(percent) : percent,
+      transcoded_size,
+      ...step_info,
+      location: `${REQ0.origin}/${REQ0.pathname}`
+    };
 
-      relay_progress_info({
-        endpoint: progress_update_endpoint
-          ? new URL(progress_update_endpoint)
-          : undefined,
-        progress_data: data
-      });
-    }
+    relay_progress_info_ws({
+      channel: data_key,
+      payload: {
+        channel: data_key,
+        status,
+        data
+      }
+    });
 
-    function kill_controller(arg0: { cleanup_files?: boolean }) {
-      const { cleanup_files } = arg0;
+    relay_progress_info({
+      endpoint: progress_update_endpoint
+        ? new URL(progress_update_endpoint)
+        : undefined,
+      progress_data: data
+    });
+  }
 
-      controller.abort();
+  function kill_controller(arg0: { cleanup_files?: boolean }) {
+    const { cleanup_files } = arg0;
 
-      // user aborted before the job was launched: mark it failed. Any
-      // multipart upload is cleaned up by putStreamWriter when the abort
-      // reaches it
-      if (cleanup_files && !live.done) {
-        fail(["Request aborted"]);
-      }
+    controller.abort();
 
-      console.log("[CONTROLLER] Request aborted");
+    // user aborted before the job was launched: mark it failed. Any
+    // multipart upload is cleaned up by putStreamWriter when the abort
+    // reaches it
+    if (cleanup_files && !live.done) {
+      fail(["Request aborted"]);
     }
 
-    async function wide_search_runner(arg0: {
-      skip?: {
-        local?: boolean;
-        db?: boolean;
-        bucket?: boolean;
-      };
-      document: boolean;
-      i_x?: boolean;
-    }) {
-      const { skip, document, i_x } = arg0;
-
-      const [E_, R_] = await NS_promise.F_catch_promise({
-        promise: NS_showtime_v2_helper.find_seed_file({
-          sbe_id,
-          output_destination: {
-            og: output_destination,
-            clean: output_destination_clean
-          },
-          picture_quality,
-          qLevel,
-          sbe_s_e,
-          cache_folder,
-          file_id: clean_file_id,
-          job_id,
-          cleanup_corruption: true,
-          document,
-          ideal_runtime: playback.ideal_runtime,
-          skip,
-          has_subs: false
-        })
-      });
+    console.log("[CONTROLLER] Request aborted");
+  }
 
-      if (R_ && "stream_link" in R_ && R_.stream_link) {
-        if (!NS_misc.isValidUrlFormat(R_.stream_link)) {
-          return;
-        }
+  async function wide_search_runner(arg0: {
+    skip?: {
+      local?: boolean;
+      db?: boolean;
+      bucket?: boolean;
+    };
+    document: boolean;
+    i_x?: boolean;
+  }) {
+    const { skip, document, i_x } = arg0;
+
+    const [E_, R_] = await NS_promise.F_catch_promise({
+      promise: NS_showtime_v2_helper.find_seed_file({
+        sbe_id,
+        output_destination: {
+          og: output_destination,
+          clean: output_destination_clean
+        },
+        picture_quality,
+        qLevel,
+        sbe_s_e,
+        cache_folder,
+        file_id: clean_file_id,
+        job_id,
+        cleanup_corruption: true,
+        document,
+        ideal_runtime: playback.ideal_runtime,
+        skip,
+        has_subs: false
+      })
+    });
+
+    if (R_ && "stream_link" in R_ && R_.stream_link) {
+      if (!NS_misc.isValidUrlFormat(R_.stream_link)) {
+        return;
+      }
 
-        if (i_x) {
-          const _ = new URL(`/showtimeV2/delivery/${data_key}`, REQ_ORIGIN);
+      if (i_x) {
+        const _ = new URL(`/showtimeV2/delivery/${data_key}`, REQ_ORIGIN);
 
-          _.searchParams.set("i_x", R_.stream_link);
-          _.searchParams.set("xc", "");
+        _.searchParams.set("i_x", R_.stream_link);
+        _.searchParams.set("xc", "");
 
-          phase = "mp4";
+        phase = "mp4";
 
-          NS_Misc.console.log({
-            ENV: "all",
-            _browser: false,
-            _log: [`🏁 PHRASE [${phase}]: INIT`, "\n"]
-          });
+        NS_Misc.console.log({
+          ENV: "all",
+          _browser: false,
+          _log: [`🏁 PHRASE [${phase}]: INIT`, "\n"]
+        });
 
-          fetch(_);
-        }
-      }
+        // fetch(_);
 
-      return R_;
+        NS_promise.F_catch_promise({
+          promise: ShowtimeV2RouterHandlePayload({
+            data_key,
+            metadata,
+            REQ0: _,
+            REQ_ORIGIN,
+            ctx: ctx as any,
+            throw_error: true
+          })
+        });
+      }
     }
-  },
-  {
-    params: t.Object({
-      data_key: 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"),
-            t.Literal("just_check")
-          ],
-          {
-            error() {
-              return "Invalid operation, must be one of: cmd, raw, decode";
-            }
-          }
-        )
-      )
-    })
-  }
-);
 
-export const StreamRouter = sub_router;
+    return R_;
+  }
+}
 
 async function fetchText(arg0: { url: string; headers: Record<string, any> }) {
   const { url, headers } = arg0;