@torrent-tv/proxy 2.107.26 → 2.107.28

package/package.json

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

package/server.js

@@ -1045,10 +1045,13 @@ export async function startProxyServer({
         if (!params) return { kind: "needs-source" };
         if (timing) {
           params.walkAccount = timing.walk ??= { lockMs: 0, reads: 0, bytes: 0 };
-          params.onTimed = (_statement, waitedMs, readMs) => {
+          params.onTimed = (statement, waitedMs, readMs) => {
             timing.reads += 1;
             timing.queuedMs += waitedMs;
             timing.readMs += readMs;
+            const measured = timing.readsByStatement[statement] ??= { queuedMs: 0, readMs: 0 };
+            measured.queuedMs += waitedMs;
+            measured.readMs += readMs;
           };
         }
         const tracks = await containerOrchestrator.inspect(params, "tracks");

package/services/encode/EncodeAdmission.js

@@ -194,9 +194,10 @@ export class EncodeAdmission {
   }
 
   /**
-   * Whether a not-yet-opened format can take a place on the whole machine.
-   * The output choice calls this for each candidate rung; the final claim uses
-   * `admitsWatching` with the same arithmetic after registering the output.
+   * Whether an output candidate can take a place on the whole machine. A
+   * partial output already in the catalogue uses its measured cost; a
+   * not-yet-opened output uses the same candidate estimate as before. The final
+   * claim uses `admitsWatching` after registering the output.
    *
    * @param {object} spec
    * @param {object} file
@@ -207,13 +208,22 @@ export class EncodeAdmission {
     if (!address) {
       return { admitted: false, reason: "the output has no address", speedX: null };
     }
+    if (this.#host.finished?.(address) === true) {
+      return { admitted: true, reason: "everything it serves is already made", speedX: null };
+    }
     if ((this.#host.liveRunsByAddress().get(address) ?? 0) > 0) {
       return { admitted: true, reason: "an encoder already runs there", speedX: null };
     }
     if (this.#heldWithoutRun().has(address)) {
       return { admitted: true, reason: "it already holds a place for another viewer", speedX: null };
     }
-    const load = this.#host.loadForCandidate?.(spec, file) ?? null;
+    // A partial output already in the catalogue has its measured rate. Use it
+    // before the candidate estimate; completed outputs took the return above.
+    const existing = this.#host.loadOf(address);
+    const hasMeasuredExistingCost = Number.isFinite(existing?.costSec) && existing.costSec > 0;
+    const load = hasMeasuredExistingCost
+      ? existing
+      : this.#host.loadForCandidate?.(spec, file) ?? existing;
     return this.#assessCandidate(address, load);
   }
 

package/services/encode/EncodeInputs.js

@@ -413,7 +413,7 @@ export class EncodeInputs {
     // 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 };
+      reads: 0, queuedMs: 0, readMs: 0, readsByStatement: {}, heldMs: 0, budgetMs: 0 };
     request.timing.attempts += 1;
     this.#observe(request, "attempt", { request: request.key, attempt: request.timing.attempts });
     request.promise = (async () => {
@@ -742,9 +742,12 @@ function awaitedIn(waiting, arrived) {
  */
 function describeTiming(timing, now) {
   if (!timing) return "";
+  const statements = Object.entries(timing.readsByStatement ?? {}).map(([statement, measured]) =>
+    `${statement} queued ${measured.queuedMs}ms/read ${measured.readMs}ms`).join(", ");
   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), ` +
+    (statements ? `by statement: ${statements}, ` : "") +
     `held ranges ${timing.heldMs}ms, budget ${timing.budgetMs}ms` +
     // Where a packet input's walk spent its read: waiting for the same
     // track's earlier walks, or reading the file (r62, torrent-tv/meta#178).

package/services/encode/quality/output-format.js

@@ -228,6 +228,20 @@ export function decideOutputFormat({
       rateControl: limit === null ? null : softwareRateControlFor({ width: w, height: h, fps, source, capKbps: limit })
     }));
   };
+  let machineRefusal = null;
+  const machineAdmissionFor = (spec) => typeof machineAdmission === "function" ? machineAdmission(spec) : null;
+  const machineCanContinue = (spec) => machineAdmissionFor(spec)?.admitted !== false;
+  const admittedByMachine = (spec) => {
+    if (!machineCan(spec.video?.encode?.width ?? 0, spec.video?.encode?.height ?? 0)) {
+      return false;
+    }
+    const answer = machineAdmissionFor(spec);
+    if (answer?.admitted === false) {
+      machineRefusal ??= answer;
+      return false;
+    }
+    return true;
+  };
   const wantedFormats = formatsAt(width, height);
   const wantedSpec = wantedFormats[0];
   const wantedKey = wantedSpec.toKey();
@@ -247,6 +261,7 @@ export function decideOutputFormat({
       wanted: { width, height },
       nextLowerArea: nextRungAreaBelow(buildResolutionLadder(ceiling.w, ceiling.h), height),
       atRisk: measured && !canSustainOutput({ benchmark, ...priced, outputPixelsPerSec: width * height * fps, frame: { width, height } }).sustainable,
+      canProduce: (candidate) => machineCanContinue(candidate.spec),
       judge: (candidate) => judge(candidate.spec),
       candidates: servingCandidates({
         wanted: wantedSpec,
@@ -262,18 +277,6 @@ export function decideOutputFormat({
   }
 
   let anySizeHeld = false;
-  let machineRefusal = null;
-  const admittedByMachine = (spec) => {
-    if (!machineCan(spec.video?.encode?.width ?? 0, spec.video?.encode?.height ?? 0)) {
-      return false;
-    }
-    const answer = typeof machineAdmission === "function" ? machineAdmission(spec) : null;
-    if (answer?.admitted === false) {
-      machineRefusal ??= answer;
-      return false;
-    }
-    return true;
-  };
   if (machineCan(width, height)) {
     for (const spec of wantedFormats) {
       if (!admittedByMachine(spec)) {

package/services/encode/quality/serving-output.js

@@ -48,15 +48,17 @@ import { admissionRank } from "./link-budget.js";
  *   on this viewer's own ladder; zero when there is none.
  * @param {boolean} params.atRisk - Producing `wanted` here is measured not to
  *   keep up with what the file needs. False where nothing measured it.
+ * @param {(candidate: Candidate) => boolean} [params.canProduce] - Whether
+ *   this machine can keep producing an output that is not finished.
  * @param {(candidate: Candidate) => { admitted: boolean, load: object }} params.judge -
  *   What this viewer's link does with the candidate's whole load.
  * @param {Candidate[]} params.candidates
  * @returns {{ key: string, answer: object } | null} The output to serve, or
  *   null to produce `wanted`.
  */
-export function chooseServingOutput({ mode, wanted, nextLowerArea, atRisk, judge, candidates }) {
+export function chooseServingOutput({ mode, wanted, nextLowerArea, atRisk, canProduce = () => true, judge, candidates }) {
   const admitted = (candidates ?? [])
-    .filter((candidate) => candidate.readyHere === true)
+    .filter((candidate) => candidate.readyHere === true && canProduce(candidate))
     .map((candidate) => ({ candidate, answer: judge(candidate) }))
     .filter((one) => one.answer.admitted);
   const areaOf = (one) => one.candidate.width * one.candidate.height;

package/services/media/container/AsfContainer.js

@@ -212,15 +212,20 @@ export class AsfContainer extends Container {
     const index = await this.readPacketIndex();
     return { times: index.keyframesOf(track.trackNumber), tolerance: 0 };
   }
-  async readPacketIndex(interval) {
+  async readPacketIndex(interval, { isCurrent } = {}) {
+    if (isCurrent?.() === false) return null;
     await this.#readHeader();
+    if (isCurrent?.() === false) return null;
     if (!this.#packets && Number.isFinite(interval?.from) && Number.isFinite(interval?.to) && interval.to > interval.from) {
-      const window = await this.#readWindow(interval);
+      const window = await this.#readWindow(interval, isCurrent);
+      if (isCurrent?.() === false) return null;
       if (window) return window;
     }
+    if (isCurrent?.() === false) return null;
     if (!this.#packets) {
       const index = await readAsfPackets({ readRange: this.readRange, fileSize: this.fileSize, tracks: this.#tracks,
-        info: { ...this.#info, durationSeconds: this.#duration }, state: this.#packetState, packetMemory: this.packetMemory });
+        info: { ...this.#info, durationSeconds: this.#duration }, state: this.#packetState, packetMemory: this.packetMemory, isCurrent });
+      if (index === null) return null;
       const timeline = this.#tracks.find(track => track.type === "video") ?? this.#tracks.find(track => track.type === "audio");
       const bounds = timeline ? index.boundsOf(timeline.trackNumber) : null;
       if (bounds) {
@@ -246,17 +251,21 @@ export class AsfContainer extends Container {
    * interval, is read again from twice as far back, and from the first packet
    * at the latest; which it reaches is checked on what it read, not assumed.
    */
-  async #readWindow(interval) {
+  async #readWindow(interval, isCurrent) {
     const data = await this.#dataLayout();
+    if (isCurrent?.() === false) return null;
     if (!data) return null;
     const requested = this.#tracks.filter(track => ["video", "audio"].includes(track.type) &&
       (!interval.trackIds?.length || interval.trackIds.includes(track.trackNumber)));
     if (!requested.length) return null;
     const info = { ...this.#info, durationSeconds: this.#duration };
     for (let lead = this.#info.prerollSeconds + WINDOW_LEAD_SECONDS; ; lead *= 2) {
+      if (isCurrent?.() === false) return null;
       const sentFrom = interval.from - lead;
-      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS);
-      const window = await readAsfWindow({ readRange: this.readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom });
+      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS, isCurrent);
+      if (isCurrent?.() === false) return null;
+      const window = await readAsfWindow({ readRange: this.readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom, isCurrent });
+      if (isCurrent?.() === false) return null;
       if (window.startCovered || first === 0) return window.index;
     }
   }
@@ -291,14 +300,16 @@ export class AsfContainer extends Container {
    * bytes the window from it to `until` is estimated to take, so the swarm is
    * asked for the packet and the window it begins at once.
    */
-  async #packetSentBefore(seconds, data, until) {
-    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data), highSent = this.#duration;
+  async #packetSentBefore(seconds, data, until, isCurrent) {
+    if (isCurrent?.() === false) return null;
+    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data, 1, isCurrent), highSent = this.#duration;
+    if (isCurrent?.() === false) return null;
     if (lowSent > seconds) return 0;
     // Past the last packet nothing is sent before the film ends; the last
     // packet itself is read only when the search needs it.
     if (!(highSent > seconds)) {
       high = data.count - 1;
-      highSent = await this.#sentAt(high, data);
+      highSent = await this.#sentAt(high, data, 1, isCurrent);
       if (highSent <= seconds) return high;
     }
     for (const [number, at] of this.#sent) {
@@ -307,12 +318,14 @@ export class AsfContainer extends Container {
       else { high = number; highSent = at; }
     }
     for (let guesses = 0; high - low > 1 && seconds - lowSent > WINDOW_SEARCH_SECONDS; guesses++) {
+      if (isCurrent?.() === false) return null;
       const perSecond = (high - low) / (highSent - lowSent);
       const aim = seconds - WINDOW_SEARCH_SECONDS / 2;
       const guess = guesses >= 3 || !(perSecond > 0) ? Math.floor((low + high) / 2) : low + Math.floor((aim - lowSent) * perSecond);
       const probe = Math.min(high - 1, Math.max(low + 1, guess));
       const window = perSecond > 0 ? Math.ceil((until - aim) * perSecond) : 1;
-      const at = await this.#sentAt(probe, data, Math.max(1, window));
+      const at = await this.#sentAt(probe, data, Math.max(1, window), isCurrent);
+      if (isCurrent?.() === false) return null;
       if (at <= seconds) { low = probe; lowSent = at; }
       else { high = probe; highSent = at; }
     }
@@ -323,7 +336,8 @@ export class AsfContainer extends Container {
    * When packet `number` is sent. A packet that is not held is said as
    * missing with the `packets` packets from it.
    */
-  async #sentAt(number, data, packets = 1) {
+  async #sentAt(number, data, packets = 1, isCurrent) {
+    if (isCurrent?.() === false) return null;
     if (!this.#sent.has(number)) {
       const at = data.start + number * data.length;
       try {
@@ -333,6 +347,6 @@ export class AsfContainer extends Container {
         throw new BytesUnavailable(at, Math.min(data.start + data.count * data.length, at + packets * data.length) - 1, 0);
       }
     }
-    return this.#sent.get(number);
+    return isCurrent?.() === false ? null : this.#sent.get(number);
   }
 }

package/services/media/container/asf-packets.js

@@ -20,7 +20,7 @@ export async function readAsfData({ readRange, fileSize, info }) {
 }
 
 /** ASF payload addresses, including fragmented and compressed media objects. */
-export async function readAsfPackets({ readRange, fileSize, tracks, info, firstPicture = false, packetMemory, state = {} }) {
+export async function readAsfPackets({ readRange, fileSize, tracks, info, firstPicture = false, packetMemory, state = {}, isCurrent }) {
   if (!state.initialized) {
   const data = await readAsfData({ readRange, fileSize, info });
   Object.assign(state, { initialized: true, at: data.start, end: data.end, count: data.count, packets: 0,
@@ -30,6 +30,7 @@ export async function readAsfPackets({ readRange, fileSize, tracks, info, firstP
   const { end, count, frames, assembling } = state;
   const declared = new Map(tracks.map(track => [track.trackNumber, track]));
   while (at < end && (!count || packets < count)) {
+    if (isCurrent?.() === false) return null;
     const previousObjects = new Map([...assembling].map(([id, object]) => [id, { ...object, ranges: [...object.ranges] }]));
     const previousLengths = new Map([...frames].map(([id, stream]) => [id, stream.length]));
     try {
@@ -37,6 +38,7 @@ export async function readAsfPackets({ readRange, fileSize, tracks, info, firstP
     packets++;
     state.at = at;
     state.packets = packets;
+    if (isCurrent?.() === false) return null;
     if (firstPicture) {
       const video = tracks.find(track => track.type === "video");
       const stream = video && frames.get(video.trackNumber);
@@ -105,7 +107,7 @@ export async function readAsfPacketTime({ readRange, at, end, info }) {
  * @param {number} params.sentFrom - When packet `first` is sent, as far as the caller knows.
  * @returns {Promise<{ index: PacketIndex, startCovered: boolean }>}
  */
-export async function readAsfWindow({ readRange, data, tracks, requested, info, first, interval, sentFrom }) {
+export async function readAsfWindow({ readRange, data, tracks, requested, info, first, interval, sentFrom, isCurrent }) {
   const declared = new Map(tracks.map(track => [track.trackNumber, track]));
   // Not admitted to IndexMemory: one segment's records, a few hundred, held
   // by the request that asked and dropped with it. Nothing owns a window to
@@ -125,23 +127,30 @@ export async function readAsfWindow({ readRange, data, tracks, requested, info,
   const held = (start, end) => buffer !== null && start >= bufferAt && end < bufferAt + buffer.length;
   const read = (start, end) => held(start, end) ? buffer.subarray(start - bufferAt, end - bufferAt + 1) : readRange(start, end);
   const load = async () => {
+    if (isCurrent?.() === false) return false;
     try {
       buffer = await readRange(at, Math.min(dataEnd - 1, at + WINDOW_PORTION_PACKETS * data.length - 1));
     } catch (error) {
+      if (isCurrent?.() === false) return false;
       if (!isUnavailable(error)) throw error;
       try {
         buffer = await readRange(at, Math.min(dataEnd - 1, at + data.length - 1));
       } catch (missing) {
+        if (isCurrent?.() === false) return false;
         if (!isUnavailable(missing)) throw missing;
         const ahead = Math.ceil(Math.max(0, interval.to + WINDOW_LEAD_SECONDS - sent) * rate);
         throw new BytesUnavailable(at, Math.min(dataEnd - 1, Math.max(at + data.length, at + ahead) - 1), 0);
       }
     }
+    if (isCurrent?.() === false) return false;
     bufferAt = at;
+    return true;
   };
   for (;;) {
+    if (isCurrent?.() === false) return null;
     if (at >= dataEnd) { reachedEnd = true; break; }
-    if (!held(at, Math.min(dataEnd, at + data.length) - 1)) await load();
+    if (!held(at, Math.min(dataEnd, at + data.length) - 1) && !(await load())) return null;
+    if (isCurrent?.() === false) return null;
     ({ next: at, sent } = await readPacket({ readRange: read, at, end: data.end, info, declared, frames, assembling, started }));
     for (const id of ids) {
       const stream = frames.get(id), times = after.get(id);