@torrent-tv/proxy 2.96.1 → 2.96.3

package/package.json

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

package/services/encode/EncodeRun.js

@@ -285,6 +285,15 @@ export class EncodeRun {
     this.indexOfName = typeof indexOfName === "function" ? indexOfName : () => null;
     /** The last thing ffmpeg said on stderr, which is what a failure is explained by. */
     this.lastError = "";
+    /**
+     * How far after the start it was asked for this run's segment muxer counts
+     * its cuts from, in seconds. The muxer measures every cut from its first
+     * reference packet, and a copied stream's first packet lies up to one frame
+     * after the requested start, so every piece of the run ends that much later
+     * than its cut. `null` until the run's first piece has closed
+     * (`piece-completeness.js`, `cutShiftOf`).
+     */
+    this.cutShiftSeconds = null;
     // EXISTING IS RUNNING. There is no moment at which a built run is not yet a
     // process, so there is no second act for two owners to perform.
     this.#begin(because);

package/services/encode/EncodeRuns.js

@@ -17,7 +17,7 @@ import { computeOutputDimensions } from "./args.js";
 import { buildAdmittedCommand } from "./admitted-command.js";
 import { buildOriginalCommand } from "./source-command.js";
 import { writeAdmittedInput } from "./AdmittedInput.js";
-import { cutOf, judgeNeighbors, judgePiece } from "./piece-completeness.js";
+import { cutOf, cutShiftOf, judgeNeighbors, judgePiece } from "./piece-completeness.js";
 import { presentationSegment } from "./segment-formats/presentation-segment.js";
 import { InputFailures, failedAdmittedInput } from "./InputFailures.js";
 
@@ -351,9 +351,13 @@ export class EncodeRuns {
    * @param {HlsSession} session
    * @param {string} name - The working name the encoder closed it under.
    * @param {number} index
+   * @param {object | false} [admitted] - The original input the run reads, when it reads one.
+   * @param {Buffer | null} [bytes]
+   * @param {EncodeRun | null} [run] - The run that closed it, which keeps where its muxer counts cuts from.
+   * @param {{ endMicros: bigint } | null} [timing] - The piece's end in the muxer's clock, from its segment list.
    * @returns {object | null | false}
    */
-  #wholeClosedPiece(session, name, index, admitted = false, bytes = null) {
+  #wholeClosedPiece(session, name, index, admitted = false, bytes = null, run = null, timing = null) {
 
     const format = session.segmentFormat;
     if (!format?.readMediaRanges || !Number.isInteger(index) || index < 0) {
@@ -371,6 +375,16 @@ export class EncodeRuns {
             .map(input => [input.track.type === "video" ? "vide" : "soun", input.sourceEndSeconds])) } : {}),
         requiredKinds: [session.spec.carries !== "audio-only" ? "vide" : null,
           session.spec.audio && !this.#host.servesAudioSeparately(session) ? "soun" : null].filter(Boolean) } : undefined;
+      if (run) {
+        // Where the muxer counts this run's cuts from is known once its first
+        // piece has closed, and holds for every piece after it. It is a fact
+        // of each piece the run makes, so it travels with the piece.
+        if (run.cutShiftSeconds === null && index === run.from) {
+          run.cutShiftSeconds = cutShiftOf(mediaRanges, grid?.[run.from], session.spec.carries !== "audio-only" ? "vide" : "soun",
+            timing?.endMicros ?? null);
+        }
+        if (mediaRanges && run.cutShiftSeconds !== null) mediaRanges.cutShiftSeconds = run.cutShiftSeconds;
+      }
       const { whole, throughSeconds, reason } = judgePiece(format, mediaRanges, cut, interval);
       if (!whole) {
         this.#host.logger.warn(
@@ -990,7 +1004,7 @@ export class EncodeRuns {
       // Why this encoder exists, recorded with its argument list. It used to be
       // handed to a separate `start` call; there is no separate call now.
       because,
-      onClosed: (name, following) => {
+      onClosed: (name, following, timing) => {
 
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
@@ -1012,7 +1026,7 @@ export class EncodeRuns {
             throw error;
           }
         }
-        const mediaRanges = this.#wholeClosedPiece(session, name, index, admittedInput, bytes);
+        const mediaRanges = this.#wholeClosedPiece(session, name, index, admittedInput, bytes, run, timing);
         if (mediaRanges === false) throw Object.assign(new Error(`Closed piece #${index} has incomplete media.`),
           { code: "ERR_INCOMPLETE_MEDIA" });
         const published = this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat, { mediaRanges, bytes });

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/piece-completeness.js

@@ -30,82 +30,81 @@ export function cutOf(timeline, index) {
 }
 
 /**
- * Track positions read from empty edits retain their movie-tick uncertainty.
- * Fresh closures also carry the muxer's packet end and its actual cut, so a
- * restarted run is judged on its own reference clock. Neither allowance is a
- * browser's frame-join rule.
+ * Whether a closed piece holds its stretch of film. With `interval` (a run
+ * reading the original file, which states the stretch each piece covers) the
+ * piece's tracks are compared with that stretch; otherwise with the cut.
+ *
+ * Both are compared on the clock the producing run's muxer cut by: moved by
+ * `ranges.cutShiftSeconds`, which the run states for every piece it closes
+ * ({@link cutShiftOf}) and which travels with the piece. A piece whose run is
+ * not known — one adopted from an earlier life of the process — has none, and
+ * is compared with the cut as published.
  *
  * @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}.
- * @returns {{ whole: boolean, throughSeconds: number | null }}
+ * @param {{ from: number, to: number, requiredKinds: string[], sourceEnds?: object }} [interval]
+ * @returns {{ whole: boolean, throughSeconds: number | null, reason?: string }}
  */
 export function judgePiece(format, ranges, cutSeconds, interval) {
   const throughSeconds = format.producedThroughSeconds?.(ranges) ?? null;
   if (throughSeconds === null) {
     return { whole: false, throughSeconds };
   }
+  const shift = Number.isFinite(ranges?.cutShiftSeconds) ? ranges.cutShiftSeconds : 0;
   if (interval) {
-    const reason = intervalFailure(ranges, interval);
+    const reason = intervalFailure(ranges, { ...interval, shift });
     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);
+  const cutMicros = Number.isFinite(cutSeconds) ? BigInt(Math.round((cutSeconds + shift) * 1_000_000)) : null;
   if (cutMicros !== null && ranges?.tracks?.length) {
-    const tracks = ranges.tracks;
-    const production = ranges.production;
-    const reference = production ? tracks.find(({ kind }) => kind === production.kind) : null;
-    const referenceEnd = reference?.ranges.at(-1)?.end;
-    const whole = tracks.every((track) => {
-      const { timescale, ranges: held, positionErrorTicks = 0n } = track;
+    const whole = ranges.tracks.every(({ timescale, ranges: held, positionErrorTicks = 0n }) => {
       const end = held.at(-1)?.end;
-      if (end === undefined) return false;
-      if (referenceEnd !== undefined) {
-        if (track === reference) return 2n * production.endMicros + 1n >= 2n * cutMicros;
-        // The segment muxer's CSV reports packet time before movenc truncates
-        // the empty edit. Compare on that clock, including another track's
-        // relative end and the precision of both written track positions.
-        const difference = (end + positionErrorTicks) * reference.timescale -
-          (referenceEnd - (reference.positionErrorTicks ?? 0n)) * timescale;
-        const denominator = timescale * reference.timescale;
-        return 2n * difference * 1_000_000n +
-          (2n * production.endMicros + 1n) * denominator >= 2n * cutMicros * denominator;
-      }
-      return (end + positionErrorTicks) * 1_000_000n >= cutMicros * timescale;
+      return end !== undefined && (end + positionErrorTicks) * 1_000_000n >= cutMicros * timescale;
     });
     return { whole, throughSeconds };
   }
   if (cutMicros !== null && throughSeconds < Number(cutMicros) / 1_000_000) {
-
     return { whole: false, throughSeconds };
   }
   return { whole: true, throughSeconds };
 }
 
-/** The muxer cuts relative to its first reference packet, not the requested seek. */
-export function productionOf(timing, cutTimes, relativeIndex, kind) {
-  if (!timing || timing.originMicros === null || !Number.isFinite(cutTimes?.[relativeIndex])) return null;
-  return {
-    kind,
-    endMicros: timing.endMicros,
-    cutMicros: timing.originMicros + BigInt(Math.round(cutTimes[relativeIndex] * 1_000_000)) -
-      BigInt(Math.round(SEGMENT_CUT_TIME_DELTA_SECONDS * 1_000_000))
-  };
-}
-
 /**
- * The first CSV entry has start_time = 0 even after a seek (segment.c).
- * Recover its reference packet's PTS from the reported end minus the exact
- * sample span. The edit-list offset cancels, including its lost precision.
+ * How far after its requested start a run's segment muxer counts its cuts
+ * from, read from the run's FIRST piece, or `null` when that piece does not
+ * start within one frame of the start.
+ *
+ * With `endMicros`, the end of the piece in the muxer's own clock as its
+ * segment list states it, the first packet is that end less the span of the
+ * piece's samples: exact, because the span is a sum of sample durations and
+ * the muxer's clock needs no track position. Without it, the first sample's
+ * position is read, which the piece states only to within its position error.
+ *
+ * The muxer measures every cut time from its first packet of the reference
+ * stream, not from the start it was asked for (measured on ffmpeg 8.1.2,
+ * 2026-10-09: AAC copied from Matroska, asked to start at 10.385 s with its
+ * first packet at 10.403 s and a cut at 10.386 s from the start, closed the
+ * piece at 20.805 s — the first packet at or after 10.403 + 10.386). A copied
+ * stream cannot start between its packets, so its first packet lies up to one
+ * frame after the requested start, and every cut of the run moves by as much.
+ *
+ * @param {object} ranges - The first piece's media intervals.
+ * @param {number} startSeconds - Where the run was asked to start.
+ * @param {string} kind - The reference track: `vide` when the output carries a picture, else `soun`.
+ * @returns {number | null}
  */
-export function originOf(ranges, endMicros, kind) {
-  const track = ranges?.tracks?.find(track => track.kind === kind);
-  if (track?.firstSampleStart === undefined || !track.ranges.length) return null;
-  const ticks = endMicros * track.timescale -
-    (track.ranges.at(-1).end - track.firstSampleStart) * 1_000_000n;
-  // CSV rounds to microseconds; rescale with the muxer's nearest rounding.
-  return ticks >= 0n ? (2n * ticks + track.timescale) / (2n * track.timescale) :
-    -((-2n * ticks + track.timescale) / (2n * track.timescale));
+export function cutShiftOf(ranges, startSeconds, kind, endMicros = null) {
+  const track = ranges?.tracks?.find((candidate) => candidate.kind === kind);
+  const first = track?.ranges?.[0];
+  if (!first || !(track.timescale > 0n) || !Number.isFinite(startSeconds)) return null;
+  const timescale = Number(track.timescale);
+  const firstSeconds = typeof endMicros === "bigint" && track.firstSampleStart !== undefined
+    ? Number(endMicros) / 1_000_000 - Number(track.ranges.at(-1).end - track.firstSampleStart) / timescale
+    : Number(first.start) / timescale;
+  const shift = firstSeconds - startSeconds;
+  const allowance = Number((track.productionFrame ?? first.frame) + (track.positionErrorTicks ?? 0n)) / timescale;
+  return Math.abs(shift) <= allowance ? shift : null;
 }
 
 /** Compare adjacent production ranges in their declared track clocks. */
@@ -129,15 +128,19 @@ export function judgeNeighbors(left, right) {
   return { whole: true };
 }
 
-/** Every required track must cover the interval with at most one-frame error. */
-function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {} }) {
+/**
+ * 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.
+ */
+function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {}, shift = 0 }) {
   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 start = BigInt(Math.round((from + shift) * Number(track.timescale)));
+    const through = Number.isFinite(sourceEnds[kind]) ? Math.min(to + shift, sourceEnds[kind]) : to + shift;
+    if (!(through > from + shift)) 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;

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