@torrent-tv/proxy 2.96.3 → 2.96.5

package/package.json

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

package/server.js

@@ -630,7 +630,9 @@ export async function startProxyServer({
       error.canRetry = true;
       throw error;
     },
-    resolveEncodeInput: async (output, fromIndex, toIndex) => {
+    // `timing`, when given, is told how long each read of a file waited behind
+    // the reads asked before it and how long it took (torrent-tv/meta#166).
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null) => {
       const grid = output.timeline?.published ?? output.timeline?.boundaries;
       const from = grid?.[fromIndex], to = grid?.[toIndex + 1];
       if (!Number.isFinite(from) || !(to > from)) return { kind: "terminal", reason: "output-interval-not-declared" };
@@ -650,6 +652,13 @@ export async function startProxyServer({
       for (const [fileIndex, choices] of selected) {
         const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
         if (!params) return { kind: "needs-source" };
+        if (timing) {
+          params.onTimed = (_statement, waitedMs, readMs) => {
+            timing.reads += 1;
+            timing.queuedMs += waitedMs;
+            timing.readMs += readMs;
+          };
+        }
         const tracks = await containerOrchestrator.inspect(params, "tracks");
         if (tracks.kind !== "result") return tracks;
         const container = containerOrchestrator.known(params.sourceKey, fileIndex);

package/services/encode/EncodeInputs.js

@@ -59,12 +59,36 @@ export class EncodeInputs {
     this.#now = now;
   }
 
-  /** One line when a request's state changes, so a wait that never ends names what it waits for. */
-  #note(request, state) {
+  /**
+   * One line when a request's state changes, so a wait that never ends names
+   * what it waits for. `detail` is said with it and does not count as a change.
+   */
+  #note(request, state, detail = "") {
     if (request.noted === state) return;
     request.noted = state;
     this.#log(`encode input #${request.from}..#${request.to} of ${request.output.outputKey ?? request.output.id}: ${state}` +
-      ` (held ${this.#held} of ${this.#allowed} allowed)`);
+      ` (held ${this.#held} of ${this.#allowed} allowed)${detail}`);
+  }
+
+  /** The container's statement of an interval, its time added to the request's account. */
+  async #resolveTimed(timing, output, from, to) {
+    const startedAt = this.#now();
+    try {
+      return await this.#resolve(output, from, to, timing);
+    } finally {
+      timing.resolutions += 1;
+      timing.resolveMs += this.#now() - startedAt;
+    }
+  }
+
+  /** `work`'s time added to one field of the request's account. */
+  async #spent(timing, field, work) {
+    const startedAt = this.#now();
+    try {
+      return await work();
+    } finally {
+      timing[field] += this.#now() - startedAt;
+    }
   }
 
   held() { return this.#held; }
@@ -216,8 +240,14 @@ export class EncodeInputs {
     request.stale = false;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
+    // Where the time from the request to its input goes, across every attempt:
+    // field 2026-10-10, a picture's request took 38 s before its copy began and
+    // nothing said on what (torrent-tv/meta#166).
+    request.timing ??= { askedAt: this.#now(), attempts: 0, resolutions: 0, resolveMs: 0,
+      reads: 0, queuedMs: 0, readMs: 0, heldMs: 0, budgetMs: 0 };
+    request.timing.attempts += 1;
     request.promise = (async () => {
-      const resolved = await this.#resolve(request.output, request.from, request.from);
+      const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from);
       if (this.#requests.get(request.key) !== request) return;
       let result;
       if (resolved.kind !== "result") {
@@ -240,7 +270,8 @@ export class EncodeInputs {
       request.result = result;
       this.#note(request, result.kind === "result" ? `ready #${result.from}..#${result.to}, ${result.bytes ?? "?"} bytes` +
         (Number.isFinite(result.copyMs) ? `, copied in ${result.copyMs}ms` : "")
-        : `${result.kind}${result.reason ? ` ${result.reason}` : ""}${Number.isFinite(result.bytes) ? ` ${result.bytes} bytes` : ""}`);
+        : `${result.kind}${result.reason ? ` ${result.reason}` : ""}${Number.isFinite(result.bytes) ? ` ${result.bytes} bytes` : ""}`,
+      describeTiming(request.timing, this.#now()));
       if (result.kind === "result" || result.kind === "terminal") this.#changed(request.output, result);
     })().catch(error => {
       if (this.#requests.get(request.key) === request) {
@@ -261,7 +292,7 @@ export class EncodeInputs {
   #reserveFor(request) {
     return async bytes => {
       this.#wanted.set(request.key, { wanted: bytes, required: bytes });
-      await this.#revise();
+      await this.#spent(request.timing, "budgetMs", () => this.#revise());
       const capacity = this.#capacity();
       if (capacity !== null && bytes > capacity && this.#urgent(request.output, request.from)) return {
         kind: "terminal", reason: "source-input-exceeds-memory-capacity", bytes, capacity
@@ -303,7 +334,7 @@ export class EncodeInputs {
       if (!stretches.has(end)) {
         // A longer stretch that cannot be stated is not one to copy; the
         // shorter one already stated still runs.
-        const resolved = await this.#resolve(output, from, end).catch(() => null);
+        const resolved = await this.#resolveTimed(request.timing, output, from, end).catch(() => null);
         stretches.set(end, resolved?.kind === "result" && resolved.sources?.every(source => source.input.original === true)
           ? { sources: resolved.sources, bytes: originalInputBytes(resolved.sources) } : null);
       }
@@ -311,7 +342,7 @@ export class EncodeInputs {
     };
     const fits = async (end, maxBytes) => {
       const stretch = await at(end);
-      return Boolean(stretch) && stretch.bytes <= maxBytes && await this.#present(stretch.sources, held);
+      return Boolean(stretch) && stretch.bytes <= maxBytes && await this.#present(stretch.sources, held, request.timing);
     };
     // Grows by doubling and then halves back: a handful of resolutions find
     // the end whether it is a piece away or the rest of the film.
@@ -333,7 +364,7 @@ export class EncodeInputs {
     let end = target === null || this.#heldRanges === null ? from : await longest(target);
     if (this.#requests.get(request.key) !== request) return undefined;
     this.#wanted.set(request.key, { wanted: stretches.get(end).bytes, required: minimum });
-    await this.#revise();
+    await this.#spent(request.timing, "budgetMs", () => this.#revise());
     if (this.#requests.get(request.key) !== request) return undefined;
     const capacity = this.#capacity();
     if (capacity !== null && minimum > capacity && this.#urgent(output, from)) {
@@ -371,10 +402,10 @@ export class EncodeInputs {
   }
 
   /** Whether every range of these sources is downloaded whole now. */
-  async #present(sources, held) {
+  async #present(sources, held, timing) {
     for (const source of sources) {
       const name = `${source.sourceKey}:${source.fileIndex}`;
-      if (!held.has(name)) held.set(name, await Promise.resolve().then(() => this.#heldRanges(source)).catch(() => null) ?? []);
+      if (!held.has(name)) held.set(name, await this.#spent(timing, "heldMs", () => Promise.resolve().then(() => this.#heldRanges(source)).catch(() => null)) ?? []);
       const ranges = held.get(name);
       if (!source.input.ranges.every(([start, end]) => ranges.some(([first, last]) => first <= start && last >= end))) return false;
     }
@@ -382,5 +413,24 @@ export class EncodeInputs {
   }
 }
 
+/**
+ * Where a request has spent its time since it was asked, as one clause of its
+ * log line. The resolutions include the reads of the file they made, and those
+ * reads are split into the time spent behind earlier reads of the same file and
+ * the time of the read itself; what is left of the total is the copy and the
+ * waits between attempts for bytes or memory.
+ *
+ * @param {object | undefined} timing
+ * @param {number} now
+ * @returns {string}
+ */
+function describeTiming(timing, now) {
+  if (!timing) return "";
+  return `; asked ${Math.max(0, now - timing.askedAt)}ms ago over ${timing.attempts} attempt(s): ` +
+    `${timing.resolutions} resolution(s) ${timing.resolveMs}ms ` +
+    `(${timing.reads} file read(s): queued ${timing.queuedMs}ms, reading ${timing.readMs}ms), ` +
+    `held ranges ${timing.heldMs}ms, budget ${timing.budgetMs}ms`;
+}
+
 function addressOf(output) { return output.outputKey ?? output.id; }
 function keyOf(output, from) { return `${addressOf(output)}:${from}`; }

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/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/ContainerOrchestrator.js

@@ -137,10 +137,16 @@ export class ContainerOrchestrator {
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
     const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false;
     const previous = this.#reads.get(key) ?? Promise.resolve();
+    // Reads of one file run one after another, so an answer can wait for every
+    // read asked before it. Told to whoever asked, apart from the read itself,
+    // because the two call for different remedies (torrent-tv/meta#166).
+    const askedAt = Date.now();
     const reading = previous.catch(() => undefined).then(async () => {
       if (!isCurrent()) return { result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } };
+      const startedAt = Date.now();
       const revision = params.onReadStart?.(statement);
       const result = await this.#inspectRead({ ...params, isCurrent }, statement);
+      params.onTimed?.(statement, startedAt - askedAt, Date.now() - startedAt);
       return { result, revision };
     });
     this.#reads.set(key, reading);

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/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/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 };
 }