@torrent-tv/proxy 2.96.2 → 2.96.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.96.2",
+  "version": "2.96.4",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "repository": {

package/services/encode/EncodePlan.js

@@ -1270,7 +1270,7 @@ export function firstUnmetWant(coverage, windows) {
  *   stated want is due now.
  * @returns {number[]} Where to start each encoder, ascending.
  */
-export function placeEncoders({
+function placeEncoders({
   coverage,
   windows,
   howMany,

package/services/encode/EncodeRuns.js

@@ -60,7 +60,7 @@ export function formatSeconds(seconds) {
  * @param {object[] | Set<object>} runs
  * @returns {number | null}
  */
-export function earliestRunStart(runs) {
+function earliestRunStart(runs) {
   const live = liveRunsOf(runs);
   return live.length > 0 ? live[0].from : null;
 }
@@ -129,7 +129,7 @@ export function isInputUnavailable(message) {
  * @param {string[]} args
  * @returns {string}
  */
-export function describeFfmpegArgs(args) {
+function describeFfmpegArgs(args) {
   const parts = [];
   for (let index = 0; index < args.length; index += 1) {
     const value = args[index];
@@ -370,7 +370,7 @@ export class EncodeRuns {
       const cut = cutOf(session.timeline, index);
       const grid = session.timeline.published ?? session.timeline.boundaries;
       const interval = admitted ? { from: grid?.[index], to: grid?.[index + 1],
-        ...(index === session.timeline.segmentCount - 1 ? { sourceEnds: Object.fromEntries(
+        ...(index === session.timeline.segmentCount - 1 ? { endsWithSource: true, sourceEnds: Object.fromEntries(
           (admitted.tracks ?? []).filter(input => Number.isFinite(input.sourceEndSeconds))
             .map(input => [input.track.type === "video" ? "vide" : "soun", input.sourceEndSeconds])) } : {}),
         requiredKinds: [session.spec.carries !== "audio-only" ? "vide" : null,

package/services/encode/OriginalInput.js

@@ -37,10 +37,10 @@ export async function admitOriginalInput({ sources, reserve, readRanges, now = D
     const reads = { count: 0, bytes: 0, firstAt: 0, lastAt: 0 };
     return {
       kind: "result", original: true, sources, bytes, copyMs, fingerprint: hash.digest("hex"),
-      tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track,
-        ...(Number.isFinite(source.input.sourceEnds?.[selection.track.trackNumber]) ? {
-          sourceEndSeconds: source.input.sourceEnds[selection.track.trackNumber] - source.timeShiftSeconds
-        } : {}) }))),
+      // No track's own end: the container names the bytes an interval needs,
+      // not where each track stops. The final piece is judged by the input
+      // reaching the end of the file instead (`piece-completeness.js`).
+      tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track }))),
       read(fileIndex, start, end, partial = false) {
         if (released) return null;
         const entry = held.get(fileIndex);

package/services/encode/OutputTimes.js

@@ -31,7 +31,7 @@ const SEGMENT_START_DISAGREEMENT_SEC = 0.25;
  * judged not to have loaded — so the player asks for it again, and again.
  * Taken from the player's published default rather than chosen here.
  */
-export const PLAYER_BUFFER_HOLE_SEC = 0.5;
+const PLAYER_BUFFER_HOLE_SEC = 0.5;
 /**
  * A live run of this session that begins exactly at this number, if there is
  * one.

package/services/encode/args.js

@@ -31,7 +31,7 @@ export const TONEMAP_FILTER_CHAIN =
 export const TRANSCODE_FPS = 24;
 // Upper bound on the output frame rate: 50/60 fps sources are halved-in-effort
 // by capping to 30, protecting the realtime encode budget on weak hosts.
-export const MAX_OUTPUT_FPS = 30;
+const MAX_OUTPUT_FPS = 30;
 
 /**
  * Choose an INTEGER output frame rate from the (possibly fractional) source
@@ -232,7 +232,7 @@ export function softwareRateControlFor({ width, height, fps, source = null, capK
  * @param {number} nominalKbps
  * @returns {number}
  */
-export function bufsizeKbpsFor(nominalKbps) {
+function bufsizeKbpsFor(nominalKbps) {
   return Math.round(nominalKbps * CAP_BUFSIZE_FACTOR);
 }
 

package/services/encode/calibration.js

@@ -53,7 +53,6 @@ import {
 } from "./hwaccel.js";
 import { interpolationErrorOf } from "./throughput.js";
 
-export { throughputAt, interpolationErrorOf } from "./throughput.js";
 
 /**
  * The sizes a mode is read at, smallest first.
@@ -64,7 +63,7 @@ export { throughputAt, interpolationErrorOf } from "./throughput.js";
  * rows, where most films are watched. 640x360 is the reference size every
  * earlier reading was taken at, so the figures stay comparable with them.
  */
-export const CALIBRATION_FRAMES = Object.freeze([
+const CALIBRATION_FRAMES = Object.freeze([
   Object.freeze({ width: 256, height: 144 }),
   Object.freeze({ width: 640, height: 360 }),
   Object.freeze({ width: 1280, height: 720 }),
@@ -95,18 +94,6 @@ const CALIBRATION_SOURCE = Object.freeze({ width: 1920, height: 1080, pictureKbp
  *   What the correctness check's segments carried.
  */
 
-/**
- * The settings a mode is known by, as text, for the log and for the key its
- * later observations are filed under.
- *
- * @param {{ benchmarkArgs: (rung: string | null) => string[] }} encoder
- * @param {string | null} rung
- * @returns {string}
- */
-export function settingsOf(encoder, rung) {
-  return encoder.benchmarkArgs(rung).join(" ");
-}
-
 /**
  * Encode the calibration clip through the product's own arguments for this
  * mode, and check every segment decodes on its own.
@@ -114,7 +101,7 @@ export function settingsOf(encoder, rung) {
  * @param {{ ffmpegBin: string, encoder: object, rung: string | null, segmentDurationSec: number }} params
  * @returns {Promise<{ ok: boolean, reason: string, segmentKbps: { averageKbps: number, peakKbps: number } | null }>}
  */
-export async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, rung, segmentDurationSec }) {
+async function checkModeProducesCorrectSegments({ ffmpegBin, encoder, rung, segmentDurationSec }) {
   let directory;
   try {
     directory = mkdtempSync(path.join(os.tmpdir(), "tt-modecheck-"));

package/services/encode/encode-run-state.js

@@ -493,7 +493,7 @@ export function declaredContainment() {
  * @param {object[] | Set<object>} runs
  * @returns {object[]}
  */
-export function runsOf(runs) {
+function runsOf(runs) {
   const listed = Array.isArray(runs) ? runs : runs instanceof Set ? [...runs] : [];
   return [...listed].sort((left, right) => left.from - right.from);
 }

package/services/encode/hwaccel.js

@@ -53,8 +53,7 @@ import {
 export {
   chooseOutputFps,
   maxrateKbpsFor,
-  nominalKbpsFor,
-  TRANSCODE_FPS
+  nominalKbpsFor
 } from "./args.js";
 
 const BENCHMARK_REF_W = 640;
@@ -72,7 +71,7 @@ const BENCHMARK_DURATION_SEC = 3;
  * @param {{ width: number, height: number }} frame
  * @returns {number}
  */
-export function rawFrameCountFor(frame) {
+function rawFrameCountFor(frame) {
   const referenceBytes = BENCHMARK_REF_W * BENCHMARK_REF_H * 1.5 * TRANSCODE_FPS * BENCHMARK_DURATION_SEC;
   const frameBytes = frame.width * frame.height * 1.5;
   return Math.max(TRANSCODE_FPS, Math.floor(referenceBytes / frameBytes));
@@ -614,10 +613,9 @@ export async function benchmarkContention({ ffmpegBin, logger, clipsDir = CALIBR
   // company, not the clip's own cost, so the smallest one says it soonest.
   const clip = path.join(clipsDir, "cal-h264-480-lo.mp4");
   const startedAt = Date.now();
-  // Lifted once and decoded three times from the same bytes. Going through
-  // `measureDecodeSlope` lifted it again for every reading — three process
-  // starts on a path that is awaited before the proxy's tunnel opens, for a
-  // remux whose result had not changed.
+  // Lifted once and decoded three times from the same bytes. Lifting it again
+  // for every reading cost three process starts on a path that is awaited
+  // before the proxy's tunnel opens, for a remux whose result had not changed.
   const streams = await extractFamilyStreams(ffmpegBin, [clip], "h264");
   const stream = streams?.[0];
   if (!stream) {
@@ -995,58 +993,6 @@ function runCapturingStderr(ffmpegBin, args, timeoutMs) {
   });
 }
 
-/**
- * Measure how fast this host DECODES a clip, from ffmpeg's own report of how
- * much video it has processed.
- *
- * Two things are deliberately outside the measurement.
- *
- * **The process starting.** Wall-clock around the process cannot answer this:
- * starting ffmpeg costs about a second, and on a quick machine a five-second
- * clip decodes in a tenth of that, so the measurement would be of the program
- * starting. Progress lines arrive AFTER it has started, and the slope between
- * two of them — video processed against time taken — contains no part of the
- * startup by construction.
- *
- * **The clip restarting.** This used to loop the clip with `-stream_loop -1`,
- * and a loop is not free: measured 2026-08-22 on a desktop, a restart costs
- * 0.03 s on the 480p clip and 0.12 s on the 1080p one — the decoder tearing
- * down and re-allocating its frame buffers, which is why the price rises with
- * the picture. A five-second clip decoded at 55x restarts eleven times a
- * second, so that cost DOMINATED the reading: the same clips measured 53.7x
- * looped against 80.3x in one continuous pass, and 11.8x against 15.8x. Worse,
- * the bias is not shared — it depends on the clip's own resolution and on how
- * fast the host is — so it does not cancel out of the fit, it tilts it. That is
- * the fast-host failure recorded on 2026-08-20, where 1080p read cheaper than
- * 720p, which is not a thing a decoder does.
- *
- * So the clip is fed to the decoder as ONE stream instead. An Annex-B
- * elementary stream carries its parameter sets inline, so writing the same
- * bytes again is simply more stream — the decoder never re-initialises, and
- * there is no restart inside the window to measure. Verified against the
- * continuous-pass truth on the same host: -0.2 % and -5.5 %, against -25 % and
- * -33 % for the loop. Nothing is written to disk and the process is killed as
- * soon as the window is wide enough.
- *
- * Exported because the property that broke here is checkable and was not being
- * checked: a bigger picture must cost more than a smaller one of the same
- * bitrate, and under the loop it did not.
- *
- * @param {string} ffmpegBin
- * @param {string} clipPath
- * @param {string} [family="h264"]
- * @returns {Promise<{ speed: number, windowSec: number, megapixelsPerSecond: number, megabitsPerSecond: number } | null>}
- */
-export async function measureDecodeSlope(ffmpegBin, clipPath, family = "h264") {
-  const streams = await extractFamilyStreams(ffmpegBin, [clipPath], family);
-  const stream = streams?.[0];
-  if (!stream) {
-    return null;
-  }
-  const measured = await decodePipedStream(ffmpegBin, stream);
-  return measured?.speed ? measured : null;
-}
-
 /**
  * Decode an elementary stream fed from memory, and report the slope.
  *

package/services/encode/output/OutputSpec.js

@@ -258,6 +258,19 @@ export class OutputSpec {
     return this.audio?.fileIndex ?? -1;
   }
 
+  /**
+   * The files of the torrent whose bytes this output reads: the picture's file
+   * where it carries a picture, the soundtrack's where it carries sound. A
+   * soundtrack shipped beside the picture is a file of its own, and its bytes
+   * are wanted from that file and not from the picture's.
+   *
+   * @returns {number[]}
+   */
+  get sourceFileIndexes() {
+    return [...new Set([this.video?.fileIndex, this.audio?.fileIndex]
+      .filter((fileIndex) => Number.isInteger(fileIndex) && fileIndex >= 0))];
+  }
+
   /** @returns {number} */
   get audioSourceTrackIndex() {
     return this.audio?.trackIndex ?? 0;

package/services/encode/output/playlists.js

@@ -42,7 +42,7 @@ export const PLAYLIST_FILE_NAME = "index.m3u8";
  * @param {string} language
  * @returns {string}
  */
-export function languageTag(language) {
+function languageTag(language) {
   const code = String(language ?? "").toLowerCase();
   return LANGUAGE_TAGS.get(code) ?? code;
 }
@@ -57,7 +57,7 @@ export function languageTag(language) {
  * @param {string} value
  * @returns {string}
  */
-export function escapeAttribute(value) {
+function escapeAttribute(value) {
   return String(value ?? "").replace(/"/g, "'").replace(/[\u0000-\u001f\u007f]/g, " ").trim();
 }
 
@@ -281,4 +281,3 @@ export function segmentIndexForTime(boundaries, seconds, segmentDurationSec) {
   return Math.min(result, boundaries.length - 2);
 }
 
-export { AUDIO_GROUP_ID, AUDIO_PATH_PREFIX, VARIANT_PATH_PREFIX };

package/services/encode/piece-completeness.js

@@ -43,7 +43,7 @@ export function cutOf(timeline, index) {
  * @param {{ producedThroughSeconds?: (ranges: object) => number | null }} format
  * @param {object} ranges - The piece's media intervals, as the format read them.
  * @param {number | undefined} cutSeconds - From {@link cutOf}.
- * @param {{ from: number, to: number, requiredKinds: string[], sourceEnds?: object }} [interval]
+ * @param {{ from: number, to: number, requiredKinds: string[], sourceEnds?: object, endsWithSource?: boolean }} [interval]
  * @returns {{ whole: boolean, throughSeconds: number | null, reason?: string }}
  */
 export function judgePiece(format, ranges, cutSeconds, interval) {
@@ -132,8 +132,18 @@ export function judgeNeighbors(left, right) {
  * Every required track must cover the interval with at most one-frame error,
  * on the clock the run's muxer cut by: the interval moved by `shift`
  * ({@link cutShiftOf}). A track's own end in the file is not moved.
+ *
+ * `endsWithSource` marks the final piece of a film. Its input is the rest of
+ * the file, and it is published only by a run that reached the end of that
+ * input, so a track that stops before the interval's end stops there in the
+ * file too: the end the piece shows is the track's own, and only a track
+ * running past the interval is refused. Where the input states a track's end
+ * (`sourceEnds`), that end is held to as before. Field 2026-10-09, Drifters
+ * episode 1: the picture's last packet ends at 1419.92 s and the separate
+ * soundtrack's at 1419.904 s against a final cut of 1419.993 s, and both last
+ * pieces were refused, so no viewer could reach the end of the episode.
  */
-function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {}, shift = 0 }) {
+function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {}, shift = 0, endsWithSource = false }) {
   if (!Number.isFinite(from) || !Number.isFinite(to) || !(to > from) || !requiredKinds?.length) return "segment-interval-is-not-declared";
   for (const kind of requiredKinds) {
     const track = coverage?.tracks?.find(track => track.kind === kind);
@@ -157,7 +167,10 @@ function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {}, s
       if (range.end > reached) reached = range.end;
     }
     const finalFrame = track.productionFrame ?? track.ranges.at(-1).frame;
-    if (reached < end - finalFrame - positionError || reached > end + finalFrame + positionError) return `segment-end-outside-interval-${kind}`;
+    const endsInFile = endsWithSource && !Number.isFinite(sourceEnds[kind]);
+    if ((reached < end - finalFrame - positionError && !endsInFile) || reached > end + finalFrame + positionError) {
+      return `segment-end-outside-interval-${kind}`;
+    }
   }
   return null;
 

package/services/encode/quality/link-budget.js

@@ -179,7 +179,7 @@ export function soundtrackLoadOf(entry, transcode) {
  * @param {import("../../media/audio-inventory.js").AudioInventoryEntry | null | undefined} entry
  * @returns {boolean}
  */
-export function soundtrackHasFigure(entry) {
+function soundtrackHasFigure(entry) {
   const peakKbps = Number(entry?.peakKbps);
   const bitrateKbps = Number(entry?.bitrateKbps);
   return (Number.isFinite(peakKbps) && peakKbps > 0) || (Number.isFinite(bitrateKbps) && bitrateKbps > 0);

package/services/encode/source-command.js

@@ -11,7 +11,7 @@ function seekLandingOffsetFor(material, keyframe) {
   return next === undefined ? wanted : Math.min(wanted, (next - keyframe) / 2);
 }
 
-export function buildRunCommand({
+function buildRunCommand({
   keyframes,
   inputFile,
   audioFile,

package/services/media/container/avi-index.js

@@ -262,7 +262,7 @@ function streamOf(chunkId, streamCount) {
 }
 
 /** The packets an AVI index states, and the index bytes FFmpeg reads to learn them. */
-export class AviIndex {
+class AviIndex {
   #held;
   #allocation;
   /** @type {Map<number, Uint32Array> | undefined} */

package/services/media/container/ebml-reader.js

@@ -130,30 +130,3 @@ export function readFloat(buffer, offset, size) {
   }
   return null;
 }
-
-/**
- * Depth-first search for the first element with `id`, descending only into the
- * container ids listed in `descendInto`.
- *
- * @param {Buffer} buffer
- * @param {number} id - Element id to find.
- * @param {number[]} descendInto - Container ids worth entering.
- * @param {number} [start=0]
- * @param {number} [end=buffer.length]
- * @returns {{ dataOffset: number, size: number } | null}
- */
-export function findElement(buffer, id, descendInto, start = 0, end = buffer.length) {
-  for (const element of iterateElements(buffer, start, end)) {
-    if (element.id === id) {
-      return { dataOffset: element.dataOffset, size: element.size };
-    }
-    if (descendInto.includes(element.id)) {
-      const limit = Math.min(end, element.dataOffset + element.size);
-      const found = findElement(buffer, id, descendInto, element.dataOffset, limit);
-      if (found) {
-        return found;
-      }
-    }
-  }
-  return null;
-}

package/services/media/container/ebml-stream.js

@@ -29,7 +29,7 @@ export const MAX_HEADER_BYTES = 12;
  * @param {{ value: number, length: number }} size
  * @returns {boolean}
  */
-export function sizeIsUnknown(size) {
+function sizeIsUnknown(size) {
   return size.value === 2 ** (7 * size.length) - 1;
 }
 

package/services/media/container/matroska-work-tags.js

@@ -79,7 +79,7 @@ function simpleTags(buffer, start, end, out) {
  * @param {Buffer} data - The data of a `Tags` element.
  * @returns {Map<number, Array<{ name: string, value: string, isDefault: boolean }>>}
  */
-export function tagsByLevel(data) {
+function tagsByLevel(data) {
   /** @type {Map<number, Array<{ name: string, value: string, isDefault: boolean }>>} */
   const levels = new Map();
   for (const tag of iterateElements(data)) {

package/services/media/container/work-tags.js

@@ -18,10 +18,10 @@
  */
 
 /** Longest text taken from one field, in characters. A stated limit. */
-export const MAX_TEXT = 2000;
+const MAX_TEXT = 2000;
 
 /** Most genres, track titles or chapter titles kept. A stated limit. */
-export const MAX_LIST = 32;
+const MAX_LIST = 32;
 
 /** Largest cover image read, in bytes. A stated limit: covers measured in #136 are tens of kilobytes. */
 export const MAX_COVER_BYTES = 4 * 1024 * 1024;

package/services/media/ffmpeg-banner.js

@@ -33,27 +33,6 @@ export function parseFfmpegDurationSeconds(stderrText) {
   return hours * 3600 + minutes * 60 + seconds;
 }
 
-/**
- * Parse the container start time (seconds) from ffmpeg's "Duration: …, start:
- * X, …" line. Many MKVs report a small non-zero start (e.g. 0.1 s); preserving
- * it via `-copyts` would put a hole at the beginning, so we normalize it away.
- * Returns 0 when absent.
- *
- * @param {string} stderrText
- * @returns {number}
- */
-export function parseFfmpegStartTimeSeconds(stderrText) {
-  if (typeof stderrText !== "string" || stderrText.length === 0) {
-    return 0;
-  }
-  const match = stderrText.match(/Duration:[^\n]*?start:\s*(-?\d+(?:\.\d+)?)/i);
-  if (!match) {
-    return 0;
-  }
-  const value = Number(match[1]);
-  return Number.isFinite(value) ? value : 0;
-}
-
 /**
  * Parse the bitrate (kbit/s) that the decode cost is priced from: the VIDEO
  * stream's own, falling back to the container's when the stream does not state
@@ -195,72 +174,3 @@ export function parseFfmpegVideoFps(stderrText) {
   const value = Number(match[1]);
   return Number.isFinite(value) && value > 0 ? value : null;
 }
-
-/**
- * Detect an HDR / wide-gamut source from the ffmpeg "Video:" line's colour
- * metadata. HDR is identified by the transfer function — `smpte2084` (PQ /
- * HDR10) or `arib-std-b67` (HLG). Re-encoding such a source to 8-bit SDR
- * without tone mapping produces a washed-out, desaturated picture, so this
- * gates the tonemap filter chain.
- *
- * @param {string} stderrText
- * @returns {boolean}
- */
-export function parseFfmpegHdr(stderrText) {
-  if (typeof stderrText !== "string" || stderrText.length === 0) {
-    return false;
-  }
-  const videoLine = stderrText.match(/Video:[^\n]*/i);
-  if (!videoLine) {
-    return false;
-  }
-  // ffmpeg prints the colour info in parentheses, e.g.
-  // "yuv420p10le(tv, bt2020nc/bt2020/smpte2084)". The transfer (last token) is
-  // the reliable HDR signal.
-  return /\b(smpte2084|arib-std-b67|arib_std_b67)\b/i.test(videoLine[0]);
-}
-
-/**
- * How many bits per sample the video carries, from the pixel format ffmpeg
- * prints on its `Video:` line.
- *
- * This is a decode-cost input, not a colour one: a 10-bit stream holds wider
- * samples and is decoded with wider arithmetic, and how much that costs is a
- * property of the machine. It is therefore its own calibration family rather
- * than a multiplier on the 8-bit one.
- *
- * ffmpeg names the depth in the format itself — `yuv420p10le`, `yuv420p12le`,
- * `p010le` — and omits it at 8 bits (`yuv420p`, `nv12`). An unreadable line
- * gives null, and the caller then prices the source as 8-bit, which is what
- * every source was priced as before this existed.
- *
- * @param {string} stderrText
- * @returns {number | null}
- */
-export function parseFfmpegBitDepth(stderrText) {
-  if (typeof stderrText !== "string" || stderrText.length === 0) {
-    return null;
-  }
-  const videoLine = stderrText.match(/Video:[^\n]*/i);
-  if (!videoLine) {
-    return null;
-  }
-  // The pixel format is the token after the codec and its tag, and the depth
-  // rides on its name. `p010`/`p016` are the two that state it without a `p`
-  // separator, and they are 10 and 16 bits.
-  const named = videoLine[0].match(/\byuv[a-z0-9]*?p(\d{1,2})(?:le|be)\b/i);
-  if (named) {
-    const depth = Number(named[1]);
-    return Number.isFinite(depth) && depth >= 8 ? depth : null;
-  }
-  if (/\bp010(?:le|be)?\b/i.test(videoLine[0])) {
-    return 10;
-  }
-  if (/\bp016(?:le|be)?\b/i.test(videoLine[0])) {
-    return 16;
-  }
-  if (/\byuv[a-z0-9]*p\b|\bnv12\b|\bnv21\b|\bgbrp\b/i.test(videoLine[0])) {
-    return 8;
-  }
-  return null;
-}

package/services/server/SegmentServing.js

@@ -16,7 +16,7 @@ import { logger } from "../../utils/logger.js";
 import { cutsAtGivenTimes, isOutputName, PLAYLIST_FILE_NAME } from "../encode/output/index.js";
 // The index of variants. Served from the same route as the media playlist, so
 // it needs no path of its own.
-export const MASTER_PLAYLIST_FILE_NAME = "master.m3u8";
+const MASTER_PLAYLIST_FILE_NAME = "master.m3u8";
 // Read segment files in large blocks so the body is delivered to the data
 // channel in few, big chunks. On a busy ARM host the in-process WebTorrent
 // hashing starves the event loop in bursts, so fewer read iterations means

package/services/server/ViewerRequests.js

@@ -584,8 +584,7 @@ export class ViewerRequests {
             output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined
         };
       });
-      const sourceIndexes = [output.spec.video?.fileIndex, output.spec.audio?.fileIndex]
-        .filter((fileIndex) => Number.isInteger(fileIndex) && fileIndex >= 0);
+      const sourceIndexes = [...output.spec.sourceFileIndexes];
       if (sourceIndexes.length === 0) {
         sourceIndexes.push(output.file.fileIndex);
       }

package/services/storage/core-dumps.js

@@ -17,7 +17,7 @@ import path from "node:path";
 import { logger } from "../../utils/logger.js";
 
 /** How many to keep, newest first. */
-export const CORE_DUMPS_KEPT = 2;
+const CORE_DUMPS_KEPT = 2;
 
 /**
  * Which dumps to remove, given what is there.

package/services/storage/memory-report.js

@@ -26,7 +26,7 @@ import v8 from "node:v8";
 import path from "node:path";
 
 /** How often the reading is taken and written. */
-export const MEMORY_REPORT_INTERVAL_MS = 60_000;
+const MEMORY_REPORT_INTERVAL_MS = 60_000;
 
 /**
  * How often the torrent worker takes its own reading.
@@ -57,7 +57,7 @@ export const WORKER_MEMORY_SAMPLE_MS = 1_000;
  *
  * @returns {{ rss: number, heapUsed: number, heapTotal: number, external: number, arrayBuffers: number, heapLimit: number }}
  */
-export function readProcessMemory() {
+function readProcessMemory() {
   const usage = process.memoryUsage();
   let heapLimit = 0;
   try {
@@ -158,7 +158,7 @@ const LARGE_MAPPING_BYTES = 2 * 1024 * 1024;
  *
  * @returns {Promise<ReturnType<typeof summariseMappings> | null>}
  */
-export async function readMappingSummary() {
+async function readMappingSummary() {
   try {
     return summariseMappings(await readFile("/proc/self/smaps", "utf8"));
   } catch {
@@ -181,7 +181,7 @@ export async function readMappingSummary() {
  *
  * @returns {Promise<number | null>} Bytes, or null off Linux.
  */
-export async function readAnonymousMemory() {
+async function readAnonymousMemory() {
   try {
     const text = await readFile("/proc/self/smaps_rollup", "utf8");
     const match = /^Anonymous:\s+(\d+)\s+kB$/m.exec(text);
@@ -206,7 +206,7 @@ export async function readAnonymousMemory() {
  * @param {string} directory
  * @returns {Promise<number | null>} Bytes free, or null where it cannot be read.
  */
-export async function readDiskFree(directory) {
+async function readDiskFree(directory) {
   try {
     const stats = await statfs(directory);
     return Number(stats.bavail) * Number(stats.bsize);

package/services/storage/segment-store/SegmentStore.js

@@ -46,7 +46,7 @@ import os from "node:os";
 import path from "node:path";
 
 /** Where every output's segments live. One root for the process. */
-export const DEFAULT_STORE_ROOT = path.join(os.tmpdir(), "torrent-tv-hls");
+const DEFAULT_STORE_ROOT = path.join(os.tmpdir(), "torrent-tv-hls");
 
 /** The file inside each directory that says which output it holds. */
 const KEY_FILE = "key.txt";

package/services/torrent/demand/DemandRegister.js

@@ -17,7 +17,7 @@
  * about pieces — so it is testable with numbers alone.
  */
 
-import { isConditional, Urgency, URGENCY_ORDER } from "./Urgency.js";
+import { isConditional, URGENCY_ORDER } from "./Urgency.js";
 import { unionOf, Window } from "./Window.js";
 
 export class DemandRegister {
@@ -208,4 +208,3 @@ export class DemandRegister {
   }
 }
 
-export { Urgency };

package/services/torrent/demand/index.js

@@ -4,5 +4,5 @@
 // still used there.
 export { DemandRegister } from "./DemandRegister.js";
 export { Window } from "./Window.js";
-export { isConditional, selectionPriority, Urgency, urgencyName } from "./Urgency.js";
-export { bytesOf, piecesOf } from "./pieces.js";
+export { isConditional, Urgency, urgencyName } from "./Urgency.js";
+export { piecesOf } from "./pieces.js";

package/services/torrent/demand/pieces.js

@@ -43,38 +43,6 @@ export function piecesOf({ fileOffset, byteStart, byteEnd, pieceLength }) {
   };
 }
 
-/**
- * The bytes of a file that a piece range covers, clamped to the file.
- *
- * The inverse of {@link piecesOf}, and here for the same reason: a caller that
- * still thinks in pieces — the reader, which walks a file piece by piece
- * because that is what arrives — states its need in bytes like everyone else,
- * and the conversion stays in this one file rather than being written out
- * again at the boundary.
- *
- * @param {object} params
- * @param {number} params.fileOffset - Where the file starts within the torrent.
- * @param {number} params.fileLength
- * @param {number} params.from - First piece, inclusive.
- * @param {number} params.to - Last piece, inclusive.
- * @param {number} params.pieceLength
- * @returns {{ byteStart: number, byteEnd: number } | null}
- */
-export function bytesOf({ fileOffset, fileLength, from, to, pieceLength }) {
-  if (!Number.isFinite(pieceLength) || pieceLength <= 0) {
-    return null;
-  }
-  if (!Number.isFinite(fileOffset) || !Number.isFinite(fileLength) || fileLength <= 0) {
-    return null;
-  }
-  if (!Number.isInteger(from) || !Number.isInteger(to) || to < from) {
-    return null;
-  }
-  const byteStart = Math.max(0, from * pieceLength - fileOffset);
-  const byteEnd = Math.min(fileLength - 1, (to + 1) * pieceLength - 1 - fileOffset);
-  return byteEnd < byteStart ? null : { byteStart, byteEnd };
-}
-
 /**
  * How many pieces a number of bytes needs, at worst.
  *

package/services/torrent/files.js

@@ -164,28 +164,6 @@ export function countVideoFiles(files) {
   return count;
 }
 
-/**
- * Subtitle formats that are text, and therefore small by construction — a whole
- * episode of dialogue is tens of kilobytes.
- *
- * The distinction is used to decide how much of such a file to fetch ahead of
- * the viewer: a text file is fetched WHOLE, because it is smaller than the
- * torrent's own piece and reading its edges would cost the same pieces as
- * reading all of it. An image-based one (`.sup`, `.sub`+`.idx`) is a picture per
- * cue and runs to tens of megabytes, so it gets the same edges treatment as
- * anything else.
- */
-export const TEXT_SUBTITLE_SIDECAR_EXTENSIONS = new Set([
-  ".srt",
-  ".ass",
-  ".ssa",
-  ".vtt",
-  ".webvtt",
-  ".ttml",
-  ".smi",
-  ".txt"
-]);
-
 /**
  * Extensions whose track table a `Container` subclass can read. Everything else
  * in {@link AUDIO_SIDECAR_EXTENSIONS} is a bare stream: one track, no metadata.
@@ -224,7 +202,7 @@ export function baseNameOf(name) {
  * @param {string} extension - Lowercased, with the dot.
  * @returns {boolean}
  */
-export function declaresItsOwnTracks(extension) {
+function declaresItsOwnTracks(extension) {
   return CONTAINER_BACKED_AUDIO.has(extension);
 }
 
@@ -331,7 +309,7 @@ export function namesPair(sidecarName, videoName) {
  * @param {string} videoName
  * @returns {boolean}
  */
-export function imageNamesPair(imageName, videoName) {
+function imageNamesPair(imageName, videoName) {
   if (sameRelease(imageName, videoName)) {
     return true;
   }

package/services/torrent/torrent-pool.js

@@ -614,7 +614,7 @@ function pieceDownloadedBytes(torrent, index) {
  * @param {import("webtorrent").Torrent} torrent
  * @returns {number}
  */
-export function torrentDownloadedBytes(torrent) {
+function torrentDownloadedBytes(torrent) {
   if (!torrent?.bitfield || !Array.isArray(torrent.pieces)) {
     return 0;
   }
@@ -634,7 +634,7 @@ export function torrentDownloadedBytes(torrent) {
  * @param {import("webtorrent").TorrentFile & { _startPiece?: number, _endPiece?: number, offset?: number, length?: number }} file
  * @returns {number}
  */
-export function fileDownloadedBytes(torrent, file) {
+function fileDownloadedBytes(torrent, file) {
   if (!torrent?.bitfield || !Array.isArray(torrent.pieces) || !file) {
     return 0;
   }

package/services/torrent/worker/channel.js

@@ -24,7 +24,7 @@ export function workerReplyError(message, fallback = "Torrent worker request fai
  *
  * @returns {() => number}
  */
-export function createRequestIds() {
+function createRequestIds() {
   let next = 0;
   return () => (next += 1);
 }

package/services/torrent/worker/fastest-wires.js

@@ -326,7 +326,7 @@ export function duplicateTailFor(torrent, pieceIndex) {
  * @param {number} pieceIndex
  * @returns {boolean}
  */
-export function pieceIsFullyReserved(torrent, pieceIndex) {
+function pieceIsFullyReserved(torrent, pieceIndex) {
   const piece = torrent?.pieces?.[pieceIndex];
   if (!piece || typeof piece.reserve !== "function") {
     return false;

package/services/torrent/worker/piece-reader.js

@@ -30,41 +30,6 @@ import { minimumBufferFrom, requiredSpeedFrom } from "../supply-margin.js";
 const PIECE_WAIT_LOG_MS = 1_000;
 
 
-/**
- * Who is working on the piece a reader is blocked on, right now.
- *
- * The open question about a seek: a single 8 MiB piece takes 3.0-4.6 s to
- * arrive while the swarm as a whole is moving 4-6 MB/s, so roughly 2 MB/s is
- * reaching the piece that is actually being waited for. Whether that is because
- * few peers hold it, few are being asked, or each is slow cannot be told apart
- * from the outside — these three counts tell them apart.
- *
- * `wire.requests` is what has been asked of that peer and not yet answered; a
- * block is 16 KB, so `blocks x 16 KB` is the work in flight on this piece.
- *
- * @param {import("webtorrent").Torrent} torrent
- * @param {number} pieceIndex
- * @returns {{ peers: number, holders: number, askedOf: number, blocks: number }}
- */
-export function pieceSupply(torrent, pieceIndex) {
-  const wires = Array.isArray(torrent?.wires) ? torrent.wires : [];
-  let holders = 0;
-  let askedOf = 0;
-  let blocks = 0;
-  for (const wire of wires) {
-    if (wire?.peerPieces?.get?.(pieceIndex)) {
-      holders += 1;
-    }
-    const requests = Array.isArray(wire?.requests) ? wire.requests : [];
-    const forThisPiece = requests.filter((request) => request?.piece === pieceIndex).length;
-    if (forThisPiece > 0) {
-      askedOf += 1;
-      blocks += forThisPiece;
-    }
-  }
-  return { peers: wires.length, holders, askedOf, blocks };
-}
-
 /**
  * Wait until a piece has been downloaded and verified.
  *
@@ -286,80 +251,6 @@ function describeWaitLevels(key) {
  */
 const waitsByLevel = new Map();
 
-/**
- * How many readers are blocked on a torrent AT THIS MOMENT, by infohash.
- *
- * Not a history and not an average: the question it answers is "is anything the
- * viewer is watching waiting for the swarm right now", and the only honest
- * answer is a count of readers currently inside a wait.
- *
- * It exists so that work which is NOT what the viewer is watching — fetching a
- * soundtrack or a subtitle file they may switch to later — can proceed while the
- * swarm has room and stand aside the instant it does not. That ordering is the
- * whole of the requirement: the picture and the track being played come first,
- * the other tracks next, and reading the film far ahead last.
- *
- * @type {Map<string, number>}
- */
-const blockedReaders = new Map();
-
-/**
- * How many stalls a torrent's readers have had, ever. Only differences between
- * two readings of it mean anything.
- *
- * @type {Map<string, number>}
- */
-const stallsSeen = new Map();
-
-/**
- * Whether any reader on this torrent is waiting for a piece right now.
- *
- * @param {string} infoHash
- * @returns {boolean}
- */
-export function readersAreBlockedOn(infoHash) {
-  return (blockedReaders.get(infoHash) ?? 0) > 0;
-}
-
-/**
- * How many times a reader on this torrent has been blocked since the process
- * started.
- *
- * Exists so that work of lower importance can ask "did the viewer stall while I
- * was busy?" — which is a different and stricter question than "is the viewer
- * stalled right now". On a swarm delivering exactly what the film needs, a
- * background fetch that only pauses DURING a stall still takes bandwidth
- * between them, and the stalls are the proof it had none to spare. Field
- * 2026-08-31: the swarm delivered 200-600 KB/s against the 399 KB/s the film
- * needs, and the picture stood still 145.6 s.
- *
- * @param {string} infoHash
- * @returns {number}
- */
-export function stallsSeenOn(infoHash) {
-  return stallsSeen.get(infoHash) ?? 0;
-}
-
-/**
- * @param {string} infoHash
- * @param {number} delta
- * @returns {void}
- */
-function countBlockedReader(infoHash, delta) {
-  if (!infoHash) {
-    return;
-  }
-  if (delta > 0) {
-    stallsSeen.set(infoHash, (stallsSeen.get(infoHash) ?? 0) + 1);
-  }
-  const next = (blockedReaders.get(infoHash) ?? 0) + delta;
-  if (next > 0) {
-    blockedReaders.set(infoHash, next);
-    return;
-  }
-  blockedReaders.delete(infoHash);
-}
-
 function noteSupplyWait(key, label, waitedMs) {
   const history = supplyWaits.get(key) ?? [];
   history.push({ waitedMs, at: Date.now() });
@@ -427,9 +318,7 @@ export async function* readFragments({ torrent, fileIndex, start, end, cancellat
       let retries = 0;
       while (true) {
         const waitAt = Date.now();
-        countBlockedReader(torrent.infoHash, 1);
-        try { await whenPieceReady(torrent, index, cancellation, wanted); }
-        finally { countBlockedReader(torrent.infoHash, -1); }
+        await whenPieceReady(torrent, index, cancellation, wanted);
         const waitedMs = Date.now() - waitAt;
         if (index > first && waitedMs >= PIECE_WAIT_LOG_MS) {
           const key = `${torrent.infoHash ?? "?"}/${file.name ?? "?"}`;

package/services/torrent/worker/protocol.js

@@ -27,11 +27,12 @@
  * standard interface outside, ownership transfer inside. Callers cannot tell
  * the difference; the cost is a tenth of a percent of a segment's playing time.
  *
- * Chunk size follows from the same measurements: a round trip costs ~100 µs, so
- * 64 KB chunks would spend 13 ms per segment on overhead against 0.5 ms sent
- * whole. {@link STREAM_CHUNK_BYTES} of 1 MB puts a 10 MB segment at ten
- * messages — about 1 ms — while still allowing a read to be cancelled promptly
- * and keeping peak memory bounded.
+ * The unit of one message follows from the same measurements: a round trip
+ * costs ~100 µs, so 64 KB chunks would spend 13 ms per segment on overhead
+ * against 0.5 ms sent whole. A read crosses as one message per PIECE fragment —
+ * its position in shared memory, not its bytes (`piece-reader.js`) — so a
+ * segment of a few pieces is a few messages, and a read is still cancelled at
+ * the next fragment.
  *
  * Torrent objects cannot cross a thread boundary, so the main thread names them
  * by `sourceKey` (the identifier the registry already uses) and the worker owns
@@ -164,11 +165,6 @@ export const Event = {
   HOLDINGS_CHANGED: "holdings-changed"
 };
 
-/**
- * Bytes per CHUNK message. See the file header for why 1 MB.
- */
-export const STREAM_CHUNK_BYTES = 1024 * 1024;
-
 /**
  * How many chunks may be in flight before the worker waits for an acknowledgement.
  *

package/services/torrent/worker/worker.js

@@ -217,11 +217,11 @@ function sendFragment(id, fragment) {
 /**
  * Stream a byte range back as CHUNK messages.
  *
- * Reads through WebTorrent's own read stream — which serves already-downloaded
- * pieces from disk and waits for the rest — and forwards it in
- * {@link STREAM_CHUNK_BYTES} pieces, transferring ownership of each so nothing
- * is copied across the boundary. `createSendStream` applies the backpressure,
- * so a fast disk cannot outrun the main thread and rebuild the queue in memory.
+ * Reads the range piece by piece (`readFragments`), which waits for what has
+ * not arrived, and forwards each fragment as its position in shared memory, so
+ * nothing is copied across the boundary. `createSendStream` applies the
+ * backpressure, so a fast disk cannot outrun the main thread and rebuild the
+ * queue in memory.
  *
  * @param {object} params
  * @param {number} params.id - Request id; CHUNK/READ_END carry it.

package/services/transport/delivery-probe.js

@@ -133,7 +133,7 @@ export function allowedGap({
  *   echoIntervalMs?: number, peerLoopLagMs?: number, intervalMs?: number }} state
  * @returns {number}
  */
-export function allowedWaitMs({
+function allowedWaitMs({
   queuedBytes,
   bytesPerSecond,
   rttMs,

package/services/transport/packet-witness.js

@@ -40,7 +40,7 @@ import os from "node:os";
 import path from "node:path";
 
 /** Per-packet capture length. Small: headers are what the signatures need. */
-export const WITNESS_SNAPLEN_BYTES = 128;
+const WITNESS_SNAPLEN_BYTES = 128;
 
 /**
  * usrsctp's maximum retransmission timeout, seconds (its `RTO.max` default).
@@ -66,19 +66,19 @@ export const WITNESS_RING_FILE_MB = 16;
 export const WITNESS_RING_FILES = 4;
 
 /** Megabytes per tail file. A wedged session emits a few packets a second. */
-export const WITNESS_TAIL_FILE_MB = 8;
+const WITNESS_TAIL_FILE_MB = 8;
 
 /** How many tail files may be written before tcpdump stops on its own. */
-export const WITNESS_TAIL_FILES = 2;
+const WITNESS_TAIL_FILES = 2;
 
 /** Extra time before the SIGKILL fallback lands on a hanging tcpdump. */
-export const WITNESS_KILL_GRACE_MS = 5_000;
+const WITNESS_KILL_GRACE_MS = 5_000;
 
 /** Minimum spacing between tail captures, whatever the reason for them. */
 export const WITNESS_COOLDOWN_MS = 10 * 60_000;
 
 /** How many old captures survive at startup, newest first. */
-export const WITNESS_CAPTURES_KEPT = 8;
+const WITNESS_CAPTURES_KEPT = 8;
 
 /** Base name of the rolling ring, before tcpdump appends its file number. */
 export const WITNESS_RING_BASENAME = "packet-witness-ring.pcap";

package/services/transport/usrsctp-state.js

@@ -39,7 +39,7 @@ const HERE = path.dirname(fileURLToPath(import.meta.url));
 export const SCTPSTATE_SCRIPT_PATH = path.join(HERE, "..", "..", "assets", "diagnostics", "sctpstate.gdb");
 
 /** How long gdb may run before it is killed. Generous: this is a rare, one-shot read. */
-export const GDB_TIMEOUT_MS = 15_000;
+const GDB_TIMEOUT_MS = 15_000;
 
 /**
  * Create the reader.

package/services/viewer/PriorityMap.js

@@ -95,10 +95,10 @@
  * Direction, urgent preparation and attenuation are separate map fields;
  * priority alone cannot distinguish an attenuated second from a passed one.
  */
-export const AT_A_WATCHING_VIEWER = 100;
+const AT_A_WATCHING_VIEWER = 100;
 
 /** Behind everybody. */
-export const NOBODY_IS_COMING = 1;
+const NOBODY_IS_COMING = 1;
 
 /** Nothing is wanted here at all. */
 const NOTHING = 0;
@@ -401,31 +401,3 @@ export function inWorkingOrder(runs) {
     (left, right) => right.priority - left.priority || left.from - right.from
   );
 }
-
-/**
- * The earliest second of film anybody is waiting on, or null when nobody is.
- *
- * WHY A SOUNDTRACK ASKS THE MAP AND NOT A VIEWER. Sound is produced for the
- * same reason a picture is — somebody is about to reach it — and the map is
- * where that is already stated, in seconds of film, merged over everybody
- * watching. Reading it from a viewer instead means the encoding layer holds a
- * person, and then every question about which person it is (the earliest of
- * two, the one on this rung, the one who has not reported yet) has to be
- * answered again in a second place. The map answers it once.
- *
- * The EARLIEST among the most urgent, because a track started at the leader's
- * position has nothing to give the viewer behind them, and the map's own order
- * — most urgent first, earliest film first within a priority — already says
- * which that is.
- *
- * @param {DemandZone[]} runs - From {@link runsOf}.
- * @returns {number | null} Seconds.
- */
-export function earliestUrgentSecond(runs) {
-  const wanted = (runs ?? []).filter((zone) => zone && !zone.behind);
-  if (wanted.length === 0) {
-    return null;
-  }
-  const top = Math.max(...wanted.map((zone) => Number(zone.priority) || 0));
-  return Math.min(...wanted.filter((zone) => (Number(zone.priority) || 0) === top).map((zone) => zone.from));
-}

package/services/viewer/PriorityOrchestrator.js

@@ -216,23 +216,34 @@ export class PriorityOrchestrator {
         if (typeof sourceKey !== "string" || !sourceKey || !Number.isSafeInteger(fileIndex) || fileIndex < 0) {
           throw new TypeError("A priority map requires its output file's source and file index.");
         }
-        const key = `${sourceKey}:${fileIndex}`;
         const durationSeconds = Number(session.file?.durationSeconds) || 0;
         // The first band is as wide as an interruption this file has actually
         // shown on this swarm, never a chosen number.
         const allowanceSeconds = this.#allowanceFor(session);
-        let held = byFile.get(key);
-        if (!held) {
-          held = {
-            sourceKey,
-            fileIndex,
-            durationSeconds,
-            allowanceSeconds,
-            viewers: [],
-            demandKey: []
-          };
-          byFile.set(key, held);
-        }
+        // EVERY FILE THE OUTPUT READS, not only the one it is named after. A
+        // soundtrack shipped beside the picture is an output of the picture's
+        // film whose bytes live in another file; mapped under the picture's
+        // file only, nobody asked the swarm for that file, its encoder waited
+        // for pieces for ever and the viewer who chose the soundtrack stood
+        // still (Home Assistant 2026-10-09, torrent-tv/meta#8).
+        const read = session.spec?.sourceFileIndexes;
+        const files = Array.isArray(read) && read.length ? read : [fileIndex];
+        const helds = files.map((index) => {
+          const fileKey = `${sourceKey}:${index}`;
+          let held = byFile.get(fileKey);
+          if (!held) {
+            held = {
+              sourceKey,
+              fileIndex: index,
+              durationSeconds,
+              allowanceSeconds,
+              viewers: [],
+              demandKey: []
+            };
+            byFile.set(fileKey, held);
+          }
+          return held;
+        });
         // Every output anybody holds a session for, whether or not a viewer is
         // consuming it — an output with nobody on it must get a map with
         // nothing in it, which is how the plan is told to stop its encoders.
@@ -240,16 +251,19 @@ export class PriorityOrchestrator {
         const address = session.outputKey ?? "";
         let mine = byOutput.get(address);
         if (!mine) {
-          mine = { durationSeconds, allowanceSeconds, viewers: [], fileKey: key };
+          // Counted over a file the output itself reads, which is always among
+          // the files mapped above; the picture's file is not one for a
+          // soundtrack read from a file of its own.
+          mine = { durationSeconds, allowanceSeconds, viewers: [], fileKey: `${sourceKey}:${files[0]}` };
           byOutput.set(address, mine);
         }
         for (const viewer of this.#viewers.forOutput(session).values()) {
           if (!viewer.isPresent()) {
             continue;
           }
-          held.demandKey.push([session.outputKey, viewer.id, viewer.audio?.trackIndex,
+          const demand = [session.outputKey, viewer.id, viewer.audio?.trackIndex,
             viewer.audio?.transcode, viewer.activeVariantId, viewer.warmingVariantId,
-            viewer.warmingAudioId, this.#watchedBy(session, viewer)]);
+            viewer.warmingAudioId, this.#watchedBy(session, viewer)];
           const stated = {
             id: viewer.id,
             atSeconds: viewer.positionSeconds(now) ?? 0,
@@ -267,7 +281,10 @@ export class PriorityOrchestrator {
               ? viewer.wantsFilmNow()
               : viewer.playing === true || viewer.waiting === true)
           };
-          held.viewers.push(stated);
+          for (const held of helds) {
+            held.demandKey.push(demand);
+            held.viewers.push(stated);
+          }
           if (this.#watchedBy(session, viewer)) {
             mine.viewers.push(stated);
           }

package/services/viewer/choices.js

@@ -319,20 +319,6 @@ export function visiblePictureOf(viewers, output, consumerId) {
   return size ? { ...size } : null;
 }
 
-/**
- * Take the picture as this viewer's page measured it, sent with the request
- * that opened their output.
- *
- * @param {object} viewers
- * @param {string} consumerId
- * @param {unknown} size
- * @returns {void}
- */
-export function noteVisiblePicture(viewers, consumerId, size) {
-  const viewer = consumerId ? viewers.get(consumerId) : null;
-  viewer?.noteVisiblePicture(size);
-}
-
 /**
  * Which way this viewer's buffer is going, and how much film it holds, as their
  * page last said (`viewer/buffer-trend.js`).

package/services/viewer/media-time.js

@@ -162,7 +162,7 @@ export function subtract(left, right) {
  * @param {bigint} factor
  * @returns {MediaTime}
  */
-export function multiply(time, factor) {
+function multiply(time, factor) {
   return { ticks: time.ticks * factor, timescale: time.timescale };
 }