@torrent-tv/proxy 2.107.49 → 2.107.51

package/package.json

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

package/services/{server/WaitLedger.js → encode/OutputWaitLedger.js}

@@ -58,6 +58,23 @@ export class WaitLedger {
   /** @type {Map<string, Map<string, number>>} */
   #counts = new Map();
 
+  /** @type {Map<string, object>} */
+  #owners = new Map();
+
+  /**
+   * Begin a live output-key lifetime. Reopening a key starts a clean history;
+   * the returned identity lets a held response prove that it still belongs to
+   * this lifetime when it eventually completes.
+   *
+   * @param {string} key
+   * @param {object} identity
+   */
+  open(key, identity) {
+    if (!key || !identity || this.#owners.get(key) === identity) return;
+    this.forget(key);
+    this.#owners.set(key, identity);
+  }
+
   /**
    * Somebody waited this long for something the map ranked this highly.
    *
@@ -66,11 +83,13 @@ export class WaitLedger {
    * @param {number} rank - The map's rank for the thing waited for.
    * @param {number} topRank - The highest rank the map states, so the rank can
    *   be read as a position rather than as an absolute number.
+   * @param {object} [identity] - The output-key lifetime that started this wait.
    */
-  note(key, waitedMs, rank, topRank) {
+  note(key, waitedMs, rank, topRank, identity = undefined) {
     if (!key || !Number.isFinite(waitedMs) || waitedMs < 0) {
       return;
     }
+    if (identity !== undefined && this.#owners.get(key) !== identity) return;
     const band = bandOf(rank, topRank);
     let byBand = this.#waits.get(key);
     if (!byBand) {
@@ -128,15 +147,26 @@ export class WaitLedger {
 
   /**
    * @param {string} key
+   * @param {object} [identity] - Ignore release from an older output lifetime.
    */
-  forget(key) {
+  forget(key, identity = undefined) {
+    if (identity !== undefined && this.#owners.get(key) !== identity) return false;
     this.#waits.delete(key);
     this.#counts.delete(key);
+    if (identity === undefined || this.#owners.get(key) === identity) this.#owners.delete(key);
+    return true;
+  }
+
+  /** Release every record owned by this proxy before its shutdown completes. */
+  clear() {
+    this.#waits.clear();
+    this.#counts.clear();
+    this.#owners.clear();
+  }
+
+  /** Number of output keys with retained measurements. */
+  get size() {
+    return this.#waits.size;
   }
 }
 
-/**
- * One ledger for the process, because the question is asked in two layers and
- * the answer is comparable only if the scale is the same.
- */
-export const waits = new WaitLedger();

package/services/encode/output/OutputCatalog.js

@@ -26,7 +26,11 @@ export class OutputCatalog {
 
   #byId = new Map();
   #lifetime = new Map();
+  /** @type {Map<string, object>} */
+  #waitIdentities = new Map();
   #now;
+  #waitIdentityStarted;
+  #waitIdentityEnded;
 
   /**
    * @param {object} [params]
@@ -35,11 +39,15 @@ export class OutputCatalog {
    *   source file is, which the torrent reports.
    * @param {(address: string) => { index: number, size: number }} [params.largestPieceOf]
    *   The biggest piece an output has made, which the disk knows.
+   * @param {(address: string, identity: object) => void} [params.waitIdentityStarted]
+   * @param {(address: string, identity: object) => void} [params.waitIdentityEnded]
    */
   constructor({
     now = Date.now,
     fileLengthOf = () => 0,
-    largestPieceOf = () => ({ index: -1, size: 0 })
+    largestPieceOf = () => ({ index: -1, size: 0 }),
+    waitIdentityStarted = () => {},
+    waitIdentityEnded = () => {}
   } = {}) {
     this.#now = now;
     // Two facts this catalog needs and does not own, taken as plain functions
@@ -48,15 +56,22 @@ export class OutputCatalog {
     // it is part of the output itself (`OutputSpec`).
     this.fileLengthOf = fileLengthOf;
     this.largestPieceOf = largestPieceOf;
+    this.#waitIdentityStarted = waitIdentityStarted;
+    this.#waitIdentityEnded = waitIdentityEnded;
   }
 
   set(id, output) {
     const known = this.#byId.get(id);
+    const oldAddress = known?.outputKey;
     this.#byId.set(id, output);
     if (known !== output) {
       const at = this.#now();
       this.#lifetime.set(id, { startedAt: at, lastAccessedAt: at });
     }
+    if (known !== output && oldAddress !== output?.outputKey) {
+      this.#forgetWaitIdentityIfUnused(oldAddress);
+    }
+    this.#openWaitIdentity(output?.outputKey);
     return this;
   }
 
@@ -69,13 +84,42 @@ export class OutputCatalog {
   }
 
   delete(id) {
+    const output = this.#byId.get(id);
     this.#lifetime.delete(id);
-    return this.#byId.delete(id);
+    const deleted = this.#byId.delete(id);
+    if (deleted) this.#forgetWaitIdentityIfUnused(output?.outputKey);
+    return deleted;
   }
 
   clear() {
+    const addresses = new Set([...this.#byId.values()].map(output => output?.outputKey).filter(Boolean));
     this.#lifetime.clear();
     this.#byId.clear();
+    for (const address of addresses) this.#forgetWaitIdentityIfUnused(address);
+  }
+
+  /** The shared active lifetime for the output addressed by a live session. */
+  waitIdentity(id) {
+    const output = this.#byId.get(id);
+    return output ? this.#waitIdentities.get(output.outputKey) ?? null : null;
+  }
+
+  #openWaitIdentity(address) {
+    if (typeof address !== "string" || !address || this.#waitIdentities.has(address)) return;
+    const identity = {};
+    this.#waitIdentities.set(address, identity);
+    this.#waitIdentityStarted(address, identity);
+  }
+
+  #forgetWaitIdentityIfUnused(address) {
+    if (typeof address !== "string" || !address) return;
+    for (const output of this.#byId.values()) {
+      if (output?.outputKey === address) return;
+    }
+    const identity = this.#waitIdentities.get(address);
+    if (!identity) return;
+    this.#waitIdentities.delete(address);
+    this.#waitIdentityEnded(address, identity);
   }
 
   touch(outputOrId, at = this.#now()) {

package/services/server/OutputLifecycle.js

@@ -55,7 +55,7 @@ export class OutputLifecycle {
   #host;
 
   /**
-   * @param {object} host - `retention`, `outputNeeded`, `outputWriting`, `outputReading`, `planEncodersSoon`, `now`, `invalidateWaits`, `segmentFormatOfKey`, `viewerSegmentsOn`, `budgetTimer`, `cleanupTimer`, `encodeRuns`, `keyframeTables`, `machineBudget`, `outputTimes`, `outputs`, `returns`, `segmentStore`, `sessionTtlMs`, `sourceFiles`, `timelines`, `viewers`
+   * @param {object} host - `retention`, `outputNeeded`, `outputWriting`, `outputReading`, `planEncodersSoon`, `now`, `invalidateWaits`, `clearWaits`, `segmentFormatOfKey`, `viewerSegmentsOn`, `budgetTimer`, `cleanupTimer`, `encodeRuns`, `keyframeTables`, `machineBudget`, `outputTimes`, `outputs`, `returns`, `segmentStore`, `sessionTtlMs`, `sourceFiles`, `timelines`, `viewers`
    */
   constructor(host) {
     this.#host = host;
@@ -267,6 +267,7 @@ export class OutputLifecycle {
     for (const sessionId of activeIds) {
       await this.disposeSession(sessionId);
     }
+    this.#host.clearWaits?.();
     // Everything this process owns, root included. See SegmentStore.dropAll.
     this.#host.segmentStore.dropAll("the proxy is shutting down");
   }

package/services/server/SegmentServing.js

@@ -78,6 +78,20 @@ export class SegmentServing {
     state.waitListeners.clear();
   }
 
+  /** Identity of the live output-key lifetime named by this session. */
+  waitIdentity(sessionId) {
+    return this.#host.outputs.waitIdentity(sessionId);
+  }
+
+  /** Record a completed wait through the ledger operation wired by the server. */
+  noteWait(ranked, waitedMs, identity) {
+    this.#host.noteWait?.(ranked, waitedMs, identity);
+  }
+
+  waitBandOf(rank, topRank) {
+    return this.#host.waitBandOf?.(rank, topRank) ?? "later";
+  }
+
   /** Observe storage and lifecycle before a request checks file availability. */
   subscribeFileChange(sessionId) {
     const output = isOutputName(sessionId) ? this.#host.outputs.get(sessionId) : null;

package/services/server/ViewerRequests.js

@@ -154,7 +154,7 @@ export class ViewerRequests {
   #forecastPieces = new WeakMap();
 
   /**
-   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `planEncodersSoon`, `encodeRuns`, `encodeSpeedReadingsOf`, `outputTimes`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
+   * @param {object} host - `opening`, `activeOutputFor`, `viewerSecondsOn`, `minimumBufferSecondsFor`, `getSourceStats`, `planEncodersSoon`, `encodeRuns`, `encodeSpeedReadingsOf`, `outputs`, `lookaheadSeconds`, `quality`, `qualityOffer`, `renditions`, `segmentDurationSec`, `segmentStore`, `sourceFiles`, `startupWaitMs`, `viewers`, `placeViewerOn`, `chooseAudioTrack`, `acceptsGeneration`, `generationOfRequest`, `noteGivenOutput`, `holdForResponse`, `noteServingVerdict`, `servingVerdictOf`
    */
   constructor(host) {
     this.#host = host;
@@ -351,6 +351,7 @@ export class ViewerRequests {
     // Whether they were already on the output this request lands on, read at
     // the moment they are put on it.
     let alreadyOn = false;
+    let placedHere = false;
     // THE PLACE ON THIS MACHINE, AND THE VIEWER IN IT, in one synchronous call
     // the opening makes the moment it has the output (roadmap item 97, step 14).
     // Asked and placed together, so the next viewer to open anything is asked
@@ -367,7 +368,7 @@ export class ViewerRequests {
             : this.#host.admitsWatching(candidate);
           if (answer.admitted) {
             known = this.#host.viewers.of(candidate, consumerId);
-            this.placeViewer(candidate, known, startPositionSeconds);
+            placedHere = this.placeViewerOn(candidate, consumerId, startPositionSeconds) === true;
           }
           return answer;
         }
@@ -385,7 +386,7 @@ export class ViewerRequests {
       // browser may need a track re-encoded that the first viewer's could
       // decode as it stands.
       const viewer = this.#host.viewers.of(output, consumerId);
-      viewer.audio = audio;
+      this.#host.chooseAudioTrack(output, consumerId, audio);
       // The picture as their page sees it, which bounds the height made for
       // them from here on (roadmap item 98).
       viewer.noteVisiblePicture(request.visiblePicture);
@@ -400,7 +401,7 @@ export class ViewerRequests {
             : null,
           bufferedAheadSec: request.bufferedAheadSec,
           bufferLimitSeconds: request.bufferLimitSeconds,
-          positionSeconds: startPositionSeconds,
+          ...(placedHere ? { positionSeconds: startPositionSeconds } : {}),
           waiting: true,
           playing: false,
           visiblePicture: request.visiblePicture
@@ -438,65 +439,24 @@ export class ViewerRequests {
   }
 
   /**
-   * Put a viewer where their own request says they are.
+   * Ask the viewer layer to place this viewer at their initial position.
    *
-   * A viewer arrives by asking for a POSITION — zero, or the time an address
-   * bar carried — so "we do not know where they are" is not a state a viewer
-   * can be in. Before 2026-09-05 it was: position was written only by a segment
-   * request, so a viewer counted as placeless until they had asked for a
-   * segment, and an output whose viewers were all placeless had every encoder
-   * on it stopped for having nobody. The soundtrack that failed that day could
-   * not have asked: the segment it would have asked for needed an `init.mp4`
-   * that the stopped encoder was going to make.
-   *
-   * Only ever places a viewer who has none. A viewer already placed is being
-   * kept current by their own requests and seeks, and a fresh create request
-   * carries a default of zero that must not drag them back to the beginning.
-   *
-   * @param {HlsSession} session
-   * @param {import("../viewer/Viewer.js").Viewer} viewer
-   * @param {number} positionSeconds
-   * @returns {void}
-   */
-  /**
-   * Put a viewer named by id onto this output, where they have no position yet.
-   *
-   * The same operation as {@link placeViewer}, addressed the way another
-   * component may address it: by name. Encoding asks for this when a request
-   * for any file of an output is the first sign of the person behind it, and it
-   * must not be handed the viewer to do it — a viewer's record has one writer,
-   * and that is the viewer layer.
+   * Encoding asks for this when a request for any file of an output is the
+   * first sign of the person behind it. The operation takes the viewer's name
+   * and position; the viewer layer owns the record and its idempotency rule.
    *
    * @param {object} output
    * @param {string} consumerId
    * @param {number} positionSeconds
-   * @returns {void}
+   * @returns {boolean} Whether the viewer layer placed the viewer.
    */
   placeViewerOn(output, consumerId, positionSeconds) {
     if (!output || !consumerId) {
-      return;
-    }
-    const viewer = this.#host.viewers.join(output, consumerId);
-    if (viewer) this.placeViewer(output, viewer, positionSeconds);
-  }
-
-  placeViewer(session, viewer, positionSeconds) {
-    if (viewer.position !== null) {
-      return;
-    }
-    const seconds = Number.isFinite(positionSeconds) && positionSeconds > 0 ? positionSeconds : 0;
-    let segment = 0;
-    try {
-      const index = this.#host.outputTimes.segmentIndexForTime(session, seconds);
-      if (Number.isInteger(index) && index >= 0) {
-        segment = index;
-      }
-    } catch {
-      // A session whose cut table is not built yet places its viewer at the
-      // beginning, which is where the run starts anyway.
+      return false;
     }
-    viewer.position = { segment, seconds, at: Date.now(), seeked: null };
-    this.#host.planEncodersSoon();
+    const placed = this.#host.placeViewerOn(output, consumerId, positionSeconds) === true;
+    if (placed) this.#host.planEncodersSoon();
+    return placed;
   }
 
   /**

package/services/server/transcode-session-files.js

@@ -1,6 +1,4 @@
 import { logger } from "../../utils/logger.js";
-import { bandOf, waits } from "./WaitLedger.js";
-
 /**
  * Which viewer is asking, or an empty string where the transport names nobody.
  *
@@ -84,6 +82,12 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
   // a plain HTTP transport, where no loader of ours builds the URL, and then
   // the single shared position decides as it always did.
   const consumerId = consumerOf(req);
+  // Hold the output-key lifetime that this request entered. Disposal followed
+  // by reopening the same key must not let its old completion write into the
+  // new output's measurements.
+  const waitIdentity = typeof serving.waitIdentity === "function"
+    ? serving.waitIdentity(sessionId)
+    : undefined;
   // Readiness or a terminal state ends the wait. A caller leaving cancels it;
   // elapsed time is not evidence that media preparation failed.
   const holdStartedAt = Date.now();
@@ -132,11 +136,12 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
     // like, and without them the table would hold only the failures.
     const ranked = result.ranked ?? null;
     if (ranked) {
-      waits.note(ranked.address, heldMs, ranked.rank, ranked.topRank);
+      serving.noteWait?.(ranked, heldMs, waitIdentity);
     }
     logger.info(
       `[hold] ${fileName} ${outcome} after ${heldMs}ms` +
-      (ranked ? ` (the map wants it ${bandOf(ranked.rank, ranked.topRank)}, rank ${ranked.rank} of ${ranked.topRank})` : "")
+      (ranked ? ` (the map wants it ${serving.waitBandOf?.(ranked.rank, ranked.topRank) ?? "later"}, ` +
+        `rank ${ranked.rank} of ${ranked.topRank})` : "")
     );
   }
 

package/services/server/wire-outputs.js

@@ -10,7 +10,7 @@
 
 import { logger } from "../../utils/logger.js";
 import { KeyframeTables } from "../media/KeyframeTables.js";
-import { waits } from "./WaitLedger.js";
+import { bandOf, WaitLedger } from "../encode/OutputWaitLedger.js";
 import { readEndedChildrenCpuSeconds, readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
 import { PriorityOrchestrator } from "../viewer/PriorityOrchestrator.js";
@@ -51,6 +51,7 @@ import {
   noteStepBeingWarmed,
   noteStepOnScreen,
   outputsBeingPrepared,
+  placeInitially,
   placeOn,
   presentOn,
   qualityModeOf,
@@ -244,6 +245,9 @@ export function wireOutputs({
     // Told when an encoder starts or ends: the room this host has for one more
     // encode changes with it, and the server chooses proxies by that room.
     onEncodersChanged = null}) {
+  // Long-lived wait diagnostics belong to this wired output graph: each live
+  // output key owns its record, and the graph releases it at the last session.
+  const waits = new WaitLedger();
   const parts = {};
   const audioDescriptionOf = (output) => (getCachedAudioTracks?.({
     sourceKey: output.file.sourceKey, fileIndex: output.spec.grid?.fileIndex ?? output.file.fileIndex
@@ -552,6 +556,9 @@ export function wireOutputs({
     get lookaheadSeconds() { return parts.lookaheadSeconds; },
     get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
+    noteWait: (ranked, waitedMs, identity) =>
+      waits.note(ranked.address, waitedMs, ranked.rank, ranked.topRank, identity),
+    waitBandOf: bandOf,
     get segmentStore() { return parts.segmentStore; },
     get startupWaitMs() { return parts.startupWaitMs; },
     get viewers() { return parts.viewers; },
@@ -565,6 +572,7 @@ export function wireOutputs({
     outputReading: key => parts.segmentStore.isReading(key) || parts.viewers.responsesHold(key),
     planEncodersSoon: () => parts.encodeRuns.planEncodersSoon(),
     invalidateWaits: (output) => parts.serving.invalidateWaits(output),
+    clearWaits: () => waits.clear(),
     segmentFormatOfKey,
     // Where the viewers of one output stand, in its segments: what the store
     // the output retention policy reads to give disk back in the right order.
@@ -675,8 +683,11 @@ export function wireOutputs({
       return video + audio;
     },
     get opening() { return parts.opening; },
-    get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
+    placeViewerOn: (output, consumerId, seconds, now) =>
+      placeInitially(parts.viewers, output, consumerId, seconds, now),
+    chooseAudioTrack: (output, consumerId, choice) =>
+      chooseAudioTrack(parts.viewers, output, consumerId, choice),
     get lookaheadSeconds() { return parts.lookaheadSeconds; },
     get quality() { return parts.quality; },
     get qualityOffer() { return parts.qualityOffer; },
@@ -960,7 +971,9 @@ export function wireOutputs({
   // belongs to, the steps, the soundtracks, the height a step is named by.
   parts.outputs = new OutputCatalog({
     fileLengthOf: (session) => parts.hostLoad.fileLengthByKey.get(session.file.key) ?? 0,
-    largestPieceOf: (address) => parts.segmentStore.largestPiece(address)
+    largestPieceOf: (address) => parts.segmentStore.largestPiece(address),
+    waitIdentityStarted: (address, identity) => waits.open(address, identity),
+    waitIdentityEnded: (address, identity) => waits.forget(address, identity)
   });
   // Where produced segments live, addressed by WHAT they are rather than by
   // which session's encoder wrote them. Two sessions of one output — two

package/services/viewer/Viewer.js

@@ -427,6 +427,22 @@ export class Viewer {
     this.bufferedSeconds = 0;
   }
 
+  /**
+   * Place this viewer at the position supplied by their first output opening.
+   * An opening that reuses an output must not reset a position already stated
+   * by this viewer. Initial placement has none of the buffer or pause effects
+   * of an explicit seek.
+   *
+   * @param {number} seconds
+   * @param {number} [now]
+   * @returns {boolean} Whether this call placed the viewer.
+   */
+  placeInitially(seconds, now = Date.now()) {
+    if (this.position !== null) return false;
+    this.#place(Number.isFinite(seconds) && seconds > 0 ? seconds : 0, now);
+    return true;
+  }
+
   /**
    * Where they are, stated — without anything a move to another place means.
    *

package/services/viewer/choices.js

@@ -96,10 +96,26 @@ export function audioChoiceOf(viewers, output, consumerId) {
  * @returns {void}
  */
 export function chooseAudioTrack(viewers, output, consumerId, choice) {
+  if (!choice) return;
   const viewer = viewers.join(output, consumerId);
   if (viewer) viewer.audio = { trackIndex: choice.trackIndex, transcode: choice.transcode === true };
 }
 
+/**
+ * Place a viewer at the initial position named by an output opening.
+ *
+ * @param {object} viewers
+ * @param {object} output
+ * @param {string} consumerId
+ * @param {number} seconds
+ * @param {number} [now]
+ * @returns {boolean} Whether this call placed the viewer.
+ */
+export function placeInitially(viewers, output, consumerId, seconds, now = Date.now()) {
+  const viewer = viewers.join(output, consumerId, now);
+  return viewer?.placeInitially(seconds, now) ?? false;
+}
+
 /**
  * The step on this viewer's screen, as a session id, or null for the picture
  * itself.