@torrent-tv/proxy 2.107.48 → 2.107.49

package/package.json

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

package/services/server/OutputLifecycle.js

@@ -427,6 +427,7 @@ export class OutputLifecycle {
     if (!output) {
       return false;
     }
+    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

package/services/server/ViewerRequests.js

@@ -1013,9 +1013,8 @@ export class ViewerRequests {
       bufferLimitSeconds: viewerReading?.bufferLimitSeconds,
       reserveSeconds,
       lookaheadSeconds: this.#host.lookaheadSeconds,
-      // What this proxy may keep of downloaded pieces on disk: the most a
-      // start can hold of the film ahead of the viewer.
-      sourceStorageBytes: this.#host.sourceStorageBytes?.() ?? null,
+      // Disk room remaining after stock reserved for other active outputs.
+      sourceStorageBytes: this.#host.sourceStorageBytes?.(session.outputKey ?? session.id) ?? null,
       requiredAudio: requiresSeparateAudio,
       sources: [...sourceMeasurements.values()],
       tracks,
@@ -1028,6 +1027,9 @@ export class ViewerRequests {
       viewer.subtitle.fileIndex === session.file.fileIndex ? viewer.subtitle : null;
     const startedAt = performance.now();
     const predicted = this.#host.playbackReadiness.predict(input);
+    if (consumerId && viewer && this.#host.viewers.get(consumerId) === viewer && Number.isFinite(predicted.cushionBytes)) {
+      this.#host.notePlaybackStorageDemand?.(session.outputKey ?? session.id, consumerId, predicted.cushionBytes);
+    }
     const predictMs = performance.now() - startedAt;
     this.#noteForecast(predictMs, tracks.map(track => track.geometry?.reason ?? "none"));
     logger.info(`readiness parts ${session.id} consumer=${consumerId}: source stats ${Math.round(parts.statsMs)}ms ` +

package/services/server/wire-outputs.js

@@ -95,6 +95,7 @@ import { audioReadingFor } from "../encode/audio-work-rate.js";
 import { wireMachineBudget } from "../storage/wire.js";
 import { Returns } from "../storage/returns.js";
 import { freeBytesFor } from "../storage/free.js";
+import { PlaybackStorageDemand } from "../storage/PlaybackStorageDemand.js";
 import { inputCacheRoot, probeInputCache } from "../encode/input-cache.js";
 import path from "node:path";
 import { contentOf, LocalObservations, PROXY_ROOT } from "../encode/LocalObservations.js";
@@ -579,6 +580,7 @@ export function wireOutputs({
     get encodeRuns() { return parts.encodeRuns; },
     get keyframeTables() { return parts.keyframeTables; },
     get machineBudget() { return parts.machineBudget; },
+    releasePlaybackStorageDemand: (key, consumerId) => parts.playbackStorageDemand.release(key, consumerId),
     get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
     get returns() { return parts.returns; },
@@ -629,7 +631,13 @@ 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: outputKey => {
+      const capacity = parts.machineBudget?.storageBytes();
+      return Number.isFinite(capacity)
+        ? Math.max(0, capacity - parts.playbackStorageDemand.bytesExcept(outputKey))
+        : null;
+    },
+    notePlaybackStorageDemand: (key, consumerId, bytes) => parts.playbackStorageDemand.note(key, consumerId, bytes),
     getSourceStats: (...args) => parts.getSourceStats?.(...args) ?? null,
     disposeSession: (...args) => parts.lifecycle.disposeSession(...args),
     planEncodersSoon: (...args) => parts.encodeRuns.planEncodersSoon(...args),
@@ -1173,6 +1181,11 @@ export function wireOutputs({
   // one term of the keeping period that is guessed rather than measured, and
   // the only place it can be measured from.
   parts.returns = new Returns();
+  parts.playbackStorageDemand = new PlaybackStorageDemand(() => {
+    if (parts.machineBudget) {
+      void parts.machineBudget.revise(parts.machineBudget.storageResource, "playback stock");
+    }
+  });
   parts.encodeInputs = encodeInputs ?? (typeof resolveEncodeInput === "function" ? new EncodeInputs({
     resolve: resolveEncodeInput,
     readRanges: readEncodeRanges,
@@ -1221,6 +1234,7 @@ export function wireOutputs({
     // FFmpeg's cache keeps its file in /tmp, or where FFmpeg runs on a build
     // without `mkstemp` — an output directory of the segments.
     inputCaches: { held: () => parts.encodeRuns?.inputCacheBytes() ?? 0, root: inputCacheRoot() },
+    playbackStorage: parts.playbackStorageDemand,
     policy: parts.budgetPolicy ?? undefined,
     readFree: freeBytesFor,
     logger

package/services/storage/PlaybackStorageDemand.js

@@ -0,0 +1,64 @@
+/**
+ * The bytes an active playback forecast says must remain available on disk.
+ * Viewers of one output share its stored bytes, so its demand is the largest
+ * live viewer demand; distinct outputs add their requirements.
+ */
+export class PlaybackStorageDemand {
+  #byOutput = new Map();
+  #changed;
+
+  constructor(changed = () => {}) {
+    this.#changed = changed;
+  }
+
+  /** @returns {number} */
+  bytes() {
+    let total = 0;
+    for (const viewers of this.#byOutput.values()) {
+      let shared = 0;
+      for (const bytes of viewers.values()) shared = Math.max(shared, bytes);
+      total += shared;
+    }
+    return total;
+  }
+
+  /** @param {string} outputKey @returns {number} */
+  bytesExcept(outputKey) {
+    let total = 0;
+    for (const [key, viewers] of this.#byOutput) {
+      if (key === outputKey) continue;
+      let shared = 0;
+      for (const bytes of viewers.values()) shared = Math.max(shared, bytes);
+      total += shared;
+    }
+    return total;
+  }
+
+  /** @param {string} outputKey @param {string} consumerId @param {number} bytes */
+  note(outputKey, consumerId, bytes) {
+    if (!outputKey || !consumerId || !Number.isFinite(bytes) || bytes < 0) return;
+    const before = this.bytes();
+    let viewers = this.#byOutput.get(outputKey);
+    if (!viewers) {
+      viewers = new Map();
+      this.#byOutput.set(outputKey, viewers);
+    }
+    viewers.set(consumerId, bytes);
+    this.#notifyIfChanged(before);
+  }
+
+  /** @param {string} outputKey @param {string} consumerId */
+  release(outputKey, consumerId) {
+    const viewers = this.#byOutput.get(outputKey);
+    if (!viewers?.has(consumerId)) return;
+    const before = this.bytes();
+    viewers.delete(consumerId);
+    if (viewers.size === 0) this.#byOutput.delete(outputKey);
+    this.#notifyIfChanged(before);
+  }
+
+  #notifyIfChanged(before) {
+    const after = this.bytes();
+    if (after !== before) this.#changed(after);
+  }
+}

package/services/storage/wire.js

@@ -10,7 +10,9 @@
  * segments an encoder produced, the files downloaded whole — and the evidence,
  * which is a claimant with a rule of its own (`Diagnostics.js`). Three of the
  * five live on the torrent thread, so they arrive as pairs of closures over its
- * channel rather than as the objects themselves.
+ * channel rather than as the objects themselves. Active playback also
+ * reserves its forecasted source stock here; that is a requirement, not a
+ * store holding bytes yet.
  *
  * **Which RESOURCE each takes is read, not assumed.** Memory is one. Disk is
  * one per device, because two filesystems cannot pay for each other: measured
@@ -56,7 +58,7 @@ import { availableMemoryBytes } from "./machine-memory.js";
  * @param {import("./MachineBudget.js").BudgetPolicy} [params.policy] - What the
  *   operator has said this proxy may take. Absent, the measured default.
  * @param {{ info: Function, warn?: Function }} [params.logger]
- * @returns {{ revise: () => Promise<unknown>, segmentBytes: () => number | null, diagnostics: object | null, describe: () => string }}
+ * @returns {{ revise: (resource?: string | null, because?: string | null) => Promise<unknown>, segmentBytes: () => number | null, storageBytes: () => number | null, storageResource: string, diagnostics: object | null, describe: () => string }}
  *   What the segments may hold is asked for rather than pushed: null until the
  *   first revision, then the measured allowance, including a measured zero.
  */
@@ -68,6 +70,7 @@ export function wireMachineBudget({
   indexMemory,
   wholeFiles,
   inputCaches,
+  playbackStorage,
   diagnostics,
   diagnosticsRoot = "",
   readFree,
@@ -177,6 +180,17 @@ export function wireMachineBudget({
     });
   }
 
+  if (typeof playbackStorage?.bytes === "function") {
+    budget.register({
+      name: "playback stock",
+      resource: segmentsOn,
+      held: () => 0,
+      wanted: () => playbackStorage.bytes(),
+      required: () => playbackStorage.bytes(),
+      allow: () => {}
+    });
+  }
+
   let evidenceOn = null;
   if (diagnostics) {
     evidenceOn = diagnosticsRoot ? deviceOf(diagnosticsRoot) : segmentsOn;
@@ -194,6 +208,8 @@ export function wireMachineBudget({
 
   return {
     capacityOf: name => budget.capacityOf(name),
+    storageBytes: () => budget.capacityOf(segmentsOn),
+    storageResource: segmentsOn,
     /** What one claimant was last allowed, or null before a measured division. */
     allowedFor: name => budget.allowedFor(name),
     /**

package/services/viewer/playback-readiness.js

@@ -841,16 +841,19 @@ export function predictPlaybackReadiness(input = {}) {
   // THE STOCK THE START ASKS FOR HAS TO FIT. Starting without a stop while the
   // source comes slower than the film plays means holding, at the start, what
   // is already here and everything that arrives before it. Where that is more
-  // than this proxy may keep of downloaded pieces, the oldest of it would be
-  // given up before the viewer reached it, and no wait makes the start safe:
+  // than the disk room left after other active playback stock is reserved,
+  // some of it would be given up before the viewer reached it, so no wait
+  // makes the start safe:
   // Despicable Me 3 BDRemux at 1.4 MB/s asked for about 36 GB against a 29.5 GB
   // 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);
   const tailParts = tailStock.filter(part => !part.skipped);
+  const cushionBytes = Number.isFinite(delay) && tailParts.length > 0
+    ? 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)
+    : null;
   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, tail: tailStock };
@@ -862,6 +865,7 @@ export function predictPlaybackReadiness(input = {}) {
     Math.max(0, reserve - buffered), ready ? 'trajectory-safe-now' :
       Number.isFinite(delay) ? 'minimum-safe-delay' : 'service-not-advancing', preparedSegments);
   return { ...forecast, measuredAt: now, predictedStartAt: Number.isFinite(delay) ? now + delay * 1000 : null,
+    ...(cushionBytes === null ? {} : { cushionBytes }),
     firstRequiredSegmentsSeconds,
     firstRequiredStages,
     // What the rest of the film weighs per source, at what rate it comes and