@torrent-tv/proxy 2.86.0 → 2.87.0

package/services/encode/quality/serving-output.js

@@ -0,0 +1,216 @@
+/**
+ * @file Which output already on this proxy serves a viewer, instead of a new
+ * encode of the format they would otherwise be given.
+ *
+ * Decided with the user 2026-09-16, and made one rule for every path on
+ * 2026-09-23 (roadmap item 97, step 11). Quality is compared by the number of
+ * points in the picture. An output qualifies only if the piece at the viewer's
+ * position is already made — material somewhere else in the film spares them
+ * nothing — AND the viewer's own link admits its load (`link-budget.js`), in
+ * every mode and on every branch. A load whose figure is a bound (`known`) is
+ * taken before one whose figure is an average (`estimated`), whatever their
+ * sizes; an `unknown` load is admitted only while nothing has measured the
+ * link.
+ *
+ * AUTOMATIC:
+ * 1. at least the quality wanted — the nearest to it;
+ * 2. below the quality wanted but above the next rung down of this viewer's
+ *    own ladder — the largest of those;
+ * 3. lower still only when producing the wanted format here risks the viewer
+ *    waiting: this machine does not hold it at the speed the file needs — the
+ *    largest of those.
+ *
+ * CHOSEN BY HAND: exactly the size chosen — of those, the one with the highest
+ * bitrate the link admits. Which encoder made it and at which speed setting do
+ * not matter to the viewer.
+ *
+ * No reading of disk or machine here: every figure arrives as a plain value.
+ */
+
+import { OutputSpec } from "../output/OutputSpec.js";
+import { admissionRank } from "./link-budget.js";
+
+/**
+ * @typedef {object} Candidate
+ * @property {string} key - The output's key.
+ * @property {OutputSpec} spec
+ * @property {number} width
+ * @property {number} height
+ * @property {boolean} readyHere - The piece at the viewer's position is made.
+ */
+
+/**
+ * @param {object} params
+ * @param {"auto" | "manual"} params.mode
+ * @param {{ width: number, height: number }} params.wanted - The format this
+ *   viewer would otherwise be given.
+ * @param {number} params.nextLowerArea - Points in the next rung below `wanted`
+ *   on this viewer's own ladder; zero when there is none.
+ * @param {boolean} params.atRisk - Producing `wanted` here is measured not to
+ *   keep up with what the file needs. False where nothing measured it.
+ * @param {(candidate: Candidate) => { admitted: boolean, load: object }} params.judge -
+ *   What this viewer's link does with the candidate's whole load.
+ * @param {Candidate[]} params.candidates
+ * @returns {{ key: string, answer: object } | null} The output to serve, or
+ *   null to produce `wanted`.
+ */
+export function chooseServingOutput({ mode, wanted, nextLowerArea, atRisk, judge, candidates }) {
+  const admitted = (candidates ?? [])
+    .filter((candidate) => candidate.readyHere === true)
+    .map((candidate) => ({ candidate, answer: judge(candidate) }))
+    .filter((one) => one.answer.admitted);
+  const areaOf = (one) => one.candidate.width * one.candidate.height;
+  const rateOf = (one) => one.answer.load.totalMbps ?? 0;
+  const byRank = (left, right) => admissionRank(right.answer) - admissionRank(left.answer);
+  const pick = (list) => (list.length > 0 ? { key: list[0].candidate.key, answer: list[0].answer } : null);
+  if (mode === "manual") {
+    return pick(
+      admitted
+        .filter((one) => one.candidate.width === wanted.width && one.candidate.height === wanted.height)
+        .sort((left, right) => byRank(left, right) || rateOf(right) - rateOf(left))
+    );
+  }
+  const wantedArea = wanted.width * wanted.height;
+  const atLeast = admitted
+    .filter((one) => areaOf(one) >= wantedArea)
+    .sort((left, right) => byRank(left, right) || areaOf(left) - areaOf(right) || rateOf(right) - rateOf(left));
+  if (atLeast.length > 0) {
+    return pick(atLeast);
+  }
+  const below = admitted
+    .filter((one) => areaOf(one) < wantedArea)
+    .sort((left, right) => byRank(left, right) || areaOf(right) - areaOf(left) || rateOf(right) - rateOf(left));
+  const close = below.filter((one) => areaOf(one) > nextLowerArea);
+  if (close.length > 0) {
+    return pick(close);
+  }
+  return atRisk ? pick(below) : null;
+}
+
+/**
+ * Points in the next rung below a height on a viewer's own ladder.
+ *
+ * @param {{ width: number, height: number }[]} ladder - High to low.
+ * @param {number} height
+ * @returns {number} Zero when nothing on the ladder is lower.
+ */
+export function nextRungAreaBelow(ladder, height) {
+  const next = (ladder ?? []).find((rung) => rung.height < height);
+  return next ? next.width * next.height : 0;
+}
+
+/**
+ * The outputs that could stand in for `wanted`, read from their keys.
+ *
+ * One qualifies when it is the same picture of the same file in every respect
+ * but its quality: the same torrent, container, cut grid, soundtrack and what
+ * the output carries. A re-encode qualifies only if this machine's encoder
+ * made it, because serving it means going on producing it, and pieces of
+ * another encoder cannot share its header. A copy is the source's own picture.
+ *
+ * @param {object} params
+ * @param {OutputSpec} params.wanted
+ * @param {Iterable<string>} params.keys - Every output this proxy holds, live
+ *   or only on disk. Repeats are fine.
+ * @param {{ width: number, height: number, megabitsPerSecond: number | null }} params.source
+ * @param {string} params.encoderName
+ * @param {(key: string) => boolean} params.readyAt - The piece at the viewer's
+ *   position is made.
+ * @returns {Candidate[]}
+ */
+/**
+ * Whether two outputs are of the same MATERIAL — the same film, the same
+ * container, the same cuts, the same tracks — and therefore interchangeable as
+ * far as anything but picture size is concerned.
+ *
+ * Stated once and exported, because two places ask it: choosing an output by
+ * quality, and answering which output serves a height. A step of a picture is
+ * only a step of THAT picture if this holds; a 720p step in fMP4 handed to a
+ * picture cut for MPEG-TS is a segment name its player cannot even ask for.
+ *
+ * Picture SIZE is deliberately not in it: differing in size is what a step is.
+ *
+ * @param {OutputSpec} spec
+ * @param {OutputSpec} wanted
+ * @returns {boolean}
+ */
+export function isSameMaterial(spec, wanted) {
+  if (!spec || !wanted || !spec.video || !wanted.video) {
+    return false;
+  }
+  return (
+    spec.sourceKey === wanted.sourceKey &&
+    spec.segmentFormatId === wanted.segmentFormatId &&
+    spec.grid.toKey() === wanted.grid.toKey() &&
+    spec.carries === wanted.carries &&
+    spec.video.fileIndex === wanted.video.fileIndex &&
+    (spec.audio?.toKey() ?? "") === (wanted.audio?.toKey() ?? "")
+  );
+}
+
+export function servingCandidates({ wanted, keys, source, encoderName, readyAt }) {
+  const found = new Map();
+  for (const key of keys ?? []) {
+    if (found.has(key)) {
+      continue;
+    }
+    const spec = OutputSpec.fromKey(key);
+    if (!spec || !spec.video || !wanted.video) {
+      continue;
+    }
+    if (!isSameMaterial(spec, wanted)) {
+      continue;
+    }
+    const encode = spec.video.encode;
+    if (encode && encode.encoder !== encoderName) {
+      continue;
+    }
+    const width = encode ? encode.width : source.width;
+    const height = encode ? encode.height : source.height;
+    if (!(width > 0 && height > 0)) {
+      continue;
+    }
+    found.set(key, {
+      key,
+      spec,
+      width,
+      height,
+      readyHere: readyAt(key)
+    });
+  }
+  return [...found.values()];
+}
+
+/**
+ * Whether ONE output may serve this viewer: the same material as the picture
+ * it would stand in for, the size their mode requires, and a load their own
+ * link admits.
+ *
+ * THE ONE RULE EVERY PATH ASKS (roadmap item 97, step 11). The picture
+ * answering for its own height, an output found already producing a height,
+ * and the choice among outputs already here used to decide each for itself,
+ * and only the last asked about the viewer at all.
+ *
+ * @param {object} params
+ * @param {OutputSpec} params.spec - The output that would serve.
+ * @param {OutputSpec} params.pictureSpec - The picture it would stand in for.
+ * @param {"auto" | "manual"} params.mode
+ * @param {{ width: number, height: number } | null} params.size - The size the
+ *   output produces; for a copy, the source's.
+ * @param {{ width: number, height: number } | null} params.wanted - The size a
+ *   viewer who picked by hand must get exactly; ignored in AUTO.
+ * @param {(spec: OutputSpec) => { admitted: boolean }} params.judge
+ * @returns {{ suits: boolean, answer: object | null, reason: string }}
+ */
+export function outputSuits({ spec, pictureSpec, mode, size, wanted, judge }) {
+  if (!isSameMaterial(spec, pictureSpec)) {
+    return { suits: false, answer: null, reason: "another material" };
+  }
+  if (mode === "manual" && wanted && size && (size.width !== wanted.width || size.height !== wanted.height)) {
+    return { suits: false, answer: null, reason: "not the size picked" };
+  }
+  const answer = judge(spec);
+  return answer.admitted
+    ? { suits: true, answer, reason: answer.verdict }
+    : { suits: false, answer, reason: answer.verdict };
+}

package/services/encode/quality/visible-rung.js

@@ -0,0 +1,57 @@
+/**
+ * @file Which rung of the ladder the picture a viewer sees asks for (roadmap
+ * item 98).
+ *
+ * THE RULE, stated by the user 2026-09-27: the smallest height of the ladder
+ * whose frame is not smaller than the visible picture — both its width and its
+ * height. The visible picture is what the viewer's page measured: the frame
+ * that would be shown without being enlarged, in physical pixels
+ * (`server/public/domain/visible-picture.js`). A frame smaller than that is
+ * enlarged on screen and loses detail; a larger one costs encoder and link for
+ * detail the screen cannot show.
+ *
+ * When no rung is large enough — a picture shown bigger than the source — the
+ * answer is the top rung, the source's own size: nothing is ever made larger
+ * than the source.
+ *
+ * It bounds only a RE-ENCODED picture. A copy of the source is not re-encoded
+ * because it is taller than the picture on screen; it is re-encoded only when
+ * the browser cannot play it or the viewer's link cannot carry it (the rule is
+ * in "Key decisions" of the project notes).
+ */
+
+import { buildResolutionLadder } from "../hwaccel.js";
+
+/**
+ * The rung of `ladder` the visible picture asks for.
+ *
+ * @param {Array<{ width: number, height: number }>} ladder - Highest first, as
+ *   `buildResolutionLadder` gives it.
+ * @param {{ width: number, height: number } | null} visible
+ * @returns {{ width: number, height: number } | null} Null when nothing was
+ *   measured or there is no ladder.
+ */
+export function rungForVisiblePicture(ladder, visible) {
+  if (!Array.isArray(ladder) || ladder.length === 0 || !(visible?.width > 0) || !(visible?.height > 0)) {
+    return null;
+  }
+  const large = ladder.filter((rung) => rung.width >= visible.width && rung.height >= visible.height);
+  return large.length > 0 ? large[large.length - 1] : ladder[0];
+}
+
+/**
+ * The height a re-encoded picture of this source is bounded by for a viewer
+ * who sees `visible`, or null when nothing bounds it.
+ *
+ * @param {number} sourceWidth
+ * @param {number} sourceHeight
+ * @param {{ width: number, height: number } | null} visible
+ * @returns {number | null}
+ */
+export function visibleHeightCap(sourceWidth, sourceHeight, visible) {
+  const rung = rungForVisiblePicture(
+    buildResolutionLadder(Math.round(Number(sourceWidth) || 0), Math.round(Number(sourceHeight) || 0)),
+    visible
+  );
+  return rung ? rung.height : null;
+}

package/services/encode/run-command.js

@@ -15,8 +15,8 @@
  * killing and resuming belong to whoever owns the process.
  */
 
-/** The name ffmpeg writes its own playlist to, and the name that is served. */
-export const PLAYLIST_FILE_NAME = "index.m3u8";
+import { PLAYLIST_FILE_NAME } from "./output/playlists.js";
+import { AUDIO_TRANSCODE_KBPS } from "./args.js";
 
 /**
  * What ffmpeg's own CLI subtracts from an input seek, and therefore what has to
@@ -223,7 +223,7 @@ export function nearestKeyframeAtOrBefore(keyframeTimes, target) {
  * the bound picks the smaller error, which is then under one keyframe interval
  * and therefore under what a player bridges.
  *
- * @param {{ transcodeVideo?: boolean, file?: { keyframeTimes?: number[], keyframeTolerance?: number } }} material
+ * @param {{ transcodeVideo?: boolean, audioOnly?: boolean, keyframes?: { times?: number[] | null, tolerance?: number } }} material
  * @param {number} keyframe - A real keyframe time the run is to begin at.
  * @returns {number} Seconds to add to the request.
  */
@@ -246,11 +246,11 @@ export function seekLandingOffsetFor(material, keyframe) {
   // A grid whose times are approximate needs that error added on top, or a name
   // sitting just below its real keyframe seeks to before it and lands on the
   // one before that. Only AVI declares one.
-  const tolerance = Number.isFinite(material?.file?.keyframeTolerance)
-    ? Math.max(0, material.file.keyframeTolerance)
+  const tolerance = Number.isFinite(material?.keyframes?.tolerance)
+    ? Math.max(0, material.keyframes.tolerance)
     : 0;
   const wanted = SEEK_LANDING_OFFSET_SEC + tolerance;
-  const times = Array.isArray(material?.file?.keyframeTimes) ? material.file.keyframeTimes : [];
+  const times = Array.isArray(material?.keyframes?.times) ? material.keyframes.times : [];
   const next = times.find((time) => time > keyframe + 0.001);
   if (next === undefined) {
     return wanted;
@@ -262,8 +262,9 @@ export function seekLandingOffsetFor(material, keyframe) {
  * Everything ffmpeg is told for one run.
  *
  * @param {object} params
- * @param {{ keyframeTimes?: number[], keyframeTolerance?: number }} params.file - The
- *   PICTURE's file: whose keyframes a seek snaps to.
+ * @param {{ times?: number[] | null, tolerance?: number }} params.keyframes - Where
+ *   the PICTURE's file has its keyframes: what a seek snaps to. Plain values,
+ *   so this can be asked without a container, a torrent or a session.
  * @param {{ startTime: number }} params.inputFile - The file this run reads.
  * @param {{ startTime: number }} params.audioFile - The file the chosen
  *   soundtrack lives in, which for a dub shipped beside the picture is not the
@@ -280,7 +281,8 @@ export function seekLandingOffsetFor(material, keyframe) {
  * @param {boolean} params.audioSeparate - The picture's sound is published as a
  *   rendition, so this output carries none.
  * @param {number} params.audioSourceTrackIndex - `0:a:N` within its own file.
- * @param {number | null} params.rateCapKbps
+ * @param {{ maxrateKbps: number, bufsizeKbps: number, level: string | null } | null} params.rateControl
+ *   The output's own, as its key names it; null where nothing bounds the rate.
  * @param {number} params.startIndex - First segment number this run makes.
  * @param {number} params.endIndex - Last it makes, inclusive; below the start
  *   means it has no end.
@@ -291,7 +293,7 @@ export function seekLandingOffsetFor(material, keyframe) {
  * @returns {{ args: string[], safeIndex: number, startSeconds: number, cutTimes: number[] | null }}
  */
 export function buildRunCommand({
-  file,
+  keyframes,
   inputFile,
   audioFile,
   inputUrl,
@@ -304,7 +306,7 @@ export function buildRunCommand({
   audioOnly,
   audioSeparate,
   audioSourceTrackIndex,
-  rateCapKbps,
+  rateControl,
   startIndex,
   endIndex,
   positionSecondsOverride,
@@ -340,8 +342,8 @@ export function buildRunCommand({
   // Fresh by construction: the session may have been created before the
   // soundtrack file's header could be read, and the reading lands on the file
   // object this session holds — so there is nothing to re-read and nothing
-  // that can be stale. Same property as `file.keyframeTimes`,
-  // which is one table shared by every session of the file.
+  // that can be stale. Same property as the keyframe table, which is one
+  // object shared by every session of the file.
   // Which timeline this run works on. Asked once, because the closure that
   // adds the second input reads it too, and two readings of one predicate is
   // how the picture and the sound came apart before.
@@ -420,13 +422,14 @@ export function buildRunCommand({
         // count can describe them: the encoder is told the times outright,
         // the same ones the muxer will cut at.
         forcedKeyframeTimes: cutTimes,
-        // A ceiling the VIEWER's measured link put on this picture, when one
-        // has been measured. Null means the rung's own nominal rate stands.
-        nominalKbps: rateCapKbps ?? null
+        // The output's own rate control and level. Read off the output, whose
+        // key names them: two limits are two outputs, and nothing moves a
+        // limit under an output that already exists.
+        rateControl: rateControl ?? null
       })
     : ["-c:v", "copy"];
   const audioCodecArgs = transcodeAudio
-    ? ["-c:a", "aac", "-ac", "2", "-b:a", "128k"]
+    ? ["-c:a", "aac", "-ac", "2", "-b:a", `${AUDIO_TRANSCODE_KBPS}k`]
     : ["-c:a", "copy"];
 
   const args = ["-hide_banner", "-nostats", "-loglevel", "error", "-progress", "pipe:1"];
@@ -478,8 +481,8 @@ export function buildRunCommand({
     : null;
   const snappedKeyframe = Number.isFinite(carriedKeyframe)
     ? carriedKeyframe
-    : (Array.isArray(file.keyframeTimes) && file.keyframeTimes.length > 0
-      ? nearestKeyframeAtOrBefore(file.keyframeTimes, seekSeconds)
+    : (Array.isArray(keyframes?.times) && keyframes.times.length > 0
+      ? nearestKeyframeAtOrBefore(keyframes.times, seekSeconds)
       : null);
   // A second input, and it exists for exactly one case: a browser that takes
   // its audio muxed into the picture, watching a release whose soundtrack is a
@@ -536,7 +539,7 @@ export function buildRunCommand({
   if (snappedKeyframe !== null) {
     const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
     if (snappedKeyframe > 0) {
-      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, file }, snappedKeyframe)));
+      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, keyframes }, snappedKeyframe)));
     }
     args.push("-i", inputUrl);
     // The coarse landing, not the exact target: the residual below is discarded

package/services/encode/run-inputs.js

@@ -0,0 +1,42 @@
+/**
+ * @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.
+ */
+
+/**
+ * @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.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, 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 });
+  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
+    ? soundtrack.streamUrl(baseUrl, { sessionId }).toString()
+    : "";
+  return { inputFile, audioFile: soundtrack, inputUrl: input.toString(), audioInputUrl };
+}

package/services/{segment-formats → encode/segment-formats}/fmp4.js

@@ -305,6 +305,69 @@ export const fmp4Format = {
     return countFragmentTracks(bytes) >= expected.size;
   },
 
+  /**
+   * Whether this piece is whole, judged against ITS OWN header.
+   *
+   * A piece that disagrees with the session's cached header is one of two very
+   * different things, and they call for opposite actions: the piece may be
+   * short, or the HEADER may be the odd one out. A self-contained piece carries
+   * a `moov` of its own, so it can be compared with itself, and that comparison
+   * tells them apart without knowing anything about encoders.
+   *
+   * WHAT THIS REPLACED, because the difference is five minutes of a frozen
+   * picture. The action used to be chosen by "is any run of this session
+   * alive?" — a question about the SESSION, asked about a fact of the BYTES. A
+   * run anywhere in the film meant "still being written; waiting for it", and
+   * nothing re-judged or re-made the piece afterwards, so one misjudgement
+   * became permanent. Field 2026-09-14: `segment-00033.mp4` of a copied
+   * picture, already served whole to one viewer at 5 099 421 bytes, was refused
+   * to a second viewer for five minutes — four holds of sixty seconds each,
+   * then 503 — while the run in force was at #192 and beyond. That viewer's
+   * picture stood still 196.2 s and then a further 56.2 s.
+   *
+   * The run question is also unanswerable and does not need asking: a piece
+   * being written is called `making-<tag>-NNNNN.mp4` and takes its served name
+   * by a rename, which is atomic. A file under its served name is never being
+   * written and never half-read.
+   *
+   * The same file read back off the disk declares one track in its header and
+   * carries one in its fragments, so what fired in the field was not the piece.
+   * Until a reading names what it was, the verdict carries every count it made.
+   *
+   * @param {Buffer} raw - The piece as it is on disk, header and all.
+   * @param {Buffer} bytes - Its media part, the header already removed.
+   * @param {Buffer | null} sessionHeader - What the session serves as its init.
+   * @returns {{ whole: boolean, serve: boolean, fragmentTracks: number,
+   *   ownTracks: number, sessionTracks: number, because: string } | null} Null
+   *   where there is nothing to compare against, which is not a verdict.
+   */
+  judgeTracks(raw, bytes, sessionHeader) {
+    if (!sessionHeader || sessionHeader.length === 0) {
+      return null;
+    }
+    const sessionTracks = readTrackTimescales(sessionHeader).size;
+    if (sessionTracks === 0) {
+      return null;
+    }
+    const fragmentTracks = countFragmentTracks(bytes);
+    if (fragmentTracks >= sessionTracks) {
+      return null;
+    }
+    const ownHeader = this.extractInit(raw);
+    const ownTracks = ownHeader ? readTrackTimescales(ownHeader).size : 0;
+    const agreesWithItself = ownTracks > 0 && fragmentTracks >= ownTracks;
+    return {
+      whole: agreesWithItself,
+      serve: agreesWithItself,
+      fragmentTracks,
+      ownTracks,
+      sessionTracks,
+      because: agreesWithItself
+        ? "it agrees with its own header, so the session's is the odd one out; serving it"
+        : "it disagrees with its own header, so it was closed short; removing it to be made again"
+    };
+  },
+
   /**
    * How many tracks an init segment declares.
    *

package/services/{segment-formats → encode/segment-formats}/index.js

@@ -2,9 +2,9 @@
  * @file Selectable HLS segment container formats.
  *
  * Everything that differs between fMP4/CMAF and MPEG-TS output lives behind one
- * interface, so `hls-session-manager` never branches on the container: it holds
- * a format object and asks it. Adding a container means adding a module here,
- * not editing the session manager.
+ * interface, so the encoding and the serving never branch on the container: they
+ * hold a format object and ask it. Adding a container means adding a module
+ * here, not editing either of them.
  *
  * The choice is per-proxy (CLI `--segment-format`), mirroring how Jellyfin lets
  * the operator pick the transcoding container. fMP4 is the default; MPEG-TS is