@torrent-tv/proxy 2.86.0 → 2.87.0

package/test/tracks-begin-together.test.js

@@ -13,15 +13,16 @@
  */
 
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
+import { SourceFile } from "../services/media/SourceFile.js";
 import { startRunOn } from "./helpers/encode-run.js";
-import { Timeline } from "../services/output/Timeline.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import test from "node:test";
 
-import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
 import { trueStartOf } from "../services/encode/run-command.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 import { ENCODE_RUN_STATE, INITIAL_RUN_STATE } from "../services/encode/encode-run-state.js";
+import { outputSpec } from "./helpers/output-spec.js";
 
 const BOUNDARIES = [0, 4, 8, 12, 16, 20];
 
@@ -29,13 +30,13 @@ const BOUNDARIES = [0, 4, 8, 12, 16, 20];
  * A film's family: the picture, and a soundtrack rendition of it. Both runs
  * begin at boundary #2, which the container's table puts at 8 s.
  *
- * @returns {{ manager: HlsSessionManager, picture: object, sound: object }}
+ * @returns {{ manager: object, picture: object, sound: object }}
  */
 function familyAtBoundaryTwo() {
   // ONE table for the film. Where it is cut is a fact about the FILE, so the
   // picture and its soundtrack hold the same array rather than a copy each.
   const boundaries = [...BOUNDARIES];
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -43,6 +44,8 @@ function familyAtBoundaryTwo() {
   });
   const picture = {
     id: "picture",
+    spec: outputSpec({ transcodeVideo: false }),
+    get outputKey() { return this.spec.toKey(); },
     state: "ready",
     timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
     file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
@@ -57,16 +60,15 @@ function familyAtBoundaryTwo() {
     segmentFormat: fmp4Format,
     // Where its encoder has got to, which a run writes into as it works.
     progress: { processedSeconds: 0 },
-    runs: new Set(),
-    pendingRun: null,
-    indexCheck: null
+    runs: new Set()
   };
   // The soundtrack of that picture: the same file, published on its own. Found
   // by what it is, since no list of ids names it any more.
   const sound = {
     id: "sound",
+    spec: outputSpec({ audioOnly: true }),
+    get outputKey() { return this.spec.toKey(); },
     state: "ready",
-    audioOnly: true,
     baseSessionId: "picture",
     timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
     file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.mkv" }),
@@ -81,14 +83,14 @@ function familyAtBoundaryTwo() {
     segmentFormat: fmp4Format,
     // Where its encoder has got to, which a run writes into as it works.
     progress: { processedSeconds: 0 },
-    runs: new Set(),
-    pendingRun: null,
-    indexCheck: null
+    runs: new Set()
   };
-  startRunOn(picture, { from: 2 });
-  startRunOn(sound, { from: 2 });
-  manager.sessionsById.set("picture", picture);
-  manager.sessionsById.set("sound", sound);
+  const pictureRun = startRunOn(picture, { from: 2 });
+  const soundRun = startRunOn(sound, { from: 2 });
+  manager.encodeOrchestrator.adopt(picture.outputKey, pictureRun);
+  manager.encodeOrchestrator.adopt(sound.outputKey, soundRun);
+  manager.outputs.set("picture", picture);
+  manager.outputs.set("sound", sound);
 
   return { manager, picture, sound };
 }
@@ -97,7 +99,7 @@ test("a soundtrack follows the picture to the instant the picture really began",
   const { manager, picture, sound } = familyAtBoundaryTwo();
   const runBefore = [...sound.runs][0];
 
-  manager.correctBoundaryFromSegment(picture, 2, 10.5);
+  manager.outputTimes.correctBoundaryFromSegment(picture, 2, 10.5);
 
   assert.deepEqual(
     picture.timeline.boundaries,
@@ -116,7 +118,11 @@ test("a soundtrack follows the picture to the instant the picture really began",
   // it is known and no further: the run goes, the stretch it held returns to the
   // map, and where the next one stands follows from where the viewers are.
   assert.equal(runBefore.state, ENCODE_RUN_STATE.STOPPED, "the run in the wrong place goes");
-  assert.equal(sound.pendingRun, null, "and this path places nothing");
+  assert.equal(
+    manager.encodeOrchestrator.runsOn(sound.outputKey).filter((run) => run.isAlive).length,
+    0,
+    "and this path places nothing"
+  );
   // The corrected instant reaches whatever the plan places there through the
   // table, which every session of the file shares. It used to be passed as an
   // argument from this one call site, so only a run started by that line ever
@@ -149,7 +155,7 @@ test("a correction the table already holds moves nobody", () => {
   // Within the tolerance: the reading agrees with the table, so there is
   // nothing to correct and nothing to move. This is what makes the repositioning
   // converge instead of repeating on every produced segment.
-  manager.correctBoundaryFromSegment(picture, 2, 8.1);
+  manager.outputTimes.correctBoundaryFromSegment(picture, 2, 8.1);
   assert.deepEqual(sound.timeline.boundaries, before);
 });
 
@@ -161,8 +167,12 @@ test("a member that is not running is left alone", () => {
   soundRun.stop("the viewer switched away");
   // A stopped run is no longer live, so nothing of this session begins at #2
   // any more — which is what "left alone" means here.
-  manager.correctBoundaryFromSegment(picture, 2, 10.5);
-  assert.equal(sound.pendingRun, null, "a stopped member is not started again for nobody");
+  manager.outputTimes.correctBoundaryFromSegment(picture, 2, 10.5);
+  assert.equal(
+    manager.encodeOrchestrator.runsOn(sound.outputKey).filter((run) => run.isAlive).length,
+    0,
+    "a stopped member is not started again for nobody"
+  );
   assert.equal(soundRun.from, 2, "a stopped member keeps its place and its silence");
   assert.equal(soundRun.state, ENCODE_RUN_STATE.STOPPED);
   assert.notEqual(INITIAL_RUN_STATE, ENCODE_RUN_STATE.STOPPED);
@@ -183,7 +193,7 @@ test("a soundtrack does not move the grid the picture is cut on", () => {
   // 1.951 s apart, each overwriting the other for as long as the film ran. The
   // table never converged, so the guard that stops a correction the table
   // already holds never fired.
-  manager.correctBoundaryFromSegment(sound, 2, 10.5);
+  manager.outputTimes.correctBoundaryFromSegment(sound, 2, 10.5);
 
   assert.deepEqual(
     picture.timeline.boundaries,
@@ -191,5 +201,9 @@ test("a soundtrack does not move the grid the picture is cut on", () => {
     "the grid is the picture's cut list and a soundtrack may not move it"
   );
   assert.deepEqual(sound.timeline.boundaries, soundBefore);
-  assert.equal(picture.pendingRun, null, "and nothing is restarted on a soundtrack's say-so");
+  assert.equal(
+    manager.encodeOrchestrator.runsOn(picture.outputKey).filter((run) => run.isAlive).length,
+    1,
+    "and nothing is restarted on a soundtrack's say-so"
+  );
 });

package/test/tunnel-renewal.test.js

@@ -17,7 +17,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { WebSocketServer } from "ws";
 
-import { createTunnelClient } from "../services/tunnel-client.js";
+import { createTunnelClient } from "../services/transport/tunnel-client.js";
 
 /**
  * Wait for the thing being asserted, not for a length of time.

package/test/two-viewers-one-picture.test.js

@@ -22,8 +22,8 @@ import { fakeProcess as fakeEncoder, startRunOn } from "./helpers/encode-run.js"
  * @param {object} session
  * @returns {boolean}
  */
-function encoding(session) {
-  return [...(session?.runs ?? [])].some((run) => run.isAlive);
+function encoding(manager, output) {
+  return manager.encodeOrchestrator.runsOn(output?.outputKey ?? "").some((run) => run.isAlive);
 }
 /**
  * Whether anybody is still watching this output.
@@ -42,22 +42,23 @@ function encoding(session) {
  * @param {object} session
  * @returns {boolean}
  */
-function watched(session) {
-  return [...(session?.viewers ?? new Map()).values()].length > 0;
+function watched(manager, session) {
+  return session ? manager.viewers.forOutput(session).size > 0 : false;
 }
 
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import { Timeline } from "../services/output/Timeline.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { audioRenditionKey, HlsSessionManager } from "../services/hls-session-manager.js";
-import { viewerOf } from "../services/viewer/Viewer.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-import { Output } from "../services/output/Output.js";
+import { audioRenditionKey } from "../services/encode/Renditions.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 BASE_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+const BASE_ID = "aaaaaaaabbbbcccc";
 const SEGMENT_SECONDS = 4;
 const FIRST = "viewer-one";
 const SECOND = "viewer-two";
@@ -65,12 +66,35 @@ const SECOND = "viewer-two";
 /**
  * A session shaped like a live one, without the ffmpeg run behind it.
  *
- * @param {{ id: string, dirPath: string, audioTrackIndex?: number, transcodeAudio?: boolean }} params
+ * @param {{ id: string, dirPath: string, audioTrackIndex?: number, transcodeAudio?: boolean, audioOnly?: boolean, audioSeparate?: boolean }} params
  * @returns {object}
  */
-function fakeSession({ id, dirPath, audioTrackIndex = 0, transcodeAudio = true }) {
+function fakeSession({
+  id,
+  dirPath,
+  audioTrackIndex = 0,
+  transcodeAudio = true,
+  audioOnly = false,
+  audioSeparate = false,
+  // THE SIZE IS PART OF THE IDENTITY, so two steps of different sizes are two
+  // addresses. Left out, every step of this fixture shared one key and the
+  // record of which output answers a height could not tell them apart — which
+  // is the fixture describing something production does not do, not a rule
+  // being too strict.
+  encodeHeight = 0
+}) {
   return {
     id,
+    spec: outputSpec({
+      transcodeVideo: !audioOnly,
+      transcodeAudio,
+      audioOnly,
+      audioSeparate,
+      audioSourceTrackIndex: audioTrackIndex,
+      height: encodeHeight,
+      width: encodeHeight > 0 ? Math.round((encodeHeight * 16) / 9) : 0
+    }),
+    get outputKey() { return this.spec.toKey(); },
     dirPath,
     // Where this file is cut, held by the file. A fixture that stated it
     // on the session was describing what production no longer does.
@@ -85,12 +109,9 @@ function fakeSession({ id, dirPath, audioTrackIndex = 0, transcodeAudio = true }
     get inputFile() { return this.file; },
     get audioFile() { return this.file; },
     startedAt: Date.now(),
-    createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     ffmpeg: null,
     lastError: "",
-    consumers: new Set(),
-    viewers: new Map(),
 
     segmentFormat: fmp4Format,
     transcodeVideo: false,
@@ -115,31 +136,35 @@ function fakeSession({ id, dirPath, audioTrackIndex = 0, transcodeAudio = true }
   };
 }
 
+function startManagedRun(manager, output, options = {}) {
+  const run = startRunOn(output, options);
+  manager.encodeOrchestrator.adopt(output.outputKey, run);
+  return run;
+}
+
 
 /**
  * A base picture serving two viewers, with its audio published separately and
  * every rendition created by a stub instead of an encoder.
  *
- * @returns {Promise<{ manager: HlsSessionManager, base: object, dirPath: string, renditions: Map<string, object> }>}
+ * @returns {Promise<{ manager: object, base: object, dirPath: string, renditions: Map<string, object> }>}
  */
 async function pictureWithTwoViewers() {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "two-viewers-"));
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const base = fakeSession({ id: BASE_ID, dirPath });
-  base.audioSeparate = true;
-  base.consumers = new Set([FIRST, SECOND]);
+  // Its own store root — see `helpers/manager.js` for what sharing one cost.
+  const { manager } = managerWithOwnStore();
+  // These checks cover ownership changes made by viewer requests. Encoder
+  // placement is covered by the plan tests and must not run asynchronously in
+  // the middle of an assertion about the request path.
+  manager.encodeRuns.planEncodersSoon = () => {};
+  const base = fakeSession({ id: BASE_ID, dirPath, audioSeparate: true });
   // Both viewers are watching the picture, which is what keeps their choices
   // alive; a viewer whose head has expired holds no encoder.
-  viewerOf(base, FIRST).position = { segment: 3, seconds: 12, at: Date.now() };
-  viewerOf(base, SECOND).position = { segment: 3, seconds: 12, at: Date.now() };
-  viewerOf(base, FIRST).audio = { trackIndex: 0, transcode: true };
-  viewerOf(base, SECOND).audio = { trackIndex: 1, transcode: true };
-  manager.sessionsById.set(BASE_ID, base);
+  manager.viewers.of(base, FIRST).position = { segment: 3, seconds: 12, at: Date.now() };
+  manager.viewers.of(base, SECOND).position = { segment: 3, seconds: 12, at: Date.now() };
+  manager.viewers.of(base, FIRST).audio = { trackIndex: 0, transcode: true };
+  manager.viewers.of(base, SECOND).audio = { trackIndex: 1, transcode: true };
+  manager.outputs.set(BASE_ID, base);
   manager.getCachedAudioTracks = () => [
     { index: 0, language: "rus", title: "Дубляж", isDefault: true, fileIndex: 0, sourceTrackIndex: 0 },
     { index: 1, language: "eng", title: "", isDefault: false, fileIndex: 0, sourceTrackIndex: 1 }
@@ -148,7 +173,7 @@ async function pictureWithTwoViewers() {
 
   /** @type {Map<string, object>} */
   const renditions = new Map();
-  manager.createOrGetSession = async (params) => {
+  manager.viewerRequests.createOrGetSession = async (params) => {
     const key = audioRenditionKey(params.audioTrackIndex, params.transcodeAudio);
     const existing = renditions.get(key);
     if (existing) {
@@ -158,11 +183,12 @@ async function pictureWithTwoViewers() {
       id: `rendition-${key}`,
       dirPath,
       audioTrackIndex: params.audioTrackIndex,
-      transcodeAudio: params.transcodeAudio
+      transcodeAudio: params.transcodeAudio,
+      audioOnly: true
     });
-    rendition.audioOnly = true;
-    startRunOn(rendition, { process: fakeEncoder() });
-    manager.sessionsById.set(rendition.id, rendition);
+    rendition.id = rendition.spec.toName();
+    startManagedRun(manager, rendition, { process: fakeEncoder() });
+    manager.outputs.set(rendition.id, rendition);
     renditions.set(key, rendition);
     return rendition;
   };
@@ -172,12 +198,12 @@ async function pictureWithTwoViewers() {
 test("one viewer fetching their soundtrack does not stop the other viewer's", async (t) => {
   const { manager, renditions, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  const first = await manager.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
-  const second = await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00003.mp4", SECOND);
+  const first = await manager.renditions.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
+  const second = await manager.renditions.resolveAudioRenditionFile(BASE_ID, 1, "segment-00003.mp4", SECOND);
 
   assert.notEqual(first.sessionId, second.sessionId, "two soundtracks are two encodes");
   for (const [key, rendition] of renditions) {
@@ -186,8 +212,8 @@ test("one viewer fetching their soundtrack does not stop the other viewer's", as
   }
 
   // And it holds under the traffic that actually happens: they alternate.
-  await manager.resolveAudioRenditionFile(BASE_ID, 0, "segment-00004.mp4", FIRST);
-  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00004.mp4", SECOND);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 0, "segment-00004.mp4", FIRST);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 1, "segment-00004.mp4", SECOND);
   for (const [key, rendition] of renditions) {
     assert.deepEqual([...rendition.runs][0]?.process?.signals ?? [], [], `nothing signalled ${key} on the second round`);
   }
@@ -196,22 +222,20 @@ test("one viewer fetching their soundtrack does not stop the other viewer's", as
 test("a soundtrack nobody is listening to any more is let go of", async (t) => {
   const { manager, base, renditions, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // One viewer only, so what they leave is left for nobody. This is the case
   // the stop exists for: an encoder AND a reader holding pieces of the torrent.
-  base.consumers = new Set([FIRST]);
-  base.viewers.delete(SECOND);
-  base.viewers.delete(SECOND);
+  manager.viewers.leaves(base, SECOND);
 
-  await manager.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
-  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00004.mp4", FIRST);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 1, "segment-00004.mp4", FIRST);
 
   const left = renditions.get(audioRenditionKey(0, true));
   const moved = renditions.get(audioRenditionKey(1, true));
-  assert.equal(watched(left), false, "the track the viewer left is nobody's now");
-  assert.ok(watched(moved), "and the track they moved to is theirs");
+  assert.equal(watched(manager, left), false, "the track the viewer left is nobody's now");
+  assert.ok(watched(manager, moved), "and the track they moved to is theirs");
   assert.deepEqual(
     [...left.runs][0]?.process?.signals ?? [],
     [],
@@ -222,35 +246,35 @@ test("a soundtrack nobody is listening to any more is let go of", async (t) => {
 test("each viewer's browser decides for itself whether its soundtrack is re-encoded", async (t) => {
   const { manager, base, renditions, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // The same track, two browsers: one can decode it as it stands, the other
   // cannot. Answering both from the session's own flag would leave the second
   // viewer with silence.
-  viewerOf(base, FIRST).audio = { trackIndex: 0, transcode: false };
-  viewerOf(base, SECOND).audio = { trackIndex: 0, transcode: true };
+  manager.viewers.of(base, FIRST).audio = { trackIndex: 0, transcode: false };
+  manager.viewers.of(base, SECOND).audio = { trackIndex: 0, transcode: true };
 
-  const copied = await manager.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
-  const encoded = await manager.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", SECOND);
+  const copied = await manager.renditions.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
+  const encoded = await manager.renditions.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", SECOND);
 
   assert.notEqual(copied.sessionId, encoded.sessionId);
   assert.equal(renditions.get(audioRenditionKey(0, false)).transcodeAudio, false);
   assert.equal(renditions.get(audioRenditionKey(0, true)).transcodeAudio, true);
   // Both are wanted, so neither is stopped.
-  assert.ok(encoding(renditions.get(audioRenditionKey(0, false))));
-  assert.ok(encoding(renditions.get(audioRenditionKey(0, true))));
+  assert.ok(encoding(manager, renditions.get(audioRenditionKey(0, false))));
+  assert.ok(encoding(manager, renditions.get(audioRenditionKey(0, true))));
 });
 
 test("the master marks each viewer's own soundtrack as the default one", async (t) => {
   const { manager, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
 
-  const forFirst = manager.buildMasterPlaylist(BASE_ID, FIRST);
-  const forSecond = manager.buildMasterPlaylist(BASE_ID, SECOND);
+  const forFirst = manager.renditions.buildMasterPlaylist(BASE_ID, FIRST);
+  const forSecond = manager.renditions.buildMasterPlaylist(BASE_ID, SECOND);
 
   const defaultsOf = (master) =>
     [...master.matchAll(/^#EXT-X-MEDIA:.*?NAME="([^"]+)".*?DEFAULT=(YES|NO)/gm)]
@@ -264,53 +288,62 @@ test("the master marks each viewer's own soundtrack as the default one", async (
 test("one viewer changing quality does not take the other off their step", async (t) => {
   const { manager, base, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   /** @type {Map<number, object>} */
   const variants = new Map();
-  manager.createOrGetSession = async (params) => {
+  manager.viewerRequests.createOrGetSession = async (params) => {
     const height = params.targetHeight;
     const existing = variants.get(height);
     if (existing) {
       return existing;
     }
-    const variant = fakeSession({ id: `variant-${height}`, dirPath });
+    // A STEP CARRIES WHAT ITS PICTURE CARRIES. This picture publishes its
+    // soundtrack separately, so its steps do too — which is what production
+    // passes (`audioRenditions: servesAudioSeparately(base)`). Built muxed, a
+    // step is not the same material as the picture it is a step of, and is
+    // rightly refused.
+    const variant = fakeSession({ id: `variant-${height}`, dirPath, encodeHeight: height, audioSeparate: true });
     variant.transcodeVideo = true;
     variant.output.encodeHeight = height;
     variant.variantHeight = height;
     variant.isStep = true;
+    manager.outputs.markStep(variant);
     variant.file = base.file;
-    startRunOn(variant, { process: fakeEncoder() });
-    manager.sessionsById.set(variant.id, variant);
+    startManagedRun(manager, variant, { process: fakeEncoder() });
+    manager.outputs.set(variant.id, variant);
     variants.set(height, variant);
     return variant;
   };
 
-  await manager.resolveVariantFile(BASE_ID, 720, "segment-00003.mp4", FIRST);
-  await manager.resolveVariantFile(BASE_ID, 540, "segment-00003.mp4", SECOND);
+  await manager.renditions.resolveVariantFile(BASE_ID, 720, "segment-00003.mp4", FIRST);
+  manager.renditions.viewerPlays(BASE_ID, FIRST, 720, 12);
+  await manager.renditions.resolveVariantFile(BASE_ID, 540, "segment-00003.mp4", SECOND);
+  manager.renditions.viewerPlays(BASE_ID, SECOND, 540, 12);
   // Both viewers go on watching their own step, which is what a player does
   // every few seconds.
-  await manager.resolveVariantFile(BASE_ID, 720, "segment-00004.mp4", FIRST);
-  await manager.resolveVariantFile(BASE_ID, 540, "segment-00004.mp4", SECOND);
+  await manager.renditions.resolveVariantFile(BASE_ID, 720, "segment-00004.mp4", FIRST);
+  await manager.renditions.resolveVariantFile(BASE_ID, 540, "segment-00004.mp4", SECOND);
 
-  assert.ok(encoding(variants.get(720)), "the first viewer's step is still encoding");
-  assert.ok(encoding(variants.get(540)), "and so is the second viewer's");
+  assert.ok(encoding(manager, variants.get(720)), "the first viewer's step is still encoding");
+  assert.ok(encoding(manager, variants.get(540)), "and so is the second viewer's");
 
   // Now the first viewer steps down. Theirs is left for nobody and stops; the
   // other viewer's is untouched.
-  await manager.resolveVariantFile(BASE_ID, 480, "segment-00005.mp4", FIRST);
+  await manager.renditions.resolveVariantFile(BASE_ID, 480, "segment-00005.mp4", FIRST);
+  manager.renditions.viewerPlays(BASE_ID, FIRST, 480, 20);
 
-  assert.equal(watched(variants.get(720)), false, "the step nobody is on is nobody's");
-  assert.ok(watched(variants.get(540)), "the step the other viewer is watching stays theirs");
-  assert.ok(watched(variants.get(480)), "and the one they moved to is now theirs");
-  assert.ok(encoding(variants.get(540)), "and nothing here touched the other viewer's encoder");
+  assert.equal(watched(manager, variants.get(720)), false, "the step nobody is on is nobody's");
+  assert.ok(watched(manager, variants.get(540)), "the step the other viewer is watching stays theirs");
+  assert.ok(watched(manager, variants.get(480)), "and the one they moved to is now theirs");
+  assert.ok(encoding(manager, variants.get(540)), "and nothing here touched the other viewer's encoder");
 });
 
 test("a step somebody is watching is never withdrawn from the offer", async (t) => {
   const { manager, base, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // A host that can re-encode 240p and nothing above it — the shape of the
@@ -330,20 +363,20 @@ test("a step somebody is watching is never withdrawn from the offer", async (t)
   // One file, two sessions of it.
   variant.file = base.file;
   variant.isStep = true;
+  manager.outputs.markStep(variant);
   variant.file = base.file;
-  manager.sessionsById.set(variant.id, variant);
-  base.file.stepHeights.set(720, 720);
+  manager.outputs.set(variant.id, variant);
 
   // Nobody on it: measured below realtime, it is withdrawn. This half is the
   // control — without it the other half proves nothing.
-  const withoutAViewer = manager.offeredHeights(base);
+  const withoutAViewer = manager.quality.offeredHeights(base);
   assert.ok(
     !withoutAViewer.includes(720),
     `a step nobody is on and that cannot keep up is withdrawn: ${withoutAViewer.join(" ")}`
   );
 
-  viewerOf(base, SECOND).activeVariantId = variant.id;
-  const withAViewer = manager.offeredHeights(base);
+  manager.viewers.of(base, SECOND).activeVariantId = variant.id;
+  const withAViewer = manager.quality.offeredHeights(base);
 
   assert.ok(
     withAViewer.includes(720),
@@ -354,20 +387,20 @@ test("a step somebody is watching is never withdrawn from the offer", async (t)
 test("a viewer whose picture has gone quiet holds no soundtrack encoder", async (t) => {
   const { manager, base, renditions, dirPath } = await pictureWithTwoViewers();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
-  await manager.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
-  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00003.mp4", SECOND);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 0, "segment-00003.mp4", FIRST);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 1, "segment-00003.mp4", SECOND);
   // The second viewer's tab is gone. Nothing releases the session when a
   // channel closes (roadmap item 54), so what expires is their head on the
   // picture — and with it their claim on an encoder.
-  base.viewers.delete(SECOND);
+  manager.viewers.leaves(base, SECOND);
 
-  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00004.mp4", FIRST);
+  await manager.renditions.resolveAudioRenditionFile(BASE_ID, 1, "segment-00004.mp4", FIRST);
 
   assert.equal(
-    watched(renditions.get(audioRenditionKey(0, true))),
+    watched(manager, renditions.get(audioRenditionKey(0, true))),
     false,
     "the first viewer moved on, so their old track is nobody's"
   );

package/test/upload-hurry.test.js

@@ -17,9 +17,9 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { decideUploadLimit, torrentsForUploadPolicy } from "../services/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/download/registry.js";
-import { Urgency } from "../services/demand/index.js";
+import { decideUploadLimit, torrentsForUploadPolicy } from "../services/torrent/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
+import { Urgency } from "../services/torrent/demand/index.js";
 
 /**
  * A torrent whose metadata has arrived and which nothing is wanted of.

package/test/usrsctp-state.test.js

@@ -11,7 +11,7 @@ import test from "node:test";
 import assert from "node:assert/strict";
 import { EventEmitter } from "node:events";
 
-import { createUsrsctpStateReader, SCTPSTATE_SCRIPT_PATH } from "../services/usrsctp-state.js";
+import { createUsrsctpStateReader, SCTPSTATE_SCRIPT_PATH } from "../services/transport/usrsctp-state.js";
 
 class FakeChild extends EventEmitter {
   constructor(command, args) {

package/test/video-facts.test.js

@@ -17,7 +17,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { Container } from "../services/container/Container.js";
+import { Container } from "../services/media/container/Container.js";
 
 const banner = (fields) => ({ width: null, height: null, fps: null, isHdr: false, bitDepth: null, ...fields });