@torrent-tv/proxy 2.80.5 → 2.80.6

package/services/encode/EncodeRun.js

@@ -199,6 +199,10 @@ export class EncodeRun {
    *   kept so a failure can quote what produced it.
    * @param {boolean} [params.usesExplicitCuts] - Whether this run cuts at times
    *   it was given, which decides how a segment is judged finished.
+   * @param {(name: string) => number | null} [params.indexOfName] - The number
+   *   a closed piece's name carries. How a piece is named belongs to the format
+   *   that writes it, so it arrives as a plain function rather than this class
+   *   knowing any naming.
    */
   constructor({
     address,
@@ -215,7 +219,8 @@ export class EncodeRun {
     lastSegmentIndex,
     inputUnavailable,
     argsDescribed = "",
-    usesExplicitCuts = false
+    usesExplicitCuts = false,
+    indexOfName
   }) {
     this.address = address;
     this.encoder = encoder;
@@ -234,6 +239,7 @@ export class EncodeRun {
     this.inputUnavailable = typeof inputUnavailable === "function" ? inputUnavailable : () => false;
     this.argsDescribed = argsDescribed;
     this.usesExplicitCuts = usesExplicitCuts === true;
+    this.indexOfName = typeof indexOfName === "function" ? indexOfName : () => null;
     /** The last thing ffmpeg said on stderr, which is what a failure is explained by. */
     this.lastError = "";
   }
@@ -456,6 +462,18 @@ export class EncodeRun {
       if (!this.#stopping) {
         this.#provenName = name;
       }
+      // WHAT THIS RUN HAS MADE IS THIS RUN'S OWN FACT, and this channel is where
+      // it learns it. It used to be told from outside, by whoever listed the
+      // output directory — which every run of an output shares — so a run
+      // inherited every number any other run had ever left there. Field
+      // 2026-09-06: a run beginning at the piece for 3:39 reported "reached #20
+      // (483 segment(s))", having produced none of them, and its head therefore
+      // described somebody else's work. Both the claim it holds and the cleanup
+      // after it read that head.
+      const index = this.indexOfName(name);
+      if (Number.isInteger(index)) {
+        this.noteProduced(index);
+      }
       this.onClosed(name);
     }
   }

package/services/encode/SegmentStore.js

@@ -98,6 +98,10 @@ export class SegmentStore {
    */
   #closed = new Map();
 
+  /** Pieces already reported as taken on the successor rule, so one is said
+   * once. @type {Map<string, Set<number>>} */
+  #unreportedSaid = new Map();
+
   /** @type {{ info: Function, warn: Function }} */
   #logger;
 
@@ -308,7 +312,55 @@ export class SegmentStore {
     if (this.#closed.get(key)?.has(index)) {
       return true;
     }
-    return this.refresh(key).byNumber.has(index + 1);
+    const bySuccessor = this.refresh(key).byNumber.has(index + 1);
+    if (bySuccessor) {
+      this.#noteUnreported(key, index);
+    }
+    return bySuccessor;
+  }
+
+  /**
+   * A piece taken as finished because the NEXT one exists, with nothing from a
+   * run to say so.
+   *
+   * The successor rule is for what this process did not watch being written —
+   * pieces from a previous life of it. It is also the one way an unfinished
+   * piece can be served: a file that stops short still has a successor if
+   * anything wrote one, and then its name promises a whole span while it holds
+   * a fraction. Field 2026-09-06: 110 698 bytes served under a name whose
+   * neighbours are 12 MB, 40 ms of film where the playlist declared 10.4 s, and
+   * the player jumped the hole it left.
+   *
+   * That cannot arise from two encoders any more — their stretches no longer
+   * overlap — so what is left is a piece from a process that died without
+   * clearing up. Said once per piece, with its size, so a return of it is
+   * visible rather than inferred.
+   *
+   * @param {string} key
+   * @param {number} index
+   */
+  #noteUnreported(key, index) {
+    let said = this.#unreportedSaid.get(key);
+    if (!said) {
+      said = new Set();
+      this.#unreportedSaid.set(key, said);
+    }
+    if (said.has(index)) {
+      return;
+    }
+    said.add(index);
+    let bytes = -1;
+    try {
+      bytes = statSync(this.pathOf(key, index)).size;
+    } catch {
+      // Gone between the listing and this: nothing to report about it.
+      return;
+    }
+    this.#logger?.info?.(
+      `segment store: #${index} of ${key.slice(0, 60)} is taken as finished because ` +
+      `#${index + 1} exists — no run reported it (${bytes} bytes). Expected only for ` +
+      "pieces left by a previous life of this process."
+    );
   }
 
   /**

package/services/encode/open-piece.js

@@ -65,7 +65,28 @@ export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeU
   // belong to a run that is still going, and removing it would take away a
   // piece somebody is producing.
   const from = Number.isInteger(within?.from) ? within.from : 0;
-  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : Number.MAX_SAFE_INTEGER;
+  // THE RUN'S OWN REACH, which is a fact it holds and needs nothing measured.
+  //
+  // A run cannot have opened a file above the one just past the last it named:
+  // ffmpeg names a piece when it closes it and opens the next, so the open piece
+  // is at most `proven + 1`, and where it named nothing at all the open one is
+  // the first it was given.
+  //
+  // Used only where no end was declared — `to` below `from`, which is how "to
+  // the end of the track" is written everywhere here. Such a run had no bound at
+  // all: the search covered the whole directory and took the highest-numbered
+  // file in it. Every run of an output writes into that one
+  // directory, so what it took was a piece a LIVE run had just finished. Field
+  // 2026-09-06: the piece holding 2:47-2:57 went that way, its number is spent
+  // for good because names only grow, and the picture stood still for 647 s.
+  const provenIndex = typeof provenName === "string" && segmentFormat.isSegmentFileName(provenName)
+    ? segmentFormat.segmentIndexFromName(provenName)
+    : null;
+  const reach = Number.isInteger(provenIndex) && provenIndex >= from ? provenIndex + 1 : from;
+  // The declared end is the bound wherever there is one. The run's own reach is
+  // the bound of LAST RESORT, for a run given none: before it, such a run had no
+  // bound at all and the search covered the whole directory.
+  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : reach;
   let highest = null;
   try {
     for (const name of await readdir(runDirPath)) {

package/services/encode/run-command.js

@@ -208,7 +208,17 @@ export function nearestKeyframeAtOrBefore(keyframeTimes, target) {
 export function seekLandingOffsetFor(material, keyframe) {
   // A re-encode trims to the requested time itself, so it needs no help and
   // must not be pushed past what it was asked for.
-  if (material?.transcodeVideo === true) {
+  //
+  // AN OUTPUT CARRYING ONLY SOUND IS SUCH A RE-ENCODE, and asking about the
+  // picture missed it: the flag says whether the PICTURE is re-encoded, and an
+  // output with no picture answers no. So the whole offset was added to the
+  // soundtrack's own seek, and the sound then played 130 ms ahead of the picture
+  // from every restart onward — reported by the viewer 2026-09-06 as lips out of
+  // step with the voice from two minutes in, and measured: both outputs were
+  // repositioned to the same boundary and both given `-ss 166.963435`, after
+  // which the copied picture landed on the keyframe at 166.833 while the
+  // re-encoded sound began where it was asked.
+  if (material?.transcodeVideo === true || material?.audioOnly === true) {
     return 0;
   }
   // A grid whose times are approximate needs that error added on top, or a name
@@ -504,7 +514,7 @@ export function buildRunCommand({
   if (snappedKeyframe !== null) {
     const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
     if (snappedKeyframe > 0) {
-      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ transcodeVideo, file }, snappedKeyframe)));
+      args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor({ audioOnly, transcodeVideo, file }, snappedKeyframe)));
     }
     args.push("-i", inputUrl);
     // The coarse landing, not the exact target: the residual below is discarded

package/services/hls-session-manager.js

@@ -23,7 +23,6 @@ import { speedFromReadings } from "./encoder-readings.js";
 import { availableShareFrom } from "./available-share.js";
 import { contentionPenalty } from "./contention.js";
 import { minimumBufferFrom } from "./supply-margin.js";
-import { mapForViewer } from "./priority/PriorityMap.js";
 import { PriorityOrchestrator } from "./priority/PriorityOrchestrator.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "./torrent-cost.js";
 import { medianOf, movedBeyondScatter, scatterOf } from "./learned-median.js";
@@ -556,12 +555,6 @@ const SEGMENT_STORE_IDLE_MS = 6 * 60 * 60 * 1000;
 const SEGMENT_STORE_FREE_SHARE = 0.25;
 /** What the store may hold where the free space cannot be read at all. */
 const SEGMENT_STORE_FALLBACK_BYTES = 2 * 1024 * 1024 * 1024;
-/**
- * What it costs to stop an encoder and start another where the material is
- * missing. Measured on the addon host 2026-09-04: a spawn with its input open
- * is 0.12 s there, 0.5-0.6 s on a developer's desktop.
- */
-const RUN_RESTART_COST_SEC = 0.12;
 const DEFAULT_STARTUP_WAIT_MS = 5_000;
 // Realtime budget — runtime downswitch (software encoder only). Periodically
 // check each active software-transcode session's ffmpeg `speed`; when it stays
@@ -1475,6 +1468,7 @@ export class HlsSessionManager {
     // could not be measured, and then nothing is corrected — the alternative
     // is inventing a penalty, which is the same fault as inventing a fill rate.
     contentionPenalties = null,
+    copySpeedX = null,
     tonemapSupported = false,
     getCachedMediaInfo = null,
     getCachedAudioTracks = null,
@@ -1529,6 +1523,10 @@ export class HlsSessionManager {
     this.getSourceStats = typeof getSourceStats === "function" ? getSourceStats : null;
     this.setPriorityMap = typeof setPriorityMap === "function" ? setPriorityMap : null;
     this.contentionPenalties = contentionPenalties instanceof Map ? contentionPenalties : null;
+    // Seconds of film per second when the picture is COPIED, measured at
+    // startup. Nothing else prices that branch: the other benchmarks measure
+    // encoding and decoding, and a copy does neither.
+    this.copySpeedX = Number.isFinite(copySpeedX) && copySpeedX > 0 ? copySpeedX : null;
     // Totals across every torrent this proxy holds, used to price what the
     // torrent itself costs the machine (item 7). Optional: a proxy wired
     // without it simply never learns that figure.
@@ -1612,6 +1610,7 @@ export class HlsSessionManager {
         benchmark: this.softwarePresetBenchmark,
         decodeModel: this.decodeCostModel,
         contentionPenalties: this.contentionPenalties,
+        copySpeedX: this.copySpeedX,
         availability: this.hostAvailability
       }),
       audioCostKey: (session) => this.#audioCostKey(session),
@@ -1638,7 +1637,8 @@ export class HlsSessionManager {
       maxRunsFor: (address) => this.maxRunsForOutput(address),
       makeRun: ({ address, from, to }) => this.#makeRunAt(address, from, to),
       segmentSeconds: this.segmentDurationSec,
-      restartCostSec: RUN_RESTART_COST_SEC,
+      contentionPenalties: this.contentionPenalties,
+      startingSpeedFor: (address) => this.encodeCost.speedForOutput(address),
       segmentStore: this.segmentStore,
       logger
     });
@@ -3659,63 +3659,6 @@ export class HlsSessionManager {
     return readers;
   }
 
-  /**
-   * One viewer's demand map, translated into this output's segment numbers.
-   *
-   * The map itself is seconds of film and knows nothing about cut grids
-   * (`services/priority/PriorityMap.js`). The translation is this output's own
-   * business, and it is exact: the timeline holds the boundaries.
-   *
-   * Two measurements feed it, and neither is chosen here:
-   *
-   * 1. the allowance below which an interruption reaches the viewer, from this
-   *    file's own recent interruptions (`minimumBufferFrom`). Null until the
-   *    reader has seen two of them, and then only the segment itself counts;
-   * 2. how fast this machine encodes THIS track, from ffmpeg's own progress.
-   *    Below realtime it decides how much has to exist before playback starts;
-   *    above it, nothing beyond the allowance is needed.
-   *
-   * @param {object} session
-   * @param {number} atSegment - Where the viewer is.
-   * @returns {{from: number, to: number, priority: number}[]} In segment
-   *   numbers, both ends inclusive.
-   */
-  #demandZonesFor(session, atSeconds, playing = true) {
-    const boundaries = session.timeline?.boundaries ?? [];
-    const segmentCount = Number(session.timeline?.segmentCount) || 0;
-    // Where they are, in this output's own numbering. The viewer holds seconds;
-    // every cut grid turns them into its own numbers, and two grids of one film
-    // give different numbers for the same second.
-    const atSegment = segmentCount > 0 ? this.#segmentIndexForTime(session, atSeconds) : 0;
-    if (segmentCount <= 0) {
-      // No playlist yet: the only thing that can be said is that they want
-      // where they are.
-      return [{ from: atSegment, to: atSegment, priority: 3 }];
-    }
-    const durationSeconds = Number(boundaries[boundaries.length - 1]) ||
-      segmentCount * this.segmentDurationSec;
-    const zones = mapForViewer({
-      atSeconds,
-      durationSeconds,
-      allowanceSeconds: minimumBufferFrom({
-        segmentSeconds: this.segmentDurationSec,
-        worstSupplyWaitSec: session.supplyFigures?.worstWaitSec
-      })?.seconds ?? this.segmentDurationSec,
-      playing
-    });
-    /** @type {{from: number, to: number, priority: number}[]} */
-    const inSegments = [];
-    for (const zone of zones) {
-      const from = Math.max(atSegment, this.#segmentIndexForTime(session, zone.from));
-      const to = Math.min(segmentCount - 1, this.#segmentIndexForTime(session, zone.to));
-      if (to >= from) {
-        inSegments.push({ from, to, priority: zone.priority });
-      }
-    }
-    return inSegments.length > 0
-      ? inSegments
-      : [{ from: atSegment, to: atSegment, priority: 3 }];
-  }
 
   /**
    * Say what the cushion is, for every session.
@@ -3871,62 +3814,35 @@ export class HlsSessionManager {
       }
       coverage.markReadyAll(this.segmentStore.provenNumbers(address));
       for (const session of sessions) {
-        for (const run of this.#runsOfSession(session)) {
+        for (const run of liveRunsOf(session)) {
           this.encodeOrchestrator.adopt(address, run);
         }
-        // What the viewers of this session are waiting for, as spans. A viewer
-        // wants the segment they are at and the cushion in front of it, which
-        // is what the encoder is steered by everywhere else in this class.
-        //
-        // PRESENCE AND POSITION ARE ASKED SEPARATELY, and that is the whole of
-        // the 2026-09-05 fix. Presence decides whether this viewer states a
-        // want at all; position decides what the want is. Asked as one question
-        // — which is what a single field written only by segment requests
-        // amounted to — a viewer who had just arrived answered "absent", every
-        // encoder on their output was stopped for having nobody, and the
-        // `init.mp4` they were waiting for in order to request their first
-        // segment was therefore never made.
-        for (const [consumerId, viewer] of viewersOf(session)) {
-          if (!viewer.isPresent(now, staleAfterMs)) {
-            this.encodeOrchestrator.release(`${session.id}:${consumerId}`);
-            continue;
-          }
-          // Placed when they arrived, from the position their own request
-          // named. A viewer with no position is one assembled by hand outside
-          // this class; they want the beginning, which is where an output
-          // starts when nobody says otherwise.
-          // SECONDS, and turned into this output's own numbering below. A
-          // segment number taken off the viewer would mean two different
-          // moments of film on the picture and on the soundtrack, which are cut
-          // independently: 454 pieces against 401 on the field file.
-          const at = viewer.positionSeconds() ?? 0;
-          // Their own map, in seconds of film, from measurements: how much must
-          // be ready before they set off so that they never stop — the observed
-          // allowance for this file plus what an encoder at THIS machine's
-          // measured speed will fail to deliver in time — then what it reaches
-          // while they watch that, then the rest of the track. No constant is
-          // consulted: the 120 seconds that used to size this window were the
-          // suspended encoder's threshold, one chosen number answering seven
-          // different questions.
-          for (const zone of this.#demandZonesFor(session, at, viewer.playing !== false)) {
-            this.encodeOrchestrator.want({
-              // The claimant is the PERSON, without the priority in it: their
-              // zones are separate windows, but they leave together, and
-              // `release` matches on this name.
-              claimant: `${session.id}:${consumerId}`,
-              address,
-              from: zone.from,
-              to: zone.to,
-              priority: zone.priority
-            });
-          }
-        }
       }
     }
+    // THE MAP IS BUILT ONCE, IN ITS OWN LAYER, AND BOTH SIDES READ THAT ONE.
+    //
+    // It used to be built twice: once here, per viewer, converted and stated to
+    // the encoding as a window each, and once again inside `publishFor` for the
+    // downloading. Two answers to one question, and the encoding's copy carried
+    // the viewer's NAME as the key of a claim — against the rule that the
+    // encoding and the viewer are not connected at all.
     this.priority.publishFor({
       sessionGroups: byOutput.values(),
       staleAfterMs: this.presenceStaleAfterMs()
     });
+    // Converted into each output's own numbering, because two outputs of one
+    // film are cut independently and the same second is a different number in
+    // each: 454 pieces against 401 on the field file.
+    for (const [address, sessions] of byOutput) {
+      const timeline = sessions[0].timeline;
+      this.encodeOrchestrator.notePriorityMap(
+        address,
+        timeline?.inSegments?.(
+          this.priority.mapFor(sessions[0].sourceKey, sessions[0].fileIndex),
+          Number(timeline?.segmentCount) || 0
+        ) ?? []
+      );
+    }
     this.encodeOrchestrator.reconcile();
   }
 
@@ -3988,34 +3904,6 @@ export class HlsSessionManager {
     }
   }
 
-  /**
-   * This session's run, told what the disk holds before it is asked where it
-   * has got to.
-   *
-   * A run learns of its own segments as they are SERVED, which is not when they
-   * are made — a viewer two minutes behind the encoder has asked for none of
-   * what is in front of them. The store knows, so the run is told, and its head
-   * is then the same figure the look-ahead and the plan have always used.
-   *
-   * @param {HlsSession} session
-   * @returns {import("./encode/EncodeRun.js").EncodeRun[]}
-   */
-  #runsOfSession(session) {
-    const runs = liveRunsOf(session);
-    if (runs.length === 0) {
-      return runs;
-    }
-    const produced = this.producedSegmentNumbers(session);
-    for (const run of runs) {
-      for (const index of produced) {
-        if (index >= run.from) {
-          run.noteProduced(index);
-        }
-      }
-    }
-    return runs;
-  }
-
   /**
    * How many encoders this machine can afford on one output at once.
    *
@@ -4031,19 +3919,10 @@ export class HlsSessionManager {
    * @returns {number}
    */
   maxRunsForOutput(address) {
-    let alone = 0;
-    for (const session of this.sessionsById.values()) {
-      if (session.outputKey !== address || session.state === "disposed") {
-        continue;
-      }
-      const measured = Number(session.recentSpeed?.speed);
-      if (Number.isFinite(measured) && measured > alone) {
-        alone = measured;
-      }
-    }
+    const alone = this.encodeCost.speedForOutput(address);
     if (!(alone > 0)) {
-      // Nothing measured on this output yet. One encoder is what it has, and
-      // what it has is what it keeps until there is a reading to argue with.
+      // The host measured nothing at all, which is a broken startup rather than
+      // a state to plan around. One encoder is what it keeps.
       return 1;
     }
     let affordable = 1;
@@ -5716,6 +5595,7 @@ export class HlsSessionManager {
         session.timeline?.segmentCount > 0 ? session.timeline.segmentCount - 1 : null,
       inputUnavailable: (message) => isInputUnavailable(message),
       onProgress: (report) => this.#noteRunProgress(session, run, report),
+      indexOfName: (name) => session.segmentFormat.segmentIndexFromName(name),
       onClosed: (name) => this.segmentStore.markClosed(session.outputKey ?? "", session.segmentFormat.segmentIndexFromName(name)),
       onEnded: (ended) => this.noteRunEnded(session, run, ended)
     });
@@ -7070,11 +6950,11 @@ export class HlsSessionManager {
     if (!output) {
       return false;
     }
-    const left = this.viewers.leaves(output, consumerId);
-    if (left) {
-      this.encodeOrchestrator.release(`${output.id}:${consumerId}`);
-    }
-    return left;
+    // Nothing to release in the encoding: it holds one map per output, built
+    // from where the viewers are, and the map that arrives next simply does not
+    // have this one in it. A name to release was the last place a viewer
+    // appeared inside the encoding at all.
+    return this.viewers.leaves(output, consumerId);
   }
 
   /**