@torrent-tv/proxy 2.86.0 → 2.87.0

package/test/startup-readings.test.js

@@ -79,21 +79,26 @@ test("nothing about the machine is asked only of a software encoder", () => {
   }
 });
 
-test("the throughput benchmark is given the encoder that will actually run", () => {
+test("the calibration is given the encoder that will actually run, and software beside it", () => {
   const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
   assert.match(
     server,
-    /benchmarkSoftwarePresets\(\{[^}]*encoder: videoEncoder/,
-    "the benchmark is not told which encoder to measure"
+    /calibrateEncoder\(\{[^}]*encoder: videoEncoder/,
+    "the calibration is not told which encoder to measure"
+  );
+  assert.match(
+    server,
+    /calibrateEncoder\(\{[^}]*encoder: softwareDescriptor\(\)/,
+    "software, which a failing device falls back to, is not calibrated"
   );
 });
 
 test("a start and a stop are measured before any viewer, and reach the plan", () => {
   const server = readFileSync(path.join(HERE, "..", "server.js"), "utf8");
   assert.match(server, /await measureStartAndStop\(/, "nothing measures a start at startup");
-  assert.match(server, /\n    startStopCost,/, "the reading never reaches the session manager");
+  assert.match(server, /\n    startStopCost,/, "the reading never reaches the wiring of the encoding");
 
-  const manager = readFileSync(path.join(HERE, "..", "services", "hls-session-manager.js"), "utf8");
+  const manager = readFileSync(path.join(HERE, "..", "services", "server", "wire-outputs.js"), "utf8");
   assert.match(
     manager,
     /noteStartupCosts\(startStopCost\)/,

package/test/subtitle-cue-framing.test.js

@@ -18,11 +18,11 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { AviContainer } from "../services/container/AviContainer.js";
-import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
-import { Mp4Container } from "../services/container/Mp4Container.js";
-import { SubtitleFileContainer } from "../services/container/SubtitleFileContainer.js";
-import { MarkupKind, TextSubtitleTrack } from "../services/tracks/TextSubtitleTrack.js";
+import { AviContainer } from "../services/media/container/AviContainer.js";
+import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
+import { Mp4Container } from "../services/media/container/Mp4Container.js";
+import { SubtitleFileContainer } from "../services/media/container/SubtitleFileContainer.js";
+import { MarkupKind, TextSubtitleTrack } from "../services/media/tracks/TextSubtitleTrack.js";
 
 /** The line from the field report, as Matroska stores it. */
 const FIELD_BLOCK =

package/test/subtitle-cue-source.test.js

@@ -1,5 +1,5 @@
 /**
- * @file WHICH THREAD answers a pull for subtitle cues.
+ * @file WHAT answers a pull for subtitle cues — the walk, and nothing else.
  *
  * Field 2026-09-03, on `[HorribleSubs] Drifters - 04 [1080p].mkv`. The file had
  * been downloaded in an earlier sitting, so the torrent worker's cluster walk
@@ -10,25 +10,27 @@
  * indexed. So the viewer watched the first 82 s with no subtitles and the rest
  * of the episode with them.
  *
- * The pull ran on the MAIN thread, where the torrent is a stand-in carrying
- * `infoHash`, `name` and a `files` list — no `bitfield`, no `pieceLength`. The
- * walk decides what it may read from those two, so every range read as "not
- * downloaded", nothing was walked, and an empty document came back. An empty
- * document is also the right answer for a file that holds no cues yet, which is
- * why nothing reported a failure.
+ * The pull was answered by something that could not read pieces. Whatever a
+ * pull is handed, the walk decides what it may read from it, so every range
+ * read as "not downloaded", nothing was walked, and an empty document came
+ * back. An empty document is also the right answer for a file that holds no
+ * cues yet, which is why nothing reported a failure.
  *
- * These checks pin the two halves of the repair: the pull is addressed to the
- * thread that owns the torrent, and a walk asked of a torrent that cannot say
- * what it holds says so rather than answering emptily.
+ * The thread stopped being the distinction on 2026-09-15 — the walk runs beside
+ * the sessions now, handed which byte ranges of a file are downloaded whole —
+ * but the property it was standing for did not: a pull is answered by the SAME
+ * walk that pushes, its own figures travel back, and anything that cannot read
+ * says so rather than answering emptily.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { SubtitleOrchestrator } from "../services/orchestrators/SubtitleOrchestrator.js";
-import { cuesHeldFor } from "../services/torrent-worker/subtitle-cues.js";
+import { SubtitleOrchestrator } from "../services/media/SubtitleOrchestrator.js";
+import { cuesHeldFor } from "../services/media/SubtitleCues.js";
+import { heldFileOver } from "./helpers/held-file.js";
 
-/** The stand-in the main thread holds: a name, a file list, and no pieces. */
+/** A torrent that cannot say which of itself is downloaded. */
 function mainThreadTorrent() {
   return {
     infoHash: "0".repeat(40),
@@ -38,24 +40,22 @@ function mainThreadTorrent() {
   };
 }
 
-test("a pull is answered by the thread that owns the torrent, not walked here", async () => {
+test("a pull is answered by the walk, and the walk's own figures travel back", async () => {
   const asked = [];
-  const pool = {
-    async getSubtitleCues(torrent, fileIndex, trackNumber) {
-      asked.push({ sourceKey: torrent.sourceKey, fileIndex, trackNumber });
+  const cues = {
+    async held(torrent, fileIndex, sourceKey, trackNumber) {
+      asked.push({ sourceKey, fileIndex, trackNumber });
       return {
         cues: [{ startSeconds: 5.4, endSeconds: 9.1, text: "So what if you brought them over?", seq: 1 }],
         coveredClusters: 283,
         indexedClusters: 283,
-        codecId: "S_TEXT/ASS",
-        codecPrivate: "",
-        language: ""
+        track: { codecId: "S_TEXT/ASS", codecPrivate: "", language: "" }
       };
     }
   };
 
-  const orchestrator = new SubtitleOrchestrator({ forget() {} });
-  const held = await orchestrator.getCues(pool, mainThreadTorrent(), 33, "a".repeat(40), 3);
+  const orchestrator = new SubtitleOrchestrator({ forget() {} }, cues);
+  const held = await orchestrator.getCues(mainThreadTorrent(), 33, "a".repeat(40), 3);
 
   assert.deepEqual(asked, [{ sourceKey: "a".repeat(40), fileIndex: 33, trackNumber: 3 }]);
   assert.equal(held.cues.length, 1);
@@ -66,11 +66,11 @@ test("a pull is answered by the thread that owns the torrent, not walked here",
 });
 
 test("the cursor of a pulled cue is the found-order the worker assigned", async () => {
-  // The browser mixes cursors from pulls and pushes. Walking a second time on
-  // another thread would start a second `seq` counter and the two would not be
-  // comparable, which is the deeper reason the pull is not served locally.
-  const pool = {
-    async getSubtitleCues() {
+  // The browser mixes cursors from pulls and pushes. A second walk would start
+  // a second `seq` counter and the two would not be comparable — which is why
+  // both ends go through the one walk, with one per-file state.
+  const cues = {
+    async held() {
       return {
         cues: [
           { startSeconds: 5.4, endSeconds: 9.1, text: "one", seq: 1 },
@@ -78,27 +78,25 @@ test("the cursor of a pulled cue is the found-order the worker assigned", async
         ],
         coveredClusters: 12,
         indexedClusters: 283,
-        codecId: "S_TEXT/ASS",
-        codecPrivate: "",
-        language: ""
+        track: { codecId: "S_TEXT/ASS", codecPrivate: "", language: "" }
       };
     }
   };
-  const orchestrator = new SubtitleOrchestrator({ forget() {} });
-  const held = await orchestrator.getCues(pool, mainThreadTorrent(), 33, "a".repeat(40), 3);
+  const orchestrator = new SubtitleOrchestrator({ forget() {} }, cues);
+  const held = await orchestrator.getCues(mainThreadTorrent(), 33, "a".repeat(40), 3);
   assert.deepEqual(held.cues.map((cue) => cue.seq), [1, 31]);
 });
 
-test("a pool with no channel to the worker is refused, not answered emptily", async () => {
+test("an orchestrator with no walk is refused, not answered emptily", async () => {
   const orchestrator = new SubtitleOrchestrator({ forget() {} });
-  const held = await orchestrator.getCues({}, mainThreadTorrent(), 33, "a".repeat(40), 3);
+  const held = await orchestrator.getCues(mainThreadTorrent(), 33, "a".repeat(40), 3);
   assert.deepEqual(held, { cues: [], coveredClusters: 0, indexedClusters: 0, track: null });
 });
 
 test("the walk refuses a torrent that cannot say which pieces it holds", async () => {
-  // Called directly, as the main thread used to call it. Without this guard the
-  // answer is an empty list indistinguishable from a file with no cues, which
-  // is what hid the defect for a whole session.
-  const held = await cuesHeldFor(mainThreadTorrent(), 33, "b".repeat(40), 3);
+  // Called directly. Without this guard the answer is an empty list
+  // indistinguishable from a file with no cues, which is what hid the defect
+  // for a whole session.
+  const held = await cuesHeldFor(heldFileOver(mainThreadTorrent(), 33, "b".repeat(40)), 3);
   assert.deepEqual(held, { cues: [], coveredClusters: 0, indexedClusters: 0, track: null });
 });

package/test/subtitle-cue-walk.test.js

@@ -19,7 +19,8 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { Readable } from "node:stream";
 
-import { cuesHeldFor, warmSubtitleCues, forgetSubtitles } from "../services/torrent-worker/subtitle-cues.js";
+import { cuesHeldFor, warmSubtitleCues, forgetSubtitles } from "../services/media/SubtitleCues.js";
+import { heldFileOver } from "./helpers/held-file.js";
 
 const ID_EBML = 0x1a45dfa3;
 const ID_SEGMENT = 0x18538067;
@@ -255,7 +256,7 @@ test("a walk of a downloaded file gives up every cue, unframed, with its times",
   const sourceKey = "a".repeat(40);
   forgetSubtitles(sourceKey);
   try {
-    const plain = await cuesHeldFor(torrent, 0, sourceKey, 2);
+    const plain = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
     assert.deepEqual(
       plain.cues.map((cue) => [cue.startSeconds, cue.endSeconds, cue.text]),
       [
@@ -264,7 +265,7 @@ test("a walk of a downloaded file gives up every cue, unframed, with its times",
       ]
     );
 
-    const ass = await cuesHeldFor(torrent, 0, sourceKey, 3);
+    const ass = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 3);
     assert.deepEqual(
       ass.cues.map((cue) => [cue.startSeconds, cue.endSeconds, cue.text]),
       [
@@ -284,7 +285,7 @@ test("the cursor is the order cues were FOUND, and it never repeats", async () =
   const sourceKey = "b".repeat(40);
   forgetSubtitles(sourceKey);
   try {
-    const held = await cuesHeldFor(torrent, 0, sourceKey, 2);
+    const held = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
     const cursors = held.cues.map((cue) => cue.seq);
     assert.deepEqual(cursors, [1, 2], "two cues found, in the order they were read");
     assert.equal(new Set(cursors).size, cursors.length, "no cue shares a cursor with another");
@@ -300,7 +301,7 @@ test("a cluster whose bytes are not downloaded is left for next time", async ()
   const sourceKey = "c".repeat(40);
   forgetSubtitles(sourceKey);
   try {
-    const held = await cuesHeldFor(torrent, 0, sourceKey, 2);
+    const held = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
     assert.deepEqual(
       held.cues.map((cue) => cue.text),
       ["First English line"],
@@ -319,10 +320,10 @@ test("one walk fills every track, and a second call reads no cluster again", asy
   const sourceKey = "d".repeat(40);
   forgetSubtitles(sourceKey);
   try {
-    await cuesHeldFor(torrent, 0, sourceKey, 2);
+    await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
     const clusterReads = reads.filter((range) => clusterAt.includes(range.start)).length;
 
-    const other = await cuesHeldFor(torrent, 0, sourceKey, 3);
+    const other = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 3);
     assert.equal(other.cues.length, 2, "the other track was filled by the same walk");
     assert.equal(
       reads.filter((range) => clusterAt.includes(range.start)).length,
@@ -340,14 +341,14 @@ test("the warm pass reports what is new, by the number the browser knows", async
   const sourceKey = "e".repeat(40);
   forgetSubtitles(sourceKey);
   try {
-    const first = await warmSubtitleCues(torrent, 0, sourceKey);
+    const first = await warmSubtitleCues(heldFileOver(torrent, 0, sourceKey));
     assert.deepEqual(
       first.map((entry) => [entry.trackIndex, entry.cues.length, entry.language]).sort(),
       [[0, 2, "eng"], [1, 2, "rus"]].sort(),
       "both text tracks gained two cues, numbered as ffmpeg numbers them"
     );
 
-    const again = await warmSubtitleCues(torrent, 0, sourceKey);
+    const again = await warmSubtitleCues(heldFileOver(torrent, 0, sourceKey));
     assert.deepEqual(again, [], "nothing is new the second time round");
   } finally {
     forgetSubtitles(sourceKey);
@@ -360,7 +361,7 @@ test("a torrent that cannot say which pieces it holds is refused, not answered e
   const sourceKey = "f".repeat(40);
   forgetSubtitles(sourceKey);
   try {
-    const held = await cuesHeldFor({ ...torrent, bitfield: null }, 0, sourceKey, 2);
+    const held = await cuesHeldFor({ ...heldFileOver(torrent, 0, sourceKey), heldRanges: null }, 2);
     assert.deepEqual(held.cues, []);
     assert.equal(held.track, null, "the answer says nothing was read, not that there is nothing");
   } finally {

package/test/subtitle-defaults.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { Container } from "../services/container/Container.js";
+import { Container } from "../services/media/container/Container.js";
 
 test("a flag the container wrote is carried through, and one it did not is not", () => {
   const banner = [

package/test/subtitle-language.test.js

@@ -24,10 +24,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { detectLanguage } from "../services/tracks/language-detect.js";
-import { SubtitleFileContainer } from "../services/container/SubtitleFileContainer.js";
-import { TextSubtitleTrack } from "../services/tracks/TextSubtitleTrack.js";
-import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
+import { detectLanguage } from "../services/media/tracks/language-detect.js";
+import { SubtitleFileContainer } from "../services/media/container/SubtitleFileContainer.js";
+import { TextSubtitleTrack } from "../services/media/tracks/TextSubtitleTrack.js";
+import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
 
 /** Varied Russian dialogue, the length a few minutes of an episode carries. */
 const RUSSIAN_DIALOGUE = [

package/test/subtitle-track-numbering.test.js

@@ -20,8 +20,9 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { Readable } from "node:stream";
-import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
-import { cuesHeldFor, forgetSubtitles } from "../services/torrent-worker/subtitle-cues.js";
+import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
+import { cuesHeldFor, forgetSubtitles } from "../services/media/SubtitleCues.js";
+import { heldFileOver } from "./helpers/held-file.js";
 
 const ID_EBML = 0x1a45dfa3;
 const ID_SEGMENT = 0x18538067;
@@ -263,8 +264,8 @@ test("two walks of one file at the same time read each cluster once", async () =
   // Both text tracks at once, which is what the warmup does on every verified
   // piece and every three seconds.
   const [first, second] = await Promise.all([
-    cuesHeldFor(torrent, 0, sourceKey, 3),
-    cuesHeldFor(torrent, 0, sourceKey, 4)
+    cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 3),
+    cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 4)
   ]);
 
   assert.equal(first.coveredClusters, 1, "the cluster the table names was walked");

package/test/supply-margin.test.js

@@ -10,7 +10,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { minimumBufferFrom, requiredSpeedFrom } from "../services/supply-margin.js";
+import { minimumBufferFrom, requiredSpeedFrom } from "../services/torrent/supply-margin.js";
 
 /**
  * Waits spaced by `intervalSec`, each lasting `waitSec`.

package/test/swarm-follows-readers.test.js

@@ -32,9 +32,9 @@ import {
   rejoinSwarm,
   stateFileEdges,
   swarmDecisionFor
-} from "../services/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/download/registry.js";
-import { Urgency } from "../services/demand/index.js";
+} from "../services/torrent/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
+import { Urgency } from "../services/torrent/demand/index.js";
 
 /**
  * A torrent that records what was done to it. Only the surface the rule

package/test/swarm-reach.test.js

@@ -19,7 +19,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { bestAnnounce, describeSwarmReach, secondsToFirstPeer } from "../services/torrent-pool.js";
+import { bestAnnounce, describeSwarmReach, secondsToFirstPeer } from "../services/torrent/torrent-pool.js";
 
 test("connected and known are separate numbers", () => {
   const torrent = { wires: [{}, {}], _peersLength: 7, _numQueued: 4 };

package/test/swarm-selection.test.js

@@ -9,9 +9,9 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { DemandRegister } from "../services/demand/DemandRegister.js";
-import { Urgency } from "../services/demand/Urgency.js";
-import { SwarmSelection } from "../services/download/SwarmSelection.js";
+import { DemandRegister } from "../services/torrent/demand/DemandRegister.js";
+import { Urgency } from "../services/torrent/demand/Urgency.js";
+import { SwarmSelection } from "../services/torrent/download/SwarmSelection.js";
 
 const PIECE = 1024;
 

package/test/tail-duplication.test.js

@@ -11,7 +11,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { duplicateTailFor } from "../services/torrent-worker/fastest-wires.js";
+import { duplicateTailFor } from "../services/torrent/worker/fastest-wires.js";
 
 /** A piece with `chunks` blocks, of which `missing` at the end are absent. */
 function piece(chunks, missing) {

package/test/the-channel-has-both-ends.test.js

@@ -0,0 +1,91 @@
+/**
+ * @file Every call across the thread boundary has something to land on.
+ *
+ * The boundary is three files that have to agree, and nothing made them:
+ * `protocol.js` names the commands, `worker.js` answers them, `client.js` asks,
+ * and `pool-adapter.js` is what the main thread calls. A mismatch anywhere in
+ * that chain is invisible to every other check in this repository, because a
+ * unit test of either end alone passes and the failure needs a real worker.
+ *
+ * It was not hypothetical. Removing three commands on 2026-09-15 took an
+ * unrelated neighbour with them — `client.fillFile`, which the adapter went on
+ * calling — and left two adapter methods calling commands that no longer
+ * existed. One of those two is the browser's own subtitle request, and it did
+ * not even throw where anybody would see it: the orchestrator caught the error
+ * and answered an EMPTY document, which is indistinguishable from a file that
+ * genuinely holds no cues. That is the exact failure the whole subtitle path is
+ * written to avoid, and it would have reached the field.
+ *
+ * These are structural because the property is: there is no input that makes a
+ * call land on a method that is not there.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } 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");
+}
+
+/**
+ * Names a file defines at the top level of a class: methods, and fields it
+ * assigns to itself. Both are callable or readable from outside.
+ *
+ * @param {string} text
+ * @returns {Set<string>}
+ */
+function membersOf(text) {
+  const names = new Set();
+  for (const match of text.matchAll(/^\s{2}(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?([a-zA-Z#][a-zA-Z0-9]*)\s*[(=]/gm)) {
+    names.add(match[1]);
+  }
+  // Fields a constructor or a method assigns rather than declares.
+  for (const match of text.matchAll(/this\.([a-zA-Z][a-zA-Z0-9]*)\s*=/g)) {
+    names.add(match[1]);
+  }
+  return names;
+}
+
+test("every client method the adapter calls exists", () => {
+  const have = membersOf(source("client.js"));
+  const used = [...source("pool-adapter.js").matchAll(/#client\.([a-zA-Z][a-zA-Z0-9]*)/g)].map((m) => m[1]);
+
+  assert.deepEqual([...new Set(used)].filter((name) => !have.has(name)), []);
+});
+
+test("every command the client sends is answered by the worker", () => {
+  const protocol = source("protocol.js");
+  const answered = new Set([...source("worker.js").matchAll(/case Command\.([A-Z_]+):/g)].map((m) => m[1]));
+  const sent = [...source("client.js").matchAll(/Command\.([A-Z_]+)/g)].map((m) => m[1]);
+
+  const unanswered = [...new Set(sent)].filter((name) => !answered.has(name));
+  assert.deepEqual(unanswered, [], "a command nobody answers waits for a reply that never comes");
+
+  const undeclared = [...new Set(sent)].filter((name) => !protocol.includes(`  ${name}:`));
+  assert.deepEqual(undeclared, [], "and one the protocol does not name is `undefined` on the wire");
+});
+
+test("every event the worker posts is received somewhere on the main thread", () => {
+  // TWO receivers, and they answer different shapes. `channel.js` matches the
+  // replies to a request by its id — a result, an error, a chunk of a body —
+  // while `client.js` has a `case` for each event that belongs to nobody's
+  // request. An event handled by neither is a fact announced into silence.
+  const receiving = `${source("client.js")}
+${source("channel.js")}`;
+  const handled = new Set([
+    ...[...receiving.matchAll(/case Event\.([A-Z_]+):/g)].map((m) => m[1]),
+    ...[...receiving.matchAll(/message\.type === Event\.([A-Z_]+)/g)].map((m) => m[1])
+  ]);
+  const posted = [...source("worker.js").matchAll(/type:\s*Event\.([A-Z_]+)/g)].map((m) => m[1]);
+
+  assert.deepEqual([...new Set(posted)].filter((name) => !handled.has(name)), []);
+});

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

@@ -0,0 +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\)/);
+});

package/test/thread-pool.test.js

@@ -21,7 +21,7 @@ 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(`../services/thread-pool.js?first=${Date.now()}`);
+    await import(`../bin/thread-pool.js?first=${Date.now()}`);
     assert.equal(
       Number(process.env.UV_THREADPOOL_SIZE) >= 16,
       true,
@@ -29,7 +29,7 @@ test("the pool is set, and left alone when the deployment states its own", async
     );
 
     process.env.UV_THREADPOOL_SIZE = "8";
-    await import(`../services/thread-pool.js?stated=${Date.now()}`);
+    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) {
@@ -47,7 +47,7 @@ test("the entry point imports it before anything that could create the pool", as
 
   assert.equal(
     imports[0],
-    "../services/thread-pool.js",
+    "./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

@@ -11,7 +11,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Timeline, Timelines } from "../services/output/Timeline.js";
+import { Timeline, Timelines } from "../services/encode/output/Timeline.js";
 
 /**
  * @returns {Timeline}
@@ -73,17 +73,6 @@ test("which segment holds a moment", () => {
   assert.equal(timeline.indexForTime(99), 3, "past the end is the last segment, not an error");
 });
 
-test("a fresh table starts with an empty tally of how well its index matched", () => {
-  const timeline = fourSecondGrid();
-
-  // The tally is a fact about the FILE and its index: asked per session it
-  // would be answered a different number of times for one film depending on
-  // how many people happened to watch it.
-  assert.equal(timeline.indexCheck.checked, 0);
-  assert.equal(timeline.indexCheck.disagreed, 0);
-  assert.equal(timeline.indexCheck.firstDisagreementIndex, -1);
-});
-
 test("a timeline nobody holds is dropped", () => {
   const timelines = new Timelines();
   const kept = timelines.get(Timelines.keyFor("torrent:abc", 0, "keyframe"), fourSecondGrid);

package/test/torrent-cost.test.js

@@ -8,7 +8,7 @@
  */
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { baseDrawFrom, costPerMegabyteFrom } from "../services/torrent-cost.js";
+import { baseDrawFrom, costPerMegabyteFrom } from "../services/encode/torrent-cost.js";
 
 test("the base draw is the share of a core spent with nothing to do", () => {
   assert.equal(baseDrawFrom({ cpuSeconds: 0.5, elapsedSeconds: 5 }), 0.1);