@torrent-tv/proxy 2.97.10 → 2.97.11

package/package.json

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

package/services/encode/EncodeInputs.js

@@ -51,13 +51,11 @@ export class EncodeInputs {
   #capacity;
   #urgent;
   #rankAt;
-  #deadlineOf;
-  #firstPieceIn;
   #log;
   #now;
 
   constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
-    rankAt = () => null, deadlineOf = () => null, firstPieceIn = () => null, openOf = () => null, log = () => {}, now = Date.now }) {
+    rankAt = () => null, openOf = () => null, log = () => {}, now = Date.now }) {
     this.#openOf = openOf;
     this.#resolve = resolve;
     this.#read = readRanges;
@@ -68,8 +66,6 @@ export class EncodeInputs {
     this.#capacity = capacity;
     this.#urgent = urgent;
     this.#rankAt = rankAt;
-    this.#deadlineOf = deadlineOf;
-    this.#firstPieceIn = firstPieceIn;
     this.#log = log;
     this.#now = now;
   }
@@ -411,26 +407,8 @@ export class EncodeInputs {
       return good;
     };
     const sizing = this.stretchFor(output);
-    let target = sizing?.bytes ?? null;
+    const target = sizing?.bytes ?? null;
     if (sizing && !sizing.openMeasured) request.timing.openApproximate = true;
-    // NO LONGER THAN THE VIEWER CAN WAIT. A stretch is sized so its copy takes
-    // no longer than an open; for a piece the viewer reaches soon, the copy and
-    // the time to that piece's being served must both fit before they reach it.
-    // Field 2026-10-12: after a seek back, 222.4 MB were copied for 7.7 s ahead
-    // of a piece needed in about 8 s, and the picture stood 13.2 s. Unknown
-    // terms leave the stretch as it was.
-    const deadline = this.#deadlineOf(output, serves);
-    const firstPiece = this.#firstPieceIn(output, from, serves);
-    const copyRate = middleOf(this.#copyRates);
-    if (target !== null && Number.isFinite(deadline) && Number.isFinite(firstPiece) && copyRate !== null) {
-      const fitting = Math.floor(copyRate * Math.max(0, deadline - firstPiece) * 1000);
-      if (fitting < target) {
-        const capped = Math.max(minimum, fitting);
-        this.#log(`encode input #${from}..#${request.to} of ${output.outputKey ?? output.id}: copy held to ${capped} of ${target} bytes ` +
-          `— #${serves} is needed in ${deadline.toFixed(1)}s and its first piece takes ${firstPiece.toFixed(1)}s to be served`);
-        target = capped;
-      }
-    }
     let end = target === null || this.#heldRanges === null ? floor : await longest(target);
     if (this.#requests.get(request.key) !== request) return undefined;
     this.#wanted.set(request.key, { wanted: stretches.get(end).bytes, required: minimum });

package/services/server/wire-outputs.js

@@ -98,7 +98,6 @@ import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObserva
 import { configurationKeyOf } from "../encode/fingerprint.js";
 import { qualityStateOf } from "../encode/quality/OutputQualityState.js";
 import { downloadShare } from "../storage/processor-share.js";
-import { secondsToServe, secondsUntilPiece } from "../encode/input-deadline.js";
 import { ENCODE_RUN_STATE, processCanBeSignalled } from "../encode/encode-run-state.js";
 
 // Where a variant and an audio rendition live under a session — `v/<height>/…`
@@ -1014,19 +1013,6 @@ export function wireOutputs({
       index >= window.from && index <= window.to && window.urgent === true),
     // The piece's rank in the output's own map, said with an input's state.
     rankAt: (output, index) => parts.encodeOrchestrator?.rankAt?.(output.outputKey ?? "", index) ?? null,
-    // WHEN THE VIEWER REACHES A PIECE: the output map's zones state it for their
-    // near edge, and a piece inside a zone is that much film further on.
-    deadlineOf: (output, index) => secondsUntilPiece(parts.encodeOrchestrator?.wantedSegmentsOn(output.outputKey ?? "") ?? [],
-      output.timeline?.published ?? output.timeline?.boundaries, index),
-    // HOW LONG A RUN STARTED AT `from` TAKES TO SERVE `serves`: its open, the
-    // pieces it encodes up to and including `serves`, and the next one where a
-    // piece waits for the file after it.
-    firstPieceIn: (output, from, serves) => secondsToServe({
-      open: parts.encodeOrchestrator?.openOf?.(output.outputKey ?? "")?.seconds,
-      speed: parts.encodeOrchestrator?.speedOn?.(output.outputKey ?? ""),
-      grid: output.timeline?.published ?? output.timeline?.boundaries,
-      from, serves, waitsForNext: !parts.encodeRuns.publishesAlone(output)
-    }),
     log: line => logger.info(line),
     changed: (output, result) => {
       if (result.kind === "terminal") {

package/services/encode/input-deadline.js

@@ -1,52 +0,0 @@
-/**
- * @file When the viewer reaches a piece, and how long a run takes to serve it:
- * the two terms that keep an encoder input's copy from making the viewer wait
- * (torrent-tv/meta#178).
- *
- * Field 2026-10-12, an AVI on Home Assistant: after a seek back to 100 s the
- * input of run `#27..#224` — 222.4 MB, copied in 7.7 s — was prepared ahead of
- * a piece the viewer reached about 8 s later, and the picture stood 13.2 s. A
- * stretch is sized so that its copy takes no longer than an open; for a piece
- * the viewer reaches soon the copy has to leave room for the run to serve it.
- */
-
-/**
- * Seconds until the viewer reaches piece `index`, from the output's map.
- *
- * A zone states `withinSeconds` for its near edge (`output/Timeline.js`); a
- * piece inside it is that much film further on. The nearest zone holding the
- * piece decides. Null where no zone holds it or the grid is unknown.
- *
- * @param {{ from: number, to: number, withinSeconds?: number }[]} zones
- * @param {number[] | null | undefined} grid - Where each piece begins, in seconds of film.
- * @param {number} index
- * @returns {number | null}
- */
-export function secondsUntilPiece(zones, grid, index) {
-  if (!Array.isArray(grid) || !Number.isFinite(grid[index])) return null;
-  let nearest = null;
-  for (const zone of zones) {
-    if (!(index >= zone.from && index <= zone.to) || !Number.isFinite(zone.withinSeconds) || !Number.isFinite(grid[zone.from])) continue;
-    const seconds = Math.max(0, zone.withinSeconds) + (grid[index] - grid[zone.from]);
-    if (nearest === null || seconds < nearest) nearest = seconds;
-  }
-  return nearest;
-}
-
-/**
- * Seconds from a run's start at `from` to piece `serves` being served.
- *
- * The open (spawn and first input, without encoding its first piece, as
- * `EncodeRuns` measures it), the film from `from` through `serves` at the
- * output's speed, and — where a piece is published only when the file after it
- * closes — that next piece too. Null when a term is unknown.
- *
- * @param {{ open?: number | null, speed?: number | null, grid?: number[] | null, from: number, serves: number, waitsForNext?: boolean }} params
- * @returns {number | null}
- */
-export function secondsToServe({ open, speed, grid, from, serves, waitsForNext = false }) {
-  if (!Number.isFinite(open) || open < 0 || !Number.isFinite(speed) || !(speed > 0) || !Array.isArray(grid)) return null;
-  const last = waitsForNext && Number.isFinite(grid[serves + 2]) ? serves + 2 : serves + 1;
-  const film = grid[last] - grid[from];
-  return Number.isFinite(film) && film > 0 ? open + film / speed : null;
-}