@torrent-tv/proxy 2.107.28 → 2.107.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.107.28",
+  "version": "2.107.30",
   "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) => {
+    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,8 +1042,10 @@ 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;
         if (timing) {
           params.walkAccount = timing.walk ??= { lockMs: 0, reads: 0, bytes: 0 };
           params.onTimed = (statement, waitedMs, readMs) => {
@@ -1073,7 +1076,6 @@ export async function startProxyServer({
         if (media.kind !== "result") return media;
         const timeShiftSeconds = Number(media.value?.startTimeSeconds) || 0;
         const sourceInterval = output.timeline.sourceInterval(fromIndex, toIndex, timeShiftSeconds);
-        if (isCurrent) params.isCurrent = isCurrent;
         params.packetInterval = { ...sourceInterval,
           trackIds: wanted.map(track => track.trackNumber),
           modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };

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) {
+  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);
+      return await this.#resolve(output, from, to, timing, isCurrent, signal, readPriority);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -208,6 +209,7 @@ export class EncodeInputs {
         : "withdrawn: no wanted window covers it");
       this.#requests.delete(key);
       this.#wanted.delete(key);
+      request.controller?.abort();
       request.result?.release?.();
     }
     this.#retryMemory();
@@ -233,6 +235,7 @@ export class EncodeInputs {
       this.#note(request, "withdrawn: the plan places no run there");
       this.#requests.delete(key);
       this.#wanted.delete(key);
+      request.controller?.abort();
       // A copy already answered may still be copying its stretch; released,
       // the stretch is dropped when its read returns.
       request.result?.release?.();
@@ -335,6 +338,7 @@ export class EncodeInputs {
       if (request.output !== output) continue;
       this.#requests.delete(key);
       this.#wanted.delete(key);
+      request.controller?.abort();
       request.result?.release?.();
     }
     this.#shared.forget(output);
@@ -404,7 +408,9 @@ 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;
@@ -421,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);
+        () => 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;
@@ -488,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
@@ -559,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() {
@@ -146,10 +169,12 @@ export class ContainerOrchestrator {
     const key = `${params.sourceKey}:${params.fileIndex}`;
     let lifetime = this.#lifetimes.get(key);
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
-    const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false;
-    // 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).
+    const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false && params.signal?.aborted !== true;
+    // 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. */
@@ -237,9 +313,10 @@ export class ContainerOrchestrator {
         value = await container.readSourceRanges(params.packetInterval);
         if (value.kind !== "result") return { ...value, requestId };
       } else if (statement === "packets") {
-        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent, account: params.walkAccount });
+        value = await container.readPacketIndex(params.packetInterval, { isCurrent: params.isCurrent, signal: params.signal, account: params.walkAccount });
         if (value === null) return { kind: "terminal", reason: "request-obsolete", requestId };
-        await value?.prepareAudioDependencies?.(params.packetInterval, container.readRange);
+        const readRange = (start, end) => container.readRange(start, end, { signal: params.signal });
+        await value?.prepareAudioDependencies?.(params.packetInterval, readRange);
       } else if (statement === "chapters") {
         value = await container.readChapters({ read: params.readHeld ?? params.readRange,
           isCurrent: params.isCurrent,
@@ -252,7 +329,7 @@ export class ContainerOrchestrator {
       }
       return { kind: "result", value, requestId };
     } catch (error) {
-      if (statement === "chapters" && params.isCurrent?.() === false) return { kind: "terminal", reason: "request-obsolete", requestId };
+      if (params.isCurrent?.() === false) return { kind: "terminal", reason: "request-obsolete", requestId };
       if (error instanceof ChapterUnsupported) return { kind: "terminal", reason: "chapter-not-supported", chapterReason: error.message, requestId };
       if (error instanceof IndexMemoryUnavailable) {
         const result = { kind: "needs-memory", bytes: error.bytes, requestId };
@@ -379,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/media/container/AsfContainer.js

@@ -42,11 +42,11 @@ export class AsfContainer extends Container {
   }
   static detect(head) { return head.length >= 16 && head.subarray(0, 16).toString("hex") === HEADER; }
 
-  async #readHeader() {
+  async #readHeader(readRange = this.readRange) {
     if (this.#info) return;
     this.#declarations ??= new RetainedReads(this.packetMemory);
     if (!this.#header) {
-      const bytes = await this.readRange(0, 29);
+      const bytes = await readRange(0, 29);
       if (!AsfContainer.detect(bytes) || bytes[28] !== 1 || bytes[29] !== 2) throw new Error("ASF header is invalid.");
       const size = Number(bytes.readBigUInt64LE(16));
       const count = bytes.readUInt32LE(24);
@@ -56,7 +56,7 @@ export class AsfContainer extends Container {
       this.#header = { size, count };
     }
     while (this.#objects.length < this.#header.count) {
-      const head = await this.readRange(this.#offset, this.#offset + 23);
+      const head = await readRange(this.#offset, this.#offset + 23);
       const size = Number(head.readBigUInt64LE(16));
       if (!Number.isSafeInteger(size) || size < 24 || this.#offset + size > this.#header.size) {
         throw new Error("ASF child object exceeds its header.");
@@ -64,7 +64,7 @@ export class AsfContainer extends Container {
       const guid = head.subarray(0, 16).toString("hex");
       if (ENCRYPTION.has(guid)) throw new Error("ASF media is encrypted.");
       const bytes = [FILE, STREAM, EXTENSION, EXTENDED_STREAM, LANGUAGES].includes(guid)
-        ? await this.#declarations.read(this.#offset + 24, this.#offset + size - 1, this.readRange) : null;
+        ? await this.#declarations.read(this.#offset + 24, this.#offset + size - 1, readRange) : null;
       this.#objects.push({ guid, bytes });
       this.#offset += size;
     }
@@ -212,18 +212,19 @@ export class AsfContainer extends Container {
     const index = await this.readPacketIndex();
     return { times: index.keyframesOf(track.trackNumber), tolerance: 0 };
   }
-  async readPacketIndex(interval, { isCurrent } = {}) {
+  async readPacketIndex(interval, { isCurrent, signal } = {}) {
+    const readRange = signal ? (start, end) => this.readRange(start, end, { signal }) : this.readRange;
     if (isCurrent?.() === false) return null;
-    await this.#readHeader();
+    await this.#readHeader(readRange);
     if (isCurrent?.() === false) return null;
     if (!this.#packets && Number.isFinite(interval?.from) && Number.isFinite(interval?.to) && interval.to > interval.from) {
-      const window = await this.#readWindow(interval, isCurrent);
+      const window = await this.#readWindow(interval, isCurrent, readRange);
       if (isCurrent?.() === false) return null;
       if (window) return window;
     }
     if (isCurrent?.() === false) return null;
     if (!this.#packets) {
-      const index = await readAsfPackets({ readRange: this.readRange, fileSize: this.fileSize, tracks: this.#tracks,
+      const index = await readAsfPackets({ readRange, fileSize: this.fileSize, tracks: this.#tracks,
         info: { ...this.#info, durationSeconds: this.#duration }, state: this.#packetState, packetMemory: this.packetMemory, isCurrent });
       if (index === null) return null;
       const timeline = this.#tracks.find(track => track.type === "video") ?? this.#tracks.find(track => track.type === "audio");
@@ -251,8 +252,8 @@ export class AsfContainer extends Container {
    * interval, is read again from twice as far back, and from the first packet
    * at the latest; which it reaches is checked on what it read, not assumed.
    */
-  async #readWindow(interval, isCurrent) {
-    const data = await this.#dataLayout();
+  async #readWindow(interval, isCurrent, readRange = this.readRange) {
+    const data = await this.#dataLayout(readRange);
     if (isCurrent?.() === false) return null;
     if (!data) return null;
     const requested = this.#tracks.filter(track => ["video", "audio"].includes(track.type) &&
@@ -262,9 +263,9 @@ export class AsfContainer extends Container {
     for (let lead = this.#info.prerollSeconds + WINDOW_LEAD_SECONDS; ; lead *= 2) {
       if (isCurrent?.() === false) return null;
       const sentFrom = interval.from - lead;
-      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS, isCurrent);
+      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS, isCurrent, readRange);
       if (isCurrent?.() === false) return null;
-      const window = await readAsfWindow({ readRange: this.readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom, isCurrent });
+      const window = await readAsfWindow({ readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom, isCurrent });
       if (isCurrent?.() === false) return null;
       if (window.startCovered || first === 0) return window.index;
     }
@@ -275,9 +276,9 @@ export class AsfContainer extends Container {
    * the format requires it (the File Properties state one length as both the
    * least and the most), and a packet is then found by its number.
    */
-  async #dataLayout() {
+  async #dataLayout(readRange = this.readRange) {
     if (this.#data === null) {
-      const data = await readAsfData({ readRange: this.readRange, fileSize: this.fileSize, info: this.#info });
+      const data = await readAsfData({ readRange, fileSize: this.fileSize, info: this.#info });
       const length = this.#info.packetLength;
       const fixed = length > 0 && this.#info.minimumPacketLength === length;
       const whole = fixed ? Math.floor((data.end - data.start) / length) : 0;
@@ -300,16 +301,16 @@ export class AsfContainer extends Container {
    * bytes the window from it to `until` is estimated to take, so the swarm is
    * asked for the packet and the window it begins at once.
    */
-  async #packetSentBefore(seconds, data, until, isCurrent) {
+  async #packetSentBefore(seconds, data, until, isCurrent, readRange = this.readRange) {
     if (isCurrent?.() === false) return null;
-    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data, 1, isCurrent), highSent = this.#duration;
+    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data, 1, isCurrent, readRange), highSent = this.#duration;
     if (isCurrent?.() === false) return null;
     if (lowSent > seconds) return 0;
     // Past the last packet nothing is sent before the film ends; the last
     // packet itself is read only when the search needs it.
     if (!(highSent > seconds)) {
       high = data.count - 1;
-      highSent = await this.#sentAt(high, data, 1, isCurrent);
+      highSent = await this.#sentAt(high, data, 1, isCurrent, readRange);
       if (highSent <= seconds) return high;
     }
     for (const [number, at] of this.#sent) {
@@ -324,7 +325,7 @@ export class AsfContainer extends Container {
       const guess = guesses >= 3 || !(perSecond > 0) ? Math.floor((low + high) / 2) : low + Math.floor((aim - lowSent) * perSecond);
       const probe = Math.min(high - 1, Math.max(low + 1, guess));
       const window = perSecond > 0 ? Math.ceil((until - aim) * perSecond) : 1;
-      const at = await this.#sentAt(probe, data, Math.max(1, window), isCurrent);
+      const at = await this.#sentAt(probe, data, Math.max(1, window), isCurrent, readRange);
       if (isCurrent?.() === false) return null;
       if (at <= seconds) { low = probe; lowSent = at; }
       else { high = probe; highSent = at; }
@@ -336,12 +337,12 @@ export class AsfContainer extends Container {
    * When packet `number` is sent. A packet that is not held is said as
    * missing with the `packets` packets from it.
    */
-  async #sentAt(number, data, packets = 1, isCurrent) {
+  async #sentAt(number, data, packets = 1, isCurrent, readRange = this.readRange) {
     if (isCurrent?.() === false) return null;
     if (!this.#sent.has(number)) {
       const at = data.start + number * data.length;
       try {
-        this.#sent.set(number, await readAsfPacketTime({ readRange: this.readRange, at, end: data.end, info: this.#info }));
+        this.#sent.set(number, await readAsfPacketTime({ readRange, at, end: data.end, info: this.#info }));
       } catch (error) {
         if (!isUnavailable(error) || packets <= 1) throw error;
         throw new BytesUnavailable(at, Math.min(data.start + data.count * data.length, at + packets * data.length) - 1, 0);

package/services/media/container/Container.js

@@ -54,7 +54,7 @@ export class Container {
    * the medium — a torrent's piece length. Absent, an element is read in one go.
    *
    * @param {object} params
-   * @param {(start:number,end:number)=>Promise<Buffer|null>} [params.readRange]
+   * @param {(start:number,end:number,options?:{signal?:AbortSignal})=>Promise<Buffer|null>} [params.readRange]
    * @param {number} [params.fileSize]
    * @param {string} [params.label]
    * @param {number} [params.portionBytes]

package/services/media/container/unavailable.js

@@ -56,17 +56,37 @@ export function isUnavailable(error) {
  * the clamped range is a read that did not finish: a stream that ended early,
  * a piece that is not downloaded, a store that could not serve it.
  *
- * @param {(start: number, end: number) => Promise<Buffer | null>} read
+ * @param {(start: number, end: number, options?: { signal?: AbortSignal }) => Promise<Buffer | null>} read
  * @param {number} fileSize
- * @returns {(start: number, end: number) => Promise<Buffer>}
+ * @returns {(start: number, end: number, options?: { signal?: AbortSignal }) => Promise<Buffer>}
  */
 export function strictReader(read, fileSize) {
-  return async (start, end) => {
+  return async (start, end, { signal } = {}) => {
     const last = Math.min(end, fileSize - 1);
     if (!(start >= 0) || last < start) {
       return Buffer.alloc(0);
     }
-    const bytes = await read(start, last);
+    let bytes;
+    if (!signal) {
+      bytes = await read(start, last);
+    } else {
+      const abort = () => {
+        const error = new Error("Read cancelled.");
+        error.name = "AbortError";
+        return error;
+      };
+      if (signal.aborted) throw abort();
+      let onAbort;
+      const cancelled = new Promise((_, reject) => {
+        onAbort = () => reject(abort());
+        signal.addEventListener("abort", onAbort, { once: true });
+      });
+      try {
+        bytes = await Promise.race([read(start, last, { signal }), cancelled]);
+      } finally {
+        signal.removeEventListener("abort", onAbort);
+      }
+    }
     const wanted = last - start + 1;
     const received = bytes ? bytes.length : 0;
     if (received < wanted) {