@torrent-tv/proxy 2.90.0 → 2.92.0

package/services/viewer/playback-readiness.js

@@ -3,7 +3,7 @@
  * exhausting the continuous media available for the required tracks.
  *
  * This module contains the playback decision's only model. Its inputs are
- * measurements and physical limits: source bytes and download rate, encoded
+ * measurements and physical limits: mapped whole-piece arrivals, encoded
  * media and encoder rate, segment sizes and client-link rate, existing
  * continuous media, and measured supply interruptions. Each service integral
  * extends its latest measured rate until the next observation. The forecast
@@ -99,8 +99,8 @@ export class RateTrend {
  * @param {number} input.lookaheadSeconds
  * @param {number} input.now
  * @param {boolean} [input.requiredAudio]
- * @param {Array<{ id: string, serviceId?: string, complete: boolean, bytesPerMediaSecond: number,
- *   readings: Array<{ at: number, value: number }> }>} input.sources
+ * @param {Array<{ id: string, complete: boolean,
+ *   downloadForecast?: { ranges: Array<{ start: number, end: number, availableAt: number | null }> } }>} input.sources
  * @param {Array<{ id: string, sourceIds: string[], processedSeconds: number,
  *   bitsPerMediaSecond: number, readings: Array<{ at: number, value: number }>,
  *   clockOffsetSeconds?: number, clientRanges?: Array<{ start: number, end: number }>,
@@ -137,10 +137,10 @@ export function predictPlaybackReadiness(input = {}) {
     ]))
   ]);
   const zero = mediaTime(0n, unit);
-  const segmentsOf = tracks.map((track, trackIndex) =>
+  const segmentsOf = tracks.map((track, trackIndex) => predictedMediaSegments(
     (Array.isArray(track.segments) ? track.segments : []).map((segment) => ({
       ...segment, ranges: playerRanges(segment.mediaRanges, rescale(clocks[trackIndex], unit), unit)
-    })));
+    })), unit));
   const origin = latest(zero, ...segmentsOf.map((segments) =>
     segments.find(({ index }) => index === 0)?.ranges?.[0]?.start ?? zero));
   const at = latest(origin, rescale(fromSeconds(finiteNonNegative(input.positionSeconds)), unit));
@@ -182,7 +182,7 @@ export function predictPlaybackReadiness(input = {}) {
     curve: rateCurve(track.readings, now),
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
-    segments: predictedMediaSegments(segmentsOf[trackIndex], unit)
+    segments: segmentsOf[trackIndex]
       .filter((segment) => Number.isInteger(segment?.index) &&
         Number.isFinite(segment?.startSeconds) && Number.isFinite(segment?.endSeconds) &&
         segment.endSeconds > segment.startSeconds && segment.endSeconds > position)
@@ -192,19 +192,8 @@ export function predictPlaybackReadiness(input = {}) {
     return result(false, null, buffered, reserve, null, "timeline-unavailable", 0);
   }
   const sourceState = new Map();
-  const downloadServices = new Map();
   for (const [id, source] of sources) {
-    const serviceId = typeof source.serviceId === "string" ? source.serviceId : id;
-    const service = downloadServices.get(serviceId);
-    if (!service || (!service.curve && source.complete !== true)) {
-      downloadServices.set(serviceId, {
-        curve: source.complete === true ? null : rateCurve(source.readings, now)
-      });
-    }
-    sourceState.set(id, {
-      source,
-      serviceId
-    });
+    sourceState.set(id, { source });
   }
   const link = rateCurve(input.linkReadings, now);
   let unknownReason = null;
@@ -246,19 +235,28 @@ export function predictPlaybackReadiness(input = {}) {
           Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.end > range.start));
       const encodeWork = produced ? 0 : remainingProcessing.reduce((sum, part) => sum + part.end - part.start, 0);
 
-      const sourceIntervals = new Map();
+      const sourceByteIntervals = new Map();
       if (!produced && encodeWork > 0) {
-        for (const sourceId of Array.isArray(track.sourceIds) ? new Set(track.sourceIds) : []) {
+        const exactInputs = Array.isArray(segment.sourceInputs) ? segment.sourceInputs : null;
+        const requiredSources = new Set([
+          ...(Array.isArray(track.sourceIds) ? track.sourceIds : []),
+          ...(exactInputs ?? []).map(input => input?.sourceId)
+        ]);
+        for (const sourceId of requiredSources) {
           const source = sourceState.get(sourceId);
           if (!source) {
             unknownReason ??= "source-measurement-unavailable";
           } else if (source.source.complete !== true) {
-            const bytesPerMediaSecond = Number(source.source.bytesPerMediaSecond);
-            if (!(bytesPerMediaSecond > 0)) {
-              unknownReason ??= "download-rate-unavailable";
-            } else {
-              sourceIntervals.set(sourceId, remainingProcessing);
+            if (exactInputs) {
+              const inputs = exactInputs.filter(input => input?.sourceId === sourceId);
+              const ranges = inputs.flatMap(input => Array.isArray(input.ranges) ? input.ranges : []);
+              if (!ranges.length || inputs.some(input => !Array.isArray(input.ranges) || !input.ranges.length) ||
+                  ranges.some(range => !range || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start)) {
+                unknownReason ??= "source-input-ranges-unavailable";
+              } else sourceByteIntervals.set(sourceId, ranges);
+              continue;
             }
+            unknownReason ??= "source-input-ranges-unavailable";
           }
         }
       }
@@ -272,8 +270,7 @@ export function predictPlaybackReadiness(input = {}) {
         ahead: Math.max(0, segment.startSeconds - position),
         sizeBits,
         encodeWork,
-        remainingProcessing,
-        sourceIntervals,
+        sourceByteIntervals,
         produced
       });
     }
@@ -295,17 +292,20 @@ export function predictPlaybackReadiness(input = {}) {
   // scheduled in media order, independently of browser storage capacity.
   // The earliest legal start is the supremum of completion lateness against
   // presentation deadlines, not a search over guessed delay candidates.
-  const sourceFinish = new Map([...downloadServices.keys()].map((id) => [id, 0]));
-  const sourceMediaService = new Map();
+  const sourceByteService = new Map();
   for (const [id, { source }] of sourceState) {
-    const density = Number(source.bytesPerMediaSecond);
-    if (density > 0 && Array.isArray(source.residence)) {
-      // Initial time-to-byte mapping uses measured file-average density.
-      // Held bytes are not downloaded again. Reading costs are already
-      // included in effective processing speed, rather than charged twice.
-      sourceMediaService.set(id, source.residence.filter(({ location, start, end }) =>
-        location !== "missing" && Number.isFinite(start) && Number.isFinite(end) && end > start)
-        .map(({ start, end }) => ({ start: start / density, end: end / density, begin: 0, finish: 0 })));
+    sourceByteService.set(id, Array.isArray(source.residence) ? source.residence
+      .filter(({ location, start, end }) => location !== "missing" && Number.isFinite(start) && Number.isFinite(end) && end > start)
+      .map(({ start, end }) => ({ start, end, begin: 0, finish: 0 })) : []);
+    if (source.downloadForecast) {
+      for (const range of source.downloadForecast.ranges ?? []) {
+        if (!Number.isFinite(range?.availableAt) || !Number.isSafeInteger(range.start) ||
+          !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start) continue;
+        const arrival = Math.max(0, (range.availableAt - now) / 1000);
+        // The entire protocol piece becomes readable after verification;
+        // bytes inside it never arrive proportionally to their file address.
+        sourceByteService.get(id).push({ start: range.start, end: range.end, begin: arrival, finish: arrival });
+      }
     }
   }
   const trackFinish = trackState.map(({ track }) => finiteNonNegative(track.startupRemainingSeconds));
@@ -313,36 +313,23 @@ export function predictPlaybackReadiness(input = {}) {
   const completions = [];
   const productions = [];
   for (const job of jobs) {
-    const { track, trackIndex, segment, sizeBits, encodeWork, sourceIntervals, remainingProcessing } = job;
+    const { track, trackIndex, segment, sizeBits, encodeWork, sourceByteIntervals } = job;
     const sourceArrivals = [];
-    for (const [sourceId, interval] of [...sourceIntervals].flatMap(([id, ranges]) =>
-      ranges.map((range) => [id, range]))) {
-      const source = sourceState.get(sourceId);
-      const served = sourceMediaService.get(sourceId) ?? [];
-      for (const part of uncoveredIntervals(interval, served)) {
-        const supply = downloadServices.get(source.serviceId)?.curve;
-        if (!supply) return result(false, null, buffered, reserve, null, "download-rate-unavailable", preparedSegments);
-        const begin = sourceFinish.get(source.serviceId) ?? 0;
-        const end = supply.finish(
-          (part.end - part.start) * Number(source.source.bytesPerMediaSecond), begin);
-        sourceFinish.set(source.serviceId, end);
-        served.push({ ...part, begin, finish: end });
+    for (const [sourceId, ranges] of sourceByteIntervals) {
+      const served = sourceByteService.get(sourceId) ?? [];
+      for (const interval of ranges) {
+        if (uncoveredIntervals(interval, served).length) return result(false, null, buffered, reserve, null, "download-schedule-unavailable", preparedSegments);
+        for (const part of served.filter(part => part.end > interval.start && part.start < interval.end)) {
+          sourceArrivals.push({ at: part.finish });
+        }
       }
-      sourceMediaService.set(sourceId, served);
-      sourceArrivals.push(...served.filter((part) => part.end > interval.start && part.start < interval.end)
-        .flatMap((part) => [Math.max(part.start, interval.start), Math.min(part.end, interval.end)]
-          .map((media) => ({ media, at: media === part.start ? part.begin : part.begin +
-            (part.finish - part.begin) * (media - part.start) / (part.end - part.start) }))));
+      sourceByteService.set(sourceId, served);
     }
-    // Max-plus composition of fluid arrival and processing. Between measured
-    // boundaries both are linear, so their supremum occurs at an endpoint.
-    // Reused input keeps its original arrival times; it is neither downloaded
-    // twice nor charged the queue start of a later request.
+    // Production accepts a complete held segment input. It cannot overlap its
+    // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    const producedAt = job.produced || encodeWork === 0 ? 0 : Math.max(
-      processing.finish(encodeWork, trackFinish[trackIndex]),
-      ...sourceArrivals.map(({ media, at }) => processing.finish(
-        remainingProcessing.reduce((sum, part) => sum + Math.max(0, part.end - Math.max(part.start, media)), 0), at)));
+    const admittedAt = Math.max(trackFinish[trackIndex], ...sourceArrivals.map(({ at }) => at));
+    const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
     productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivals.some(({ at }) => at > 0) });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));

package/services/viewer/segment-demands.js

@@ -0,0 +1,37 @@
+/** Translate map demand to complete output intervals and selected source tracks. */
+export function segmentDemands(output, fileIndex, zones) {
+  const tracks = [];
+  for (const type of ["video", "audio"]) {
+    const spec = output.spec?.[type];
+    if (spec?.fileIndex !== fileIndex) continue;
+    tracks.push({ type, index: type === "video" ? 0 : spec.trackIndex,
+      mode: type === "video" ? spec.encode ? "transcode" : "copy" : spec.transcode ? "transcode" : "copy" });
+  }
+  if (!tracks.length) return [];
+  const grid = output.timeline?.published ?? output.timeline?.boundaries;
+  if (!Array.isArray(grid)) return [];
+  const demands = [];
+  for (let index = 0; index + 1 < grid.length; index++) {
+    const from = grid[index], to = grid[index + 1];
+    if (!Number.isFinite(from) || !Number.isFinite(to) || !(to > from)) throw new Error("An output segment needs a valid interval.");
+    const overlapping = zones.filter(zone => zone.priority > 0 && zone.from < to && zone.to > from);
+    if (!overlapping.length) continue;
+    const owner = overlapping.reduce((first, zone) => (zone.deadlineAt ?? Infinity) < (first.deadlineAt ?? Infinity) ? zone : first);
+    demands.push({ index, from, to, tracks, owner,
+      priority: Math.max(...overlapping.map(zone => zone.priority)),
+      urgent: overlapping.some(zone => zone.urgent),
+      behind: overlapping.every(zone => zone.behind),
+      deferred: overlapping.every(zone => zone.deferred),
+      deadlineAt: Math.min(...overlapping.map(zone => Number.isFinite(zone.deadlineAt) ? zone.deadlineAt : Infinity)) });
+  }
+  return demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
+}
+
+/** Source bytes must arrive before measured processing and delivery consume time. */
+export function sourceDeadline(demand, { encodeSpeed, outputBytes, linkMbps }) {
+  const span = demand.to - demand.from;
+  const processing = Number.isFinite(encodeSpeed) && encodeSpeed > 0 ? span / encodeSpeed : 0;
+  const delivery = Number.isFinite(outputBytes) && outputBytes > 0 && Number.isFinite(linkMbps) && linkMbps > 0
+    ? outputBytes * 8 / (linkMbps * 1_000_000) : 0;
+  return Number.isFinite(demand.deadlineAt) ? demand.deadlineAt - (processing + delivery) * 1000 : demand.deadlineAt;
+}

package/services/viewer/urgent-output-ready.js

@@ -0,0 +1,26 @@
+/** All outputs still consumed by this viewer must cover the urgent interval. */
+export function urgentOutputsReady({ sourceKey, fileIndex, durationSeconds, atSeconds, seconds,
+  outputs, consumed, segmentIndex, segmentStart, closed }) {
+  if (!Number.isFinite(durationSeconds) || !(durationSeconds > 0) ||
+      !Number.isFinite(atSeconds) || atSeconds < 0 ||
+      !Number.isFinite(seconds) || !(seconds > 0)) return false;
+  const target = Math.min(durationSeconds, atSeconds + seconds);
+  let found = false;
+  for (const output of outputs) {
+    if (output.file?.sourceKey !== sourceKey || output.file?.fileIndex !== fileIndex || !consumed(output)) continue;
+    found = true;
+    if (!output.timeline || !output.outputKey) return false;
+    let index = segmentIndex(output, atSeconds);
+    if (!Number.isSafeInteger(index) || index < 0) return false;
+    let start = segmentStart(output, index);
+    if (!Number.isFinite(start) || start > atSeconds) return false;
+    while (start < target) {
+      if (!closed(output.outputKey, index)) return false;
+      const next = segmentStart(output, index + 1);
+      if (!Number.isFinite(next) || !(next > start)) return false;
+      start = next;
+      index += 1;
+    }
+  }
+  return found;
+}

package/services/encode/run-inputs.js

@@ -1,53 +0,0 @@
-/**
- * @file The addresses an encoder reads its source from.
- *
- * Built per run from facts that belong elsewhere — which files the output
- * reads (`OutputSpec`), where the stream route listens, which output the read
- * feeds, and how wide its read window is — and kept nowhere.
- *
- * Two query parameters are what make the encoder's read what it is to the
- * stream route: `reader=playback`, the one read that says where the viewer is,
- * and `windowBytes`, how far ahead of itself that read asks the swarm for,
- * sized in seconds of playback by whoever knows the file's byte rate.
- */
-
-/** The query parameter naming which run of an output a read feeds. */
-const RUN_PARAMETER = "run";
-
-/**
- * @param {object} params
- * @param {{ fileIndex: number, streamUrl: (baseUrl: string, options?: { sessionId?: string }) => URL }} params.picture
- * @param {{ fileIndex: number, streamUrl: (baseUrl: string, options?: { sessionId?: string }) => URL }} params.soundtrack
- *   The file the carried soundtrack lives in; the picture's own file for an
- *   embedded track.
- * @param {"video-only" | "audio-only" | "muxed" | "empty"} params.carries
- * @param {boolean} params.audioSeparate - The picture's sound travels as its own output.
- * @param {string} params.sessionId - Which output this read feeds.
- * @param {number} [params.runToken] - Which run of that output the read feeds,
- *   so the time its input waits is charged to that run and not to another one
- *   working on the same output.
- * @param {number} params.readWindowBytes - Zero when no window was measured.
- * @param {string} params.baseUrl
- * @returns {{ inputFile: object, audioFile: object, inputUrl: string, audioInputUrl: string }}
- */
-export function encoderInputs({ picture, soundtrack, carries, audioSeparate, sessionId, runToken, readWindowBytes, baseUrl }) {
-  // A soundtrack shipped as its own file is encoded FROM that file, so a
-  // rendition of it reads nothing else.
-  const inputFile = carries === "audio-only" && soundtrack !== picture ? soundtrack : picture;
-  const input = inputFile.streamUrl(baseUrl, { sessionId });
-  const forRun = (url) => {
-    if (Number.isInteger(runToken)) url.searchParams.set(RUN_PARAMETER, String(runToken));
-    return url;
-  };
-  forRun(input);
-  if (Number.isFinite(readWindowBytes) && readWindowBytes > 0) {
-    input.searchParams.set("windowBytes", String(readWindowBytes));
-    input.searchParams.set("reader", "playback");
-  }
-  // The second input exists only for a picture that carries its sound inside
-  // itself when that sound is in another file.
-  const audioInputUrl = carries !== "audio-only" && !audioSeparate && soundtrack !== inputFile
-    ? forRun(soundtrack.streamUrl(baseUrl, { sessionId })).toString()
-    : "";
-  return { inputFile, audioFile: soundtrack, inputUrl: input.toString(), audioInputUrl };
-}

package/services/media/keyframe-probe.js

@@ -1,157 +0,0 @@
-/**
- * @file Where a file's keyframes are, found by DECODING it rather than by
- * reading what its container states.
- *
- * The SECOND reader of one fact, and the weaker of the two: the container's own
- * index is two point reads of 16 KB and names every keyframe, while this scans
- * the media over a torrent-backed input and on a large file often does not
- * finish — measured 2026-08-02, 77 keyframes in 45 s against all 570 in 0.8 s
- * from the index. So it is never waited for and never displaces an index that
- * answered; `KeyframeTable.learn` keeps the fuller answer whichever arrives
- * second.
- *
- * It exists because some containers state no index at all, and a keyframe is
- * still needed for something both encode branches need: choosing a SOURCE seek
- * position ffmpeg can land on. `-ss` before `-i` trusts the container's
- * on-the-fly seek, which for some containers (observed: AVI with VBR MP3 audio)
- * can point at a position with no valid frame boundary at all — ffmpeg then
- * fails outright ("Seek failed" / "Header missing"), not merely imprecisely.
- *
- * **Why it is here and not in `container/`.** It runs a process and reads the
- * file over the address this proxy serves it at. A container is built from four
- * functions and takes byte ranges; it spawns nothing and knows no URL. Both are
- * readings of the same file, so both are this layer's — and they are separate
- * files because one of them needs a machine and the other needs sixteen
- * kilobytes.
- */
-
-import { spawn } from "node:child_process";
-
-/**
- * The ffprobe that sits beside a given ffmpeg.
- *
- * @param {string} ffmpegBin
- * @returns {string}
- */
-export function ffprobeBinFor(ffmpegBin) {
-  if (typeof ffmpegBin !== "string" || ffmpegBin.length === 0) {
-    return "ffprobe";
-  }
-  if (/ffmpeg(\.exe)?$/i.test(ffmpegBin)) {
-    return ffmpegBin.replace(/ffmpeg(\.exe)?$/i, "ffprobe$1");
-  }
-  return "ffprobe";
-}
-
-/**
- * Where this file's keyframes are, found by DECODING it rather than by reading
- * what its container states.
- *
- * The second reader of one fact, and the weaker of the two: the container's own
- * index is two point reads of 16 KB and names every keyframe, while this scans
- * the media over a torrent-backed input and on a large file often does not
- * finish — measured 2026-08-02, 77 keyframes in 45 s against all 570 in 0.8 s
- * from the index. So it is never waited for and never displaces an index that
- * answered; `KeyframeTable.learn` keeps the fuller answer whichever arrives
- * second.
- *
- * It exists because some containers state no index at all, and a keyframe is
- * still needed for something both branches need: choosing a SOURCE seek
- * position ffmpeg can land on. `-ss` before `-i` trusts the container's
- * on-the-fly seek, which for some containers (observed: AVI with VBR MP3 audio)
- * can point at a position with no valid frame boundary at all — ffmpeg then
- * fails outright ("Seek failed" / "Header missing"), not merely imprecisely.
- *
- * It lives here, beside the codec probe, because it is the same kind of thing:
- * a reading of the file made by running ffmpeg's own tools over the address
- * this proxy serves it at. The container layer takes byte ranges and spawns
- * nothing.
- *
- * @param {string} ffmpegBin
- * @param {string | URL} inputUrl
- * @param {number} [timeoutMs]
- * @returns {Promise<number[] | null>} Sorted keyframe times, or null.
- */
-export async function probeVideoKeyframeTimes(ffmpegBin, inputUrl, timeoutMs = 25_000) {
-  return new Promise((resolve) => {
-    let proc;
-    try {
-      proc = spawn(
-        ffprobeBinFor(ffmpegBin),
-        [
-          "-v", "error",
-          // `-skip_frame nokey` makes the decoder discard non-keyframes, so the
-          // probe reads only what it needs. Without it a full packet scan of a
-          // ~5 GB MKV cannot finish inside any sane budget over a torrent-backed
-          // input, the probe returns nothing, and the playlist falls back to a
-          // uniform grid — which on the COPY path is a lie: cuts land on the
-          // source's real keyframes, not on a 4 s ruler. The player then finds
-          // the declared times do not match the media, stops trusting the
-          // playlist and walks the file from segment #1 to locate the seek
-          // position by hand (field 2026-08-02: a seek to 1:30 produced requests
-          // #1, #2, #45, #86, #123 … #1187, taking minutes and never arriving).
-          "-skip_frame", "nokey",
-          "-select_streams", "v:0",
-          "-show_entries", "packet=pts_time,flags",
-          "-of", "csv=p=0",
-          String(inputUrl)
-        ],
-        { stdio: ["ignore", "pipe", "ignore"], windowsHide: true }
-      );
-    } catch {
-      resolve(null);
-      return;
-    }
-    let stdout = "";
-    let settled = false;
-    const finish = (value) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      resolve(value);
-    };
-    const timer = setTimeout(() => {
-      try {
-        if (!proc.killed) {
-          proc.kill("SIGTERM");
-        }
-      } catch {
-        // ignore
-      }
-      finish(null);
-    }, timeoutMs);
-    proc.stdout.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    proc.on("error", () => {
-      clearTimeout(timer);
-      finish(null);
-    });
-    proc.on("exit", (code) => {
-      clearTimeout(timer);
-      if (code !== 0) {
-        finish(null);
-        return;
-      }
-      const times = [];
-      for (const line of stdout.split("\n")) {
-        // Each line: "<pts_time>,<flags>" e.g. "12.345000,K__"
-        const comma = line.indexOf(",");
-        if (comma < 0) {
-          continue;
-        }
-        const flags = line.slice(comma + 1);
-        if (!flags.includes("K")) {
-          continue;
-        }
-        const t = Number(line.slice(0, comma));
-        if (Number.isFinite(t)) {
-          times.push(t);
-        }
-      }
-      times.sort((a, b) => a - b);
-      finish(times.length > 0 ? times : null);
-    });
-  });
-}

package/services/media/media-info-probe.js

@@ -1,93 +0,0 @@
-/**
- * @file What a stream's own header says: duration, picture size, frame rate,
- * start time, stream counts and HDR — from one short ffmpeg run that stops as
- * soon as the header has been printed.
- */
-
-import { spawn } from "node:child_process";
-import {
-  parseFfmpegBitrateKbps,
-  parseFfmpegDurationSeconds,
-  parseFfmpegHdr,
-  parseFfmpegStartTimeSeconds,
-  parseFfmpegStreamCounts,
-  parseFfmpegVideoDimensions,
-  parseFfmpegVideoFps
-} from "./ffmpeg-banner.js";
-
-/**
- * Run a short ffmpeg probe to extract the total duration AND video resolution
- * of a stream from the container header. Both are printed almost immediately
- * (before any decoding), so this returns as soon as they are seen; an 8 s
- * timeout guards the rest.
- *
- * @param {string} ffmpegBin - Path to the ffmpeg executable.
- * @param {string | URL} inputUrl - URL of the stream to probe.
- * @returns {Promise<{ durationSeconds: number | null, width: number | null, height: number | null, fps: number | null, startTime: number, isHdr: boolean }>}
- */
-export async function probeInputMediaInfo(ffmpegBin, inputUrl) {
-  return new Promise((resolve) => {
-    const ffmpeg = spawn(ffmpegBin, ["-hide_banner", "-loglevel", "info", "-i", inputUrl, "-f", "null", "-"], {
-      stdio: ["ignore", "ignore", "pipe"],
-      windowsHide: true
-    });
-    let stderr = "";
-    let settled = false;
-    const finish = () => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      const dims = parseFfmpegVideoDimensions(stderr);
-      resolve({
-        durationSeconds: parseFfmpegDurationSeconds(stderr),
-        bitrateKbps: parseFfmpegBitrateKbps(stderr),
-        width: dims.width,
-        height: dims.height,
-        fps: parseFfmpegVideoFps(stderr),
-        startTime: parseFfmpegStartTimeSeconds(stderr),
-        // Only ever read when a run fails, and read HERE because by then the
-        // banner is long gone: this probe is the one place the source says what
-        // it holds.
-        streamCounts: parseFfmpegStreamCounts(stderr),
-        isHdr: parseFfmpegHdr(stderr)
-      });
-    };
-    const timeoutId = setTimeout(() => {
-      if (!ffmpeg.killed) {
-        ffmpeg.kill("SIGTERM");
-      }
-      finish();
-    }, 8_000);
-    ffmpeg.stderr.on("data", (chunk) => {
-      stderr += String(chunk);
-      // The header ("Duration:" then the "Video: … WxH" stream line) is printed
-      // before any decoding. Bail as soon as both are present instead of letting
-      // `-f null -` decode the whole stream until the 8 s timeout.
-      //
-      // This probe asks about the PICTURE and nothing else now: a file with no
-      // video track is read by the container layer, which answers from 64 KB of
-      // header. It used to take an `expectVideo: false` for exactly that case,
-      // and the branch cost 8121 ms of every cold start (2026-09-03) because
-      // the exit still waited for a parsed DURATION, which a partly downloaded
-      // file prints as `N/A`.
-      const duration = parseFfmpegDurationSeconds(stderr);
-      const dims = parseFfmpegVideoDimensions(stderr);
-      if (duration != null && dims.width != null) {
-        clearTimeout(timeoutId);
-        if (!ffmpeg.killed) {
-          ffmpeg.kill("SIGTERM");
-        }
-        finish();
-      }
-    });
-    ffmpeg.on("error", () => {
-      clearTimeout(timeoutId);
-      finish();
-    });
-    ffmpeg.on("exit", () => {
-      clearTimeout(timeoutId);
-      finish();
-    });
-  });
-}