@torrent-tv/proxy 2.86.0 → 2.87.1

package/test/priority-map-per-output.test.js

@@ -1,209 +1,215 @@
-/**
- * @file One fact asked at two scopes: what the swarm is asked for, and what the
- * encoders are placed by.
- *
- * Both are right for what asks them. The swarm is asked for bytes of a FILE,
- * and the picture, a quality step and a soundtrack of one film read the same
- * bytes — so every viewer of any of them wants that file's bytes. Encoders are
- * placed per OUTPUT, and a person watching 480p wants nothing of the 1080p
- * output at all.
- *
- * One map for both was the second authority over encoders. Every output of a
- * film was handed the whole film's map, so the plan wanted an encoder on every
- * one of them; what actually stopped the ones nobody was watching was the
- * session manager killing them by its own judgement — and since a viewer moving
- * between steps also announces itself, the plan started them again on the next
- * pass. Field 2026-09-08.
- *
- * Built out of the real classes throughout: the real viewer registry holds real
- * viewers, the real `LiveOutputs` answers what a film's shape is, and the real
- * `PriorityOrchestrator` builds the maps. A session is a plain object in this
- * proxy — there is no class for one — so the literals below are the thing
- * itself and not a stand-in for it.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { PriorityOrchestrator } from "../services/priority/PriorityOrchestrator.js";
-import { LiveOutputs } from "../services/output/LiveOutputs.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-import { viewersOf } from "../services/viewer/Viewer.js";
-import { runsOf } from "../services/priority/PriorityMap.js";
-
-const FILM = { sourceKey: "source-1", fileIndex: 0, durationSeconds: 600 };
-const STALE_AFTER_MS = 60_000;
-
-/**
- * A session, as much of one as these classes read.
- *
- * @param {{ id: string, outputKey: string, isStep?: boolean, audioOnly?: boolean }} params
- * @returns {object}
- */
-function outputOf({ id, outputKey, isStep = false, audioOnly = false }) {
-  return {
-    id,
-    outputKey,
-    isStep,
-    audioOnly,
-    state: "ready",
-    sourceKey: FILM.sourceKey,
-    fileIndex: FILM.fileIndex,
-    file: { key: "film-1", durationSeconds: FILM.durationSeconds }
-  };
-}
-
-/**
- * The real orchestrator over the real registry, wired the way the session
- * manager wires it.
- *
- * @param {object[]} sessions
- * @returns {{ priority: PriorityOrchestrator, viewers: Viewers, publish: () => void }}
- */
-function over(sessions) {
-  const live = new LiveOutputs({ sessionsById: new Map(sessions.map((one) => [one.id, one])) });
-  const viewers = new Viewers();
-  const priority = new PriorityOrchestrator({
-    publish: () => {},
-    viewersOf: (session) => viewersOf(session),
-    allowanceFor: () => 10,
-    watchedBy: (session, viewer) => !live.supersededBy(session, viewer.activeVariantId ?? null)
-  });
-  return {
-    priority,
-    viewers,
-    live,
-    publish: () => priority.publishFor({ sessionGroups: [sessions], staleAfterMs: STALE_AFTER_MS })
-  };
-}
-
-test("a person on a step wants nothing of the picture they stepped off", () => {
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const step = outputOf({ id: "step", outputKey: "out:480", isStep: true });
-  const { priority, viewers, publish } = over([picture, step]);
-  // ONE viewer object per person, referenced from both outputs — which is why
-  // the step they are on is known when the picture is asked about.
-  viewers.of(picture, "p");
-  const person = viewers.of(step, "p");
-  person.moveTo(300);
-  person.activeVariantId = "step";
-  publish();
-
-  assert.ok(
-    runsOf(priority.mapForOutput("out:480")).length > 0,
-    "the step they are watching is wanted"
-  );
-  assert.deepEqual(
-    runsOf(priority.mapForOutput("out:1080")),
-    [],
-    "and the picture is producing for nobody, which is what makes its encoder unwanted"
-  );
-  // The bytes are another matter: both outputs read the same file, and the
-  // swarm is asked for the file.
-  assert.ok(
-    runsOf(priority.mapFor(FILM.sourceKey, FILM.fileIndex)).length > 0,
-    "the download still wants the film, because that is what is being watched"
-  );
-});
-
-test("a soundtrack is wanted by whoever is registered on it", () => {
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const sound = outputOf({ id: "rus", outputKey: "out:a1", audioOnly: true });
-  const { priority, viewers, publish } = over([picture, sound]);
-  // Standing on a STEP of the picture says nothing about the sound: the tracks
-  // nobody chose are let go of where a track is chosen, so being known to a
-  // soundtrack is listening to it.
-  const person = viewers.of(sound, "p");
-  person.moveTo(120);
-  person.activeVariantId = "step";
-  publish();
-
-  assert.ok(runsOf(priority.mapForOutput("out:a1")).length > 0);
-});
-
-test("a step being warmed is wanted, and so is the picture still on screen", () => {
-  // Both are genuinely being produced through a warm-up, which is the price of
-  // the switch not being visible. Whether the machine can afford two encoders
-  // is the budget's question and not this one's.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const step = outputOf({ id: "step", outputKey: "out:480", isStep: true });
-  const { priority, viewers, publish } = over([picture, step]);
-  viewers.of(picture, "p");
-  const person = viewers.of(step, "p");
-  person.moveTo(300);
-  person.warmingVariantId = "step";
-  publish();
-
-  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0, "still on screen");
-  assert.ok(runsOf(priority.mapForOutput("out:480")).length > 0, "being made ready");
-});
-
-test("an output everybody has left is stated as empty, not left as it was", () => {
-  // The difference matters: the plan stops the encoders of an output whose map
-  // is empty, and would keep the map it had when somebody was watching.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const { priority, viewers, publish } = over([picture]);
-  viewers.of(picture, "p").moveTo(300);
-
-  publish();
-  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0);
-
-  viewers.leaves(picture, "p");
-  publish();
-  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), []);
-});
-
-test("a viewer who has gone is not watching anything", () => {
-  // Presence is the connection and nothing else. Silence — however long — is a
-  // paused viewer, a throttled hidden tab, or a full cushion, and none of those
-  // is leaving; what ends it is a statement.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const live = new LiveOutputs({ sessionsById: new Map([["pic", picture]]) });
-  const viewers = new Viewers();
-  const priority = new PriorityOrchestrator({
-    publish: () => {},
-    viewersOf: (session) => viewersOf(session),
-    allowanceFor: () => 10,
-    watchedBy: (session, viewer) => !live.supersededBy(session, viewer.activeVariantId ?? null)
-  });
-  const person = viewers.of(picture, "p");
-  person.moveTo(300);
-  viewers.leaves(picture, "p");
-
-  priority.publishFor({ sessionGroups: [[picture]], now: Date.now() });
-
-  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), []);
-});
-
-test("a file and an output that are gone are forgotten", () => {
-  // These are the projection of the live sessions, never a memory of them. Left
-  // to accumulate they were three maps that only grew, and `forget` was written
-  // for that and called from nowhere.
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const { priority, viewers, publish } = over([picture]);
-  viewers.of(picture, "p").moveTo(300);
-
-  publish();
-  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0);
-
-  priority.publishFor({ sessionGroups: [[]], staleAfterMs: STALE_AFTER_MS });
-  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), [], "the output is gone");
-  assert.deepEqual(
-    runsOf(priority.mapFor(FILM.sourceKey, FILM.fileIndex)),
-    [],
-    "and so is the file"
-  );
-});
-
-test("the picture is watched by a person who never moved off it", () => {
-  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
-  const { viewers, live } = over([picture]);
-  const person = viewers.of(picture, "p");
-
-  assert.equal(live.supersededBy(picture, null), false, "no step is active");
-  person.activeVariantId = "pic";
-  assert.equal(
-    live.supersededBy(picture, person.activeVariantId),
-    false,
-    "and naming the picture itself as the step is the same statement"
-  );
-});
+/**
+ * @file One fact asked at two scopes: what the swarm is asked for, and what the
+ * encoders are placed by.
+ *
+ * Both are right for what asks them. The swarm is asked for bytes of a FILE,
+ * and the picture, a quality step and a soundtrack of one film read the same
+ * bytes — so every viewer of any of them wants that file's bytes. Encoders are
+ * placed per OUTPUT, and a person watching 480p wants nothing of the 1080p
+ * output at all.
+ *
+ * One map for both was the second authority over encoders. Every output of a
+ * film was handed the whole film's map, so the plan wanted an encoder on every
+ * one of them; what actually stopped the ones nobody was watching was the
+ * session manager killing them by its own judgement — and since a viewer moving
+ * between steps also announces itself, the plan started them again on the next
+ * pass. Field 2026-09-08.
+ *
+ * Built out of the real classes throughout: the real viewer registry holds real
+ * viewers, the real `OutputCatalog` answers what a film's shape is, and the real
+ * `PriorityOrchestrator` builds the maps. A session is a plain object in this
+ * proxy — there is no class for one — so the literals below are the thing
+ * itself and not a stand-in for it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { PriorityOrchestrator } from "../services/viewer/PriorityOrchestrator.js";
+import { OutputCatalog } from "../services/encode/output/OutputCatalog.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+import { runsOf } from "../services/viewer/PriorityMap.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const FILM = { sourceKey: "source-1", fileIndex: 0, durationSeconds: 600 };
+const STALE_AFTER_MS = 60_000;
+
+/**
+ * A session, as much of one as these classes read.
+ *
+ * @param {{ id: string, outputKey: string, isStep?: boolean, audioOnly?: boolean }} params
+ * @returns {object}
+ */
+function outputOf({ id, outputKey, isStep = false, audioOnly = false }) {
+  return {
+    id,
+    spec: outputSpec({ sourceKey: FILM.sourceKey, audioOnly }),
+    outputKey,
+    isStep,
+    audioOnly,
+    state: "ready",
+    sourceKey: FILM.sourceKey,
+    fileIndex: FILM.fileIndex,
+    file: { key: "film-1", durationSeconds: FILM.durationSeconds }
+  };
+}
+
+/**
+ * The real orchestrator over the real registry, wired the way the session
+ * manager wires it.
+ *
+ * @param {object[]} sessions
+ * @returns {{ priority: PriorityOrchestrator, viewers: Viewers, publish: () => void }}
+ */
+function over(sessions) {
+  const live = new OutputCatalog();
+  for (const one of sessions) {
+    live.set(one.id, one);
+    if (one.isStep) live.markStep(one);
+  }
+  const viewers = new Viewers();
+  const priority = new PriorityOrchestrator({
+    publish: () => {},
+    viewers,
+    allowanceFor: () => 10,
+    watchedBy: (session, viewer) => !live.supersededBy(session, viewer.activeVariantId ?? null)
+  });
+  return {
+    priority,
+    viewers,
+    live,
+    publish: () => priority.publishFor({ sessionGroups: [sessions], staleAfterMs: STALE_AFTER_MS })
+  };
+}
+
+test("a person on a step wants nothing of the picture they stepped off", () => {
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const step = outputOf({ id: "step", outputKey: "out:480", isStep: true });
+  const { priority, viewers, publish } = over([picture, step]);
+  // ONE viewer object per person, referenced from both outputs — which is why
+  // the step they are on is known when the picture is asked about.
+  viewers.of(picture, "p");
+  const person = viewers.of(step, "p");
+  person.moveTo(300);
+  person.activeVariantId = "step";
+  publish();
+
+  assert.ok(
+    runsOf(priority.mapForOutput("out:480")).length > 0,
+    "the step they are watching is wanted"
+  );
+  assert.deepEqual(
+    runsOf(priority.mapForOutput("out:1080")),
+    [],
+    "and the picture is producing for nobody, which is what makes its encoder unwanted"
+  );
+  // The bytes are another matter: both outputs read the same file, and the
+  // swarm is asked for the file.
+  assert.ok(
+    runsOf(priority.mapFor(FILM.sourceKey, FILM.fileIndex)).length > 0,
+    "the download still wants the film, because that is what is being watched"
+  );
+});
+
+test("a soundtrack is wanted by whoever is registered on it", () => {
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const sound = outputOf({ id: "rus", outputKey: "out:a1", audioOnly: true });
+  const { priority, viewers, publish } = over([picture, sound]);
+  // Standing on a STEP of the picture says nothing about the sound: the tracks
+  // nobody chose are let go of where a track is chosen, so being known to a
+  // soundtrack is listening to it.
+  const person = viewers.of(sound, "p");
+  person.moveTo(120);
+  person.activeVariantId = "step";
+  publish();
+
+  assert.ok(runsOf(priority.mapForOutput("out:a1")).length > 0);
+});
+
+test("a step being warmed is wanted, and so is the picture still on screen", () => {
+  // Both are genuinely being produced through a warm-up, which is the price of
+  // the switch not being visible. Whether the machine can afford two encoders
+  // is the budget's question and not this one's.
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const step = outputOf({ id: "step", outputKey: "out:480", isStep: true });
+  const { priority, viewers, publish } = over([picture, step]);
+  viewers.of(picture, "p");
+  const person = viewers.of(step, "p");
+  person.moveTo(300);
+  person.warmingVariantId = "step";
+  publish();
+
+  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0, "still on screen");
+  assert.ok(runsOf(priority.mapForOutput("out:480")).length > 0, "being made ready");
+});
+
+test("an output everybody has left is stated as empty, not left as it was", () => {
+  // The difference matters: the plan stops the encoders of an output whose map
+  // is empty, and would keep the map it had when somebody was watching.
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const { priority, viewers, publish } = over([picture]);
+  viewers.of(picture, "p").moveTo(300);
+
+  publish();
+  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0);
+
+  viewers.leaves(picture, "p");
+  publish();
+  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), []);
+});
+
+test("a viewer who has gone is not watching anything", () => {
+  // Presence is the connection and nothing else. Silence — however long — is a
+  // paused viewer, a throttled hidden tab, or a full cushion, and none of those
+  // is leaving; what ends it is a statement.
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const live = new OutputCatalog();
+  live.set("pic", picture);
+  const viewers = new Viewers();
+  const priority = new PriorityOrchestrator({
+    publish: () => {},
+    viewers,
+    allowanceFor: () => 10,
+    watchedBy: (session, viewer) => !live.supersededBy(session, viewer.activeVariantId ?? null)
+  });
+  const person = viewers.of(picture, "p");
+  person.moveTo(300);
+  viewers.leaves(picture, "p");
+
+  priority.publishFor({ sessionGroups: [[picture]], now: Date.now() });
+
+  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), []);
+});
+
+test("a file and an output that are gone are forgotten", () => {
+  // These are the projection of the live sessions, never a memory of them. Left
+  // to accumulate they were three maps that only grew, and `forget` was written
+  // for that and called from nowhere.
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const { priority, viewers, publish } = over([picture]);
+  viewers.of(picture, "p").moveTo(300);
+
+  publish();
+  assert.ok(runsOf(priority.mapForOutput("out:1080")).length > 0);
+
+  priority.publishFor({ sessionGroups: [[]], staleAfterMs: STALE_AFTER_MS });
+  assert.deepEqual(runsOf(priority.mapForOutput("out:1080")), [], "the output is gone");
+  assert.deepEqual(
+    runsOf(priority.mapFor(FILM.sourceKey, FILM.fileIndex)),
+    [],
+    "and so is the file"
+  );
+});
+
+test("the picture is watched by a person who never moved off it", () => {
+  const picture = outputOf({ id: "pic", outputKey: "out:1080" });
+  const { viewers, live } = over([picture]);
+  const person = viewers.of(picture, "p");
+
+  assert.equal(live.supersededBy(picture, null), false, "no step is active");
+  person.activeVariantId = "pic";
+  assert.equal(
+    live.supersededBy(picture, person.activeVariantId),
+    false,
+    "and naming the picture itself as the step is the same statement"
+  );
+});

package/test/priority-map.test.js

@@ -20,7 +20,7 @@ import {
   mapForViewer,
   mergeMaps,
   runsOf
-} from "../services/priority/PriorityMap.js";
+} from "../services/viewer/PriorityMap.js";
 
 const FILM = 3600;
 const ALLOWANCE = 8;

package/test/probe-wedge-certainty.test.js

@@ -1,7 +1,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { probeWedgeIsCertain, readProbeState, PROBE_INTERVAL_MS } from "../services/delivery-probe.js";
+import { probeWedgeIsCertain, readProbeState, PROBE_INTERVAL_MS } from "../services/transport/delivery-probe.js";
 
 test("a seen-counter bounded lag is not a wedge, however long it lasts", () => {
   // Session 4dcac61b, field log 2026-08-28: gap held at 6-7 probes for 95+

package/test/produced-copy-choice.test.js

@@ -21,20 +21,21 @@
 
 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 { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
 import { mkdtemp, readdir, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { HlsSessionManager, usableSegmentIndices } from "../services/hls-session-manager.js";
+import { managerWithOwnStore } from "./helpers/manager.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";
+import { outputSpec } from "./helpers/output-spec.js";
 
 const MOVIE_TIMESCALE = 1000;
 const VIDEO_TIMESCALE = 90_000;
 const AUDIO_TIMESCALE = 48_000;
 const SEGMENT_SECONDS = 12.5;
-const SESSION_ID = "aef21c88-a8d6-4a9a-8e7a-d0a9536351cf";
+const SESSION_ID = "aef21c88a8d64a9a";
 
 /**
  * @param {string} type
@@ -119,18 +120,15 @@ function wholePiece(offsetSeconds) {
 /**
  * A session with the output directory every run writes into.
  *
- * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
+ * @returns {Promise<{ manager: object, session: object, dirPath: string }>}
  */
 async function sessionOnOneDirectory() {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "produced-copy-"));
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
+  // Its own store root — see `helpers/manager.js` for what sharing one cost.
+  const { manager } = managerWithOwnStore();
   const session = {
     id: SESSION_ID,
+    spec: outputSpec({ transcodeVideo: false }),
     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.
@@ -145,20 +143,16 @@ async function sessionOnOneDirectory() {
     get inputFile() { return this.file; },
     get audioFile() { return this.file; },
     startedAt: Date.now(),
-    createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     runs: new Set(),
     lastError: "",
-    consumers: new Set(),
-    viewers: new Map(),
     segmentFormat: fmp4Format,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
     initBytes: fmp4Format.extractInit(wholePiece(0)),
-    firstSegmentLogged: false,
     waitEpoch: 0
   };
-  manager.sessionsById.set(SESSION_ID, session);
+  manager.outputs.set(SESSION_ID, session);
   // A run exists and is alive — the state the field case was in, and the one in
   // which the old test called every leftover "still being written".
   startRunOn(session, { from: 0, usesExplicitCuts: true });
@@ -170,7 +164,7 @@ async function sessionOnOneDirectory() {
 test("a leftover of a run that has ended is not served, and answering does not delete it", async (t) => {
   const { manager, session, dirPath } = await sessionOnOneDirectory();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // Opened by a run that is gone. It has a name and no bytes, so there is
@@ -178,7 +172,7 @@ test("a leftover of a run that has ended is not served, and answering does not d
   session.runs = new Set();
   await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
 
-  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
 
   assert.equal(result.kind, "warming-up", "nothing servable exists yet, so the viewer waits");
   // AND ANSWERING A REQUEST DELETES NOTHING. It used to: this test was written
@@ -198,7 +192,7 @@ test("a leftover of a run that has ended is not served, and answering does not d
 test("the current run's own unfinished piece is waited for, never deleted", async (t) => {
   const { manager, session, dirPath } = await sessionOnOneDirectory();
   t.after(async () => {
-    await manager.disposeAll();
+    await manager.lifecycle.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
   // The same file, in the directory of the run that is alive. It is being
@@ -210,49 +204,10 @@ test("the current run's own unfinished piece is waited for, never deleted", asyn
   startRunOn(session, { from: 1, producing: false, usesExplicitCuts: true });
   await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
 
-  const result = await manager.getFileStream(SESSION_ID, "segment-00001.mp4", { requestSeq: 1 });
+  const result = await manager.serving.getFileStream(SESSION_ID, "segment-00001.mp4");
 
   assert.equal(result.kind, "warming-up");
   const left = (await readdir(dirPath)).filter((name) => name === "segment-00001.mp4");
   assert.deepEqual(left, ["segment-00001.mp4"], "the live run's own output must be left alone");
 });
 
-test("the look-ahead does not count a file with nothing in it", async (t) => {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "usable-indices-"));
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), Buffer.alloc(0));
-
-  assert.deepEqual(
-    [...usableSegmentIndices([dirPath], fmp4Format, new Set())].sort((a, b) => a - b),
-    [0],
-    "an empty file bridged the hole and bought the encoder a suspension it had not earned"
-  );
-
-  // The same number, made properly: now it genuinely is ready.
-  await writeFile(path.join(dirPath, "segment-00001.mp4"), wholePiece(SEGMENT_SECONDS));
-  assert.deepEqual(
-    [...usableSegmentIndices([dirPath], fmp4Format, new Set())].sort((a, b) => a - b),
-    [0, 1],
-    "a copy with bytes in it, which is what the serving path will find"
-  );
-});
-
-test("what the output holds is asked of the filesystem once per file", async (t) => {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "usable-memo-"));
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  await writeFile(path.join(dirPath, "segment-00000.mp4"), wholePiece(0));
-  const known = new Set();
-
-  usableSegmentIndices([dirPath], fmp4Format, known);
-
-  assert.deepEqual(
-    [...known],
-    [path.join(dirPath, "segment-00000.mp4")],
-    "a piece that has bytes never loses them, and this runs on the thread carrying the data channel"
-  );
-});