@torrent-tv/proxy 2.107.39 → 2.107.41

package/package.json

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

package/services/server/wire-outputs.js

@@ -629,7 +629,7 @@ export function wireOutputs({
     viewerSecondsOn: (output, consumerId, now) => viewerSecondsOn(parts.viewers, output, consumerId, now),
     minimumBufferSecondsFor: (output) => minimumBufferSecondsOf(output),
     // What this proxy may keep of downloaded pieces on disk.
-    sourceStorageBytes: () => parts.machineBudget?.allowedFor?.("spilled pieces") ?? null,
+    sourceStorageBytes: () => parts.machineBudget?.allowedFor("spilled pieces") ?? null,
     getSourceStats: (...args) => parts.getSourceStats?.(...args) ?? null,
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
     planEncodersSoon: (...args) => parts.encodeRuns.planEncodersSoon(...args),

package/services/storage/wire.js

@@ -194,6 +194,8 @@ export function wireMachineBudget({
 
   return {
     capacityOf: name => budget.capacityOf(name),
+    /** What one claimant was last allowed, or null before a measured division. */
+    allowedFor: name => budget.allowedFor(name),
     /**
      * @param {string | null} [resource] - One resource to revise; all when absent.
      * @param {string | null} [because] - Who asked, for the revision's line.

package/services/viewer/playback-readiness.js

@@ -687,8 +687,16 @@ export function predictPlaybackReadiness(input = {}) {
   }
   const tailStock = [];
   if (trackState.some(({ tailEndSeconds }) => Number.isFinite(tailEndSeconds))) {
-    const stop = scheduleTail({ trackState, sourceState, sourceByteCoverage, runStarts, trackFinish,
-      link, position, buffered, reserve, transferFinish, constrain, duration, stock: tailStock });
+    // Where each source's bytes stop being the near window's: the last byte
+    // its pieces read, in the file's own offsets.
+    const windowEnds = new Map();
+    for (const { sourceByteIntervals } of jobs) {
+      for (const [sourceId, ranges] of sourceByteIntervals) {
+        for (const range of ranges) windowEnds.set(sourceId, Math.max(windowEnds.get(sourceId) ?? 0, range.end));
+      }
+    }
+    const stop = scheduleTail({ trackState, sourceState, runStarts, trackFinish,
+      link, position, buffered, reserve, transferFinish, constrain, duration, stock: tailStock, windowEnds });
     if (stop) {
       return { ...result(false, null, buffered, reserve, null, stop.reason, preparedSegments),
         ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
@@ -732,12 +740,13 @@ export function predictPlaybackReadiness(input = {}) {
   // share (Home Assistant 2026-10-26, torrent-tv/meta#239). Said as such, and
   // the viewer keeps waiting rather than starting into stops.
   const storageBytes = Number(input.sourceStorageBytes);
-  if (Number.isFinite(delay) && Number.isFinite(storageBytes) && storageBytes >= 0 && tailStock.length > 0) {
-    const cushionBytes = tailStock.reduce((sum, part) => sum + Math.max(0, part.totalBytes - part.missingBytes) +
+  const tailParts = tailStock.filter(part => !part.skipped);
+  if (Number.isFinite(delay) && Number.isFinite(storageBytes) && storageBytes >= 0 && tailParts.length > 0) {
+    const cushionBytes = tailParts.reduce((sum, part) => sum + Math.max(0, part.totalBytes - part.missingBytes) +
       Math.max(0, part.missingBytes - part.bytesPerSecond * Math.max(0, part.finish - delay)), 0);
     if (cushionBytes > storageBytes) {
       return { ...result(false, null, buffered, reserve, null, "cushion-exceeds-storage", preparedSegments),
-        cushionBytes, storageBytes };
+        cushionBytes, storageBytes, tail: tailStock };
     }
   }
   const originReady = trackState.every(({ clientRanges }) => compare(contiguousEnd(clientRanges, at), at) > 0);
@@ -748,6 +757,9 @@ export function predictPlaybackReadiness(input = {}) {
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
     firstRequiredSegmentsSeconds,
     firstRequiredStages,
+    // What the rest of the film weighs per source, at what rate it comes and
+    // when, or why a source has none: said in the readiness line.
+    tail: tailStock,
     // 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.
@@ -786,14 +798,18 @@ function isPiece(segment) {
  *
  * @returns {{ reason: string, unavailableSource?: object } | null} Why there is no answer, or null.
  */
-function scheduleTail({ trackState, sourceState, sourceByteCoverage, runStarts, trackFinish, link,
-  position, buffered, reserve, transferFinish, constrain, duration, stock = null }) {
+function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
+  position, buffered, reserve, transferFinish, constrain, duration, stock = null, windowEnds = null }) {
   const tailStart = Math.max(position, ...trackState.map(state => state.tailStartSeconds));
   if (!Number.isFinite(tailStart)) return null;
   const sourceDurations = new Map();
   for (const state of trackState) {
     const seconds = Math.max(0, state.tailEndSeconds - tailStart) * state.tailWorkFraction;
-    if (!(seconds > 0)) continue;
+    if (!(seconds > 0)) {
+      stock?.push({ track: state.track.id, skipped: "no-work", tailStart, tailEnd: state.tailEndSeconds,
+        workFraction: state.tailWorkFraction, tailSegments: state.tailSegmentCount });
+      continue;
+    }
     for (const sourceId of new Set(state.track.sourceIds ?? [])) {
       sourceDurations.set(sourceId, Math.max(sourceDurations.get(sourceId) ?? 0, seconds));
     }
@@ -803,16 +819,23 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, runStarts,
   for (const [sourceId, seconds] of sourceDurations) {
     const source = sourceState.get(sourceId);
     if (!source) return { reason: "source-measurement-unavailable" };
-    if (source.source.complete === true) continue;
-    // Held means on this proxy now, past the bytes the near window already
-    // scheduled: those are counted above, and the window's planned arrivals
-    // counted again as held took 117 s of film off a 90-minute tail.
-    const windowEnd = Math.max(0, ...(sourceByteCoverage.get(sourceId) ?? []).map(range => range.end));
+    if (source.source.complete === true) {
+      stock?.push({ sourceId, skipped: "complete" });
+      continue;
+    }
+    // Held means on this proxy now, past the last byte the near window's
+    // pieces read: those are counted above, and the window's planned arrivals
+    // counted again as held took 117 s of film off a 90-minute tail. The
+    // torrent thread's plan is not that end: it can reach the end of the file.
+    const windowEnd = windowEnds?.get(sourceId) ?? 0;
     const bytes = estimateUnmappedSourceBytes(source.source, seconds, duration,
       heldBeyond(source.source.residence, windowEnd), windowEnd);
     if (bytes === null) return { reason: "source-measurement-unavailable",
       unavailableSource: { sourceId, phase: "tail" } };
-    if (!(bytes > 0)) continue;
+    if (!(bytes > 0)) {
+      stock?.push({ sourceId, skipped: "held", seconds, windowEnd });
+      continue;
+    }
     const { service } = source;
     const rate = service.tailRate ?? service.rate;
     if (!rate || !(rate.rateAt(0) > 0)) {
@@ -823,7 +846,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, runStarts,
     sourceArrivalAt = Math.max(sourceArrivalAt, service.finish);
     // What this stretch weighs and what it still lacks: the stock the start
     // asks to hold is read from these once the start's delay is known.
-    stock?.push({ totalBytes: estimateUnmappedSourceBytes(source.source, seconds, duration, []) ?? bytes,
+    stock?.push({ sourceId, seconds, windowEnd, totalBytes:estimateUnmappedSourceBytes(source.source, seconds, duration, []) ?? bytes,
       missingBytes: bytes, bytesPerSecond: rate.rateAt(0), finish: service.finish });
     const state = trackState.find(candidate => candidate.track.sourceIds?.includes(sourceId));
     const index = state?.segments.at(-1)?.index ?? 0;