@torrent-tv/proxy 2.91.0 → 2.92.0

package/services/encode/OutputOpening.js

@@ -10,7 +10,7 @@
  * and nothing about a viewer enters what is decided here.
  *
  * What the file says about itself is read by the media component and handed in
- * (`probeMediaInfo`, `probeKeyframeTimes`), as is everything else this reads.
+ * (`readSourceMedia`), as is everything else this reads.
  */
 
 import { createRequire } from "node:module";
@@ -44,7 +44,7 @@ export class OutputOpening {
   #host;
 
   /**
-   * @param {object} host - `logger`, `probeMediaInfo`, `probeKeyframeTimes`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `admission`, `outputs`, `segmentOutputFiles`, `hostTimings`, `returns`, `encodeRuns`
+   * @param {object} host - `logger`, `readSourceMedia`, `enabled`, `segmentFormat`, `renditions`, `sourceFiles`, `getCachedMediaInfo`, `localBaseUrl`, `tonemapSupported`, `videoEncoder`, `hostLoad`, `keyframeTables`, `timelines`, `segmentDurationSec`, `softwarePresetBenchmark`, `decodeCostModel`, `encodeCost`, `admission`, `outputs`, `segmentOutputFiles`, `hostTimings`, `returns`, `encodeRuns`
    * @param {SegmentOutputFiles} host.segmentOutputFiles - The storage
    *   operations needed while selecting or opening an output.
    */
@@ -292,7 +292,6 @@ export class OutputOpening {
     // statement as "the file it reads is not the file of the picture", so it is
     // that comparison now and there is nothing to keep in step.
     const audioFile = this.#host.sourceFiles.get(sourceKey, audioSource.fileIndex, audioSource.name);
-    const inputFile = audioOnly === true && audioSource.isSidecar ? audioFile : file;
     // Media info (duration/resolution/fps/startTime/HDR) up front, so we can
     // serve a complete VOD playlist (#EXT-X-ENDLIST) with the correct total
     // duration and a fully seekable timeline before a single segment exists.
@@ -317,10 +316,16 @@ export class OutputOpening {
     // No session id on it: this read is a probe of the picture, not this
     // session's own delivery, and counting it against the session would tell a
     // waiting browser that its film is arriving when what arrived was a header.
-    const pictureUrl = file.streamUrl(this.#host.localBaseUrl);
     const mediaInfo = cachedUsable
       ? cachedMediaInfo
-      : await this.#host.probeMediaInfo(pictureUrl.toString());
+      : this.#host.readSourceMedia
+        ? await this.#host.readSourceMedia({ sourceKey, fileIndex })
+        : (() => {
+          const error = new Error("Source media declarations are not configured.");
+          error.code = "SOURCE_MEDIA_READER_UNAVAILABLE";
+          error.canRetry = false;
+          throw error;
+        })();
     const mediaInfoMs = Date.now() - mediaInfoStartMs;
     const mediaInfoSource = cachedUsable ? "cached" : "probed";
     // The file takes in what the probe said. It is the same answer for every
@@ -329,6 +334,7 @@ export class OutputOpening {
     // fresher reading updates it: on a cold torrent the first probe can come
     // back without a duration, and the second is the one that has it.
     file.learn(mediaInfo);
+    await this.#host.hostLoad.readFileLength(sourceKey, fileIndex);
     const durationSeconds = file.durationSeconds ?? 0;
     const sourceWidth = file.width;
     const sourceHeight = file.height;
@@ -383,11 +389,6 @@ export class OutputOpening {
     // duration, so the picture's byte rate would buy a window twenty times
     // wider than the seconds it is meant to represent, and the piece store
     // would hold it.
-    const readWindowBytes = await this.#host.hostLoad.readWindowBytesFor(
-      inputFile.sourceKey,
-      inputFile.fileIndex,
-      durationSeconds
-    );
     if (!hasDuration) {
       this.#host.logger.warn(
         `transcode "${logName}": could not probe duration; falling back to ` +
@@ -428,13 +429,6 @@ export class OutputOpening {
       // segment boundaries (the playlist itself), so this MUST block session
       // creation — an incorrect playlist is worse than a slower start.
       //
-      // The wait is bounded, and the bound is what the read costs on a real
-      // host rather than a figure picked here (`KEYFRAME_TABLE_BUDGET_MS`). A
-      // comment in this place used to promise a short timeout and "never more
-      // than ~6 s to session start" when no timeout existed at all; the file
-      // comes off a torrent, so the bytes the table lives in may still be
-      // arriving, and a session used to wait for them without limit.
-      //
       // What is read is the container's OWN table (Cues/stss) rather than a
       // scan of the media. On the copy path ffmpeg can only cut at the source's
       // existing keyframes, so these times ARE the segment boundaries —
@@ -449,18 +443,9 @@ export class OutputOpening {
       const { arrived } = await this.#host.keyframeTables.within({ sourceKey, fileIndex, logName });
       keyframeMs = Date.now() - keyframeStartMs;
       if (!arrived) {
-        // A read that ran out of its budget is still running, and one that
-        // found its bytes not downloaded yet is made again when they arrive;
-        // either way the table is still unanswered — which is not the same as a file with no keyframes,
-        // and the distinction is the table's own (`answered` against
-        // `readable`). Recorded as an absence it would make a passing shortage
-        // of bytes look like a property of the bytes, and every later session
-        // of the file would re-encode a picture that can be copied.
-        this.#host.logger.warn(
-          `transcode: the keyframe table for "${logName}" has not arrived after ${keyframeMs}ms ` +
-            `(budget ${Math.round(this.#host.keyframeTables.budgetMs / 1000)}s), so this session re-encodes the picture ` +
-            "instead of copying it; the read goes on and the next session of this file gets the copy"
-        );
+        const error = new Error("Source keyframe declarations require more available bytes.");
+        error.code = "MEDIA_BYTES_UNAVAILABLE";
+        throw error;
       }
       if (!keyframes.readable) {
         // No index, so there is no honest grid for a COPY: a copied picture can
@@ -474,9 +459,7 @@ export class OutputOpening {
         // then PLACED at our own cut times rather than found, so the grid is
         // correct by construction whatever the container. MPEG-TS is the case
         // this exists for — measured 2026-08-21, 669 real keyframes and no
-        // index of any kind to read them from — and a container whose index
-        // could not be read in the budget lands here too, which is right for
-        // the same reason.
+        // index of any kind to read them from.
         transcodeVideo = true;
         if (keyframes.answered) {
           this.#host.logger.warn(
@@ -486,36 +469,6 @@ export class OutputOpening {
           );
         }
       }
-    } else if (hasDuration && transcodeVideo) {
-      // Re-encode path: keyframeTimes are ONLY used to snap a LATER seek (see
-      // #startEncodeRun) — segment boundaries stay on the uniform grid either
-      // way. So this does NOT need to block session creation / the first
-      // segment's start. Run it in the background with a FULL budget instead of
-      // the 6 s cap: AVI-class containers need a full packet scan, which 6 s can
-      // never afford without delaying playback start — that starved budget is
-      // exactly why the probe kept missing on the container where the seek bug
-      // was field-diagnosed. A run reads the file's table on every call, so a
-      // seek that happens AFTER this finishes picks it up automatically; one
-      // that happens before falls back to the existing circuit breaker as a
-      // safety net (no regression either way).
-      keyframeMs = -2;
-      const backgroundStartedAt = Date.now();
-      void this.#host.probeKeyframeTimes(inputFile.streamUrl(this.#host.localBaseUrl).toString(), 25_000).then((times) => {
-        // Into the FILE's table, which the picture, its quality steps and a
-        // second viewer's session all hold — so nothing has to be alive for the
-        // answer to be kept, and the session this probe was started for may
-        // long since have gone. It used to be written onto whichever session
-        // was still there, and dropped outright when none was.
-        this.#host.keyframeTables.learn({ sourceKey, fileIndex }, { times, format: "packet probe" });
-        const elapsedMs = Date.now() - backgroundStartedAt;
-        this.#host.logger.info(
-          times
-            ? `transcode: background keyframe probe found ${times.length} keyframes ` +
-                `(${elapsedMs}ms) for "${logName}" — later seeks will snap to them`
-            : `transcode: background keyframe probe unavailable (${elapsedMs}ms) for "${logName}" ` +
-                `— seeks keep using the raw target (falls back to the circuit breaker on failure)`
-        );
-      });
     }
     this.#host.logger.info(
       `cold-start "${logName}": media-info=${mediaInfoMs}ms (${mediaInfoSource}) ` +
@@ -584,7 +537,7 @@ export class OutputOpening {
       encodesPicture: transcodeVideo && carriesVideo,
       exact: forceExactSize,
       target: this.#targetFor({ normalizedTargetWidth, normalizedTargetHeight, visiblePicture, sourceWidth, sourceHeight }),
-      source: { width: sourceWidth, height: sourceHeight, megabitsPerSecond: file.decode?.megabitsPerSecond ?? null, decode: file.decode },
+      source: { width: sourceWidth, height: sourceHeight, megabitsPerSecond: file.megabitsPerSecond, decode: file.decode },
       fps: outputFps,
       encoder: this.#host.videoEncoder,
       benchmark: this.#host.softwarePresetBenchmark,
@@ -722,7 +675,6 @@ export class OutputOpening {
     this.#host.segmentOutputFiles.directoryFor(spec.toKey());
     this.#host.segmentOutputFiles.useFormat(spec.toKey(), segmentFormat);
     this.#host.hostTimings.noteOutputCreated(session, createEntryMs);
-    this.#host.encodeRuns.setReadWindow(session, readWindowBytes);
     this.#host.encodeCost.notePredictionFor(session, output.encodeHeight);
     // Decided before the key was built and only recorded here. Whether the audio
     // travels separately decides the ffmpeg arguments, what the master says,

package/services/encode/Renditions.js

@@ -14,7 +14,6 @@ import { variantHeightsFor } from "./output/ladder.js";
 import { isSameMaterial, outputSuits } from "./quality/serving-output.js";
 import { SOUNDTRACK_MODE_CAUSE, chooseSoundtrackMode, linkAnswerFigures, linkCouldCarry, loadOf, soundtrackLoadOf, videoLoadOfLimit, videoLoadOfSpec } from "./quality/link-budget.js";
 import { maxrateKbpsFor } from "./args.js";
-import { encoderInputs } from "./run-inputs.js";
 /**
  * How a base files the audio renditions it has made.
  *
@@ -132,7 +131,7 @@ export class Renditions {
       wanted,
       judge: (spec) => linkCouldCarry(
         linkMbps,
-        loadOf(videoLoadOfSpec(spec, base.file.decode?.megabitsPerSecond ?? null, this.#host.observedPeakMbps?.(spec) ?? null), audioLoad)
+        loadOf(videoLoadOfSpec(spec, base.file.megabitsPerSecond, this.#host.observedPeakMbps?.(spec) ?? null), audioLoad)
       )
     });
   }
@@ -1661,21 +1660,6 @@ export class Renditions {
     ) ?? null;
   }
 
-  inputOf(session, runToken) {
-    return encoderInputs({
-      picture: session.file,
-      soundtrack: session.spec.audio
-        ? this.#host.sourceFiles.get(session.file.sourceKey, session.spec.audioFileIndex)
-        : session.file,
-      carries: session.spec.carries,
-      audioSeparate: this.servesAudioSeparately(session),
-      sessionId: session.id,
-      runToken,
-      readWindowBytes: this.#host.encodeRuns.readWindowFor(session),
-      baseUrl: this.#host.localBaseUrl
-    });
-  }
-
   /**
    * One file of an audio rendition: its playlist, its init segment or one of
    * its segments.

package/services/encode/admitted-command.js

@@ -0,0 +1,60 @@
+import { AUDIO_TRANSCODE_KBPS } from "./args.js";
+import { ffmpegSeconds, publishedStartTime, publishedGridFor } from "./run-command.js";
+import { SEGMENT_CUT_TIME_DELTA_SECONDS } from "./output/index.js";
+
+/** One held Matroska stdin, with no container seek or second input. */
+export function buildAdmittedCommand({ admittedInput, timeline, output, segmentFormat, transcodeVideo,
+  transcodeAudio, audioOnly, audioSeparate, rateControl, startIndex, endIndex, videoEncoder, segmentDurationSec }) {
+  const safeIndex = Math.max(0, Number.isInteger(startIndex) ? startIndex : 0);
+  const startSeconds = publishedStartTime(timeline, safeIndex, segmentDurationSec);
+  const grid = publishedGridFor(timeline);
+  const endSeconds = grid?.[endIndex + 1];
+  if (!(endSeconds > startSeconds)) throw new Error("An admitted run requires a complete finite output interval.");
+  const origin = admittedInput.originSeconds;
+  const relativeStart = Math.max(0, startSeconds - origin);
+  const relativeEnd = endSeconds - origin;
+  const cutTimes = grid.slice(safeIndex + 1, endIndex + 1).map(time => time - startSeconds);
+  const args = ["-hide_banner", "-nostats", "-loglevel", "error", "-progress", "pipe:1"];
+  if (transcodeVideo && Array.isArray(videoEncoder.inputArgs)) args.push(...videoEncoder.inputArgs);
+  args.push("-f", "matroska", "-i", "pipe:0", "-copyts", "-avoid_negative_ts", "disabled", "-output_ts_offset", ffmpegSeconds(origin));
+  const video = transcodeVideo ? videoEncoder.buildVideoArgs({
+    targetWidth: output.encodeWidth, targetHeight: output.encodeHeight, segmentDurationSec,
+    fps: output.outputFps, preset: output.softwarePreset ?? undefined, tonemap: output.applyTonemap === true,
+    forcedKeyframeTimes: [relativeStart, ...cutTimes.map(time => relativeStart + time)], rateControl: rateControl ?? null
+  }) : ["-c:v", "copy"];
+  if (transcodeVideo) {
+    video.push("-fps_mode:v", "passthrough", "-enc_time_base:v", "1:1000000");
+    const existing = video.indexOf("-vf");
+    const trim = `trim=start=${ffmpegSeconds(relativeStart)}:end=${ffmpegSeconds(relativeEnd)}`;
+    if (existing >= 0) {
+      // Anchor the frame cadence at the requested interval, rather than the
+      // earlier audio preroll that determined the shared stdin origin.
+      const filters = video[existing + 1].replace(/fps=(\d+)(?=,|$)/g,
+        (_match, fps) => `setpts=PTS+${ffmpegSeconds(origin)}/TB,fps=${fps}:start_time=${ffmpegSeconds(startSeconds)},settb=1/1000000,setpts=PTS-${ffmpegSeconds(origin)}/TB`);
+      video[existing + 1] = `${trim},${filters},${trim}`;
+    }
+    else video.push("-vf", trim);
+  }
+  const audio = transcodeAudio ? ["-c:a", "aac", "-ac", "2", "-b:a", `${AUDIO_TRANSCODE_KBPS}k`,
+    "-af", `atrim=start=${ffmpegSeconds(relativeStart)}:end=${ffmpegSeconds(relativeEnd)}`] : ["-c:a", "copy"];
+  if (audioOnly) args.push("-vn", "-map", "0:a:0", ...audio);
+  else if (audioSeparate) args.push("-an", "-map", "0:v:0", ...video);
+  else args.push("-map", "0:v:0", "-map", "0:a:0?", ...video, ...audio);
+  args.push("-to", ffmpegSeconds(relativeEnd), "-f", "segment");
+  if (cutTimes.length) args.push("-segment_times", cutTimes.join(","));
+  else args.push("-segment_time", ffmpegSeconds(endSeconds - startSeconds));
+  const formatArgs = segmentFormat.explicitTimesMuxerArgs?.();
+  if (!Array.isArray(formatArgs)) throw new Error("The segment format cannot publish admitted packet input.");
+  const muxOptions = formatArgs.indexOf("-segment_format_options");
+  const muxFormat = formatArgs.indexOf("-segment_format");
+  if (muxFormat >= 0 && formatArgs[muxFormat + 1] === "mp4" && muxOptions >= 0) {
+    // Millisecond movie edits cannot retain a sample-accurate AAC origin.
+    formatArgs[muxOptions + 1] += ":movie_timescale=1000000";
+  }
+  // Audio has no keyframe rounding: the video tolerance can remove several
+  // audio frames from the declared interval before the requested cut.
+  args.push("-segment_time_delta", String(audioOnly ? 0 : SEGMENT_CUT_TIME_DELTA_SECONDS), "-segment_start_number", String(safeIndex),
+    "-segment_list", "pipe:3", "-segment_list_flags", "+live", ...formatArgs,
+    segmentFormat.makingFileNameTemplate(admittedInput.runTag ?? `${safeIndex}-${admittedInput.fingerprint.slice(0, 12)}`));
+  return { args, safeIndex, startSeconds, cutTimes };
+}

package/services/encode/annex-b-input.js

@@ -0,0 +1,37 @@
+/** Convert borrowed Annex B payload slices to Matroska AVC length framing. */
+export function avcPacketSlices(slices) {
+  if (!Array.isArray(slices) || slices.some(slice => !Buffer.isBuffer(slice))) throw new TypeError("AVC packet slices must be buffers.");
+  const units = [];
+  let position = 0, zeroes = 0, start = null;
+  for (const slice of slices) {
+    for (const byte of slice) {
+      if (byte === 1 && zeroes >= 2) {
+        const end = position - zeroes;
+        if (start !== null) {
+          if (end <= start) throw new Error("AVC Annex B contains an empty NAL unit.");
+          units.push([start, end]);
+        } else if (end !== 0) throw new Error("AVC Annex B precedes its first start code with data.");
+        start = position + 1;
+      }
+      zeroes = byte === 0 ? zeroes + 1 : 0;
+      position++;
+    }
+  }
+  if (start === null || position - zeroes <= start) throw new Error("AVC Annex B has no complete NAL unit.");
+  units.push([start, position - zeroes]);
+  const result = [];
+  for (const [from, to] of units) {
+    const length = to - from;
+    if (length > 0xffffffff) throw new Error("AVC NAL unit exceeds its length declaration.");
+    const header = Buffer.alloc(4);
+    header.writeUInt32BE(length);
+    result.push(header);
+    let offset = 0;
+    for (const slice of slices) {
+      if (offset < to && offset + slice.length > from) result.push(slice.subarray(Math.max(0, from - offset), Math.min(slice.length, to - offset)));
+      offset += slice.length;
+      if (offset >= to) break;
+    }
+  }
+  return result;
+}

package/services/encode/bit-payload.js

@@ -0,0 +1,29 @@
+/** Normalize an admitted byte-sized payload that starts between source bytes. */
+export function bitPayloadSlices(slices, bitOffset, bitLength) {
+  const total = slices.reduce((sum, slice) => sum + slice.length, 0);
+  if (!Number.isSafeInteger(bitOffset) || bitOffset < 0 || !Number.isSafeInteger(bitLength) ||
+      bitLength <= 0 || bitLength % 8 !== 0 || bitOffset + bitLength > total * 8) throw new Error("Admitted packet bit payload is incomplete.");
+  const first = Math.floor(bitOffset / 8), length = bitLength / 8, shift = bitOffset & 7;
+  if (!shift) {
+    let offset = 0;
+    const result = [];
+    for (const slice of slices) {
+      if (offset < first + length && offset + slice.length > first) result.push(slice.subarray(Math.max(0, first - offset), Math.min(slice.length, first + length - offset)));
+      offset += slice.length;
+    }
+    return result;
+  }
+  const result = Buffer.alloc(length);
+  let sliceIndex = 0, base = 0;
+  const byteAt = position => {
+    while (base + slices[sliceIndex].length <= position) { base += slices[sliceIndex].length; sliceIndex++; }
+    return slices[sliceIndex][position - base];
+  };
+  let before = byteAt(first);
+  for (let offset = 0; offset < length; offset++) {
+    const after = byteAt(first + offset + 1);
+    result[offset] = ((before << shift) | (after >> (8 - shift))) & 255;
+    before = after;
+  }
+  return [result];
+}

package/services/encode/output/OutputCatalog.js

@@ -401,7 +401,7 @@ export class OutputCatalog {
         // The probe's own reading of the video stream, which is known from the
         // moment the session exists and covers the gap before the torrent has
         // reported a length.
-        streamBitsPerSecond: (Number(session.file?.decode?.megabitsPerSecond) || 0) * 1_000_000,
+        streamBitsPerSecond: (Number(session.file?.megabitsPerSecond) || 0) * 1_000_000,
         largest: this.largestPieceOf(session.outputKey ?? ""),
         boundaries: session.timeline?.published ?? session.timeline?.boundaries ?? null,
         producedHeight: this.producedHeightOf(session),

package/services/encode/output/Timeline.js

@@ -118,6 +118,17 @@ export class Timeline {
     return this.sourceTimes[Math.min(index, this.sourceTimes.length - 1)] ?? null;
   }
 
+  /** Address source packets with exact cuts, translated only for another file. */
+  sourceInterval(fromIndex, toIndex, sourceStartTime = 0) {
+    const base = this.sourceStartOf(0);
+    const from = this.sourceStartOf(fromIndex), to = this.sourceStartOf(toIndex + 1);
+    const shift = sourceStartTime - (base ?? 0);
+    return {
+      from: from === null ? this.publishedStartOf(fromIndex) + sourceStartTime : from + shift,
+      to: to === null ? this.publishedStartOf(toIndex + 1) + sourceStartTime : to + shift
+    };
+  }
+
   /**
    * Where segment `index` begins on the live table — where a run cutting now
    * will really put it.

package/services/encode/pcm-normalization.js

@@ -0,0 +1,30 @@
+/** PCM variants that Matroska requires in a different byte representation. */
+export function pcmNormalization(track) {
+  if (track.matroskaCodecId) return null;
+  const format = /^pcm_([suf])(8|16|24|32|64)(le|be)?$/.exec(track.codecId ?? "");
+  if (!format) return null;
+  const [, kind, bits, endian] = format;
+  const width = Number(bits) / 8;
+  const swap = kind === "f" && endian === "be";
+  const flipSign = (kind === "s" && width === 1) || (kind === "u" && width > 1);
+  return swap || flipSign ? { width, swap, flipSign, little: endian === "le" } : null;
+}
+
+/** Convert owned output bytes without modifying any shared source slice. */
+export function normalizePcmSlices(slices, format) {
+  const length = slices.reduce((sum, slice) => sum + slice.length, 0);
+  if (length % format.width) throw new Error("PCM packet ends inside a sample.");
+  const output = Buffer.alloc(length);
+  let source = 0;
+  for (const slice of slices) {
+    for (const byte of slice) {
+      const sample = Math.floor(source / format.width) * format.width;
+      const within = source % format.width;
+      const target = sample + (format.swap ? format.width - 1 - within : within);
+      const signByte = format.little ? format.width - 1 : 0;
+      output[target] = format.flipSign && within === signByte ? byte ^ 0x80 : byte;
+      source++;
+    }
+  }
+  return output;
+}

package/services/encode/piece-completeness.js

@@ -40,11 +40,15 @@ export function cutOf(timeline, index) {
  * @param {number | undefined} cutSeconds - From {@link cutOf}.
  * @returns {{ whole: boolean, throughSeconds: number | null }}
  */
-export function judgePiece(format, ranges, cutSeconds) {
+export function judgePiece(format, ranges, cutSeconds, interval) {
   const throughSeconds = format.producedThroughSeconds?.(ranges) ?? null;
   if (throughSeconds === null) {
     return { whole: false, throughSeconds };
   }
+  if (interval) {
+    const reason = intervalFailure(ranges, interval);
+    return reason ? { whole: false, throughSeconds, reason } : { whole: true, throughSeconds };
+  }
   const cutMicros = ranges?.production?.cutMicros ??
     (Number.isFinite(cutSeconds) ? BigInt(Math.round(cutSeconds * 1_000_000)) : null);
   if (cutMicros !== null && ranges?.tracks?.length) {
@@ -72,6 +76,7 @@ export function judgePiece(format, ranges, cutSeconds) {
     return { whole, throughSeconds };
   }
   if (cutMicros !== null && throughSeconds < Number(cutMicros) / 1_000_000) {
+
     return { whole: false, throughSeconds };
   }
   return { whole: true, throughSeconds };
@@ -102,3 +107,51 @@ export function originOf(ranges, endMicros, kind) {
   return ticks >= 0n ? (2n * ticks + track.timescale) / (2n * track.timescale) :
     -((-2n * ticks + track.timescale) / (2n * track.timescale));
 }
+
+/** Compare adjacent production ranges in their declared track clocks. */
+export function judgeNeighbors(left, right) {
+  if (!left?.tracks?.length || !right?.tracks?.length) return { whole: false, reason: "neighbor-tracks-are-missing" };
+  for (const track of right.tracks) {
+    if (!left.tracks.some(previous => previous.kind === track.kind)) return { whole: false, reason: `neighbor-missing-${track.kind}` };
+  }
+  for (const track of left?.tracks ?? []) {
+    const next = right?.tracks?.find(candidate => candidate.kind === track.kind);
+    if (!next?.ranges?.length || !track.ranges?.length) return { whole: false, reason: `neighbor-missing-${track.kind}` };
+    if (!(track.timescale > 0n) || !(next.timescale > 0n)) return { whole: false, reason: "neighbor-clock-is-invalid" };
+    const end = track.ranges.at(-1), start = next.ranges[0];
+    const difference = start.start * track.timescale - end.end * next.timescale;
+    const leftFrame = (track.productionFrame ?? end.frame) * next.timescale;
+    const rightFrame = (next.productionFrame ?? start.frame) * track.timescale;
+    if (!(leftFrame > 0n) || !(rightFrame > 0n)) return { whole: false, reason: "neighbor-frame-is-invalid" };
+    const allowance = leftFrame > rightFrame ? leftFrame : rightFrame;
+    if (difference > allowance || difference < -allowance) return { whole: false, reason: `neighbor-discontinuity-${track.kind}` };
+  }
+  return { whole: true };
+}
+
+/** Every required track must cover the interval with at most one-frame error. */
+function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {} }) {
+  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);
+    if (!track?.ranges?.length || !(track.timescale > 0n)) return `segment-missing-${kind}`;
+    const start = BigInt(Math.round(from * Number(track.timescale)));
+    const through = Number.isFinite(sourceEnds[kind]) ? Math.min(to, sourceEnds[kind]) : to;
+    if (!(through > from)) return `segment-interval-is-empty-${kind}`;
+    const end = BigInt(Math.round(through * Number(track.timescale)));
+    const first = track.ranges[0];
+    const frame = track.productionFrame ?? first.frame;
+    if (first.start > start + frame || first.start < start - frame) return `segment-start-outside-interval-${kind}`;
+    // The first sample's cadence already bounds the interval start. A shorter
+    // final sample must not replace that bound when this range is traversed.
+    let reached = first.start;
+    for (const range of track.ranges) {
+      if (!(range.frame > 0n) || range.end <= range.start || range.start > reached + range.frame) return `segment-gap-within-interval-${kind}`;
+      if (range.end > reached) reached = range.end;
+    }
+    const finalFrame = track.productionFrame ?? track.ranges.at(-1).frame;
+    if (reached < end - finalFrame || reached > end + finalFrame) return `segment-end-outside-interval-${kind}`;
+  }
+  return null;
+
+}

package/services/encode/quality/HostLoad.js

@@ -15,19 +15,6 @@ import { medianOf, movedBeyondScatter, READINGS_KEPT, scatterOf } from "../learn
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode-run-state.js";
 import { SourceFiles } from "../../media/SourceFile.js";
 
-// How far ahead of its own read head a reader asks the swarm for, expressed in
-// seconds of PLAYBACK. The torrent thread can only think in bytes, and a fixed
-// byte window is wrong at both ends of the range: 32 MB is half a minute of a
-// 1080p film and about four seconds of a disc remux. Duration and file size are
-// both known here, so the window is sized where the knowledge is and sent down
-// on the ffmpeg input URL.
-const READ_WINDOW_SECONDS = 30;
-// Bounds, so a wrong or unusual byte rate cannot ask for something absurd. The
-// floor keeps a few pieces in flight on a low-bitrate file; the ceiling keeps
-// one reader from claiming more than a fraction of the piece store.
-const READ_WINDOW_MIN_BYTES = 16 * 1024 * 1024;
-const READ_WINDOW_MAX_BYTES = 96 * 1024 * 1024;
-
 export class HostLoad {
   /** What this reads and asks of the rest of the proxy, and nothing else. @type {object} */
   #host;
@@ -42,8 +29,7 @@ export class HostLoad {
   #idleLoadSample = null;
 
   /**
-   * How long each file is in bytes, from the stats call the read window already
-   * makes. The torrent moves the CONTAINER, so this — not the video stream's
+   * How long each file is in bytes, from its declared source statistics. The torrent moves the CONTAINER, so this — not the video stream's
    * bitrate — is what its work should be priced against.
    *
    * @type {Map<string, number>}
@@ -96,67 +82,18 @@ export class HostLoad {
     this.#host = host;
   }
 
-  /**
-   * The read-ahead window for a file, in bytes, sized from how many seconds of
-   * playback it holds.
-   *
-   * @param {string} sourceKey
-   * @param {number} fileIndex
-   * @param {number} durationSeconds
-   * @returns {Promise<number>} Zero when the byte rate cannot be established,
-   *   which leaves the reader on its own default.
-   */
-  async readWindowBytesFor(sourceKey, fileIndex, durationSeconds) {
-    // The length read here is also what prices the torrent's own work for this
-    // file, so it is remembered rather than discarded.
-
-    if (!this.#host.getSourceStats || !Number.isFinite(durationSeconds) || durationSeconds <= 0) {
-      return 0;
-    }
-    let fileLength = 0;
+  /** Read the declared source length for pricing; this does not request file bytes. */
+  async readFileLength(sourceKey, fileIndex) {
+    if (!this.#host.getSourceStats) return null;
     try {
       const stats = await this.#host.getSourceStats(sourceKey, fileIndex);
-      fileLength = Number(stats?.fileLength);
+      const length = Number(stats?.fileLength);
+      if (!Number.isFinite(length) || length <= 0) return null;
+      this.fileLengthByKey.set(SourceFiles.keyFor(sourceKey, fileIndex), length);
+      return length;
     } catch {
-      return 0;
-    }
-    if (!Number.isFinite(fileLength) || fileLength <= 0) {
-      return 0;
-    }
-    this.fileLengthByKey.set(SourceFiles.keyFor(sourceKey, fileIndex), fileLength);
-    const bytesPerSecond = fileLength / durationSeconds;
-    // Shared between the readers this file already has. The window is stated in
-    // seconds of playback and the store's memory is one budget for the whole
-    // torrent, so N readers asking for thirty seconds each ask for N times what
-    // was provided for — and on 2026-08-15 that is exactly what happened: a
-    // viewer with a picture and an audio track had every resident piece held at
-    // once, a read ended with zero bytes, and every encoder on the file took
-    // that for the end of it.
-    //
-    // Dividing keeps the promise the budget was written against. It is not the
-    // sliding window of roadmap item 8 — pieces still leave only by the store's
-    // own eviction — but it removes the multiplication that broke it.
-    const readers = Math.max(1, this.#readersOn(sourceKey, fileIndex));
-    const wanted = Math.round((bytesPerSecond * READ_WINDOW_SECONDS) / readers);
-    return Math.min(READ_WINDOW_MAX_BYTES, Math.max(READ_WINDOW_MIN_BYTES, wanted));
-  }
-
-  /**
-   * How many live sessions read this file: the picture, any rung being warmed
-   * beside it, and any audio track published on its own.
-   *
-   * @param {string} sourceKey
-   * @param {number} fileIndex
-   * @returns {number}
-   */
-  #readersOn(sourceKey, fileIndex) {
-    let readers = 0;
-    for (const session of this.#host.outputs.values()) {
-      if (session?.file.sourceKey === sourceKey && session.file.fileIndex === fileIndex) {
-        readers += 1;
-      }
+      return null;
     }
-    return readers;
   }
 
   /**
@@ -172,16 +109,23 @@ export class HostLoad {
    * is the torrent's.
    */
   async #learnTorrentCost() {
+    const activityBefore = this.#host.readMetadataActivity?.();
+    const bytes = await this.#torrentBytesMoved();
     const now = {
       takenAt: Date.now(),
       cpuSeconds: this.#host.readProxyCpuSeconds(),
-      bytes: await this.#torrentBytesMoved()
+      bytes,
+      metadata: this.#host.readMetadataActivity?.()
     };
     const previous = this.#idleLoadSample;
     this.#idleLoadSample = now;
     if (previous === null || now.bytes === null || previous.bytes === null) {
       return;
     }
+    // Process CPU includes metadata parsing. Keep the sample as a baseline,
+    // but never attribute an interval containing that work to torrent bytes.
+    if (activityBefore?.active || now.metadata?.active || previous.metadata?.active ||
+      activityBefore?.epoch !== now.metadata?.epoch || previous.metadata?.epoch !== now.metadata?.epoch) return;
     const elapsedSec = (now.takenAt - previous.takenAt) / 1000;
     const megabytes = (now.bytes - previous.bytes) / 1e6;
     // Divided by the cores, because `process.cpuUsage()` adds up every thread
@@ -260,6 +204,8 @@ export class HostLoad {
         // client, whichever of its files are being read. Kept per source and
         // divided among the files being watched, so two episodes of one pack
         // do not each charge the machine for the whole download.
+        const length = Number(stats?.fileLength);
+        if (Number.isFinite(length) && length > 0) this.fileLengthByKey.set(key, length);
         const rate = Number(stats?.downloadSpeed);
         if (Number.isFinite(rate) && rate >= 0) {
           measured.set(source.sourceKey, rate);

package/services/encode/quality/QualityOffer.js

@@ -409,7 +409,7 @@ export class QualityOffer {
     return videoLoadForFrame({
       sourceHeight,
       copiesAtSource: !base.spec.transcodesVideo,
-      sourceMbps: base.file.decode?.megabitsPerSecond ?? null,
+      sourceMbps: base.file.megabitsPerSecond,
       encoderKind
     }, frame);
   }