@torrent-tv/proxy 2.107.53 → 2.107.55

package/services/torrent/worker/worker.js

@@ -42,6 +42,9 @@ import { startMemoryReport, WORKER_MEMORY_SAMPLE_MS } from "../../storage/memory
 import { profileThisThread } from "../../storage/cpu-profile.js";
 import { forwardLogsTo, logger } from "../../../utils/logger.js";
 
+const WORKER_CLOCK_EPOCH = performance.timeOrigin;
+let sourceSnapshotRevision = 0;
+
 /**
  * Everything this thread logs goes to the main thread, which owns the file.
  *
@@ -492,6 +495,8 @@ async function runCommand(command, params, id) {
 
     case Command.FILE_STATS: {
       const statsStartedAt = performance.now();
+      const sourceCaptureStartedAt = statsStartedAt;
+      const sourceRevision = ++sourceSnapshotRevision;
       emitWaitTrace(params.sourceKey, "W10", "begin", { startedAt: statsStartedAt,
         fileIndex: params.fileIndex, forecast: params.forecast === true });
       const finishStatsTrace = (outcome, fields = {}) => {
@@ -504,7 +509,14 @@ async function runCommand(command, params, id) {
         if (!torrent) {
           const whole = wholeSources.fileOf(params.sourceKey, params.fileIndex);
           finishStatsTrace(whole ? "whole-file" : "pending");
-          return whole ? wholeFileStats(whole.length) : { pending: true };
+          return {
+            ...(whole ? wholeFileStats(whole.length) : { pending: true }),
+            sourceCapture: {
+              owner: "torrent-worker", clock: "performance", clockEpoch: WORKER_CLOCK_EPOCH,
+              startedAt: sourceCaptureStartedAt, completedAt: performance.now(), revision: sourceRevision,
+              validity: whole ? "valid" : "unknown", unknownReason: whole ? null : "source-not-ready"
+            }
+          };
         }
         // What this file's own interruptions demand, measured by the reader in
         // this thread. It travels with the stats because the caller asking for
@@ -515,7 +527,8 @@ async function runCommand(command, params, id) {
         const file = Array.isArray(torrent?.files) ? torrent.files[params.fileIndex] : null;
         const forecastAt = performance.now();
         const forecast = file && params.forecast === true ? downloadForecastOf(torrent) : null;
-        const forecastMs = params.forecast === true ? performance.now() - forecastAt : 0;
+        const forecastCompletedAt = performance.now();
+        const forecastMs = params.forecast === true ? forecastCompletedAt - forecastAt : 0;
         const stats = pool.getFileStats(torrent, params.fileIndex);
         const ranges = [];
         if (forecast) for (const [piece, availableAt] of forecast.arrivals) {
@@ -526,8 +539,19 @@ async function runCommand(command, params, id) {
         finishStatsTrace("ok", { forecast: params.forecast === true });
         return {
           ...stats,
+          sourceCapture: {
+            owner: "torrent-worker", clock: "performance", clockEpoch: WORKER_CLOCK_EPOCH,
+            startedAt: sourceCaptureStartedAt, completedAt: performance.now(), revision: sourceRevision,
+            validity: stats ? "valid" : "unknown", unknownReason: stats ? null : "source-stats-unavailable"
+          },
           ...(params.forecast === true ? { downloadForecast: {
-            measuredAt: forecast?.measuredAt ?? Date.now(), global: true, ranges
+            measuredAt: forecast?.measuredAt ?? Date.now(), global: true, ranges,
+            capture: {
+              owner: "torrent-worker", clock: "performance", clockEpoch: WORKER_CLOCK_EPOCH,
+              startedAt: forecastAt, completedAt: forecastCompletedAt, revision: sourceRevision,
+              validity: forecast ? "valid" : "unknown",
+              unknownReason: forecast ? null : "source-arrival-forecast-unavailable"
+            }
           } } : {}),
           supply: supplyFiguresFor(torrent?.infoHash, file?.name, params.segmentSeconds ?? 4),
           // How long this answer waited for the arrival forecast, which the

package/services/viewer/OutputForecastGeometry.js

@@ -27,10 +27,11 @@ export class OutputForecastGeometry {
     const count = timeline?.segmentCount ?? 0;
     let forecast = this.#byOutput.get(output);
     if (!forecast) {
-      forecast = { pieces: [], geometry: {} };
+      forecast = { pieces: [], tailPieces: [], tailSegments: [], geometry: {} };
       this.#byOutput.set(output, forecast);
     }
     const kept = forecast.pieces;
+    const keptTail = forecast.tailPieces;
     const segments = [];
     const lookahead = Number(this.#host.lookaheadSeconds);
     const start = Number.isFinite(positionSeconds) ? Math.max(0, positionSeconds) : 0;
@@ -50,6 +51,23 @@ export class OutputForecastGeometry {
       else high = middle;
     }
     const last = low;
+    const tailSegments = [];
+    for (let index = last; index < count; index += 1) {
+      const startSeconds = timeline.publishedStartOf(index);
+      const endSeconds = timeline.publishedStartOf(index + 1);
+      const sourceInputs = this.#host.sourceInputsFor?.(output, index) ?? undefined;
+      const previous = keptTail[index];
+      if (previous && previous.startSeconds === startSeconds && previous.endSeconds === endSeconds &&
+        sameInputs(previous.sourceInputs, sourceInputs)) {
+        tailSegments.push(previous);
+        continue;
+      }
+      const segment = { index, startSeconds, endSeconds, sourceInputs };
+      keptTail[index] = segment;
+      tailSegments.push(segment);
+    }
+    if (keptTail.length > count) keptTail.length = count;
+    forecast.tailSegments = tailSegments;
     const indexes = new Set([0]);
     for (let index = first; index < last; index++) indexes.add(index);
     for (const index of indexes) {

package/services/viewer/Viewer.js

@@ -53,6 +53,34 @@ function fragmentEventAges(value) {
     Number.isFinite(value?.[name]) && value[name] >= 0 ? value[name] : null]));
 }
 
+function browserCaptureOf(report, sessionId) {
+  const clockEpoch = report.captureClockEpoch;
+  const startedAt = report.captureStartedAtBrowser;
+  const completedAt = report.captureCompletedAtBrowser;
+  const valid = typeof report.captureEpoch === "string" && report.captureEpoch.length > 0 &&
+    Number.isFinite(report.captureEpochStartedAtBrowser) && Number.isFinite(report.captureRevision) &&
+    Number.isSafeInteger(report.captureRevision) && report.captureRevision > 0 &&
+    Number.isFinite(clockEpoch) && Number.isFinite(startedAt) && Number.isFinite(completedAt) &&
+    report.captureEpochStartedAtBrowser >= clockEpoch && startedAt >= report.captureEpochStartedAtBrowser &&
+    completedAt >= startedAt &&
+    Number.isSafeInteger(report.generation) && report.generation >= 0;
+  return {
+    owner: "browser",
+    clock: "performance",
+    clockEpoch: Number.isFinite(clockEpoch) ? clockEpoch : null,
+    startedAt: Number.isFinite(startedAt) ? startedAt : null,
+    completedAt: Number.isFinite(completedAt) ? completedAt : null,
+    actionId: typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null,
+    generation: Number.isSafeInteger(report.generation) ? report.generation : null,
+    revision: Number.isSafeInteger(report.captureRevision) ? report.captureRevision : null,
+    epoch: typeof report.captureEpoch === "string" ? report.captureEpoch : null,
+    epochStartedAt: Number.isFinite(report.captureEpochStartedAtBrowser)
+      ? report.captureEpochStartedAtBrowser : null,
+    validity: valid ? "valid" : "unknown",
+    unknownReason: valid ? null : "missing-or-invalid-browser-capture"
+  };
+}
+
 function appendServiceSnapshot(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const snapshot = {};
@@ -522,6 +550,18 @@ export class Viewer {
       appendEpoch = null,
       appendEpochStartedAt = null,
       appendSnapshotAt = null,
+      captureClockEpoch = null,
+      captureEpoch = null,
+      captureEpochStartedAtBrowser = null,
+      captureRevision = null,
+      captureStartedAtBrowser = null,
+      captureCompletedAtBrowser = null,
+      linkSampleStartedAtBrowser = null,
+      linkSampleCompletedAtBrowser = null,
+      linkSampleActionId = null,
+      linkSampleGeneration = null,
+      linkSampleClockEpoch = null,
+      linkSampleRevision = null,
       appendService: appendServiceReading = null,
       fragmentService: fragmentServiceReading = null,
       bufferedAheadSec,
@@ -564,6 +604,18 @@ export class Viewer {
     const sampleMbps = Number(linkSampleMbps);
     const sampleAt = Number(linkSampleAt);
     const previous = this.netReport;
+    const browserCapture = browserCaptureOf({ captureClockEpoch, captureEpoch, captureEpochStartedAtBrowser,
+      captureRevision, captureStartedAtBrowser, captureCompletedAtBrowser, generation }, appendSessionId);
+    const previousCapture = previous?.bufferCapture ?? null;
+    const captureOrderKnown = browserCapture.clockEpoch !== null && browserCapture.epoch !== null &&
+      browserCapture.epochStartedAt !== null && browserCapture.revision !== null && browserCapture.revision > 0;
+    const sameCaptureClock = captureOrderKnown && browserCapture.clockEpoch === previousCapture?.clockEpoch;
+    const sameCaptureEpoch = sameCaptureClock && browserCapture.epoch === previousCapture?.epoch;
+    const newerCapture = captureOrderKnown && (!previousCapture || !previousCapture.clockEpoch ||
+      !sameCaptureClock && browserCapture.epochStartedAt > (previousCapture.epochStartedAt ?? 0) ||
+      sameCaptureClock && (sameCaptureEpoch && browserCapture.revision > previousCapture.revision ||
+        !sameCaptureEpoch && browserCapture.epochStartedAt > (previousCapture.epochStartedAt ?? 0)));
+    const staleCapture = captureOrderKnown && previousCapture && !newerCapture;
     const incomingAppendService = typeof appendEpoch === "string" && appendEpoch.length > 0
       ? appendServiceSnapshot(appendServiceReading) : null;
     const incomingFragmentService = typeof appendEpoch === "string" && appendEpoch.length > 0
@@ -578,37 +630,85 @@ export class Viewer {
           (!previous?.appendService || appendServiceIsMonotonic(incomingAppendService, previous.appendService)) &&
           (!previous?.fragmentService || fragmentServiceIsMonotonic(incomingFragmentService, previous.fragmentService))
         : appendEpochStartedAt > (previous?.appendEpochStartedAt ?? 0));
+    const preserveBrowserService = sameAppendEpoch && incomingAppendService && incomingFragmentService;
     const hasPlaybackSample = Number.isFinite(sampleMbps) && sampleMbps > 0 &&
-      Number.isFinite(sampleAt) && sampleAt > 0;
-    const newerPlaybackSample = hasPlaybackSample && sampleAt > (this.netReport?.linkSampleAt ?? 0);
+      Number.isFinite(sampleAt) && sampleAt > 0 && Number.isFinite(captureClockEpoch) &&
+      Number.isFinite(linkSampleClockEpoch) && linkSampleClockEpoch === captureClockEpoch &&
+      Number.isSafeInteger(linkSampleRevision) && linkSampleRevision > 0 &&
+      Number.isFinite(linkSampleStartedAtBrowser) && Number.isFinite(linkSampleCompletedAtBrowser) &&
+      linkSampleStartedAtBrowser >= captureClockEpoch && linkSampleCompletedAtBrowser === sampleAt &&
+      linkSampleStartedAtBrowser <= linkSampleCompletedAtBrowser &&
+      Number.isFinite(captureCompletedAtBrowser) && sampleAt <= captureCompletedAtBrowser &&
+      Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0;
+    const oldLinkEpoch = this.netReport?.linkCapture?.epoch !== String(linkSampleClockEpoch) &&
+      Number.isFinite(this.netReport?.linkCapture?.epochStartedAt) &&
+      Number.isFinite(linkSampleClockEpoch) &&
+      linkSampleClockEpoch <= this.netReport.linkCapture.epochStartedAt;
+    const newerPlaybackSample = hasPlaybackSample && !oldLinkEpoch &&
+      (linkSampleClockEpoch !== this.netReport?.linkCapture?.clockEpoch ||
+        linkSampleRevision > (this.netReport?.linkCapture?.revision ?? 0));
+    const linkClockEpochChanged = Number.isFinite(captureClockEpoch) &&
+      Number.isFinite(this.netReport?.linkCapture?.clockEpoch) &&
+      captureClockEpoch !== this.netReport.linkCapture.clockEpoch;
+    const newerInvalidPlaybackSample = !stale && newerCapture && !hasPlaybackSample &&
+      (Number.isSafeInteger(linkSampleRevision) || linkSampleAt !== null && linkSampleAt !== undefined ||
+        linkClockEpochChanged);
+    const preserveCapture = stale || staleCapture;
+    const linkCapture = newerPlaybackSample ? {
+      owner: "browser", clock: "performance", clockEpoch: linkSampleClockEpoch,
+      startedAt: linkSampleStartedAtBrowser, completedAt: linkSampleCompletedAtBrowser,
+      actionId: typeof linkSampleActionId === "string" ? linkSampleActionId : null,
+      generation: Number.isSafeInteger(linkSampleGeneration) ? linkSampleGeneration : null,
+      epoch: String(linkSampleClockEpoch), epochStartedAt: linkSampleClockEpoch,
+      revision: linkSampleRevision, validity: "valid", unknownReason: null
+    } : newerInvalidPlaybackSample ? {
+      owner: "browser", clock: "performance", clockEpoch: Number.isFinite(captureClockEpoch) ? captureClockEpoch : null,
+      startedAt: null, completedAt: null, actionId: appendSessionId,
+      generation: Number.isSafeInteger(generation) ? generation : null,
+      epoch: Number.isFinite(captureClockEpoch) ? String(captureClockEpoch) : null,
+      epochStartedAt: captureClockEpoch,
+      revision: linkSampleRevision, validity: "invalid", unknownReason: "invalid-link-sample-capture"
+    } : this.netReport?.linkCapture ?? {
+      owner: "browser", clock: "performance", clockEpoch: null, startedAt: null, completedAt: null,
+      actionId: appendSessionId, generation: Number.isSafeInteger(generation) ? generation : null,
+      epoch: null, epochStartedAt: null, revision: null, validity: "unknown",
+      unknownReason: "missing-link-sample-capture"
+    };
+    const useCapture = !stale && !staleCapture && newerCapture && browserCapture.validity === "valid";
     this.netReport = {
       linkMbps: lastLinkMbps,
       linkMeasuredAt,
-      linkSampleAt: newerPlaybackSample ? sampleAt : this.netReport?.linkSampleAt ?? null,
-      linkSampleMbps: newerPlaybackSample ? sampleMbps : this.netReport?.linkSampleMbps ?? null,
-      linkSampleMeasuredAt: newerPlaybackSample
-        ? Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0
-          ? now - linkSampleAgeMs
-          : now
-        : this.netReport?.linkSampleMeasuredAt ?? null,
+      linkSampleAt: newerPlaybackSample ? sampleAt : newerInvalidPlaybackSample ? null : this.netReport?.linkSampleAt ?? null,
+      linkSampleMbps: newerPlaybackSample ? sampleMbps : newerInvalidPlaybackSample ? null : this.netReport?.linkSampleMbps ?? null,
+      linkSampleMeasuredAt: newerPlaybackSample ? now : newerInvalidPlaybackSample ? null : this.netReport?.linkSampleMeasuredAt ?? null,
+      linkCapture,
+      bufferCapture: preserveCapture ? previousCapture ?? browserCapture : useCapture ? browserCapture : {
+        ...browserCapture,
+        validity: "unknown",
+        unknownReason: browserCapture.unknownReason ?? "missing-or-invalid-browser-capture"
+      },
       appendSessionId: useBrowserService ? appendSessionId : previous?.appendSessionId ?? null,
-      appendEpoch: useBrowserService ? appendEpoch : previous?.appendEpoch ?? null,
+      appendEpoch: useBrowserService ? appendEpoch : preserveBrowserService ? previous?.appendEpoch ?? null
+        : useCapture ? null : previous?.appendEpoch ?? null,
       appendEpochStartedAt: useBrowserService ? appendEpochStartedAt : previous?.appendEpochStartedAt ?? null,
       appendSnapshotAt: useBrowserService ? appendSnapshotAt : previous?.appendSnapshotAt ?? null,
-      appendService: useBrowserService ? incomingAppendService : previous?.appendService ?? null,
-      fragmentService: useBrowserService ? incomingFragmentService : previous?.fragmentService ?? null,
-      appendServiceReceivedAt: useBrowserService ? now : previous?.appendServiceReceivedAt ?? null,
-      bufferedAheadSec: held,
+      appendService: useBrowserService ? incomingAppendService : preserveBrowserService ? previous?.appendService ?? null
+        : useCapture ? null : previous?.appendService ?? null,
+      fragmentService: useBrowserService ? incomingFragmentService : preserveBrowserService ? previous?.fragmentService ?? null
+        : useCapture ? null : previous?.fragmentService ?? null,
+      appendServiceReceivedAt: useBrowserService ? now : preserveBrowserService ? previous?.appendServiceReceivedAt ?? null
+        : useCapture ? null : previous?.appendServiceReceivedAt ?? null,
+      bufferedAheadSec: preserveCapture ? previous?.bufferedAheadSec ?? 0 : useCapture ? held : 0,
       timestampOffsets: Object.fromEntries(["video", "audio"].filter((key) =>
         Number.isFinite(timestampOffsets?.[key])).map((key) => [key, timestampOffsets[key]])),
-      bufferedRanges: bufferedRanges && typeof bufferedRanges === "object" ?
+      bufferedRanges: preserveCapture ? previous?.bufferedRanges ?? null : useCapture && bufferedRanges && typeof bufferedRanges === "object" ?
         Object.fromEntries(["video", "audio", "media"].filter((key) => Array.isArray(bufferedRanges[key]))
           .map((key) => [key, bufferedRanges[key].slice(0, 256).filter((range) =>
             Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.start >= 0 && range.end > range.start)
             .map(({ start, end }) => ({ start, end }))])) : null,
-      bufferLimitSeconds: Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0
+      bufferLimitSeconds: preserveCapture ? previous?.bufferLimitSeconds ?? null : useCapture && Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0
         ? bufferLimitSeconds
-        : this.netReport?.bufferLimitSeconds ?? null,
+        : useCapture ? null : this.netReport?.bufferLimitSeconds ?? null,
       positionSeconds:
         Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : null,
       at: now

package/services/viewer/ViewerPlaybackState.js

@@ -46,11 +46,15 @@ export class ViewerPlaybackState {
     return removed;
   }
 
-  addLinkReading(state, at, mbps) {
-    state.link.add(at, mbps * 1_000_000);
+  addLinkReading(state, at, mbps, capture = null) {
+    state.link.add(at, mbps * 1_000_000, capture);
   }
 
-  sourceRateReadings(state, id, stats, now, playbackReadiness, lookaheadSeconds) {
+  forgetLinkReadings(state, playbackReadiness, lookaheadSeconds) {
+    if (state) state.link = new playbackReadiness.RateTrend(lookaheadSeconds);
+  }
+
+  sourceRateReadings(state, id, stats, now, playbackReadiness, lookaheadSeconds, capture = null) {
     let source = state.sources.get(id);
     if (!source) {
       const { RateTrend, SessionRate } = playbackReadiness;
@@ -58,15 +62,16 @@ export class ViewerPlaybackState {
         deliveredAll: new SessionRate(), freeAll: new SessionRate(), limit: null };
       state.sources.set(id, source);
     }
+    const readingCapture = capture ?? stats?.sourceCapture ?? null;
     if (Number.isFinite(stats?.downloadSpeed) && stats.downloadSpeed >= 0) {
-      source.delivered.add(now, stats.downloadSpeed);
-      source.deliveredAll.add(now, stats.downloadSpeed);
+      source.delivered.add(now, stats.downloadSpeed, readingCapture);
+      source.deliveredAll.add(now, stats.downloadSpeed, readingCapture);
     }
     const limit = stats?.selectionLimit;
     if (limit && source.limit && limit.freeMs > source.limit.freeMs) {
       const free = Math.max(0, limit.freeBytes - source.limit.freeBytes) * 1000 / (limit.freeMs - source.limit.freeMs);
-      source.free.add(now, free);
-      source.freeAll.add(now, free);
+      source.free.add(now, free, readingCapture);
+      source.freeAll.add(now, free, readingCapture);
     }
     if (limit) source.limit = limit;
     return sourceService(source.free.snapshot(), source.delivered.snapshot(),
@@ -85,6 +90,19 @@ export class ViewerPlaybackState {
     return source ? { free: source.free.snapshot(), delivered: source.delivered.snapshot() } : null;
   }
 
+  sourceCaptureSnapshot(state, id) {
+    const source = state.sources.get(id);
+    if (!source) return null;
+    return {
+      recent: { delivered: source.delivered.captureSnapshot(), free: source.free.captureSnapshot() },
+      tail: { delivered: source.deliveredAll.captureSnapshot(), free: source.freeAll.captureSnapshot() }
+    };
+  }
+
+  forgetSourceReadings(state, id) {
+    state?.sources.delete(id);
+  }
+
   getWait(viewer, waitId) {
     return this.#stateFor(viewer)?.waits.get(waitId) ?? null;
   }