@torrent-tv/proxy 2.107.29 → 2.107.31

package/package.json

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

package/server.js

@@ -917,7 +917,7 @@ export async function startProxyServer({
     reviseBudget: () => { void outputParts.machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
     changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
   });
-  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand }) => {
+  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand, readPriority }) => {
     const record = sourceRegistry.get(sourceKey);
     if (!record) {
       return null;
@@ -932,6 +932,7 @@ export async function startProxyServer({
       fileIndex,
       requestId,
       packetInterval,
+      readPriority,
       packetMemory: indexMemory.forFile(sourceKey, fileIndex),
       downloadInterval: demand ? { from: demand.from, to: demand.to } : null,
       readRange: (start, end) =>
@@ -1023,7 +1024,7 @@ export async function startProxyServer({
     },
     // `timing`, when given, is told how long each read of a file waited behind
     // the reads asked before it and how long it took (torrent-tv/meta#166).
-    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null, signal = null) => {
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null, signal = null, readPriority = null) => {
       const grid = output.timeline?.published ?? output.timeline?.boundaries;
       const from = grid?.[fromIndex], to = grid?.[toIndex + 1];
       if (!Number.isFinite(from) || !(to > from)) return { kind: "terminal", reason: "output-interval-not-declared" };
@@ -1041,7 +1042,7 @@ export async function startProxyServer({
       // reassembled packets otherwise.
       const files = [];
       for (const [fileIndex, choices] of selected) {
-        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
+        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex, readPriority });
         if (!params) return { kind: "needs-source" };
         if (isCurrent) params.isCurrent = isCurrent;
         if (signal) params.signal = signal;

package/services/encode/EncodeInputs.js

@@ -100,7 +100,8 @@ export class EncodeInputs {
     if (request.noted === state) return;
     request.noted = state;
     const serves = request.serves ?? request.from;
-    const rank = this.#rankAt(request.output, serves);
+    const rank = request.readPriority?.serves === serves
+      ? request.readPriority : this.#rankAt(request.output, serves);
     this.#log(`encode input #${request.from}..#${request.to} of ${request.output.outputKey ?? request.output.id}: ${state}` +
       ` (held ${this.held()} of ${this.#allowed} allowed; for #${serves}` +
       `${rank ? `, rank ${rank.rank} of ${rank.topRank}` : ""})${detail}`);
@@ -115,10 +116,10 @@ export class EncodeInputs {
   }
 
   /** The container's statement of an interval, its time added to the request's account. */
-  async #resolveTimed(timing, output, from, to, isCurrent = null, signal = null) {
+  async #resolveTimed(timing, output, from, to, isCurrent = null, signal = null, readPriority = null) {
     const startedAt = this.#now();
     try {
-      return await this.#resolve(output, from, to, timing, isCurrent, signal);
+      return await this.#resolve(output, from, to, timing, isCurrent, signal, readPriority);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -409,6 +410,7 @@ export class EncodeInputs {
   #prepare(request) {
     request.controller ??= new AbortController();
     request.pending = true;
+    request.readPriority = this.#readPriority(request, request.from, request.from);
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
     request.arrivedMeanwhile = null;
@@ -425,7 +427,8 @@ export class EncodeInputs {
       // packet walk, left to run, held the file's reads and the piece the
       // viewer had seeked to waited 16.9 s behind it (r59, torrent-tv/meta#178).
       const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from,
-        () => this.#requests.get(request.key) === request && !request.controller.signal.aborted, request.controller.signal);
+        () => this.#requests.get(request.key) === request && !request.controller.signal.aborted, request.controller.signal,
+        request.readPriority);
       if (resolved.kind === "result") this.#original.set(request.output, resolved.sources?.every(source => source.input.original === true) === true);
       if (this.#requests.get(request.key) !== request) return;
       let result;
@@ -492,6 +495,23 @@ export class EncodeInputs {
     });
   }
 
+  /**
+   * The media reads that prepare one input keep the output map's urgency and
+   * the segment they serve, so a container can run an exact nearby interval
+   * before a speculative attempt to extend that input.
+   *
+   * @param {object} request
+   * @param {number} from
+   * @param {number} to
+   * @returns {{ rank: number, serves: number, from: number, to: number }}
+   */
+  #readPriority(request, from, to) {
+    const serves = request.serves ?? request.from;
+    const rank = this.#rankAt(request.output, serves);
+    return { rank: Number.isFinite(rank?.rank) ? rank.rank : 0, topRank: Number.isFinite(rank?.topRank) ? rank.topRank : 0,
+      serves, from, to };
+  }
+
   /**
    * Whether bytes came during a try that the try may have missed. A try that
    * waits for named bytes is repeated only when some of them came, or when an
@@ -563,7 +583,9 @@ export class EncodeInputs {
       if (!stretches.has(end)) {
         // A longer stretch that cannot be stated is not one to copy; the
         // shorter one already stated still runs.
-        const resolved = await this.#resolveTimed(request.timing, output, from, end).catch(() => null);
+        const current = () => this.#requests.get(request.key) === request && !request.controller.signal.aborted;
+        const resolved = await this.#resolveTimed(request.timing, output, from, end, current, request.controller.signal,
+          this.#readPriority(request, from, end)).catch(() => null);
         stretches.set(end, resolved?.kind === "result" && resolved.sources?.every(source => source.input.original === true)
           ? { sources: resolved.sources, bytes: originalInputBytes(resolved.sources) } : null);
       }

package/services/media/ContainerOrchestrator.js

@@ -32,6 +32,28 @@ import { logger } from "../../utils/logger.js";
  */
 export const CONTAINER_HEAD_BYTES = 256 * 1024;
 
+/** Higher urgency, earlier served time, then the smaller source interval. */
+function compareReadPriority(left, right) {
+  const leftRanked = Number.isFinite(left.readPriority?.rank) && left.readPriority.rank > 0;
+  const rightRanked = Number.isFinite(right.readPriority?.rank) && right.readPriority.rank > 0;
+  if (leftRanked !== rightRanked) return rightRanked - leftRanked;
+  if (!leftRanked) return left.sequence - right.sequence;
+  const leftRank = left.readPriority.rank;
+  const rightRank = right.readPriority.rank;
+  if (leftRank !== rightRank) return rightRank - leftRank;
+  const leftServes = Number.isFinite(left.readPriority?.serves) ? left.readPriority.serves : Number.POSITIVE_INFINITY;
+  const rightServes = Number.isFinite(right.readPriority?.serves) ? right.readPriority.serves : Number.POSITIVE_INFINITY;
+  if (leftServes !== rightServes) return leftServes - rightServes;
+  const leftSpan = Number.isFinite(left.readPriority?.from) && Number.isFinite(left.readPriority?.to)
+    ? Math.max(0, left.readPriority.to - left.readPriority.from) : Number.POSITIVE_INFINITY;
+  const rightSpan = Number.isFinite(right.readPriority?.from) && Number.isFinite(right.readPriority?.to)
+    ? Math.max(0, right.readPriority.to - right.readPriority.from) : Number.POSITIVE_INFINITY;
+  if (leftSpan !== rightSpan) return leftSpan - rightSpan;
+  const leftFrom = Number.isFinite(left.readPriority?.from) ? left.readPriority.from : Number.POSITIVE_INFINITY;
+  const rightFrom = Number.isFinite(right.readPriority?.from) ? right.readPriority.from : Number.POSITIVE_INFINITY;
+  return leftFrom - rightFrom || left.sequence - right.sequence;
+}
+
 /**
  * The size of the file and its OpenSubtitles hash, from the two edges. Nothing
  * partial is kept: an edge that has not arrived is named instead.
@@ -101,6 +123,7 @@ export class ContainerOrchestrator {
   #lifetimes = new Map();
   #activityEpoch = 0;
   #activeReads = 0;
+  #readSequence = 0;
 
   activity() { return { epoch: this.#activityEpoch, active: this.#activeReads > 0 }; }
   constructor() {
@@ -147,9 +170,11 @@ export class ContainerOrchestrator {
     let lifetime = this.#lifetimes.get(key);
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
     const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false && params.signal?.aborted !== true;
-    // Reads of one file run one after another, so an answer can wait for every
-    // read asked before it. Told to whoever asked, apart from the read itself,
-    // because the two call for different remedies (torrent-tv/meta#166).
+    // Reads of one file run one after another, ordered by playback-map urgency
+    // and then by interval size, so speculative extensions cannot sit ahead of
+    // an exact interval the viewer needs. Told to whoever asked, apart from
+    // the read itself, because the two call for different remedies
+    // (torrent-tv/meta#166, #ttv-245).
     // A statement answered from what was already read reads and parses
     // nothing, so it is answered beside the queue and holds nobody up: the
     // picture's first input of an AVI waited about 4 s behind the sound's
@@ -159,9 +184,8 @@ export class ContainerOrchestrator {
     // index. Keep it serial with other chapter reads, but out of the queue used
     // to prepare playback inputs for this file.
     const queueKey = statement === "chapters" ? `${key}:chapters` : key;
-    const previous = aside ? Promise.resolve() : this.#reads.get(queueKey) ?? Promise.resolve();
     const askedAt = performance.now();
-    const reading = previous.catch(() => undefined).then(async () => {
+    const perform = async () => {
       if (!isCurrent()) return { result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } };
       const startedAt = performance.now();
       const revision = params.onReadStart?.(statement);
@@ -171,18 +195,70 @@ export class ContainerOrchestrator {
       params.onObserved?.({ statement, askedAt, startedAt, endedAt, queuedMs: startedAt - askedAt,
         readMs: endedAt - startedAt, cached: aside, result: result.kind, reason: result.reason, ranges: result.ranges });
       return { result, revision };
+    };
+    const reading = aside ? Promise.resolve().then(perform) : this.#queueRead(queueKey, { params, isCurrent, perform });
+    const { result, revision } = await reading;
+    if (!isCurrent()) return { kind: "terminal", reason: "request-obsolete", requestId: params.requestId };
+    if (result.kind === "needs-ranges") params.onNeedsRanges?.(result);
+    if (statement === "tracks" && result.kind === "result") params.onTracks?.(result.value);
+    await params.onReadResult?.(statement, result, revision);
+    return result;
+  }
+
+  /** Run one media read at a time per file, in the map's order of urgency. */
+  #queueRead(key, { params, isCurrent, perform }) {
+    let queue = this.#reads.get(key);
+    if (!queue) this.#reads.set(key, queue = { active: false, pending: [] });
+    return new Promise((resolve, reject) => {
+      const entry = { params, isCurrent, perform, resolve, reject, readPriority: params.readPriority,
+        sequence: this.#readSequence++, started: false, abort: null };
+      const cancel = () => {
+        if (entry.started) return;
+        const index = queue.pending.indexOf(entry);
+        if (index < 0) return;
+        queue.pending.splice(index, 1);
+        params.signal?.removeEventListener("abort", entry.abort);
+        resolve({ result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } });
+        this.#drainReadQueue(key, queue);
+      };
+      entry.abort = cancel;
+      queue.pending.push(entry);
+      queue.pending.sort(compareReadPriority);
+      if (params.signal?.aborted) cancel();
+      else params.signal?.addEventListener("abort", cancel, { once: true });
+      this.#drainReadQueue(key, queue);
     });
-    if (!aside) this.#reads.set(queueKey, reading);
-    try {
-      const { result, revision } = await reading;
-      if (!isCurrent()) return { kind: "terminal", reason: "request-obsolete", requestId: params.requestId };
-      if (result.kind === "needs-ranges") params.onNeedsRanges?.(result);
-      if (statement === "tracks" && result.kind === "result") params.onTracks?.(result.value);
-      await params.onReadResult?.(statement, result, revision);
-      return result;
-    } finally {
-      if (this.#reads.get(queueKey) === reading) this.#reads.delete(queueKey);
+  }
+
+  #drainReadQueue(key, queue) {
+    if (queue.active) return;
+    while (queue.pending.length > 0) {
+      const entry = queue.pending.shift();
+      entry.params.signal?.removeEventListener("abort", entry.abort);
+      if (!entry.isCurrent()) {
+        entry.resolve({ result: { kind: "terminal", reason: "request-obsolete", requestId: entry.params.requestId } });
+        continue;
+      }
+      entry.started = true;
+      queue.active = true;
+      Promise.resolve().then(entry.perform).then(entry.resolve, entry.reject).finally(() => {
+        queue.active = false;
+        if (queue.pending.length === 0 && this.#reads.get(key) === queue) this.#reads.delete(key);
+        else this.#drainReadQueue(key, queue);
+      });
+      return;
+    }
+    if (this.#reads.get(key) === queue) this.#reads.delete(key);
+  }
+
+  #cancelQueuedReads(key) {
+    const queue = this.#reads.get(key);
+    if (!queue) return;
+    for (const entry of queue.pending.splice(0)) {
+      entry.params.signal?.removeEventListener("abort", entry.abort);
+      entry.resolve({ result: { kind: "terminal", reason: "request-obsolete", requestId: entry.params.requestId } });
     }
+    if (this.#reads.get(key) === queue) this.#reads.delete(key);
   }
 
   /** Whether a statement of this file is answered from what was already read: its track table kept here, or the container's word. */
@@ -380,7 +456,8 @@ export class ContainerOrchestrator {
     for (const key of this.#lifetimes.keys()) {
       if (fileIndex === undefined ? key.startsWith(prefix) : key === `${sourceKey}:${fileIndex}`) {
         this.#lifetimes.delete(key);
-        this.#reads.delete(key);
+        this.#cancelQueuedReads(key);
+        this.#cancelQueuedReads(`${key}:chapters`);
       }
     }
     if (fileIndex === undefined) {

package/services/viewer/playback-readiness.js

@@ -157,16 +157,17 @@ export function predictPlaybackReadiness(input = {}) {
   // starts), the read piece nearest before them (what an unread piece is placed
   // by) and read pieces inside what the page reports holding (their frames).
   //
-  // THE NEAR WINDOW AND THE SUFFIX. The look-ahead is scheduled with exact
-  // segment times and source ranges when known. Missing range metadata is priced
-  // from aggregate file density and measured download service without claiming
-  // an address or byte. Beyond the look-ahead, {@link scheduleTail} estimates
-  // remaining source, encoder and delivery work without visiting every segment.
+  // THE NEAR WINDOW. The look-ahead is scheduled with exact segment times and
+  // source ranges when known. Missing range metadata is priced from aggregate
+  // file density and measured download service without claiming an address or
+  // byte. This forecast decides whether playback can start from work near the
+  // viewer; it does not make the first frame wait on an aggregate estimate of
+  // the whole remaining film. Each later poll advances this same window.
   const lookahead = finiteNonNegative(input.lookaheadSeconds);
   const horizonEnd = lookahead > 0 ? finiteNonNegative(input.positionSeconds) + lookahead : Number.POSITIVE_INFINITY;
   const tracks = (Array.isArray(input.tracks) ? input.tracks : []).map((track) =>
-    Array.isArray(track.segments) ? { ...track, segmentCount: track.segmentCount ?? track.segments.length,
-      segments: piecesThatMatter(track, finiteNonNegative(input.positionSeconds), horizonEnd) } : track);
+    Array.isArray(track.segments)
+      ? { ...track, segments: piecesThatMatter(track, finiteNonNegative(input.positionSeconds), horizonEnd) } : track);
   const duration = finiteNonNegative(input.durationSeconds);
   // Each track's served ticks are placed on the clock the page reports by the
   // offset its player applied (`timestampOffset`).
@@ -237,25 +238,11 @@ export function predictPlaybackReadiness(input = {}) {
       .filter((segment) => isPiece(segment) &&
         segment.endSeconds >= position - PLAYER_SEEK_TOLERANCE_SECONDS && segment.startSeconds < horizonEnd)
       .sort((left, right) => left.startSeconds - right.startSeconds || left.index - right.index),
-    // The pieces after the near window, as the playlist cuts them, and the
-    // offset the page's player placed them by.
-    tail: [],
-    tailStartSeconds: horizonEnd,
     durationSeconds: Number.isFinite(track.durationSeconds) ? track.durationSeconds : duration,
-    segmentCount: Number.isSafeInteger(track.segmentCount) ? track.segmentCount
-      : Math.max(0, ...track.segments.map(segment => segment.index + 1)),
     clockSeconds: Number.isFinite(track.clockOffsetSeconds) ? track.clockOffsetSeconds : 0
   }));
   for (const state of trackState) {
-    state.tailEndSeconds = Number.isFinite(horizonEnd) && horizonEnd < duration
-      ? Math.min(duration, state.durationSeconds + state.clockSeconds) : null;
-    const endIndex = state.segments.reduce((last, segment) => segment.startSeconds < horizonEnd
-      ? Math.max(last, segment.index) : last, -1);
-    state.tailSegmentCount = Math.max(0, state.segmentCount - endIndex - 1);
-    const readyTail = [...state.ready].reduce((count, index) => count + Number(index > endIndex), 0);
-    state.tailWorkFraction = state.tailSegmentCount > 0
-      ? Math.max(0, 1 - Math.min(state.tailSegmentCount, readyTail) / state.tailSegmentCount)
-      : 0;
+    state.trackEndSeconds = Math.min(duration, state.durationSeconds + state.clockSeconds);
   }
   if (trackState.some(({ segments }) => segments.length === 0)) {
     return result(false, null, buffered, reserve, null, "timeline-unavailable", 0);
@@ -604,21 +591,12 @@ export function predictPlaybackReadiness(input = {}) {
       // Supply interruption coverage is stock held by the proxy as well as
       // the browser. It is not a browser buffer-size admission rule.
       // The reserve is bounded by what is left of the track, not of the window.
-      const left = state.tailEndSeconds === null ? secondsAhead(trackEnd, before)
-        : Math.max(0, state.tailEndSeconds - toSeconds(before));
+      const left = Math.max(0, state.trackEndSeconds - 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.sourceArrivalAt, production.sourcePlanned);
     }
   }
-  if (trackState.some(({ tailEndSeconds }) => Number.isFinite(tailEndSeconds))) {
-    const stop = scheduleTail({ trackState, sourceState, sourceByteCoverage, runStarts, trackFinish,
-      link, position, buffered, reserve, transferFinish, constrain, duration });
-    if (stop) {
-      return { ...result(false, null, buffered, reserve, null, stop.reason, preparedSegments),
-        ...(stop.unavailableSource ? { unavailableSource: stop.unavailableSource } : {}) };
-    }
-  }
   const firstRequiredStages = trackState.slice(0, requiredTracks).map((state, trackIndex) => {
     const first = state.segments.find(segment => segment.endSeconds > position);
     if (!first) return { track: state.track.id ?? trackIndex, segment: null, alreadyBuffered: true,
@@ -683,93 +661,6 @@ function isPiece(segment) {
     Number.isFinite(segment?.endSeconds) && segment.endSeconds > segment.startSeconds;
 }
 
-/**
- * A duration-level estimate of the suffix after the exact near window. Source
- * work uses each file's aggregate byte density and measured download service;
- * processing uses each track's measured rate; delivery uses output bitrates and
- * measured link service. Held source bytes and made segments reduce the
- * estimate. This conditional forecast does not assert exact source ranges or
- * individual frame timing. Its work is bounded by sources and tracks, not by
- * the film's segment count.
- *
- * @returns {{ reason: string, unavailableSource?: object } | null} Why there is no answer, or null.
- */
-function scheduleTail({ trackState, sourceState, sourceByteCoverage, runStarts, trackFinish, link,
-  position, buffered, reserve, transferFinish, constrain, duration }) {
-  const tailStart = Math.max(position, ...trackState.map(state => state.tailStartSeconds));
-  if (!Number.isFinite(tailStart)) return null;
-  const sourceDurations = new Map();
-  for (const state of trackState) {
-    const seconds = Math.max(0, state.tailEndSeconds - tailStart) * state.tailWorkFraction;
-    if (!(seconds > 0)) continue;
-    for (const sourceId of new Set(state.track.sourceIds ?? [])) {
-      sourceDurations.set(sourceId, Math.max(sourceDurations.get(sourceId) ?? 0, seconds));
-    }
-  }
-
-  let sourceArrivalAt = 0;
-  for (const [sourceId, seconds] of sourceDurations) {
-    const source = sourceState.get(sourceId);
-    if (!source) return { reason: "source-measurement-unavailable" };
-    if (source.source.complete === true) continue;
-    const bytes = estimateUnmappedSourceBytes(source.source, seconds, duration,
-      sourceByteCoverage.get(sourceId));
-    if (bytes === null) return { reason: "source-measurement-unavailable",
-      unavailableSource: { sourceId, phase: "tail" } };
-    if (!(bytes > 0)) continue;
-    const { service } = source;
-    if (!service.rate || !(service.rate.rateAt(0) > 0)) {
-      return { reason: service.rate ? "service-not-advancing" : "download-rate-unavailable",
-        unavailableSource: { sourceId, estimatedBytes: bytes, phase: "tail" } };
-    }
-    service.finish = service.rate.finish(bytes, service.finish);
-    sourceArrivalAt = Math.max(sourceArrivalAt, service.finish);
-    const state = trackState.find(candidate => candidate.track.sourceIds?.includes(sourceId));
-    const index = state?.segments.at(-1)?.index ?? 0;
-    const ahead = Math.max(0, (state?.tailEndSeconds ?? tailStart) - position);
-    constrain(service.finish - Math.max(0, ahead - reserve), "source", trackState.indexOf(state), index,
-      service.finish, ahead, true, service.finish, false);
-  }
-
-  let outputBits = 0;
-  let latestTrackFinish = 0;
-  for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
-    const state = trackState[trackIndex];
-    const end = state.tailEndSeconds;
-    const seconds = Math.max(0, end - tailStart);
-    if (!(seconds > 0)) continue;
-    const track = state.track;
-    const segment = state.segments.at(-1) ?? { index: 0 };
-    const remaining = seconds * state.tailWorkFraction;
-    const work = Math.max(0, remaining - numericCoverage((track.processingRanges ?? [])
-      .filter(range => Number.isFinite(range?.start) && Number.isFinite(range?.end))
-      .map(range => ({ start: Math.max(tailStart, range.start), end: Math.min(end, range.end) }))
-      .filter(range => range.end > range.start)).reduce((sum, range) => sum + range.end - range.start, 0));
-    const processing = state.curve;
-    if (work > 0 && !processing) return { reason: "encode-rate-unavailable" };
-    const run = runStarts[trackIndex];
-    const localStart = tailStart - state.clockSeconds;
-    const inRun = run.spans.some(span => localStart >= span.start && localStart < span.end);
-    const open = work > 0 && !inRun ? run.openSeconds : 0;
-    const finishedAt = work > 0 ? processing.finish(work, trackFinish[trackIndex] + open) : trackFinish[trackIndex];
-    latestTrackFinish = Math.max(latestTrackFinish, finishedAt);
-    const deliveryStart = Math.max(tailStart, position + buffered);
-    outputBits += Math.max(0, state.bitsPerMediaSecond) * Math.max(0, end - deliveryStart);
-    const ahead = Math.max(0, end - position);
-    constrain(finishedAt - Math.max(0, ahead - reserve), "production", trackIndex, segment.index,
-      finishedAt, ahead, sourceArrivalAt > 0, sourceArrivalAt, false);
-  }
-
-  if (outputBits > 0) {
-    const end = Math.max(...trackState.map(state => state.tailEndSeconds));
-    const completedAt = link.finish(outputBits, Math.max(transferFinish, latestTrackFinish));
-    const ahead = Math.max(0, end - position);
-    constrain(completedAt - Math.max(0, ahead - reserve), "delivery", 0,
-      trackState[0]?.segments.at(-1)?.index ?? 0, completedAt, ahead, false, sourceArrivalAt, false);
-  }
-  return null;
-}
-
 /**
  * Seconds from `from` to `to`, or zero when `to` is not later.
  *
@@ -1075,7 +966,7 @@ function numericCoverage(ranges) {
 /**
  * Estimate download work without claiming an address or held byte. The whole
  * file's measured density, reduced by the held fraction, prices unresolved
- * intervals and the aggregate suffix.
+ * intervals in the near window.
  */
 function estimateUnmappedSourceBytes(source, mediaSeconds, durationSeconds, coverage = null) {
   const fileLength = Number(source.fileLength);