@torrent-tv/proxy 2.107.48 → 2.107.50

package/package.json

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

package/services/{server/WaitLedger.js → encode/OutputWaitLedger.js}

@@ -58,6 +58,23 @@ export class WaitLedger {
   /** @type {Map<string, Map<string, number>>} */
   #counts = new Map();
 
+  /** @type {Map<string, object>} */
+  #owners = new Map();
+
+  /**
+   * Begin a live output-key lifetime. Reopening a key starts a clean history;
+   * the returned identity lets a held response prove that it still belongs to
+   * this lifetime when it eventually completes.
+   *
+   * @param {string} key
+   * @param {object} identity
+   */
+  open(key, identity) {
+    if (!key || !identity || this.#owners.get(key) === identity) return;
+    this.forget(key);
+    this.#owners.set(key, identity);
+  }
+
   /**
    * Somebody waited this long for something the map ranked this highly.
    *
@@ -66,11 +83,13 @@ export class WaitLedger {
    * @param {number} rank - The map's rank for the thing waited for.
    * @param {number} topRank - The highest rank the map states, so the rank can
    *   be read as a position rather than as an absolute number.
+   * @param {object} [identity] - The output-key lifetime that started this wait.
    */
-  note(key, waitedMs, rank, topRank) {
+  note(key, waitedMs, rank, topRank, identity = undefined) {
     if (!key || !Number.isFinite(waitedMs) || waitedMs < 0) {
       return;
     }
+    if (identity !== undefined && this.#owners.get(key) !== identity) return;
     const band = bandOf(rank, topRank);
     let byBand = this.#waits.get(key);
     if (!byBand) {
@@ -128,15 +147,26 @@ export class WaitLedger {
 
   /**
    * @param {string} key
+   * @param {object} [identity] - Ignore release from an older output lifetime.
    */
-  forget(key) {
+  forget(key, identity = undefined) {
+    if (identity !== undefined && this.#owners.get(key) !== identity) return false;
     this.#waits.delete(key);
     this.#counts.delete(key);
+    if (identity === undefined || this.#owners.get(key) === identity) this.#owners.delete(key);
+    return true;
+  }
+
+  /** Release every record owned by this proxy before its shutdown completes. */
+  clear() {
+    this.#waits.clear();
+    this.#counts.clear();
+    this.#owners.clear();
+  }
+
+  /** Number of output keys with retained measurements. */
+  get size() {
+    return this.#waits.size;
   }
 }
 
-/**
- * One ledger for the process, because the question is asked in two layers and
- * the answer is comparable only if the scale is the same.
- */
-export const waits = new WaitLedger();

package/services/encode/output/OutputCatalog.js

@@ -26,7 +26,11 @@ export class OutputCatalog {
 
   #byId = new Map();
   #lifetime = new Map();
+  /** @type {Map<string, object>} */
+  #waitIdentities = new Map();
   #now;
+  #waitIdentityStarted;
+  #waitIdentityEnded;
 
   /**
    * @param {object} [params]
@@ -35,11 +39,15 @@ export class OutputCatalog {
    *   source file is, which the torrent reports.
    * @param {(address: string) => { index: number, size: number }} [params.largestPieceOf]
    *   The biggest piece an output has made, which the disk knows.
+   * @param {(address: string, identity: object) => void} [params.waitIdentityStarted]
+   * @param {(address: string, identity: object) => void} [params.waitIdentityEnded]
    */
   constructor({
     now = Date.now,
     fileLengthOf = () => 0,
-    largestPieceOf = () => ({ index: -1, size: 0 })
+    largestPieceOf = () => ({ index: -1, size: 0 }),
+    waitIdentityStarted = () => {},
+    waitIdentityEnded = () => {}
   } = {}) {
     this.#now = now;
     // Two facts this catalog needs and does not own, taken as plain functions
@@ -48,15 +56,22 @@ export class OutputCatalog {
     // it is part of the output itself (`OutputSpec`).
     this.fileLengthOf = fileLengthOf;
     this.largestPieceOf = largestPieceOf;
+    this.#waitIdentityStarted = waitIdentityStarted;
+    this.#waitIdentityEnded = waitIdentityEnded;
   }
 
   set(id, output) {
     const known = this.#byId.get(id);
+    const oldAddress = known?.outputKey;
     this.#byId.set(id, output);
     if (known !== output) {
       const at = this.#now();
       this.#lifetime.set(id, { startedAt: at, lastAccessedAt: at });
     }
+    if (known !== output && oldAddress !== output?.outputKey) {
+      this.#forgetWaitIdentityIfUnused(oldAddress);
+    }
+    this.#openWaitIdentity(output?.outputKey);
     return this;
   }
 
@@ -69,13 +84,42 @@ export class OutputCatalog {
   }
 
   delete(id) {
+    const output = this.#byId.get(id);
     this.#lifetime.delete(id);
-    return this.#byId.delete(id);
+    const deleted = this.#byId.delete(id);
+    if (deleted) this.#forgetWaitIdentityIfUnused(output?.outputKey);
+    return deleted;
   }
 
   clear() {
+    const addresses = new Set([...this.#byId.values()].map(output => output?.outputKey).filter(Boolean));
     this.#lifetime.clear();
     this.#byId.clear();
+    for (const address of addresses) this.#forgetWaitIdentityIfUnused(address);
+  }
+
+  /** The shared active lifetime for the output addressed by a live session. */
+  waitIdentity(id) {
+    const output = this.#byId.get(id);
+    return output ? this.#waitIdentities.get(output.outputKey) ?? null : null;
+  }
+
+  #openWaitIdentity(address) {
+    if (typeof address !== "string" || !address || this.#waitIdentities.has(address)) return;
+    const identity = {};
+    this.#waitIdentities.set(address, identity);
+    this.#waitIdentityStarted(address, identity);
+  }
+
+  #forgetWaitIdentityIfUnused(address) {
+    if (typeof address !== "string" || !address) return;
+    for (const output of this.#byId.values()) {
+      if (output?.outputKey === address) return;
+    }
+    const identity = this.#waitIdentities.get(address);
+    if (!identity) return;
+    this.#waitIdentities.delete(address);
+    this.#waitIdentityEnded(address, identity);
   }
 
   touch(outputOrId, at = this.#now()) {

package/services/server/OutputLifecycle.js

@@ -55,7 +55,7 @@ export class OutputLifecycle {
   #host;
 
   /**
-   * @param {object} host - `retention`, `outputNeeded`, `outputWriting`, `outputReading`, `planEncodersSoon`, `now`, `invalidateWaits`, `segmentFormatOfKey`, `viewerSegmentsOn`, `budgetTimer`, `cleanupTimer`, `encodeRuns`, `keyframeTables`, `machineBudget`, `outputTimes`, `outputs`, `returns`, `segmentStore`, `sessionTtlMs`, `sourceFiles`, `timelines`, `viewers`
+   * @param {object} host - `retention`, `outputNeeded`, `outputWriting`, `outputReading`, `planEncodersSoon`, `now`, `invalidateWaits`, `clearWaits`, `segmentFormatOfKey`, `viewerSegmentsOn`, `budgetTimer`, `cleanupTimer`, `encodeRuns`, `keyframeTables`, `machineBudget`, `outputTimes`, `outputs`, `returns`, `segmentStore`, `sessionTtlMs`, `sourceFiles`, `timelines`, `viewers`
    */
   constructor(host) {
     this.#host = host;
@@ -267,6 +267,7 @@ export class OutputLifecycle {
     for (const sessionId of activeIds) {
       await this.disposeSession(sessionId);
     }
+    this.#host.clearWaits?.();
     // Everything this process owns, root included. See SegmentStore.dropAll.
     this.#host.segmentStore.dropAll("the proxy is shutting down");
   }
@@ -427,6 +428,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/SegmentServing.js

@@ -78,6 +78,20 @@ export class SegmentServing {
     state.waitListeners.clear();
   }
 
+  /** Identity of the live output-key lifetime named by this session. */
+  waitIdentity(sessionId) {
+    return this.#host.outputs.waitIdentity(sessionId);
+  }
+
+  /** Record a completed wait through the ledger operation wired by the server. */
+  noteWait(ranked, waitedMs, identity) {
+    this.#host.noteWait?.(ranked, waitedMs, identity);
+  }
+
+  waitBandOf(rank, topRank) {
+    return this.#host.waitBandOf?.(rank, topRank) ?? "later";
+  }
+
   /** Observe storage and lifecycle before a request checks file availability. */
   subscribeFileChange(sessionId) {
     const output = isOutputName(sessionId) ? this.#host.outputs.get(sessionId) : null;

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/transcode-session-files.js

@@ -1,6 +1,4 @@
 import { logger } from "../../utils/logger.js";
-import { bandOf, waits } from "./WaitLedger.js";
-
 /**
  * Which viewer is asking, or an empty string where the transport names nobody.
  *
@@ -84,6 +82,12 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
   // a plain HTTP transport, where no loader of ours builds the URL, and then
   // the single shared position decides as it always did.
   const consumerId = consumerOf(req);
+  // Hold the output-key lifetime that this request entered. Disposal followed
+  // by reopening the same key must not let its old completion write into the
+  // new output's measurements.
+  const waitIdentity = typeof serving.waitIdentity === "function"
+    ? serving.waitIdentity(sessionId)
+    : undefined;
   // Readiness or a terminal state ends the wait. A caller leaving cancels it;
   // elapsed time is not evidence that media preparation failed.
   const holdStartedAt = Date.now();
@@ -132,11 +136,12 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
     // like, and without them the table would hold only the failures.
     const ranked = result.ranked ?? null;
     if (ranked) {
-      waits.note(ranked.address, heldMs, ranked.rank, ranked.topRank);
+      serving.noteWait?.(ranked, heldMs, waitIdentity);
     }
     logger.info(
       `[hold] ${fileName} ${outcome} after ${heldMs}ms` +
-      (ranked ? ` (the map wants it ${bandOf(ranked.rank, ranked.topRank)}, rank ${ranked.rank} of ${ranked.topRank})` : "")
+      (ranked ? ` (the map wants it ${serving.waitBandOf?.(ranked.rank, ranked.topRank) ?? "later"}, ` +
+        `rank ${ranked.rank} of ${ranked.topRank})` : "")
     );
   }
 

package/services/server/wire-outputs.js

@@ -10,7 +10,7 @@
 
 import { logger } from "../../utils/logger.js";
 import { KeyframeTables } from "../media/KeyframeTables.js";
-import { waits } from "./WaitLedger.js";
+import { bandOf, WaitLedger } from "../encode/OutputWaitLedger.js";
 import { readEndedChildrenCpuSeconds, readMachineState, readProcessCpuSeconds, readProxyCpuSeconds, readSystemCpu, shareOfMachine } from "../encode/host-load.js";
 import { minimumBufferFrom } from "../torrent/supply-margin.js";
 import { PriorityOrchestrator } from "../viewer/PriorityOrchestrator.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";
@@ -243,6 +244,9 @@ export function wireOutputs({
     // Told when an encoder starts or ends: the room this host has for one more
     // encode changes with it, and the server chooses proxies by that room.
     onEncodersChanged = null}) {
+  // Long-lived wait diagnostics belong to this wired output graph: each live
+  // output key owns its record, and the graph releases it at the last session.
+  const waits = new WaitLedger();
   const parts = {};
   const audioDescriptionOf = (output) => (getCachedAudioTracks?.({
     sourceKey: output.file.sourceKey, fileIndex: output.spec.grid?.fileIndex ?? output.file.fileIndex
@@ -551,6 +555,9 @@ export function wireOutputs({
     get lookaheadSeconds() { return parts.lookaheadSeconds; },
     get outputTimes() { return parts.outputTimes; },
     get outputs() { return parts.outputs; },
+    noteWait: (ranked, waitedMs, identity) =>
+      waits.note(ranked.address, waitedMs, ranked.rank, ranked.topRank, identity),
+    waitBandOf: bandOf,
     get segmentStore() { return parts.segmentStore; },
     get startupWaitMs() { return parts.startupWaitMs; },
     get viewers() { return parts.viewers; },
@@ -564,6 +571,7 @@ export function wireOutputs({
     outputReading: key => parts.segmentStore.isReading(key) || parts.viewers.responsesHold(key),
     planEncodersSoon: () => parts.encodeRuns.planEncodersSoon(),
     invalidateWaits: (output) => parts.serving.invalidateWaits(output),
+    clearWaits: () => waits.clear(),
     segmentFormatOfKey,
     // Where the viewers of one output stand, in its segments: what the store
     // the output retention policy reads to give disk back in the right order.
@@ -579,6 +587,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 +638,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),
@@ -952,7 +967,9 @@ export function wireOutputs({
   // belongs to, the steps, the soundtracks, the height a step is named by.
   parts.outputs = new OutputCatalog({
     fileLengthOf: (session) => parts.hostLoad.fileLengthByKey.get(session.file.key) ?? 0,
-    largestPieceOf: (address) => parts.segmentStore.largestPiece(address)
+    largestPieceOf: (address) => parts.segmentStore.largestPiece(address),
+    waitIdentityStarted: (address, identity) => waits.open(address, identity),
+    waitIdentityEnded: (address, identity) => waits.forget(address, identity)
   });
   // Where produced segments live, addressed by WHAT they are rather than by
   // which session's encoder wrote them. Two sessions of one output — two
@@ -1173,6 +1190,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 +1243,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