@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/manager-surface.test.js

@@ -1,291 +0,0 @@
-/**
- * @file What the HTTP layer asks of the components, checked from the HTTP layer.
- *
- * Written as the net under the dismantling of `hls-session-manager.js`, which
- * was 9608 lines and 142 methods and is now gone: its members are methods of
- * the components that own them, wired by `services/server/wire-outputs.js`.
- * Most tests that build those components name something INSIDE them — a field,
- * a fake output shaped the way one happens to be shaped — so they move when the
- * code moves, and a test that moves with the code cannot say the code still
- * works.
- *
- * This one is derived from the other side: from what the HTTP layer asks of
- * the components. That contract does not move. A route calling a member that no longer exists
- * is the exact failure a nine-step move risks, and it is silent — Fastify
- * answers 500 at runtime, months later, on a path no unit test walks.
- *
- * So the first check READS `routes/` and `server.js` rather than listing what
- * the manager has. It cannot go stale: adding a call to a route adds it to the
- * requirement, and removing the member it names breaks this test the same
- * minute.
- *
- * The second is a characteristic record rather than a judgement: what the
- * progress report carries today. Eighteen figures reach the page from it and
- * nothing on this side of the wire knows which of them the page needs, so the
- * honest statement is "these are the ones there were" — the point being that a
- * move must not change them, not that they are the right ones.
- *
- * Every manager here has a store root of its own, for the reason
- * `helpers/manager.js` records.
- */
-
-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";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { managerWithOwnStore } from "./helpers/manager.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { Output } from "../services/encode/output/Output.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const PROXY = path.join(HERE, "..");
-const SESSION_ID = "aaaaaaaabbbbcccc";
-/** The components the HTTP layer is handed. */
-const COMPONENTS = ["serving", "viewerRequests", "renditions", "lifecycle", "quality", "outputs", "hostTimings", "viewers", "encodeRuns"];
-
-/**
- * Every `.js` file under a directory, at any depth.
- *
- * @param {string} dir
- * @returns {string[]}
- */
-function jsFilesUnder(dir) {
-  /** @type {string[]} */
-  const found = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      found.push(...jsFilesUnder(full));
-      continue;
-    }
-    if (entry.name.endsWith(".js")) {
-      found.push(full);
-    }
-  }
-  return found;
-}
-
-/**
- * What the HTTP layer asks of each component, read from the HTTP layer.
- *
- * Deliberately not a list kept here: a list is a second statement of the same
- * fact, and the two drift. The callers are the statement. A route names the
- * component it was handed (`serving.getFileStream`); `server.js` names it
- * through what the wiring returned (`outputParts.serving.getFileStream`).
- *
- * @returns {Map<string, string[]>} `component.member` to the files that ask for it.
- */
-function membersTheHttpLayerCalls() {
-  /** @type {Map<string, string[]>} */
-  const asked = new Map();
-  const sources = [path.join(PROXY, "server.js"), ...jsFilesUnder(path.join(PROXY, "routes"))];
-  const pattern = new RegExp(String.raw`\b(${COMPONENTS.join("|")})\.([A-Za-z][A-Za-z0-9]*)\(`, "g");
-  for (const file of sources) {
-    const text = readFileSync(file, "utf8");
-    for (const match of text.matchAll(pattern)) {
-      const asking = `${match[1]}.${match[2]}`;
-      const where = asked.get(asking) ?? [];
-      where.push(path.relative(PROXY, file));
-      asked.set(asking, where);
-    }
-  }
-  return asked;
-}
-
-/**
- * A manager with nothing running behind it, over a store of its own.
- *
- * Its two timers are unref'd, so nothing here keeps the process alive.
- *
- * @returns {object}
- */
-function bareManager() {
-  return managerWithOwnStore().manager;
-}
-
-/**
- * A session shaped like a live one, with no encoder behind it.
- *
- * @param {{ id?: string }} [params]
- * @returns {object}
- */
-function fakeSession({ id = SESSION_ID } = {}) {
-  return {
-    id,
-    spec: outputSpec({ cutGrid: "keyframe", audioSeparate: true }),
-    outputKey: "surface:fmt=fmp4:grid=kf@0:video-only:v=0/copy",
-    dirPath: path.join(PROXY, "test", "does-not-exist"),
-    file: new SourceFile({ sourceKey: "torrent:abc", fileIndex: 0, name: "video.mkv" })
-      .learn({ width: 1920, height: 1080 }),
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 11 }, (_, index) => index * 4),
-      cutGrid: "keyframe"
-    }),
-    segmentFormat: fmp4Format,
-    output: new Output({
-      encodeWidth: 0,
-      encodeHeight: 0,
-      outputFps: 24,
-      softwarePreset: null,
-      applyTonemap: false
-    }),
-    transcodeVideo: false,
-    transcodeAudio: true,
-    audioTrackIndex: 0,
-    audioSourceTrackIndex: 0,
-    useSyntheticPlaylist: true,
-    playlistText: "#EXTM3U\n",
-    segmentCount: 10,
-    progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0 }
-  };
-}
-
-test("every call the HTTP layer makes is answered", () => {
-  const parts = bareManager();
-  const asked = membersTheHttpLayerCalls();
-  // If this ever reads zero the extraction has broken, and the test would then
-  // pass by asking nothing at all.
-  assert.ok(asked.size >= 15, `expected the HTTP layer to ask for members, found ${asked.size}`);
-
-  const missing = [];
-  for (const [asking, callers] of asked) {
-    const [component, member] = asking.split(".");
-    if (!(parts[component] && member in parts[component])) {
-      missing.push(`${asking} (asked by ${[...new Set(callers)].join(", ")})`);
-    }
-  }
-  assert.deepEqual(missing, [], `the HTTP layer calls members no component has:\n${missing.join("\n")}`);
-});
-
-test("the progress report keeps every figure it carries today", async () => {
-  const manager = bareManager();
-  manager.outputs.set(SESSION_ID, fakeSession());
-  const progress = await manager.viewerRequests.getSessionProgress(SESSION_ID, "viewer-one");
-  assert.ok(progress, "a live session has a progress report");
-
-  // A characteristic record: what the page is given now. The claim is "a move
-  // did not change this", never "this is the right set".
-  const carried = [
-    "sessionId",
-    "state",
-    "minimumBufferSeconds",
-    "processedSeconds",
-    "inputBytes",
-    "startPositionSeconds",
-    "totalSeconds",
-    "percent",
-    "remainingSeconds",
-    "segmentDurationSec",
-    "currentHeight",
-    "offeredHeights",
-    "requestedHeight",
-    "expectedSessionCreateMs",
-    "expectedFirstSegmentMs",
-    "updatedAt",
-    "error"
-  ];
-  const absent = carried.filter((key) => !(key in progress));
-  assert.deepEqual(absent, [], `the progress report lost ${absent.join(", ")}`);
-  assert.equal(progress.sessionId, SESSION_ID);
-});
-
-test("a session that is not there is answered, not invented", async () => {
-  const manager = bareManager();
-  const absent = "ffffffffffffffff";
-
-  assert.equal(await manager.viewerRequests.getSessionProgress(absent), null);
-  assert.equal((await manager.serving.getFileStream(absent, "segment-00000.mp4")).kind, "not-found");
-  // A name no session could have must be refused before anything touches the
-  // disk with it.
-  assert.equal((await manager.serving.getFileStream("../../etc", "segment-00000.mp4")).kind, "not-found");
-});
-
-test("what a viewer states about themselves is kept and answered", () => {
-  const manager = bareManager();
-  manager.outputs.set(SESSION_ID, fakeSession());
-
-  // Nine public members had no test of any kind before the dismantling began,
-  // and six of them are the viewer's own facts — the ones that move into
-  // `viewer/`. They are cheap to state and were simply never stated.
-
-  // A SEEK DOES ONE THING: it puts the viewer where they now are. Recorded
-  // here because it used to do eleven, and because the one remaining effect is
-  // what every reading of a viewer's position now rests on.
-  assert.equal(manager.viewerRequests.requestSeek(SESSION_ID, 120, "viewer-one"), true);
-  assert.equal(manager.viewerRequests.viewerPositionOf(SESSION_ID, "viewer-one"), 120);
-  assert.equal(manager.viewerRequests.requestSeek("no-such-session", 120, "viewer-one"), false);
-
-  // A seek wakes requests held on each output this viewer watches so each one
-  // can check whether it is still the segment this viewer needs.
-  assert.equal(manager.serving.seekEpoch(SESSION_ID), 1, "a seek invalidates waits on the watched output");
-  assert.equal(manager.serving.seekEpoch("no-such-session"), 0);
-
-  manager.encodeRuns.noteInputBytes(SESSION_ID, 4096);
-  manager.encodeRuns.noteInputBytes(SESSION_ID, 1024);
-  assert.equal(
-    manager.encodeRuns.inputBytesOf(manager.outputs.get(SESSION_ID)),
-    5120,
-    "input bytes accumulate at their owner"
-  );
-
-  // A far fragment is a reading and must never throw, whatever the player says.
-  manager.serving.recordFragmentFar(SESSION_ID, {
-    sn: 40, track: "video", fragStartSec: 200, bufferEndSec: 130, currentTimeSec: 128
-  });
-  manager.serving.recordFragmentFar("no-such-session", { sn: 1, track: "video" });
-});
-
-test("a session nobody has touched is disposed, one that is being watched is not", async () => {
-  const manager = bareManager();
-  const stale = fakeSession({ id: "1111111111111111" });
-  const fresh = fakeSession({ id: "2222222222222222" });
-  // Older than any TTL this manager could carry, without naming one here: the
-  // period is the manager's business and this test is about the rule.
-  manager.outputs.set(stale.id, stale);
-  manager.outputs.set(fresh.id, fresh);
-  manager.outputs.touch(stale, Date.now() - (2 * 60 * 60 * 1000));
-
-  await manager.lifecycle.cleanupExpired();
-
-  assert.equal(manager.outputs.has(stale.id), false, "an untouched session goes");
-  assert.equal("state" in stale, false, "removal from the registry is the only lifetime fact");
-  assert.equal(manager.outputs.has(fresh.id), true, "a session just read stays");
-});
-
-test("what a file declares and what this host could offer are answered without a session", () => {
-  const manager = bareManager();
-  const session = fakeSession();
-  manager.outputs.set(SESSION_ID, session);
-
-  // `declaredTracks` reads the session's own record and must answer even when
-  // nothing has probed the file yet.
-  assert.doesNotThrow(() => manager.renditions.declaredTracks(session));
-
-  // The offer is predicted before any session exists — that is its whole point,
-  // the menu being complete from the moment a file is opened.
-  assert.equal(manager.quality.predictOfferedHeights({ height: 0, width: 0 }), null, "an unknown picture offers nothing");
-  const offered = manager.quality.predictOfferedHeights({
-    height: 1080, width: 1920, fps: 24, sourceKey: "torrent:abc", fileIndex: 0
-  });
-  // TWO ANSWERS, not one: what this host can hold when the picture is copied,
-  // and what it can hold when it is re-encoded. The browser decides which of
-  // the two applies, because whether it can play the source is its own fact.
-  assert.ok(Array.isArray(offered?.copy), "the copied branch gets a list");
-  assert.ok(Array.isArray(offered?.transcode), "the re-encoded branch gets a list");
-});
-
-test("a segment name that is not one is refused", async () => {
-  const manager = bareManager();
-  manager.outputs.set(SESSION_ID, fakeSession());
-
-  for (const name of ["../key.txt", "segment-00000.mp4/../../x", "making-0-00000.mp4"]) {
-    const answer = await manager.serving.getFileStream(SESSION_ID, name);
-    assert.equal(answer.kind, "not-found", `${name} must not be servable`);
-  }
-});

package/test/matroska-cluster-discovery.test.js

@@ -1,323 +0,0 @@
-/**
- * @file Where a Matroska file's clusters are, found from what is downloaded —
- * and what is read out of them, in what order, within what memory.
- *
- * RFC 9559 §22.1 says each subtitle frame SHOULD be named by the Cues table, and
- * a file may have no Cues at all. Until 2026-10-01 such a file showed no
- * subtitles ever. Every check builds a file element by element, says which
- * byte ranges are "downloaded", and runs passes of the walk the way arriving
- * pieces would. Fakes only.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
-import {
-  ID,
-  buildMatroska,
-  clusterData,
-  cueBlock,
-  element,
-  heldOver,
-  idBytes,
-  pictureBlock,
-  readerOver,
-  trackEntry
-} from "./helpers/matroska-file.js";
-
-const TRACKS = [
-  trackEntry({ number: 1, type: 1, codecId: "V_MPEG4/ISO/AVC", language: "jpn" }),
-  trackEntry({ number: 2, type: 17, codecId: "S_TEXT/UTF8" })
-];
-
-/** One cluster a second-and-a-bit long with one line on track 2 and a picture. */
-function plainCluster(ticks, text, picture = Buffer.alloc(16, 7)) {
-  return {
-    ticks,
-    data: clusterData({
-      ticks,
-      blocks: [pictureBlock({ track: 1, payload: picture }), cueBlock({ track: 2, relativeTicks: 0, durationTicks: 900, text })]
-    })
-  };
-}
-
-async function planOf(file) {
-  const { read } = readerOver(file);
-  const container = new MatroskaContainer({ readRange: read, fileSize: file.length });
-  return { container, plan: await container.readSubtitlePlan() };
-}
-
-async function pass(container, plan, progress, held) {
-  const result = await container.readHeldCues(plan, plan.tracks[0], progress, held);
-  return { ...result, texts: (result.found.get(2) ?? []).map((cue) => cue.text) };
-}
-
-test("a Cues table that names only the picture still leads to every subtitle line", async () => {
-  const { file } = buildMatroska({
-    tracks: TRACKS,
-    cues: [1],
-    clusters: [plainCluster(0, "a"), plainCluster(10_000, "b"), plainCluster(20_000, "c")]
-  });
-  const { container, plan } = await planOf(file);
-  assert.equal(plan.cuesState, "complete");
-  assert.deepEqual(plan.tracks[0].clusterPositions, [], "the table names no cluster for the subtitle track");
-  const result = await pass(container, plan, {}, heldOver(file, [[0, file.length - 1]]));
-  assert.deepEqual(result.texts.sort(), ["a", "b", "c"]);
-});
-
-test("with no Cues, the chain reads what is joined up and the search finds what lies past a gap", async () => {
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [plainCluster(0, "a"), plainCluster(10_000, "b"), plainCluster(20_000, "c"), plainCluster(30_000, "d")]
-  });
-  const { container, plan } = await planOf(file);
-  assert.equal(plan.cuesState, "absent");
-  const progress = {};
-  const gap = [clusterAt[2], clusterAt[3] - 1];
-  const first = await pass(container, plan, progress, heldOver(file, [[0, gap[0] - 1], [gap[1] + 1, file.length - 1]]));
-  assert.deepEqual(first.texts.sort(), ["a", "b", "d"], "the third cluster is not downloaded; the fourth is found by searching");
-  assert.equal(first.stats.fromSearch, 1);
-
-  const second = await pass(container, plan, progress, heldOver(file, [[0, file.length - 1]]));
-  assert.deepEqual(second.texts, ["c"], "the gap filled: the chain reaches the third, and nothing is read twice");
-  assert.deepEqual(second.withdrawn, [], "the search was right, so nothing is taken back");
-});
-
-test("the walk reads the structure of a cluster, not the frames of its picture", async () => {
-  // Pictures of 64 KB: a walk that read them would move them all.
-  const picture = Buffer.alloc(64 * 1024, 7);
-  const { file } = buildMatroska({
-    tracks: TRACKS,
-    cues: [1],
-    clusters: [plainCluster(0, "a", picture), plainCluster(10_000, "b", picture), plainCluster(20_000, "c", picture)]
-  });
-  const { container, plan } = await planOf(file);
-  const reads = [];
-  const held = heldOver(file, [[0, file.length - 1]], { portionBytes: 4 * 1024 * 1024, reads });
-  const result = await pass(container, plan, {}, held);
-  assert.deepEqual(result.texts.sort(), ["a", "b", "c"]);
-  const moved = reads.reduce((sum, { start, end }) => sum + (end - start + 1), 0);
-  assert.ok(moved < picture.length, `${moved} bytes read for three clusters of ${picture.length}-byte pictures`);
-});
-
-test("with no Cues, the search stops at the first cluster it accepts and the chain knows the rest", async () => {
-  const picture = Buffer.alloc(64 * 1024, 7);
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [0, 10_000, 20_000, 30_000, 40_000].map((ticks, index) => plainCluster(ticks, String(index), picture))
-  });
-  const { container, plan } = await planOf(file);
-  const reads = [];
-  // The first cluster's header is not here, so nothing establishes the chain:
-  // only the search can start it.
-  const held = heldOver(file, [[0, clusterAt[0] - 1], [clusterAt[0] + 12, file.length - 1]], { portionBytes: 32 * 1024, reads });
-  const result = await pass(container, plan, {}, held);
-  assert.deepEqual(result.texts.sort(), ["1", "2", "3", "4"]);
-  assert.equal(result.stats.fromSearch, 4, "found by the search, then by its chain");
-  const searchedPast = reads.filter(({ start }) => start > clusterAt[2]).reduce((sum, { start, end }) => sum + (end - start + 1), 0);
-  assert.ok(searchedPast < picture.length, `${searchedPast} bytes read past the third cluster`);
-});
-
-test("a Cluster id inside a picture's bytes is checked and refused, and gives no line", async () => {
-  // An id, a plausible size and some bytes — inside a SimpleBlock's payload.
-  const fake = Buffer.concat([idBytes(ID.CLUSTER), Buffer.from([0x88]), Buffer.alloc(8, 0x41)]);
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [plainCluster(0, "a"), plainCluster(10_000, "b", Buffer.concat([Buffer.alloc(8), fake, Buffer.alloc(8)]))]
-  });
-  const { container, plan } = await planOf(file);
-  // The second cluster's own header is not downloaded, so nothing establishes it.
-  const result = await pass(
-    container,
-    plan,
-    {},
-    heldOver(file, [[0, clusterAt[1] - 1], [clusterAt[1] + 12, file.length - 1]])
-  );
-  assert.deepEqual(result.texts, ["a"]);
-  assert.ok(result.stats.rejectedCandidates >= 1, "the false start was looked at and refused");
-});
-
-test("a candidate that a cluster the file establishes later turns out to contain is taken back, with its lines", async () => {
-  // A whole, well-formed cluster hidden inside a picture block of a real one.
-  const hidden = element(
-    ID.CLUSTER,
-    clusterData({ ticks: 12_000, blocks: [cueBlock({ track: 2, relativeTicks: 0, durationTicks: 500, text: "hidden" })] })
-  );
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [
-      plainCluster(0, "a"),
-      plainCluster(10_000, "b", Buffer.concat([Buffer.alloc(4), hidden, Buffer.alloc(4)])),
-      plainCluster(20_000, "c")
-    ]
-  });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  const hiddenAt = file.indexOf(hidden);
-  const first = await pass(
-    container,
-    plan,
-    progress,
-    heldOver(file, [[0, clusterAt[1] - 1], [clusterAt[1] + 12, file.length - 1]])
-  );
-  assert.ok(first.texts.includes("hidden"), "the search found it and its structure held");
-
-  const second = await pass(container, plan, progress, heldOver(file, [[0, file.length - 1]]));
-  assert.deepEqual(second.withdrawn, [hiddenAt], "the real cluster around it takes it back");
-  assert.deepEqual(second.texts, ["b"], "and gives its own line");
-});
-
-test("a cluster whose bytes are only partly here is read once, when they all are", async () => {
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: [1],
-    clusters: [plainCluster(0, "a"), plainCluster(10_000, "b")]
-  });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  const partly = await pass(container, plan, progress, heldOver(file, [[0, clusterAt[1] + 20]]));
-  assert.deepEqual(partly.texts, ["a"]);
-  const whole = await pass(container, plan, progress, heldOver(file, [[0, file.length - 1]]));
-  assert.deepEqual(whole.texts, ["b"]);
-  const again = await pass(container, plan, progress, heldOver(file, [[0, file.length - 1]]));
-  assert.deepEqual(again.texts, [], "nothing is read twice");
-});
-
-test("a cluster of unknown size ends where the next top-level element begins", async () => {
-  const { file } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [plainCluster(0, "a"), { ...plainCluster(10_000, "b"), unknownSize: true }, plainCluster(20_000, "c")]
-  });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  const held = heldOver(file, [[0, file.length - 1]]);
-  const first = await pass(container, plan, progress, held);
-  const second = await pass(container, plan, progress, held);
-  assert.deepEqual([...first.texts, ...second.texts].sort(), ["a", "b", "c"]);
-});
-
-test("a CRC-32 before the Timestamp is a cluster like any other; a candidate whose CRC is wrong is refused", async () => {
-  const withCrc = (ticks, text, crc) => ({
-    ticks,
-    data: clusterData({ ticks, crc, blocks: [cueBlock({ track: 2, relativeTicks: 0, durationTicks: 500, text })] })
-  });
-  for (const [crc, expected] of [[true, ["b", "c"]], ["wrong", ["c"]]]) {
-    const { file, clusterAt } = buildMatroska({
-      tracks: TRACKS,
-      cues: null,
-      clusters: [withCrc(0, "a", false), withCrc(10_000, "b", crc), withCrc(20_000, "c", false)]
-    });
-    const { container, plan } = await planOf(file);
-    // The first cluster's header is not here, so the second is reached only by
-    // the search, which checks the CRC.
-    const result = await pass(container, plan, {}, heldOver(file, [[0, clusterAt[0] - 1], [clusterAt[0] + 12, file.length - 1]]));
-    assert.deepEqual(result.texts.sort(), expected, `crc ${crc}`);
-    if (crc === "wrong") {
-      assert.ok(result.stats.rejectedCandidates >= 1);
-    }
-  }
-});
-
-test("a candidate whose end has not arrived waits, and is read when it has", async () => {
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [plainCluster(0, "a"), plainCluster(10_000, "b"), plainCluster(20_000, "c")]
-  });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  const first = await pass(
-    container,
-    plan,
-    progress,
-    heldOver(file, [[0, clusterAt[1] - 1], [clusterAt[2], clusterAt[2] + 20]])
-  );
-  assert.deepEqual(first.texts, ["a"]);
-  assert.equal(first.stats.pendingCandidates, 1, "found, and waiting for its bytes");
-  const second = await pass(container, plan, progress, heldOver(file, [[0, clusterAt[1] - 1], [clusterAt[2], file.length - 1]]));
-  assert.deepEqual(second.texts, ["c"]);
-});
-
-test("an id cut by the end of what is downloaded is found once the run grows", async () => {
-  const { file, clusterAt } = buildMatroska({
-    tracks: TRACKS,
-    cues: null,
-    clusters: [plainCluster(0, "a"), plainCluster(10_000, "b"), plainCluster(20_000, "c")]
-  });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  // The run ends two bytes into the third cluster's id.
-  await pass(container, plan, progress, heldOver(file, [[0, clusterAt[1] - 1], [clusterAt[1] + 12, clusterAt[2] + 1]]));
-  const grown = await pass(container, plan, progress, heldOver(file, [[0, clusterAt[1] - 1], [clusterAt[1] + 12, file.length - 1]]));
-  assert.ok(grown.texts.includes("c"), "the cut id was searched again and found");
-});
-
-test("the cluster a viewer stands in is read first, then the one before it, then onward", async () => {
-  const clusters = [0, 10_000, 20_000, 30_000, 40_000].map((ticks) => plainCluster(ticks, `at ${ticks / 1000}`));
-  // A line that starts in the 10 s cluster and is still on screen at 25 s.
-  clusters[1] = {
-    ticks: 10_000,
-    data: clusterData({ ticks: 10_000, blocks: [cueBlock({ track: 2, relativeTicks: 0, durationTicks: 16_000, text: "at 10" })] })
-  };
-  const { file } = buildMatroska({ tracks: TRACKS, cues: [1], clusters });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  const held = heldOver(file, [[0, file.length - 1]], { wantedSeconds: [25] });
-  const first = await pass(container, plan, progress, held);
-  assert.deepEqual(first.texts, ["at 20", "at 10"], "the pass ends with what is on screen, to be pushed at once");
-  assert.equal(first.more, true, "and says there is more to read now");
-  const second = await pass(container, plan, progress, held);
-  assert.deepEqual(second.texts, ["at 30", "at 40", "at 0"], "then onward from the viewer, then the rest");
-  assert.equal(second.more, false);
-});
-
-test("a pass reading the rest stops when a viewer moves, and the next one starts from there", async () => {
-  const clusters = [0, 10_000, 20_000, 30_000, 40_000, 50_000].map((ticks) => plainCluster(ticks, `at ${ticks / 1000}`));
-  const { file } = buildMatroska({ tracks: TRACKS, cues: [1], clusters });
-  const { container, plan } = await planOf(file);
-  const progress = {};
-  let viewer = [];
-  let readsBeforeSeek = 2;
-  const held = heldOver(file, [[0, file.length - 1]]);
-  held.wantedSeconds = () => {
-    // The viewer seeks to 45 s after the pass has read two clusters.
-    readsBeforeSeek -= 1;
-    if (readsBeforeSeek < 0) {
-      viewer = [45];
-    }
-    return viewer;
-  };
-  const first = await pass(container, plan, progress, held);
-  assert.equal(first.more, true, "stopped for the viewer who moved");
-  const second = await pass(container, plan, progress, held);
-  assert.deepEqual(second.texts.slice(0, 1), ["at 40"], "the next pass reads where the viewer now is first");
-});
-
-test("no read is larger than one portion, and a block larger than one is refused while the rest is read", async () => {
-  const portion = 96;
-  const { file } = buildMatroska({
-    tracks: TRACKS,
-    cues: [1],
-    clusters: [
-      plainCluster(0, "short"),
-      {
-        ticks: 10_000,
-        data: clusterData({ ticks: 10_000, blocks: [cueBlock({ track: 2, relativeTicks: 0, durationTicks: 500, text: "x".repeat(200) })] })
-      },
-      plainCluster(20_000, "also short")
-    ]
-  });
-  const { container, plan } = await planOf(file);
-  const reads = [];
-  const result = await pass(container, plan, {}, heldOver(file, [[0, file.length - 1]], { portionBytes: portion, reads }));
-  assert.deepEqual(result.texts.sort(), ["also short", "short"]);
-  assert.equal(result.stats.refusedElements, 1);
-  assert.ok(reads.every(({ start, end }) => end - start + 1 <= portion), "every read stayed within one portion");
-});
-