@torrent-tv/proxy 2.83.2 → 2.83.4

package/test/torrent-contents.test.js

@@ -0,0 +1,235 @@
+/**
+ * @file What one torrent says is in it: its pictures, what belongs to each, and
+ * the order a person reads them in.
+ *
+ * The fixtures are real releases. `Drifters` ships twelve episodes in the root
+ * with a Russian soundtrack per episode under `Rus Sound/` and a subtitle file
+ * per episode under `Sub/[group]/`; the single-film shape ships one `.mkv` with
+ * a dub whose name has nothing in common with it. Both are the cases the
+ * pairing rules beside this were written against, and this file is about what
+ * is built ON them — the grouping, the order and the leftovers.
+ *
+ * Measured on the survey collection, 2026-09-12, and recorded here because it
+ * is what says the grouping is not an invention: 134 torrents, 44 of them with
+ * more than one picture, 1357 items and 421 files paired to one. Not a single
+ * file was paired to two pictures, and in all 1357 the grouping agreed with the
+ * per-picture call it replaces.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { TorrentContents, contentsOf } from "../services/torrent/Contents.js";
+
+/**
+ * The Drifters torrent, as WebTorrent reports it: every path prefixed with the
+ * torrent's own name, and the episodes in the order the tool that made it chose
+ * — which is not the order anybody reads them in.
+ *
+ * @param {number[]} episodes
+ * @returns {Array<{ path: string, name: string, length: number }>}
+ */
+function driftersFiles(episodes) {
+  const files = [];
+  const push = (relative, length) => {
+    const name = relative.slice(relative.lastIndexOf("/") + 1);
+    files.push({ path: `Drifters/${relative}`, name, length });
+  };
+  for (const episode of episodes) {
+    const stem = `[HorribleSubs] Drifters - ${String(episode).padStart(2, "0")} [1080p]`;
+    push(`Sub/[Stan WarHammer & Nesitach]/${stem}.ass`, 29_000);
+    push(`Rus Sound/${stem}.mka`, 30_000_000);
+    push(`${stem}.mkv`, 566_000_000);
+  }
+  return files;
+}
+
+test("every picture is an item, with its own sound and subtitles on it", () => {
+  const contents = new TorrentContents({ files: driftersFiles([1, 2]), name: "Drifters" });
+
+  assert.equal(contents.videoCount, 2);
+  assert.equal(contents.items.length, 2);
+  const [first, second] = contents.items;
+  assert.match(first.name, / - 01 /);
+  assert.match(second.name, / - 02 /);
+  assert.deepEqual(
+    first.audio.map((file) => file.name),
+    ["[HorribleSubs] Drifters - 01 [1080p].mka"]
+  );
+  assert.deepEqual(
+    first.subtitles.map((file) => file.name),
+    ["[HorribleSubs] Drifters - 01 [1080p].ass"]
+  );
+  // The sound of episode 1 must never appear on the picture of episode 2: the
+  // wrong pairing is silent everywhere downstream.
+  assert.deepEqual(
+    second.audio.map((file) => file.name),
+    ["[HorribleSubs] Drifters - 02 [1080p].mka"]
+  );
+});
+
+test("items come out in the order a person reads them, not the torrent's own", () => {
+  // A real release lists its episodes 08, 06, 07, 01 — the order of whatever
+  // tool made the torrent, routinely by size.
+  const contents = new TorrentContents({ files: driftersFiles([8, 6, 10, 2]), name: "Drifters" });
+
+  assert.deepEqual(
+    contents.items.map((item) => item.name.match(/ - (\d+) /)[1]),
+    ["02", "06", "08", "10"]
+  );
+});
+
+test("runs of digits are compared as numbers, so 2 comes before 10", () => {
+  const files = [
+    { path: "Show/ep10.mkv", name: "ep10.mkv", length: 9 },
+    { path: "Show/ep2.mkv", name: "ep2.mkv", length: 9 }
+  ];
+  const contents = new TorrentContents({ files, name: "Show" });
+
+  assert.deepEqual(
+    contents.items.map((item) => item.name),
+    ["ep2.mkv", "ep10.mkv"]
+  );
+});
+
+test("an item keeps the torrent's own index, whatever order it is read in", () => {
+  const contents = new TorrentContents({ files: driftersFiles([8, 2]), name: "Drifters" });
+
+  // Episode 2 is read first and is the fifth file of the torrent.
+  assert.equal(contents.items[0].fileIndex, 5);
+  assert.equal(contents.items[1].fileIndex, 2);
+});
+
+test("a file is answered for by the item it belongs to, as a picture or as a part", () => {
+  const contents = new TorrentContents({ files: driftersFiles([1]), name: "Drifters" });
+  const [item] = contents.items;
+
+  assert.equal(contents.itemOf(item.fileIndex), item);
+  assert.equal(contents.itemOf(item.audio[0].fileIndex), item);
+  assert.equal(contents.itemOf(item.subtitles[0].fileIndex), item);
+  assert.equal(contents.itemOf(404), null);
+});
+
+test("what belongs beside one picture is answered from what was decided once", () => {
+  const contents = new TorrentContents({ files: driftersFiles([1, 2]), name: "Drifters" });
+  const [first] = contents.items;
+
+  const beside = contents.sidecarsOf(first.fileIndex);
+  assert.deepEqual(beside.audio, first.audio);
+  assert.deepEqual(beside.subtitles, first.subtitles);
+  // Asked about a file that is not a picture, the answer is nothing rather than
+  // the item that file happens to sit in: the question is "what goes beside
+  // this picture", and a soundtrack is not one.
+  assert.deepEqual(contents.sidecarsOf(first.audio[0].fileIndex), {
+    audio: [],
+    subtitles: [],
+    images: []
+  });
+});
+
+test("a torrent with one picture takes the dub whose name has nothing in common", () => {
+  const files = [
+    { path: "Film/Film.2024.1080p.mkv", name: "Film.2024.1080p.mkv", length: 4_000_000_000 },
+    { path: "Film/Rus Sound/dub.mka", name: "dub.mka", length: 30_000_000 }
+  ];
+  const contents = new TorrentContents({ files, name: "Film" });
+
+  assert.equal(contents.items.length, 1);
+  assert.deepEqual(
+    contents.items[0].audio.map((file) => file.name),
+    ["dub.mka"]
+  );
+  assert.deepEqual(contents.leftovers, []);
+});
+
+test("what belongs to no picture is listed as such, and nothing is lost", () => {
+  // `.nfo` is the release's own note and belongs to nothing. A `.txt` would
+  // NOT do here: the pairing layer counts it among the subtitle formats, and a
+  // torrent with one picture takes every sidecar there is.
+  const files = [
+    { path: "Film/Film.mkv", name: "Film.mkv", length: 9 },
+    { path: "Film/release.nfo", name: "release.nfo", length: 1 },
+    { path: "Film/Screens/unrelated.jpg", name: "unrelated.jpg", length: 1 }
+  ];
+  const contents = new TorrentContents({ files, name: "Film" });
+
+  assert.deepEqual(
+    contents.leftovers.map((file) => file.relativePath),
+    ["release.nfo", "Screens/unrelated.jpg"]
+  );
+  const accounted =
+    contents.items.length +
+    contents.items.reduce(
+      (count, item) => count + item.audio.length + item.subtitles.length + item.images.length,
+      0
+    ) +
+    contents.leftovers.length;
+  assert.equal(accounted, files.length);
+});
+
+test("a torrent whose metadata has not arrived says it holds nothing", () => {
+  const contents = new TorrentContents({ files: [], name: "" });
+
+  assert.deepEqual(contents.items, []);
+  assert.deepEqual(contents.leftovers, []);
+  assert.equal(contents.videoCount, 0);
+  assert.equal(contents.itemOf(0), null);
+});
+
+test("the answer is worked out once per torrent, and again when its files arrive", () => {
+  const torrent = { name: "Drifters", files: [] };
+
+  const empty = contentsOf(torrent);
+  assert.equal(contentsOf(torrent), empty, "asking twice must not work it out twice");
+
+  // A magnet has no files until its metadata lands, which happens exactly once.
+  torrent.files = driftersFiles([1]);
+  const full = contentsOf(torrent);
+  assert.notEqual(full, empty);
+  assert.equal(full.items.length, 1);
+  assert.equal(contentsOf(torrent), full);
+});
+
+test("folders order before names, so seasons stay together", () => {
+  const files = [
+    { path: "Show/Season 2/ep 1.mkv", length: 9 },
+    { path: "Show/Season 10/ep 1.mkv", length: 9 },
+    { path: "Show/Season 1/ep 2.mkv", length: 9 },
+    { path: "Show/Season 1/ep 1.mkv", length: 9 }
+  ];
+  const contents = new TorrentContents({ files, name: "Show" });
+
+  assert.deepEqual(
+    contents.items.map((item) => item.relativePath),
+    ["Season 1/ep 1.mkv", "Season 1/ep 2.mkv", "Season 2/ep 1.mkv", "Season 10/ep 1.mkv"]
+  );
+});
+
+test("every file is described by what it is, in the order a person reads them", () => {
+  // What the browser is given. It used to answer this itself — a list of video
+  // extensions in its parser and a second, shorter pair inside its picker —
+  // against this one, and the three had already diverged.
+  const files = [
+    { path: "Film/notes.nfo", length: 1 },
+    { path: "Film/cover.jpg", length: 2 },
+    { path: "Film/film.mkv", length: 9 },
+    { path: "Film/Rus Sound/dub.mka", length: 3 },
+    { path: "Film/Sub/film.ass", length: 1 }
+  ];
+  const contents = new TorrentContents({ files, name: "Film" });
+
+  assert.deepEqual(
+    contents.files().map((file) => [file.relativePath, file.kind]),
+    [
+      ["cover.jpg", "image"],
+      ["film.mkv", "video"],
+      ["notes.nfo", "other"],
+      ["Rus Sound/dub.mka", "audio"],
+      ["Sub/film.ass", "subtitle"]
+    ]
+  );
+  assert.deepEqual(
+    contents.files().map((file) => file.fileIndex),
+    [1, 2, 0, 3, 4],
+    "the torrent's own numbers travel with them"
+  );
+});

package/test/upload-hurry.test.js

@@ -18,6 +18,40 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { decideUploadLimit, torrentsForUploadPolicy } from "../services/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/download/registry.js";
+import { Urgency } from "../services/demand/index.js";
+
+/**
+ * A torrent whose metadata has arrived and which nothing is wanted of.
+ *
+ * The files matter: a torrent with no list of files cannot be stated about at
+ * all, and is wanted for that reason alone — it is still being fetched.
+ *
+ * @param {string} name
+ * @returns {object}
+ */
+function quiet(name) {
+  return { name, files: [{ offset: 0, length: 1_000, name }] };
+}
+
+/**
+ * The same, with something stated for it — which is what "somebody wants this"
+ * means now that nothing counts readers.
+ *
+ * @param {string} name
+ * @returns {object}
+ */
+function wanted(name) {
+  const torrent = quiet(name);
+  demandFor(torrent).register.state({
+    claimant: "priority-map:0:0",
+    fileIndex: 0,
+    byteStart: 0,
+    byteEnd: 999,
+    urgency: Urgency.NEAR
+  });
+  return torrent;
+}
 
 const NOW = 1_000_000;
 const healthy = (extra = {}) => ({
@@ -65,34 +99,38 @@ test("the reciprocity boost still works when no hurry is on", () => {
   assert.match(decision.reason, /earn unchoke/);
 });
 
-test("a torrent with no reader still reaches the policy while it is in a hurry", () => {
+test("a torrent nothing is wanted of still reaches the policy while it is in a hurry", () => {
   // The moment that matters: a torrent has just been added and its head and
-  // tail are being fetched for the codec probe. That read goes straight to
-  // `createReadStream`, so no reader is registered — and the selection only
-  // ever kept torrents that had one, which is where the gap was.
-  const hurrying = { name: "film.mkv", hurryUntil: NOW + 20_000 };
-  const idle = { name: "other.mkv" };
-  const usage = new Map();
-
-  assert.deepEqual(
-    torrentsForUploadPolicy([hurrying, idle], usage, NOW),
-    [hurrying],
-    "a torrent with no reader yet was ignored"
-  );
+  // tail are being fetched for the codec probe. Nothing is stated for it yet,
+  // and the selection only ever kept torrents something was — which is where
+  // the gap was.
+  const hurrying = quiet("film.mkv");
+  hurrying.hurryUntil = NOW + 20_000;
+  const idle = quiet("other.mkv");
+  const watched = wanted("watched.mkv");
+  try {
+    assert.deepEqual(
+      torrentsForUploadPolicy([hurrying, idle], NOW),
+      [hurrying],
+      "a torrent nothing is stated for yet was ignored"
+    );
 
-  assert.deepEqual(
-    torrentsForUploadPolicy([{ ...hurrying, hurryUntil: NOW - 1 }, idle], usage, NOW),
-    [],
-    "and stops counting once the rush is over"
-  );
+    assert.deepEqual(
+      torrentsForUploadPolicy([{ ...hurrying, hurryUntil: NOW - 1 }, idle], NOW),
+      [],
+      "and stops counting once the rush is over"
+    );
 
-  const read = { name: "watched.mkv" };
-  usage.set(read, new Set([0]));
-  assert.deepEqual(
-    torrentsForUploadPolicy([read], usage, NOW),
-    [read],
-    "a torrent being read still counts, hurry or not"
-  );
+    assert.deepEqual(
+      torrentsForUploadPolicy([watched], NOW),
+      [watched],
+      "a torrent somebody wants something of still counts, hurry or not"
+    );
+  } finally {
+    forgetTorrent(hurrying);
+    forgetTorrent(idle);
+    forgetTorrent(watched);
+  }
 });
 
 test("a torrent nobody is reading is not treated as starving", () => {
@@ -102,7 +140,7 @@ test("a torrent nobody is reading is not treated as starving", () => {
   // minutes, every one of them reported as `earn unchoke ... down=0KB/s`.
   const idleButChoked = {
     name: "film.mkv",
-    hasActiveReader: false,
+    isWanted: false,
     wires: [
       { amInterested: true, peerChoking: true },
       { amInterested: true, peerChoking: true }
@@ -112,7 +150,7 @@ test("a torrent nobody is reading is not treated as starving", () => {
   };
   assert.equal(decideUploadLimit([idleButChoked], { now: NOW }).bytesPerSec, 50 * 1024);
 
-  const waiting = { ...idleButChoked, hasActiveReader: true };
+  const waiting = { ...idleButChoked, isWanted: true };
   assert.equal(
     decideUploadLimit([waiting], { now: NOW }).bytesPerSec,
     512 * 1024,
@@ -128,7 +166,7 @@ test("a torrent short of nothing is not worth uploading for", () => {
   // buying while somebody is still short of bytes.
   const complete = {
     name: "watched to the end",
-    hasActiveReader: true,
+    isWanted: true,
     hasUnmetDemand: false,
     done: false,
     downloadSpeed: 0,

package/services/torrent-worker/file-claims.js

@@ -1,91 +0,0 @@
-/**
- * @file Who is holding which file open.
- *
- * A claim keeps a file's data from being removed while something is reading it.
- * Until 2.9.77 claims were keyed by `sourceKey:fileIndex`, which quietly made
- * them **shared**: a second reader of the same file found the key taken and
- * added nothing, so the first reader to finish released the claim out from
- * under the second. The proxy reads one file from several places at once —
- * ffmpeg's input, the keyframe index, the codec probe, a second viewer — so
- * this was the normal case, not an edge one.
- *
- * The fix is not a counter. A counter restores the arithmetic but keeps the
- * ambiguity: a release names a file, not a claim, so a duplicate or late
- * release still decrements someone else's hold and nothing can detect it. Here
- * every claim gets its own identity and a release names exactly that claim —
- * so a stray release matches nothing, is reported, and harms no one.
- */
-
-/**
- * @typedef {object} FileClaims
- * @property {(sourceKey: string, fileIndex: number, release: () => void) => string} open
- * @property {(claimId: string) => boolean} close
- * @property {() => void} closeAll
- * @property {number} size
- */
-
-/**
- * Track file claims by identity.
- *
- * @returns {FileClaims}
- */
-export function createFileClaims() {
-  /** Claim id → the function that releases that one claim. */
-  const claims = new Map();
-  let counter = 0;
-
-  return {
-    /**
-     * Record a new claim and return its identity.
-     *
-     * Each call is a distinct claim even for the same file — that is the whole
-     * point.
-     *
-     * @param {string} sourceKey
-     * @param {number} fileIndex
-     * @param {() => void} release
-     * @returns {string}
-     */
-    open(sourceKey, fileIndex, release) {
-      counter += 1;
-      // The file is in the id purely so a log line reads usefully; matching is
-      // on the whole string.
-      const claimId = `${sourceKey}:${fileIndex}:${counter}`;
-      claims.set(claimId, release);
-      return claimId;
-    },
-
-    /**
-     * Release one claim. Returns false when there was no such claim, which is
-     * worth logging: it means a release arrived twice, or after teardown.
-     *
-     * @param {string} claimId
-     * @returns {boolean}
-     */
-    close(claimId) {
-      const release = claims.get(claimId);
-      if (!release) {
-        return false;
-      }
-      claims.delete(claimId);
-      release();
-      return true;
-    },
-
-    /**
-     * Release everything — the worker is shutting down.
-     *
-     * @returns {void}
-     */
-    closeAll() {
-      for (const [, release] of claims) {
-        release();
-      }
-      claims.clear();
-    },
-
-    get size() {
-      return claims.size;
-    }
-  };
-}

package/test/file-claims.test.js

@@ -1,64 +0,0 @@
-/**
- * @file File claims must be held per reader, not per file.
- *
- * The proxy reads one file from several places at once — ffmpeg's input, the
- * keyframe index, the codec probe, a second viewer. Keying claims by file made
- * them shared, so the first reader to finish released the hold while the others
- * were still reading, and the file's data could then be removed under them.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createFileClaims } from "../services/torrent-worker/file-claims.js";
-
-test("two readers of one file hold two claims", () => {
-  const claims = createFileClaims();
-  let released = 0;
-
-  const first = claims.open("source", 0, () => (released += 1));
-  const second = claims.open("source", 0, () => (released += 1));
-
-  assert.notEqual(first, second, "the second reader reused the first one's claim");
-  assert.equal(claims.size, 2);
-
-  claims.close(first);
-  assert.equal(released, 1, "closing one claim released more than one hold");
-  assert.equal(claims.size, 1, "the second reader's claim went with the first");
-
-  claims.close(second);
-  assert.equal(released, 2);
-  assert.equal(claims.size, 0);
-});
-
-test("a repeated release affects nothing and reports itself", () => {
-  const claims = createFileClaims();
-  let released = 0;
-  const claimId = claims.open("source", 3, () => (released += 1));
-
-  assert.equal(claims.close(claimId), true);
-  assert.equal(claims.close(claimId), false, "a second release was accepted as valid");
-  assert.equal(released, 1, "the hold was released twice");
-});
-
-test("a release naming nothing is rejected rather than guessed at", () => {
-  const claims = createFileClaims();
-  let released = 0;
-  claims.open("source", 0, () => (released += 1));
-
-  assert.equal(claims.close("source:0:999"), false);
-  assert.equal(released, 0, "an unknown claim released a real hold");
-  assert.equal(claims.size, 1);
-});
-
-test("teardown releases every outstanding claim", () => {
-  const claims = createFileClaims();
-  let released = 0;
-  claims.open("a", 0, () => (released += 1));
-  claims.open("a", 1, () => (released += 1));
-  claims.open("b", 0, () => (released += 1));
-
-  claims.closeAll();
-
-  assert.equal(released, 3);
-  assert.equal(claims.size, 0);
-});