@torrent-tv/proxy 2.107.40 → 2.107.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.40",
+  "version": "2.107.42",
   "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,16 +687,8 @@ export function predictPlaybackReadiness(input = {}) {
   }
   const tailStock = [];
   if (trackState.some(({ tailEndSeconds }) => Number.isFinite(tailEndSeconds))) {
-    // 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 });
+      link, position, buffered, reserve, transferFinish, constrain, duration, stock: tailStock });
     if (stop) {
       return { ...result(false, null, buffered, reserve, null, stop.reason, preparedSegments),
         ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
@@ -740,12 +732,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);
@@ -756,6 +749,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.
@@ -795,13 +791,17 @@ function isPiece(segment) {
  * @returns {{ reason: string, unavailableSource?: object } | null} Why there is no answer, or null.
  */
 function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
-  position, buffered, reserve, transferFinish, constrain, duration, stock = null, windowEnds = null }) {
+  position, buffered, reserve, transferFinish, constrain, duration, stock = 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));
     }
@@ -811,17 +811,29 @@ function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
   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 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;
+    if (source.source.complete === true) {
+      stock?.push({ sourceId, skipped: "complete" });
+      continue;
+    }
+    // Held means on this proxy now, in the bytes of the film after the near
+    // window: the window's own bytes are counted above, and its planned
+    // arrivals counted again as held took 117 s of film off a 90-minute tail.
+    // Where those bytes begin is placed by the density the tail is priced at.
+    // Neither the torrent thread's plan nor the bytes the window reads are
+    // that place: both can reach the end of the file — a copied Matroska file
+    // reads its index there — and the whole of Despicable Me 3 then counted
+    // as held (Home Assistant 2026-10-26, torrent-tv/meta#239).
+    const fileLength = Number(source.source.fileLength);
+    const windowEnd = fileLength > 0 && duration > 0
+      ? Math.min(fileLength, Math.max(0, fileLength * tailStart / duration)) : 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)) {
@@ -832,7 +844,7 @@ function scheduleTail({ trackState, sourceState, runStarts, trackFinish, link,
     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;