@torrent-tv/proxy 2.95.3 → 2.95.5

package/services/torrent/download/FutureDownload.js

@@ -1,166 +1,114 @@
 import { setImmediate as nextTurn } from "node:timers/promises";
-import { downloadCandidates, dispatchDownloadCandidates, peerCanServe, peerRequestCapacity, copyRequestArrival } from "./DeadlineScheduler.js";
+import { piecesOf } from "../demand/pieces.js";
+import { pieceStoreOf } from "../piece-store-of.js";
+import { compareBands } from "./bands.js";
 
 const BLOCK_BYTES = 16 * 1024;
 
-/** Replay the actual request scheduler against copied protocol state only. */
-export async function futureDownload(entries, { now = Date.now(), findStore, replayOnly = false, isCurrent = () => true } = {}) {
+/** Estimate completion from observed queues and the public selection bands.
+ * The native picker decides the order within a band, so every unqueued piece
+ * uses that band's completion time rather than an invented request order.
+ * Pieces without a measured supplier remain unknown. 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 candidates = downloadCandidates(entries, findStore);
-  const copies = new Map();
-  let clock = now;
-  for (const candidate of candidates) {
-    const source = candidate.torrent;
-    let copy = copies.get(source);
-    if (!copy) {
-      copy = { pieceLength: source.pieceLength, maxWebConns: source.maxWebConns, states: new Map(), wires: [], arrivals: new Map() };
-      copies.set(source, copy);
-      for (const peer of source.wires ?? []) {
-        if (peer.destroyed || (!peer.requests?.length && peer.peerChoking && !peer.hasFast)) continue;
-        const speed = Math.max(0, Number(peer.downloadSpeed?.()) || 0);
-        const available = new Set(candidates.filter(one => one.torrent === source && peer.peerPieces?.get(one.piece)).map(one => one.piece));
-        if (!available.size && !peer.requests?.length) continue;
-        const wire = { type: peer.type, destroyed: peer.destroyed, peerChoking: peer.peerChoking,
-          hasFast: peer.hasFast, peerAllowedFastSet: [...(peer.peerAllowedFastSet ?? [])], peerPieces: { get: piece => available.has(piece) },
-          peerExtendedHandshake: { reqq: peer.peerExtendedHandshake?.reqq }, downloadSpeed: () => speed,
-          requests: (peer.requests ?? []).map(request => copyRequestArrival(request,
-            { piece: request.piece, offset: request.offset, length: request.length, remaining: request.length })) };
-        wire.cancel = (piece, offset, length) => {
-          const index = wire.requests.findIndex(request => request.piece === piece && request.offset === offset && request.length === length);
-          if (index < 0) return;
-          wire.requests.splice(index, 1);
-          const state = copy.states.get(piece);
-          for (let block = offset / BLOCK_BYTES; state && block * BLOCK_BYTES < offset + length; block++) {
-            state.reserved.delete(block);
-            state.cursor = Math.min(state.cursor, block);
-          }
-        };
-        copy.wires.push(wire);
+  const forecasts = new Map();
+  const pending = [];
+  let steps = 0;
+  for (const { torrent, register } of entries) {
+    if (torrent.destroyed || torrent.ready === false) continue;
+    const wanted = new Map();
+    for (const window of register.windows()) {
+      const file = torrent.files?.[window.fileIndex];
+      if (!file) continue;
+      const range = piecesOf({ fileOffset: file.offset, byteStart: window.byteStart,
+        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 });
+        }
+        if (++steps % 256 === 0) {
+          await nextTurn();
+          if (!isCurrent()) return new Map();
+        }
       }
-      copy._request = (wire, piece) => {
-        const state = copy.states.get(piece);
-        if (!state || state.complete) return false;
-        let block = state.cursor;
-        while (block < state.count && (state.present.has(block) || state.reserved.has(block))) block++;
-        if (block === state.count) return false;
-        const offset = block * BLOCK_BYTES;
-        const length = wire.type === "webSeed" ? state.length - offset : Math.min(BLOCK_BYTES, state.length - offset);
-        for (let index = block; index * BLOCK_BYTES < offset + length; index++) state.reserved.add(index);
-        state.cursor = Math.ceil((offset + length) / BLOCK_BYTES);
-        wire.requests.push({ piece, offset, length, remaining: length });
-        return true;
-      };
-    }
-    const piece = source.pieces?.[candidate.piece];
-    if (!piece || !Number.isSafeInteger(piece.length) || piece.length <= 0 ||
-        (piece.missing !== piece.length && !Array.isArray(piece._buffer))) {
-      copy.arrivals.set(candidate.piece, null);
-      continue;
-    }
-    const count = Math.ceil(piece.length / BLOCK_BYTES);
-    const present = new Set();
-    for (let block = 0; block < count; block++) if (piece._buffer?.[block]) present.add(block);
-    const reserved = new Set();
-    for (const wire of copy.wires) for (const request of wire.requests) {
-      if (request.piece !== candidate.piece) continue;
-      for (let block = request.offset / BLOCK_BYTES; block * BLOCK_BYTES < request.offset + request.length; block++) reserved.add(block);
-    }
-    copy.states.set(candidate.piece, { length: piece.length, count, present, reserved, cursor: 0, complete: false });
-  }
-  const ordered = candidates.filter(candidate => copies.get(candidate.torrent).states.has(candidate.piece))
-    .map(candidate => ({ ...candidate, torrent: copies.get(candidate.torrent) }));
-  dispatchDownloadCandidates(ordered, clock);
-  const solved = new Set();
-  if (!replayOnly) for (const copy of copies.values()) {
-    if (copy.wires.length === 1 && !copy.wires[0].destroyed) {
-      finishSinglePeer(copy, ordered.filter(candidate => candidate.torrent === copy), now);
-      solved.add(copy);
     }
-  }
-  const replay = ordered.filter(candidate => !solved.has(candidate.torrent));
-  const pendingCandidates = new Set(replay);
-  const candidateByCopy = new Map();
-  for (const candidate of replay) {
-    let pieces = candidateByCopy.get(candidate.torrent);
-    if (!pieces) candidateByCopy.set(candidate.torrent, pieces = new Map());
-    pieces.set(candidate.piece, candidate);
-  }
-  const wires = [...copies.values()].filter(copy => !solved.has(copy)).flatMap(copy => copy.wires.map(wire => ({ copy, wire })));
-  let steps = 0;
-  while (pendingCandidates.size) {
-    dispatchDownloadCandidates([...pendingCandidates], clock);
-    let next = null, delay = Infinity;
-    for (const entry of wires) {
-      const { wire } = entry;
-      if (!wire.requests.length || !(wire.downloadSpeed() > 0)) continue;
-      const arrivesIn = wire.requests[0].remaining / wire.downloadSpeed() * 1000;
-      if (arrivesIn < delay) { delay = arrivesIn; next = entry; }
+    const queued = new Map();
+    for (const wire of torrent.wires ?? []) {
+      if (wire.destroyed) continue;
+      const speed = Number(wire.downloadSpeed?.());
+      if (!Number.isFinite(speed) || speed <= 0) continue;
+      let bytes = 0;
+      for (const request of wire.requests ?? []) {
+        if (!Number.isSafeInteger(request.length) || request.length <= 0) continue;
+        bytes += request.length;
+        const piece = torrent.pieces?.[request.piece];
+        if (!wanted.has(request.piece) || !piece || !Number.isSafeInteger(request.offset) ||
+            request.offset < 0 || request.offset % BLOCK_BYTES !== 0 ||
+            request.offset + request.length > piece.length ||
+            ((request.offset + request.length) % BLOCK_BYTES !== 0 && request.offset + request.length !== piece.length)) continue;
+        let blocks = queued.get(request.piece);
+        if (!blocks) queued.set(request.piece, blocks = new Map());
+        const at = now + bytes / speed * 1000;
+        for (let block = request.offset / BLOCK_BYTES; block * BLOCK_BYTES < request.offset + request.length; block++) {
+          blocks.set(block, Math.min(blocks.get(block) ?? Infinity, at));
+        }
+      }
     }
-    if (!next || !Number.isFinite(delay)) break;
-    clock += delay;
-    for (const { copy, wire } of wires) {
-      const request = wire.requests[0];
-      if (!request) continue;
-      request.remaining = Math.max(0, request.remaining - delay / 1000 * wire.downloadSpeed());
-      if (wire === next.wire) request.remaining = 0;
-      if (request.remaining > 0) continue;
-      wire.requests.shift();
-      const state = copy.states.get(request.piece);
-      if (!state || state.complete) continue;
-      for (let block = request.offset / BLOCK_BYTES; block * BLOCK_BYTES < request.offset + request.length; block++) {
-        state.present.add(block);
-        state.reserved.delete(block);
+    const store = findStore(torrent);
+    const arrivals = new Map();
+    for (const [index, band] of wanted) {
+      const present = store?.locationOf ? store.locationOf(index) !== "missing" : torrent.bitfield?.get(index);
+      if (present) {
+        arrivals.set(index, now);
+        continue;
       }
-      if (state.present.size === state.count) {
-        state.complete = true;
-        state.present.clear();
-        state.reserved.clear();
-        copy.arrivals.set(request.piece, clock);
-        pendingCandidates.delete(candidateByCopy.get(copy)?.get(request.piece));
+      const piece = torrent.pieces?.[index];
+      let at = now;
+      if (!piece || !Number.isSafeInteger(piece.length) || piece.length <= 0 ||
+          (piece.missing !== piece.length && !Array.isArray(piece._buffer))) at = null;
+      else for (let block = 0; block * BLOCK_BYTES < piece.length; block++) {
+        const length = Math.min(BLOCK_BYTES, piece.length - block * BLOCK_BYTES);
+        if (piece._buffer?.[block]?.length === length) continue;
+        const arrival = queued.get(index)?.get(block);
+        if (!Number.isFinite(arrival)) { at = null; break; }
+        at = Math.max(at, arrival);
+      }
+      arrivals.set(index, at);
+      const remaining = piece?.missing;
+      const speed = (torrent.wires ?? []).reduce((sum, wire) => {
+        if (wire.destroyed || !wire.peerPieces?.get(index)) return sum;
+        const rate = Number(wire.downloadSpeed?.());
+        return Number.isFinite(rate) && rate > 0 ? sum + rate : sum;
+      }, 0);
+      pending.push({ arrivals, index, ...band, seconds:
+        Number.isSafeInteger(remaining) && remaining > 0 && remaining <= piece.length && speed > 0
+          ? remaining / speed : null });
+      if (++steps % 256 === 0) {
+        await nextTurn();
+        if (!isCurrent()) return new Map();
       }
     }
-    if (++steps % 256 === 0) {
-      await nextTurn();
-      if (!isCurrent()) return new Map();
-    }
+    forecasts.set(torrent, { measuredAt: now, arrivals });
   }
-  return new Map([...copies].map(([torrent, copy]) => {
-    for (const piece of copy.states.keys()) if (!copy.arrivals.has(piece)) copy.arrivals.set(piece, null);
-    return [torrent, { measuredAt: now, arrivals: copy.arrivals }];
-  }));
-}
-
-/** With one peer there is no reassignment: its FIFO consumes the common map
- * order. Sum that unchanged order instead of replaying every block arrival. */
-function finishSinglePeer(copy, candidates, now) {
-  const wire = copy.wires[0];
-  const speed = wire.downloadSpeed();
-  if (!(speed > 0) || !(peerRequestCapacity(copy, wire) > 0)) return;
-  let at = now;
-  for (const request of wire.requests) {
-    at += request.length / speed * 1000;
-    const state = copy.states.get(request.piece);
-    if (!state || state.complete) continue;
-    for (let block = request.offset / BLOCK_BYTES; block * BLOCK_BYTES < request.offset + request.length; block++) {
-      state.present.add(block);
-      state.reserved.delete(block);
-    }
-    if (state.present.size === state.count) {
-      state.complete = true;
-      state.present.clear();
-      state.reserved.clear();
-      copy.arrivals.set(request.piece, at);
+  pending.sort(compareBands);
+  let finish = now;
+  for (let start = 0; start < pending.length;) {
+    let end = start;
+    const first = pending[start];
+    while (end < pending.length && compareBands(pending[end], first) === 0) {
+      const seconds = pending[end++].seconds;
+      finish = finish === null || seconds === null ? null : finish + seconds * 1000;
     }
-  }
-  for (const { piece } of candidates) {
-    const state = copy.states.get(piece);
-    if (state.complete || !peerCanServe(wire, piece)) continue;
-    let missing = 0;
-    for (let block = 0; block < state.count; block++) {
-      if (!state.present.has(block)) missing += Math.min(BLOCK_BYTES, state.length - block * BLOCK_BYTES);
+    for (let i = start; i < end; i++) {
+      const { arrivals, index } = pending[i];
+      const queuedAt = arrivals.get(index);
+      if (finish !== null) arrivals.set(index, queuedAt === null ? finish : Math.min(queuedAt, finish));
     }
-    at += missing / speed * 1000;
-    state.complete = true;
-    copy.arrivals.set(piece, at);
+    start = end;
   }
+  return isCurrent() ? forecasts : new Map();
 }

package/services/torrent/download/SwarmSelection.js

@@ -29,6 +29,7 @@ import {
   urgencyName
 } from "../demand/index.js";
 import { pieceStoreOf } from "../piece-store-of.js";
+import { compareBands } from "./bands.js";
 
 export class SwarmSelection {
   #torrent;
@@ -69,23 +70,37 @@ export class SwarmSelection {
    *   shared and the question is not a per-torrent one.
    * @returns {{ stated: number, withdrawn: number }}
    */
-  reconcile() {
-    const levels = [...new Set(this.#register.windows().map(window => window.urgency))];
+  reconcile({ speculativeAllowed = true, maximumUrgency = Infinity, minimumPriority = 1, latestDeadlineAt = Infinity } = {}) {
+    const windows=this.#register.windows();
+    const missing=windows.filter(window=>!this.#isSatisfied(window));
+    const urgency=missing.length?Math.min(...missing.map(window=>window.urgency)):null;
+    const eligible=missing.filter(window=>window.urgency===urgency);
+    const priority=eligible.length?Math.max(...eligible.map(window=>window.priority)):null;
+    const ranked=eligible.filter(window=>window.priority===priority);
+    const deadlineAt=ranked.length?Math.min(...ranked.map(window=>window.deadlineAt)):Infinity;
+    const active=urgency===null||urgency>maximumUrgency||priority<minimumPriority||deadlineAt>latestDeadlineAt||(!speculativeAllowed&&urgency>=Urgency.TAIL)?[]:
+      ranked.filter(window=>window.deadlineAt===deadlineAt);
     /** @type {Map<string, { from: number, to: number, priority: number }>} */
     const wanted = new Map();
-    for (const urgency of levels) {
-      for (const window of this.#register.at(urgency)) {
+    for (const window of active) {
         const range = this.#piecesFor(window);
         if (!range) {
           continue;
         }
         // Merged by range and priority, not by claimant: two readers wanting
         // the same pieces are one instruction to the swarm.
-        const key = `${range.from}-${range.to}-${selectionPriority(urgency)}`;
-        wanted.set(key, { from: range.from, to: range.to, priority: selectionPriority(urgency) });
-      }
+        const key = `${range.from}-${range.to}-${selectionPriority(window.urgency)}`;
+        wanted.set(key, { from: range.from, to: range.to, priority: selectionPriority(window.urgency) });
     }
 
+    // Public selections merge adjacent ranges. Publish their union so an
+    // unchanged map does not repeatedly replace the library's merged range.
+    const ordered=[...wanted.values()].sort((a,b)=>a.from-b.from);
+    wanted.clear();
+    const union=[];
+    for(const range of ordered){const previous=union.at(-1);if(previous&&range.from<=previous.to+1)previous.to=Math.max(previous.to,range.to);else union.push({...range});}
+    for(const range of union)wanted.set(`${range.from}-${range.to}-${range.priority}`,range);
+
     let withdrawn = 0;
     for (const [key, range] of [...this.#stated]) {
       if (wanted.has(key)) {
@@ -111,6 +126,14 @@ export class SwarmSelection {
     }
 
     this.#projectIntoMemory();
+    for (const window of this.#register.at(Urgency.BLOCKED)) {
+      if (this.#isSatisfied(window)) continue;
+      const range = this.#piecesFor(window);
+      if (range) {
+        try { this.#torrent.critical?.(range.from, range.to); }
+        catch { /* A closing torrent cannot accept a critical selection. */ }
+      }
+    }
     return { stated, withdrawn };
   }
 
@@ -177,16 +200,15 @@ export class SwarmSelection {
     return false;
   }
 
-  /**
-   * Permission to take a block from a slow peer, for the level being waited on
-   * and nothing else.
-   *
-   * Cleared before it is set again, because WebTorrent never clears the flag
-   * itself: a reader walking a film would otherwise leave every piece of it
-   * marked, and the mark would mean nothing anywhere.
-   *
-   * @returns {void}
-   */
+  /** The highest missing map band, without choosing protocol blocks. */
+  missingBand() {
+    let band=null;
+    for(const window of this.#register.windows()) {
+      if(this.#isSatisfied(window))continue;
+      if(!band||compareBands(window,band)<0)band={urgency:window.urgency,priority:window.priority,deadlineAt:window.deadlineAt};
+    }
+    return band;
+  }
 
   /**
    * Tell the piece store which bytes will be read soon, from the same stated
@@ -281,8 +303,10 @@ export class SwarmSelection {
     if (!range) {
       return true;
     }
+    const store = this.#findStore(this.#torrent);
     for (let index = range.from; index <= range.to; index += 1) {
-      if (!this.#torrent.bitfield?.get(index)) {
+      const present = store?.locationOf ? store.locationOf(index) !== "missing" : this.#torrent.bitfield?.get(index);
+      if (!present) {
         return false;
       }
     }
@@ -311,15 +335,7 @@ export class SwarmSelection {
    */
   #select({ from, to, priority }) {
     try {
-      // The private form takes the stream flag, which makes a selection several
-      // claimants can hold at the same bounds; the public one merges and
-      // subtracts intervals and cannot express "one of several wants this". The
-      // public call is the fallback if a future version drops the private one.
-      if (typeof this.#torrent._select === "function") {
-        this.#torrent._select(from, to, priority, null, true);
-      } else if (typeof this.#torrent.select === "function") {
-        this.#torrent.select(from, to, priority);
-      }
+      this.#torrent.select?.(from, to, priority);
     } catch {
       // silent-ok: never fail a read because the download set refused.
     }
@@ -331,11 +347,7 @@ export class SwarmSelection {
    */
   #deselect({ from, to }) {
     try {
-      if (typeof this.#torrent._deselect === "function") {
-        this.#torrent._deselect(from, to, true);
-      } else if (typeof this.#torrent.deselect === "function") {
-        this.#torrent.deselect(from, to);
-      }
+      this.#torrent.deselect?.(from, to);
     } catch {
       // silent-ok.
     }
@@ -353,7 +365,7 @@ export class SwarmSelection {
     return (
       `download: ${this.#stated.size} instruction(s) to the swarm from ` +
       `${this.#register.size} stated need(s) [${needs.join(" ")}]` +
-      "; peer requests ordered by deadline and priority"
+      "; peer requests issued by WebTorrent"
     );
   }
 }

package/services/torrent/download/bands.js

@@ -0,0 +1,5 @@
+/** Public selection groups retain both the map's rank and its required time. */
+export function compareBands(left, right) {
+  return left.urgency - right.urgency || right.priority - left.priority ||
+    (left.deadlineAt === right.deadlineAt ? 0 : left.deadlineAt - right.deadlineAt);
+}

package/services/torrent/download/registry.js

@@ -17,14 +17,12 @@
 
 import { DemandRegister } from "../demand/DemandRegister.js";
 import { SwarmSelection } from "./SwarmSelection.js";
-import { DeadlineScheduler } from "./DeadlineScheduler.js";
 import { futureDownload } from "./FutureDownload.js";
 
 /** @type {WeakMap<object, { register: DemandRegister, selection: SwarmSelection }>} */
 const byTorrent = new WeakMap();
 /** @type {Set<{ register: DemandRegister, selection: SwarmSelection }>} */
 const live = new Set();
-const scheduler = new DeadlineScheduler({ entries: () => live });
 let futurePending = null;
 let publishingSelections = false;
 
@@ -56,12 +54,6 @@ export function demandFor(torrent) {
   }
   const register = new DemandRegister();
   const entry = { torrent, register, selection: new SwarmSelection({ torrent, register }), withdrawalRevision: 0 };
-  if (typeof torrent._request === "function" && typeof torrent._updateWire === "function") {
-    entry.previousWireUpdate = torrent._updateWire;
-    torrent._updateWire = wire => {
-      if (!publishingSelections) scheduler.reconcile(Date.now(), { torrent, wire });
-    };
-  }
   byTorrent.set(torrent, entry);
   live.add(entry);
   entry.onBytesChanged = () => reconcileAll();
@@ -106,7 +98,6 @@ export function forgetTorrent(torrent) {
   held.register.clear();
   torrent.removeListener?.("verified", held.onBytesChanged);
   torrent.removeListener?.("piece-withdrawn", held.onWithdrawn);
-  if (held.previousWireUpdate) torrent._updateWire = held.previousWireUpdate;
   byTorrent.delete(torrent);
   live.delete(held);
 }
@@ -125,18 +116,21 @@ export function reconcileAll() {
   if (publishingSelections) return { torrents: live.size, speculativeAllowed: false, stated: 0, withdrawn: 0 };
   const entries = [...live];
   const speculativeAllowed = !entries.some((entry) => entry.selection.hasUrgentMissing());
+  const bands=entries.map(entry=>entry.selection.missingBand()).filter(Boolean);
+  const maximumUrgency=bands.length?Math.min(...bands.map(band=>band.urgency)):Infinity;
+  const minimumPriority=bands.length?Math.max(...bands.filter(band=>band.urgency===maximumUrgency).map(band=>band.priority)):1;
+  const latestDeadlineAt=bands.length?Math.min(...bands.filter(band=>band.urgency===maximumUrgency&&band.priority===minimumPriority).map(band=>band.deadlineAt)):Infinity;
   let stated = 0;
   let withdrawn = 0;
   publishingSelections = true;
   try {
     for (const entry of entries) {
-      const result = entry.selection.reconcile({ speculativeAllowed, deadlineDriven: !!entry.previousWireUpdate });
+      const result = entry.selection.reconcile({ speculativeAllowed, maximumUrgency, minimumPriority, latestDeadlineAt });
       stated += result.stated;
       withdrawn += result.withdrawn;
     }
   } finally {
     publishingSelections = false;
   }
-  scheduler.reconcile();
   return { torrents: entries.length, speculativeAllowed, stated, withdrawn };
 }

package/services/viewer/DownloadMaps.js

@@ -23,7 +23,7 @@ export class DownloadMaps {
       const interval = zone.downloadInterval ?? zone;
       const current = file.sourceZones.find(candidate => candidate.from === interval.from && candidate.to === interval.to);
       const deadlineAt = current && Number.isFinite(current.deadlineAt)
-        ? current.deadlineAt - (zone.leadSeconds ?? 0) * 1000 : current?.deadlineAt;
+        ? current.deadlineAt + (Math.max(0, zone.from - current.from) - (zone.leadSeconds ?? 0)) * 1000 : current?.deadlineAt;
       if (!current || Object.keys(current).some(key => key !== "from" && key !== "to" && !Object.is(zone[key], key === "deadlineAt" ? deadlineAt : current[key]))) changed = true;
       return current ? [{ ...zone, ...current, from: zone.from, to: zone.to, deadlineAt }] : [];
     });

package/services/viewer/NativeSourceMap.js

@@ -1,5 +1,30 @@
 import { mapForViewer, mergeMaps, runsOf } from "./PriorityMap.js";
 
+/** Price original-file cluster ranges without requiring a packet index. */
+export async function nativeOriginalSourceMap({ container, viewers, durationSeconds, startTimeSeconds = 0,
+  allowanceSeconds, urgentReadyFor, now = Date.now() }) {
+  if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) return [];
+  const maps = viewers.map(viewer => mapForViewer({
+    atSeconds: viewer.positionSeconds(now) ?? 0, durationSeconds, allowanceSeconds,
+    playing: viewer.playing || viewer.waiting, viewerCount: viewers.length,
+    pauseSeconds: viewer.pausedAt === null ? 0 : (now - viewer.pausedAt) / 1000,
+    urgentReady: urgentReadyFor(viewer)
+  }));
+  const zones = [];
+  for (const zone of runsOf(mergeMaps(maps))) {
+    const input = await container.readMappedSourceRanges({ from: zone.from + startTimeSeconds,
+      to: Math.min(durationSeconds, zone.to) + startTimeSeconds });
+    if (input.kind !== "result") continue;
+    const links = viewers.filter((_viewer, index) => maps[index].priority[zone.from] === zone.priority)
+      .map(viewer => viewer.linkReading()?.linkMbps).filter(rate => Number.isFinite(rate) && rate > 0);
+    const bytes = input.ranges.reduce((sum, [start, end]) => sum + end - start + 1, 0);
+    const deliverySeconds = links.length ? bytes * 8 / (Math.min(...links) * 1_000_000) : 0;
+    for (const [byteStart, byteEnd] of input.ranges) zones.push({ ...zone, byteStart, byteEnd,
+      deadlineAt: Number.isFinite(zone.withinSeconds) ? now + (zone.withinSeconds - deliverySeconds) * 1000 : Infinity });
+  }
+  return zones;
+}
+
 /** Price native source packets with the same viewer map as encoded outputs. */
 export function nativeSourceMap({ index, tracks, viewers, durationSeconds, startTimeSeconds = 0,
   allowanceSeconds, urgentReadyFor, now = Date.now() }) {

package/services/viewer/PriorityMap.js

@@ -83,6 +83,7 @@
  * @property {number} to - Last second, exclusive.
  * @property {number} priority
  * @property {number} withinSeconds
+ * @property {boolean} urgent - Required preparation before playback can continue.
  * @property {boolean} behind - Whether this lies behind every viewer.
  */