@torrent-tv/proxy 2.101.10 → 2.101.12

package/package.json

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

package/services/encode/EncodeOrchestrator.js

@@ -156,10 +156,19 @@ export class EncodeOrchestrator {
    * Whether the run a viewer needs first is short of the processor, from the
    * last time who has the processor was decided (`processorShortfall`).
    *
-   * @type {{ address: string, speed: { middle: number, scatter: number }, need: number, seconds: number } | null}
+   * @type {{ address: string, speed: { middle: number, scatter: number }, need: number, seconds: number,
+   *   waitedFor?: number } | null}
    */
   #shortfall = null;
 
+  /**
+   * The piece each waiting viewer's start is held by the production of, as
+   * the start forecast last said it (`noteViewerWaiting`), by viewer.
+   *
+   * @type {Map<string, { address: string, index: number }>}
+   */
+  #viewersWaiting = new Map();
+
   /**
    * What starting and stopping an encoder was measured to cost on this host,
    * before any viewer existed. Told once; real runs replace it as they end.
@@ -455,6 +464,7 @@ export class EncodeOrchestrator {
     this.#lastError.delete(address);
     this.#lastProgress.delete(address);
     this.#failedStarts.delete(address);
+    this.#forgetWaitsOn(address);
   }
 
   /** @param {string} address @returns {{ at: number, count: number, blocked: boolean, limit: number }} */
@@ -610,6 +620,37 @@ export class EncodeOrchestrator {
     // right whatever the last one met.
     if (!Array.isArray(zones) || zones.length === 0) {
       this.#forgetInputState(address);
+      this.#forgetWaitsOn(address);
+    }
+  }
+
+  /**
+   * What a viewer's start waits for, as the start forecast says each time it
+   * is asked: the production of piece `index` of `address`, or nothing an
+   * encoder makes (null). The map's deadlines can be met while the forecast
+   * still holds the viewer for the stock it wants after the piece they stand
+   * in: on Home Assistant (r87, torrent-tv/meta#180) the download was let go
+   * 5.3 s before a seek's viewer started, while the forecast held them for
+   * the production of the next piece. Who has the processor is decided again
+   * when it changes.
+   *
+   * @param {string} viewer
+   * @param {{ address: string, index: number } | null} wait
+   */
+  noteViewerWaiting(viewer, wait) {
+    const said = this.#viewersWaiting.get(viewer) ?? null;
+    const next = typeof wait?.address === "string" && Number.isInteger(wait.index)
+      ? { address: wait.address, index: wait.index } : null;
+    if (said?.address === next?.address && said?.index === next?.index) return;
+    if (next) this.#viewersWaiting.set(viewer, next);
+    else this.#viewersWaiting.delete(viewer);
+    this.shareTheMachine();
+  }
+
+  /** @param {string} address */
+  #forgetWaitsOn(address) {
+    for (const [viewer, wait] of this.#viewersWaiting) {
+      if (wait.address === address) this.#viewersWaiting.delete(viewer);
     }
   }
 
@@ -739,9 +780,14 @@ export class EncodeOrchestrator {
     const now = this.now();
     const running = this.#runningNow();
     const need = this.#needOf(leading);
-    // Only a run in a band a viewer is in can be short for a viewer.
-    const short = leading.urgent === true ? this.#pauseRule.shortfall({ leader: leading.run, need }) : null;
-    this.#noteShortfall(short ? { address: leading.address, ...short } : null);
+    // Only a run in a band a viewer is in can be short for a viewer, and a run
+    // making a piece the start forecast holds a viewer for needs all it can
+    // make, whatever the map's deadlines say.
+    const waited = this.#runAViewerWaitsFor();
+    const judged = waited ?? (leading.urgent === true ? leading : null);
+    const short = judged
+      ? this.#pauseRule.shortfall({ leader: judged.run, need: waited ? Number.POSITIVE_INFINITY : need }) : null;
+    this.#noteShortfall(short ? { address: judged.address, ...short, ...(waited ? { waitedFor: waited.index } : {}) } : null);
     const free = this.#processorReading("freeCores");
     const others = this.#processorReading("otherCores");
     for (const [address, runs] of this.#runs) {
@@ -768,20 +814,41 @@ export class EncodeOrchestrator {
     this.#placeHeldBack(leading);
   }
 
+  /**
+   * The live run making a piece the start forecast holds a viewer for, the
+   * most urgent if there are several; null where none is.
+   *
+   * @returns {{ address: string, index: number, run: object, band: { urgent: boolean, priority: number } } | null}
+   */
+  #runAViewerWaitsFor() {
+    let found = null;
+    for (const { address, index } of this.#viewersWaiting.values()) {
+      for (const run of this.#runs.get(address) ?? []) {
+        if (!run.isAlive || run.isStopping || run.isSuspended === true || index < run.head || index > run.to) continue;
+        const band = this.#bandAt(address, run.head);
+        if (!found || compareUrgency(band, found.band) < 0) found = { address, index, run, band };
+      }
+    }
+    return found;
+  }
+
   /**
    * Whether the run a viewer needs first is short of the processor, and by
    * what: its output, the speed it made over its seconds kept (median and
    * scatter) and the speed its deadlines need, infinite where a viewer waits
-   * for it (`PauseRule.shortfall`, torrent-tv/meta#180). Null where it is not
-   * short, or nothing measured it.
+   * for it (`PauseRule.shortfall`, torrent-tv/meta#180). The run the start
+   * forecast holds a viewer for is judged before the map's leader, and names
+   * the piece it is waited for by (`waitedFor`). Null where it is not short,
+   * or nothing measured it.
    *
-   * @returns {{ address: string, speed: { middle: number, scatter: number }, need: number, seconds: number } | null}
+   * @returns {{ address: string, speed: { middle: number, scatter: number }, need: number, seconds: number,
+   *   waitedFor?: number } | null}
    */
   processorShortfall() {
     return this.#shortfall;
   }
 
-  /** @param {{ address: string, speed: { middle: number, scatter: number }, need: number, seconds: number } | null} short */
+  /** @param {{ address: string, speed: { middle: number, scatter: number }, need: number, seconds: number, waitedFor?: number } | null} short */
   #noteShortfall(short) {
     this.#shortfall = short;
     this.shortfallNoted();

package/services/server/OutputLifecycle.js

@@ -403,17 +403,12 @@ export class OutputLifecycle {
     if (typeof consumerId !== "string" || consumerId.length === 0) {
       return 0;
     }
-    const watched = this.#host.viewers.get(consumerId)?.outputs;
-    if (!watched || watched.size === 0) {
-      this.#host.viewers.hasGone(consumerId);
-      return 0;
-    }
-    // Copied before anything is released: releasing walks the same set.
-    const outputs = [...watched];
+    // Presence ends synchronously, before disposal waits for a child process.
+    // Late reports and preparations must not rejoin this viewer meanwhile.
+    const outputs = this.#host.viewers.hasGone(consumerId);
     for (const outputId of outputs) {
       await this.releaseSessionConsumer(outputId, consumerId, because);
     }
-    this.#host.viewers.hasGone(consumerId);
     return outputs.length;
   }
 

package/services/server/SegmentServing.js

@@ -904,9 +904,8 @@ export class SegmentServing {
    * backwards several times a second — measured 2026-09-13, 77 encoder starts
    * and 141 stops in six minutes while both viewers sat frozen.
    *
-   * A viewer is forgotten once nothing has been heard from them for longer than
-   * any silence a watching viewer can produce. The figure is the proxy's own
-   * look-ahead, not a chosen interval.
+   * Presence is established by arrival or an explicit opening and ends with
+   * the connection. A queued request cannot restore a viewer who has left.
    *
    * @param {HlsSession} session
    * @param {string} consumerId
@@ -917,7 +916,7 @@ export class SegmentServing {
     if (!consumerId) {
       return;
     }
-    this.#host.viewers.of(session, consumerId).seen();
+    this.#host.viewers.join(session, consumerId)?.seen();
   }
 
   /**

package/services/server/ViewerRequests.js

@@ -121,7 +121,13 @@ export class ViewerRequests {
     // What this viewer's link last measured, where the request does not say:
     // a viewer who comes back to open another film has a link this proxy has
     // already measured, and the output they are given is judged by it.
-    const known = consumerId ? this.#host.viewers.get(consumerId) : null;
+    let known = consumerId ? this.#host.viewers.get(consumerId) : null;
+    const requireViewing = () => {
+      request.signal?.throwIfAborted();
+      if (known && this.#host.viewers.get(consumerId) !== known) {
+        throw new DOMException("The viewer left while the output was opening.", "AbortError");
+      }
+    };
     const viewerLinkMbps = request.viewerLinkMbps ?? known?.linkReading()?.linkMbps ?? null;
     const startPositionSeconds = request.startPositionSeconds ?? 0;
     // Whether they were already on the output this request lands on, read at
@@ -136,13 +142,14 @@ export class ViewerRequests {
     // state nothing has every encoder on it stopped.
     const claim = consumerId
       ? (candidate) => {
-          request.signal?.throwIfAborted();
+          requireViewing();
           alreadyOn = this.#host.viewers.forOutput(candidate).has(consumerId);
           const answer = alreadyOn
             ? { admitted: true, reason: "already watching it", speedX: null }
             : this.#host.admitsWatching(candidate);
           if (answer.admitted) {
-            this.placeViewer(candidate, this.#host.viewers.of(candidate, consumerId), startPositionSeconds);
+            known = this.#host.viewers.of(candidate, consumerId);
+            this.placeViewer(candidate, known, startPositionSeconds);
           }
           return answer;
         }
@@ -152,7 +159,7 @@ export class ViewerRequests {
       viewerLinkMbps,
       claim
     });
-    request.signal?.throwIfAborted();
+    requireViewing();
     if (consumerId) {
       const joined = existed && !alreadyOn;
       // What THIS viewer wants of the sound, which an output they are joining
@@ -257,7 +264,8 @@ export class ViewerRequests {
     if (!output || !consumerId) {
       return;
     }
-    this.placeViewer(output, this.#host.viewers.of(output, consumerId), positionSeconds);
+    const viewer = this.#host.viewers.join(output, consumerId);
+    if (viewer) this.placeViewer(output, viewer, positionSeconds);
   }
 
   placeViewer(session, viewer, positionSeconds) {
@@ -320,7 +328,8 @@ export class ViewerRequests {
     // from where the viewers are, and both orchestrators read the map.
     // A seek that names nobody moves nobody: the route refuses it before it
     // gets here.
-    const viewer = this.#host.viewers.of(named, consumerId);
+    const viewer = this.#host.viewers.join(named, consumerId);
+    if (!viewer) return false;
     viewer.moveTo(positionSeconds);
     // WHICH VIEWING THEIR REQUESTS NOW BELONG TO, as the page states it.
     //
@@ -790,6 +799,11 @@ export class ViewerRequests {
       })}`);
     }
     this.#sayHolding(session, consumerId, measurement, forecast, input, now);
+    // The encoder this viewer waits for, told to whoever shares the processor
+    // (torrent-tv/meta#180): the forecast knows it before the map's deadlines do.
+    const holding = forecast.holdingBy;
+    this.#host.noteViewerWaiting?.(consumerId || session.id,
+      holding?.kind === "production" ? { address: holding.track, index: holding.segment } : null);
     return forecast;
   }
 

package/services/server/wire-outputs.js

@@ -631,6 +631,7 @@ export function wireOutputs({
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
     planEncodersSoon: (...args) => parts.encodeRuns.planEncodersSoon(...args),
     waitUntilReady: (...args) => parts.serving.waitUntilReady(...args),
+    noteViewerWaiting: (viewer, wait) => parts.encodeOrchestrator?.noteViewerWaiting(viewer, wait),
     get encodeRuns() { return parts.encodeRuns; },
     // When this viewer's playback can start and run to the end: the viewer
     // component's forecast, which models the viewer's browser.
@@ -781,7 +782,8 @@ export function wireOutputs({
       const swarm = parts.hostLoad.swarmRate();
       const made = `the encoder a viewer needs first made ${short.speed.middle.toFixed(2)}x ` +
         `(scatter ${short.speed.scatter.toFixed(2)}) over ${short.seconds}s` +
-        (Number.isFinite(short.need) ? `, needing ${short.need.toFixed(2)}x` : " with a viewer waiting");
+        (Number.isFinite(short.need) ? `, needing ${short.need.toFixed(2)}x` : " with a viewer waiting") +
+        (Number.isInteger(short.waitedFor) ? ` for its #${short.waitedFor} by the start forecast` : "");
       if (!Number.isFinite(needs) || needs <= 0) {
         because = `${made}; its film's bytes per second are unknown`;
       } else if (swarm === null) {

package/services/viewer/Viewers.js

@@ -179,6 +179,16 @@ export class Viewers {
     return this.#byId.get(consumerId) ?? null;
   }
 
+  /**
+   * Add an output to an existing viewing. A request or preparation completing
+   * after departure cannot establish presence again; only arrival or a new
+   * explicit opening may do that through `present` or `of`.
+   */
+  join(output, consumerId, now = Date.now()) {
+    const viewer = this.get(consumerId);
+    return viewer?.isPresent() ? this.of(output, consumerId, now) : null;
+  }
+
   sourceKeys() {
     return new Set([...this.#byId.values()].filter(viewer => viewer.isPresent() && viewer.source)
       .map(viewer => viewer.source.sourceKey));

package/services/viewer/choices.js

@@ -96,7 +96,8 @@ export function audioChoiceOf(viewers, output, consumerId) {
  * @returns {void}
  */
 export function chooseAudioTrack(viewers, output, consumerId, choice) {
-  viewers.of(output, consumerId).audio = { trackIndex: choice.trackIndex, transcode: choice.transcode === true };
+  const viewer = viewers.join(output, consumerId);
+  if (viewer) viewer.audio = { trackIndex: choice.trackIndex, transcode: choice.transcode === true };
 }
 
 /**
@@ -122,7 +123,8 @@ export function stepOnScreenOf(viewers, output, consumerId) {
  * @returns {void}
  */
 export function noteStepOnScreen(viewers, output, consumerId, stepId) {
-  viewers.of(output, consumerId).activeVariantId = stepId;
+  const viewer = viewers.join(output, consumerId);
+  if (viewer) viewer.activeVariantId = stepId;
 }
 
 /**
@@ -148,7 +150,7 @@ export function noteStepBeingWarmed(viewers, output, consumerId, stepId) {
   // Clearing does not make a watcher. Warming one FOR somebody is them
   // watching; saying nothing is being warmed for a person who watches nothing
   // would put them on this output for the sake of a null.
-  const viewer = stepId ? viewers.of(output, consumerId) : on(viewers, output, consumerId);
+  const viewer = stepId ? viewers.join(output, consumerId) : on(viewers, output, consumerId);
   if (viewer) {
     // When the warming of THIS step began: kept across a repeat of the same
     // step, started afresh for another one, gone with it.
@@ -192,16 +194,15 @@ export function audioBeingWarmedOf(viewers, output, consumerId) {
  * @returns {void}
  */
 export function noteAudioBeingWarmed(viewers, output, consumerId, renditionId) {
-  const viewer = renditionId ? viewers.of(output, consumerId) : on(viewers, output, consumerId);
+  const viewer = renditionId ? viewers.join(output, consumerId) : on(viewers, output, consumerId);
   if (viewer) {
     viewer.warmingAudioId = renditionId;
   }
 }
 
 /**
- * This viewer is watching this output. Asking for any of its files is watching
- * it: nothing is made for an output nobody is on, so the init a player needs
- * before it can ask for a segment would never be made.
+ * A present viewer is watching this output. Asking for its init or a segment
+ * adds the output to their viewing; a late request cannot establish presence.
  *
  * @param {object} viewers
  * @param {object} output
@@ -209,7 +210,7 @@ export function noteAudioBeingWarmed(viewers, output, consumerId, renditionId) {
  * @returns {void}
  */
 export function watches(viewers, output, consumerId) {
-  viewers.of(output, consumerId);
+  viewers.join(output, consumerId);
 }
 
 /**
@@ -222,7 +223,7 @@ export function watches(viewers, output, consumerId) {
  * @returns {void}
  */
 export function placeOn(viewers, output, consumerId, seconds) {
-  viewers.of(output, consumerId).moveTo(seconds);
+  viewers.join(output, consumerId)?.moveTo(seconds);
 }
 
 /**

package/services/viewer/report-intake.js

@@ -23,13 +23,12 @@ import { activeOutputFor } from "./active-output.js";
  *
  * @param {object} params
  * @param {{ get: (id: string) => object | undefined }} params.outputs - Every live output, by id.
- * @param {{ of: (session: object, consumerId: string) => import("./Viewer.js").Viewer }} params.viewers
+ * @param {{ join: (session: object, consumerId: string) => import("./Viewer.js").Viewer | null }} params.viewers
  * @param {string} params.sessionId - The session the page addresses, which is
  *   always the picture's: the browser is not told which rung it is on.
  * @param {object} params.report - What they said about themselves.
  * @param {number} [params.now]
- * @returns {boolean} False when no such session is live, which is the page
- *   reporting into one that has been disposed.
+ * @returns {boolean} False when the session or its viewer has gone.
  */
 export function recordViewerReport({ outputs, viewers, sessionId, report, now = Date.now() }) {
   const named = outputs.get(sessionId);
@@ -41,6 +40,8 @@ export function recordViewerReport({ outputs, viewers, sessionId, report, now =
   // The stream on screen is the reporter's own: with two viewers on two rungs,
   // one report says nothing about the other's encoder.
   const session = activeOutputFor({ base: named, consumerId, outputs, viewers });
-  viewers.of(session, consumerId).report(report, now);
+  const viewer = viewers.join(session, consumerId);
+  if (!viewer) return false;
+  viewer.report(report, now);
   return true;
 }