@torrent-tv/proxy 2.72.2 → 2.73.1

package/test/container-media-info.test.js

@@ -0,0 +1,228 @@
+/**
+ * @file What a file declares about ITSELF — format, duration, and where its own
+ * timeline begins — read from its header by the container layer.
+ *
+ * These fixtures are built byte by byte rather than produced by ffmpeg, on
+ * purpose: a test that runs a real encoder measures the machine it runs on, and
+ * two such tests in this suite have failed four times in one day for exactly
+ * that reason (roadmap item 54). The numbers here are checked against ffmpeg
+ * ONCE, by hand, and the result is recorded rather than re-measured on every
+ * run — 2026-09-03, a Matroska file offset by 0.130435 s: ffmpeg reported
+ * `Duration: 00:00:02.13, start: 0.130000` and this reader answered
+ * `durationSeconds 2.131, startTimeSeconds 0.13`, which is the same number at
+ * the precision each prints. The same file as MP4: `start: 0.000000` from
+ * ffmpeg, 0 from this reader.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
+import { Mp4Container } from "../services/container/Mp4Container.js";
+import { AviContainer } from "../services/container/AviContainer.js";
+
+/**
+ * An EBML element: its id bytes, a four-byte size, then the payload.
+ *
+ * @param {number[]} idBytes
+ * @param {Buffer} payload
+ * @returns {Buffer}
+ */
+function ebml(idBytes, payload) {
+  const size = Buffer.alloc(4);
+  // Four-byte size form: `0001xxxx` in the leading byte marks the width.
+  size.writeUInt32BE(payload.length);
+  size[0] |= 0x10;
+  return Buffer.concat([Buffer.from(idBytes), size, payload]);
+}
+
+/** @param {number} value @param {number} bytes @returns {Buffer} */
+function uint(value, bytes) {
+  const out = Buffer.alloc(bytes);
+  out.writeUIntBE(value, 0, bytes);
+  return out;
+}
+
+/** @param {number} value @returns {Buffer} */
+function float64(value) {
+  const out = Buffer.alloc(8);
+  out.writeDoubleBE(value);
+  return out;
+}
+
+const ID_EBML_HEADER = [0x1a, 0x45, 0xdf, 0xa3];
+const ID_SEGMENT = [0x18, 0x53, 0x80, 0x67];
+const ID_SEEK_HEAD = [0x11, 0x4d, 0x9b, 0x74];
+const ID_SEEK = [0x4d, 0xbb];
+const ID_SEEK_ID = [0x53, 0xab];
+const ID_SEEK_POSITION = [0x53, 0xac];
+const ID_INFO = [0x15, 0x49, 0xa9, 0x66];
+const ID_TIMESTAMP_SCALE = [0x2a, 0xd7, 0xb1];
+const ID_DURATION = [0x44, 0x89];
+const ID_CLUSTER = [0x1f, 0x43, 0xb6, 0x75];
+const ID_TIMESTAMP = [0xe7];
+const ID_VOID = [0xec];
+
+/**
+ * A reader over a buffer, in the shape the container layer takes.
+ *
+ * @param {Buffer} bytes
+ * @returns {(start: number, end: number) => Promise<Buffer>}
+ */
+function readerOver(bytes) {
+  return async (start, end) => bytes.subarray(start, Math.min(end + 1, bytes.length));
+}
+
+test("a Matroska file states its duration in ticks and its start in the first cluster", async () => {
+  const info = ebml(ID_INFO, Buffer.concat([
+    ebml(ID_TIMESTAMP_SCALE, uint(1_000_000, 3)),
+    // 2131 ticks of a millisecond each.
+    ebml(ID_DURATION, float64(2131))
+  ]));
+  const cluster = ebml(ID_CLUSTER, ebml(ID_TIMESTAMP, uint(130, 1)));
+  const file = Buffer.concat([
+    ebml(ID_EBML_HEADER, Buffer.alloc(4)),
+    ebml(ID_SEGMENT, Buffer.concat([info, cluster]))
+  ]);
+
+  const container = new MatroskaContainer({ readRange: readerOver(file), fileSize: file.length });
+  const read = await container.readMediaInfo();
+
+  assert.equal(read.format, "matroska");
+  assert.ok(Math.abs(read.durationSeconds - 2.131) < 1e-9, `duration was ${read.durationSeconds}`);
+  assert.ok(Math.abs(read.startTimeSeconds - 0.13) < 1e-9, `start was ${read.startTimeSeconds}`);
+});
+
+test("a cluster past the head window is found through the SeekHead", async () => {
+  // Everything before the cluster is padded past the 64 KB the head read covers,
+  // which is the case this second path exists for: a file whose Tracks element
+  // is large enough to push the first cluster out of reach.
+  const info = ebml(ID_INFO, ebml(ID_TIMESTAMP_SCALE, uint(1_000_000, 3)));
+  const padding = ebml(ID_VOID, Buffer.alloc(70 * 1024));
+  const cluster = ebml(ID_CLUSTER, ebml(ID_TIMESTAMP, uint(2500, 2)));
+  // The SeekHead is written first, so its own length is known before the
+  // position it names can be computed — build it with a placeholder, measure,
+  // then write the real position.
+  const seekHeadFor = (position) => ebml(ID_SEEK_HEAD, ebml(ID_SEEK, Buffer.concat([
+    ebml(ID_SEEK_ID, Buffer.from(ID_CLUSTER)),
+    ebml(ID_SEEK_POSITION, uint(position, 4))
+  ])));
+  const seekHeadLength = seekHeadFor(0).length;
+  const clusterPosition = seekHeadLength + info.length + padding.length;
+  const segmentPayload = Buffer.concat([seekHeadFor(clusterPosition), info, padding, cluster]);
+  const file = Buffer.concat([
+    ebml(ID_EBML_HEADER, Buffer.alloc(4)),
+    ebml(ID_SEGMENT, segmentPayload)
+  ]);
+
+  const container = new MatroskaContainer({ readRange: readerOver(file), fileSize: file.length });
+  const read = await container.readMediaInfo();
+
+  assert.ok(Math.abs(read.startTimeSeconds - 2.5) < 1e-9, `start was ${read.startTimeSeconds}`);
+});
+
+test("a Matroska file that declares no duration says so, rather than saying zero", async () => {
+  const cluster = ebml(ID_CLUSTER, ebml(ID_TIMESTAMP, uint(0, 1)));
+  const file = Buffer.concat([
+    ebml(ID_EBML_HEADER, Buffer.alloc(4)),
+    ebml(ID_SEGMENT, cluster)
+  ]);
+
+  const container = new MatroskaContainer({ readRange: readerOver(file), fileSize: file.length });
+  const read = await container.readMediaInfo();
+
+  assert.equal(read.durationSeconds, null);
+  assert.equal(read.startTimeSeconds, 0);
+});
+
+/**
+ * An ISO/IEC 14496-12 box.
+ *
+ * @param {string} type
+ * @param {Buffer} payload
+ * @returns {Buffer}
+ */
+function box(type, payload) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(payload.length + 8);
+  header.write(type, 4, "latin1");
+  return Buffer.concat([header, payload]);
+}
+
+test("an MP4 states its duration in mvhd and its start in an empty edit", async () => {
+  const mvhd = box("mvhd", Buffer.concat([
+    Buffer.alloc(4), // version 0 + flags
+    Buffer.alloc(8), // creation, modification
+    uint(1000, 4), // timescale: ticks per second
+    uint(2000, 4), // duration: two seconds
+    Buffer.alloc(80)
+  ]));
+  const elst = box("elst", Buffer.concat([
+    Buffer.alloc(4), // version 0 + flags
+    uint(1, 4), // one entry
+    uint(130, 4), // segment_duration: 0.130 s at the movie timescale
+    Buffer.from([0xff, 0xff, 0xff, 0xff]), // media_time -1: an EMPTY edit
+    uint(0x00010000, 4) // media_rate 1.0
+  ]));
+  const trak = box("trak", box("edts", elst));
+  const file = Buffer.concat([
+    box("ftyp", Buffer.from("isom", "latin1")),
+    box("moov", Buffer.concat([mvhd, trak]))
+  ]);
+
+  const container = new Mp4Container({ readRange: readerOver(file), fileSize: file.length });
+  const read = await container.readMediaInfo();
+
+  assert.equal(read.format, "mp4");
+  assert.ok(Math.abs(read.durationSeconds - 2) < 1e-9, `duration was ${read.durationSeconds}`);
+  assert.ok(Math.abs(read.startTimeSeconds - 0.13) < 1e-9, `start was ${read.startTimeSeconds}`);
+});
+
+test("an MP4 with no edit list begins at zero, and that is an answer", async () => {
+  const mvhd = box("mvhd", Buffer.concat([
+    Buffer.alloc(4),
+    Buffer.alloc(8),
+    uint(600, 4),
+    uint(1200, 4),
+    Buffer.alloc(80)
+  ]));
+  const file = Buffer.concat([
+    box("ftyp", Buffer.from("isom", "latin1")),
+    box("moov", mvhd)
+  ]);
+
+  const container = new Mp4Container({ readRange: readerOver(file), fileSize: file.length });
+  const read = await container.readMediaInfo();
+
+  assert.ok(Math.abs(read.durationSeconds - 2) < 1e-9, `duration was ${read.durationSeconds}`);
+  assert.equal(read.startTimeSeconds, 0);
+});
+
+test("an AVI states its length as microseconds per frame times the frame count", async () => {
+  const avih = Buffer.concat([
+    Buffer.from("avih", "latin1"),
+    uint(56, 4),
+    Buffer.from(new Uint8Array(new Uint32Array([
+      40_000, // dwMicroSecPerFrame: 25 fps
+      0, 0, 0,
+      50 // dwTotalFrames: two seconds of them
+    ]).buffer)),
+    Buffer.alloc(36)
+  ]);
+  const file = Buffer.concat([
+    Buffer.from("RIFF", "latin1"),
+    uint(0, 4),
+    Buffer.from("AVI ", "latin1"),
+    Buffer.from("LIST", "latin1"),
+    uint(avih.length + 4, 4),
+    Buffer.from("hdrl", "latin1"),
+    avih
+  ]);
+
+  const container = new AviContainer({ readRange: readerOver(file), fileSize: file.length });
+  const read = await container.readMediaInfo();
+
+  assert.equal(read.format, "avi");
+  assert.ok(Math.abs(read.durationSeconds - 2) < 1e-9, `duration was ${read.durationSeconds}`);
+  assert.equal(read.startTimeSeconds, 0);
+});

package/test/resume-warm.test.js

@@ -0,0 +1,39 @@
+/**
+ * @file Where a viewer's resume position falls in the file, in bytes.
+ *
+ * The warm-up fetches a file's two edges, because that is what the codec probe
+ * reads. The region the VIEWER will resume at was asked for by nobody until the
+ * encoder opened its input — field 2026-09-03, 53 s after the Retry button on a
+ * cold torrent, and the piece it then needed took another 46.3 s to arrive.
+ * Turning the position into an offset is the only arithmetic in that path, so it
+ * is the only part with anything to get wrong.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { resumeByteOffset } from "../services/torrent-worker/container-tracks.js";
+
+test("a position halfway through a film is halfway through its file", () => {
+  assert.equal(resumeByteOffset(1000, 100, 50), 500);
+});
+
+test("the field case lands where the encoder went looking", () => {
+  // The measured session: 171.338 s into a 23:41 episode of 541 MB, and the
+  // read that blocked was at 63 MB.
+  const at = resumeByteOffset(541 * 1024 * 1024, 23 * 60 + 41, 171.338);
+  const megabytes = at / (1024 * 1024);
+  assert.ok(megabytes > 60 && megabytes < 68, `landed at ${megabytes.toFixed(1)}MB`);
+});
+
+test("a position past the end reads the end, rather than past it", () => {
+  const length = 1000;
+  const at = resumeByteOffset(length, 100, 10_000);
+  assert.equal(at, length - 1);
+});
+
+test("nothing is known, nothing is guessed", () => {
+  assert.equal(resumeByteOffset(0, 100, 50), 0, "no file length");
+  assert.equal(resumeByteOffset(1000, 0, 50), 0, "no duration — the container did not declare one");
+  assert.equal(resumeByteOffset(1000, 100, 0), 0, "the viewer is at the beginning, where the edges already are");
+});

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

@@ -0,0 +1,104 @@
+/**
+ * @file WHICH THREAD answers a pull for subtitle cues.
+ *
+ * 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
+ * found cues 1.5 s after the file was opened and pushed four batches — cursor 1
+ * to 31, covering everything up to 81.7 s — before the browser had subscribed.
+ * The browser's catch-up pull, which exists for exactly that case, answered a
+ * seven-byte `WEBVTT` with `x-subtitle-covered-clusters: 0` against 283
+ * 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.
+ *
+ * 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.
+ */
+
+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";
+
+/** The stand-in the main thread holds: a name, a file list, and no pieces. */
+function mainThreadTorrent() {
+  return {
+    infoHash: "0".repeat(40),
+    name: "[HorribleSubs] Drifters - 04 [1080p].mkv",
+    sourceKey: "a".repeat(40),
+    files: [{ name: "[HorribleSubs] Drifters - 04 [1080p].mkv", length: 567_535_843, createReadStream: () => { throw new Error("not reached"); } }]
+  };
+}
+
+test("a pull is answered by the thread that owns the torrent, not walked here", async () => {
+  const asked = [];
+  const pool = {
+    async getSubtitleCues(torrent, fileIndex, trackNumber) {
+      asked.push({ sourceKey: torrent.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: ""
+      };
+    }
+  };
+
+  const orchestrator = new SubtitleOrchestrator({ forget() {} });
+  const held = await orchestrator.getCues(pool, mainThreadTorrent(), 33, "a".repeat(40), 3);
+
+  assert.deepEqual(asked, [{ sourceKey: "a".repeat(40), fileIndex: 33, trackNumber: 3 }]);
+  assert.equal(held.cues.length, 1);
+  assert.equal(held.coveredClusters, 283, "the walk's own figure travels back, so the header cannot claim 0 of 283");
+  // The worker answers with the track's fields flat — only plain objects cross
+  // the boundary — and the caller reads them through `held.track`.
+  assert.equal(held.track.codecId, "S_TEXT/ASS");
+});
+
+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() {
+      return {
+        cues: [
+          { startSeconds: 5.4, endSeconds: 9.1, text: "one", seq: 1 },
+          { startSeconds: 81.7, endSeconds: 84.0, text: "two", seq: 31 }
+        ],
+        coveredClusters: 12,
+        indexedClusters: 283,
+        codecId: "S_TEXT/ASS",
+        codecPrivate: "",
+        language: ""
+      };
+    }
+  };
+  const orchestrator = new SubtitleOrchestrator({ forget() {} });
+  const held = await orchestrator.getCues(pool, 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 () => {
+  const orchestrator = new SubtitleOrchestrator({ forget() {} });
+  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);
+  assert.deepEqual(held, { cues: [], coveredClusters: 0, indexedClusters: 0, track: null });
+});

package/test/tail-duplication.test.js

@@ -60,7 +60,7 @@ test("the missing blocks are freed and asked of a second wire", () => {
 });
 
 test("at most one duplicate per wire, however long the tail", () => {
-  const target = piece(512, 40);
+  const target = piece(512, 16);
   const torrent = {
     pieces: [target],
     wires: [wire(), wire()],
@@ -73,7 +73,29 @@ test("at most one duplicate per wire, however long the tail", () => {
   assert.equal(target.cancelled.length, 2, "and no reservation is freed that nobody was asked for");
 });
 
-test("a wire whose pipeline is full ends the attempt", () => {
+test("a piece still arriving normally is not duplicated at all", () => {
+  // Forty blocks outstanding is not a tail, it is a piece in transit. Asking
+  // for a second copy of it would spend the shared link on bytes that are
+  // already on their way — which is the whole difference between this and the
+  // 2-14 blocks a blocked reader was measured waiting on.
+  const target = piece(512, 40);
+  const torrent = {
+    pieces: [target],
+    wires: [wire(), wire()],
+    _request: () => true
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 0);
+  assert.equal(target.cancelled.length, 0, "and nothing is freed either");
+});
+
+test("a wire whose pipeline is full does not end the attempt", () => {
+  // Pipelines are per wire, so one wire being full says nothing about the next.
+  // This used to stop the whole pass on the first refusal, on the stated
+  // reasoning that the remaining wires were "no emptier" — an assumption about
+  // other peers' queues that nothing measures.
   const target = piece(512, 5);
   const torrent = {
     pieces: [target],
@@ -88,11 +110,33 @@ test("a wire whose pipeline is full ends the attempt", () => {
   assert.equal(result.duplicated, 0);
   assert.equal(
     target.cancelled.length,
-    1,
-    "only the block that was actually offered is freed; the rest keep their reservations"
+    3,
+    "every wire was offered a block; a freed reservation nobody took is handed to whoever asks next"
   );
 });
 
+test("a refusal by one wire does not cost the block a faster wire would have taken", () => {
+  const target = piece(512, 3);
+  const placed = [];
+  const torrent = {
+    pieces: [target],
+    wires: [wire({ speed: 900_000 }), wire({ speed: 800_000 })],
+    _request: (wireAsked, index) => {
+      // The first wire is full; the second is not.
+      if (wireAsked === torrent.wires[0]) {
+        return false;
+      }
+      placed.push(index);
+      return true;
+    }
+  };
+
+  const result = duplicateTailFor(torrent, 0);
+
+  assert.equal(result.duplicated, 1);
+  assert.deepEqual(placed, [0], "the second wire was still asked");
+});
+
 test("a piece with nothing missing is left alone", () => {
   const target = piece(4, 0);
   const torrent = { pieces: [target], wires: [wire()], _request: () => true };