@torrent-tv/proxy 2.89.17 → 2.89.19

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

@@ -1,200 +0,0 @@
-/**
- * @file Two axes, kept apart: the framing a CONTAINER puts round a cue, and the
- * markup the CODEC puts inside it.
- *
- * Field 2026-09-03, an English track of an embedded `.mkv`: the viewer was
- * shown `21,0,Default,,0000,0000,0000,,I am the powerful Demon King of the
- * Sixth Heaven.` — the whole dialogue row, fields and all. The cause was one
- * function doing both jobs and deciding which framing it held by counting
- * commas: it expected the ten fields a row has in a FILE, a Matroska block
- * carries nine, so it returned the row untouched.
- *
- * What each check here pins is therefore not "ASS is stripped" but "the right
- * side answers": the container takes off what it put on, and the codec takes
- * off what it put in. The case that matters most is the last one — the same
- * line of dialogue, stored two ways, coming out identical.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-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 =
-  "21,0,Default,,0000,0000,0000,,I am the powerful Demon King of the Sixth Heaven. Good... Evil...";
-
-function block(text) {
-  return Buffer.from(text, "utf8");
-}
-
-test("a Matroska ASS block gives up its text and nothing else", () => {
-  // Nine fields exactly, and no comma in the dialogue: the shape that defeated
-  // the old field count and put the whole row on the viewer's screen.
-  assert.equal(
-    MatroskaContainer.cueTextOf(block(FIELD_BLOCK), "S_TEXT/ASS"),
-    "I am the powerful Demon King of the Sixth Heaven. Good... Evil..."
-  );
-});
-
-test("commas in the dialogue are dialogue, not fields", () => {
-  assert.equal(
-    MatroskaContainer.cueTextOf(block("7,0,Main,Nobunaga,0000,0000,0000,,Yes, of course, my lord"), "S_TEXT/ASS"),
-    "Yes, of course, my lord"
-  );
-});
-
-test("an SSA block is framed the same way as an ASS one", () => {
-  // SSA writes `Marked` where ASS writes `Layer`; the count is the same and so
-  // is the answer.
-  assert.equal(
-    MatroskaContainer.cueTextOf(block("3,,Default,,0000,0000,0000,,Toujours rien."), "S_TEXT/SSA"),
-    "Toujours rien."
-  );
-});
-
-test("a row too short to hold a text field yields nothing to show", () => {
-  assert.equal(MatroskaContainer.cueTextOf(block("21,0,Default,,0000"), "S_TEXT/ASS"), "");
-  assert.equal(MatroskaContainer.cueTextOf(block("21,0,Default,,0000,0000,0000,,"), "S_TEXT/ASS"), "");
-});
-
-test("a plain-text Matroska block is not touched at all", () => {
-  // `S_TEXT/UTF8` has no framing: the block IS the text, commas included.
-  const line = "Yes, of course, my lord";
-  assert.equal(MatroskaContainer.cueTextOf(block(line), "S_TEXT/UTF8"), line);
-  assert.equal(MatroskaContainer.cueTextOf(block(line), "S_TEXT/WEBVTT"), line);
-});
-
-test("an MP4 sample is unframed by the MP4, length prefix and all", () => {
-  const text = Buffer.from("Yes, of course, my lord", "utf8");
-  const sample = Buffer.concat([Buffer.from([0x00, text.length]), text]);
-  assert.equal(Mp4Container.cueTextOf(sample, "tx3g"), "Yes, of course, my lord");
-});
-
-test("a container with no framing of its own refuses to guess", () => {
-  // AVI declares no subtitle tracks, so no cue can reach it. If one ever did,
-  // the answer must be an error and not a guess at somebody else's framing.
-  assert.throws(() => AviContainer.cueTextOf(block("x"), "S_TEXT/ASS"), /cueTextOf not implemented/);
-});
-
-test("ASS markup is taken off wherever the text came from", () => {
-  assert.equal(TextSubtitleTrack.plainTextOf("{\\pos(640,620)}Hello{\\i1} there{\\i0}", "S_TEXT/ASS"), "Hello there");
-  assert.equal(TextSubtitleTrack.plainTextOf("First\\NSecond\\nThird", "S_TEXT/ASS"), "First\nSecond\nThird");
-  assert.equal(TextSubtitleTrack.plainTextOf("Wide\\hspace", "S_TEXT/ASS"), "Wide space");
-  // The same text under a codec that has no such markup keeps its characters.
-  assert.equal(TextSubtitleTrack.plainTextOf("{\\pos(1,2)}Hello", "S_TEXT/UTF8"), "{\\pos(1,2)}Hello");
-});
-
-test("a codec is known by any of its names", () => {
-  assert.equal(TextSubtitleTrack.markupKindOf("S_TEXT/ASS"), MarkupKind.ASS);
-  assert.equal(TextSubtitleTrack.markupKindOf(".ASS"), MarkupKind.ASS);
-  assert.equal(TextSubtitleTrack.markupKindOf("S_TEXT/UTF8"), MarkupKind.NONE);
-  assert.equal(TextSubtitleTrack.markupKindOf("wvtt"), MarkupKind.NONE);
-  // Unknown: shown as it is, rather than refused.
-  assert.equal(TextSubtitleTrack.markupKindOf("S_TEXT/SOMETHING"), MarkupKind.NONE);
-});
-
-test("a text track answers for its own markup", () => {
-  const track = new TextSubtitleTrack({ trackNumber: 3, declaredIndex: 0, codecId: "S_TEXT/ASS" });
-  assert.equal(track.markupKind, MarkupKind.ASS);
-  assert.equal(track.plainText("{\\be1}Готовьте лучников"), "Готовьте лучников");
-});
-
-test("a file states its own column order and is obeyed", () => {
-  // This `Format:` has no `Name` column, so the text is the ninth field and not
-  // the tenth. A reader that assumed a position would take the effect field as
-  // the line — which is the file-side form of the defect this suite is about.
-  const file = [
-    "[Script Info]",
-    "ScriptType: v4.00+",
-    "[Events]",
-    "Format: Layer, Start, End, Style, MarginL, MarginR, MarginV, Effect, Text",
-    "Dialogue: 0,0:00:01.00,0:00:03.50,Default,0000,0000,0000,,Ты видишь их?",
-    ""
-  ].join("\n");
-
-  const cues = new SubtitleFileContainer({ extension: ".ass" }).readCues(file);
-  assert.deepEqual(cues, [{ startSeconds: 1, endSeconds: 3.5, text: "Ты видишь их?" }]);
-});
-
-test("a dialogue row before any Format line is not guessed at", () => {
-  const file = ["[Events]", "Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,Ignored", ""].join("\n");
-  assert.deepEqual(new SubtitleFileContainer({ extension: ".ass" }).readCues(file), []);
-});
-
-test("SubRip cues keep their words and lose their numbering", () => {
-  const file = [
-    "1",
-    "00:00:01,000 --> 00:00:03,500",
-    "Ты видишь их?",
-    "",
-    "2",
-    "00:01:02,250 --> 00:01:04,000",
-    "<i>Да.</i>",
-    "Но не столько вижу.",
-    ""
-  ].join("\n");
-
-  const cues = new SubtitleFileContainer({ extension: ".srt" }).readCues(file);
-  assert.deepEqual(cues, [
-    { startSeconds: 1, endSeconds: 3.5, text: "Ты видишь их?" },
-    { startSeconds: 62.25, endSeconds: 64, text: "<i>Да.</i>\nНо не столько вижу." }
-  ]);
-});
-
-test("a SubRip file with no blank line between cues does not swallow the ordinal", () => {
-  const file = [
-    "1",
-    "00:00:01,000 --> 00:00:02,000",
-    "First",
-    "2",
-    "00:00:03,000 --> 00:00:04,000",
-    "Second"
-  ].join("\n");
-
-  const cues = new SubtitleFileContainer({ extension: ".srt" }).readCues(file);
-  assert.deepEqual(cues.map((cue) => cue.text), ["First", "Second"]);
-});
-
-test("a WebVTT file is passed through, not taken apart", () => {
-  const file = "WEBVTT\n\nSTYLE\n::cue { color: yellow }\n\nintro\n00:00:01.000 --> 00:00:02.000\nHello\n";
-  assert.equal(SubtitleFileContainer.toVtt(file, ".vtt"), file);
-  assert.equal(new SubtitleFileContainer({ extension: ".vtt" }).readCues(file), null);
-});
-
-test("a format nothing here reads is refused rather than mangled", () => {
-  assert.equal(SubtitleFileContainer.toVtt("whatever", ".sup"), null);
-  assert.equal(SubtitleFileContainer.toVtt("whatever", ".ttml"), null);
-});
-
-test("one line of dialogue, two framings, one result", () => {
-  // The whole point of the split. The same ASS line stored in a Matroska block
-  // and in a file must reach the viewer identically, and neither path may know
-  // anything about the other.
-  const spoken = "Yes, of course, my lord";
-  const markup = `{\\pos(640,620)}${spoken}`;
-
-  const fromBlock = TextSubtitleTrack.finalizeCues(
-    [{
-      startSeconds: 1,
-      endSeconds: 3,
-      text: MatroskaContainer.cueTextOf(block(`21,0,Default,,0000,0000,0000,,${markup}`), "S_TEXT/ASS")
-    }],
-    "S_TEXT/ASS"
-  );
-
-  const fromFile = new SubtitleFileContainer({ extension: ".ass" }).readCues([
-    "[Events]",
-    "Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text",
-    `Dialogue: 0,0:00:01.00,0:00:03.00,Default,,0000,0000,0000,,${markup}`,
-    ""
-  ].join("\n"));
-
-  assert.equal(fromBlock[0].text, spoken);
-  assert.equal(TextSubtitleTrack.finalizeCues(fromFile, ".ass")[0].text, spoken);
-  assert.equal(TextSubtitleTrack.cuesToVtt(fromBlock, "S_TEXT/ASS"), TextSubtitleTrack.cuesToVtt(fromFile, ".ass"));
-});

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

@@ -1,102 +0,0 @@
-/**
- * @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
- * 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 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.
- *
- * 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/media/SubtitleOrchestrator.js";
-import { cuesHeldFor } from "../services/media/SubtitleCues.js";
-import { heldFileOver } from "./helpers/held-file.js";
-
-/** A torrent that cannot say which of itself is downloaded. */
-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 walk, and the walk's own figures travel back", async () => {
-  const asked = [];
-  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,
-        track: { codecId: "S_TEXT/ASS", codecPrivate: "", language: "" }
-      };
-    }
-  };
-
-  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);
-  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. 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 },
-          { startSeconds: 81.7, endSeconds: 84.0, text: "two", seq: 31 }
-        ],
-        coveredClusters: 12,
-        indexedClusters: 283,
-        track: { codecId: "S_TEXT/ASS", codecPrivate: "", language: "" }
-      };
-    }
-  };
-  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("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);
-  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. 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

@@ -1,385 +0,0 @@
-/**
- * @file What comes out of a real cluster walk, end to end.
- *
- * This is the check the walk never had. Everything around it was covered — the
- * numbering a track is asked for by, the framing one cue's bytes carry, the
- * thread a pull is answered on — and the walk itself, six hundred lines of it,
- * had none: a file is built here with real clusters carrying real blocks, and
- * the cues that come back out are stated exactly. Two field defects landed on
- * this path in one week; a move of this code without a check that would catch a
- * regression is a change nobody can verify.
- *
- * The four things asserted are the four the walk exists for: the text of each
- * cue with its times, the found-order cursor a browser follows, the rule that
- * only already-downloaded clusters are read, and the rule that one walk fills
- * every track of the file.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Readable } from "node:stream";
-
-import { cuesHeldFor, warmSubtitleCues, forgetSubtitles, subtitleTracksOf } from "../services/media/SubtitleCues.js";
-import { heldFileOver } from "./helpers/held-file.js";
-
-const ID_EBML = 0x1a45dfa3;
-const ID_SEGMENT = 0x18538067;
-const ID_SEEK_HEAD = 0x114d9b74;
-const ID_SEEK = 0x4dbb;
-const ID_SEEK_ID = 0x53ab;
-const ID_SEEK_POSITION = 0x53ac;
-const ID_INFO = 0x1549a966;
-const ID_TIMESTAMP_SCALE = 0x2ad7b1;
-const ID_TRACKS = 0x1654ae6b;
-const ID_TRACK_ENTRY = 0xae;
-const ID_TRACK_NUMBER = 0xd7;
-const ID_TRACK_TYPE = 0x83;
-const ID_CODEC_ID = 0x86;
-const ID_LANGUAGE = 0x22b59c;
-const ID_CUES = 0x1c53bb6b;
-const ID_CUE_POINT = 0xbb;
-const ID_CUE_TIME = 0xb3;
-const ID_CUE_TRACK_POSITIONS = 0xb7;
-const ID_CUE_TRACK = 0xf7;
-const ID_CUE_CLUSTER_POSITION = 0xf1;
-const ID_CLUSTER = 0x1f43b675;
-const ID_TIMESTAMP = 0xe7;
-const ID_BLOCK_GROUP = 0xa0;
-const ID_BLOCK = 0xa1;
-const ID_BLOCK_DURATION = 0x9b;
-
-function idBytes(id) {
-  const bytes = [];
-  let rest = id;
-  while (rest > 0) {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  }
-  return Buffer.from(bytes);
-}
-
-/** A four-byte size: a valid variable-length integer whatever the payload. */
-function sizeBytes(size) {
-  const buffer = Buffer.alloc(4);
-  buffer.writeUInt32BE(size, 0);
-  buffer[0] |= 0x10;
-  return buffer;
-}
-
-function element(id, payload) {
-  return Buffer.concat([idBytes(id), sizeBytes(payload.length), payload]);
-}
-
-function uintElement(id, value) {
-  const bytes = [];
-  let rest = value;
-  do {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  } while (rest > 0);
-  return element(id, Buffer.from(bytes));
-}
-
-function stringElement(id, value) {
-  return element(id, Buffer.from(value, "utf8"));
-}
-
-/** A fixed four bytes, so a table measured twice comes out the same length. */
-function uint32Element(id, value) {
-  const payload = Buffer.alloc(4);
-  payload.writeUInt32BE(value, 0);
-  return element(id, payload);
-}
-
-function trackEntry({ number, type, codecId, language }) {
-  return element(ID_TRACK_ENTRY, Buffer.concat([
-    uintElement(ID_TRACK_NUMBER, number),
-    uintElement(ID_TRACK_TYPE, type),
-    stringElement(ID_CODEC_ID, codecId),
-    stringElement(ID_LANGUAGE, language)
-  ]));
-}
-
-/**
- * One cue, as a BlockGroup so it can carry its own duration.
- *
- * @param {{ track: number, relativeTicks: number, durationTicks: number, text: string }} params
- * @returns {Buffer}
- */
-function cueBlock({ track, relativeTicks, durationTicks, text }) {
-  const header = Buffer.alloc(4);
-  header[0] = 0x80 | track; // track numbers under 128 are one byte, marker set
-  header.writeInt16BE(relativeTicks, 1);
-  header[3] = 0;
-  const block = element(ID_BLOCK, Buffer.concat([header, Buffer.from(text, "utf8")]));
-  return element(ID_BLOCK_GROUP, Buffer.concat([block, uintElement(ID_BLOCK_DURATION, durationTicks)]));
-}
-
-/**
- * A file with two text tracks and two clusters, each carrying a line for each
- * track.
- *
- * Track 2 is `S_TEXT/UTF8`, whose block payload IS the text. Track 3 is
- * `S_TEXT/ASS`, whose payload is the dialogue row without its `Dialogue:`
- * header — eight comma-separated fields and then the words, which is what
- * Matroska states and what the framing rule has to strip.
- *
- * @returns {{ file: Buffer, clusterAt: number[] }}
- */
-function buildFile() {
-  const info = element(ID_INFO, uintElement(ID_TIMESTAMP_SCALE, 1_000_000));
-  const tracks = element(ID_TRACKS, Buffer.concat([
-    trackEntry({ number: 1, type: 1, codecId: "V_MPEG4/ISO/AVC", language: "und" }),
-    trackEntry({ number: 2, type: 17, codecId: "S_TEXT/UTF8", language: "eng" }),
-    trackEntry({ number: 3, type: 17, codecId: "S_TEXT/ASS", language: "rus" })
-  ]));
-
-  const clusterOne = element(ID_CLUSTER, Buffer.concat([
-    uintElement(ID_TIMESTAMP, 1000),
-    cueBlock({ track: 2, relativeTicks: 0, durationTicks: 2000, text: "First English line" }),
-    cueBlock({
-      track: 3,
-      relativeTicks: 500,
-      durationTicks: 1500,
-      // ReadOrder, Layer, Style, Name, MarginL, MarginR, MarginV, Effect,
-      // then the text — the Dialogue row without its header and its timestamps.
-      text: "1,0,Default,,0000,0000,0000,,Первая русская строка"
-    })
-  ]));
-  const clusterTwo = element(ID_CLUSTER, Buffer.concat([
-    uintElement(ID_TIMESTAMP, 10_000),
-    cueBlock({ track: 2, relativeTicks: 0, durationTicks: 1000, text: "Second English line" }),
-    cueBlock({
-      track: 3,
-      relativeTicks: 250,
-      durationTicks: 1000,
-      text: "2,0,Default,,0000,0000,0000,,Вторая, с запятой"
-    })
-  ]));
-
-  const cuesWith = (firstAt, secondAt) => element(ID_CUES, Buffer.concat([
-    element(ID_CUE_POINT, Buffer.concat([
-      uintElement(ID_CUE_TIME, 1000),
-      element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
-        uintElement(ID_CUE_TRACK, 2),
-        uint32Element(ID_CUE_CLUSTER_POSITION, firstAt)
-      ])),
-      element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
-        uintElement(ID_CUE_TRACK, 3),
-        uint32Element(ID_CUE_CLUSTER_POSITION, firstAt)
-      ]))
-    ])),
-    element(ID_CUE_POINT, Buffer.concat([
-      uintElement(ID_CUE_TIME, 10_000),
-      element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
-        uintElement(ID_CUE_TRACK, 2),
-        uint32Element(ID_CUE_CLUSTER_POSITION, secondAt)
-      ])),
-      element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
-        uintElement(ID_CUE_TRACK, 3),
-        uint32Element(ID_CUE_CLUSTER_POSITION, secondAt)
-      ]))
-    ]))
-  ]));
-
-  const seekEntry = (targetId, position) => element(ID_SEEK, Buffer.concat([
-    element(ID_SEEK_ID, idBytes(targetId)),
-    uint32Element(ID_SEEK_POSITION, position)
-  ]));
-  const seekHeadWith = (infoAt, tracksAt, cuesAt) => element(ID_SEEK_HEAD, Buffer.concat([
-    seekEntry(ID_INFO, infoAt),
-    seekEntry(ID_TRACKS, tracksAt),
-    seekEntry(ID_CUES, cuesAt)
-  ]));
-
-  const headLength = seekHeadWith(0, 0, 0).length;
-  const infoAt = headLength;
-  const tracksAt = infoAt + info.length;
-  const cuesAt = tracksAt + tracks.length;
-  const firstClusterAt = cuesAt + cuesWith(0, 0).length;
-  const secondClusterAt = firstClusterAt + clusterOne.length;
-
-  const segmentPayload = Buffer.concat([
-    seekHeadWith(infoAt, tracksAt, cuesAt),
-    info,
-    tracks,
-    cuesWith(firstClusterAt, secondClusterAt),
-    clusterOne,
-    clusterTwo
-  ]);
-  const ebml = element(ID_EBML, Buffer.from([0x42, 0x86, 0x81, 0x01]));
-  const segment = element(ID_SEGMENT, segmentPayload);
-  const segmentDataOffset = ebml.length + segment.length - segmentPayload.length;
-  return {
-    file: Buffer.concat([ebml, segment]),
-    clusterAt: [segmentDataOffset + firstClusterAt, segmentDataOffset + secondClusterAt]
-  };
-}
-
-/**
- * A torrent over one file, holding whichever pieces the caller says.
- *
- * @param {Buffer} bytes
- * @param {(index: number) => boolean} [holds] - Whether a piece is downloaded.
- * @returns {{ torrent: object, reads: Array<{ start: number, end: number }>, pieceLength: number }}
- */
-function torrentOver(bytes, holds = () => true) {
-  const pieceLength = 64;
-  const reads = [];
-  const file = {
-    name: "film.mkv",
-    length: bytes.length,
-    offset: 0,
-    createReadStream({ start = 0, end = bytes.length - 1 } = {}) {
-      reads.push({ start, end });
-      return Readable.from((async function* chunks() {
-        await new Promise((resolve) => setImmediate(resolve));
-        yield bytes.subarray(start, end + 1);
-      })());
-    }
-  };
-  return {
-    reads,
-    pieceLength,
-    torrent: {
-      name: "film",
-      pieceLength,
-      bitfield: { get: (index) => holds(index) },
-      files: [file]
-    }
-  };
-}
-
-test("a walk of a downloaded file gives up every cue, unframed, with its times", async () => {
-  const { file } = buildFile();
-  const { torrent } = torrentOver(file);
-  const sourceKey = "a".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    const plain = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
-    assert.deepEqual(
-      plain.cues.map((cue) => [cue.startSeconds, cue.endSeconds, cue.text]),
-      [
-        [1, 3, "First English line"],
-        [10, 11, "Second English line"]
-      ]
-    );
-
-    const ass = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 3);
-    assert.deepEqual(
-      ass.cues.map((cue) => [cue.startSeconds, cue.endSeconds, cue.text]),
-      [
-        [1.5, 3, "Первая русская строка"],
-        [10.25, 11.25, "Вторая, с запятой"]
-      ],
-      "the eight fields Matroska puts before the text are the container's framing, not the words"
-    );
-  } finally {
-    forgetSubtitles(sourceKey);
-  }
-});
-
-test("the cursor is the order cues were FOUND, and it never repeats", async () => {
-  const { file } = buildFile();
-  const { torrent } = torrentOver(file);
-  const sourceKey = "b".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    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");
-  } finally {
-    forgetSubtitles(sourceKey);
-  }
-});
-
-test("a cluster whose bytes are not downloaded is left for next time", async () => {
-  const { file, clusterAt } = buildFile();
-  // Everything except the pieces the SECOND cluster sits in.
-  const { torrent, pieceLength } = torrentOver(file, (index) => index * pieceLength < clusterAt[1]);
-  const sourceKey = "c".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    const held = await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
-    assert.deepEqual(
-      held.cues.map((cue) => cue.text),
-      ["First English line"],
-      "the downloaded cluster is read and the other is not — nothing is asked of the swarm"
-    );
-    assert.equal(held.coveredClusters, 1);
-    assert.equal(held.indexedClusters, 2, "the file states two, and one is not here yet");
-  } finally {
-    forgetSubtitles(sourceKey);
-  }
-});
-
-test("one walk fills every track, and a second call reads no cluster again", async () => {
-  const { file, clusterAt } = buildFile();
-  const { torrent, reads } = torrentOver(file);
-  const sourceKey = "d".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    await cuesHeldFor(heldFileOver(torrent, 0, sourceKey), 2);
-    const clusterReads = reads.filter((range) => clusterAt.includes(range.start)).length;
-
-    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,
-      clusterReads,
-      "asking for the second track reads no cluster a second time"
-    );
-  } finally {
-    forgetSubtitles(sourceKey);
-  }
-});
-
-test("the warm pass walks nothing for a file nobody has asked about", async () => {
-  const { file } = buildFile();
-  const { torrent, reads } = torrentOver(file);
-  const sourceKey = "9".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    assert.deepEqual(await warmSubtitleCues(heldFileOver(torrent, 0, sourceKey)), []);
-    assert.equal(reads.length, 0, "neither its head nor its Cues table was read for it");
-  } finally {
-    forgetSubtitles(sourceKey);
-  }
-});
-
-test("the warm pass reports what is new, by the number the browser knows", async () => {
-  const { file } = buildFile();
-  const { torrent } = torrentOver(file);
-  const sourceKey = "e".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    // A browser asking for a track is what makes a file one the walk follows.
-    await subtitleTracksOf(heldFileOver(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(heldFileOver(torrent, 0, sourceKey));
-    assert.deepEqual(again, [], "nothing is new the second time round");
-  } finally {
-    forgetSubtitles(sourceKey);
-  }
-});
-
-test("a torrent that cannot say which pieces it holds is refused, not answered emptily", async () => {
-  const { file } = buildFile();
-  const { torrent } = torrentOver(file);
-  const sourceKey = "f".repeat(40);
-  forgetSubtitles(sourceKey);
-  try {
-    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 {
-    forgetSubtitles(sourceKey);
-  }
-});