@torrent-tv/proxy 2.83.3 → 2.83.4

package/routes/stream/get.js

@@ -208,8 +208,6 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
     return;
   }
 
-  const releaseFile = torrentPool.acquireFile(torrent, fileIndex);
-
   const range = parseRange(req.headers.range, file.length);
   // Prioritize the pieces at this read position so a seek (a request at a new
   // byte offset) downloads first instead of waiting behind the sequential
@@ -343,8 +341,6 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
         logger.warn(line);
       }
       reply.raw.destroy();
-    } finally {
-      releaseFile();
     }
     return;
   }
@@ -355,41 +351,11 @@ export async function handleStreamGet(req, reply, { sourceRegistry, torrentPool,
 
   if (!range) {
     reply.header("Content-Length", String(file.length));
-    const stream = file.createReadStream();
-    bindRelease(stream, reply, releaseFile);
-    return reply.send(stream);
+    return reply.send(file.createReadStream());
   }
 
   reply.code(206);
   reply.header("Content-Length", String(contentLength));
   reply.header("Content-Range", `bytes ${start}-${end}/${file.length}`);
-  const stream = file.createReadStream({ start, end });
-  bindRelease(stream, reply, releaseFile);
-  return reply.send(stream);
-}
-
-/**
- * Attach event listeners that release the file reference exactly once when
- * the stream or the underlying HTTP connection closes.
- *
- * @param {import("node:stream").Readable} stream
- * @param {import("fastify").FastifyReply} reply
- * @param {() => void} release
- * @returns {void}
- */
-function bindRelease(stream, reply, release) {
-  let released = false;
-  const releaseOnce = () => {
-    if (released) {
-      return;
-    }
-    released = true;
-    release();
-  };
-
-  stream.on("close", releaseOnce);
-  stream.on("end", releaseOnce);
-  stream.on("error", releaseOnce);
-  reply.raw.once("close", releaseOnce);
-  reply.raw.once("finish", releaseOnce);
+  return reply.send(file.createReadStream({ start, end }));
 }

package/services/controllers/SubtitleController.js

@@ -51,7 +51,6 @@ export class SubtitleController {
     if (!hasTrack) {
       const name = file.name ?? "";
       const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
-      const release = this.torrentPool.acquireFile(torrent, fileIndex);
       try {
         const bytes = await readFileFully(file, EXTERNAL_MAX_BYTES);
         const text = SubtitleFileContainer.decodeBytes(bytes);
@@ -65,8 +64,6 @@ export class SubtitleController {
         return { vtt, language: TextSubtitleTrack.detectLanguageFromVtt(vtt), headers: {} };
       } catch (e) {
         return { error: `Could not read subtitle file: ${e?.message ?? e}`, status: 502 };
-      } finally {
-        release();
       }
     }
 

package/services/hls-session-manager.js

@@ -1680,12 +1680,7 @@ export class HlsSessionManager {
     // keyframe times and which container they were read from. Present only for
     // a variant of a session cut at the source's keyframes, and it is what
     // makes the two interchangeable.
-    inheritedGrid = null,
-    // Called once for a session that is actually created, and expected to
-    // return a function that lets the source go. It is what keeps the torrent's
-    // data alive for as long as a viewer has a session on it — see
-    // disposeSession.
-    acquireSource = null
+    inheritedGrid = null
   }) {
     if (!this.enabled) {
       const error = new Error("Audio transcoding is disabled on this proxy.");
@@ -2540,40 +2535,6 @@ export class HlsSessionManager {
         lastLoggedAt: 0
       }
     };
-    // Kept so a variant of this session can take its own hold on the same
-    // source: a variant is another encode of the same file and must keep the
-    // torrent's data alive exactly as this one does.
-    session.acquireSource = typeof acquireSource === "function" ? acquireSource : null;
-    if (typeof acquireSource === "function") {
-      // One claim per file this session READS. Almost always that is one file;
-      // a muxed session whose soundtrack ships beside the picture reads two, and
-      // holding only the picture would leave the sound to be swept off the disk
-      // from under a running encoder.
-      const claim = (heldFileIndex) => {
-        try {
-          const release = acquireSource(heldFileIndex);
-          return typeof release === "function" ? release : null;
-        } catch {
-          return null;
-        }
-      };
-      const releases = [claim(undefined)];
-      if (audioInputUrl) {
-        releases.push(claim(audioSource.fileIndex));
-      }
-      const held = releases.filter((release) => typeof release === "function");
-      session.releaseSource = held.length > 0
-        ? () => {
-            for (const release of held) {
-              try {
-                release();
-              } catch {
-                // Best effort — a session must always finish being disposed.
-              }
-            }
-          }
-        : null;
-    }
     // The viewer who asked for this session, so a browser that names itself
     // never has to have requested a segment first for its own soundtrack choice
     // to be known — nor for its own POSITION to be known, which is the same
@@ -7839,8 +7800,7 @@ export class HlsSessionManager {
             // creations (field 2026-08-17, corrections of 0.6-2.9 s).
             published: base.timeline.published
           }
-        : null,
-      acquireSource: base.acquireSource
+        : null
     })
       .then(async (variant) => {
         // Making a session takes seconds — a probe and a keyframe index — and
@@ -8628,15 +8588,7 @@ export class HlsSessionManager {
             boundaries: base.timeline.boundaries,
             published: base.timeline.published
           }
-        : null,
-      // Hold the file this rendition will READ. For a soundtrack shipped beside
-      // the picture that is a different file of the same torrent, and nothing
-      // else claims it: the base holds the picture, and the disk sweep deletes
-      // what nobody is holding — which is how a film being watched was deleted
-      // on 2026-08-06.
-      acquireSource: () => base.acquireSource?.(
-        this.#resolveAudioSource(base.file.sourceKey, base.file.fileIndex, trackIndex).fileIndex
-      )
+        : null
     });
     return rendition ?? null;
   }
@@ -10017,23 +9969,6 @@ export class HlsSessionManager {
       }
     }
 
-    // Let go of the source. While a session exists its torrent must survive
-    // both cleanups the pool runs, and until now neither knew about it: the
-    // only claim on a file is taken by a READ, and during a seek there is no
-    // read at all — the old encoder is dead and the new one has not started.
-    // Field 2026-08-06, that window met the thirty-second disk sweep and the
-    // film being watched was evicted mid-seek, six gigabytes deleted, after
-    // which the new encoder had nothing to read. The session's own thirty
-    // minutes governed the session, never the data under it.
-    if (typeof session.releaseSource === "function") {
-      try {
-        session.releaseSource();
-      } catch {
-        // Best effort — a session must always finish being disposed.
-      }
-      session.releaseSource = null;
-    }
-
     if (session.inputRetryTimer) {
       clearTimeout(session.inputRetryTimer);
       session.inputRetryTimer = null;

package/services/playback-planner.js

@@ -10,7 +10,7 @@ import { spawn } from "node:child_process";
 import { logger } from "../utils/logger.js";
 import { Container } from "./container/Container.js";
 import { buildAudioInventory } from "./audio-inventory.js";
-import { countVideoFiles, matchSidecarFiles } from "./torrent/files.js";
+import { contentsOf } from "./torrent/Contents.js";
 import {
   parseFfmpegDurationSeconds,
   parseFfmpegStartTimeSeconds,
@@ -339,22 +339,18 @@ export function createPlaybackPlanner({
   /**
    * The files beside this picture that belong to it, in three groups.
    *
-   * One call site's worth of arguments, spelled once: the file list, the
-   * torrent's own name (which WebTorrent prefixes to every path) and how many
-   * pictures the torrent holds, which is what decides whether a sidecar with a
-   * name in common with nothing can still belong to the only video there is.
+   * Asked of what the torrent says about itself, which works the grouping out
+   * once and keeps it. It used to be worked out here on every call, and again
+   * on the warm-up's own path over the same list, so one opened film paired the
+   * same files several times and neither side could be sure of the other's
+   * answer.
    *
    * @param {object} torrent
    * @param {number} fileIndex
    * @returns {{ audio: object[], subtitles: object[], images: object[] }}
    */
   function sidecarsOf(torrent, fileIndex) {
-    return matchSidecarFiles({
-      files: torrent?.files ?? [],
-      videoIndex: fileIndex,
-      torrentName: typeof torrent?.name === "string" ? torrent.name : "",
-      videoCount: countVideoFiles(torrent?.files ?? [])
-    });
+    return contentsOf(torrent ?? {}).sidecarsOf(fileIndex);
   }
 
   async function withContainerDefaults(torrent, fileIndex, subtitleTracks) {
@@ -630,7 +626,10 @@ export function createPlaybackPlanner({
       // codecs. A transient empty probe must NOT be cached: otherwise the wrong
       // plan (file treated as directly playable) sticks permanently for this
       // file, and an unsupported codec like xvid gets copied → black video.
-      await torrentPool.prefetchFileEdges(torrent, fileIndex);
+      // Awaited in the literal sense: this answer cannot be given until the
+      // file has said what is in it, and a person is watching a loading screen
+      // for as long as that takes.
+      await torrentPool.prefetchFileEdges(torrent, fileIndex, { awaited: true });
       edgesReadyMs = Date.now() - planEntryMs;
       // The keyframe index reads the tail of the file, which the probe has just
       // waited for as well. Started here it overlaps the probe instead of
@@ -653,7 +652,7 @@ export function createPlaybackPlanner({
       ) {
         attempt += 1;
         await delay(Math.min(3_000, 500 + attempt * 250));
-        await torrentPool.prefetchFileEdges(torrent, fileIndex);
+        await torrentPool.prefetchFileEdges(torrent, fileIndex, { awaited: true });
         probe = await probeStreamCodecs({ ffmpegBin, inputUrl: directUrl, userAgent });
       }
       const { audioCodec, videoCodec, container, durationSeconds, videoWidth, videoHeight, audioTracks, subtitleTracks } = probe;

package/services/priority/PriorityOrchestrator.js

@@ -22,7 +22,13 @@ export class PriorityOrchestrator {
   /** Where the map goes once it is built. @type {(published: object) => void} */
   #publish;
 
-  /** The last map published per film and file, so an unchanged one is not resent. */
+  /**
+   * The last map published per film and file, so an unchanged one is not
+   * resent — and what it was about, so that a file everybody has left can be
+   * published as wanting nothing.
+   *
+   * @type {Map<string, { shape: string, sourceKey: string, fileIndex: number, durationSeconds: number }>}
+   */
   #last = new Map();
 
   /** The last map BUILT per film and file, for whoever reads instead of being
@@ -138,13 +144,33 @@ export class PriorityOrchestrator {
     // second by second, which is the same comparison over far fewer values.
     const zones = runsOf(map);
     const shape = JSON.stringify(zones);
-    if (this.#last.get(key) !== shape) {
-      this.#last.set(key, shape);
+    if (this.#last.get(key)?.shape !== shape) {
+      // The length is remembered with the shape, so that a file whose viewers
+      // have all gone can still be spoken for: what is published then is the
+      // same statement with nothing in it, and it has to name the file it is
+      // about.
+      this.#last.set(key, { shape, sourceKey, fileIndex, durationSeconds });
       this.#publish({ sourceKey, fileIndex, durationSeconds, zones });
     }
     return map;
   }
 
+  /**
+   * NOBODY WANTS ANYTHING OF THIS FILE ANY MORE — said, rather than left to be
+   * inferred from silence.
+   *
+   * The map used to be deleted from this class's memory and published nowhere,
+   * so what had been stated about that file on the swarm's behalf stood until
+   * the torrent itself was removed. Read from the register, a film nobody had
+   * watched for an hour was indistinguishable from one being watched now.
+   *
+   * @param {{ sourceKey: string, fileIndex: number, durationSeconds: number }} what
+   * @returns {void}
+   */
+  #publishNothingFor({ sourceKey, fileIndex, durationSeconds }) {
+    this.#publish({ sourceKey, fileIndex, durationSeconds, zones: [] });
+  }
+
   /**
    * Build and publish the map for every file anybody is watching.
    *
@@ -222,8 +248,12 @@ export class PriorityOrchestrator {
     // for it and called from nowhere.
     for (const key of [...this.#maps.keys()]) {
       if (!byFile.has(key)) {
+        const last = this.#last.get(key);
         this.#maps.delete(key);
         this.#last.delete(key);
+        if (last) {
+          this.#publishNothingFor(last);
+        }
       }
     }
     for (const address of [...this.#byOutput.keys()]) {
@@ -232,9 +262,13 @@ export class PriorityOrchestrator {
       }
     }
     for (const one of byFile.values()) {
-      // A file of unknown length cannot be divided into zones, and a file
-      // nobody is watching has nothing to be urgent about.
-      if (one.durationSeconds > 0 && one.viewers.length > 0) {
+      // A file of unknown length cannot be divided into zones at all. A file
+      // whose viewers have all gone CAN be spoken for, and must be: `build`
+      // with nobody watching produces a map with nothing in it, which is the
+      // truth and is what withdraws what was stated for them. Skipped, as it
+      // was, the last thing said about that file stood for as long as the
+      // torrent did.
+      if (one.durationSeconds > 0) {
         this.build(one);
       }
     }

package/services/torrent/Contents.js

@@ -0,0 +1,324 @@
+/**
+ * @file WHAT IS IN ONE TORRENT — its files, which of them carry a picture, and
+ * which files belong to which picture.
+ *
+ * The torrent's own statement about itself, held instead of recomputed. The
+ * pairing rules already lived beside this file, as functions; what did not
+ * exist was anywhere to keep their answer, so every caller worked it out again
+ * — the warm-up on one path and the playback plan on another, over the same
+ * list, several times per opened film.
+ *
+ * It is a class rather than a set of functions because the fact it holds passes
+ * the test this project uses for that: the composition is born with the file
+ * list, dies with the record of the torrent, and is addressed by one name.
+ *
+ * **What it must NOT hold**, and the boundary is the point:
+ *
+ *  - nothing about a FILM. A poster, a title, a description are answers from a
+ *    third party about an identity, and that identity comes from a file's own
+ *    bytes rather than from the torrent's list of names. They are keyed by the
+ *    picture's file, arrive late or not at all, and must never delay playback;
+ *  - no reference to another layer. Not a container, whose life is a file's and
+ *    which reads bytes; not a priority map, which is built from viewers and
+ *    lives above this; not a viewer. What leaves here is plain values — indices
+ *    into the torrent's own list — and whoever takes them holds nothing of this
+ *    object.
+ *
+ * **What was measured and deliberately NOT built**, so that it is not proposed
+ * again as an oversight: telling a real episode from an extra. Over the 134
+ * torrents of the survey collection, the words that would say so (`sample`,
+ * `trailer`, `extra`, `bonus`, `preview`, `making`) matched four files, and all
+ * four were ordinary titles — "Making cash with her pussy" is an episode, not a
+ * making-of. Size says no more: the ratio of a video to the median of its own
+ * torrent runs continuously from 0.00 to 1.00 with no gap anywhere, because a
+ * collection of short clips is made of short clips. So there is nothing here to
+ * derive a rule from, and a rule invented anyway would decide the order in
+ * which a stranger's bandwidth is spent. Every picture is an item.
+ *
+ * Nothing here reads bytes, waits on the swarm or knows about ffmpeg. Like the
+ * functions it is built on, it is a function of the list of names.
+ */
+
+import {
+  AUDIO_SIDECAR_EXTENSIONS,
+  IMAGE_SIDECAR_EXTENSIONS,
+  SUBTITLE_SIDECAR_EXTENSIONS,
+  VIDEO_FILE_EXTENSIONS,
+  extensionOf,
+  matchSidecarFiles,
+  splitTorrentPath
+} from "./files.js";
+
+/**
+ * One picture of a torrent, with the files that belong to it.
+ *
+ * @typedef {object} TorrentItem
+ * @property {number} fileIndex - Index of the picture in the torrent's own list.
+ * @property {string} name - Its file name, extension included.
+ * @property {string[]} folders - The folders above it, relative to the torrent root.
+ * @property {string} relativePath - Both of those as one path.
+ * @property {number} length - Bytes.
+ * @property {import("./files.js").SidecarFile[]} audio - Soundtracks beside it.
+ * @property {import("./files.js").SidecarFile[]} subtitles - Subtitle files beside it.
+ * @property {import("./files.js").SidecarFile[]} images - Contact sheets and covers.
+ */
+
+/**
+ * One file of a torrent that belongs to no picture.
+ *
+ * @typedef {object} TorrentLeftover
+ * @property {number} fileIndex
+ * @property {string} name
+ * @property {string[]} folders
+ * @property {string} relativePath
+ * @property {number} length
+ */
+
+/**
+ * Files in the order a person reads them: by folder, then by name, with runs of
+ * digits compared as numbers.
+ *
+ * A torrent's own order is whatever the tool that made it chose, and it is
+ * routinely by size — one measured release lists its episodes 08, 06, 07, 01,
+ * 02, 10. Nothing downstream depends on the position: every item carries the
+ * torrent's own index, and that is what a file is opened by.
+ *
+ * `numeric` is what makes 2 come before 10; comparing the strings would put
+ * "10" before "2".
+ *
+ * @param {{ relativePath: string }} left
+ * @param {{ relativePath: string }} right
+ * @returns {number}
+ */
+function inReadingOrder(left, right) {
+  return left.relativePath.localeCompare(right.relativePath, undefined, {
+    numeric: true,
+    sensitivity: "base"
+  });
+}
+
+export class TorrentContents {
+  /** @type {TorrentItem[]} */
+  #items = [];
+
+  /** Which item a file belongs to, as its picture or as one of its parts. @type {Map<number, TorrentItem>} */
+  #itemByFile = new Map();
+
+  /** How many files carry a picture. @type {number} */
+  #videoCount = 0;
+
+  /** @type {TorrentLeftover[]} */
+  #leftovers = [];
+
+  /** Every file as this class reads it, in the torrent's own order. @type {object[]} */
+  #described = [];
+
+  /**
+   * @param {object} params
+   * @param {Array<{ path?: string, name?: string, length?: number }>} params.files -
+   *   The torrent's own list, in its own order.
+   * @param {string} [params.name] - The torrent's name, which WebTorrent
+   *   prefixes to every path in a multi-file torrent.
+   */
+  constructor({ files, name = "" }) {
+    const list = Array.isArray(files) ? files : [];
+    const described = list.map((file, fileIndex) => {
+      const { folders, name: fileName } = splitTorrentPath(file?.path ?? file?.name ?? "", name);
+      return {
+        fileIndex,
+        name: fileName,
+        folders,
+        relativePath: [...folders, fileName].join("/"),
+        length: Number.isFinite(file?.length) ? file.length : 0,
+        isVideo: VIDEO_FILE_EXTENSIONS.has(extensionOf(fileName))
+      };
+    });
+    this.#described = described;
+    this.#videoCount = described.filter((file) => file.isVideo).length;
+
+    const claimed = new Set();
+    for (const file of described.filter((one) => one.isVideo).sort(inReadingOrder)) {
+      const { audio, subtitles, images } = matchSidecarFiles({
+        files: list,
+        videoIndex: file.fileIndex,
+        torrentName: name,
+        videoCount: this.#videoCount
+      });
+      /** @type {TorrentItem} */
+      const item = {
+        fileIndex: file.fileIndex,
+        name: file.name,
+        folders: file.folders,
+        relativePath: file.relativePath,
+        length: file.length,
+        audio,
+        subtitles,
+        images
+      };
+      this.#items.push(item);
+      claimed.add(file.fileIndex);
+      this.#itemByFile.set(file.fileIndex, item);
+      for (const part of [...audio, ...subtitles, ...images]) {
+        claimed.add(part.fileIndex);
+        // A part paired with two pictures is answered for by the first that
+        // took it, which in this order is the earlier episode. Both items keep
+        // it in their own lists, because both genuinely offer it; this map
+        // answers the other question — which picture to fetch it beside — and
+        // there one answer is what stops it being fetched twice.
+        if (!this.#itemByFile.has(part.fileIndex)) {
+          this.#itemByFile.set(part.fileIndex, item);
+        }
+      }
+    }
+
+    this.#leftovers = described
+      .filter((file) => !claimed.has(file.fileIndex))
+      .sort(inReadingOrder)
+      .map((file) => ({
+        fileIndex: file.fileIndex,
+        name: file.name,
+        folders: file.folders,
+        relativePath: file.relativePath,
+        length: file.length
+      }));
+  }
+
+  /**
+   * Every picture of this torrent with what belongs to it, in reading order.
+   *
+   * @returns {TorrentItem[]}
+   */
+  get items() {
+    return this.#items;
+  }
+
+  /**
+   * How many files of this torrent carry a picture.
+   *
+   * @returns {number}
+   */
+  get videoCount() {
+    return this.#videoCount;
+  }
+
+  /**
+   * Files that belong to no picture: the release's own notes, a screenshot pack
+   * matched to nothing, anything a torrent carries beside its films.
+   *
+   * @returns {TorrentLeftover[]}
+   */
+  get leftovers() {
+    return this.#leftovers;
+  }
+
+  /**
+   * WHAT THIS FILE IS, by its name alone.
+   *
+   * The one place the question is answered for the whole product: the browser
+   * used to answer it again, twice — a list of extensions in its torrent parser
+   * and a second, shorter pair inside its picker — and the three had already
+   * diverged.
+   *
+   * @param {number} fileIndex
+   * @returns {"video" | "audio" | "subtitle" | "image" | "other"}
+   */
+  kindOf(fileIndex) {
+    const file = this.#described[fileIndex];
+    if (!file) {
+      return "other";
+    }
+    if (file.isVideo) {
+      return "video";
+    }
+    const extension = extensionOf(file.name);
+    if (AUDIO_SIDECAR_EXTENSIONS.has(extension)) {
+      return "audio";
+    }
+    if (SUBTITLE_SIDECAR_EXTENSIONS.has(extension)) {
+      return "subtitle";
+    }
+    if (IMAGE_SIDECAR_EXTENSIONS.has(extension)) {
+      return "image";
+    }
+    return "other";
+  }
+
+  /**
+   * Every file of the torrent, in the order a person reads them, with what each
+   * one is and where it sits.
+   *
+   * What the browser is given: it shows this list and asks nothing about the
+   * names itself.
+   *
+   * @returns {{ fileIndex: number, name: string, relativePath: string, length: number, kind: string }[]}
+   */
+  files() {
+    return [...this.#described]
+      .sort(inReadingOrder)
+      .map((file) => ({
+        fileIndex: file.fileIndex,
+        name: file.name,
+        relativePath: file.relativePath,
+        length: file.length,
+        kind: this.kindOf(file.fileIndex)
+      }));
+  }
+
+  /**
+   * The item this file belongs to — as its picture, or as one of its parts.
+   *
+   * @param {number} fileIndex
+   * @returns {TorrentItem | null}
+   */
+  itemOf(fileIndex) {
+    return this.#itemByFile.get(fileIndex) ?? null;
+  }
+
+  /**
+   * The files beside one picture that belong to it, in three groups.
+   *
+   * The shape the warm-up and the playback plan each worked out for themselves,
+   * answered from what was decided once, at construction.
+   *
+   * @param {number} fileIndex - The picture's index in the torrent.
+   * @returns {{ audio: import("./files.js").SidecarFile[], subtitles: import("./files.js").SidecarFile[], images: import("./files.js").SidecarFile[] }}
+   */
+  sidecarsOf(fileIndex) {
+    const item = this.#itemByFile.get(fileIndex);
+    if (!item || item.fileIndex !== fileIndex) {
+      return { audio: [], subtitles: [], images: [] };
+    }
+    return { audio: item.audio, subtitles: item.subtitles, images: item.images };
+  }
+}
+
+/** What has been worked out per torrent, and from how many files. @type {WeakMap<object, { contents: TorrentContents, fileCount: number }>} */
+const byTorrent = new WeakMap();
+
+/**
+ * What is in this torrent, worked out once.
+ *
+ * Found from the torrent itself, in the shape the piece store and the demand
+ * register already use, because the same instance is wanted by callers that
+ * have no way to hand it to one another.
+ *
+ * A torrent added from a magnet has no files until its metadata arrives, so the
+ * answer is rebuilt when the list changes size — which it does exactly once,
+ * from nothing to everything.
+ *
+ * @param {{ files?: unknown[], name?: string }} torrent
+ * @returns {TorrentContents}
+ */
+export function contentsOf(torrent) {
+  const files = Array.isArray(torrent?.files) ? torrent.files : [];
+  const held = byTorrent.get(torrent);
+  if (held && held.fileCount === files.length) {
+    return held.contents;
+  }
+  const contents = new TorrentContents({
+    files,
+    name: typeof torrent?.name === "string" ? torrent.name : ""
+  });
+  byTorrent.set(torrent, { contents, fileCount: files.length });
+  return contents;
+}

package/services/torrent/files.js

@@ -135,7 +135,14 @@ export const VIDEO_FILE_EXTENSIONS = new Set([
   ".m2p",
   ".mxf",
   ".rm",
-  ".rmvb"
+  ".rmvb",
+  // A Video CD's MPEG-1 stream. It was offered by the browser and not counted
+  // here, which is the divergence that made this one list rather than two
+  // (measured 2026-09-12, and the only extension the two disagreed on). The
+  // union is the safe way to settle it: a file that is offered and turns out to
+  // be unplayable is one probe, while a file that is a film and is never
+  // offered cannot be reached at all.
+  ".dat"
 ]);
 
 /**