@torrent-tv/proxy 2.91.0 → 2.92.0

package/services/viewer/SourcePreparation.js

@@ -0,0 +1,278 @@
+/** Source preparation is derived from viewers before any output exists. */
+export class SourcePreparation {
+  #viewers;
+  #candidates;
+  #related;
+  #priorityFor;
+  #inspect;
+  #withdraw;
+  #failed;
+  #reprice;
+  #inputReady;
+  #readyChanged;
+  #work = new Map();
+  #revision = 0;
+  #completedRevision = null;
+  #pending = null;
+  #candidateAbort = new AbortController();
+
+  constructor({ viewers, candidatesFor, relatedFilesFor = () => [], priorityFor = (_viewer, priority) => priority,
+    inputReady = async () => false, readyChanged = () => {}, inspect, withdraw, reprice = () => {}, failed }) {
+    this.#viewers = viewers;
+    this.#candidates = candidatesFor;
+    this.#related = relatedFilesFor;
+    this.#priorityFor = priorityFor;
+    this.#inspect = inspect;
+    this.#withdraw = withdraw;
+    this.#failed = failed;
+    this.#reprice = reprice;
+    this.#inputReady = inputReady;
+    this.#readyChanged = readyChanged;
+  }
+
+  refresh() {
+    this.#revision++;
+    this.#candidateAbort.abort();
+    this.#candidateAbort = new AbortController();
+    for (const [key, work] of this.#work) {
+      const demand = this.demandFor(work);
+      if (demand) { this.#reprice(work, demand); continue; }
+      this.#work.delete(key);
+      this.#withdraw(work);
+    }
+    if (!this.#pending) {
+      let succeeded = false;
+      this.#pending = this.#run().then(() => { succeeded = true; }).catch(error => this.#failed?.(error)).finally(() => {
+        this.#pending = null;
+        if (succeeded && this.#completedRevision !== this.#revision) void this.refresh();
+      });
+    }
+    return this.#pending;
+  }
+
+  /** Current owners determine priority; old work never restores a withdrawn read. */
+  demandFor(work) {
+    if (work.selected && work.statement === "packets" &&
+      work.positions !== this.#positionsFor(work.sourceKey, work.fileIndex, work.ownerId)) return null;
+    if (work.role === "subtitle-embedded" && ["packets", "subtitle-cues"].includes(work.statement) &&
+      work.positions !== this.#positionsFor(work.sourceKey, work.fileIndex, work.ownerId, true)) return null;
+    const owners = this.#viewers.forSource(work.sourceKey).filter(viewer => {
+      if (work.ownerId !== undefined && viewer.id !== work.ownerId) return false;
+      if (work.role === "subtitle-embedded" && (viewer.subtitle?.fileIndex !== work.fileIndex ||
+        viewer.subtitle.trackIndex !== work.trackIndex)) return false;
+      const selected = viewer.source.selectedFileIndex;
+      if (work.ownerFileIndex !== undefined) return selected === work.ownerFileIndex &&
+        (work.role !== "source-rest" || viewer.outputs.size === 0);
+      if (work.statement !== "packets") return selected === null || selected === work.fileIndex;
+      if (selected !== null) return selected === work.fileIndex && viewer.outputs.size === 0 && work.selected;
+      return !work.selected && viewer.source.visibleFileIndices.includes(work.fileIndex);
+    });
+    if (!owners.length) return null;
+    const selected = work.ownerFileIndex === undefined && owners.some(viewer => viewer.source.selectedFileIndex !== null);
+    const base = work.role === "source-rest" ? 1 : work.role === "next-episode" ? 5 : work.ownerFileIndex !== undefined ? 10 : 100;
+    const demands = owners.map(viewer => {
+      const chosenSubtitle = ["subtitle", "subtitle-embedded"].includes(work.role) && viewer.subtitle?.fileIndex === work.fileIndex;
+      const ownBase = chosenSubtitle ? 100 : base;
+      const priority = this.#priorityFor(viewer, ownBase, work);
+      return { priority, urgent: (selected || chosenSubtitle) && priority === ownBase };
+    });
+    const priority = Math.max(...demands.map(demand => demand.priority));
+    const urgent = demands.some(demand => demand.urgent);
+    return { priority,
+      urgent, deadlineAt: urgent ? 0 : Infinity, order: work.order ?? 0 };
+  }
+
+  accepts(work) { return this.#work.get(work.key) === work && this.demandFor(work) !== null; }
+
+  /** A retired torrent cannot retain completed preparation or accept late reads. */
+  forget(sourceKey) {
+    this.#revision++;
+    this.#candidateAbort.abort();
+    this.#candidateAbort = new AbortController();
+    for (const [key, work] of this.#work) {
+      if (work.sourceKey !== sourceKey) continue;
+      this.#work.delete(key);
+      this.#withdraw(work);
+    }
+  }
+
+  urgentReadyFor(viewer) {
+    if (!this.subtitleReadyFor(viewer)) return false;
+    return [...this.#work.values()].some(work => work.selected && work.ownerId === viewer.id &&
+      work.urgentReady === true && viewer.source?.sourceKey === work.sourceKey &&
+      viewer.source.selectedFileIndex === work.fileIndex && viewer.outputs.size === 0 &&
+      work.positions === this.#positionsFor(work.sourceKey, work.fileIndex, viewer.id));
+  }
+
+  subtitleReadyFor(viewer) {
+    const selection = viewer.subtitle;
+    if (!selection) return true;
+    return [...this.#work.values()].some(work => work.sourceKey === selection.sourceKey &&
+      work.fileIndex === selection.fileIndex && ["result", "terminal"].includes(work.result) &&
+      (selection.trackIndex === null ? work.statement === "subtitle-file" && work.ownerFileIndex === viewer.source.selectedFileIndex
+        : work.statement === "subtitle-cues" && work.ownerId === viewer.id && work.trackIndex === selection.trackIndex &&
+          work.positions === this.#positionsFor(work.sourceKey, work.fileIndex, viewer.id, true)));
+  }
+
+  async bytesChanged(sourceKey, fileIndex) {
+    let changed = false;
+    for (const work of this.#work.values()) {
+      if (!work.selected || work.sourceKey !== sourceKey || work.fileIndex !== fileIndex || !work.inputRanges) continue;
+      const revision = work.readinessRevision = (work.readinessRevision ?? 0) + 1;
+      const ready = await this.#inputReady(work);
+      if (revision !== work.readinessRevision || !this.accepts(work)) continue;
+      if (work.urgentReady !== ready) {
+        work.urgentReady = ready;
+        changed = true;
+        this.#readyChanged(work, ready);
+      }
+    }
+    if (changed) for (const work of this.#work.values()) {
+      const demand = this.demandFor(work);
+      if (demand) this.#reprice(work, demand);
+    }
+  }
+
+  ownsFile(sourceKey, fileIndex) {
+    return [...this.#work.values()].some(work => work.sourceKey === sourceKey &&
+      work.fileIndex === fileIndex && this.demandFor(work));
+  }
+
+  #positionsFor(sourceKey, fileIndex, ownerId, includeOutputs = false) {
+    return JSON.stringify(this.#viewers.forSource(sourceKey)
+      .filter(viewer => viewer.source.selectedFileIndex === fileIndex && (includeOutputs || viewer.outputs.size === 0) &&
+        (ownerId === undefined || viewer.id === ownerId))
+      .map(viewer => [viewer.id, viewer.position?.seconds ?? 0]).sort((left, right) => left[0].localeCompare(right[0])));
+  }
+
+  result(work, result) {
+    const current = this.#work.get(work.key);
+    if (current !== work || !this.demandFor(work)) return;
+    current.result = result.kind;
+    if (!["needs-ranges", "needs-memory"].includes(result.kind)) void this.refresh();
+  }
+
+  async #run() {
+    let revision;
+    do {
+      revision = this.#revision;
+      for (const sourceKey of this.#viewers.sourceKeys()) {
+        let candidates;
+        try { candidates = await this.#availableCandidates(sourceKey, this.#candidateAbort.signal); }
+        catch (error) {
+          if (error?.name === "AbortError") break;
+          throw error;
+        }
+        if (revision !== this.#revision) break;
+        const people = this.#viewers.forSource(sourceKey);
+        const selected = people.map(viewer => viewer.source.selectedFileIndex).filter(index => index !== null);
+        const files = [...new Set([...candidates, ...selected])];
+        const related = [...new Set(selected)].flatMap(ownerFileIndex =>
+          this.#related(sourceKey, ownerFileIndex).map(file => ({ ...file, ownerFileIndex })));
+        for (const viewer of people) {
+          if (viewer.subtitle?.trackIndex !== null && viewer.subtitle?.trackIndex !== undefined &&
+            viewer.subtitle.fileIndex === viewer.source.selectedFileIndex) {
+            related.push({ fileIndex: viewer.subtitle.fileIndex, ownerFileIndex: viewer.source.selectedFileIndex,
+              ownerId: viewer.id, trackIndex: viewer.subtitle.trackIndex, role: "subtitle-embedded" });
+          }
+        }
+        for (const [key, work] of this.#work) {
+          if (work.sourceKey === sourceKey && !files.includes(work.fileIndex) &&
+            !related.some(file => file.fileIndex === work.fileIndex && file.ownerFileIndex === work.ownerFileIndex)) {
+            this.#work.delete(key);
+            this.#withdraw(work);
+          }
+        }
+        const metadata = [];
+        for (const [order, fileIndex] of files.entries()) {
+          for (const statement of ["tracks", "media-info"]) {
+            if (revision !== this.#revision) break;
+            const work = this.#request({ sourceKey, fileIndex, statement, order });
+            if (!this.demandFor(work)) continue;
+            metadata.push(work);
+            await this.#read(work);
+          }
+        }
+        if (revision !== this.#revision || metadata.some(work => !["result", "terminal"].includes(work.result))) continue;
+        for (const [order, fileIndex] of files.entries()) {
+          if (revision !== this.#revision) break;
+          const selections = [{ selected: false }, ...people
+            .filter(viewer => viewer.source.selectedFileIndex === fileIndex && viewer.outputs.size === 0)
+            .map(viewer => ({ selected: true, ownerId: viewer.id }))];
+          for (const selection of selections) {
+            const work = this.#request({ sourceKey, fileIndex, statement: "packets", ...selection, order });
+            if (this.demandFor(work)) await this.#read(work);
+          }
+        }
+        for (const [order, file] of related.entries()) {
+          if (revision !== this.#revision) break;
+          if (file.role === "subtitle") {
+            await this.#read(this.#request({ sourceKey, ...file, statement: "subtitle-file", order: files.length + order }));
+            continue;
+          }
+          const declarations = [];
+          for (const statement of ["tracks", "media-info"]) {
+            const work = this.#request({ sourceKey, ...file, statement, order: files.length + order });
+            declarations.push(work);
+            await this.#read(work);
+          }
+          if (declarations.some(work => work.result !== "result")) continue;
+          const packets = this.#request({ sourceKey, ...file, statement: "packets", order: files.length + order });
+          await this.#read(packets);
+          if (file.role === "subtitle-embedded" && packets.result === "result") {
+            await this.#read(this.#request({ sourceKey, ...file, statement: "subtitle-cues", order: files.length + order }));
+          }
+        }
+      }
+    } while (revision !== this.#revision);
+    this.#completedRevision = revision;
+  }
+
+  #request(address) {
+    if (address.selected && address.statement === "packets") {
+      address = { ...address, positions: this.#positionsFor(address.sourceKey, address.fileIndex, address.ownerId) };
+    }
+    if (address.role === "subtitle-embedded" && ["packets", "subtitle-cues"].includes(address.statement)) {
+      address = { ...address, positions: this.#positionsFor(address.sourceKey, address.fileIndex, address.ownerId, true) };
+    }
+    const key = JSON.stringify([address.sourceKey, address.fileIndex, address.statement, address.selected ?? null,
+      address.ownerFileIndex ?? null, address.role ?? null, address.positions ?? null, address.ownerId ?? null, address.trackIndex ?? null]);
+    let work = this.#work.get(key);
+    if (work && work.order !== address.order) {
+      work.order = address.order;
+      const demand = this.demandFor(work);
+      if (demand) this.#reprice(work, demand);
+    }
+    if (!work) {
+      work = { ...address, key, requestId: `prepare:${key}`, result: null };
+      if (this.demandFor(work)) this.#work.set(key, work);
+    }
+    return work;
+  }
+
+  #availableCandidates(sourceKey, signal) {
+    return new Promise((resolve, reject) => {
+      let done = false;
+      const finish = (error, value) => {
+        if (done) return;
+        done = true;
+        signal.removeEventListener("abort", aborted);
+        if (error) reject(error); else resolve(value);
+      };
+      const aborted = () => finish(new DOMException("Source preparation was cancelled.", "AbortError"));
+      signal.addEventListener("abort", aborted, { once: true });
+      if (signal.aborted) { aborted(); return; }
+      Promise.resolve().then(() => {
+        if (signal.aborted) throw new DOMException("Source preparation was cancelled.", "AbortError");
+        return this.#candidates(sourceKey);
+      }).then(value => finish(null, value), error => finish(error));
+    });
+  }
+
+  async #read(work) {
+    if (work.result !== null || !this.demandFor(work)) return;
+    const result = await this.#inspect(work);
+    if (this.#work.get(work.key) === work && this.demandFor(work)) work.result = result.kind;
+    if (work.selected && work.inputRanges) await this.bytesChanged(work.sourceKey, work.fileIndex);
+  }
+}

package/services/viewer/Viewer.js

@@ -192,6 +192,8 @@ export class Viewer {
      * @type {Set<string>}
      */
     this.outputs = new Set();
+    /** Source selection exists before any prepared output. */
+    this.source = null;
     /**
      * Which output answers THIS viewer, and for how long that stands.
      *
@@ -225,6 +227,7 @@ export class Viewer {
      * @type {Set<string>}
      */
     this.wantsCuesFor = new Set();
+    this.subtitle = null;
     // WHETHER THE PICTURE IS MOVING, and separately WHETHER THIS VIEWER IS
     // BLOCKED ON US. Two booleans, because there are three states and one
     // boolean cannot hold them:
@@ -254,6 +257,8 @@ export class Viewer {
     // the instant they arrive, without the position ever being invented.
     this.playing = false;
     this.waiting = true;
+    /** When explicit paused state began; waiting for media is not a pause. */
+    this.pausedAt = null;
     // Whether the page carrying this viewer is ON SCREEN, and whether the
     // picture has been pulled out of it.
     //
@@ -312,6 +317,7 @@ export class Viewer {
       return;
     }
     this.#place(seconds, now);
+    if (this.pausedAt !== null) this.pausedAt = now;
     // The buffer's history belongs to the place they left.
     this.bufferReadings = [];
     // WHAT THEY HELD AT THE PLACE THEY LEFT SAYS NOTHING ABOUT THE PLACE THEY
@@ -475,6 +481,11 @@ export class Viewer {
     // material, which is the direction that costs an encoder rather than a
     // viewer.
     this.waiting = waiting === undefined ? this.playing === false && held === 0 : waiting === true;
+    if (!this.playing && !this.waiting) {
+      if (this.pausedAt === null) this.pausedAt = now;
+    } else {
+      this.pausedAt = null;
+    }
     this.inPictureInPicture = inPictureInPicture === undefined ? false : Boolean(inPictureInPicture);
     this.onScreen = onScreen === undefined ? true : Boolean(onScreen);
     this.seen(now);

package/services/viewer/Viewers.js

@@ -50,6 +50,79 @@ export class Viewers {
     this.#onChange = typeof onChange === "function" ? onChange : () => {};
   }
 
+  /** Register presence before source metadata or an output exists. */
+  present(consumerId, now = Date.now()) {
+    if (typeof consumerId !== "string" || !consumerId) throw new TypeError("A viewer needs a name.");
+    const known = this.#byId.get(consumerId);
+    const viewer = known ?? new Viewer(consumerId, now);
+    viewer.seen(now);
+    viewer.gone = false;
+    this.#byId.set(consumerId, viewer);
+    if (!known) this.#onChange();
+    return viewer;
+  }
+
+  /** Bind the same viewer to their source before metadata preparation. */
+  selectsSource(consumerId, sourceKey, now = Date.now()) {
+    if (typeof sourceKey !== "string" || !sourceKey) throw new TypeError("A selected source needs a key.");
+    const viewer = this.present(consumerId, now);
+    if (viewer.source?.sourceKey !== sourceKey) {
+      viewer.source = { sourceKey, visibleFileIndices: [], selectedFileIndex: null };
+      viewer.subtitle = null;
+      this.#onChange();
+    }
+    return viewer;
+  }
+
+  selectsFile(consumerId, sourceKey, fileIndex, now = Date.now(), selection = {}) {
+    if (!Number.isSafeInteger(fileIndex) || fileIndex < 0) throw new TypeError("A selected file needs its source index.");
+    const viewer = this.selectsSource(consumerId, sourceKey, now);
+    const changed = viewer.source.selectedFileIndex !== fileIndex;
+    if (changed) {
+      viewer.source.selectedFileIndex = fileIndex;
+      viewer.source.generation = 0;
+      viewer.subtitle = null;
+    }
+    if (changed || Number.isFinite(selection.positionSeconds)) viewer.moveTo(selection.positionSeconds ?? 0, now);
+    if (typeof selection.wantsToPlay === "boolean") {
+      viewer.playing = false;
+      viewer.waiting = selection.wantsToPlay;
+      viewer.pausedAt = selection.wantsToPlay ? null : viewer.pausedAt ?? now;
+    }
+    if (changed || Object.keys(selection).length) this.#onChange();
+    return viewer;
+  }
+
+  visibleFiles(consumerId, sourceKey, indices, now = Date.now()) {
+    if (!Array.isArray(indices) || indices.some(index => !Number.isSafeInteger(index) || index < 0)) {
+      throw new TypeError("Visible files need source indices.");
+    }
+    const viewer = this.selectsSource(consumerId, sourceKey, now);
+    const visible = [...new Set(indices)];
+    if (JSON.stringify(viewer.source.visibleFileIndices) !== JSON.stringify(visible)) {
+      viewer.source.visibleFileIndices = visible;
+      this.#onChange();
+    }
+    return viewer;
+  }
+
+  /** Accept a source report only while its original selection is still present. */
+  reportSource(consumerId, sourceKey, fileIndex, report, now = Date.now()) {
+    const viewer = this.get(consumerId);
+    if (!viewer || viewer.gone || viewer.outputs.size !== 0 ||
+        viewer.source?.sourceKey !== sourceKey || viewer.source.selectedFileIndex !== fileIndex) return false;
+    if (report.generation !== undefined) {
+      if (!Number.isSafeInteger(report.generation) || report.generation < (viewer.source.generation ?? 0)) return false;
+      viewer.source.generation = report.generation;
+    }
+    if (report.seek === true && Number.isFinite(report.positionSeconds) && report.positionSeconds >= 0) {
+      viewer.moveTo(report.positionSeconds, now);
+    }
+    viewer.report(report, now);
+    this.#onChange();
+    return true;
+  }
+
   /**
    * This viewer, watching this output.
    *
@@ -106,6 +179,15 @@ export class Viewers {
     return this.#byId.get(consumerId) ?? null;
   }
 
+  sourceKeys() {
+    return new Set([...this.#byId.values()].filter(viewer => viewer.isPresent() && viewer.source)
+      .map(viewer => viewer.source.sourceKey));
+  }
+
+  forSource(sourceKey) {
+    return [...this.#byId.values()].filter(viewer => viewer.isPresent() && viewer.source?.sourceKey === sourceKey);
+  }
+
   /**
    * A viewer of one output, without creating one.
    *
@@ -244,7 +326,7 @@ export class Viewers {
       return false;
     }
     viewer.outputs.delete(output.id);
-    if (viewer.outputs.size === 0) {
+    if (viewer.outputs.size === 0 && !viewer.source) {
       // Watching nothing at all: this is a statement that they are gone, and
       // not merely that this one output is no longer theirs.
       viewer.markGone();
@@ -287,7 +369,7 @@ export class Viewers {
     for (const [consumerId, viewer] of this.#byId) {
       if (!viewer.outputs.delete(outputId)) continue;
       if (viewer.activeVariantId === outputId) viewer.activeVariantId = null;
-      if (viewer.outputs.size === 0) {
+      if (viewer.outputs.size === 0 && !viewer.source) {
         viewer.markGone();
         this.#byId.delete(consumerId);
       }
@@ -334,6 +416,31 @@ export class Viewers {
     return true;
   }
 
+  /** Record the chosen subtitle without creating or restoring a viewer. */
+  selectsSubtitle(consumerId, sourceKey, fileIndex, trackIndex = null) {
+    const viewer = this.get(consumerId);
+    if (!viewer || viewer.gone || viewer.source?.sourceKey !== sourceKey ||
+      !Number.isSafeInteger(fileIndex) || fileIndex < 0 ||
+      (trackIndex !== null && (!Number.isSafeInteger(trackIndex) || trackIndex < 0))) return false;
+    if (trackIndex !== null && viewer.source.selectedFileIndex !== fileIndex) return false;
+    const selection = { sourceKey, fileIndex, trackIndex };
+    if (JSON.stringify(viewer.subtitle) !== JSON.stringify(selection)) {
+      viewer.subtitle = selection;
+      this.#onChange();
+    }
+    return true;
+  }
+
+  clearsSubtitle(consumerId, sourceKey) {
+    const viewer = this.get(consumerId);
+    if (!viewer || viewer.gone || viewer.source?.sourceKey !== sourceKey) return false;
+    if (viewer.subtitle !== null) {
+      viewer.subtitle = null;
+      this.#onChange();
+    }
+    return true;
+  }
+
   /**
    * Who has subtitles switched on for this file.
    *

package/services/viewer/playback-readiness.js

@@ -3,7 +3,7 @@
  * exhausting the continuous media available for the required tracks.
  *
  * This module contains the playback decision's only model. Its inputs are
- * measurements and physical limits: source bytes and download rate, encoded
+ * measurements and physical limits: mapped whole-piece arrivals, encoded
  * media and encoder rate, segment sizes and client-link rate, existing
  * continuous media, and measured supply interruptions. Each service integral
  * extends its latest measured rate until the next observation. The forecast
@@ -99,8 +99,8 @@ export class RateTrend {
  * @param {number} input.lookaheadSeconds
  * @param {number} input.now
  * @param {boolean} [input.requiredAudio]
- * @param {Array<{ id: string, serviceId?: string, complete: boolean, bytesPerMediaSecond: number,
- *   readings: Array<{ at: number, value: number }> }>} input.sources
+ * @param {Array<{ id: string, complete: boolean,
+ *   downloadForecast?: { ranges: Array<{ start: number, end: number, availableAt: number | null }> } }>} input.sources
  * @param {Array<{ id: string, sourceIds: string[], processedSeconds: number,
  *   bitsPerMediaSecond: number, readings: Array<{ at: number, value: number }>,
  *   clockOffsetSeconds?: number, clientRanges?: Array<{ start: number, end: number }>,
@@ -137,10 +137,10 @@ export function predictPlaybackReadiness(input = {}) {
     ]))
   ]);
   const zero = mediaTime(0n, unit);
-  const segmentsOf = tracks.map((track, trackIndex) =>
+  const segmentsOf = tracks.map((track, trackIndex) => predictedMediaSegments(
     (Array.isArray(track.segments) ? track.segments : []).map((segment) => ({
       ...segment, ranges: playerRanges(segment.mediaRanges, rescale(clocks[trackIndex], unit), unit)
-    })));
+    })), unit));
   const origin = latest(zero, ...segmentsOf.map((segments) =>
     segments.find(({ index }) => index === 0)?.ranges?.[0]?.start ?? zero));
   const at = latest(origin, rescale(fromSeconds(finiteNonNegative(input.positionSeconds)), unit));
@@ -182,7 +182,7 @@ export function predictPlaybackReadiness(input = {}) {
     curve: rateCurve(track.readings, now),
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
       new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : [])),
-    segments: predictedMediaSegments(segmentsOf[trackIndex], unit)
+    segments: segmentsOf[trackIndex]
       .filter((segment) => Number.isInteger(segment?.index) &&
         Number.isFinite(segment?.startSeconds) && Number.isFinite(segment?.endSeconds) &&
         segment.endSeconds > segment.startSeconds && segment.endSeconds > position)
@@ -192,19 +192,8 @@ export function predictPlaybackReadiness(input = {}) {
     return result(false, null, buffered, reserve, null, "timeline-unavailable", 0);
   }
   const sourceState = new Map();
-  const downloadServices = new Map();
   for (const [id, source] of sources) {
-    const serviceId = typeof source.serviceId === "string" ? source.serviceId : id;
-    const service = downloadServices.get(serviceId);
-    if (!service || (!service.curve && source.complete !== true)) {
-      downloadServices.set(serviceId, {
-        curve: source.complete === true ? null : rateCurve(source.readings, now)
-      });
-    }
-    sourceState.set(id, {
-      source,
-      serviceId
-    });
+    sourceState.set(id, { source });
   }
   const link = rateCurve(input.linkReadings, now);
   let unknownReason = null;
@@ -246,19 +235,28 @@ export function predictPlaybackReadiness(input = {}) {
           Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.end > range.start));
       const encodeWork = produced ? 0 : remainingProcessing.reduce((sum, part) => sum + part.end - part.start, 0);
 
-      const sourceIntervals = new Map();
+      const sourceByteIntervals = new Map();
       if (!produced && encodeWork > 0) {
-        for (const sourceId of Array.isArray(track.sourceIds) ? new Set(track.sourceIds) : []) {
+        const exactInputs = Array.isArray(segment.sourceInputs) ? segment.sourceInputs : null;
+        const requiredSources = new Set([
+          ...(Array.isArray(track.sourceIds) ? track.sourceIds : []),
+          ...(exactInputs ?? []).map(input => input?.sourceId)
+        ]);
+        for (const sourceId of requiredSources) {
           const source = sourceState.get(sourceId);
           if (!source) {
             unknownReason ??= "source-measurement-unavailable";
           } else if (source.source.complete !== true) {
-            const bytesPerMediaSecond = Number(source.source.bytesPerMediaSecond);
-            if (!(bytesPerMediaSecond > 0)) {
-              unknownReason ??= "download-rate-unavailable";
-            } else {
-              sourceIntervals.set(sourceId, remainingProcessing);
+            if (exactInputs) {
+              const inputs = exactInputs.filter(input => input?.sourceId === sourceId);
+              const ranges = inputs.flatMap(input => Array.isArray(input.ranges) ? input.ranges : []);
+              if (!ranges.length || inputs.some(input => !Array.isArray(input.ranges) || !input.ranges.length) ||
+                  ranges.some(range => !range || !Number.isSafeInteger(range.start) || !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start)) {
+                unknownReason ??= "source-input-ranges-unavailable";
+              } else sourceByteIntervals.set(sourceId, ranges);
+              continue;
             }
+            unknownReason ??= "source-input-ranges-unavailable";
           }
         }
       }
@@ -272,8 +270,7 @@ export function predictPlaybackReadiness(input = {}) {
         ahead: Math.max(0, segment.startSeconds - position),
         sizeBits,
         encodeWork,
-        remainingProcessing,
-        sourceIntervals,
+        sourceByteIntervals,
         produced
       });
     }
@@ -295,17 +292,20 @@ export function predictPlaybackReadiness(input = {}) {
   // scheduled in media order, independently of browser storage capacity.
   // The earliest legal start is the supremum of completion lateness against
   // presentation deadlines, not a search over guessed delay candidates.
-  const sourceFinish = new Map([...downloadServices.keys()].map((id) => [id, 0]));
-  const sourceMediaService = new Map();
+  const sourceByteService = new Map();
   for (const [id, { source }] of sourceState) {
-    const density = Number(source.bytesPerMediaSecond);
-    if (density > 0 && Array.isArray(source.residence)) {
-      // Initial time-to-byte mapping uses measured file-average density.
-      // Held bytes are not downloaded again. Reading costs are already
-      // included in effective processing speed, rather than charged twice.
-      sourceMediaService.set(id, source.residence.filter(({ location, start, end }) =>
-        location !== "missing" && Number.isFinite(start) && Number.isFinite(end) && end > start)
-        .map(({ start, end }) => ({ start: start / density, end: end / density, begin: 0, finish: 0 })));
+    sourceByteService.set(id, Array.isArray(source.residence) ? source.residence
+      .filter(({ location, start, end }) => location !== "missing" && Number.isFinite(start) && Number.isFinite(end) && end > start)
+      .map(({ start, end }) => ({ start, end, begin: 0, finish: 0 })) : []);
+    if (source.downloadForecast) {
+      for (const range of source.downloadForecast.ranges ?? []) {
+        if (!Number.isFinite(range?.availableAt) || !Number.isSafeInteger(range.start) ||
+          !Number.isSafeInteger(range.end) || range.start < 0 || range.end <= range.start) continue;
+        const arrival = Math.max(0, (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 });
+      }
     }
   }
   const trackFinish = trackState.map(({ track }) => finiteNonNegative(track.startupRemainingSeconds));
@@ -313,36 +313,23 @@ export function predictPlaybackReadiness(input = {}) {
   const completions = [];
   const productions = [];
   for (const job of jobs) {
-    const { track, trackIndex, segment, sizeBits, encodeWork, sourceIntervals, remainingProcessing } = job;
+    const { track, trackIndex, segment, sizeBits, encodeWork, sourceByteIntervals } = job;
     const sourceArrivals = [];
-    for (const [sourceId, interval] of [...sourceIntervals].flatMap(([id, ranges]) =>
-      ranges.map((range) => [id, range]))) {
-      const source = sourceState.get(sourceId);
-      const served = sourceMediaService.get(sourceId) ?? [];
-      for (const part of uncoveredIntervals(interval, served)) {
-        const supply = downloadServices.get(source.serviceId)?.curve;
-        if (!supply) return result(false, null, buffered, reserve, null, "download-rate-unavailable", preparedSegments);
-        const begin = sourceFinish.get(source.serviceId) ?? 0;
-        const end = supply.finish(
-          (part.end - part.start) * Number(source.source.bytesPerMediaSecond), begin);
-        sourceFinish.set(source.serviceId, end);
-        served.push({ ...part, begin, finish: end });
+    for (const [sourceId, ranges] of sourceByteIntervals) {
+      const served = sourceByteService.get(sourceId) ?? [];
+      for (const interval of ranges) {
+        if (uncoveredIntervals(interval, served).length) return result(false, null, buffered, reserve, null, "download-schedule-unavailable", preparedSegments);
+        for (const part of served.filter(part => part.end > interval.start && part.start < interval.end)) {
+          sourceArrivals.push({ at: part.finish });
+        }
       }
-      sourceMediaService.set(sourceId, served);
-      sourceArrivals.push(...served.filter((part) => part.end > interval.start && part.start < interval.end)
-        .flatMap((part) => [Math.max(part.start, interval.start), Math.min(part.end, interval.end)]
-          .map((media) => ({ media, at: media === part.start ? part.begin : part.begin +
-            (part.finish - part.begin) * (media - part.start) / (part.end - part.start) }))));
+      sourceByteService.set(sourceId, served);
     }
-    // Max-plus composition of fluid arrival and processing. Between measured
-    // boundaries both are linear, so their supremum occurs at an endpoint.
-    // Reused input keeps its original arrival times; it is neither downloaded
-    // twice nor charged the queue start of a later request.
+    // Production accepts a complete held segment input. It cannot overlap its
+    // own source download; reused input retains its original arrival time.
     const processing = trackState[trackIndex].curve;
-    const producedAt = job.produced || encodeWork === 0 ? 0 : Math.max(
-      processing.finish(encodeWork, trackFinish[trackIndex]),
-      ...sourceArrivals.map(({ media, at }) => processing.finish(
-        remainingProcessing.reduce((sum, part) => sum + Math.max(0, part.end - Math.max(part.start, media)), 0), at)));
+    const admittedAt = Math.max(trackFinish[trackIndex], ...sourceArrivals.map(({ at }) => at));
+    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: sourceArrivals.some(({ at }) => at > 0) });
     const deliveryAt = link.finish(sizeBits, Math.max(transferFinish, producedAt));