@torrent-tv/proxy 2.97.15 → 2.97.16

package/package.json

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

package/server.js

@@ -524,6 +524,14 @@ export async function startProxyServer({
       if (!map.isCurrent()) return [];
       const direct = navigated.kind === "result" && navigated.value === true &&
         typeof container?.readSourceRanges === "function" ? container : null;
+      // An output whose file-level reading is not there in this pass — the
+      // index or Cues that say where a segment is, not yet downloaded, or the
+      // table its segments read, refused memory — answers its other segments
+      // the same way. One unanswered request is kept to be retried when the
+      // bytes or the memory change, and the map is built again when it
+      // answers; asking every segment held the main thread for 3.3 s on a cold
+      // two-hour AVI (torrent-tv/meta#178).
+      const waiting = new Set();
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
         // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
@@ -547,6 +555,7 @@ export async function startProxyServer({
         // were never asked for (Home Assistant 2026-10-08, torrent-tv/meta#151).
         const known = segmentSourceRanges.get(rangesKey);
         if (known) { convert(known); continue; }
+        if (waiting.has(zone.outputKey)) continue;
         if (direct) {
           // Asked per zone too: a soundtrack of an AVI is read from its own
           // packets, which the same index states (torrent-tv/meta#166).
@@ -572,10 +581,14 @@ export async function startProxyServer({
         if (!map.isCurrent()) return [];
         if (!intervalParams) continue;
         const navigation = await containerOrchestrator.inspect(intervalParams, "source-navigation");
-        if (navigation.kind !== "result") continue;
+        if (navigation.kind !== "result") {
+          if (navigation.kind === "needs-ranges" || navigation.kind === "needs-memory") waiting.add(zone.outputKey);
+          continue;
+        }
         const originalRanges = navigation.value;
         const packets = await containerOrchestrator.inspect(intervalParams, originalRanges ? "source-ranges" : "packets");
         if (!map.isCurrent()) return [];
+        if (packets.kind === "needs-memory") waiting.add(zone.outputKey);
         if (packets.kind !== "result") continue;
         const input = originalRanges ? packets.value : new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
         if (input.kind !== "result") continue;
@@ -599,7 +612,7 @@ export async function startProxyServer({
     failed: (request, error) => logger.warn(`media request=${request.key} probe failed: ${error?.message ?? error}`)
   });
   const indexMemory = new IndexMemory({
-    reviseBudget: () => { void outputParts.machineBudget.revise().catch(error => logger.warn(`packet index budget: ${error.message}`)); },
+    reviseBudget: () => { void outputParts.machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
     changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
   });
   const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand }) => {

package/services/media/MediaReadRequests.js

@@ -1,6 +1,22 @@
-/** Retry unfinished statements when their missing resource changes. */
+/**
+ * Retry unfinished statements when their missing resource changes.
+ *
+ * ONE REFUSAL OF MEMORY ANSWERS THE STATEMENT, not one request of it. The
+ * table a statement reserves belongs to the file — a soundtrack's packet table
+ * is one table for every segment of it — so once a read of a statement has
+ * been refused memory, the other requests of the same statement of the same
+ * file wait for memory to change instead of being read and refused one by one.
+ * Read one by one, a cold two-hour AVI's 1943 soundtrack segments were refused
+ * in turn when the index's last piece arrived, which held the main thread for
+ * 3.3 s and the budget revision that would have given the memory behind it
+ * (Home Assistant 2026-10-12, torrent-tv/meta#178). A retry wave therefore
+ * reads one request of each statement first and the others once it has
+ * answered.
+ */
 export class MediaReadRequests {
   #requests = new Map();
+  /** File and statement → the memory revision at which a read of it was refused memory. */
+  #refusedMemory = new Map();
   #read;
   #failed;
   #versions = new Map();
@@ -39,6 +55,7 @@ export class MediaReadRequests {
       this.#notify(params.sourceKey, params.fileIndex, result);
       return this.#requests.delete(key);
     }
+    if (result.kind === "needs-memory") this.#refusedMemory.set(statementKey(params, statement), memoryRevision);
     const existing = this.#requests.get(key);
     if (existing) { existing.params = params; existing.kind = result.kind; }
     else this.#requests.set(key, { params, statement, kind: result.kind, running: false, changed: false });
@@ -54,24 +71,49 @@ export class MediaReadRequests {
 
   memoryChanged() {
     this.#memoryVersion++;
+    const wave = [];
     for (const request of this.#requests.values()) {
       if (request.kind !== "needs-memory") continue;
       // The retried statement announces its result. A memory event is not a
       // source change for another statement still waiting for missing bytes.
       request.changed = true;
-      if (!request.running) void this.#retry(request);
+      if (!request.running) wave.push(request);
     }
+    this.#retryWave(wave);
   }
 
   bytesChanged(sourceKey, fileIndex) {
     const fileKey = `${sourceKey}:${fileIndex}`;
     this.#versions.set(fileKey, this.revision(sourceKey, fileIndex) + 1);
     this.#notify(sourceKey, fileIndex, { kind: "bytes-changed" });
+    const wave = [];
     for (const request of this.#requests.values()) {
       if (request.params.sourceKey !== sourceKey || request.params.fileIndex !== fileIndex) continue;
       if (request.kind !== "needs-ranges") continue;
       request.changed = true;
-      if (!request.running) void this.#retry(request);
+      if (!request.running) wave.push(request);
+    }
+    this.#retryWave(wave);
+  }
+
+  /**
+   * Retry `requests`: one of each statement of each file first, the others of
+   * that statement once it has answered.
+   *
+   * @param {object[]} requests
+   */
+  #retryWave(requests) {
+    const groups = new Map();
+    for (const request of requests) {
+      const key = statementKey(request.params, request.statement);
+      const group = groups.get(key);
+      if (group) group.push(request);
+      else groups.set(key, [request]);
+    }
+    for (const [head, ...rest] of groups.values()) {
+      void this.#retry(head).then(() => {
+        for (const request of rest) if (!request.running) void this.#retry(request);
+      });
     }
   }
 
@@ -90,6 +132,10 @@ export class MediaReadRequests {
     for (const key of this.#versions.keys()) {
       if (fileIndex === undefined ? key.startsWith(`${sourceKey}:`) : key === `${sourceKey}:${fileIndex}`) this.#versions.delete(key);
     }
+    for (const key of [...this.#refusedMemory.keys()]) {
+      const [refusedSource, refusedFile] = JSON.parse(key);
+      if (refusedSource === sourceKey && (fileIndex === undefined || refusedFile === fileIndex)) this.#refusedMemory.delete(key);
+    }
   }
 
   retain(sourceKey, fileIndex, wanted) {
@@ -105,6 +151,12 @@ export class MediaReadRequests {
     try {
       while (request.changed && this.#requests.get(key) === request) {
         request.changed = false;
+        if (this.#refusedMemory.get(statementKey(request.params, request.statement)) === this.#memoryVersion) {
+          // The same statement of the same file was refused memory in this
+          // very state of memory: so is this one, without reading it.
+          request.kind = "needs-memory";
+          break;
+        }
         await this.#read(request.params, request.statement);
       }
     } catch (error) {
@@ -118,3 +170,7 @@ export class MediaReadRequests {
 function requestKey(params, statement) {
   return JSON.stringify([params.sourceKey, params.fileIndex, statement, params.requestId ?? null]);
 }
+
+function statementKey(params, statement) {
+  return JSON.stringify([params.sourceKey, params.fileIndex, statement]);
+}

package/services/server/ViewerRequests.js

@@ -738,9 +738,49 @@ export class ViewerRequests {
         }))
       })}`);
     }
+    this.#sayHolding(session, consumerId, measurement, forecast, input, now);
     return forecast;
   }
 
+  /**
+   * What holds a waiting viewer's start, said when it changes: which piece,
+   * its production or its delivery, when it comes against the media before it,
+   * and the rates the forecast used. Said again when the delay has moved by a
+   * second, at most once a second; a hold that changes nothing says nothing.
+   *
+   * @param {object} session
+   * @param {string} consumerId
+   * @param {object} measurement - This viewer's forecast state.
+   * @param {object} forecast
+   * @param {object} input
+   * @param {number} now
+   */
+  #sayHolding(session, consumerId, measurement, forecast, input, now) {
+    const holding = forecast.holdingBy;
+    if (!holding) {
+      measurement.held = null;
+      return;
+    }
+    const key = `${holding.kind}:${holding.track}:${holding.segment}`;
+    const delay = Number.isFinite(forecast.delaySeconds) ? forecast.delaySeconds : null;
+    const said = measurement.held;
+    if (said && said.key === key && (delay === null || said.delay === null || Math.abs(delay - said.delay) < 1 ||
+      now - said.at < 1000)) return;
+    measurement.held = { key, delay, at: now };
+    const seconds = value => Number.isFinite(value) ? value.toFixed(2) : "?";
+    const rates = (forecast.operations ?? []).map(operation =>
+      `${operation.track} ${operation.operation} ${Number.isFinite(operation.speed) ? operation.speed.toFixed(2) : "?"}x`);
+    const downloads = (input.sources ?? []).map(source => {
+      const rate = source.downloadRateReadings?.lastValue;
+      return `${Number.isFinite(rate) ? (rate / 1_048_576).toFixed(2) : "?"} MB/s`;
+    });
+    logger.info(`playback held ${session.id} consumer=${consumerId}: delay ${seconds(delay)}s by ` +
+      (holding.kind === "position-not-held" ? "the position, which nothing buffered covers" :
+        `the ${holding.kind} of ${holding.track} #${holding.segment} in ${seconds(holding.atSeconds)}s against ` +
+        `${seconds(holding.aheadSeconds)}s of media before it${holding.requiresSource ? ", its input still downloading" : ""}`) +
+      `; buffered ${seconds(forecast.bufferedSeconds)}s; rates ${rates.join(", ") || "none"}; download ${downloads.join(", ") || "none"}`);
+  }
+
   /**
    * The pieces of one output as the start forecast reads them, kept between
    * polls: a piece whose playlist edges, read ranges and torrent inputs have

package/services/server/wire-outputs.js

@@ -1008,7 +1008,7 @@ export function wireOutputs({
     resolve: resolveEncodeInput,
     readRanges: readEncodeRanges,
     heldRanges: readEncodeHeldRanges,
-    reviseBudget: () => parts.machineBudget.revise(),
+    reviseBudget: () => parts.machineBudget.revise("memory", "admitted encode inputs"),
     capacity: () => parts.machineBudget.capacityOf("memory"),
     // How long this output's input takes to open, from the one owner of start
     // readings (torrent-tv/meta#184).

package/services/storage/MachineBudget.js

@@ -77,6 +77,14 @@ import { OtherDemand, divideAllowance } from "./allowance.js";
 export class MachineBudget {
   #revisionPromise = null;
   #reviseAgain = false;
+  /**
+   * The resources the next pass reads: `null` for every one, else their names.
+   * A claimant short of memory asks for memory alone; reading the disks first
+   * made its answer wait for them (torrent-tv/meta#178).
+   *
+   * @type {Set<string> | null}
+   */
+  #againScope = null;
   /**
    * The revision in hand, for its own line: when it was first asked for, how
    * many asks joined it, and which pass this is. At a cold start on the addon
@@ -151,32 +159,45 @@ export class MachineBudget {
   }
 
   /**
-   * Read every resource, divide each, and tell each claimant its share.
+   * Read the resources, divide each, and tell each claimant its share.
    *
+   * @param {string | null} [resource] - One resource to read and divide; every
+   *   resource when absent. The others keep their last division.
+   * @param {string | null} [because] - Who asked, said in the revision's line.
    * @returns {Promise<Map<string, { freeBytes: number, allowanceBytes: number, shares: object[] }>>}
    */
-  revise() {
+  revise(resource = null, because = null) {
+    const scope = resource === null ? null : new Set([resource]);
     if (this.#revisionPromise) {
       this.#reviseAgain = true;
+      this.#againScope = this.#againScope === null || scope === null ? null : new Set([...this.#againScope, ...scope]);
       this.#revision.asks += 1;
       return this.#revisionPromise;
     }
-    this.#revision = { askedAt: Date.now(), asks: 1, pass: 0 };
+    this.#revision = { askedAt: Date.now(), asks: 1, pass: 0, because };
+    this.#againScope = scope;
     this.#revisionPromise = (async () => {
       do {
+        const passScope = this.#againScope;
+        this.#againScope = new Set();
         this.#reviseAgain = false;
         this.#revision.pass += 1;
-        await this.#readRevision();
+        await this.#readRevision(passScope);
       } while (this.#reviseAgain);
       return this.#last;
     })().finally(() => { this.#revisionPromise = null; });
     return this.#revisionPromise;
   }
 
-  async #readRevision() {
+  /** @param {Set<string> | null} scope */
+  async #readRevision(scope) {
     const passFrom = Date.now();
     let readingMs = 0;
+    const readings = [];
     for (const [name, resource] of this.#resources) {
+      if (scope !== null && !scope.has(name)) {
+        continue;
+      }
       const claimants = this.#claimants.filter((one) => one.resource === name);
       if (claimants.length === 0) {
         continue;
@@ -185,6 +206,7 @@ export class MachineBudget {
       const readFrom = Date.now();
       const free = await resource.readFree();
       readingMs += Date.now() - readFrom;
+      readings.push(`${name} ${Date.now() - readFrom}ms`);
       // WITHOUT A READING, NOTHING IS ALLOWED TO GROW. A resource whose free
       // space cannot be read is not a resource with room; answering "unbounded"
       // there is how the spill file came to have no limit in the first place.
@@ -213,8 +235,9 @@ export class MachineBudget {
     }
     const revision = this.#revision;
     this.#logger?.info?.(`${this.describe()}` + (revision
-      ? ` (pass ${revision.pass} of a revision asked ${revision.asks} time(s), first ${Date.now() - revision.askedAt}ms ago; ` +
-        `this pass ${Date.now() - passFrom}ms, ${readingMs}ms of it reading what is free)`
+      ? ` (pass ${revision.pass} of a revision asked ${revision.asks} time(s), first ${Date.now() - revision.askedAt}ms ago` +
+        `${revision.because ? `, first by ${revision.because}` : ""}; ` +
+        `this pass ${Date.now() - passFrom}ms, ${readingMs}ms of it reading what is free: ${readings.join(", ") || "nothing"})`
       : ""));
     return this.#last;
   }

package/services/storage/wire.js

@@ -153,8 +153,9 @@ export function wireMachineBudget({
     });
   }
 
+  let evidenceOn = null;
   if (diagnostics) {
-    const evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
+    evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
     defineDisk(evidenceOn, diagnosticsRoot || segmentStore.root);
     budget.register({
       name: "diagnostics",
@@ -169,11 +170,22 @@ export function wireMachineBudget({
 
   return {
     capacityOf: name => budget.capacityOf(name),
-    revise: async () => {
-      // Re-read the evidence before dividing: it is the one claimant whose
-      // bytes are written by something that never reports them.
-      await diagnostics?.measure();
-      return budget.revise();
+    /**
+     * @param {string | null} [resource] - One resource to revise; all when absent.
+     * @param {string | null} [because] - Who asked, for the revision's line.
+     */
+    revise: async (resource = null, because = null) => {
+      // Re-read the evidence before dividing its disk: it is the one claimant
+      // whose bytes are written by something that never reports them. Only
+      // there: a claimant short of memory asks for memory alone, and walking
+      // the evidence's directory first made every memory answer wait for it —
+      // 3.7 s on a cold AVI behind 1943 other reads (torrent-tv/meta#178).
+      if (diagnostics && (resource === null || resource === evidenceOn)) {
+        const from = Date.now();
+        await diagnostics.measure();
+        because = `${because ?? "a full revision"}, after the evidence was measured in ${Date.now() - from}ms`;
+      }
+      return budget.revise(resource, because);
     },
     segmentBytes: () => segmentBytes,
     diagnostics: diagnostics ?? null,

package/services/torrent/worker/held-bytes.js

@@ -2,9 +2,11 @@ import { pieceStoreOf } from "../piece-store-of.js";
 
 /**
  * How many pieces one read for a reader asks of the store at once: the threads
- * libuv runs file operations on (`UV_THREADPOOL_SIZE`, four unless set). A
- * piece from disk is three of their operations, and more at once would only
- * wait behind them (torrent-tv/meta#178).
+ * libuv runs file operations on (`UV_THREADPOOL_SIZE`). The proxy's entry point
+ * sets 64 where the deployment states none (`bin/thread-pool.js`), and libuv's
+ * own default of four applies only to code run without it, such as the
+ * checks. A piece from disk is three of their operations, and more at once
+ * would only wait behind them (torrent-tv/meta#178).
  */
 const FILE_READS_AT_ONCE = Math.max(1, Number.parseInt(process.env.UV_THREADPOOL_SIZE ?? "", 10) || 4);
 
@@ -225,8 +227,8 @@ export async function readHeldRanges(torrent, fileIndex, ranges, maxBytes, logge
     // and the loop runs 0.3-0.7 s late while the swarm delivers 7-14 MB/s: a
     // 210 MB stretch took 11 s here (Home Assistant 2026-10-12,
     // torrent-tv/meta#178). As many are in flight as the runtime has threads
-    // for file operations (libuv's pool, `UV_THREADPOOL_SIZE`, four by
-    // default); more would only queue behind them and ahead of everything else
+    // for file operations (libuv's pool, `UV_THREADPOOL_SIZE`, 64 as the proxy
+    // starts); more would only queue behind them and ahead of everything else
     // this process reads or writes.
     const readOne = async ([index, span]) => {
       const pieceStart = index * pieceLength;

package/services/viewer/playback-readiness.js

@@ -396,6 +396,16 @@ export function predictPlaybackReadiness(input = {}) {
   }
 
   const constraints = [];
+  // WHICH CONSTRAINT HOLDS THE START, said with the answer: the delay is the
+  // largest of thousands, and the log could only say that some term was
+  // positive while the picture stood for 17 s (torrent-tv/meta#178).
+  let holding = null;
+  const constrain = (value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource) => {
+    constraints.push(value);
+    if (value > 0 && (holding === null || value > holding.value)) {
+      holding = { value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource };
+    }
+  };
   const end = rescale(fromSeconds(duration), unit);
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
     const state = trackState[trackIndex];
@@ -407,7 +417,8 @@ export function predictPlaybackReadiness(input = {}) {
       const before = contiguousEnd(delivered, at);
       for (const range of completion.segment.ranges) addMediaRange(delivered, range);
       const after = contiguousEnd(delivered, at);
-      constraints.push(completion.at - secondsAhead(earliest(before, trackEnd), at));
+      const ahead = secondsAhead(earliest(before, trackEnd), at);
+      constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false);
       if (compare(after, before) <= 0 && completion.segment.ranges.some(({ start }) => compare(start, before) > 0)) {
         // A timestamp hole cannot be repaired by waiting longer. Keep it
         // distinct from an unavailable rate or a slow but finite service.
@@ -425,8 +436,10 @@ export function predictPlaybackReadiness(input = {}) {
       for (const range of production.segment.ranges) addMediaRange(prepared, range);
       // Supply interruption coverage is stock held by the proxy as well as
       // the browser. It is not a browser buffer-size admission rule.
-      constraints.push(production.at - Math.max(0, secondsAhead(before, at) -
-        Math.min(reserve, secondsAhead(trackEnd, before)) * Number(production.requiresSource)));
+      const ahead = Math.max(0, secondsAhead(before, at) -
+        Math.min(reserve, secondsAhead(trackEnd, before)) * Number(production.requiresSource));
+      constrain(production.at - ahead, "production", trackIndex, production.segment.index, production.at, ahead,
+        production.requiresSource);
     }
   }
   const delay = Math.max(0, ...constraints);
@@ -436,6 +449,13 @@ export function predictPlaybackReadiness(input = {}) {
     Math.max(0, reserve - buffered), ready ? 'trajectory-safe-now' :
       Number.isFinite(delay) ? 'minimum-safe-delay' : 'service-not-advancing', preparedSegments);
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
+    // The piece whose `kind` — its production, or its delivery to the page —
+    // comes `atSeconds` from now while the media before it lasts
+    // `aheadSeconds`: the difference is the delay.
+    holdingBy: ready ? null : holding === null ? (originReady ? null : { kind: "position-not-held" })
+      : { kind: holding.kind, track: tracks[holding.trackIndex]?.id ?? holding.trackIndex,
+        segment: holding.segment, atSeconds: holding.atSeconds, aheadSeconds: holding.aheadSeconds,
+        requiresSource: holding.requiresSource },
     preparedUntilSeconds: Math.min(duration, ...trackState.map((state, index) => {
       const ranges = state.clientRanges.map((range) => ({ ...range }));
       for (const item of productions.filter((item) => item.trackIndex === index && item.at <= delay)) {