@torrent-tv/proxy 2.91.0 → 2.92.1

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();
-    });
-  });
-}

package/services/torrent/worker/background-fill.js

@@ -1,213 +0,0 @@
-/**
- * Fetch a whole file that nobody is playing yet, using only the room the viewer
- * is not using.
- *
- * WHAT IT IS FOR. A release ships its dub and its subtitles as separate files,
- * and a viewer who switches to one waits for the swarm to deliver its first
- * pieces — 27.7 s in the field on 2026-08-31, which is longer than the switch is
- * willing to wait. These files are small beside the picture (30 MB against 566
- * MB, about a twentieth), so having them on disk before anyone asks turns every
- * later switch into a local read.
- *
- * THE ORDERING, WHICH IS THE WHOLE DESIGN. What plays now comes first: the
- * picture at the playhead, the soundtrack being heard, the subtitles being
- * shown. The other soundtracks and subtitle files come next. Reading the film
- * far ahead comes last. This module implements the middle tier, and it stays
- * below the first by a condition that is measured rather than chosen: it fetches
- * only while NO reader on the torrent is inside a wait. A reader blocked on a
- * piece is the viewer's own reading starving, and that is exactly the moment
- * this must not be asking the swarm for anything.
- *
- * WHY IT IS A READ AND NOT A SELECTION. `file.select()` claims every piece of a
- * file at once. `#syncSelections` in `torrent/torrent-pool.js` records what that cost
- * when it was done alongside the readers' own moving windows: a claim covering
- * everything always outranked the window, and a seek to 89.1 % of a 4.7 GB film
- * waited 93 s while the swarm fetched 2.47 GB in file order. So this walks the
- * file a piece at a time through an ordinary bounded read, which claims what it
- * is reading and gives it back.
- */
-
-import { logger } from "../../../utils/logger.js";
-import { readersAreBlockedOn, stallsSeenOn } from "./piece-reader.js";
-
-/**
- * How long to stand aside after finding the viewer's own reading blocked.
- *
- * Not a measurement of anything: it is how often the question "is the viewer
- * still starving?" is asked, and it is answered by the reader count, which is
- * exact. Short enough that room is used soon after it appears, long enough that
- * asking costs nothing.
- */
-const STAND_ASIDE_MS = 1_000;
-
-/** Files being filled, by `sourceKey:fileIndex`, so one runs per file. */
-const running = new Map();
-
-/**
- * @param {number} ms
- * @returns {Promise<void>}
- */
-function pause(ms) {
-  return new Promise((resolve) => {
-    const timer = setTimeout(resolve, ms);
-    timer.unref?.();
-  });
-}
-
-/**
- * Read one byte range, letting the torrent fetch what is missing.
- *
- * @param {object} file
- * @param {number} start
- * @param {number} end - Inclusive.
- * @returns {Promise<number>} Bytes read; 0 on failure.
- */
-function readRange(file, start, end) {
-  return new Promise((resolve) => {
-    let stream;
-    try {
-      stream = file.createReadStream({ start, end });
-    } catch {
-      resolve(0);
-      return;
-    }
-    let bytes = 0;
-    let settled = false;
-    const settle = (value) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      resolve(value);
-    };
-    stream.on("data", (chunk) => {
-      bytes += chunk.length;
-    });
-    stream.on("end", () => settle(bytes));
-    stream.on("error", () => {
-      stream.destroy?.();
-      settle(0);
-    });
-  });
-}
-
-/**
- * Fetch a file whole, in the room the viewer leaves.
- *
- * Returns as soon as the work is under way; the caller is not waiting for it.
- * One fill per file — a second request while one is running is ignored rather
- * than doubling the reads.
- *
- * @param {object} torrent
- * @param {number} fileIndex
- * @param {string} sourceKey
- * @param {{ chunkBytes?: number, isBlocked?: (infoHash: string) => boolean, stallsSeen?: (infoHash: string) => number }} [options]
- *   `isBlocked` answers "is the viewer's own reading starving right now"; it is
- *   the tier boundary, and it is a parameter so it can be exercised without a
- *   swarm.
- * @returns {boolean} Whether a fill was started by this call.
- */
-export function fillFileInBackground(torrent, fileIndex, sourceKey, options = {}) {
-  const key = `${sourceKey}:${fileIndex}`;
-  if (running.has(key)) {
-    return false;
-  }
-  const file = torrent?.files?.[fileIndex];
-  if (!file || !Number.isFinite(file.length) || file.length <= 0) {
-    return false;
-  }
-  // One piece at a time: the smallest unit the swarm actually delivers, so the
-  // gap between two checks of "is the viewer starving?" is as short as it can
-  // usefully be.
-  const chunkBytes = Number.isFinite(options.chunkBytes) && options.chunkBytes > 0
-    ? options.chunkBytes
-    : (Number(torrent?.pieceLength) || 4 * 1024 * 1024);
-  const isBlocked = typeof options.isBlocked === "function" ? options.isBlocked : readersAreBlockedOn;
-  const stallsSeen = typeof options.stallsSeen === "function" ? options.stallsSeen : stallsSeenOn;
-  const work = fill(torrent, file, fileIndex, chunkBytes, isBlocked, stallsSeen).finally(() => {
-    running.delete(key);
-  });
-  running.set(key, work);
-  return true;
-}
-
-/**
- * @param {object} torrent
- * @param {object} file
- * @param {number} fileIndex
- * @param {number} chunkBytes
- * @param {(infoHash: string) => boolean} isBlocked
- * @param {(infoHash: string) => number} stallsSeen
- * @returns {Promise<void>}
- */
-async function fill(torrent, file, fileIndex, chunkBytes, isBlocked, stallsSeen) {
-  const startedAt = Date.now();
-  const infoHash = String(torrent?.infoHash ?? "");
-  let read = 0;
-  let stoodAsideMs = 0;
-  // The stall count this fill last saw. A chunk is fetched only when it has not
-  // moved since the previous one.
-  let quietSince = stallsSeen(infoHash);
-  logger.info(
-    `background-fill: "${String(file.name).slice(0, 40)}" (${(file.length / 1e6).toFixed(1)}MB) will be ` +
-      "fetched whole while the viewer's own reading leaves room"
-  );
-  for (let start = 0; start < file.length; start += chunkBytes) {
-    // Stand aside while anything the viewer is watching is waiting on the
-    // swarm — AND for as long after it as it takes for a quiet stretch to
-    // pass. Pausing only DURING a stall is not enough: on a swarm delivering
-    // exactly what the film needs, this still takes bandwidth between stalls,
-    // and the stalls themselves are the proof there was none to spare. Field
-    // 2026-08-31, the case that forced this: 200-600 KB/s delivered against
-    // the 399 KB/s the film eats, one piece waited 101 s, and the picture
-    // stood still 145.6 s.
-    //
-    // "A quiet stretch" is measured, not chosen: the stall counter must not
-    // have moved while the previous chunk was being fetched. On a starving
-    // swarm it moves constantly and this stops altogether, which is the right
-    // answer — there is no spare room to use.
-    while (isBlocked(infoHash) || stallsSeen(infoHash) !== quietSince) {
-      stoodAsideMs += STAND_ASIDE_MS;
-      await pause(STAND_ASIDE_MS);
-      // Re-baselined after the pause, so a stretch that passes without a new
-      // stall lets the fill go on. Without this it could never resume.
-      quietSince = stallsSeen(infoHash);
-    }
-    // The torrent may have been destroyed under us — a viewer who left, the
-    // disk sweep, a restart. Reading a destroyed file throws, and there is
-    // nothing here worth an error.
-    if (!torrent?.files?.[fileIndex]) {
-      return;
-    }
-    // Taken BEFORE the read, and deliberately not refreshed after it: a stall
-    // that happens while this chunk is in flight must still be visible to the
-    // next iteration. Refreshing afterwards erased exactly that evidence, which
-    // is the defect a test caught here.
-    quietSince = stallsSeen(infoHash);
-    const bytes = await readRange(file, start, Math.min(start + chunkBytes, file.length) - 1);
-    if (bytes === 0) {
-      logger.info(
-        `background-fill: "${String(file.name).slice(0, 40)}" stopped at ` +
-          `${(start / 1e6).toFixed(1)}MB — the read returned nothing`
-      );
-      return;
-    }
-    read += bytes;
-  }
-  logger.info(
-    `background-fill: "${String(file.name).slice(0, 40)}" is on disk — ${(read / 1e6).toFixed(1)}MB in ` +
-      `${((Date.now() - startedAt) / 1000).toFixed(0)}s, of which ${(stoodAsideMs / 1000).toFixed(0)}s ` +
-      "was spent standing aside for the viewer; a switch to it will not wait for the swarm"
-  );
-}
-
-/**
- * Whether a file is being filled right now. For tests and for the log.
- *
- * @param {string} sourceKey
- * @param {number} fileIndex
- * @returns {boolean}
- */
-export function fillIsRunning(sourceKey, fileIndex) {
-  return running.has(`${sourceKey}:${fileIndex}`);
-}