@torrent-tv/proxy 2.80.8 → 2.80.10

package/test/segment-store.test.js

@@ -1,187 +1,216 @@
-/**
- * @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);
-});
+/**
+ * @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 `hls` muxer carries no channel to report on and renames into place when
+  // it closes a piece, so on that branch existence IS the proof; the same
+  // answers for the pieces a previous life of this process left behind.
+  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 run's own stretch bounds what it unproves", (t) => {
+  const { store, root } = storeInATempRoot();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  store.useFormat(KEY, fmp4Format);
+  store.directoryFor(KEY);
+  for (let index = 0; index <= 5; index += 1) {
+    store.markClosed(KEY, index);
+  }
+
+  // A run of #0..#0 rewrites #0 and nothing else. Unbounded, this forgot the
+  // whole film beyond it — and with readiness a projection of what is proven,
+  // that is an output declaring itself unmade whenever an encoder starts near
+  // the beginning, which is a fresh encoder for every segment of it.
+  //
+  // Asked with no files on the disk, so the successor rule cannot answer for
+  // the statements and only the statements are under test.
+  store.forgetClosed(KEY, 0, 0);
+  assert.equal(store.isClosed(KEY, 0), false, "the one number it will rewrite");
+  assert.equal(store.isClosed(KEY, 1), true, "and nothing beyond its stretch");
+  assert.equal(store.isClosed(KEY, 5), true);
+
+  store.forgetClosed(KEY, 3);
+  assert.equal(store.isClosed(KEY, 2), true);
+  assert.equal(store.isClosed(KEY, 3), false, "no end given means to the end of the film");
+  assert.equal(store.isClosed(KEY, 5), false);
+});
+
+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/stale-request-after-seek.test.js

@@ -1,19 +1,21 @@
 /**
- * @file A request issued before a seek must not steer the encoder.
+ * @file A segment request steers nothing.
  *
  * Field 2026-08-17: the viewer seeked to 2083.4 s, both runs restarted at
  * segment #373, and a request for #371 — issued before the seek and reissued by
  * the player a second later — moved the encoder to #370. The viewer was at
  * #374 and waited for the encoder to come back to them.
  *
- * The rule pinned here: a reported seek is the viewer STATING where they are; a
- * segment request is evidence about where the player is reading. Evidence may
- * refine a statement forward, never contradict it backwards.
+ * That was answered first by a guard: a request behind what the viewer had
+ * REPORTED was refused, while the same traffic still moved the encoder when
+ * nothing had been reported. The guard is gone with the thing it guarded. A
+ * request for a file is not a statement about where anybody is, and nothing
+ * about it belongs in the decision of where encoders go — that is read from the
+ * priority map, which is built from where the viewers are and from nothing else.
  *
- * Both cases go through `getFileStream`, the way production reaches the repair,
- * and the second is the control: without a reported seek the very same traffic
- * DOES move the encoder, which is what makes the first case a measurement of
- * the guard rather than of the weather.
+ * So the rule pinned here is now the whole rule, and it has no exception: a
+ * request moves neither the encoder nor the viewer, whether or not the viewer
+ * has said anything.
  */
 
 import assert from "node:assert/strict";
@@ -40,79 +42,48 @@ const SESSION_ID = "22222222-3333-4444-5555-666666666666";
  * @returns {Promise<{ manager: HlsSessionManager, session: object, dirPath: string }>}
  */
 async function sessionWithRunAt373() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-seek-"));
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "stale-request-"));
   const manager = new HlsSessionManager({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
-  const boundaries = [];
-  for (let index = 0; index <= 600; index += 1) {
-    boundaries.push(index * SEGMENT_SECONDS);
-  }
   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: boundaries,
+      boundaries: Array.from({ length: 901 }, (_, index) => index * SEGMENT_SECONDS),
       cutGrid: "uniform"
     }),
     state: "ready",
     file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.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,
+    segmentCount: 900,
+    startedAt: Date.now(),
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
+    runs: new Set(),
     consumers: new Set(),
-    segmentFormat: fmp4Format,
+    viewers: new Map(),
+    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS },
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentCount: boundaries.length - 1,
-    runs: new Set(),
-    behindHeadAsks: new Map(),
-    firstWantedAt: new Map(),
-    holdExplainedAt: new Map(),
-    seekSettleTimer: null,
-    seekTarget: null,
-    failedStartAt: -1,
-    failedStartCount: 0,
-    waitEpoch: 0,
-    firstSegmentLogged: true,
-    progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS, speed: "1.0x", startPositionSeconds: RUN_STARTS_AT * SEGMENT_SECONDS }
+    lastError: "",
+    firstSegmentLogged: false,
+    waitEpoch: 0
   };
   manager.sessionsById.set(SESSION_ID, session);
-  // A live run: the repair refuses outright when nothing is encoding.
-  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true });
+  startRunOn(session, { from: RUN_STARTS_AT, usesExplicitCuts: true, speedX: 2 });
   return { manager, session, dirPath };
 }
 
 /**
- * The traffic that dragged the encoder back: the same index asked for twice,
- * first wanted long enough ago to pass the repair's patience guard.
- *
- * @param {object} session
- */
-function askedTwiceLongEnough(session) {
-  session.firstWantedAt.set(BEHIND_INDEX, Date.now() - 5_000);
-  session.behindHeadAsks.set(BEHIND_INDEX, { count: 3, at: Date.now() });
-}
-
-/**
- * Put the session down without going through disposal.
- *
- * Disposal signals the encoder and waits for it to die, which a stub cannot do
- * — and none of that is what these tests are about. Clearing the map and any
- * armed timer leaves nothing running.
- *
  * @param {HlsSessionManager} manager
  * @param {object} session
  * @param {string} dirPath
- * @returns {Promise<void>}
  */
 async function tidy(manager, session, dirPath) {
   if (session.seekSettleTimer) {
@@ -131,45 +102,48 @@ 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);
-  askedTwiceLongEnough(session);
+  manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
 
-  const answer = await manager.getFileStream(
+  await manager.getFileStream(
     SESSION_ID,
     fmp4Format.segmentFileName(BEHIND_INDEX),
     { requestSeq: 1 }
   );
 
-  assert.equal(answer.kind, "warming-up", "the request is answered, not obeyed");
-  // The viewer's own seek legitimately armed a move to #519. What must NOT
-  // happen is the stale request replacing that with #370 — which is exactly
-  // what the field log shows: `seek settle → restart at segment #370`.
-  assert.notEqual(
-    session.seekTarget,
-    BEHIND_INDEX - 1,
+  // The field log's line was `seek settle → restart at segment #370`. Nothing
+  // aims an encoder from here at all now, so there is no destination for a
+  // stale request to become.
+  assert.equal(
+    session.seekTarget ?? null,
+    null,
     "a request behind the viewer must not become the encoder's destination"
   );
-  assert.equal(session.seekTarget, 519, "the viewer's own seek is what the encoder is going to");
+  assert.equal(
+    session.seekSettleTimer ?? null,
+    null,
+    "and it must not arm a restart"
+  );
 });
 
-test("the same traffic DOES move the encoder when the viewer has said nothing", async (t) => {
+test("the same traffic moves nothing when the viewer has said nothing either", async (t) => {
   const { manager, session, dirPath } = await sessionWithRunAt373();
   t.after(async () => {
     await tidy(manager, session, dirPath);
   });
 
-  // No reported seek: a run placed wrongly is exactly what the repair is for,
-  // and this is the case it must keep serving.
-  askedTwiceLongEnough(session);
-
-  await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
-
-  assert.equal(
-    session.seekTarget,
-    BEHIND_INDEX - 1,
-    "with nothing said by the viewer, a request stuck behind the head still repairs the run"
+  // THE CONTROL, INVERTED. It used to be that without a reported seek this very
+  // traffic DID move the encoder — the guard applied only to a viewer who had
+  // 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(
+    SESSION_ID,
+    fmp4Format.segmentFileName(BEHIND_INDEX),
+    { requestSeq: 1 }
   );
-  assert.notEqual(session.seekSettleTimer, null);
+
+  assert.equal(session.seekTarget ?? null, null);
+  assert.equal(session.seekSettleTimer ?? null, null);
 });
 
 test("a request cannot move the viewer's position backwards", async (t) => {
@@ -178,12 +152,12 @@ test("a request cannot move the viewer's position backwards", async (t) => {
     await tidy(manager, session, dirPath);
   });
 
-  manager.requestSeek(SESSION_ID, 2083.4);
+  manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
   await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
 
   assert.equal(
-    session.furthestViewerSeconds,
+    manager.viewers.get("viewer-1")?.positionSeconds(),
     2083.4,
-    "a stale request must not rewrite what the viewer reported — that is how the repair came to believe it"
+    "a stale request must not rewrite what the viewer said about themselves"
   );
 });