@torrent-tv/proxy 2.87.12 → 2.87.14

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.87.14
+
+- **Fix**: Evaluate source-stall coverage against the continuous timeline already prepared on the proxy, while independently checking client-buffer continuity and delivery capacity.
+
+## 2.87.13
+
+- **Fix**: Include distinct active piece reads in memory demand and preserve their slots immediately, so reads without priority-map ranges cannot deadlock the torrent piece store.
+
 ## 2.87.12
 
 - **Fix**: Check each automatic output against whole-machine encoding occupancy before opening it, so a rejected size can resolve to a lower admissible rung instead of failing the request.

package/package.json

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

package/services/server/playback-readiness.js

@@ -81,7 +81,7 @@ export class RateTrend {
  * @param {number} input.durationSeconds
  * @param {number} input.bufferedAheadSeconds
  * @param {number} input.bufferLimitSeconds
- * @param {number} input.reserveSeconds
+ * @param {number} input.reserveSeconds - Measured source-stall coverage, in media seconds.
  * @param {number} input.lookaheadSeconds
  * @param {number} input.now
  * @param {boolean} [input.requiredAudio]
@@ -110,12 +110,9 @@ export function predictPlaybackReadiness(input = {}) {
   if (remaining <= buffered) {
     return result(true, 0, buffered, reserve, 0, "client-buffer-covers-end", 0);
   }
-  if (!(duration > 0) || !(capacity > 0) || !(reserve > 0) || tracks.length === 0) {
+  if (!(duration > 0) || !(capacity > 0) || tracks.length === 0) {
     return result(false, null, buffered, reserve, null, "incomplete-state", 0);
   }
-  if (reserve > capacity) {
-    return result(false, null, buffered, reserve, null, "reserve-exceeds-client-capacity", 0);
-  }
   const requiredTracks = input.requiredAudio === true ? 2 : 1;
   if (tracks.length < requiredTracks) {
     return result(false, null, buffered, reserve, null, "separate-audio-not-observed", 0);
@@ -166,7 +163,7 @@ export function predictPlaybackReadiness(input = {}) {
 
   for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
     const state = trackState[trackIndex];
-    const { track, ready, segments } = state;
+    const { track, segments } = state;
     const measuredBitsPerMediaSecond = state.bitsPerMediaSecond;
     for (const segment of segments) {
       if (segment.endSeconds <= position + buffered) {
@@ -277,6 +274,7 @@ export function predictPlaybackReadiness(input = {}) {
     const trackFinish = trackState.map(() => 0);
     let transferFinish = 0;
     const completions = [];
+    const productions = [];
     for (const job of jobs) {
       const { track, trackIndex, segment, ahead, sizeBits, encodeWork, sourceIntervals } = job;
       if (prefillOnly && (ahead > prefillReach || segment.endSeconds - position > capacity)) {
@@ -322,7 +320,14 @@ export function predictPlaybackReadiness(input = {}) {
       if (!job.produced) {
         trackFinish[trackIndex] = encodedAt;
       }
-      const producedAt = Math.max(sourceReadyAtLatest, encodedAt);
+      const producedAt = job.produced ? 0 : Math.max(sourceReadyAtLatest, encodedAt);
+      productions.push({
+        at: producedAt,
+        sourceReadyAt: sourceReadyAtLatest,
+        trackIndex,
+        segment,
+        requiresSource: sourceIntervals.size > 0
+      });
       const roomAt = segment.endSeconds - position <= capacity
         ? 0
         : startDelaySeconds + segment.endSeconds - position - capacity;
@@ -339,12 +344,16 @@ export function predictPlaybackReadiness(input = {}) {
       ? completions.filter(({ segment }) => segment.startSeconds - position <= prefillReach &&
         segment.endSeconds - position <= capacity)
       : completions;
-    const safety = isSafeSchedule(usefulCompletions, trackState, position, duration,
+    const usefulProductions = prefillOnly
+      ? productions.filter(({ segment }) => segment.startSeconds - position <= prefillReach &&
+        segment.endSeconds - position <= capacity)
+      : productions;
+    const safety = isSafeSchedule(usefulCompletions, usefulProductions, trackState, position, duration,
       buffered, capacity, reserve, startDelaySeconds);
     return { safe: safety.safe,
       bufferedAtStart: safety.bufferedAtStart,
-      finishAt: usefulCompletions.reduce((latest, item) => Math.max(latest, item.at), 0),
-      completions: usefulCompletions };
+      neededSeconds: safety.neededSeconds,
+      finishAt: usefulCompletions.reduce((latest, item) => Math.max(latest, item.at), 0) };
   };
 
   const prefillReach = Math.min(capacity, lookahead, remaining);
@@ -353,7 +362,8 @@ export function predictPlaybackReadiness(input = {}) {
   if (!Number.isFinite(maximumUsefulDelay)) {
     return result(false, null, buffered, reserve, null, "prefill-cannot-complete", preparedSegments);
   }
-  if (schedule(0).safe) {
+  const immediate = schedule(0);
+  if (immediate.safe) {
     return result(true, 0, buffered, reserve, 0, "trajectory-safe-now", preparedSegments);
   }
   const searchLimit = Math.max(maximumUsefulDelay, rateRecoveryDelay);
@@ -396,7 +406,7 @@ export function predictPlaybackReadiness(input = {}) {
     }
   }
   const readiness = schedule(high);
-  return result(false, high, buffered, reserve, Math.max(0, reserve - buffered),
+  return result(false, high, buffered, reserve, immediate.neededSeconds,
     "minimum-safe-delay", preparedSegments, readiness.bufferedAtStart);
 }
 
@@ -508,53 +518,104 @@ function averageBitsPerMediaSecond(track, segments, ready) {
   return finiteNonNegative(track.bitsPerMediaSecond);
 }
 
-function isSafeSchedule(completions, trackState, position, duration, buffered, capacity, reserve, startDelay) {
-  const ranges = trackState.map(() => [{ start: position, end: position + buffered }]);
-  const ordered = [...completions]
+function isSafeSchedule(completions, productions, trackState, position, duration, buffered, capacity, reserve,
+  startDelay) {
+  // Client continuity is constrained by its buffer limit; source-stall reserve
+  // is covered by the larger union of client data and output already prepared here.
+  const clientRanges = trackState.map(() => [{ start: position, end: position + buffered }]);
+  const preparedRanges = trackState.map(() => [{ start: position, end: position + buffered }]);
+  const orderedCompletions = [...completions]
     .filter(({ at }) => Number.isFinite(at))
     .sort((left, right) => left.at - right.at || left.trackIndex - right.trackIndex);
+  const orderedProductions = [...productions]
+    .filter(({ at }) => Number.isFinite(at))
+    .sort((left, right) => left.at - right.at || left.trackIndex - right.trackIndex);
+  const reserveUntil = trackState.map(() => Number.NEGATIVE_INFINITY);
+  // The measured reserve applies only until this track's last required source
+  // interval has arrived; encoding and client delivery stay in the schedule.
+  for (const production of productions) {
+    if (production.requiresSource) {
+      reserveUntil[production.trackIndex] = Math.max(reserveUntil[production.trackIndex],
+        production.sourceReadyAt);
+    }
+  }
   let completionIndex = 0;
+  let productionIndex = 0;
 
   const addThrough = (time) => {
-    while (completionIndex < ordered.length && ordered[completionIndex].at <= time) {
-      const { trackIndex, segment } = ordered[completionIndex];
-      addRange(ranges[trackIndex], segment.startSeconds, segment.endSeconds);
+    while (productionIndex < orderedProductions.length && orderedProductions[productionIndex].at <= time) {
+      const { trackIndex, segment } = orderedProductions[productionIndex];
+      addRange(preparedRanges[trackIndex], segment.startSeconds, segment.endSeconds);
+      productionIndex += 1;
+    }
+    while (completionIndex < orderedCompletions.length && orderedCompletions[completionIndex].at <= time) {
+      const { trackIndex, segment } = orderedCompletions[completionIndex];
+      addRange(clientRanges[trackIndex], segment.startSeconds, segment.endSeconds);
+      addRange(preparedRanges[trackIndex], segment.startSeconds, segment.endSeconds);
       completionIndex += 1;
     }
   };
-  const safeAt = (time) => {
+  const safeAt = (time, checkClient = true) => {
     const playerPosition = position + Math.max(0, time - startDelay);
-    const available = Math.min(capacity, ...ranges.map((trackRanges) =>
+    if (playerPosition >= duration) {
+      return { safe: true, stockSafe: true, available: 0, neededSeconds: 0 };
+    }
+    const available = Math.min(capacity, ...clientRanges.map((trackRanges) =>
       Math.max(0, contiguousEnd(trackRanges, playerPosition) - playerPosition)));
-    const required = Math.min(reserve, Math.max(0, duration - playerPosition));
-    return { safe: available >= required, available };
+    let neededSeconds = 0;
+    let stockSafe = true;
+    for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
+      const required = time <= reserveUntil[trackIndex]
+        ? Math.min(reserve, Math.max(0, duration - playerPosition))
+        : 0;
+      const preparedAhead = Math.max(0,
+        contiguousEnd(preparedRanges[trackIndex], playerPosition) - playerPosition);
+      const deficit = Math.max(0, required - preparedAhead);
+      neededSeconds = Math.max(neededSeconds, deficit);
+      stockSafe &&= deficit === 0;
+    }
+    return {
+      safe: (!checkClient || available > 0) && stockSafe,
+      stockSafe,
+      available,
+      neededSeconds
+    };
   };
 
   addThrough(startDelay);
   const atStart = safeAt(startDelay);
   if (!atStart.safe) {
-    return { safe: false, bufferedAtStart: atStart.available };
-  }
-
-  while (completionIndex < ordered.length) {
-    const time = ordered[completionIndex].at;
-    if (time > startDelay) {
-      const beforeArrival = safeAt(time);
-      if (!beforeArrival.safe) {
-        return { safe: false, bufferedAtStart: atStart.available };
-      }
+    return { safe: false, bufferedAtStart: atStart.available, neededSeconds: atStart.neededSeconds };
+  }
+
+  const playbackEnd = startDelay + Math.max(0, duration - position);
+  const playbackBoundaries = [position + buffered,
+    ...trackState.flatMap(({ segments }) => segments.map(({ endSeconds }) => endSeconds))]
+    .filter((boundary) => boundary > position && boundary < duration)
+    .map((boundary) => startDelay + boundary - position);
+  const sourceReadyTimes = productions
+    .filter(({ requiresSource }) => requiresSource)
+    .map(({ sourceReadyAt }) => sourceReadyAt);
+  const eventTimes = [...orderedCompletions.map(({ at }) => at),
+    ...orderedProductions.map(({ at }) => at), ...playbackBoundaries, ...sourceReadyTimes]
+    .filter((time) => Number.isFinite(time) && time > startDelay && time < playbackEnd)
+    .sort((left, right) => left - right)
+    .filter((time, index, all) => index === 0 || time !== all[index - 1]);
+
+  for (const time of eventTimes) {
+    const beforeArrival = safeAt(time, false);
+    if (!beforeArrival.stockSafe) {
+      return { safe: false, bufferedAtStart: atStart.available, neededSeconds: beforeArrival.neededSeconds };
     }
     addThrough(time);
-    if (time > startDelay) {
-      const afterArrival = safeAt(time);
-      if (!afterArrival.safe) {
-        return { safe: false, bufferedAtStart: atStart.available };
-      }
+    const afterArrival = safeAt(time);
+    if (!afterArrival.safe) {
+      return { safe: false, bufferedAtStart: atStart.available, neededSeconds: afterArrival.neededSeconds };
     }
   }
 
-  const atEnd = safeAt(startDelay + Math.max(0, duration - position));
-  return { safe: atEnd.safe, bufferedAtStart: atStart.available };
+  const atEnd = safeAt(playbackEnd);
+  return { safe: atEnd.safe, bufferedAtStart: atStart.available, neededSeconds: atStart.neededSeconds };
 }
 
 function addRange(ranges, start, end) {

package/services/storage/piece-store/shared-piece-store.js

@@ -593,13 +593,13 @@ export class SharedPieceStore {
   }
 
   /**
-   * Whether the machine's share of memory is smaller than one reader's window.
+   * Whether the machine's share is smaller than current read demand.
    *
    * The store holds the window anyway — refusing would leave the read it is
    * serving unable to finish, which is worse — but it is the honest measure of
    * "this machine cannot take any more", and it is measured rather than
-   * guessed: it is the last revision's own comparison of what the machine
-   * allowed against what the widest reader declared.
+   * guessed: it is the last revision's comparison of the machine's share
+   * against declared windows and distinct pieces pinned by live reads.
    */
   get isBeyondTheMachine() {
     return this.#beyondTheMachine;
@@ -650,15 +650,17 @@ export class SharedPieceStore {
    * resident piece ends up pinned, the read returns zero bytes and ffmpeg takes
    * that for the end of the file (field 2026-08-15, roadmap item 9).
    *
-   * With no reader declaring anything there is no demand to speak of, so the
-   * store asks for what the machine allows and the first revision after a read
-   * begins brings it down to what that read needs.
+   * A declared window is not the only evidence of demand: a live reader pins
+   * each piece it is waiting on or handing to its consumer. Include those
+   * distinct pins as well, because some byte reads do not have a priority-map
+   * range to declare.
    */
   get wantedBytes() {
     const demand = this.#lru.demand();
+    const pinned = this.#lru.pinnedCount;
     if (demand.readers > 0) {
       this.#widestSeenPieces = Math.max(this.#widestSeenPieces, demand.widestPieces);
-      const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces);
+      const pieces = Math.max(MIN_RESIDENT_PIECES, demand.unionPieces, demand.widestPieces, pinned);
       // Plus room to absorb what arrives while a write is finishing. Asking for
       // exactly what the readers want leaves no free place ever, so every
       // arrival evicts one of them — measured 2026-09-02: `6 reader(s) want 23
@@ -666,9 +668,9 @@ export class SharedPieceStore {
       // that followed.
       return (pieces + this.slackPieces()) * this.#chunkLength;
     }
-    // WITH NO READER, THE FLOOR IS ONE READER'S WINDOW — the widest this store
-    // has actually been asked for, which is measured rather than chosen, and
-    // `MIN_RESIDENT_PIECES` only until it has been asked for anything.
+    // WITH NO DECLARED RANGE, the floor is the widest prior window or the
+    // distinct pieces pinned by current reads, both measured rather than
+    // chosen. `MIN_RESIDENT_PIECES` applies until either has been observed.
     //
     // It used to fall to the minimum the moment the last reader went, and the
     // allowance is re-derived once a minute (`STORE_REPORT_INTERVAL_MS`) while
@@ -677,12 +679,11 @@ export class SharedPieceStore {
     // to another file of the same torrent and the store was at
     // `0/3 (0MB of 12MB allowed)` with the machine offering 4.3 GB.
     //
-    // Holding one window's worth between readers is not waste: it is what the
-    // next read will ask for within seconds, and the pieces in it are the ones
-    // that reader left off at. A store that has never been read keeps nothing
-    // either — its pieces are arriving for a reader on the way, and they have
-    // the disk.
-    return (Math.max(MIN_RESIDENT_PIECES, this.#widestSeenPieces) + this.slackPieces()) * this.#chunkLength;
+    // Retaining the last declared window between reads avoids dropping back to
+    // the minimum; current pins cover reads that have no declared window. A
+    // store that has never been read keeps only the measured minimum.
+    const pieces = Math.max(MIN_RESIDENT_PIECES, this.#widestSeenPieces, pinned);
+    return (pieces + this.slackPieces()) * this.#chunkLength;
   }
 
   reviseGrowthCeiling(allowedBytes) {
@@ -692,27 +693,33 @@ export class SharedPieceStore {
     // the machine was full kept a small allowance for its whole life, however
     // much memory was freed afterwards (roadmap item 2, 2026-09-02).
     const wanted = Math.floor(Number(allowedBytes) / this.#chunkLength);
-    // Never below what the live readers together hold, even when the machine's
-    // share says less. A store that cannot hold what its readers are pinning
-    // cannot complete any of their reads at all: every resident piece ends up
-    // pinned, a read returns zero bytes and ffmpeg takes that for the end of
-    // the file, which killed every encoder on that file in the field on
+    // Never below what the live readers together need, even when the machine's
+    // share says less. That is the union of declared windows, or the distinct
+    // pieces pinned by direct reads that have no declared window. A store that
+    // cannot hold what its readers are pinning cannot complete those reads:
+    // every resident piece ends up pinned, a read returns zero bytes and
+    // ffmpeg takes that for the end of the file, which killed every encoder on
+    // that file in the field on
     // 2026-08-15 (one reader) and again on 2026-09-07 (three readers of one
     // file at once — picture, sound and the edge-warming read — where this
     // floor was still computed from only the widest one of them, `wantedBytes`
     // above already asks for the union and got it right; this is the same
-    // union, used as the floor instead of only as the ask). Exceeding the share
-    // is the lesser failure, and the line below says when it happens.
+    // union, used as the floor instead of only as the ask). A live read can
+    // also pin pieces without a priority-map range, so those measured pins are
+    // part of the same minimum. Exceeding the share is the lesser failure, and
+    // the line below says when it happens.
     const demand = this.#lru.demand();
-    this.#growthCeiling = Math.max(
+    const activeDemandPieces = Math.max(
       MIN_RESIDENT_PIECES,
-      demand.readers > 0 ? demand.unionPieces : MIN_RESIDENT_PIECES,
+      demand.readers > 0 ? demand.unionPieces : 0,
+      this.#lru.pinnedCount
+    );
+    this.#growthCeiling = Math.max(
+      activeDemandPieces,
       Number.isFinite(wanted) ? wanted : MIN_RESIDENT_PIECES
     );
-    const belowAWindow = demand.readers > 0
-      && Number.isFinite(wanted)
-      && wanted < demand.unionPieces;
-    this.#beyondTheMachine = belowAWindow;
+    const belowActiveDemand = Number.isFinite(wanted) && wanted < activeDemandPieces;
+    this.#beyondTheMachine = belowActiveDemand;
     // The LRU is told too. It was constructed with the store's original
     // capacity and never revised, so `isFull()` answered against a number that
     // had not been the limit for some time — dormant only because nothing calls
@@ -754,7 +761,7 @@ export class SharedPieceStore {
       committedBytes: this.#blocksAllocated * this.#chunkLength,
       evicted,
       releasedBlocks,
-      belowAWindow
+      belowActiveDemand
     };
   }
 
@@ -803,6 +810,19 @@ export class SharedPieceStore {
 
   pin(index) {
     this.#lru.pin(index);
+    // A piece reader pins before it waits for the bytes to arrive or return
+    // from disk. That is the only live record of some reads; the priority map
+    // can have no declared range for them (for example, a verified piece that
+    // was spilled). Include the measured set of distinct active pins in the
+    // immediate floor so a claim does not wait for the next budget pass to get
+    // a slot. `wantedBytes` carries the same demand to the machine-wide owner.
+    const pinned = this.#lru.pinnedCount;
+    if (pinned > this.#growthCeiling) {
+      this.#growthCeiling = pinned;
+      this.#lru.setCapacity(pinned);
+      this.#beyondTheMachine = true;
+      this.#wake();
+    }
   }
 
   unpin(index) {

package/services/torrent/worker/worker.js

@@ -638,11 +638,11 @@ setInterval(() => {
         (revised.releasedBlocks > 0 ? `, gave back ${revised.releasedBlocks} block(s) of memory` : "") +
         ` — now ${Math.round(revised.committedBytes / 1048576)}MB committed`
       );
-    } else if (revised.belowAWindow) {
+    } else if (revised.belowActiveDemand) {
       log(
-        `piece-store "${revised.name.slice(0, 40)}": the machine's share is smaller than one ` +
-        `reader's window, so the allowance is held at ${Math.round(revised.ceilingBytes / 1048576)}MB ` +
-        "anyway — a store that cannot hold the window of the read it is serving cannot finish that read"
+        `piece-store "${revised.name.slice(0, 40)}": the machine's share is smaller than active read demand, ` +
+        `so the allowance is held at ${Math.round(revised.ceilingBytes / 1048576)}MB ` +
+        "— a store cannot finish a read if it cannot hold the pieces that read is using"
       );
     } else if (revised.committedBytes > revised.ceilingBytes) {
       log(

package/test/piece-store-eviction.test.js

@@ -428,6 +428,41 @@ test("a store whose readers have gone asks for nothing, one that never had them
   }
 });
 
+test("live piece pins set memory demand when no priority-map range is declared", async () => {
+  const { store, directory } = await makeStore(2);
+  try {
+    await put(store, 0, pieceOf(0));
+    await put(store, 1, pieceOf(1));
+
+    store.pin(0);
+    store.pin(1);
+    store.pin(2);
+
+    assert.equal(store.stats().demand.readers, 0, "this read has no priority-map range");
+    assert.equal(store.stats().pinned, 3, "the three distinct live pieces are measured");
+    assert.equal(store.capacity, 3, "the active read demand expands capacity immediately");
+    assert.equal(store.wantedBytes, 3 * PIECE, "the budget owner sees the same measured demand");
+
+    const revised = store.reviseGrowthCeiling(2 * PIECE);
+    assert.equal(revised.ceilingBytes, 3 * PIECE, "a budget pass preserves pieces in active reads");
+    assert.equal(revised.belowActiveDemand, true, "the store reports that the machine share was short");
+
+    await put(store, 2, pieceOf(2));
+    assert.ok(store.locate(0), "the first active piece remains resident");
+    assert.ok(store.locate(1), "the second active piece remains resident");
+    assert.ok(store.locate(2), "the pending active piece obtains a memory slot");
+
+    store.unpin(0);
+    store.unpin(1);
+    store.unpin(2);
+    const released = store.reviseGrowthCeiling(2 * PIECE);
+    assert.equal(released.ceilingBytes, 2 * PIECE, "the measured floor falls after the reads release their pieces");
+  } finally {
+    await store.destroy();
+    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
+  }
+});
+
 test("the allowance is never cut below one reader's whole window", async () => {
   const { store, directory } = await makeStore(16);
   try {
@@ -438,13 +473,13 @@ test("the allowance is never cut below one reader's whole window", async () => {
     // which killed every encoder on that file in the field on 2026-08-15.
     const revised = store.reviseGrowthCeiling(2 * PIECE);
     assert.equal(revised.ceilingBytes, 10 * PIECE, "one whole window is the floor");
-    assert.equal(revised.belowAWindow, true, "and the store says the share was smaller than that");
+    assert.equal(revised.belowActiveDemand, true, "and the store says the share was smaller than that");
 
     // With no reader there is no window to protect and the share is obeyed.
     store.releaseProtection("video");
     const obeyed = store.reviseGrowthCeiling(2 * PIECE);
     assert.equal(obeyed.ceilingBytes, 2 * PIECE);
-    assert.equal(obeyed.belowAWindow, false);
+    assert.equal(obeyed.belowActiveDemand, false);
   } finally {
     store.destroy(() => undefined);
     await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });

package/test/playback-readiness.test.js

@@ -36,7 +36,50 @@ test("finds the first safe start from segments delivered before playback", () =>
 
   assert.equal(forecast.ready, false);
   assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Math.abs(forecast.delaySeconds - 3) < 1e-8);
+  assert.ok(Math.abs(forecast.delaySeconds - 1) < 1e-8);
+});
+
+test("keeps source-stall reserve in the proxy's prepared timeline, not the capped browser buffer", () => {
+  const now = 10_000;
+  const forecast = predictPlaybackReadiness({
+    now,
+    positionSeconds: 0,
+    durationSeconds: 12,
+    bufferedAheadSeconds: 2,
+    bufferLimitSeconds: 4,
+    reserveSeconds: 6,
+    lookaheadSeconds: 12,
+    sources: [{
+      id: "source",
+      complete: false,
+      bytesPerMediaSecond: 1,
+      readings: [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }]
+    }],
+    tracks: [{
+      id: "video",
+      sourceIds: ["source"],
+      processedSeconds: 8,
+      bitsPerMediaSecond: 80,
+      readings: [{ at: now - 1_000, value: 2 }, { at: now, value: 2 }],
+      segments: [
+        { index: 0, startSeconds: 0, endSeconds: 2 },
+        { index: 1, startSeconds: 2, endSeconds: 4 },
+        { index: 2, startSeconds: 4, endSeconds: 6 },
+        { index: 3, startSeconds: 6, endSeconds: 8 },
+        { index: 4, startSeconds: 8, endSeconds: 10 },
+        { index: 5, startSeconds: 10, endSeconds: 12 }
+      ],
+      readySegmentIndices: [0, 1, 2, 3],
+      segmentSizesBytes: new Map([[0, 20], [1, 20], [2, 20], [3, 20], [4, 20], [5, 20]])
+    }],
+    linkReadings: [{ at: now - 1_000, value: 80_000 }, { at: now, value: 80_000 }]
+  });
+
+  assert.equal(forecast.ready, true);
+  assert.equal(forecast.reason, "trajectory-safe-now");
+  assert.equal(forecast.reserveSeconds, 6);
+  assert.equal(forecast.bufferedSeconds, 2);
+  assert.equal(forecast.preparedSegments, 4);
 });
 
 test("overlaps source reads and encoding, then waits for the slower stage and delivery", () => {
@@ -53,7 +96,7 @@ test("overlaps source reads and encoding, then waits for the slower stage and de
   const forecast = predictPlaybackReadiness(input({ sources: [source], tracks: [track] }));
 
   assert.equal(forecast.ready, false);
-  assert.ok(Math.abs(forecast.delaySeconds - 3) < 1e-8);
+  assert.ok(Math.abs(forecast.delaySeconds - 2) < 1e-8);
 });
 
 test("does not produce an ETA without a client-link measurement", () => {
@@ -177,7 +220,7 @@ test("downloads an overlapping source interval once when two tracks use the same
 
   assert.equal(forecast.ready, false);
   assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Math.abs(forecast.delaySeconds - 2.048) < 1e-8);
+  assert.ok(Math.abs(forecast.delaySeconds - 2.032) < 1e-8);
 });
 
 test("downloads sources on separate torrents concurrently", () => {
@@ -319,5 +362,5 @@ test("finds a safe interval when rising encode speed and falling link speed make
   assert.equal(forecast.ready, false);
   assert.equal(forecast.reason, "minimum-safe-delay");
   assert.ok(Number.isFinite(forecast.delaySeconds));
-  assert.ok(forecast.delaySeconds > 7 && forecast.delaySeconds < 10);
+  assert.ok(forecast.delaySeconds > 4 && forecast.delaySeconds < 5);
 });