@torrent-tv/proxy 2.107.52 → 2.107.54

package/package.json

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

package/routes/api/sources/files/get.js

@@ -33,6 +33,11 @@ export async function handleApiSourceFilesGet(req, reply, { sourceRegistry, torr
     return reply.code(404).send({ error: "Source key was not found." });
   }
 
+  const consumerId = typeof req.query?.consumerId === "string" ? req.query.consumerId.trim() : "";
+  const generationRaw = typeof req.query?.generation === "string" ? req.query.generation : "";
+  const generation = generationRaw !== "" && /^\d+$/.test(generationRaw) ? Number(generationRaw) : null;
+  const viewerToken = viewerRequests?.viewerTokenOf?.(consumerId) ?? null;
+
   let cancelled;
   const waitPromise = new Promise(resolve => { cancelled = () => resolve(CANCELLED); });
   reply.raw?.once?.("close", cancelled);
@@ -71,10 +76,7 @@ export async function handleApiSourceFilesGet(req, reply, { sourceRegistry, torr
     if (file.excludedReason) logger.info(`contents request=${req.id ?? "unstated"} source=${sourceKey} ` +
       `file=${file.fileIndex} name=${JSON.stringify(file.relativePath)} bytes=${file.length} excluded=${file.excludedReason}`);
   }
-  const consumerId = typeof req.query?.consumerId === "string" ? req.query.consumerId.trim() : "";
   if (consumerId) viewers?.visibleFiles(consumerId, sourceKey, contents.items.map(item => item.fileIndex));
-  const generationRaw = typeof req.query?.generation === "string" ? req.query.generation : "";
-  const generation = generationRaw !== "" && /^\d+$/.test(generationRaw) ? Number(generationRaw) : null;
   const linkMbps = Number(req.query?.linkMbps);
   const linkSampleAgeMs = Number(req.query?.linkSampleAgeMs);
   const earlyLink = Number.isFinite(linkMbps) && linkMbps > 0
@@ -84,7 +86,7 @@ export async function handleApiSourceFilesGet(req, reply, { sourceRegistry, torr
     if (!consumerId || !Number.isSafeInteger(generation) || file.kind !== "video" || file.excludedReason) return file;
     viewerRequests?.noteWaitFileSnapshot?.({ consumerId, generation, sourceKey,
       fileIndex: file.fileIndex, fileName: file.relativePath ?? file.name, fileLength: file.length,
-      ...earlyLink });
+      ...earlyLink, ...(viewerToken ? { viewerToken } : {}) });
     return file;
   });
   return reply.send({

package/routes/api/sources/stats/get.js

@@ -34,6 +34,7 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
   const fileIndexRaw = typeof req.query.fileIndex === "string" ? req.query.fileIndex : "";
   const fileIndex = fileIndexRaw !== "" && /^\d+$/.test(fileIndexRaw) ? Number(fileIndexRaw) : null;
   const consumerId = typeof req.query.consumer === "string" ? req.query.consumer : "";
+  const viewerToken = viewerRequests?.viewerTokenOf?.(consumerId) ?? null;
   const generationRaw = typeof req.query.generation === "string" ? req.query.generation : "";
   const generation = generationRaw !== "" && /^\d+$/.test(generationRaw) ? Number(generationRaw) : null;
   const requestedFileName = typeof req.query.fileName === "string" ? req.query.fileName : "";
@@ -47,7 +48,8 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
   const noteInitialSnapshot = () => {
     if (consumerId && Number.isSafeInteger(generation) && Number.isSafeInteger(fileIndex)) {
       viewerRequests?.noteWaitFileSnapshot?.({ consumerId, generation, sourceKey, fileIndex,
-        fileName: requestedFileName, fileLength: requestedFileLength, ...earlyLink });
+        fileName: requestedFileName, fileLength: requestedFileLength, ...earlyLink,
+        ...(viewerToken ? { viewerToken } : {}) });
     }
   };
 
@@ -68,12 +70,10 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
   // local lookup. Without the await the reply was the pending promise itself,
   // which serialises to `{}` — the empty stats seen in the field 2026-08-02.
   const statsStartedAt = performance.now();
-  let statsCompletedAt;
   let stats;
   try {
     stats = await torrentPool.getFileStats(torrent, fileIndex);
   } finally {
-    statsCompletedAt = performance.now();
     logger.info(`[stats] ${sourceKey.slice(0, 8)} getFileStatsMs=${(performance.now() - statsStartedAt).toFixed(1)}`);
   }
   if (stats?.pending || !stats) {
@@ -155,13 +155,15 @@ export async function handleApiSourceStatsGet(req, reply, { sourceRegistry, torr
   if (consumerId && Number.isSafeInteger(generation)) {
     viewerRequests?.noteWaitSourceSnapshot?.({ consumerId, generation, sourceKey, fileIndex,
       fileName: torrent.files?.[fileIndex]?.name ?? requestedFileName, fileLength: requestedFileLength,
-      stats, ...earlyLink });
+      stats, ...earlyLink, ...(viewerToken ? { viewerToken } : {}) });
   }
   const responsePreparedAtProxyMs = performance.now();
   return reply.send({ ...stats, sourceSnapshotTransport: {
+    clockEpoch: performance.timeOrigin,
+    snapshotClockEpoch: stats.sourceCapture?.clockEpoch ?? null,
     requestReceivedAtProxyMs,
-    snapshotStartedAtProxyMs: statsStartedAt,
-    snapshotCompletedAtProxyMs: statsCompletedAt,
+    snapshotStartedAtProxyMs: stats.sourceCapture?.validity === "valid" ? stats.sourceCapture.startedAt : null,
+    snapshotCompletedAtProxyMs: stats.sourceCapture?.validity === "valid" ? stats.sourceCapture.completedAt : null,
     responsePreparedAtProxyMs
   } });
 }

package/routes/api/transcode-sessions/net-report/post.js

@@ -117,12 +117,30 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply,
       linkMbps: Number.isFinite(linkMbps) && linkMbps > 0 ? linkMbps : undefined,
       linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : undefined,
       linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : undefined,
+      linkSampleAgeMs: Number.isFinite(body.linkSampleAgeMs) && body.linkSampleAgeMs >= 0
+        ? body.linkSampleAgeMs : undefined,
       appendSessionId: sessionId,
       appendEpoch: typeof body.appendEpoch === "string" ? body.appendEpoch : undefined,
       appendEpochStartedAt: Number.isFinite(body.appendEpochStartedAt) && body.appendEpochStartedAt > 0
         ? body.appendEpochStartedAt : undefined,
       appendSnapshotAt: Number.isFinite(body.appendSnapshotAt) && body.appendSnapshotAt > 0
         ? body.appendSnapshotAt : undefined,
+      captureClockEpoch: Number.isFinite(body.captureClockEpoch) ? body.captureClockEpoch : undefined,
+      captureEpoch: typeof body.captureEpoch === "string" ? body.captureEpoch : undefined,
+      captureEpochStartedAtBrowser: Number.isFinite(body.captureEpochStartedAtBrowser)
+        ? body.captureEpochStartedAtBrowser : undefined,
+      captureRevision: Number.isSafeInteger(body.captureRevision) ? body.captureRevision : undefined,
+      captureStartedAtBrowser: Number.isFinite(body.captureStartedAtBrowser) ? body.captureStartedAtBrowser : undefined,
+      captureCompletedAtBrowser: Number.isFinite(body.captureCompletedAtBrowser)
+        ? body.captureCompletedAtBrowser : undefined,
+      linkSampleStartedAtBrowser: Number.isFinite(body.linkSampleStartedAtBrowser)
+        ? body.linkSampleStartedAtBrowser : undefined,
+      linkSampleCompletedAtBrowser: Number.isFinite(body.linkSampleCompletedAtBrowser)
+        ? body.linkSampleCompletedAtBrowser : undefined,
+      linkSampleActionId: typeof body.linkSampleActionId === "string" ? body.linkSampleActionId : undefined,
+      linkSampleGeneration: Number.isSafeInteger(body.linkSampleGeneration) ? body.linkSampleGeneration : undefined,
+      linkSampleClockEpoch: Number.isFinite(body.linkSampleClockEpoch) ? body.linkSampleClockEpoch : undefined,
+      linkSampleRevision: Number.isSafeInteger(body.linkSampleRevision) ? body.linkSampleRevision : undefined,
       appendService: body.appendService && typeof body.appendService === "object" ? body.appendService : undefined,
       fragmentService: body.fragmentService && typeof body.fragmentService === "object" ? body.fragmentService : undefined,
       bufferedAheadSec,

package/routes/api/transcode-sessions/progress/get.js

@@ -19,13 +19,21 @@ export async function handleApiTranscodeSessionsProgressGet(req, reply, { viewer
   // quality change the stream on screen is another session — a different one
   // for each viewer who changed.
   const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  const progress = await viewerRequests.getSessionProgress(sessionId, consumerId);
+  const stated = Number(req.query?.generation);
+  const generation = Number.isSafeInteger(stated) && stated >= 0 ? stated : Number.NaN;
+  const progress = await viewerRequests.getSessionProgress(sessionId, consumerId, generation);
+  if (progress?.superseded === true) {
+    return reply.code(409).send({ error: "Viewer action was superseded." });
+  }
   if (!progress) {
     return reply.code(404).send({ error: "Transcode session was not found." });
   }
 
   const responsePreparedAtProxyMs = performance.now();
   progress.snapshotTransport = {
+    clockEpoch: performance.timeOrigin,
+    snapshotClockEpoch: progress.playbackReadiness?.snapshotClockEpoch ?? null,
+    generation: Number.isSafeInteger(generation) ? generation : null,
     requestReceivedAtProxyMs,
     snapshotAtProxyMs: progress.playbackReadiness?.snapshotAtProxyMs ?? null,
     responsePreparedAtProxyMs

package/services/encode/EncodeRun.js

@@ -37,6 +37,8 @@
  * owns the output. This carries a decision out and reports what happened.
  */
 
+import { performance } from "node:perf_hooks";
+
 import { ENCODE_RUN_EVENT, ENCODE_RUN_STATE, INITIAL_RUN_STATE, nextState } from "./encode-run-state.js";
 import { classifyEncodeExit, ENCODE_EXIT } from "./encode-exit.js";
 import { workDeltaBetween } from "./encoder-readings.js";
@@ -228,6 +230,7 @@ export class EncodeRun {
    * @param {(args: string[]) => import("node:child_process").ChildProcess} params.spawn
    * @param {{ info: (line: string) => void, warn: (line: string) => void, error?: (line: string) => void }} params.logger
    * @param {() => number} [params.now]
+   * @param {() => number} [params.monotonicNow]
    * @param {(ended: RunEnded) => void} [params.onEnded]
    * @param {(reading: { speed: number, at: number, workSeconds: number, workingSeconds: number }) => void} [params.onSpeedMeasured] -
    *   Told each time this run has measured its processing speed, once per
@@ -291,6 +294,7 @@ export class EncodeRun {
     indexOfName,
     startSeconds = 0,
     totalSeconds = null,
+    monotonicNow,
     because = "no reason was given"
   }) {
     this.address = address;
@@ -302,10 +306,11 @@ export class EncodeRun {
     this.spawnProcess = spawn;
     this.logger = logger;
     this.now = typeof now === "function" ? now : Date.now;
-    this.progress = new RunProgress({ startSeconds, totalSeconds, now: this.now });
+    this.monotonicNow = typeof monotonicNow === "function" ? monotonicNow : () => performance.now();
+    this.progress = new RunProgress({ startSeconds, totalSeconds, now: this.now, monotonicNow: this.monotonicNow });
     /** Where this run's time went: its own work, or waiting, or stopped. */
     this.clock = new RunClock({ now: this.now });
-    this.#pieceSample = { at: this.now(), producedSeconds: 0, workingMs: 0 };
+    this.#pieceSample = { at: this.now(), monotonicAt: this.monotonicNow(), producedSeconds: 0, workingMs: 0 };
     this.onEnded = typeof onEnded === "function" ? onEnded : () => {};
     this.onProgress = typeof onProgress === "function" ? onProgress : () => {};
     this.onProduced = typeof onProduced === "function" ? onProduced : () => {};
@@ -463,6 +468,7 @@ export class EncodeRun {
       this.#pieceSample = {
         ...this.#workSample,
         at: this.now(),
+        monotonicAt: this.monotonicNow(),
         workingMs: this.clock.workingMs()
       };
     }
@@ -600,6 +606,7 @@ export class EncodeRun {
       const at = this.now();
       this.#workSample = {
         at,
+        monotonicAt: this.progress.updatedAtMonotonic,
         producedSeconds: Math.max(0, this.progress.processedSeconds - this.progress.startPositionSeconds),
         workingMs: this.clock.workingMs(at)
       };
@@ -766,7 +773,10 @@ export class EncodeRun {
     }
     const work = workDeltaBetween(this.#pieceSample, sample);
     if (work !== null) {
-      this.#speedReading = { speed: work.workSeconds / work.workingSeconds, at: sample.at, ...work };
+      this.#speedReading = { speed: work.workSeconds / work.workingSeconds, at: sample.at, ...work,
+        captureOwner: "proxy-encoder", captureClock: "performance", captureClockEpoch: performance.timeOrigin,
+        captureStartedAtMonotonic: this.#pieceSample.monotonicAt,
+        captureCompletedAtMonotonic: sample.monotonicAt };
       this.#pieceSample = sample;
       this.#speedMeasurementPending = false;
       this.onSpeedMeasured(this.speedReading);

package/services/encode/RunProgress.js

@@ -1,3 +1,5 @@
+import { performance } from "node:perf_hooks";
+
 /**
  * @file Progress reported by one encoder run, placed on the source timeline.
  *
@@ -22,15 +24,18 @@ function parseTimestamp(value) {
 }
 
 export class RunProgress {
-  constructor({ startSeconds = 0, totalSeconds = null, now = Date.now } = {}) {
+  constructor({ startSeconds = 0, totalSeconds = null, now = Date.now, monotonicNow = () => performance.now() } = {}) {
     this.startPositionSeconds = Number.isFinite(startSeconds) ? Math.max(0, startSeconds) : 0;
     this.processedSeconds = this.startPositionSeconds;
     this.totalSeconds = Number.isFinite(totalSeconds) && totalSeconds > 0 ? totalSeconds : null;
     this.percent = null;
     this.remainingSeconds = this.totalSeconds;
     this.updatedAt = now();
+    this.updatedAtMonotonic = monotonicNow();
+    this.clockEpoch = performance.timeOrigin;
     this.lastLoggedAt = 0;
     this.now = now;
+    this.monotonicNow = monotonicNow;
     this.#derive();
   }
 
@@ -42,6 +47,7 @@ export class RunProgress {
       this.processedSeconds = this.startPositionSeconds + Math.max(0, relative);
     }
     this.updatedAt = this.now();
+    this.updatedAtMonotonic = this.monotonicNow();
     this.#derive();
     return this.snapshot();
   }
@@ -61,7 +67,9 @@ export class RunProgress {
       totalSeconds: this.totalSeconds,
       percent: this.percent,
       remainingSeconds: this.remainingSeconds,
-      updatedAt: this.updatedAt
+      updatedAt: this.updatedAt,
+      updatedAtMonotonic: this.updatedAtMonotonic,
+      clockEpoch: this.clockEpoch
     };
   }
 
@@ -77,3 +85,4 @@ export class RunProgress {
     this.remainingSeconds = Math.max(0, this.totalSeconds - this.processedSeconds);
   }
 }
+

package/services/encode/SpeedReadings.js

@@ -14,7 +14,9 @@
  */
 
 export class SpeedReadings {
-  /** @type {WeakMap<object, Array<{ speed: number, at: number, workSeconds?: number, workingSeconds?: number }>>} */
+  /** @type {WeakMap<object, Array<{ speed: number, at: number, workSeconds?: number, workingSeconds?: number,
+   * captureOwner?: string, captureClock?: string, captureClockEpoch?: number,
+   * captureStartedAtMonotonic?: number, captureCompletedAtMonotonic?: number }>>} */
   #byOutput = new WeakMap();
   #keepMs;
 
@@ -25,7 +27,9 @@ export class SpeedReadings {
 
   /**
    * @param {object} output
-   * @param {{ speed: number, at: number, workSeconds?: number, workingSeconds?: number } | null} reading
+   * @param {{ speed: number, at: number, workSeconds?: number, workingSeconds?: number,
+   * captureOwner?: string, captureClock?: string, captureClockEpoch?: number,
+   * captureStartedAtMonotonic?: number, captureCompletedAtMonotonic?: number } | null} reading
    */
   note(output, reading) {
     if (!output || !(reading?.speed > 0) || !Number.isFinite(reading.at)) return;
@@ -34,6 +38,10 @@ export class SpeedReadings {
     let place = readings.length;
     while (place > 0 && readings[place - 1].at > reading.at) place -= 1;
     const sample = { speed: reading.speed, at: reading.at };
+    for (const key of ["captureOwner", "captureClock", "captureClockEpoch", "captureStartedAtMonotonic",
+      "captureCompletedAtMonotonic"]) {
+      if (reading[key] !== undefined) sample[key] = reading[key];
+    }
     if (Number.isFinite(reading.workSeconds) && reading.workSeconds > 0 &&
         Number.isFinite(reading.workingSeconds) && reading.workingSeconds > 0) {
       Object.assign(sample, { workSeconds: reading.workSeconds, workingSeconds: reading.workingSeconds });

package/services/encode/quality/HostLoad.js

@@ -325,7 +325,7 @@ export class HostLoad {
    * What the swarm can give every torrent, in bytes per second: the median of
    * what it carried while our selection held no connection back, but never
    * less than the median of what it carried in all — the same choice the
-   * start forecast makes for one source (`ViewerRequests` `sourceService`).
+   * start forecast makes for one source (`ViewerPlaybackState` `sourceService`).
    * Time our selection held a connection back measures our asking, not the
    * swarm, so holding the speculative levels back does not lower it
    * (torrent-tv/meta#180). Null before any interval was read.

package/services/server/ForecastDiagnostics.js

@@ -0,0 +1,23 @@
+/** Aggregates playback-forecast work for the existing once-a-minute log. */
+export class ForecastDiagnostics {
+  #logger;
+  #costs = { since: Date.now(), polls: 0, ms: 0, maxMs: 0, times: new Map() };
+
+  constructor({ logger }) {
+    this.#logger = logger;
+  }
+
+  note(ms, reasons) {
+    const costs = this.#costs;
+    costs.polls += 1;
+    costs.ms += ms;
+    costs.maxMs = Math.max(costs.maxMs, ms);
+    for (const reason of reasons) costs.times.set(reason, (costs.times.get(reason) ?? 0) + 1);
+    const now = Date.now();
+    if (now - costs.since < 60_000) return;
+    this.#logger.info(`start forecasts in ${((now - costs.since) / 1000).toFixed(1)}s: ${costs.polls}, ` +
+      `${Math.round(costs.ms)}ms in all, ${(costs.ms / costs.polls).toFixed(1)}ms each, longest ${Math.round(costs.maxMs)}ms; ` +
+      `times of a track's pieces: ${[...costs.times].map(([reason, count]) => `${reason} ${count}`).join(", ")}`);
+    Object.assign(costs, { since: now, polls: 0, ms: 0, maxMs: 0, times: new Map() });
+  }
+}

package/services/server/OutputLifecycle.js

@@ -73,6 +73,7 @@ export class OutputLifecycle {
       return;
     }
     this.#host.invalidateWaits(session);
+    this.#host.forgetForecastOutput?.(session);
     this.#host.outputs.delete(sessionId);
     this.#host.outputTimes.logIndexAccuracy(session);
 
@@ -406,7 +407,9 @@ export class OutputLifecycle {
     }
     // Presence ends synchronously, before disposal waits for a child process.
     // Late reports and preparations must not rejoin this viewer meanwhile.
+    const viewer = this.#host.viewers.get(consumerId);
     const outputs = this.#host.viewers.hasGone(consumerId);
+    this.#host.viewerDeparted?.(viewer);
     for (const outputId of outputs) {
       await this.releaseSessionConsumer(outputId, consumerId, because);
     }
@@ -428,11 +431,14 @@ export class OutputLifecycle {
     if (!output) {
       return false;
     }
+    const viewer = this.#host.viewers.get(consumerId);
     this.#host.releasePlaybackStorageDemand?.(output.outputKey ?? "", consumerId);
     // Nothing to release in the encoding: it holds one map per output, built
     // from where the viewers are, and the map that arrives next simply does not
     // have this one in it. A name to release was the last place a viewer
     // appeared inside the encoding at all.
-    return this.#host.viewers.leaves(output, consumerId);
+    const removed = this.#host.viewers.leaves(output, consumerId);
+    if (removed) this.#host.outputViewerDeparted?.(viewer, output);
+    return removed;
   }
 }