@torrent-tv/proxy 2.87.9 → 2.87.11

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

@@ -1,103 +1,103 @@
-/**
- * @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(() => {
-    assert.deepEqual(sent.body.items, [
-      { fileIndex: 0, audio: [1], subtitles: [2], images: [] },
-      { fileIndex: 3, audio: [], subtitles: [], images: [] }
-    ]);
-    // 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(() => {
+    assert.deepEqual(sent.body.items, [
+      { fileIndex: 0, audio: [1], subtitles: [2], images: [] },
+      { fileIndex: 3, audio: [], subtitles: [], images: [] }
+    ]);
+    // 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);
+});

package/test/split-a-stretch.test.js

@@ -1,139 +1,139 @@
-/**
- * @file Where a second encoder joins a stretch, and whether it is worth having.
- *
- * Both halves are arithmetic and neither was asked before. The stretch used to
- * be halved, unconditionally:
- *
- *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
- *
- * Halving IS the answer when both encoders are fresh and owe the same. It is not
- * when one of them is already partway through a piece, and it never asked the
- * other question at all — whether two encoders under this host's measured
- * contention beat one at full speed.
- *
- * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
- * already on it stands at `from` and owes `w` before the piece under it exists;
- * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
- * both then work at the rate two encoders leave each other:
- *
- *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
- *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
- *
- *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
- *
- * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
- * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
- * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
- * piece is short and a start is not. Measuring only the re-encode rate
- * understated it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { planEncoders } from "../services/encode/EncodePlan.js";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-const SEGMENT_SECONDS = 4.2;
-const LAST = 199;
-
-/**
- * One encoder on a long stretch nobody has made, and room for more.
- *
- * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
- *   maxRuns?: number }} params
- * @returns {{ actions: object[], run: object }}
- */
-function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
-  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
-  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
-  const live = runs ?? [run];
-  for (const one of live) {
-    coverage.claim(one, one.from, one.to);
-  }
-  return {
-    run,
-    actions: planEncoders({
-      coverage,
-      // One zone over the whole film, due now, so nothing but the arithmetic of
-      // sharing it decides anything.
-      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
-      runs: live,
-      maxRuns,
-      segmentSeconds: SEGMENT_SECONDS,
-      speedX,
-      killCostSec: 0.04,
-      firstByteWaitSec: 0.9,
-      moveCostSec: 0.94,
-      refetchSecPerFilmSecond: 0,
-      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
-      // to the power of how many others there are, so a third costs again.
-      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
-      now: 1_000_000 + ageMs
-    })
-  };
-}
-
-test("one encoder that reaches everything in time is left to do it alone", () => {
-  // A zone whose deadline GROWS with distance — which is what the map states,
-  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
-  // is due in 835 s and arrives in 189 s. So there is no position to fill and
-  // nothing to split, whatever the budget says.
-  //
-  // Measured rather than assumed: this is what the plan answers, and the test
-  // was written expecting two encoders before it was run.
-  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["keep #0..#-1"],
-    "one encoder, its road to the end of the film"
-  );
-});
-
-test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
-  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
-  // meeting point is the midpoint, which is what halving always said. What is
-  // new is that each one's road ENDS where the next begins, so neither writes
-  // into the other's names.
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#100", "start #101..#199"],
-    "0..199 halved at 100"
-  );
-});
-
-test("a third encoder halves the widest half that is left", () => {
-  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
-
-  assert.deepEqual(
-    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
-    ["start #0..#50", "start #51..#100", "start #101..#199"],
-    "the first half is halved again, greedily, widest first"
-  );
-});
-
-test("a stretch of one piece is not split at all", () => {
-  const coverage = new CoverageMap({ segmentCount: 2 });
-  const actions = planEncoders({
-    coverage,
-    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
-    runs: [],
-    maxRuns: 3,
-    segmentSeconds: SEGMENT_SECONDS,
-    speedX: 8.9,
-    killCostSec: 0.04,
-    firstByteWaitSec: 0.9,
-    moveCostSec: 0.94,
-    refetchSecPerFilmSecond: 0,
-    contentionPenaltyFor: () => 1,
-    now: 1_000_000
-  });
-
-  assert.equal(
-    actions.filter((one) => one.type === "start").length,
-    1,
-    "there is nothing to share"
-  );
-});
+/**
+ * @file Where a second encoder joins a stretch, and whether it is worth having.
+ *
+ * Both halves are arithmetic and neither was asked before. The stretch used to
+ * be halved, unconditionally:
+ *
+ *     widestFrom = from + Math.floor(Math.min(room, to - from + 1) / 2)
+ *
+ * Halving IS the answer when both encoders are fresh and owe the same. It is not
+ * when one of them is already partway through a piece, and it never asked the
+ * other question at all — whether two encoders under this host's measured
+ * contention beat one at full speed.
+ *
+ * The derivation. A stretch of unmade film runs from `from` to `to`; whoever is
+ * already on it stands at `from` and owes `w` before the piece under it exists;
+ * a fresh one placed at `x` owes `d` — its start and then a whole piece — and
+ * both then work at the rate two encoders leave each other:
+ *
+ *     the one there closes [from, x-1]:  w + (x - 1 - from) / r   rises with x
+ *     the fresh one closes [x, to]:      d + (to - x)     / r     falls with x
+ *
+ *     x* = (from + to + 1) / 2  +  (d - w) * r / 2
+ *
+ * The shift is `firstByteWait / (2 * perPiece)` pieces, so it depends on how
+ * long a piece takes here: 0.24 of a piece at 4.45x on a 4.2 s grid, but 0.96 at
+ * 8.9x and 2.14 at 20x — a whole segment and more on the copy branch, where a
+ * piece is short and a start is not. Measuring only the re-encode rate
+ * understated it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { planEncoders } from "../services/encode/EncodePlan.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+const SEGMENT_SECONDS = 4.2;
+const LAST = 199;
+
+/**
+ * One encoder on a long stretch nobody has made, and room for more.
+ *
+ * @param {{ speedX: number, penalty: number, head?: number, ageMs?: number,
+ *   maxRuns?: number }} params
+ * @returns {{ actions: object[], run: object }}
+ */
+function planFor({ speedX, penalty, head = 0, ageMs = 60_000, maxRuns = 3, runs = null }) {
+  const coverage = new CoverageMap({ segmentCount: LAST + 1 });
+  const run = { from: 0, to: -1, head, speedX, isAlive: true, startedAt: 1_000_000 };
+  const live = runs ?? [run];
+  for (const one of live) {
+    coverage.claim(one, one.from, one.to);
+  }
+  return {
+    run,
+    actions: planEncoders({
+      coverage,
+      // One zone over the whole film, due now, so nothing but the arithmetic of
+      // sharing it decides anything.
+      windows: [{ from: 0, to: LAST, priority: 100, withinSeconds: 0, behind: false }],
+      runs: live,
+      maxRuns,
+      segmentSeconds: SEGMENT_SECONDS,
+      speedX,
+      killCostSec: 0.04,
+      firstByteWaitSec: 0.9,
+      moveCostSec: 0.94,
+      refetchSecPerFilmSecond: 0,
+      // Measured on the addon host: 1.70 at 854x480, 1.98 at 1920x1080. Raised
+      // to the power of how many others there are, so a third costs again.
+      contentionPenaltyFor: (others) => (others <= 0 ? 1 : penalty ** others),
+      now: 1_000_000 + ageMs
+    })
+  };
+}
+
+test("one encoder that reaches everything in time is left to do it alone", () => {
+  // A zone whose deadline GROWS with distance — which is what the map states,
+  // one segment at a time — is comfortably served by one encoder at 4.45x: #199
+  // is due in 835 s and arrives in 189 s. So there is no position to fill and
+  // nothing to split, whatever the budget says.
+  //
+  // Measured rather than assumed: this is what the plan answers, and the test
+  // was written expecting two encoders before it was run.
+  const { actions } = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3 });
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["keep #0..#-1"],
+    "one encoder, its road to the end of the film"
+  );
+});
+
+test("a stretch nobody is on is split at the middle, and the halves bound each other", () => {
+  // Both encoders are fresh, so both owe the same and `d - w` is zero: the
+  // meeting point is the midpoint, which is what halving always said. What is
+  // new is that each one's road ENDS where the next begins, so neither writes
+  // into the other's names.
+  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 2, runs: [] }).actions;
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["start #0..#100", "start #101..#199"],
+    "0..199 halved at 100"
+  );
+});
+
+test("a third encoder halves the widest half that is left", () => {
+  const actions = planFor({ speedX: 4.45, penalty: 1, maxRuns: 3, runs: [] }).actions;
+
+  assert.deepEqual(
+    actions.map((one) => `${one.type} #${one.from}..#${one.to}`),
+    ["start #0..#50", "start #51..#100", "start #101..#199"],
+    "the first half is halved again, greedily, widest first"
+  );
+});
+
+test("a stretch of one piece is not split at all", () => {
+  const coverage = new CoverageMap({ segmentCount: 2 });
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 0, to: 0, priority: 100, withinSeconds: 0, behind: false }],
+    runs: [],
+    maxRuns: 3,
+    segmentSeconds: SEGMENT_SECONDS,
+    speedX: 8.9,
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1,
+    now: 1_000_000
+  });
+
+  assert.equal(
+    actions.filter((one) => one.type === "start").length,
+    1,
+    "there is nothing to share"
+  );
+});