@torrent-tv/proxy 2.85.1 → 2.87.0

package/test/segment-store.test.js

@@ -8,8 +8,8 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { directoryNameFor, SegmentStore } from "../services/encode/SegmentStore.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { directoryNameFor, SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 
 /**
  * @returns {{ store: SegmentStore, root: string, lines: string[] }}
@@ -37,7 +37,14 @@ const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 
 test("two viewers of one output are given the same directory", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   // Which viewer asked never enters it — the address is what the segments are.
   assert.equal(store.directoryFor(KEY), store.directoryFor(KEY));
@@ -46,7 +53,14 @@ test("two viewers of one output are given the same directory", (t) => {
 
 test("the directory says what it holds, so a later process can tell", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   const names = readdirSync(dir);
@@ -55,7 +69,14 @@ test("the directory says what it holds, so a later process can tell", (t) => {
 
 test("a piece under its served name is finished, and the last one too", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, fmp4Format);
@@ -72,7 +93,14 @@ test("a piece under its served name is finished, and the last one too", (t) => {
 
 test("a piece still being written is not a piece, and its name says so", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, fmp4Format);
@@ -91,7 +119,14 @@ test("a piece still being written is not a piece, and its name says so", (t) =>
 
 test("a file of no bytes is not a segment, whatever it is called", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, fmp4Format);
@@ -109,7 +144,14 @@ test("a file of no bytes is not a segment, whatever it is called", (t) => {
 
 test("clearing up after one run leaves every other run's work alone", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, fmp4Format);
@@ -134,7 +176,14 @@ test("clearing up after one run leaves every other run's work alone", (t) => {
 
 test("a directory that has not moved is not read again", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, fmp4Format);
@@ -148,7 +197,14 @@ test("a directory that has not moved is not read again", (t) => {
 
 test("what a killed process left is found, named and counted", (t) => {
   const { store, root, lines } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = path.join(root, directoryNameFor(KEY));
   mkdirSync(dir, { recursive: true });
@@ -169,7 +225,14 @@ test("what a killed process left is found, named and counted", (t) => {
 
 test("what survived a kill is taken back whole, minus what was still being written", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = path.join(root, directoryNameFor(KEY));
   mkdirSync(dir, { recursive: true });
@@ -195,7 +258,14 @@ test("what survived a kill is taken back whole, minus what was still being writt
 
 test("a directory that cannot name itself is thrown away rather than served", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const orphan = path.join(root, "0123456789abcdef");
   mkdirSync(orphan, { recursive: true });
@@ -210,7 +280,14 @@ test("a directory that cannot name itself is thrown away rather than served", (t
 
 test("an output this proxy can no longer serve is thrown away too", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = path.join(root, directoryNameFor(KEY));
   mkdirSync(dir, { recursive: true });
@@ -225,7 +302,14 @@ test("an output this proxy can no longer serve is thrown away too", (t) => {
 
 test("what the store weighs is reported, and dropping one output frees it", (t) => {
   const { store, root } = storeInATempRoot();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+  t.after(() => {
+    // The store lets its directories go, and only then is the root removed: it
+    // holds a watch on each of them — that is how a piece closed by a muxer
+    // with no channel of its own becomes an event — and a directory with an
+    // open watch cannot be removed on Windows.
+    store.dropAll("the check is over");
+    rmSync(root, { recursive: true, force: true });
+  });
 
   const dir = store.directoryFor(KEY);
   store.useFormat(KEY, fmp4Format);

package/test/segment-true-start.test.js

@@ -15,7 +15,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readSelfContainedStartSeconds } from "../services/segment-formats/mp4-boxes.js";
+import { readSelfContainedStartSeconds } from "../services/encode/segment-formats/mp4-boxes.js";
 
 /**
  * A minimal MP4 carrying `moov > mvhd` and `moov > trak > edts > elst`, with a

package/test/segments-are-shared.test.js

@@ -15,24 +15,25 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
+import { SourceFile } from "../services/media/SourceFile.js";
 import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { SegmentStore } from "../services/encode/SegmentStore.js";
-import { Timeline } from "../services/output/Timeline.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { outputSpec } from "./helpers/output-spec.js";
 
 const OUTPUT_KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 
 /**
- * @returns {{ manager: HlsSessionManager, store: SegmentStore, root: string }}
+ * @returns {{ manager: object, store: SegmentStore, root: string }}
  */
 function managerOverATempStore() {
   const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
   const store = new SegmentStore({ root });
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -52,6 +53,7 @@ function managerOverATempStore() {
 function sessionOn({ id, dirPath, outputKey }) {
   return {
     id,
+    spec: outputSpec({ transcodeVideo: false }),
     outputKey,
     dirPath,
     state: "ready",
@@ -63,7 +65,6 @@ function sessionOn({ id, dirPath, outputKey }) {
     segmentFormat: fmp4Format,
     // Where the file is cut, which every live session holds.
     timeline: new Timeline({ boundaries: [0, 4, 8], cutGrid: "keyframe" }),
-    consumers: new Set(),
     lastAccessedAt: Date.now()
   };
 }
@@ -93,12 +94,12 @@ test("each session serves the segments the other one's encoder made", (t) => {
 
   const viewerOne = sessionOn({ id: "s-one", dirPath, outputKey: OUTPUT_KEY });
   const viewerTwo = sessionOn({ id: "s-two", dirPath, outputKey: OUTPUT_KEY });
-  manager.sessionsById.set(viewerOne.id, viewerOne);
-  manager.sessionsById.set(viewerTwo.id, viewerTwo);
+  manager.outputs.set(viewerOne.id, viewerOne);
+  manager.outputs.set(viewerTwo.id, viewerTwo);
 
   const sorted = (numbers) => [...numbers].sort((left, right) => left - right);
-  const heldByOne = sorted(manager.producedSegmentNumbers(viewerOne));
-  const heldByTwo = sorted(manager.producedSegmentNumbers(viewerTwo));
+  const heldByOne = sorted(manager.serving.producedSegmentNumbers(viewerOne));
+  const heldByTwo = sorted(manager.serving.producedSegmentNumbers(viewerTwo));
 
   assert.deepEqual(heldByOne, [0, 100]);
   assert.deepEqual(heldByTwo, [0, 100], "neither viewer's session is the owner of either run");
@@ -114,11 +115,11 @@ test("a session leaving does not take the segments with it", async (t) => {
 
   const viewerOne = sessionOn({ id: "s-one", dirPath, outputKey: OUTPUT_KEY });
   const viewerTwo = sessionOn({ id: "s-two", dirPath, outputKey: OUTPUT_KEY });
-  manager.sessionsById.set(viewerOne.id, viewerOne);
-  manager.sessionsById.set(viewerTwo.id, viewerTwo);
+  manager.outputs.set(viewerOne.id, viewerOne);
+  manager.outputs.set(viewerTwo.id, viewerTwo);
 
-  await manager.disposeSession(viewerOne.id);
-  await manager.disposeSession(viewerTwo.id);
+  await manager.lifecycle.disposeSession(viewerOne.id);
+  await manager.lifecycle.disposeSession(viewerTwo.id);
 
   // Both sessions are gone and the material is still here. That is the whole
   // decoupling: a session ending says nothing about whether anybody will ask

package/test/send-chunk-bytes.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { bodySender } from "../services/data-channel-handler.js";
+import { bodySender } from "../services/transport/data-channel-handler.js";
 
 /**
  * Drives the sender over a body arriving in the given read sizes, and answers

package/test/serving-existing-output.test.js

@@ -0,0 +1,102 @@
+/**
+ * @file An output already made serves a viewer when the rules decided with the
+ * user 2026-09-16 allow it, through the paths a real request takes.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { managerWithOwnStore } from "./helpers/manager.js";
+import { outputSpec } from "./helpers/output-spec.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { Output } from "../services/encode/output/Output.js";
+
+const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
+
+function hostWithA1080pOutput(t) {
+  const { manager, store, cleanup } = managerWithOwnStore({
+    startupWaitMs: 0,
+    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
+  });
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    cleanup();
+  });
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  manager.getCachedMediaInfo = () => ({ durationSeconds: 400, width: 1920, height: 1080, fps: 24 });
+  const spec = outputSpec({
+    sourceKey: TORRENT,
+    transcodeVideo: true,
+    transcodeAudio: false,
+    encoder: "h264_vaapi",
+    width: 1920,
+    height: 1080,
+    fps: 24,
+    cutGrid: "uniform"
+  });
+  const key = spec.toKey();
+  store.useFormat(key, fmp4Format);
+  // The piece at the start of the film is made.
+  writeFileSync(path.join(store.directoryFor(key), fmp4Format.segmentFileName(0)), Buffer.alloc(100));
+  const file = new SourceFile({ sourceKey: TORRENT, fileIndex: 0, name: "film.mkv" }).learn({ width: 1920, height: 1080, durationSeconds: 400 });
+  const made = {
+    id: spec.toName(),
+    spec,
+    get outputKey() { return this.spec.toKey(); },
+    file,
+    timeline: new Timeline({ boundaries: Array.from({ length: 101 }, (_, index) => index * 4), cutGrid: "uniform" }),
+    output: new Output({ encodeWidth: 1920, encodeHeight: 1080, outputFps: 24 }),
+    segmentFormat: fmp4Format,
+    useSyntheticPlaylist: true
+  };
+  manager.outputs.set(made.id, made);
+  return { manager, made };
+}
+
+function request(over) {
+  return {
+    sourceKey: TORRENT,
+    fileIndex: 0,
+    fileName: "film.mkv",
+    transcodeVideo: true,
+    transcodeAudio: false,
+    segmentFormatId: "fmp4",
+    ...over
+  };
+}
+
+test("the automatic choice is served by a better output whose piece at the viewer's position is made", async (t) => {
+  const { manager, made } = hostWithA1080pOutput(t);
+  const answered = await manager.viewerRequests.createOrGetSession(
+    request({ consumerId: "auto-viewer", targetWidth: 1280, targetHeight: 720 })
+  );
+  assert.equal(answered, made);
+});
+
+test("a size picked by hand is not served by another size", async (t) => {
+  const { manager, made } = hostWithA1080pOutput(t);
+  let answered = null;
+  try {
+    answered = await manager.viewerRequests.createOrGetSession(
+      request({ consumerId: "picker", targetWidth: 1280, targetHeight: 720, exactSize: true })
+    );
+  } catch {
+    answered = null;
+  }
+  assert.notEqual(answered, made);
+});
+
+test("a step asked for by an automatic viewer and served by the picture leaves the picture a picture", async (t) => {
+  const { manager, made } = hostWithA1080pOutput(t);
+  manager.viewers.of(made, "auto-viewer").qualityMode = "auto";
+
+  const variant = await manager.renditions.resolveVariantSession(made.id, 720, 0, "auto-viewer");
+
+  assert.equal(variant, made, "the picture already made at 1080p serves the 720p request");
+  assert.notEqual(made.isStep, true, "and is not turned into a step of itself");
+  assert.ok(manager.viewers.forOutput(made).has("auto-viewer"));
+});

package/test/serving-output.test.js

@@ -0,0 +1,102 @@
+/**
+ * @file Which existing output serves a viewer: the rules decided with the user
+ * 2026-09-16, with the viewer's own link asked in every mode and on every
+ * branch (roadmap item 97, step 11).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { chooseServingOutput } from "../services/encode/quality/serving-output.js";
+import { linkCouldCarry, loadOf, PEAK_CLASS } from "../services/encode/quality/link-budget.js";
+
+const WANTED = { width: 1824, height: 1026 };
+const NEXT_LOWER = 1280 * 720;
+
+/**
+ * @param {string} key
+ * @param {number} width
+ * @param {number} height
+ * @param {{ mbps?: number | null, peakClass?: string, readyHere?: boolean }} [over]
+ */
+function candidate(key, width, height, { mbps = 5, peakClass = PEAK_CLASS.KNOWN, readyHere = true } = {}) {
+  return { key, width, height, readyHere, load: loadOf({ mbps, peakClass: mbps === null ? PEAK_CLASS.UNKNOWN : peakClass }, null) };
+}
+
+/**
+ * @param {object} over
+ * @param {number | null} [linkMbps] - What this viewer's link measured.
+ */
+function choose(over, linkMbps = null) {
+  return chooseServingOutput({
+    mode: "auto",
+    wanted: WANTED,
+    nextLowerArea: NEXT_LOWER,
+    atRisk: false,
+    judge: (one) => linkCouldCarry(linkMbps, one.load),
+    candidates: [],
+    ...over
+  })?.key ?? null;
+}
+
+test("the same quality or higher is served, the nearest of them", () => {
+  assert.equal(choose({ candidates: [candidate("2160", 3840, 2160), candidate("1080", 1920, 1080)] }), "1080");
+});
+
+test("higher quality is not served over a link it does not fit", () => {
+  assert.equal(choose({ candidates: [candidate("1080", 1920, 1080, { mbps: 12 })] }, 10), null);
+});
+
+test("a little lower — above the next rung down — is served, and only if the link admits it", () => {
+  assert.equal(choose({ candidates: [candidate("1000", 1776, 1000)] }), "1000");
+  assert.equal(
+    choose({ candidates: [candidate("1000", 1776, 1000, { mbps: 12 })] }, 10),
+    null,
+    "a smaller picture proves nothing by itself: its own load is asked"
+  );
+});
+
+test("the next rung down or lower is served only when making the wanted format risks a wait, and only if it fits", () => {
+  const lower = [candidate("720", 1280, 720), candidate("480", 854, 480)];
+  assert.equal(choose({ candidates: lower }), null);
+  assert.equal(choose({ candidates: lower, atRisk: true }), "720");
+  assert.equal(
+    choose({ candidates: [candidate("720", 1280, 720, { mbps: 12 }), candidate("480", 854, 480, { mbps: 3 })], atRisk: true }, 10),
+    "480",
+    "the larger one does not fit this link, so it is not taken"
+  );
+});
+
+test("an output without the piece at the viewer's position spares them nothing", () => {
+  assert.equal(choose({ candidates: [candidate("1080", 1920, 1080, { readyHere: false })] }), null);
+});
+
+test("a size chosen by hand is served only exactly, and only if the link admits it", () => {
+  const candidates = [candidate("1080", 1920, 1080), candidate("exact", 1824, 1026)];
+  assert.equal(choose({ mode: "manual", candidates }), "exact");
+  assert.equal(choose({ mode: "manual", candidates: [candidate("1080", 1920, 1080)], atRisk: true }), null);
+  assert.equal(
+    choose({ mode: "manual", candidates: [candidate("exact", 1824, 1026, { mbps: 12 })] }, 10),
+    null,
+    "the size they picked, but more than their link carries: not handed over"
+  );
+});
+
+test("of two outputs of the size picked by hand, the higher limit the link admits is served", () => {
+  const candidates = [candidate("2800", 1824, 1026, { mbps: 3.64 }), candidate("1400", 1824, 1026, { mbps: 1.82 })];
+  assert.equal(choose({ mode: "manual", candidates }, 10), "2800");
+  assert.equal(choose({ mode: "manual", candidates }, 3), "1400", "the link admits only the lower limit");
+});
+
+test("a bound is taken before an average, even when the average's limit is higher", () => {
+  const candidates = [
+    candidate("estimated", 1824, 1026, { mbps: 6, peakClass: PEAK_CLASS.ESTIMATED }),
+    candidate("known", 1824, 1026, { mbps: 4, peakClass: PEAK_CLASS.KNOWN })
+  ];
+  assert.equal(choose({ mode: "manual", candidates }, 10), "known");
+});
+
+test("an output with no bound is not served against a measured link, and is while nothing measured it", () => {
+  const candidates = [candidate("hardware", 1824, 1026, { mbps: null })];
+  assert.equal(choose({ mode: "manual", candidates }, 50), null);
+  assert.equal(choose({ mode: "manual", candidates }, null), "hardware");
+});

package/test/shared-piece-store.test.js

@@ -12,7 +12,7 @@ import assert from "node:assert/strict";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { SharedPieceStore } from "../services/piece-store/shared-piece-store.js";
+import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
 
 const CHUNK = 64 * 1024;
 

package/test/source-file.test.js

@@ -12,7 +12,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/source/SourceFile.js";
+import { SourceFile, SourceFiles, sourceDecodeCharacteristics } from "../services/media/SourceFile.js";
 
 test("a file's key is the pair that identifies it, spelled in one place", () => {
   const file = new SourceFile({ sourceKey: "abc123", fileIndex: 4 });

package/test/stale-request-after-seek.test.js

@@ -19,31 +19,31 @@
  */
 
 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 test from "node:test";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
 import { startRunOn } from "./helpers/encode-run.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 
 const SEGMENT_SECONDS = 4;
 const RUN_STARTS_AT = 373;
 const BEHIND_INDEX = 371;
-const SESSION_ID = "22222222-3333-4444-5555-666666666666";
+const SESSION_ID = "2222222233334444";
 
 /**
  * A live session whose run begins at #373 and whose directory is empty, so any
  * segment request is a request for something not yet produced.
  *
- * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
+ * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
  */
 async function sessionWithRunAt373() {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -63,7 +63,6 @@ async function sessionWithRunAt373() {
     segmentFormat: fmp4Format,
     segmentCount: 900,
     startedAt: Date.now(),
-    createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     runs: new Set(),
     consumers: new Set(),
@@ -72,16 +71,15 @@ async function sessionWithRunAt373() {
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     lastError: "",
-    firstSegmentLogged: false,
     waitEpoch: 0
   };
-  manager.sessionsById.set(SESSION_ID, session);
+  manager.outputs.set(SESSION_ID, session);
   startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
   return { manager, session, dirPath };
 }
 
 /**
- * @param {HlsSessionManager} manager
+ * @param {object} manager
  * @param {object} session
  * @param {string} dirPath
  */
@@ -90,7 +88,7 @@ async function tidy(manager, session, dirPath) {
     clearTimeout(session.seekSettleTimer);
     session.seekSettleTimer = null;
   }
-  manager.sessionsById.clear();
+  manager.outputs.clear();
   manager.stop?.();
   await rm(dirPath, { recursive: true, force: true });
 }
@@ -102,12 +100,11 @@ test("a request behind where the viewer said they are does not move the encoder"
   });
 
   // The viewer stated their position: 2083.4 s, which is segment #520 here.
-  manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
+  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
 
-  await manager.getFileStream(
+  await manager.serving.getFileStream(
     SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX),
-    { requestSeq: 1 }
+    fmp4Format.segmentFileName(BEHIND_INDEX)
   );
 
   // The field log's line was `seek settle → restart at segment #370`. Nothing
@@ -136,10 +133,9 @@ test("the same traffic moves nothing when the viewer has said nothing either", a
   // spoken. That exception is the thing that was removed: a request is evidence
   // about what a player is reading, never about where a person is, and an
   // encoder placed from it is placed from a number the player picked.
-  await manager.getFileStream(
+  await manager.serving.getFileStream(
     SESSION_ID,
-    fmp4Format.segmentFileName(BEHIND_INDEX),
-    { requestSeq: 1 }
+    fmp4Format.segmentFileName(BEHIND_INDEX)
   );
 
   assert.equal(session.seekTarget ?? null, null);
@@ -152,8 +148,8 @@ test("a request cannot move the viewer's position backwards", async (t) => {
     await tidy(manager, session, dirPath);
   });
 
-  manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
+  manager.viewerRequests.requestSeek(SESSION_ID, 2083.4, "viewer-1");
+  await manager.serving.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX));
 
   assert.ok(
     Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,