@torrent-tv/proxy 2.107.27 → 2.107.29

package/package.json

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

package/server.js

@@ -1023,7 +1023,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) => {
       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" };
@@ -1043,12 +1043,17 @@ export async function startProxyServer({
       for (const [fileIndex, choices] of selected) {
         const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
         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) => {
+          params.onTimed = (statement, waitedMs, readMs) => {
             timing.reads += 1;
             timing.queuedMs += waitedMs;
             timing.readMs += readMs;
+            const measured = timing.readsByStatement[statement] ??= { queuedMs: 0, readMs: 0 };
+            measured.queuedMs += waitedMs;
+            measured.readMs += readMs;
           };
         }
         const tracks = await containerOrchestrator.inspect(params, "tracks");
@@ -1070,7 +1075,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

@@ -115,10 +115,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) {
     const startedAt = this.#now();
     try {
-      return await this.#resolve(output, from, to, timing, isCurrent);
+      return await this.#resolve(output, from, to, timing, isCurrent, signal);
     } finally {
       timing.resolutions += 1;
       timing.resolveMs += this.#now() - startedAt;
@@ -208,6 +208,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 +234,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 +337,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,6 +407,7 @@ export class EncodeInputs {
   }
 
   #prepare(request) {
+    request.controller ??= new AbortController();
     request.pending = true;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
@@ -413,7 +417,7 @@ export class EncodeInputs {
     // field 2026-10-10, a picture's request took 38 s before its copy began and
     // nothing said on what (torrent-tv/meta#166).
     request.timing ??= { askedAt: this.#now(), attempts: 0, resolutions: 0, resolveMs: 0,
-      reads: 0, queuedMs: 0, readMs: 0, heldMs: 0, budgetMs: 0 };
+      reads: 0, queuedMs: 0, readMs: 0, readsByStatement: {}, heldMs: 0, budgetMs: 0 };
     request.timing.attempts += 1;
     this.#observe(request, "attempt", { request: request.key, attempt: request.timing.attempts });
     request.promise = (async () => {
@@ -421,7 +425,7 @@ 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);
       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;
@@ -742,9 +746,12 @@ function awaitedIn(waiting, arrived) {
  */
 function describeTiming(timing, now) {
   if (!timing) return "";
+  const statements = Object.entries(timing.readsByStatement ?? {}).map(([statement, measured]) =>
+    `${statement} queued ${measured.queuedMs}ms/read ${measured.readMs}ms`).join(", ");
   return `; asked ${Math.max(0, now - timing.askedAt)}ms ago over ${timing.attempts} attempt(s): ` +
     `${timing.resolutions} resolution(s) ${timing.resolveMs}ms ` +
     `(${timing.reads} file read(s): queued ${timing.queuedMs}ms, reading ${timing.readMs}ms), ` +
+    (statements ? `by statement: ${statements}, ` : "") +
     `held ranges ${timing.heldMs}ms, budget ${timing.budgetMs}ms` +
     // Where a packet input's walk spent its read: waiting for the same
     // track's earlier walks, or reading the file (r62, torrent-tv/meta#178).

package/services/media/ContainerOrchestrator.js

@@ -146,7 +146,7 @@ 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;
+    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).
@@ -237,9 +237,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 +253,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 };

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,15 +212,21 @@ export class AsfContainer extends Container {
     const index = await this.readPacketIndex();
     return { times: index.keyframesOf(track.trackNumber), tolerance: 0 };
   }
-  async readPacketIndex(interval) {
-    await this.#readHeader();
+  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(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);
+      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,
-        info: { ...this.#info, durationSeconds: this.#duration }, state: this.#packetState, packetMemory: this.packetMemory });
+      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");
       const bounds = timeline ? index.boundsOf(timeline.trackNumber) : null;
       if (bounds) {
@@ -246,17 +252,21 @@ 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) {
-    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) &&
       (!interval.trackIds?.length || interval.trackIds.includes(track.trackNumber)));
     if (!requested.length) return null;
     const info = { ...this.#info, durationSeconds: this.#duration };
     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);
-      const window = await readAsfWindow({ readRange: this.readRange, data, tracks: this.#tracks, requested, info, first, interval, sentFrom });
+      const first = await this.#packetSentBefore(sentFrom, data, interval.to + WINDOW_LEAD_SECONDS, isCurrent, readRange);
+      if (isCurrent?.() === false) return null;
+      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;
     }
   }
@@ -266,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;
@@ -291,14 +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) {
-    let low = 0, high = data.count, lowSent = await this.#sentAt(0, data), highSent = this.#duration;
+  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, 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);
+      highSent = await this.#sentAt(high, data, 1, isCurrent, readRange);
       if (highSent <= seconds) return high;
     }
     for (const [number, at] of this.#sent) {
@@ -307,12 +319,14 @@ export class AsfContainer extends Container {
       else { high = number; highSent = at; }
     }
     for (let guesses = 0; high - low > 1 && seconds - lowSent > WINDOW_SEARCH_SECONDS; guesses++) {
+      if (isCurrent?.() === false) return null;
       const perSecond = (high - low) / (highSent - lowSent);
       const aim = seconds - WINDOW_SEARCH_SECONDS / 2;
       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));
+      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; }
     }
@@ -323,16 +337,17 @@ 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) {
+  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);
       }
     }
-    return this.#sent.get(number);
+    return isCurrent?.() === false ? null : this.#sent.get(number);
   }
 }

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/asf-packets.js

@@ -20,7 +20,7 @@ export async function readAsfData({ readRange, fileSize, info }) {
 }
 
 /** ASF payload addresses, including fragmented and compressed media objects. */
-export async function readAsfPackets({ readRange, fileSize, tracks, info, firstPicture = false, packetMemory, state = {} }) {
+export async function readAsfPackets({ readRange, fileSize, tracks, info, firstPicture = false, packetMemory, state = {}, isCurrent }) {
   if (!state.initialized) {
   const data = await readAsfData({ readRange, fileSize, info });
   Object.assign(state, { initialized: true, at: data.start, end: data.end, count: data.count, packets: 0,
@@ -30,6 +30,7 @@ export async function readAsfPackets({ readRange, fileSize, tracks, info, firstP
   const { end, count, frames, assembling } = state;
   const declared = new Map(tracks.map(track => [track.trackNumber, track]));
   while (at < end && (!count || packets < count)) {
+    if (isCurrent?.() === false) return null;
     const previousObjects = new Map([...assembling].map(([id, object]) => [id, { ...object, ranges: [...object.ranges] }]));
     const previousLengths = new Map([...frames].map(([id, stream]) => [id, stream.length]));
     try {
@@ -37,6 +38,7 @@ export async function readAsfPackets({ readRange, fileSize, tracks, info, firstP
     packets++;
     state.at = at;
     state.packets = packets;
+    if (isCurrent?.() === false) return null;
     if (firstPicture) {
       const video = tracks.find(track => track.type === "video");
       const stream = video && frames.get(video.trackNumber);
@@ -105,7 +107,7 @@ export async function readAsfPacketTime({ readRange, at, end, info }) {
  * @param {number} params.sentFrom - When packet `first` is sent, as far as the caller knows.
  * @returns {Promise<{ index: PacketIndex, startCovered: boolean }>}
  */
-export async function readAsfWindow({ readRange, data, tracks, requested, info, first, interval, sentFrom }) {
+export async function readAsfWindow({ readRange, data, tracks, requested, info, first, interval, sentFrom, isCurrent }) {
   const declared = new Map(tracks.map(track => [track.trackNumber, track]));
   // Not admitted to IndexMemory: one segment's records, a few hundred, held
   // by the request that asked and dropped with it. Nothing owns a window to
@@ -125,23 +127,30 @@ export async function readAsfWindow({ readRange, data, tracks, requested, info,
   const held = (start, end) => buffer !== null && start >= bufferAt && end < bufferAt + buffer.length;
   const read = (start, end) => held(start, end) ? buffer.subarray(start - bufferAt, end - bufferAt + 1) : readRange(start, end);
   const load = async () => {
+    if (isCurrent?.() === false) return false;
     try {
       buffer = await readRange(at, Math.min(dataEnd - 1, at + WINDOW_PORTION_PACKETS * data.length - 1));
     } catch (error) {
+      if (isCurrent?.() === false) return false;
       if (!isUnavailable(error)) throw error;
       try {
         buffer = await readRange(at, Math.min(dataEnd - 1, at + data.length - 1));
       } catch (missing) {
+        if (isCurrent?.() === false) return false;
         if (!isUnavailable(missing)) throw missing;
         const ahead = Math.ceil(Math.max(0, interval.to + WINDOW_LEAD_SECONDS - sent) * rate);
         throw new BytesUnavailable(at, Math.min(dataEnd - 1, Math.max(at + data.length, at + ahead) - 1), 0);
       }
     }
+    if (isCurrent?.() === false) return false;
     bufferAt = at;
+    return true;
   };
   for (;;) {
+    if (isCurrent?.() === false) return null;
     if (at >= dataEnd) { reachedEnd = true; break; }
-    if (!held(at, Math.min(dataEnd, at + data.length) - 1)) await load();
+    if (!held(at, Math.min(dataEnd, at + data.length) - 1) && !(await load())) return null;
+    if (isCurrent?.() === false) return null;
     ({ next: at, sent } = await readPacket({ readRange: read, at, end: data.end, info, declared, frames, assembling, started }));
     for (const id of ids) {
       const stream = frames.get(id), times = after.get(id);

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) {