@torrent-tv/proxy 2.86.0 → 2.87.1

package/test/init-compat.test.js

@@ -0,0 +1,219 @@
+/**
+ * @file The rule that decides whether one output's pieces may be played under
+ * another's header — and it is written BEFORE the experiment that will use it.
+ *
+ * The order matters and was a review finding: a criterion derived from the
+ * differences an experiment happened to produce proves only that those
+ * differences were handled. This one compares the whole header, names every
+ * difference by where it sits, and refuses anything no listed exception covers.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { INIT_DIFFERENCE_EXCEPTIONS, compareInits, initLeaves } from "../services/encode/segment-formats/init-compat.js";
+
+/**
+ * One ISO base media box.
+ *
+ * @param {string} type
+ * @param {...(Buffer | number[])} parts
+ * @returns {Buffer}
+ */
+function box(type, ...parts) {
+  const body = Buffer.concat(parts.map((part) => (Buffer.isBuffer(part) ? part : Buffer.from(part))));
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(body.length + 8, 0);
+  header.write(type, 4, "latin1");
+  return Buffer.concat([header, body]);
+}
+
+/**
+ * A version-0 `mdhd`: version+flags, creation, modification, timescale,
+ * duration, language, quality.
+ *
+ * @param {number} timescale
+ * @returns {Buffer}
+ */
+function mdhd(timescale) {
+  const body = Buffer.alloc(24);
+  body.writeUInt32BE(timescale, 12);
+  return box("mdhd", body);
+}
+
+/**
+ * A `btrt`: decoding buffer size, maximum rate, average rate.
+ *
+ * @param {number} maxBitrate
+ * @returns {Buffer}
+ */
+function btrt(maxBitrate) {
+  const body = Buffer.alloc(12);
+  body.writeUInt32BE(1875072, 0);
+  body.writeUInt32BE(maxBitrate, 4);
+  body.writeUInt32BE(maxBitrate, 8);
+  return box("btrt", body);
+}
+
+/**
+ * A `stsd` carrying one visual sample entry: its 78-byte preamble, then the
+ * codec configuration, then optionally a bit rate declaration.
+ *
+ * @param {{ entryType?: string, config?: number[], maxBitrate?: number | null, preamble?: number }} [how]
+ * @returns {Buffer}
+ */
+function stsd({ entryType = "avc1", config = [1, 100, 0, 31], maxBitrate = null, preamble = 78 } = {}) {
+  const versionAndCount = Buffer.alloc(8);
+  versionAndCount.writeUInt32BE(1, 4);
+  const children = [box("avcC", config)];
+  if (maxBitrate !== null) {
+    children.push(btrt(maxBitrate));
+  }
+  const entry = box(entryType, Buffer.alloc(preamble), ...children);
+  return box("stsd", versionAndCount, entry);
+}
+
+/**
+ * A whole init segment, shaped as ffmpeg writes one.
+ *
+ * @param {{ timescale?: number, tracks?: number } & Parameters<typeof stsd>[0]} [how]
+ * @returns {Buffer}
+ */
+function init({ timescale = 90000, tracks = 1, ...entry } = {}) {
+  const trak = (index) =>
+    box(
+      "trak",
+      box("tkhd", Buffer.alloc(84, index)),
+      box("mdia", mdhd(timescale), box("hdlr", Buffer.alloc(32)), box("minf", box("stbl", stsd(entry))))
+    );
+  const traks = [];
+  for (let index = 0; index < tracks; index += 1) {
+    traks.push(trak(index));
+  }
+  return Buffer.concat([
+    box("ftyp", Buffer.from("isom")),
+    box("moov", box("mvhd", Buffer.alloc(100)), ...traks, box("mvex", box("trex", Buffer.alloc(24))))
+  ]);
+}
+
+const ENTRY = "moov[0]/trak[0]/mdia[0]/minf[0]/stbl[0]/stsd[0]/avc1[0]";
+
+test("every exception carries the reason it is one", () => {
+  for (const exception of INIT_DIFFERENCE_EXCEPTIONS) {
+    assert.ok(exception.why && exception.why.length > 40, `no reason given for ${JSON.stringify(exception)}`);
+    assert.ok(
+      exception.path !== undefined || exception.sampleEntryBox !== undefined,
+      "an exception says WHAT it covers"
+    );
+  }
+});
+
+test("every leaf of the header is named by whose child it is, inside a sample entry too", () => {
+  const paths = [...initLeaves(init({ tracks: 2, maxBitrate: 3_000_000 })).keys()];
+
+  assert.ok(paths.includes("moov[0]/trak[0]/mdia[0]/mdhd[0]"), paths.join(" "));
+  assert.ok(paths.includes("moov[0]/trak[1]/mdia[0]/mdhd[0]"), "the second track is its own path");
+  assert.ok(paths.includes("moov[0]/mvex[0]/trex[0]"));
+  assert.ok(
+    paths.includes(`${ENTRY}/avcC[0]`),
+    "the codec configuration is a leaf of its own, so it can refuse on its own"
+  );
+  assert.ok(paths.includes(`${ENTRY}/btrt[0]`), "and so is the bit rate declaration");
+});
+
+test("one header serves its own pieces", () => {
+  const answer = compareInits(init(), init());
+
+  assert.equal(answer.compatible, true);
+  assert.deepEqual(answer.differences, []);
+});
+
+test("a bit rate declaration is the one difference that does not refuse", () => {
+  const answer = compareInits(init({ maxBitrate: 3_000_000 }), init({ maxBitrate: 1_200_000 }));
+
+  assert.equal(answer.compatible, true, answer.differences.join(" | "));
+  assert.deepEqual(answer.refusedPaths, []);
+  assert.ok(
+    answer.differences.some((line) => line.includes("max 3000000") && line.includes("max 1200000")),
+    `the difference is still reported, with its numbers: ${answer.differences.join(" | ")}`
+  );
+});
+
+test("allowing the bit rate does not allow the parameter sets beside it", () => {
+  const answer = compareInits(
+    init({ maxBitrate: 3_000_000, config: [1, 100, 0, 31] }),
+    init({ maxBitrate: 1_200_000, config: [1, 100, 0, 30] })
+  );
+
+  assert.equal(answer.compatible, false);
+  assert.deepEqual(answer.refusedPaths, [`${ENTRY}/avcC[0]`]);
+});
+
+test("the bit rate exception is scoped to a sample entry", () => {
+  const strayLeft = box("moov", box("trak", box("mdia", box("minf", box("stbl", btrt(3_000_000))))));
+  const strayRight = box("moov", box("trak", box("mdia", box("minf", box("stbl", btrt(1_200_000))))));
+
+  const answer = compareInits(strayLeft, strayRight);
+
+  assert.equal(answer.compatible, false, "a btrt that is nobody's sample entry is not the box the reason is about");
+  assert.deepEqual(answer.refusedPaths, ["moov[0]/trak[0]/mdia[0]/minf[0]/stbl[0]/btrt[0]"]);
+});
+
+test("a sample entry whose children do not tile is compared whole", () => {
+  const answer = compareInits(init({ preamble: 8, config: [1, 100, 0, 31] }), init({ preamble: 8, config: [1, 100, 0, 30] }));
+
+  assert.equal(answer.compatible, false);
+  assert.deepEqual(
+    answer.refusedPaths,
+    [ENTRY],
+    "the descent is checked, and where it does not hold the whole entry refuses"
+  );
+});
+
+test("a different media timescale is refused, and said in those words", () => {
+  const answer = compareInits(init({ timescale: 90000 }), init({ timescale: 48000 }));
+
+  assert.equal(answer.compatible, false);
+  assert.ok(
+    answer.differences.some((line) => line.includes("timescale 90000 against 48000")),
+    answer.differences.join(" | ")
+  );
+  assert.deepEqual(answer.refusedPaths, ["moov[0]/trak[0]/mdia[0]/mdhd[0]"]);
+});
+
+test("a track present in one header and not the other is refused", () => {
+  const answer = compareInits(init({ tracks: 1 }), init({ tracks: 2 }));
+
+  assert.equal(answer.compatible, false);
+  assert.ok(
+    answer.differences.some((line) => line.includes("trak[1]") && line.includes("absent from the first")),
+    answer.differences.join(" | ")
+  );
+});
+
+test("an exact-path exception decides by path", () => {
+  const served = init({ timescale: 90000 });
+  const made = init({ timescale: 48000 });
+
+  const refused = compareInits(served, made);
+  const permitted = compareInits(served, made, {
+    exceptions: [{ path: "moov[0]/trak[0]/mdia[0]/mdhd[0]", why: "for this check only" }]
+  });
+
+  assert.equal(refused.compatible, false);
+  assert.equal(permitted.compatible, true, "the exception list is what decides, and it is asked by path");
+  assert.equal(permitted.differences.length, 1, "a permitted difference is still reported");
+});
+
+test("allowing one path does not allow the same box of another track", () => {
+  const answer = compareInits(init({ tracks: 2, timescale: 90000 }), init({ tracks: 2, timescale: 48000 }), {
+    exceptions: [{ path: "moov[0]/trak[0]/mdia[0]/mdhd[0]", why: "for this check only" }]
+  });
+
+  assert.equal(answer.compatible, false);
+  assert.deepEqual(answer.refusedPaths, ["moov[0]/trak[1]/mdia[0]/mdhd[0]"]);
+});
+
+test("a missing header is never compatible", () => {
+  assert.equal(compareInits(init(), Buffer.alloc(0)).compatible, false);
+  assert.equal(compareInits(Buffer.alloc(0), init()).compatible, false);
+});

package/test/input-lost-quiets-the-plan.test.js

@@ -20,7 +20,7 @@ import { EventEmitter } from "node:events";
 import { EncodeRun } from "../services/encode/EncodeRun.js";
 import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
 import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { EncodeOrchestrator } from "../services/orchestrators/EncodeOrchestrator.js";
+import { EncodeOrchestrator } from "../services/encode/EncodeOrchestrator.js";
 
 const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 

package/test/input-unavailable.test.js

@@ -14,7 +14,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { isInputUnavailable } from "../services/hls-session-manager.js";
+import { isInputUnavailable } from "../services/encode/EncodeRuns.js";
 
 test("the messages the field produced when data went away are all temporary", () => {
   for (const message of [

package/test/keeping-period.test.js

@@ -11,8 +11,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { IDLE_KEEP_MS } from "../services/disk/keep.js";
-import { Returns } from "../services/disk/returns.js";
+import { IDLE_KEEP_MS } from "../services/storage/keep.js";
+import { Returns } from "../services/storage/returns.js";
 
 const MINUTE = 60 * 1000;
 
@@ -38,8 +38,8 @@ test("one number, and both kinds of material read it", async () => {
   const here = path.dirname(fileURLToPath(import.meta.url));
   const read = (relative) => readFileSync(path.join(here, "..", relative), "utf8");
 
-  assert.match(read("services/torrent-pool.js"), /TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS/);
-  assert.match(read("services/hls-session-manager.js"), /SEGMENT_STORE_IDLE_MS = IDLE_KEEP_MS/);
+  assert.match(read("services/torrent/torrent-pool.js"), /TORRENT_IDLE_TTL_MS = IDLE_KEEP_MS/);
+  assert.match(read("services/server/OutputLifecycle.js"), /SEGMENT_STORE_IDLE_MS = IDLE_KEEP_MS/);
 });
 
 test("a session opened on material still held is a return, and its age is kept", () => {

package/test/keyframe-index-accuracy.test.js

@@ -11,93 +11,156 @@
  * states where it truly begins, and it is already read whole in order to be
  * stamped. Only boundaries that were actually produced are counted — the parts
  * somebody watched.
+ *
+ * Counted ON THE FILE'S OWN TABLE, because that is whose fact it is: the same
+ * finding for every quality step of the film and for every later session of it.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import { Timeline } from "../services/output/Timeline.js";
-import { newIndexCheck, noteIndexDeviation } from "../services/hls-session-manager.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const TOLERANCE = 0.25;
+
+/**
+ * A table naming keyframes every four seconds, which is what the grid of a
+ * copied picture is built from.
+ *
+ * @returns {KeyframeTable}
+ */
+function fourSecondKeyframes() {
+  return new KeyframeTable().learn({
+    times: [0, 4, 8, 12, 16, 20],
+    format: "matroska"
+  });
+}
 
 test("an index that describes its file exactly is reported as such", () => {
-  const check = newIndexCheck();
+  const table = fourSecondKeyframes();
 
   for (let index = 0; index < 4; index += 1) {
-    noteIndexDeviation(check, index, 0);
+    table.witness({ index, trueStart: index * 4, deviationSec: 0, toleranceSec: TOLERANCE });
   }
 
-  assert.equal(check.checked, 4);
-  assert.equal(check.disagreed, 0, "nothing disagreed — which is a finding, not silence");
-  assert.equal(check.maxDeviationSec, 0);
+  assert.equal(table.evidence.checked, 4);
+  assert.equal(table.evidence.disagreed, 0, "nothing disagreed — which is a finding, not silence");
+  assert.equal(table.evidence.maxDeviationSec, 0);
 });
 
 test("a boundary the index placed wrongly is counted, with how far out it was", () => {
-  const check = newIndexCheck();
+  const table = fourSecondKeyframes();
 
-  noteIndexDeviation(check, 0, 0);
+  table.witness({ index: 0, trueStart: 0, deviationSec: 0, toleranceSec: TOLERANCE });
   // The measured shape: the playlist said 157.99 s, the file cut at 153.82 s.
-  noteIndexDeviation(check, 2, 4.17);
-  noteIndexDeviation(check, 3, 0.01);
+  table.witness({ index: 2, trueStart: 3.83, deviationSec: 4.17, toleranceSec: TOLERANCE });
+  table.witness({ index: 3, trueStart: 12.01, deviationSec: 0.01, toleranceSec: TOLERANCE });
 
-  assert.equal(check.checked, 3);
-  assert.equal(check.disagreed, 1);
-  assert.equal(check.firstDisagreementIndex, 2);
+  assert.equal(table.evidence.checked, 3);
+  assert.equal(table.evidence.disagreed, 1);
+  assert.equal(table.evidence.firstDisagreementIndex, 2);
   assert.equal(
-    check.maxDeviationSec,
+    table.evidence.maxDeviationSec,
     4.17,
     "the size of the error is what decides whether a rung can be cut on this grid"
   );
 });
 
 test("a deviation within tolerance is not a disagreement, but still shows in the worst case", () => {
-  const check = newIndexCheck();
+  const table = fourSecondKeyframes();
+
+  table.witness({ index: 0, trueStart: 0.2, deviationSec: 0.2, toleranceSec: TOLERANCE });
+
+  assert.equal(
+    table.evidence.disagreed,
+    0,
+    "rounding in a container's timestamps is not the index being wrong"
+  );
+  assert.equal(
+    table.evidence.maxDeviationSec,
+    0.2,
+    "and it is still worth knowing how close to the line it ran"
+  );
+});
+
+test("a piece that began at ANOTHER time the table names is told apart from one that began nowhere", () => {
+  // The discriminator, and it decides which of two opposite faults this is. A
+  // piece that began at another keyframe of the same list was not mis-described
+  // by the table: the grid was built over a gap in it. One that began where the
+  // table names nothing is the table describing times the file does not have.
+  // The table answers it itself, because it is the only thing that holds the
+  // list — asked of the caller, it was one more fact travelling by hand.
+  const table = fourSecondKeyframes();
 
-  noteIndexDeviation(check, 0, 0.2);
+  table.witness({ index: 1, trueStart: 8, deviationSec: 4, toleranceSec: TOLERANCE });
+  table.witness({ index: 2, trueStart: 9.7, deviationSec: 1.7, toleranceSec: TOLERANCE });
 
-  assert.equal(check.disagreed, 0, "rounding in a container's timestamps is not the index being wrong");
-  assert.equal(check.maxDeviationSec, 0.2, "and it is still worth knowing how close to the line it ran");
+  assert.equal(table.evidence.disagreed, 2);
+  assert.equal(table.evidence.landedOnAnotherKeyframe, 1);
+});
+
+test("a table that has read nothing claims no evidence about itself", () => {
+  // It cannot be wrong about a file it has not described. `readable` is false,
+  // every picture of the file is re-encoded, and no copy can witness anything.
+  const table = new KeyframeTable().learn({ times: null, format: "mpegts" });
+
+  assert.equal(table.evidence, null);
+  assert.equal(table.names(4), false);
+});
+
+test("a segment requested again is not new evidence", () => {
+  const table = fourSecondKeyframes();
+
+  for (let repeat = 0; repeat < 3; repeat += 1) {
+    table.witness({ index: 1, trueStart: 4.9, deviationSec: 0.9, toleranceSec: TOLERANCE });
+  }
+
+  assert.equal(table.evidence.checked, 1, "a repeat request is the same boundary, counted once");
+  assert.equal(table.evidence.disagreed, 1);
 });
 
 test("a boundary the index got wrong is replaced by the time the file really has", async (t) => {
-  const { HlsSessionManager } = await import("../services/hls-session-manager.js");
-  const manager = new HlsSessionManager({
+  const { wireOutputs } = await import("../services/server/wire-outputs.js");
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
-  t.after(() => manager.disposeAll());
+  t.after(() => manager.lifecycle.disposeAll());
   // ONE table for the film, held by both. It used to be a copy each, kept in
   // step by writing the correction into every member — which is what the shared
   // table replaces, and what drifted in the field.
   const boundaries = [0, 10, 20, 30, 40];
   const base = {
-    id: "aaaaaaaa-1111-2222-3333-444444444444",
+    id: "aaaaaaaa11112222",
+    spec: outputSpec({ transcodeVideo: false }),
     fileName: "film.mkv",
     state: "ready",
-    transcodeVideo: false,
     timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
     file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
     segmentFormat: { segmentFileName: (index) => `segment-${index}.mp4` }
   };
   const rung = {
-    id: "bbbbbbbb-1111-2222-3333-444444444444",
+    id: "bbbbbbbb11112222",
+    spec: outputSpec({ transcodeVideo: true, height: 540 }),
     fileName: "film.mkv",
     state: "ready",
-    transcodeVideo: true,
     timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
     // A step of the picture: the same file, and made as a step.
     file: base.file,
     variantHeight: 540,
     isStep: true
   };
-  base.file.stepHeights.set(540, 540);
-  manager.sessionsById.set(base.id, base);
-  manager.sessionsById.set(rung.id, rung);
+  manager.outputs.set(base.id, base);
+  manager.outputs.set(rung.id, rung);
+  manager.outputs.markStep(rung);
 
   // The copy produced segment #2, and it really begins at 17.4 s — the index
   // said 20. This is the shape reproduced from the field on 2026-08-12.
-  manager.correctBoundaryFromSegment(base, 2, 17.4);
+  manager.outputTimes.correctBoundaryFromSegment(base, 2, 17.4);
 
   assert.equal(
     base.timeline.boundaries[2],
@@ -118,19 +181,8 @@ test("a boundary the index got wrong is replaced by the time the file really has
   // A reading that cannot be a boundary is not evidence about one. It comes
   // from a run that started somewhere else, and applying it would leave the
   // table describing nothing.
-  manager.correctBoundaryFromSegment(base, 2, 35);
-  manager.correctBoundaryFromSegment(base, 2, 5);
-  manager.correctBoundaryFromSegment(base, 0, 3);
+  manager.outputTimes.correctBoundaryFromSegment(base, 2, 35);
+  manager.outputTimes.correctBoundaryFromSegment(base, 2, 5);
+  manager.outputTimes.correctBoundaryFromSegment(base, 0, 3);
   assert.deepEqual(base.timeline.boundaries, [0, 10, 17.4, 30, 40], "out-of-order readings are refused");
 });
-
-test("a segment requested again is not new evidence", () => {
-  const check = newIndexCheck();
-
-  noteIndexDeviation(check, 1, 0.9);
-  noteIndexDeviation(check, 1, 0.9);
-  noteIndexDeviation(check, 1, 0.9);
-
-  assert.equal(check.checked, 1, "a repeat request is the same boundary, counted once");
-  assert.equal(check.disagreed, 1);
-});

package/test/keyframe-table-budget.test.js

@@ -1,5 +1,5 @@
 /**
- * @file How long a session waits for the file's keyframe table.
+ * @file How long anybody waits for the file's keyframe table.
  *
  * With the table a picture is copied; without it the whole picture is
  * re-encoded, which on a weak host is the difference between almost free and
@@ -16,66 +16,62 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { KeyframeTables } from "../services/media/KeyframeTables.js";
+
+const QUIET = { info: () => {}, warn: () => {} };
 
 /**
  * @param {number} budgetMs
- * @returns {HlsSessionManager}
+ * @param {(params: object) => Promise<object | null>} readTable
+ * @returns {KeyframeTables}
  */
-function manager(budgetMs) {
-  return new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    keyframeTableBudgetMs: budgetMs
-  });
+function tables(budgetMs, readTable) {
+  return new KeyframeTables({ readTable, budgetMs, logger: QUIET });
 }
 
 const FILE = { sourceKey: "torrent:abc", fileIndex: 0, logName: "a.mkv" };
 
 test("a table that arrives inside the budget is the answer", async () => {
-  const sessions = manager(1_000);
-  sessions.getContainerKeyframes = async () => ({ times: [0, 4, 8], tolerance: 0, format: "matroska" });
+  const keyframes = tables(1_000, async () => ({ times: [0, 4, 8], tolerance: 0, format: "matroska" }));
 
-  const answer = await sessions.readKeyframeTableWithin(FILE);
+  const { table, arrived } = await keyframes.within(FILE);
 
-  assert.deepEqual(answer.times, [0, 4, 8]);
-  assert.equal(answer.arrived, true, "the file has answered, so what it said may be written onto it");
+  assert.deepEqual(table.times, [0, 4, 8]);
+  assert.equal(arrived, true, "the file has answered, so the picture may be copied");
+  assert.equal(table.readable, true);
 });
 
 test("a table that has not arrived gives up on copying rather than on the session", async () => {
-  const sessions = manager(60);
   // The bytes it needs are still coming off the swarm. On the field host this
   // is a torrent with one peer: the read was still waiting after two minutes.
-  sessions.getContainerKeyframes = () => new Promise(() => {});
+  const keyframes = tables(60, () => new Promise(() => {}));
 
   const startedAt = Date.now();
-  const answer = await sessions.readKeyframeTableWithin(FILE);
+  const { table, arrived } = await keyframes.within(FILE);
   const waited = Date.now() - startedAt;
 
-  assert.equal(answer.times, null, "no table, so this session cannot copy the picture");
+  assert.equal(table.readable, false, "no table, so this session cannot copy the picture");
   assert.equal(
-    answer.arrived,
+    table.answered,
     false,
-    "and it says the file has NOT answered — an absence written onto the file would make " +
-      "a passing shortage of bytes look like a property of the bytes"
+    "and the file has NOT answered — an absence recorded as an answer would make a passing " +
+      "shortage of bytes look like a property of the bytes"
   );
+  assert.equal(arrived, false);
   assert.ok(waited < 2_000, `the wait ended at the bound, not at the read (${waited}ms)`);
 });
 
 test("the read goes on after the budget, so the next session of the file gets the copy", async () => {
-  const sessions = manager(40);
   let reads = 0;
   let answerLate = null;
-  sessions.getContainerKeyframes = () => {
+  const keyframes = tables(40, () => {
     reads += 1;
     return new Promise((resolve) => {
       answerLate = resolve;
     });
-  };
+  });
 
-  const first = await sessions.readKeyframeTableWithin(FILE);
+  const first = await keyframes.within(FILE);
   assert.equal(first.arrived, false);
 
   answerLate({ times: [0, 5, 10], tolerance: 0, format: "matroska" });
@@ -87,20 +83,19 @@ test("the read goes on after the budget, so the next session of the file gets th
   // is the very thing the last assertion here is about.
   await new Promise((resolve) => { setImmediate(resolve); });
 
-  const second = await sessions.readKeyframeTableWithin(FILE);
-  assert.deepEqual(second.times, [0, 5, 10], "the late answer was kept, not thrown away");
+  const second = await keyframes.within(FILE);
+  assert.deepEqual(second.table.times, [0, 5, 10], "the late answer was kept, not thrown away");
   assert.equal(second.arrived, true);
   assert.equal(reads, 1, "and it was not read a second time");
 });
 
 test("a read that fails is not turned into a bounded wait's silence", async () => {
-  const sessions = manager(1_000);
-  sessions.getContainerKeyframes = async () => {
+  const keyframes = tables(1_000, async () => {
     throw new Error("the head is not downloaded");
-  };
+  });
 
   await assert.rejects(
-    () => sessions.readKeyframeTableWithin(FILE),
+    () => keyframes.read(FILE),
     /the head is not downloaded/,
     "a read that threw is a different thing from a read that is still running"
   );