@torrent-tv/proxy 2.101.4 → 2.101.6

package/package.json

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

package/services/encode/PauseRule.js

@@ -160,9 +160,16 @@ export class PauseRule {
     const since = this.#triedAt.get(run) ?? Number.NEGATIVE_INFINITY;
     const beside = lead.filter((second) => second.running.has(run) && second.at > since);
     if (beside.length < LEAST_SECONDS) {
-      // Let go by this rule and not measured yet: it runs until it is.
-      // Running since before anything could be compared: the urgency rule.
-      return this.#triedAt.has(run) ? { runs: true, because: `being measured beside the leader (${beside.length}s so far)` } : null;
+      if (this.#triedAt.has(run)) {
+        // Let go by this rule and not measured yet: it runs until it is.
+        return { runs: true, because: `being measured beside the leader (${beside.length}s so far)` };
+      }
+      // Running and not measured yet without having been let go by this rule
+      // (a start the plan made, or a run that led before): judged as a try,
+      // the condition `wouldStart` let it start under. Paused at once and
+      // tried a tick later instead, short runs on Home Assistant (r80) went
+      // through both: 81 pauses of 0.3 s (median), one per run.
+      return this.#whetherToTry({ leader, band, run, need, lead, without, draw, free, others, otherRunning, now });
     }
     const besideSpeed = middleAndScatter(beside.map((second) => second.speed));
     if (Number.isFinite(need)) {

package/services/encode/quality/HostLoad.js

@@ -157,7 +157,7 @@ export class HostLoad {
   #supplyByKey = new Map();
 
   /**
-   * @param {object} host - `liveRunsOf`, `runStateOf`, the readings of `encode/host-load.js` (`readMachineState`, `readProcessCpuSeconds`, `readProxyCpuSeconds`, `readSystemCpu`, `shareOfMachine`), `getSourceStats`, `getTorrentTotals`, `outputs`
+   * @param {object} host - `liveRunsOf`, `runStateOf`, the readings of `encode/host-load.js` (`readMachineState`, `readProcessCpuSeconds`, `readProxyCpuSeconds`, `readSystemCpu`, `shareOfMachine`), `getSourceStats`, `getTorrentTotals`, `outputs`, and optionally `costSecOf(session)`, `EncodeCost`'s cost of an output, said beside each run's `k`
    */
   /** The share of the machine this process draws doing nothing priced; zero until measured. */
   get baseDraw() {
@@ -634,6 +634,13 @@ export class HostLoad {
    * Only runs read at both ends that made film in between are said. For the
    * log only.
    *
+   * Beside each `k`, `EncodeCost`'s cost of the run's output (`c`) and `k`
+   * converted to that unit over the cores this process may use (`k/U`), on the
+   * same reading: where a run uses less than it is given the two differ, and
+   * whether the processor claim moves from `c` to `k` is judged from these
+   * lines (plan 2.3, torrent-tv/meta#180). `c` is filed as if the run were
+   * alone on a quiet machine; a `k` read beside other runs is not.
+   *
    * @param {{ takenAt: number, byPid: Map<number, number>, runs?: Map<number, { film: number | null, label: string, kind: string }> }} previous
    * @param {{ takenAt: number, byPid: Map<number, number>, runs?: Map<number, { film: number | null, label: string, kind: string }> }} sample
    */
@@ -642,6 +649,8 @@ export class HostLoad {
     const elapsedSec = (sample.takenAt - previous.takenAt) / 1000;
     if (!(elapsedSec > 0)) return;
     const alive = new Map([...previous.runs, ...sample.runs]);
+    const boundCores = Number(sample.processor?.bound?.cores);
+    const cores = Number.isFinite(boundCores) && boundCores > 0 ? boundCores : Math.max(1, os.cpus().length);
     const said = [];
     for (const [pid, run] of sample.runs) {
       const before = previous.runs.get(pid);
@@ -653,15 +662,34 @@ export class HostLoad {
       if (!(film > 0)) continue;
       const cpu = cpuNow - cpuBefore;
       const beside = [...alive].filter(([other]) => other !== pid).map(([, other]) => other.kind);
-      said.push(`${run.label} ${run.kind} k=${(cpu / film).toFixed(3)} CPU-s per film-s ` +
+      const k = cpu / film;
+      said.push(`${run.label} ${run.kind} k=${k.toFixed(3)} CPU-s per film-s ` +
         `(${cpu.toFixed(2)} CPU-s, ${film.toFixed(2)} film-s, speed ${(film / elapsedSec).toFixed(2)}x, ` +
-        `${(cpu / elapsedSec).toFixed(2)} cores), beside ${beside.length}` + (beside.length > 0 ? ` [${beside.join(", ")}]` : ""));
+        `${(cpu / elapsedSec).toFixed(2)} cores), ` +
+        `c=${Number.isFinite(run.costSec) && run.costSec > 0 ? run.costSec.toFixed(3) : "unpriced"} k/U=${(k / cores).toFixed(3)} ` +
+        `(U=${cores.toFixed(2)} cores), beside ${beside.length}` + (beside.length > 0 ? ` [${beside.join(", ")}]` : ""));
     }
     if (said.length > 0) {
       logger.info(`processor: run cost over ${elapsedSec.toFixed(1)}s: ${said.join("; ")}`);
     }
   }
 
+  /**
+   * `EncodeCost`'s cost of an output, for the log; null where it is unpriced
+   * or cannot be read.
+   *
+   * @param {object} session
+   * @returns {number | null}
+   */
+  #costSecOf(session) {
+    try {
+      const cost = Number(this.#host.costSecOf?.(session));
+      return Number.isFinite(cost) && cost > 0 ? cost : null;
+    } catch {
+      return null;
+    }
+  }
+
   /**
    * @param {{ elapsedSec: number, processShare: number | null, systemShare: number | null, rejected?: string[] } | null} share
    * @param {{ proxyCpuSeconds: number | null }} previous
@@ -750,7 +778,8 @@ export class HostLoad {
         startedAt: run.startedAt,
         film: filmMadeBy(run),
         label: `${session.outputKey ?? session.id} #${run.from}..#${run.to}`,
-        kind: costKindForSession(session)
+        kind: costKindForSession(session),
+        costSec: this.#costSecOf(session)
       })));
     const [system, endedChildren, ...cpuReadings] = await Promise.all([
       this.#host.readSystemCpu(),
@@ -761,7 +790,7 @@ export class HostLoad {
     const byPid = new Map();
     /** @type {Map<number, number>} */
     const startedAt = new Map();
-    /** @type {Map<number, { film: number | null, label: string, kind: string }>} */
+    /** @type {Map<number, { film: number | null, label: string, kind: string, costSec: number | null }>} */
     const runsByPid = new Map();
     runs.forEach((run, index) => {
       const seconds = cpuReadings[index];
@@ -769,7 +798,7 @@ export class HostLoad {
         byPid.set(run.pid, seconds);
         startedAt.set(run.pid, run.startedAt);
       }
-      runsByPid.set(run.pid, { film: run.film, label: run.label, kind: run.kind });
+      runsByPid.set(run.pid, { film: run.film, label: run.label, kind: run.kind, costSec: run.costSec });
     });
     const sample = {
       takenAt: Date.now(),

package/services/server/ViewerRequests.js

@@ -828,7 +828,9 @@ export class ViewerRequests {
     logger.info(`playback held ${session.id} consumer=${consumerId}: delay ${seconds(delay)}s by ` +
       (holding.kind === "position-not-held" ? "the position, which nothing buffered covers" :
         `the ${holding.kind} of ${holding.track} #${holding.segment} in ${seconds(holding.atSeconds)}s against ` +
-        `${seconds(holding.aheadSeconds)}s of media before it${holding.requiresSource ? ", its input still downloading" : ""}`) +
+        `${seconds(holding.aheadSeconds)}s of media before it${holding.requiresSource ? ", its input still downloading" : ""}` +
+        (Number.isFinite(holding.sourceArrivalSeconds) ? ` until ${seconds(holding.sourceArrivalSeconds)}s by ` +
+          (holding.sourcePlanned ? "the torrent's queues" : "the measured download rate") : "")) +
       `; buffered ${seconds(forecast.bufferedSeconds)}s; rates ${rates.join(", ") || "none"}; download ${downloads.join(", ") || "none"}`);
   }
 

package/services/server/wire-outputs.js

@@ -309,6 +309,8 @@ export function wireOutputs({
     describeProcessor,
     liveRunsOf: (...args) => parts.encodeRuns.liveRunsOf(...args),
     runStateOf: (...args) => parts.encodeRuns.runStateOf(...args),
+    // Today's cost `c` beside each run's measured `k` (torrent-tv/meta#180, plan 2.3).
+    costSecOf: (session) => parts.encodeCost?.loadOfOutput(session.outputKey)?.costSec ?? null,
     get getSourceStats() { return parts.getSourceStats; },
     get getTorrentTotals() { return parts.getTorrentTotals; },
     get outputs() { return parts.outputs; },

package/services/torrent/download/FutureDownload.js

@@ -1,27 +1,25 @@
 import { setImmediate as nextTurn } from "node:timers/promises";
 import { piecesOf } from "../demand/pieces.js";
 import { pieceStoreOf } from "../piece-store-of.js";
-import { compareBands } from "./bands.js";
 
 const BLOCK_BYTES = 16 * 1024;
 
-/** Estimate completion from observed queues and the public selection bands.
- * The native picker takes a band's pieces from its first up (the `sequential`
- * strategy), so an unqueued piece arrives after the band's pieces before it.
- * A piece whose every missing block is asked for arrives when its queues say,
- * and is not the band's to share out. A supplier is a peer that can be asked
- * for the piece now. Pieces without a measured supplier remain unknown. No
- * requests are changed.
+/** When the pieces whose every missing block is asked for arrive, from the
+ * queues that hold them. A block is reserved to the wire it was asked of, so a
+ * faster peer elsewhere does not bring it sooner (WebTorrent 2.8.5 `_request`,
+ * torrent.js:1758). Every other missing piece is left unknown: the start
+ * forecast brings those at the source's measured service, in its own media
+ * order (`viewer/playback-readiness.js`), one model of supply rather than a
+ * second one here (torrent-tv/meta#185). No requests are changed.
  * Times are conditional on the measured rate and successful verification.
  */
 export async function futureDownload(entries, { now = Date.now(), findStore = pieceStoreOf, isCurrent = () => true } = {}) {
   if (!isCurrent()) return new Map();
   const forecasts = new Map();
-  const pending = [];
   let steps = 0;
-  for (const { torrent, register, limit = null } of entries) {
+  for (const { torrent, register } of entries) {
     if (torrent.destroyed || torrent.ready === false) continue;
-    const wanted = new Map();
+    const wanted = new Set();
     for (const window of register.windows()) {
       const file = torrent.files?.[window.fileIndex];
       if (!file) continue;
@@ -29,10 +27,7 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
         byteEnd: Math.min(window.byteEnd, file.length - 1), pieceLength: torrent.pieceLength });
       if (!range) continue;
       for (let piece = range.from; piece <= range.to; piece++) {
-        const previous = wanted.get(piece);
-        if (!previous || compareBands(window, previous) < 0) {
-          wanted.set(piece, { urgency: window.urgency, priority: window.priority, deadlineAt: window.deadlineAt });
-        }
+        wanted.add(piece);
         if (++steps % 256 === 0) {
           await nextTurn();
           if (!isCurrent()) return new Map();
@@ -63,7 +58,7 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
     }
     const store = findStore(torrent);
     const arrivals = new Map();
-    for (const [index, band] of wanted) {
+    for (const index of wanted) {
       const present = store?.locationOf ? store.locationOf(index) !== "missing" : torrent.bitfield?.get(index);
       if (present) {
         arrivals.set(index, now);
@@ -81,33 +76,6 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
         at = Math.max(at, arrival);
       }
       arrivals.set(index, at);
-      // EVERY MISSING BLOCK ASKED FOR: the queues holding them say when it
-      // arrives. Each block is reserved to the wire it was asked of, so a faster
-      // peer elsewhere does not bring it sooner, and its bytes are not the
-      // band's to share out (torrent-tv/meta#178 review, WebTorrent 2.8.5
-      // `_request`, torrent.js:1758).
-      if (at !== null) {
-        if (++steps % 256 === 0) {
-          await nextTurn();
-          if (!isCurrent()) return new Map();
-        }
-        continue;
-      }
-      const remaining = piece?.missing;
-      const holders = [];
-      for (const wire of torrent.wires ?? []) {
-        // Only a peer that can be asked for it now: one choking us is asked for
-        // nothing outside the pieces it allows, whatever it carried before.
-        if (wire.destroyed || !wire.peerPieces?.get(index) || !mayAsk(wire, index)) continue;
-        // What it carried with its queue kept full, where it has been seen so:
-        // its speed while our selection gave it little measures our asking
-        // (`SelectionLimit`, torrent-tv/meta#178).
-        const rate = Number(limit?.capacityOf?.(wire) ?? wire.downloadSpeed?.());
-        if (Number.isFinite(rate) && rate > 0) holders.push({ wire, rate });
-      }
-      pending.push({ arrivals, index, ...band, holders, remaining:
-        Number.isSafeInteger(remaining) && remaining > 0 && remaining <= piece.length && holders.length > 0
-          ? remaining : null });
       if (++steps % 256 === 0) {
         await nextTurn();
         if (!isCurrent()) return new Map();
@@ -115,77 +83,5 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
     }
     forecasts.set(torrent, { measuredAt: now, arrivals });
   }
-  // WITHIN A BAND, IN THE ORDER THE PIECES COME. The picker walks each
-  // selection from its first piece up (WebTorrent 2.8.5's default `sequential`
-  // strategy, which this proxy keeps), so a piece of a band arrives once those
-  // before it have. Charged the whole band's end instead, a band of many
-  // segments — the map states one per stretch of a level since 2.97.27 — would
-  // put its nearest piece at its farthest piece's time (torrent-tv/meta#178).
-  //
-  // AND IN PARALLEL WHERE THE PEERS DIFFER. A piece is brought by the peers
-  // holding it, each from when it has brought what was asked of it before, and
-  // no sooner than the measured supply of every peer that holds a piece still
-  // to come carries all the bytes ahead of it. Summed one piece after another
-  // at its own holders' speed, a two-hour film whose far pieces each had a few
-  // unchoked holders was forecast to arrive in 127 838 s at 2.33 MB/s, and a
-  // seek was held for 39 s on it (r49, torrent-tv/meta#178). One holder for
-  // every piece gives the sum it was; a piece nobody can be asked for still
-  // leaves every piece after it unknown.
-  pending.sort((left, right) => compareBands(left, right) || left.index - right.index);
-  const supply = new Map();
-  for (const { holders } of pending) for (const { wire, rate } of holders) supply.set(wire, rate);
-  const total = [...supply.values()].reduce((sum, rate) => sum + rate, 0);
-  const freeAt = new Map();
-  let ahead = 0;
-  let known = true;
-  for (const { arrivals, index, holders, remaining } of pending) {
-    if (!known || remaining === null || !(total > 0)) {
-      known = false;
-      continue;
-    }
-    ahead += remaining;
-    const finish = Math.max(sharedFinish(holders, freeAt, remaining, now), now + ahead / total * 1000);
-    for (const { wire } of holders) freeAt.set(wire, Math.max(freeAt.get(wire) ?? now, finish));
-    arrivals.set(index, finish);
-  }
   return isCurrent() ? forecasts : new Map();
 }
-
-/**
- * When peers bringing `bytes` together finish: each starts when it is free
- * and brings at its own rate, so the finish is where their combined bytes
- * reach `bytes` (the earliest of them working alone at first, more joining as
- * they come free).
- *
- * @param {Array<{ wire: object, rate: number }>} holders - Bytes per second.
- * @param {Map<object, number>} freeAt - Milliseconds.
- * @param {number} bytes
- * @param {number} now - Milliseconds.
- * @returns {number} Milliseconds.
- */
-function sharedFinish(holders, freeAt, bytes, now) {
-  const starts = holders.map(({ wire, rate }) => ({ at: Math.max(now, freeAt.get(wire) ?? now), rate }))
-    .sort((left, right) => left.at - right.at);
-  let rate = 0;
-  let weighted = 0;
-  for (let index = 0; index < starts.length; index++) {
-    rate += starts[index].rate;
-    weighted += starts[index].rate * starts[index].at;
-    const finish = (bytes * 1000 + weighted) / rate;
-    if (index === starts.length - 1 || finish <= starts[index + 1].at) return finish;
-  }
-  return now;
-}
-
-/**
- * Whether this peer can be asked for this piece now: it is not choking us, or
- * it allows this piece while it does (BEP 6, WebTorrent 2.8.5 `_updateWire`).
- *
- * @param {{ peerChoking?: boolean, hasFast?: boolean, peerAllowedFastSet?: number[] }} wire
- * @param {number} index
- * @returns {boolean}
- */
-function mayAsk(wire, index) {
-  if (wire.peerChoking !== true) return true;
-  return wire.hasFast === true && Array.isArray(wire.peerAllowedFastSet) && wire.peerAllowedFastSet.includes(index);
-}

package/services/viewer/playback-readiness.js

@@ -380,7 +380,7 @@ export function predictPlaybackReadiness(input = {}) {
         const arrival = (range.availableAt - now) / 1000;
         // The entire protocol piece becomes readable after verification;
         // bytes inside it never arrive proportionally to their file address.
-        sourceByteService.get(id).push({ start: range.start, end: range.end, begin: arrival, finish: arrival });
+        sourceByteService.get(id).push({ start: range.start, end: range.end, begin: arrival, finish: arrival, planned: true });
       }
     }
   }
@@ -409,6 +409,7 @@ export function predictPlaybackReadiness(input = {}) {
   for (const job of jobs) {
     const { track, trackIndex, segment, sizeBits, encodeWork, sourceByteIntervals } = job;
     let sourceArrivalAt = 0;
+    const plan = { finish: 0 };
     for (const [sourceId, ranges] of sourceByteIntervals) {
       const source = sourceState.get(sourceId);
       if (!source) {
@@ -417,7 +418,7 @@ export function predictPlaybackReadiness(input = {}) {
       for (const interval of ranges) {
         const missing = uncoveredIntervals(interval, sourceByteCoverage.get(sourceId) ?? []);
         if (missing.length === 0) {
-          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId)));
+          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(interval, sourceArrivals.get(sourceId), plan));
           continue;
         }
 
@@ -468,10 +469,13 @@ export function predictPlaybackReadiness(input = {}) {
     }
     const producedAt = job.produced || encodeWork === 0 ? 0 : processing.finish(encodeWork, admittedAt);
     trackFinish[trackIndex] = Math.max(trackFinish[trackIndex], producedAt);
-    productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0 });
+    const sourcePlanned = sourceArrivalAt > 0 && plan.finish >= sourceArrivalAt;
+    productions.push({ at: producedAt, trackIndex, segment, requiresSource: sourceArrivalAt > 0, sourceArrivalAt,
+      sourcePlanned });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));
     transferFinish = deliveryAt;
-    completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment });
+    completions.push({ at: deliveryAt + finiteNonNegative(track.appendSeconds), trackIndex, segment, sourceArrivalAt,
+      sourcePlanned });
   }
 
   const constraints = [];
@@ -479,10 +483,12 @@ export function predictPlaybackReadiness(input = {}) {
   // largest of thousands, and the log could only say that some term was
   // positive while the picture stood for 17 s (torrent-tv/meta#178).
   let holding = null;
-  const constrain = (value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource) => {
+  const constrain = (value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource,
+    sourceArrivalAt = 0, sourcePlanned = false) => {
     constraints.push(value);
     if (value > 0 && (holding === null || value > holding.value)) {
-      holding = { value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource };
+      holding = { value, kind, trackIndex, segment, atSeconds, aheadSeconds, requiresSource, sourceArrivalAt,
+        sourcePlanned };
     }
   };
   const end = rescale(fromSeconds(duration), unit);
@@ -501,7 +507,8 @@ export function predictPlaybackReadiness(input = {}) {
       for (const range of completion.segment.ranges) addMediaRange(delivered, range);
       after = contiguousEnd(delivered, at);
       const ahead = secondsAhead(earliest(before, trackEnd), at);
-      constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false);
+      constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false,
+        completion.sourceArrivalAt, completion.sourcePlanned);
       if (compare(after, before) <= 0 && completion.segment.ranges.some(({ start }) => compare(start, before) > 0)) {
         // A timestamp hole cannot be repaired by waiting longer. Keep it
         // distinct from an unavailable rate or a slow but finite service.
@@ -524,7 +531,7 @@ export function predictPlaybackReadiness(input = {}) {
         : Math.max(0, state.tailEndSeconds - toSeconds(before));
       const ahead = Math.max(0, secondsAhead(before, at) - Math.min(reserve, left) * Number(production.requiresSource));
       constrain(production.at - ahead, "production", trackIndex, production.segment.index, production.at, ahead,
-        production.requiresSource);
+        production.requiresSource, production.sourceArrivalAt, production.sourcePlanned);
     }
   }
   if (trackState.some(({ tail }) => tail.length > 0)) {
@@ -548,7 +555,11 @@ export function predictPlaybackReadiness(input = {}) {
     holdingBy: ready ? null : holding === null ? (originReady ? null : { kind: "position-not-held" })
       : { kind: holding.kind, track: tracks[holding.trackIndex]?.id ?? holding.trackIndex,
         segment: holding.segment, atSeconds: holding.atSeconds, aheadSeconds: holding.aheadSeconds,
-        requiresSource: holding.requiresSource },
+        requiresSource: holding.requiresSource,
+        // When its input's last bytes come, and whether the torrent thread's
+        // queues say so rather than the source's measured service.
+        ...(holding.sourceArrivalAt > 0 ? { sourceArrivalSeconds: holding.sourceArrivalAt,
+          sourcePlanned: holding.sourcePlanned } : {}) },
     preparedUntilSeconds: Math.min(duration, ...trackState.map((state, index) => {
       const ranges = state.clientRanges.map((range) => ({ ...range }));
       for (const item of productions.filter((item) => item.trackIndex === index && item.at <= delay)) {
@@ -600,6 +611,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
     return state;
   };
   const next = trackState.map(() => 0);
+  const plan = { finish: 0 };
   let delivered = transferFinish;
   for (;;) {
     // The next piece in media order across the tracks, as the near window orders them.
@@ -635,6 +647,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
       work = Math.max(0, work);
     }
     let sourceArrivalAt = 0;
+    plan.finish = 0;
     if (work > 0) {
       if (!state.curve) return { reason: "encode-rate-unavailable" };
       const trackSources = Array.isArray(track.sourceIds) ? track.sourceIds : [];
@@ -653,7 +666,7 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
         let order = 0;
         for (const range of ranges) {
           // Bytes the torrent thread planned, or the near window brought, come when they were to come.
-          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(range, sourceArrivals.get(sourceId)));
+          sourceArrivalAt = Math.max(sourceArrivalAt, latestArrival(range, sourceArrivals.get(sourceId), plan));
           const after = missingBefore(bytes, range.end);
           if (after > missingBefore(bytes, range.start)) order = Math.max(order, after);
         }
@@ -703,10 +716,13 @@ function scheduleTail({ trackState, sourceState, sourceByteCoverage, sourceArriv
     // hole stops the media is decided in the near window, in exact time.
     const ahead = Math.max(0, startsAt - position);
     const requiresSource = sourceArrivalAt > 0;
-    constrain(completedAt - ahead, "delivery", trackIndex, segment.index, completedAt, ahead, false);
+    const sourcePlanned = requiresSource && plan.finish >= sourceArrivalAt;
+    constrain(completedAt - ahead, "delivery", trackIndex, segment.index, completedAt, ahead, false, sourceArrivalAt,
+      sourcePlanned);
     const covered = Math.max(0, ahead - Math.min(reserve, Math.max(0, state.tailEndSeconds - startsAt)) *
       Number(requiresSource));
-    constrain(producedAt - covered, "production", trackIndex, segment.index, producedAt, covered, requiresSource);
+    constrain(producedAt - covered, "production", trackIndex, segment.index, producedAt, covered, requiresSource,
+      sourceArrivalAt, sourcePlanned);
   }
 }
 
@@ -1023,7 +1039,16 @@ function indexedArrivals(ranges) {
     .map(range => ({ ...range, maximumEnd: maximumEnd = Math.max(maximumEnd, range.end) }));
 }
 
-function latestArrival(interval, ranges = []) {
+/**
+ * When the last of an interval's bytes arrives, by the arrivals indexed; with
+ * `plan`, the latest of those the torrent thread's queues gave is kept in it.
+ *
+ * @param {{ start: number, end: number }} interval
+ * @param {Array<{ start: number, end: number, finish: number, maximumEnd: number, planned?: boolean }>} [ranges]
+ * @param {{ finish: number } | null} [plan]
+ * @returns {number}
+ */
+function latestArrival(interval, ranges = [], plan = null) {
   let low = 0, high = ranges.length;
   while (low < high) {
     const middle = (low + high) >>> 1;
@@ -1032,7 +1057,10 @@ function latestArrival(interval, ranges = []) {
   }
   let finish = 0;
   for (let index = low; index < ranges.length && ranges[index].start < interval.end; index++) {
-    if (ranges[index].end > interval.start) finish = Math.max(finish, ranges[index].finish);
+    if (ranges[index].end > interval.start) {
+      finish = Math.max(finish, ranges[index].finish);
+      if (plan && ranges[index].planned) plan.finish = Math.max(plan.finish, ranges[index].finish);
+    }
   }
   return finish;
 }