@torrent-tv/proxy 2.89.7 → 2.89.9

package/test/the-torrent-thread-serves-bytes.test.js

@@ -1,107 +1,107 @@
-/**
- * @file The torrent thread serves bytes. It does not read what a file says.
- *
- * Both halves of that were true of the design and only one was true of the
- * code: pieces have lived in shared memory since the reader was rewritten, and
- * the torrent thread ALSO parsed containers — the track table, the media info
- * and the keyframe index — and carried each answer back over the channel.
- *
- * The stated reason was "the main thread cannot open a read stream on one of
- * its files". That is true of WebTorrent's own API and not of the bytes: a
- * container is built from one function, `readRange(start, end)`, and the read
- * that serves every segment already waits for what has not arrived and steers
- * the swarm toward it. What the split cost was three commands, a second
- * `ContainerOrchestrator` in that thread, and — because an answer then had to
- * be carried across — the question of where each such answer is KEPT, which is
- * how one fact came to be stored twice.
- *
- * These checks are structural because the property is structural: there is no
- * input that makes a parse happen in the wrong thread, only an import.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync, readdirSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const WORKER = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../services/torrent/worker");
-
-/**
- * @param {string} name
- * @returns {string}
- */
-function source(name) {
-  return readFileSync(path.join(WORKER, name), "utf8");
-}
-
-test("no command asks the torrent thread what a file declares", () => {
-  const protocol = source("protocol.js");
-
-  for (const gone of [
-    "CONTAINER_TRACKS",
-    "CONTAINER_MEDIA_INFO",
-    "CONTAINER_KEYFRAMES",
-    "SUBTITLE_TRACKS",
-    "SUBTITLE_CUES"
-  ]) {
-    assert.equal(
-      protocol.includes(gone),
-      false,
-      `${gone} is a question about the FILE, and it is answered where the sessions are`
-    );
-  }
-});
-
-test("nothing in that thread reaches into the media layer at all", () => {
-  // The last one to was the subtitle cue walk, and it moved with the rest: it
-  // is handed which ranges of a file are downloaded whole and how to read one
-  // of those, and it has no use for a torrent beyond that. What stayed behind
-  // is the two things only this thread can answer — the bitfield as a list of
-  // ranges, and a store read that never fetches (`held-bytes.js`).
-  const reaching = readdirSync(WORKER)
-    .filter((name) => name.endsWith(".js"))
-    .filter((name) => /from "(?:\.\.\/)+media\//.test(source(name)));
-
-  assert.deepEqual(reaching, []);
-});
-
-test("what the walk may read is answered as a list, not asked per cluster", () => {
-  // A pass asks about every cluster of the file — hundreds on the field files,
-  // every three seconds. One list per pass costs one message; the same answers
-  // one at a time would cost hundreds of round trips for a walk that is meant
-  // to be free when there is nothing new to find.
-  const held = source("held-bytes.js");
-
-  assert.match(held, /export function heldRangesOf\(torrent, fileIndex\)/);
-  assert.match(held, /export function readHeldBytes\(/);
-});
-
-test("the walk's read never fetches", () => {
-  // The ordinary range read declares demand and steers the swarm, which is
-  // right for a viewer waiting on a segment and wrong here: switching subtitles
-  // on must not pull bytes the viewer is not waiting for.
-  const held = source("held-bytes.js");
-
-  assert.equal(held.includes("demandFor"), false);
-  assert.equal(held.includes("readFragments"), false);
-});
-
-test("the resume warm is TOLD how long the file runs", () => {
-  // It used to read the container itself to find out, which is what a file
-  // states about itself. What is left here is the part that really is the
-  // torrent's: a position in seconds becomes a byte offset, and that region is
-  // pulled off the swarm.
-  const warm = source("resume-warm.js");
-
-  assert.match(warm, /options\.durationSeconds/);
-  assert.equal(warm.includes("containerOrchestrator"), false);
-  assert.equal(warm.includes("ContainerFactory"), false);
-});
-
-test("the main thread can read a byte range of a file", () => {
-  // The one thing the move needed, and the whole of what a container is built
-  // from. Without it the parse has nowhere to get its bytes and the commands
-  // come back.
-  assert.match(source("pool-adapter.js"), /async readRangeOf\(torrent, fileIndex, start, end\)/);
-});
+/**
+ * @file The torrent thread serves bytes. It does not read what a file says.
+ *
+ * Both halves of that were true of the design and only one was true of the
+ * code: pieces have lived in shared memory since the reader was rewritten, and
+ * the torrent thread ALSO parsed containers — the track table, the media info
+ * and the keyframe index — and carried each answer back over the channel.
+ *
+ * The stated reason was "the main thread cannot open a read stream on one of
+ * its files". That is true of WebTorrent's own API and not of the bytes: a
+ * container is built from one function, `readRange(start, end)`, and the read
+ * that serves every segment already waits for what has not arrived and steers
+ * the swarm toward it. What the split cost was three commands, a second
+ * `ContainerOrchestrator` in that thread, and — because an answer then had to
+ * be carried across — the question of where each such answer is KEPT, which is
+ * how one fact came to be stored twice.
+ *
+ * These checks are structural because the property is structural: there is no
+ * input that makes a parse happen in the wrong thread, only an import.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const WORKER = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../services/torrent/worker");
+
+/**
+ * @param {string} name
+ * @returns {string}
+ */
+function source(name) {
+  return readFileSync(path.join(WORKER, name), "utf8");
+}
+
+test("no command asks the torrent thread what a file declares", () => {
+  const protocol = source("protocol.js");
+
+  for (const gone of [
+    "CONTAINER_TRACKS",
+    "CONTAINER_MEDIA_INFO",
+    "CONTAINER_KEYFRAMES",
+    "SUBTITLE_TRACKS",
+    "SUBTITLE_CUES"
+  ]) {
+    assert.equal(
+      protocol.includes(gone),
+      false,
+      `${gone} is a question about the FILE, and it is answered where the sessions are`
+    );
+  }
+});
+
+test("nothing in that thread reaches into the media layer at all", () => {
+  // The last one to was the subtitle cue walk, and it moved with the rest: it
+  // is handed which ranges of a file are downloaded whole and how to read one
+  // of those, and it has no use for a torrent beyond that. What stayed behind
+  // is the two things only this thread can answer — the bitfield as a list of
+  // ranges, and a store read that never fetches (`held-bytes.js`).
+  const reaching = readdirSync(WORKER)
+    .filter((name) => name.endsWith(".js"))
+    .filter((name) => /from "(?:\.\.\/)+media\//.test(source(name)));
+
+  assert.deepEqual(reaching, []);
+});
+
+test("what the walk may read is answered as a list, not asked per cluster", () => {
+  // A pass asks about every cluster of the file — hundreds on the field files,
+  // every three seconds. One list per pass costs one message; the same answers
+  // one at a time would cost hundreds of round trips for a walk that is meant
+  // to be free when there is nothing new to find.
+  const held = source("held-bytes.js");
+
+  assert.match(held, /export function heldRangesOf\(torrent, fileIndex\)/);
+  assert.match(held, /export function readHeldBytes\(/);
+});
+
+test("the walk's read never fetches", () => {
+  // The ordinary range read declares demand and steers the swarm, which is
+  // right for a viewer waiting on a segment and wrong here: switching subtitles
+  // on must not pull bytes the viewer is not waiting for.
+  const held = source("held-bytes.js");
+
+  assert.equal(held.includes("demandFor"), false);
+  assert.equal(held.includes("readFragments"), false);
+});
+
+test("the resume warm is TOLD how long the file runs", () => {
+  // It used to read the container itself to find out, which is what a file
+  // states about itself. What is left here is the part that really is the
+  // torrent's: a position in seconds becomes a byte offset, and that region is
+  // pulled off the swarm.
+  const warm = source("resume-warm.js");
+
+  assert.match(warm, /options\.durationSeconds/);
+  assert.equal(warm.includes("containerOrchestrator"), false);
+  assert.equal(warm.includes("ContainerFactory"), false);
+});
+
+test("the main thread can read a byte range of a file", () => {
+  // The one thing the move needed, and the whole of what a container is built
+  // from. Without it the parse has nowhere to get its bytes and the commands
+  // come back.
+  assert.match(source("pool-adapter.js"), /async readRangeOf\(torrent, fileIndex, start, end\)/);
+});

package/test/thread-pool.test.js

@@ -1,53 +1,53 @@
-/**
- * @file The blocking-call pool is stated before anything can create it.
- *
- * Field 2026-08-18: a film with 517 seeders spent eleven minutes with zero
- * peers on the addon host. Every announce timed out — UDP and HTTP alike — and
- * the cause was not the network: resolving that torrent's ten tracker names as
- * a burst took 7.58 s on the default four-thread pool, against 27-42 ms each
- * when the pool was larger. A dead tracker holds a thread for the resolver's
- * whole timeout, and every announce queued behind it misses its own deadline.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-
-test("the pool is set, and left alone when the deployment states its own", async () => {
-  const previous = process.env.UV_THREADPOOL_SIZE;
-  try {
-    process.env.UV_THREADPOOL_SIZE = "";
-    await import(`../bin/thread-pool.js?first=${Date.now()}`);
-    assert.equal(
-      Number(process.env.UV_THREADPOOL_SIZE) >= 16,
-      true,
-      "enough threads for a torrent's whole announce list to resolve at once"
-    );
-
-    process.env.UV_THREADPOOL_SIZE = "8";
-    await import(`../bin/thread-pool.js?stated=${Date.now()}`);
-    assert.equal(process.env.UV_THREADPOOL_SIZE, "8", "a stated size is the deployment's to choose");
-  } finally {
-    if (previous === undefined) {
-      delete process.env.UV_THREADPOOL_SIZE;
-    } else {
-      process.env.UV_THREADPOOL_SIZE = previous;
-    }
-  }
-});
-
-test("the entry point imports it before anything that could create the pool", async () => {
-  const cli = await readFile(path.join(here, "..", "bin", "cli.js"), "utf8");
-  const imports = [...cli.matchAll(/^import\s.*?from\s+["'](.+?)["'];|^import\s+["'](.+?)["'];/gm)]
-    .map((match) => match[1] ?? match[2]);
-
-  assert.equal(
-    imports[0],
-    "./thread-pool.js",
-    "a module's imports run before its body, so this cannot be a statement in cli.js"
-  );
-});
+/**
+ * @file The blocking-call pool is stated before anything can create it.
+ *
+ * Field 2026-08-18: a film with 517 seeders spent eleven minutes with zero
+ * peers on the addon host. Every announce timed out — UDP and HTTP alike — and
+ * the cause was not the network: resolving that torrent's ten tracker names as
+ * a burst took 7.58 s on the default four-thread pool, against 27-42 ms each
+ * when the pool was larger. A dead tracker holds a thread for the resolver's
+ * whole timeout, and every announce queued behind it misses its own deadline.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = path.dirname(fileURLToPath(import.meta.url));
+
+test("the pool is set, and left alone when the deployment states its own", async () => {
+  const previous = process.env.UV_THREADPOOL_SIZE;
+  try {
+    process.env.UV_THREADPOOL_SIZE = "";
+    await import(`../bin/thread-pool.js?first=${Date.now()}`);
+    assert.equal(
+      Number(process.env.UV_THREADPOOL_SIZE) >= 16,
+      true,
+      "enough threads for a torrent's whole announce list to resolve at once"
+    );
+
+    process.env.UV_THREADPOOL_SIZE = "8";
+    await import(`../bin/thread-pool.js?stated=${Date.now()}`);
+    assert.equal(process.env.UV_THREADPOOL_SIZE, "8", "a stated size is the deployment's to choose");
+  } finally {
+    if (previous === undefined) {
+      delete process.env.UV_THREADPOOL_SIZE;
+    } else {
+      process.env.UV_THREADPOOL_SIZE = previous;
+    }
+  }
+});
+
+test("the entry point imports it before anything that could create the pool", async () => {
+  const cli = await readFile(path.join(here, "..", "bin", "cli.js"), "utf8");
+  const imports = [...cli.matchAll(/^import\s.*?from\s+["'](.+?)["'];|^import\s+["'](.+?)["'];/gm)]
+    .map((match) => match[1] ?? match[2]);
+
+  assert.equal(
+    imports[0],
+    "./thread-pool.js",
+    "a module's imports run before its body, so this cannot be a statement in cli.js"
+  );
+});

package/test/timeline.test.js

@@ -1,84 +1,84 @@
-/**
- * @file Where a file is cut is a fact about the FILE, held once.
- *
- * Every quality step of one film has to be cut at exactly the same times, and
- * every session serving it has to publish the same playlist. That agreement was
- * arranged by COPYING — a table handed to each new session at creation — and it
- * drifted twice in the field: 0.6-2.9 s between two sessions of one film on
- * 2026-08-17, and segments arriving a uniform 2.002 s before the times the
- * playlist named for them on 2026-08-20, four times what a player bridges.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Timeline, Timelines } from "../services/encode/output/Timeline.js";
-
-/**
- * @returns {Timeline}
- */
-function fourSecondGrid() {
-  // Only what is per grid. The container's own keyframe table, how exact it is,
-  // which container answered and how long the file runs are facts of the FILE
-  // and live on the source file — stating them here stated nothing.
-  return new Timeline({
-    boundaries: [0, 4, 8, 12, 16],
-    cutGrid: "keyframe"
-  });
-}
-
-test("the table the player was given does not move when the live one is corrected", () => {
-  const timeline = fourSecondGrid();
-
-  // A produced segment says where the file's cut really is. That corrects what
-  // a run will cut at; it must never correct what the player was told, because
-  // the player places a fragment by the playlist it holds and that text was
-  // written once.
-  timeline.boundaries[2] = 8.5;
-
-  assert.equal(timeline.liveStartOf(2), 8.5);
-  assert.equal(timeline.publishedStartOf(2), 8);
-});
-
-test("one file and grid answer with one table, whoever asks", () => {
-  const timelines = new Timelines();
-  const key = Timelines.keyFor("torrent:abc", 0, "keyframe");
-
-  const first = timelines.get(key, fourSecondGrid);
-  const second = timelines.get(key, () => {
-    throw new Error("a second table would be the drift this exists to remove");
-  });
-
-  assert.equal(second, first);
-  // A correction found by one session is seen by every other, because there is
-  // nothing to keep in step.
-  first.boundaries[1] = 4.5;
-  assert.equal(second.liveStartOf(1), 4.5);
-});
-
-test("the same file cut two ways is two tables", () => {
-  const timelines = new Timelines();
-  const onKeyframes = timelines.get(Timelines.keyFor("torrent:abc", 0, "keyframe"), fourSecondGrid);
-  const onTheEvenGrid = timelines.get(Timelines.keyFor("torrent:abc", 0, "uniform"), fourSecondGrid);
-
-  assert.notEqual(onTheEvenGrid, onKeyframes);
-});
-
-test("which segment holds a moment", () => {
-  const timeline = fourSecondGrid();
-
-  assert.equal(timeline.indexForTime(0), 0);
-  assert.equal(timeline.indexForTime(3.9), 0);
-  assert.equal(timeline.indexForTime(4), 1);
-  assert.equal(timeline.indexForTime(15.9), 3);
-  assert.equal(timeline.indexForTime(99), 3, "past the end is the last segment, not an error");
-});
-
-test("a timeline nobody holds is dropped", () => {
-  const timelines = new Timelines();
-  const kept = timelines.get(Timelines.keyFor("torrent:abc", 0, "keyframe"), fourSecondGrid);
-  timelines.get(Timelines.keyFor("torrent:xyz", 0, "keyframe"), fourSecondGrid);
-
-  assert.equal(timelines.size, 2);
-  assert.equal(timelines.forgetUnused(new Set([kept])), 1);
-  assert.equal(timelines.size, 1);
-});
+/**
+ * @file Where a file is cut is a fact about the FILE, held once.
+ *
+ * Every quality step of one film has to be cut at exactly the same times, and
+ * every session serving it has to publish the same playlist. That agreement was
+ * arranged by COPYING — a table handed to each new session at creation — and it
+ * drifted twice in the field: 0.6-2.9 s between two sessions of one film on
+ * 2026-08-17, and segments arriving a uniform 2.002 s before the times the
+ * playlist named for them on 2026-08-20, four times what a player bridges.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Timeline, Timelines } from "../services/encode/output/Timeline.js";
+
+/**
+ * @returns {Timeline}
+ */
+function fourSecondGrid() {
+  // Only what is per grid. The container's own keyframe table, how exact it is,
+  // which container answered and how long the file runs are facts of the FILE
+  // and live on the source file — stating them here stated nothing.
+  return new Timeline({
+    boundaries: [0, 4, 8, 12, 16],
+    cutGrid: "keyframe"
+  });
+}
+
+test("the table the player was given does not move when the live one is corrected", () => {
+  const timeline = fourSecondGrid();
+
+  // A produced segment says where the file's cut really is. That corrects what
+  // a run will cut at; it must never correct what the player was told, because
+  // the player places a fragment by the playlist it holds and that text was
+  // written once.
+  timeline.boundaries[2] = 8.5;
+
+  assert.equal(timeline.liveStartOf(2), 8.5);
+  assert.equal(timeline.publishedStartOf(2), 8);
+});
+
+test("one file and grid answer with one table, whoever asks", () => {
+  const timelines = new Timelines();
+  const key = Timelines.keyFor("torrent:abc", 0, "keyframe");
+
+  const first = timelines.get(key, fourSecondGrid);
+  const second = timelines.get(key, () => {
+    throw new Error("a second table would be the drift this exists to remove");
+  });
+
+  assert.equal(second, first);
+  // A correction found by one session is seen by every other, because there is
+  // nothing to keep in step.
+  first.boundaries[1] = 4.5;
+  assert.equal(second.liveStartOf(1), 4.5);
+});
+
+test("the same file cut two ways is two tables", () => {
+  const timelines = new Timelines();
+  const onKeyframes = timelines.get(Timelines.keyFor("torrent:abc", 0, "keyframe"), fourSecondGrid);
+  const onTheEvenGrid = timelines.get(Timelines.keyFor("torrent:abc", 0, "uniform"), fourSecondGrid);
+
+  assert.notEqual(onTheEvenGrid, onKeyframes);
+});
+
+test("which segment holds a moment", () => {
+  const timeline = fourSecondGrid();
+
+  assert.equal(timeline.indexForTime(0), 0);
+  assert.equal(timeline.indexForTime(3.9), 0);
+  assert.equal(timeline.indexForTime(4), 1);
+  assert.equal(timeline.indexForTime(15.9), 3);
+  assert.equal(timeline.indexForTime(99), 3, "past the end is the last segment, not an error");
+});
+
+test("a timeline nobody holds is dropped", () => {
+  const timelines = new Timelines();
+  const kept = timelines.get(Timelines.keyFor("torrent:abc", 0, "keyframe"), fourSecondGrid);
+  timelines.get(Timelines.keyFor("torrent:xyz", 0, "keyframe"), fourSecondGrid);
+
+  assert.equal(timelines.size, 2);
+  assert.equal(timelines.forgetUnused(new Set([kept])), 1);
+  assert.equal(timelines.size, 1);
+});