@torrent-tv/proxy 2.74.1 → 2.76.0

package/test/segment-serve-wiring.test.js

@@ -17,11 +17,14 @@
 
 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 { mkdtemp, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { ENCODE_RUN_STATE } from "../services/encode-run-state.js";
+import { ENCODE_RUN_STATE } from "../services/encode/encode-run-state.js";
+import { startRunOn } from "./helpers/encode-run.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const MOVIE_TIMESCALE = 1000;
@@ -132,25 +135,35 @@ async function managerWithReadySegment(overrides = {}) {
   const session = {
     id: SESSION_ID,
     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.
+    timeline: new Timeline({
+      boundaries: [0, SEGMENT_START_SECONDS, 25],
+      cutGrid: "uniform"
+    }),
     state: "ready",
-    fileName: "video.mkv",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
+    // An ordinary session reads its own file, and its sound is inside it. The
+    // three differ only for a soundtrack shipped as a file of its own.
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
     startedAt: Date.now(),
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
-    ffmpeg: null,
+    runs: new Set(),
     lastError: "",
     consumers: new Set(),
     segmentFormat: overrides.segmentFormat ?? fmp4Format,
-    usesExplicitCuts: true,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentBoundaries: [0, SEGMENT_START_SECONDS, 25],
     initBytes: fmp4Format.extractInit(piece),
-    encodeStartIndex: 0,
     firstSegmentLogged: false,
     waitEpoch: 0
   };
   manager.sessionsById.set(SESSION_ID, session);
+  // The run in force. The fixture's segments live directly in the session
+  // directory, which is exactly what one run's directory is here.
+  startRunOn(session, { from: 0, usesExplicitCuts: true });
   return { manager, session, dirPath };
 }
 
@@ -163,11 +176,11 @@ test("serving a segment records what its real start says about the container's i
   // The tally is counted in the module tests; what this pins is that serving a
   // segment reaches it at all. A counter nothing increments reports a clean
   // index for every file forever, which is worse than no measurement.
-  session.indexCheck = { checked: 0, disagreed: 0, maxDeviationSec: 0, firstDisagreementIndex: -1, seen: new Set() };
+  session.timeline.indexCheck = { checked: 0, disagreed: 0, maxDeviationSec: 0, firstDisagreementIndex: -1, seen: new Set() };
 
   await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
-  assert.equal(session.indexCheck.checked, 1, "the boundary that was just produced must have been examined");
+  assert.equal(session.timeline.indexCheck.checked, 1, "the boundary that was just produced must have been examined");
 });
 
 test("a segment that exists is served, not reported as still being produced", async (t) => {
@@ -202,7 +215,7 @@ test("a segment that exists is served, not reported as still being produced", as
     "the segment must be stamped with where it really begins"
   );
   assert.equal(
-    session.indexCheck.checked,
+    session.timeline.indexCheck.checked,
     1,
     "and the piece's own position must still have been read, or nothing measures the index"
   );
@@ -241,8 +254,6 @@ test("a run's FIRST segment is served once the encoder has passed it, without wa
   // successor and nothing is producing one. Waiting for that successor is what
   // held #317 for 46 s and then answered 404 to a browser that had given up.
   await rm(path.join(dirPath, "segment-00001.mp4"));
-  session.encodeStartIndex = 0;
-  session.ffmpeg = { killed: true, kill() {} };
   session.progress = { processedSeconds: SEGMENT_START_SECONDS + 10 };
 
   const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
@@ -254,38 +265,26 @@ test("a run's FIRST segment is served once the encoder has passed it, without wa
   );
 });
 
-test("a segment is found in the run directory that produced it, newest run first", async (t) => {
+test("a segment an earlier run made is served by whatever run is going now", async (t) => {
   const { manager, session, dirPath } = await managerWithReadySegment();
   t.after(async () => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
-  // Runs write into a directory each — that is what lets a restart begin
-  // without waiting for its predecessor to die, which measured 0.7-1.3 s of
-  // every seek. A later run's answer supersedes an earlier one's, because the
-  // older file may be the truncated output of a run that was killed mid-write.
-  const { mkdir } = await import("node:fs/promises");
-  const piece = selfContainedPiece(SEGMENT_START_SECONDS);
-  await mkdir(path.join(dirPath, "run-1"), { recursive: true });
-  await mkdir(path.join(dirPath, "run-2"), { recursive: true });
-  await writeFile(path.join(dirPath, "run-1", "segment-00000.mp4"), Buffer.alloc(8));
-  await writeFile(path.join(dirPath, "run-2", "segment-00000.mp4"), piece);
-  await writeFile(path.join(dirPath, "run-2", "segment-00001.mp4"), piece);
-  await rm(path.join(dirPath, "segment-00000.mp4"));
-  await rm(path.join(dirPath, "segment-00001.mp4"));
-  session.encodeStartIndex = 0;
+  // Every run of an output writes into that output's own directory — there is
+  // one, and runs are kept apart by their stretches instead. So a viewer who
+  // seeks back is served what an earlier run made, with no restart and no
+  // search: the run going now began at #40 and #0 is simply there.
+  startRunOn(session, { from: 40, usesExplicitCuts: true });
 
   const result = await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
-  assert.equal(result.kind, "file", "a segment produced by a run must be found in that run's directory");
+  assert.equal(result.kind, "file", "what any run of this output made is what this output holds");
   const chunks = [];
   for await (const chunk of result.stream) {
     chunks.push(chunk);
   }
-  assert.ok(
-    Buffer.concat(chunks).length > 8,
-    "the newest run's output must win — the older file here is the 8-byte stub a killed run leaves"
-  );
+  assert.ok(Buffer.concat(chunks).length > 0);
 });
 
 test("serving a run's own segment moves the run out of STARTING", async (t) => {
@@ -294,41 +293,37 @@ test("serving a run's own segment moves the run out of STARTING", async (t) => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
-  // The table lives in `encode-run-state.js` and is tested there as a graph.
+  // The table lives in `encode/encode-run-state.js` and is tested there as a graph.
   // What this pins is that a real serve REACHES it: a state nothing writes
   // describes every run as still starting, for ever, and the log built on it
   // would say so too.
-  session.runState = ENCODE_RUN_STATE.STARTING;
-  // Where the run in force is writing. The fixture's segments live directly in
-  // the session directory, which is exactly what a single run's directory is
-  // here.
-  session.runDirPath = dirPath;
+  // A run that has not yet made anything: starting. The fixture's own run is
+  // let go first, because this test is about ONE run and what serving does to
+  // it.
+  session.runs.clear();
+  const run = startRunOn(session, { from: 0, producing: false, usesExplicitCuts: true });
+  assert.equal(run.state, ENCODE_RUN_STATE.STARTING);
 
   await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
-  assert.equal(session.runState, ENCODE_RUN_STATE.PRODUCING);
+  assert.equal(run.state, ENCODE_RUN_STATE.PRODUCING);
 });
 
-test("a segment left by an earlier run does not claim the new run has produced", async (t) => {
+test("a segment behind a run's own start does not claim that run has produced", async (t) => {
   const { manager, session, dirPath } = await managerWithReadySegment();
   t.after(async () => {
     await manager.disposeAll();
     await rm(dirPath, { recursive: true, force: true });
   });
-  // A seek places the new run in a directory of its own; the previous run's
-  // segments stay servable and are served from theirs. They say nothing about
-  // what the run now starting has done — and a run believed to be producing is
-  // one the look-ahead may suspend and the seek path may wave through as
-  // "already covered by the running encode".
-  //
-  // Deliberately a segment ABOVE the new run's start index, because that is the
-  // case an index comparison gets wrong: after a backward seek the old run's
-  // output sits ahead of the new run's beginning.
-  session.runState = ENCODE_RUN_STATE.STARTING;
-  session.encodeStartIndex = 0;
-  session.runDirPath = path.join(dirPath, "run-7");
+  // What moves a run out of starting is ITS OWN first segment. An earlier run's
+  // output sits in the same directory, and after a backward seek some of it
+  // lies ahead of the new run's beginning — so the question cannot be asked of
+  // the number alone, and a run believed to be producing is one the look-ahead
+  // may suspend and the seek path may wave through as "already covered".
+  session.runs.clear();
+  const run = startRunOn(session, { from: 5, producing: false, usesExplicitCuts: true });
 
   await manager.getFileStream(SESSION_ID, "segment-00000.mp4", { requestSeq: 1 });
 
-  assert.equal(session.runState, ENCODE_RUN_STATE.STARTING);
+  assert.equal(run.state, ENCODE_RUN_STATE.STARTING);
 });

package/test/segment-store.test.js

@@ -0,0 +1,187 @@
+/**
+ * @file One store of segments, addressed by what they are, and what it makes of
+ * what a killed process left behind.
+ */
+
+import test from "node:test";
+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";
+
+/**
+ * @returns {{ store: SegmentStore, root: string, lines: string[] }}
+ */
+function storeInATempRoot() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "segment-store-"));
+  const lines = [];
+  const store = new SegmentStore({
+    root,
+    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) }
+  });
+  return { store, root, lines };
+}
+
+/**
+ * @param {string} dir
+ * @param {number} index
+ * @param {number} bytes
+ */
+function writeSegment(dir, index, bytes = 16) {
+  writeFileSync(path.join(dir, fmp4Format.segmentFileName(index)), Buffer.alloc(bytes));
+}
+
+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 }));
+
+  // Which viewer asked never enters it — the address is what the segments are.
+  assert.equal(store.directoryFor(KEY), store.directoryFor(KEY));
+  assert.notEqual(store.directoryFor(KEY), store.directoryFor(`${KEY}:other`));
+});
+
+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 }));
+
+  const dir = store.directoryFor(KEY);
+  const names = readdirSync(dir);
+  assert.deepEqual(names, ["key.txt"]);
+});
+
+test("a segment is proven closed by the existence of the next one", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+  writeSegment(dir, 2);
+
+  // The `segment` muxer writes no temporary file, so a file that exists may
+  // still be growing; only a run that has moved past it proves otherwise.
+  assert.deepEqual(store.provenNumbers(KEY), [0, 1]);
+  assert.equal(store.unprovenNumber(KEY), 2);
+});
+
+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 }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+  writeSegment(dir, 2, 0);
+
+  // What a run killed the moment after opening its next piece leaves behind.
+  // Counted as a segment once, it closed the only hole in the numbering and
+  // convinced the look-ahead the encoder had produced it.
+  assert.equal(store.pathOf(KEY, 2), null);
+  assert.deepEqual(store.provenNumbers(KEY), [0]);
+});
+
+test("a directory that has not moved is not read again", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+
+  const first = store.refresh(KEY);
+  const second = store.refresh(KEY);
+  assert.equal(first, second, "the same reading is handed back, not a fresh listing");
+});
+
+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 }));
+
+  const dir = path.join(root, directoryNameFor(KEY));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
+  writeSegment(dir, 0);
+  writeSegment(dir, 1);
+  const orphan = path.join(root, "0123456789abcdef");
+  mkdirSync(orphan, { recursive: true });
+  writeSegment(orphan, 0);
+
+  const swept = store.sweep();
+  assert.equal(swept.directories, 2);
+  assert.equal(swept.unidentified, 1, "the one with no key file cannot be matched to a request");
+  assert.equal(swept.segments, 3);
+  assert.match(lines.join("\n"), /startup sweep/);
+  assert.match(lines.join("\n"), /ended\s+without anything recording why/);
+});
+
+test("what survived a kill is taken back, minus the piece nothing proves", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dir = path.join(root, directoryNameFor(KEY));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
+  for (let index = 0; index <= 5; index += 1) {
+    writeSegment(dir, index);
+  }
+
+  const taken = store.adoptWhatSurvived(() => fmp4Format);
+
+  assert.equal(taken.adopted, 1);
+  assert.equal(taken.unprovenRemoved, 1, "the highest number was being written when the run died");
+  // Five kept rather than six thrown away: a copied segment's bytes depend only
+  // on the source, and re-encoding them costs a machine already short of it.
+  assert.deepEqual(store.provenNumbers(KEY), [0, 1, 2, 3, 4]);
+  assert.equal(store.pathOf(KEY, 5), null);
+});
+
+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 }));
+
+  const orphan = path.join(root, "0123456789abcdef");
+  mkdirSync(orphan, { recursive: true });
+  writeSegment(orphan, 0);
+
+  const taken = store.adoptWhatSurvived(() => fmp4Format);
+
+  assert.equal(taken.adopted, 0);
+  assert.equal(taken.dropped, 1);
+  assert.equal(readdirSync(root).length, 0);
+});
+
+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 }));
+
+  const dir = path.join(root, directoryNameFor(KEY));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(path.join(dir, "key.txt"), `${KEY}\n`);
+  writeSegment(dir, 0);
+
+  const taken = store.adoptWhatSurvived(() => null);
+
+  assert.equal(taken.dropped, 1);
+  assert.equal(readdirSync(root).length, 0);
+});
+
+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 }));
+
+  const dir = store.directoryFor(KEY);
+  store.useFormat(KEY, fmp4Format);
+  writeSegment(dir, 0, 1000);
+  writeSegment(dir, 1, 1000);
+
+  assert.equal(store.stats().bytes, 2000);
+  store.drop(KEY, "nobody is watching it");
+  assert.equal(store.stats().outputs, 0);
+});

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

@@ -0,0 +1,175 @@
+/**
+ * @file Two sessions of one output write into one place, and each serves what
+ * the other has made.
+ *
+ * This is what the whole address change is for. Measured 2026-09-03: two
+ * viewers of one copied file got two sessions with byte-identical output —
+ * `segment-00000.mp4` of 4141899 bytes, twice — and neither could see the
+ * other's work, because the directory was named after the session's own random
+ * id (`research/two-viewers-one-file-2026-09-03.md`).
+ *
+ * The start position is deliberately NOT part of the address: segment 42 covers
+ * the same span whoever began where, so two viewers who opened the same film at
+ * different places produce interchangeable segments and must share them.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/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";
+
+const OUTPUT_KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+
+/**
+ * @returns {{ manager: HlsSessionManager, store: SegmentStore, root: string }}
+ */
+function managerOverATempStore() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
+  const store = new SegmentStore({ root });
+  const manager = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    segmentStore: store
+  });
+  return { manager, store, root };
+}
+
+/**
+ * A session shaped like a live one, sharing an output with any other built
+ * from the same key.
+ *
+ * @param {{ id: string, dirPath: string, outputKey: string }} params
+ * @returns {object}
+ */
+function sessionOn({ id, dirPath, outputKey }) {
+  return {
+    id,
+    outputKey,
+    dirPath,
+    state: "ready",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
+    // An ordinary session reads its own file, and its sound is inside it. The
+    // three differ only for a soundtrack shipped as a file of its own.
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    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()
+  };
+}
+
+test("a second session of the same output is given the same directory", (t) => {
+  const { store, root } = managerOverATempStore();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  // Two viewers who opened one film ten minutes apart. Their sessions differ —
+  // the start position is still what keeps their encoders apart — but what they
+  // produce is the same material.
+  assert.equal(store.pathFor(OUTPUT_KEY), store.pathFor(OUTPUT_KEY));
+});
+
+test("each session serves the segments the other one's encoder made", (t) => {
+  const { manager, store, root } = managerOverATempStore();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dirPath = store.directoryFor(OUTPUT_KEY);
+  store.useFormat(OUTPUT_KEY, fmp4Format);
+
+  // Two runs writing into the ONE directory this output has. They are kept
+  // apart by the stretches they were given, not by a directory each, so neither
+  // can reach the other's numbers and there is nothing to separate.
+  writeFileSync(path.join(dirPath, "segment-00000.mp4"), Buffer.alloc(32, 1));
+  writeFileSync(path.join(dirPath, "segment-00100.mp4"), Buffer.alloc(32, 2));
+
+  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);
+
+  const sorted = (numbers) => [...numbers].sort((left, right) => left - right);
+  const heldByOne = sorted(manager.producedSegmentNumbers(viewerOne));
+  const heldByTwo = sorted(manager.producedSegmentNumbers(viewerTwo));
+
+  assert.deepEqual(heldByOne, [0, 100]);
+  assert.deepEqual(heldByTwo, [0, 100], "neither viewer's session is the owner of either run");
+});
+
+test("a session leaving does not take the segments with it", async (t) => {
+  const { manager, store, root } = managerOverATempStore();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const dirPath = store.directoryFor(OUTPUT_KEY);
+  store.useFormat(OUTPUT_KEY, fmp4Format);
+  writeFileSync(path.join(dirPath, "segment-00000.mp4"), Buffer.alloc(32, 1));
+
+  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);
+
+  await manager.disposeSession(viewerOne.id);
+  await manager.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
+  // for these segments again — the viewer who left may come back, and a viewer
+  // who never had a session here may open the same film in a minute.
+  assert.notEqual(store.pathOf(OUTPUT_KEY, 0), null);
+});
+
+test("what nobody has read for long enough goes, and time is the only judge", (t) => {
+  const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  let clock = 1_000_000;
+  const store = new SegmentStore({ root, now: () => clock });
+
+  const dirPath = store.directoryFor(OUTPUT_KEY);
+  store.useFormat(OUTPUT_KEY, fmp4Format);
+  writeFileSync(path.join(dirPath, "segment-00000.mp4"), Buffer.alloc(32, 1));
+
+  clock += 60_000;
+  assert.deepEqual(
+    store.enforce({ idleMs: 3_600_000, maxBytes: 1e9 }),
+    { droppedIdle: 0, droppedForRoom: 0, bytes: 32 }
+  );
+
+  clock += 7_200_000;
+  const swept = store.enforce({ idleMs: 3_600_000, maxBytes: 1e9 });
+  assert.equal(swept.droppedIdle, 1);
+  assert.equal(store.pathOf(OUTPUT_KEY, 0), null);
+});
+
+test("over the allowance, what was read longest ago goes first", (t) => {
+  const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+  let clock = 1_000_000;
+  const store = new SegmentStore({ root, now: () => clock });
+
+  const older = OUTPUT_KEY;
+  const newer = `${OUTPUT_KEY}:second`;
+  for (const key of [older, newer]) {
+    const dir = store.directoryFor(key);
+    store.useFormat(key, fmp4Format);
+    writeFileSync(path.join(dir, "segment-00000.mp4"), Buffer.alloc(1000, 1));
+    clock += 1000;
+  }
+  // Reading the newer one again is what puts the older one at the front of the
+  // queue: the judge is the last REQUEST, not when the file was written.
+  clock += 1000;
+  store.pathOf(newer, 0);
+
+  const swept = store.enforce({ idleMs: 3_600_000, maxBytes: 1500 });
+  assert.equal(swept.droppedForRoom, 1);
+  assert.equal(store.pathOf(older, 0), null);
+  assert.notEqual(store.pathOf(newer, 0), null);
+});