@torrent-tv/proxy 2.88.2 → 2.88.4

package/test/source-file.test.js

@@ -1,133 +1,133 @@
-/**
- * @file The file as a handle: its key, its name, what a probe said about it,
- * and the address this proxy serves it at.
- *
- * The reason this object exists is the key. Twenty places in the session
- * manager assembled `${sourceKey}:${fileIndex}` by hand, through five different
- * spellings, to reach caches that are keyed by a file. These checks pin the
- * shape those call sites now depend on, and the one property the registry has
- * to have: the same file asked for twice is the same object, or a fact learned
- * through one reference would be invisible through the other.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/media/SourceFile.js";
-
-test("a file's key is the pair that identifies it, spelled in one place", () => {
-  const file = new SourceFile({ sourceKey: "abc123", fileIndex: 4 });
-  assert.equal(file.key, "abc123:4");
-  assert.equal(SourceFiles.keyFor("abc123", 4), file.key);
-});
-
-test("a file with no name is named by its index, so no log line is about a nameless thing", () => {
-  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7 }).name, "file#7");
-  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7, name: "  Film.mkv  " }).name, "Film.mkv");
-});
-
-test("facts are absent until a probe answers, and 'absent' is not 'zero'", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  assert.equal(file.width, null, "an unread frame size is unknown, not 0x0");
-  assert.equal(file.height, null);
-  assert.equal(file.fps, null);
-  assert.equal(file.durationSeconds, null);
-  assert.equal(file.hasDuration, false);
-  assert.equal(file.isHdr, false, "a file nobody has read is not claimed to be HDR");
-  assert.equal(file.startTime, 0, "no stated start time means the timeline begins at zero");
-  assert.equal(file.decode, null, "and nothing is priced from facts that were never read");
-});
-
-test("readings are merged, because two readers answer about different things", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  // ffmpeg's banner: the frame size and rate, and no start time.
-  file.learn({ width: 1920, height: 1080, fps: 24 });
-  // The container's own header, read for one field — a sidecar soundtrack is
-  // read for exactly this and nothing else.
-  file.learn({ startTime: 0.083 });
-  assert.equal(file.startTime, 0.083);
-  assert.equal(file.width, 1920, "the second reader must not erase what the first found");
-});
-
-test("a fresher reading replaces the first, because a cold torrent answers incompletely", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 0, startTime: 1.5 });
-  assert.equal(file.width, 1920);
-  assert.equal(file.hasDuration, false, "a duration of zero is no duration");
-  assert.equal(file.startTime, 1.5);
-
-  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 5400, startTime: 1.5 });
-  assert.equal(file.durationSeconds, 5400);
-  assert.equal(file.hasDuration, true);
-
-  file.learn(null);
-  assert.equal(file.durationSeconds, 5400, "nothing is unlearned by an answer that did not come");
-});
-
-test("what decoding costs is derived from the file's own facts, per codec family", () => {
-  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
-  file.learn({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000, codec: "hevc", bitDepth: 10 });
-  assert.deepEqual(file.decode, {
-    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
-    megabitsPerSecond: 8,
-    codec: "hevc",
-    bitDepth: 10
-  });
-  // The same arithmetic, still callable on a plain reading — the offer prices a
-  // file it has not made a session for.
-  assert.deepEqual(sourceDecodeCharacteristics({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000 }), {
-    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
-    megabitsPerSecond: 8,
-    codec: "",
-    bitDepth: null
-  });
-});
-
-test("the address carries the file and the session, and the proxy's own base is a parameter", () => {
-  const file = new SourceFile({ sourceKey: "abc", fileIndex: 2 });
-  const url = file.streamUrl("http://127.0.0.1:9090", { sessionId: "sess-1" });
-  assert.equal(url.pathname, "/stream");
-  assert.equal(url.searchParams.get("sourceKey"), "abc");
-  assert.equal(url.searchParams.get("fileIndex"), "2");
-  assert.equal(url.searchParams.get("session"), "sess-1");
-
-  const noSession = file.streamUrl("http://127.0.0.1:9090");
-  assert.equal(noSession.searchParams.has("session"), false, "a read nobody is accounting for says so");
-});
-
-test("the same file asked for twice is the same object, or a fact learned once is lost", () => {
-  const files = new SourceFiles();
-  const first = files.get("abc", 1, "Film.mkv");
-  first.learn({ width: 1280, height: 720, fps: 25, durationSeconds: 60 });
-
-  const second = files.get("abc", 1);
-  assert.equal(second, first, "two viewers of one file must not hold two copies of its facts");
-  assert.equal(second.width, 1280);
-  assert.equal(second.name, "Film.mkv");
-
-  const other = files.get("abc", 2);
-  assert.notEqual(other, first, "and a different file in the same torrent is a different file");
-});
-
-test("a name learned later is kept, since the first caller often has only an index", () => {
-  const files = new SourceFiles();
-  const bare = files.get("abc", 1);
-  assert.equal(bare.name, "file#1");
-  files.get("abc", 1, "Film.mkv");
-  assert.equal(bare.name, "Film.mkv");
-  files.get("abc", 1, "Something.else.mkv");
-  assert.equal(bare.name, "Film.mkv", "and it is not renamed underneath a log line already written");
-});
-
-test("files nobody names are dropped, and a file still named survives the sweep", () => {
-  const files = new SourceFiles();
-  const kept = files.get("abc", 1);
-  files.get("abc", 2);
-  files.get("def", 9);
-  assert.equal(files.size, 3);
-
-  const dropped = files.forgetUnused(new Set([kept]));
-  assert.equal(dropped, 2);
-  assert.equal(files.size, 1);
-  assert.equal(files.peek(kept.key), kept);
-  assert.equal(files.peek("abc:2"), null);
-});
+/**
+ * @file The file as a handle: its key, its name, what a probe said about it,
+ * and the address this proxy serves it at.
+ *
+ * The reason this object exists is the key. Twenty places in the session
+ * manager assembled `${sourceKey}:${fileIndex}` by hand, through five different
+ * spellings, to reach caches that are keyed by a file. These checks pin the
+ * shape those call sites now depend on, and the one property the registry has
+ * to have: the same file asked for twice is the same object, or a fact learned
+ * through one reference would be invisible through the other.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/media/SourceFile.js";
+
+test("a file's key is the pair that identifies it, spelled in one place", () => {
+  const file = new SourceFile({ sourceKey: "abc123", fileIndex: 4 });
+  assert.equal(file.key, "abc123:4");
+  assert.equal(SourceFiles.keyFor("abc123", 4), file.key);
+});
+
+test("a file with no name is named by its index, so no log line is about a nameless thing", () => {
+  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7 }).name, "file#7");
+  assert.equal(new SourceFile({ sourceKey: "s", fileIndex: 7, name: "  Film.mkv  " }).name, "Film.mkv");
+});
+
+test("facts are absent until a probe answers, and 'absent' is not 'zero'", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  assert.equal(file.width, null, "an unread frame size is unknown, not 0x0");
+  assert.equal(file.height, null);
+  assert.equal(file.fps, null);
+  assert.equal(file.durationSeconds, null);
+  assert.equal(file.hasDuration, false);
+  assert.equal(file.isHdr, false, "a file nobody has read is not claimed to be HDR");
+  assert.equal(file.startTime, 0, "no stated start time means the timeline begins at zero");
+  assert.equal(file.decode, null, "and nothing is priced from facts that were never read");
+});
+
+test("readings are merged, because two readers answer about different things", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  // ffmpeg's banner: the frame size and rate, and no start time.
+  file.learn({ width: 1920, height: 1080, fps: 24 });
+  // The container's own header, read for one field — a sidecar soundtrack is
+  // read for exactly this and nothing else.
+  file.learn({ startTime: 0.083 });
+  assert.equal(file.startTime, 0.083);
+  assert.equal(file.width, 1920, "the second reader must not erase what the first found");
+});
+
+test("a fresher reading replaces the first, because a cold torrent answers incompletely", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 0, startTime: 1.5 });
+  assert.equal(file.width, 1920);
+  assert.equal(file.hasDuration, false, "a duration of zero is no duration");
+  assert.equal(file.startTime, 1.5);
+
+  file.learn({ width: 1920, height: 1080, fps: 24, durationSeconds: 5400, startTime: 1.5 });
+  assert.equal(file.durationSeconds, 5400);
+  assert.equal(file.hasDuration, true);
+
+  file.learn(null);
+  assert.equal(file.durationSeconds, 5400, "nothing is unlearned by an answer that did not come");
+});
+
+test("what decoding costs is derived from the file's own facts, per codec family", () => {
+  const file = new SourceFile({ sourceKey: "s", fileIndex: 0 });
+  file.learn({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000, codec: "hevc", bitDepth: 10 });
+  assert.deepEqual(file.decode, {
+    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
+    megabitsPerSecond: 8,
+    codec: "hevc",
+    bitDepth: 10
+  });
+  // The same arithmetic, still callable on a plain reading — the offer prices a
+  // file it has not made a session for.
+  assert.deepEqual(sourceDecodeCharacteristics({ width: 1920, height: 1080, fps: 24, bitrateKbps: 8000 }), {
+    megapixelsPerSecond: (1920 * 1080 * 24) / 1e6,
+    megabitsPerSecond: 8,
+    codec: "",
+    bitDepth: null
+  });
+});
+
+test("the address carries the file and the session, and the proxy's own base is a parameter", () => {
+  const file = new SourceFile({ sourceKey: "abc", fileIndex: 2 });
+  const url = file.streamUrl("http://127.0.0.1:9090", { sessionId: "sess-1" });
+  assert.equal(url.pathname, "/stream");
+  assert.equal(url.searchParams.get("sourceKey"), "abc");
+  assert.equal(url.searchParams.get("fileIndex"), "2");
+  assert.equal(url.searchParams.get("session"), "sess-1");
+
+  const noSession = file.streamUrl("http://127.0.0.1:9090");
+  assert.equal(noSession.searchParams.has("session"), false, "a read nobody is accounting for says so");
+});
+
+test("the same file asked for twice is the same object, or a fact learned once is lost", () => {
+  const files = new SourceFiles();
+  const first = files.get("abc", 1, "Film.mkv");
+  first.learn({ width: 1280, height: 720, fps: 25, durationSeconds: 60 });
+
+  const second = files.get("abc", 1);
+  assert.equal(second, first, "two viewers of one file must not hold two copies of its facts");
+  assert.equal(second.width, 1280);
+  assert.equal(second.name, "Film.mkv");
+
+  const other = files.get("abc", 2);
+  assert.notEqual(other, first, "and a different file in the same torrent is a different file");
+});
+
+test("a name learned later is kept, since the first caller often has only an index", () => {
+  const files = new SourceFiles();
+  const bare = files.get("abc", 1);
+  assert.equal(bare.name, "file#1");
+  files.get("abc", 1, "Film.mkv");
+  assert.equal(bare.name, "Film.mkv");
+  files.get("abc", 1, "Something.else.mkv");
+  assert.equal(bare.name, "Film.mkv", "and it is not renamed underneath a log line already written");
+});
+
+test("files nobody names are dropped, and a file still named survives the sweep", () => {
+  const files = new SourceFiles();
+  const kept = files.get("abc", 1);
+  files.get("abc", 2);
+  files.get("def", 9);
+  assert.equal(files.size, 3);
+
+  const dropped = files.forgetUnused(new Set([kept]));
+  assert.equal(dropped, 2);
+  assert.equal(files.size, 1);
+  assert.equal(files.peek(kept.key), kept);
+  assert.equal(files.peek("abc:2"), null);
+});

package/test/source-files-route.test.js

@@ -1,113 +1,113 @@
-/**
- * @file WHAT THE BROWSER IS TOLD IS IN A TORRENT.
- *
- * This is the one place the product answers it. The browser used to answer it
- * as well — a list of video extensions in its parser and a second, shorter pair
- * inside its picker — and the three had already diverged: measured 2026-09-12,
- * `.dat` was offered there as video and not counted here, which also decides
- * whether a sidecar whose name matches nothing can belong to the only video
- * present.
- *
- * So the shape of this answer is a contract with the page, and the page shows
- * what it is given without looking at a name.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { handleApiSourceFilesGet } from "../routes/api/sources/files/get.js";
-
-/**
- * A request, a reply and the torrent behind them.
- *
- * @param {Array<{ path: string, length: number }>} files
- * @returns {{ req: object, reply: object, sent: { body: object | null, code: number }, deps: object }}
- */
-function harness(files) {
-  const sent = { body: null, code: 200 };
-  const reply = {
-    code(value) {
-      sent.code = value;
-      return reply;
-    },
-    send(body) {
-      sent.body = body;
-      return reply;
-    }
-  };
-  const deps = {
-    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:abc" }) },
-    torrentPool: {
-      async getTorrent() {
-        return { name: "Drifters", infoHash: "abc", files };
-      }
-    }
-  };
-  return { req: { params: { sourceKey: "key" }, query: {} }, reply, sent, deps };
-}
-
-test("the files come back in reading order, each saying what it is", () => {
-  const { req, reply, sent, deps } = harness([
-    { path: "Drifters/ep 10.mkv", length: 9 },
-    { path: "Drifters/ep 2.mkv", length: 9 },
-    { path: "Drifters/Rus Sound/ep 2.mka", length: 2 },
-    { path: "Drifters/notes.nfo", length: 1 }
-  ]);
-
-  return handleApiSourceFilesGet(req, reply, deps).then(() => {
-    assert.equal(sent.code, 200);
-    assert.deepEqual(
-      sent.body.files.map((file) => [file.relativePath, file.kind]),
-      [
-        // Runs of digits compare as numbers, so 2 comes before 10; the torrent's
-        // own order is whatever the tool that made it chose.
-        ["ep 2.mkv", "video"],
-        ["ep 10.mkv", "video"],
-        ["notes.nfo", "other"],
-        ["Rus Sound/ep 2.mka", "audio"]
-      ]
-    );
-    // Relative to the torrent root: WebTorrent prefixes its own name to every
-    // path, and stripping it here means one rule in the product rather than two
-    // that can disagree.
-    assert.ok(sent.body.files.every((file) => !file.relativePath.startsWith("Drifters/")));
-  });
-});
-
-test("each picture is named with what belongs to it, by index", () => {
-  const { req, reply, sent, deps } = harness([
-    { path: "Drifters/ep 1.mkv", length: 9 },
-    { path: "Drifters/Rus Sound/ep 1.mka", length: 2 },
-    { path: "Drifters/Sub/ep 1.ass", length: 1 },
-    { path: "Drifters/ep 2.mkv", length: 9 }
-  ]);
-
-  return handleApiSourceFilesGet(req, reply, deps).then(() => {
-    const episode = (number) => ({
-      season: null,
-      episodes: [number],
-      part: null,
-      special: false,
-      showHint: "",
-      titleHint: ""
-    });
-    assert.deepEqual(sent.body.items, [
-      { fileIndex: 0, audio: [1], subtitles: [2], images: [], episode: episode(1) },
-      { fileIndex: 3, audio: [], subtitles: [], images: [], episode: episode(2) }
-    ]);
-    // Two numbered pictures of one show: the release is a series.
-    assert.equal(sent.body.shape, "series");
-    // The files themselves are in the list above; saying them twice is how two
-    // copies of one fact start.
-    assert.ok(sent.body.items.every((item) => item.audio.every((one) => Number.isInteger(one))));
-  });
-});
-
-test("a torrent whose metadata has not arrived says so and lists nothing", () => {
-  const { req, reply, sent, deps } = harness([]);
-
-  return handleApiSourceFilesGet(req, reply, deps).then(() => {
-    assert.deepEqual(sent.body.files, []);
-    assert.deepEqual(sent.body.items, []);
-    assert.equal(sent.body.name, "Drifters");
-  });
-});
+/**
+ * @file WHAT THE BROWSER IS TOLD IS IN A TORRENT.
+ *
+ * This is the one place the product answers it. The browser used to answer it
+ * as well — a list of video extensions in its parser and a second, shorter pair
+ * inside its picker — and the three had already diverged: measured 2026-09-12,
+ * `.dat` was offered there as video and not counted here, which also decides
+ * whether a sidecar whose name matches nothing can belong to the only video
+ * present.
+ *
+ * So the shape of this answer is a contract with the page, and the page shows
+ * what it is given without looking at a name.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleApiSourceFilesGet } from "../routes/api/sources/files/get.js";
+
+/**
+ * A request, a reply and the torrent behind them.
+ *
+ * @param {Array<{ path: string, length: number }>} files
+ * @returns {{ req: object, reply: object, sent: { body: object | null, code: number }, deps: object }}
+ */
+function harness(files) {
+  const sent = { body: null, code: 200 };
+  const reply = {
+    code(value) {
+      sent.code = value;
+      return reply;
+    },
+    send(body) {
+      sent.body = body;
+      return reply;
+    }
+  };
+  const deps = {
+    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:abc" }) },
+    torrentPool: {
+      async getTorrent() {
+        return { name: "Drifters", infoHash: "abc", files };
+      }
+    }
+  };
+  return { req: { params: { sourceKey: "key" }, query: {} }, reply, sent, deps };
+}
+
+test("the files come back in reading order, each saying what it is", () => {
+  const { req, reply, sent, deps } = harness([
+    { path: "Drifters/ep 10.mkv", length: 9 },
+    { path: "Drifters/ep 2.mkv", length: 9 },
+    { path: "Drifters/Rus Sound/ep 2.mka", length: 2 },
+    { path: "Drifters/notes.nfo", length: 1 }
+  ]);
+
+  return handleApiSourceFilesGet(req, reply, deps).then(() => {
+    assert.equal(sent.code, 200);
+    assert.deepEqual(
+      sent.body.files.map((file) => [file.relativePath, file.kind]),
+      [
+        // Runs of digits compare as numbers, so 2 comes before 10; the torrent's
+        // own order is whatever the tool that made it chose.
+        ["ep 2.mkv", "video"],
+        ["ep 10.mkv", "video"],
+        ["notes.nfo", "other"],
+        ["Rus Sound/ep 2.mka", "audio"]
+      ]
+    );
+    // Relative to the torrent root: WebTorrent prefixes its own name to every
+    // path, and stripping it here means one rule in the product rather than two
+    // that can disagree.
+    assert.ok(sent.body.files.every((file) => !file.relativePath.startsWith("Drifters/")));
+  });
+});
+
+test("each picture is named with what belongs to it, by index", () => {
+  const { req, reply, sent, deps } = harness([
+    { path: "Drifters/ep 1.mkv", length: 9 },
+    { path: "Drifters/Rus Sound/ep 1.mka", length: 2 },
+    { path: "Drifters/Sub/ep 1.ass", length: 1 },
+    { path: "Drifters/ep 2.mkv", length: 9 }
+  ]);
+
+  return handleApiSourceFilesGet(req, reply, deps).then(() => {
+    const episode = (number) => ({
+      season: null,
+      episodes: [number],
+      part: null,
+      special: false,
+      showHint: "",
+      titleHint: ""
+    });
+    assert.deepEqual(sent.body.items, [
+      { fileIndex: 0, audio: [1], subtitles: [2], images: [], episode: episode(1) },
+      { fileIndex: 3, audio: [], subtitles: [], images: [], episode: episode(2) }
+    ]);
+    // Two numbered pictures of one show: the release is a series.
+    assert.equal(sent.body.shape, "series");
+    // The files themselves are in the list above; saying them twice is how two
+    // copies of one fact start.
+    assert.ok(sent.body.items.every((item) => item.audio.every((one) => Number.isInteger(one))));
+  });
+});
+
+test("a torrent whose metadata has not arrived says so and lists nothing", () => {
+  const { req, reply, sent, deps } = harness([]);
+
+  return handleApiSourceFilesGet(req, reply, deps).then(() => {
+    assert.deepEqual(sent.body.files, []);
+    assert.deepEqual(sent.body.items, []);
+    assert.equal(sent.body.name, "Drifters");
+  });
+});

package/test/source-registry.test.js

@@ -1,18 +1,18 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { createSourceRegistry } from "../store/source-registry.js";
-
-const infoHash = "0123456789abcdef0123456789abcdef01234567";
-
-test("magnet links for one torrent share a source key", async () => {
-  const registry = createSourceRegistry();
-  const first = `magnet:?xt=urn:btih:${infoHash}&dn=First+name&tr=udp%3A%2F%2Ftracker.one%3A80`;
-  const second = `magnet:?xt=urn:btih:${infoHash}&dn=Different+name&tr=udp%3A%2F%2Ftracker.two%3A80`;
-
-  const firstKey = await registry.upsert("magnet", first);
-  const secondKey = await registry.upsert("magnet", second);
-
-  assert.equal(firstKey, `torrent:${infoHash}`);
-  assert.equal(secondKey, firstKey);
-  assert.equal(registry.get(firstKey)?.source, second);
-});
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createSourceRegistry } from "../store/source-registry.js";
+
+const infoHash = "0123456789abcdef0123456789abcdef01234567";
+
+test("magnet links for one torrent share a source key", async () => {
+  const registry = createSourceRegistry();
+  const first = `magnet:?xt=urn:btih:${infoHash}&dn=First+name&tr=udp%3A%2F%2Ftracker.one%3A80`;
+  const second = `magnet:?xt=urn:btih:${infoHash}&dn=Different+name&tr=udp%3A%2F%2Ftracker.two%3A80`;
+
+  const firstKey = await registry.upsert("magnet", first);
+  const secondKey = await registry.upsert("magnet", second);
+
+  assert.equal(firstKey, `torrent:${infoHash}`);
+  assert.equal(secondKey, firstKey);
+  assert.equal(registry.get(firstKey)?.source, second);
+});