@torrent-tv/proxy 2.80.4 → 2.80.6

package/test/priority-map-download.test.js

@@ -15,7 +15,7 @@ import assert from "node:assert/strict";
 import { TorrentPool } from "../services/torrent-pool.js";
 import { demandFor, forgetTorrent } from "../services/download/registry.js";
 import { Urgency } from "../services/demand/index.js";
-import { mapForViewer } from "../services/priority/PriorityMap.js";
+import { mapForViewer, runsOf } from "../services/priority/PriorityMap.js";
 
 /** A torrent that is nothing but one file of a known length. */
 function torrentOf({ length = 1_000_000, offset = 0 } = {}) {
@@ -58,11 +58,11 @@ test("a zone is stated at the level it means, not at the level of its position",
   try {
     // A viewer 300 s into a 3000 s film: one band behind them that nobody is
     // approaching, then bands of decreasing urgency ahead.
-    const zones = mapForViewer({
+    const zones = runsOf(mapForViewer({
       atSeconds: 300,
       durationSeconds: 3000,
       allowanceSeconds: 10
-    });
+    }));
     assert.ok(zones.length > 5, "the map should be finer than the register's levels");
 
     applyPriorityMap.call(null, torrent, 0, zones, 3000);
@@ -93,23 +93,41 @@ test("a zone is stated at the level it means, not at the level of its position",
 test("a viewer who has stopped the picture makes the whole film wanted last", () => {
   const torrent = torrentOf();
   try {
-    const zones = mapForViewer({
+    const zones = runsOf(mapForViewer({
       atSeconds: 300,
       durationSeconds: 3000,
       allowanceSeconds: 10,
       playing: false
-    });
+    }));
     applyPriorityMap.call(null, torrent, 0, zones, 3000);
 
     const { register } = demandFor(torrent);
     const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-    assert.equal(stated.length, 1, "a viewer going nowhere makes one band of the whole film");
+    // A PAUSE REMOVES THE TIME, NOT THE DIRECTION. What they have watched is
+    // behind them and what they have not is in front, exactly as while they were
+    // watching; what changes is that nothing has a time any more, so every band
+    // of theirs yields to anybody who is on their way somewhere.
+    assert.ok(stated.length >= 2, "their position survives the pause");
+    for (const one of stated) {
+      assert.ok(
+        one.urgency === Urgency.BEHIND || one.urgency === Urgency.TAIL,
+        "and nothing of theirs is urgent, because nobody is coming"
+      );
+    }
+    const front = stated.filter((one) => one.urgency === Urgency.TAIL);
+    assert.ok(front.length >= 1, "the film in front of them is still in front");
+    assert.ok(
+      front[0].byteStart >= Math.floor((300 / 3000) * 1_000_000),
+      "and it begins where they stopped"
+    );
     // Wanted last ABSOLUTELY, not relative to this film's own map. The two
     // speculative levels are withheld across every torrent at once while
     // anything urgent is missing anywhere, so this has to lose to a film
     // somebody is actually watching — and judged against itself alone it would
     // be the most urgent thing there is.
-    assert.equal(stated[0].urgency, Urgency.BEHIND);
+    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
+    assert.equal(behind.length, 1, "what they have already watched is wanted last of all");
+    assert.equal(behind[0].byteStart, 0, "and it is the stretch from the beginning to where they stopped");
   } finally {
     forgetTorrent(torrent);
   }

package/test/priority-map.test.js

@@ -1,112 +1,163 @@
 /**
- * @file A map per viewer, merged into one, in the order the work is taken.
+ * @file The priority map: one number per second of film.
  *
- * In seconds of film throughout: it is the only unit every term of the
- * arithmetic is already stated in, and the one two consumers with different
- * states can both be translated from.
+ * The map is literally a map — an array as long as the film, saying how urgently
+ * each second is wanted, and beside it how long until somebody plays it. What is
+ * checked here is what the numbers MEAN, since only their order is meaningful:
+ * in front of a viewer beats behind them, nearer beats further, and two viewers
+ * merge to the more urgent of them.
+ *
+ * Nothing here spawns anything, reads a disk or looks at a clock: this layer is
+ * exercised with plain values alone, which is the layer check made executable.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mapForViewer, mergeMaps, inWorkingOrder } from "../services/priority/PriorityMap.js";
+import {
+  emptyMap,
+  inWorkingOrder,
+  isBehindEverybody,
+  mapForViewer,
+  mergeMaps,
+  runsOf
+} from "../services/priority/PriorityMap.js";
+
+const FILM = 3600;
+const ALLOWANCE = 8;
 
-test("the rest of the track is still wanted, and wanted last", () => {
-  const map = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 4, encodeSpeedX: 2 });
+/**
+ * @param {number} atSeconds
+ * @param {boolean} [playing]
+ */
+function viewer(atSeconds, playing = true) {
+  return mapForViewer({
+    atSeconds,
+    durationSeconds: FILM,
+    allowanceSeconds: ALLOWANCE,
+    playing
+  });
+}
+
+test("the map is one entry per second of film", () => {
+  const map = viewer(600);
+  assert.equal(map.durationSeconds, FILM);
+  assert.equal(map.priority.length, FILM);
+  assert.equal(map.secondsUntilPlayed.length, FILM);
+  assert.equal(map.behind.length, FILM);
+});
 
-  assert.equal(map[map.length - 1].to, 1000, "the map reaches the end of the film");
-  assert.ok(map[map.length - 1].priority > 0, "and the far end is still wanted");
-  let previousEnd = 0;
-  for (const zone of map) {
-    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
-    previousEnd = zone.to;
-  }
+test("the nearer a viewer is to a second, the higher its number", () => {
+  // The whole of what a priority means: which of two seconds is wanted first.
+  const map = viewer(600);
+  assert.ok(map.priority[600] > map.priority[700], "their own second beats one a hundred on");
+  assert.ok(map.priority[700] > map.priority[3000], "and that beats one forty minutes on");
 });
 
-test("two viewers merge to the highest priority per second, with no overlaps", () => {
-  const first = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
-  const second = mapForViewer({ atSeconds: 500, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
+test("the time is the distance, because a viewer covers a second of film in a second", () => {
+  const map = viewer(600);
+  assert.equal(map.secondsUntilPlayed[600], 0, "they are there now");
+  assert.equal(map.secondsUntilPlayed[660], 60, "a minute of film away is a minute away");
+});
 
-  const merged = mergeMaps([first, second]);
+test("what is behind a viewer is wanted, and wanted last", () => {
+  // Still wanted — a seek back must be cheap — but it yields to everything
+  // anybody is walking towards, however far off that is.
+  const map = viewer(600);
+  assert.equal(map.behind[599], 1);
+  assert.equal(map.behind[600], 0);
+  assert.ok(isBehindEverybody(map.priority[599]));
+  assert.ok(map.priority[599] < map.priority[3599],
+    "the last second of the film outranks the second they just watched");
+  assert.equal(map.secondsUntilPlayed[599], Number.POSITIVE_INFINITY,
+    "nobody is on their way there, so there is no time by which it must exist");
+});
 
-  let previousEnd = merged[0].from;
-  for (const zone of merged) {
-    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
-    previousEnd = zone.to;
+test("a viewer who has stopped the picture keeps their position, and loses their times", () => {
+  // A pause removes the time, not the direction. Collapsed to one flat value
+  // over the whole film, as it was, their position disappeared entirely — and
+  // with it the rule that what is in front of them is made first.
+  const map = viewer(600, false);
+  assert.equal(map.behind[599], 1, "what they have watched is still behind them");
+  assert.equal(map.behind[600], 0, "and what they have not is still in front");
+  assert.ok(map.priority[600] > map.priority[599], "in front still outranks behind");
+  assert.ok(map.priority[600] > map.priority[3000], "and nearer still outranks further");
+  for (const second of [599, 600, 3000]) {
+    assert.equal(map.secondsUntilPlayed[second], Number.POSITIVE_INFINITY,
+      "but nothing has a time, because they are on their way nowhere");
   }
-  const priorityAt = (at) => merged.find((zone) => at >= zone.from && at < zone.to)?.priority;
-  assert.equal(priorityAt(0), priorityAt(500), "both viewers' own positions are equally urgent");
-  assert.ok(priorityAt(500) > priorityAt(300), "a viewer at 500 outranks the far zone of the one at 0");
 });
 
-test("the second viewer's position is not buried under the first viewer's far zone", () => {
-  // The case that used to leave a viewer opening the same film further in with
-  // no encoder at all, because the first run claimed everything in front of it.
-  const first = mapForViewer({ atSeconds: 0, durationSeconds: 4000, allowanceSeconds: 8, encodeSpeedX: 2 });
-  const second = mapForViewer({ atSeconds: 2000, durationSeconds: 4000, allowanceSeconds: 8, encodeSpeedX: 2 });
-
-  const order = inWorkingOrder(mergeMaps([first, second]));
-  const firstTwo = order.slice(0, 2).map((zone) => zone.from);
-
-  assert.ok(firstTwo.includes(0), "the first viewer's own position is taken first");
-  assert.ok(firstTwo.includes(2000), "so is the second viewer's, before anything less urgent");
+test("anybody who is watching outranks anybody who has stopped", () => {
+  // An ordering fact rather than a chosen number: somebody watching needs their
+  // next second almost at once, while somebody stopped needs theirs at a time
+  // nothing here knows.
+  const watching = viewer(600);
+  const stopped = viewer(3000, false);
+  assert.ok(watching.priority[3599] > stopped.priority[3000],
+    "the far tail of a watching viewer beats the very next second of a stopped one");
 });
 
-test("within one priority the earliest film goes first — that is where somebody is stopped", () => {
-  const order = inWorkingOrder([
-    { from: 900, to: 1000, priority: 2 },
-    { from: 100, to: 200, priority: 2 },
-    { from: 0, to: 10, priority: 3 }
-  ]);
+test("two viewers merge to the more urgent of them, second by second", () => {
+  const merged = mergeMaps([viewer(600), viewer(1800)]);
+  assert.equal(merged.priority[1800], merged.priority[600],
+    "each of them is at the top of the scale where they stand");
+  assert.equal(merged.secondsUntilPlayed[1800], 0, "the nearer time wins");
+  assert.equal(merged.behind[599], 1, "behind both of them is behind");
+  assert.equal(merged.behind[700], 0, "and in front of ANYBODY is in front");
+});
 
-  assert.deepEqual(order.map((zone) => zone.from), [0, 100, 900]);
+test("the second viewer's position is not buried under the first viewer's distance", () => {
+  // The failure this guards: one viewer's far film outranking another viewer's
+  // own second, so the second of them is served by nobody.
+  const merged = mergeMaps([viewer(600), viewer(1800)]);
+  assert.ok(merged.priority[1800] > merged.priority[1799],
+    "where the second viewer stands beats the film just before them");
 });
 
-test("the nearer a viewer is to a second, the higher its number", () => {
-  // The number is a reading of how far they still have to travel, and nothing
-  // else. That is what makes two viewers comparable at all.
-  const map = mapForViewer({ atSeconds: 300, durationSeconds: 3000, allowanceSeconds: 10 });
-  const ahead = map.filter((zone) => zone.from >= 300);
+test("a film nobody is watching wants nothing", () => {
+  const merged = mergeMaps([]);
+  assert.equal(merged.durationSeconds, 0);
+  assert.deepEqual(runsOf(merged), []);
+});
 
-  assert.equal(ahead[0].from, 300, "it starts where they are");
-  assert.equal(ahead[0].to, 310, "and the first band is the measured allowance");
-  for (let index = 1; index < ahead.length; index += 1) {
-    assert.ok(ahead[index].priority < ahead[index - 1].priority, "further off is less urgent");
+test("the map as stretches says the same thing in fewer numbers", () => {
+  const runs = runsOf(viewer(600));
+  assert.ok(runs.length > 1 && runs.length < 40, "a handful of stretches, not thousands");
+  assert.equal(runs[0].from, 0, "starting at the beginning of the film");
+  assert.equal(runs[0].behind, true, "which is behind them");
+  assert.equal(runs[runs.length - 1].to, FILM, "and ending at its end");
+  for (let index = 0; index < runs.length - 1; index += 1) {
+    assert.equal(runs[index].to, runs[index + 1].from, "with no gaps");
   }
 });
 
-test("the bands widen, so any film is described by a handful of them", () => {
-  // Near the viewer the difference between now and ten seconds away decides
-  // what is made first; twenty minutes out it changes nothing.
-  const map = mapForViewer({ atSeconds: 0, durationSeconds: 3000, allowanceSeconds: 10 });
-
-  assert.ok(map.length <= 12, `a fifty-minute film in ${map.length} bands`);
-  assert.equal(map[0].to - map[0].from, 10);
-  assert.equal(map[1].to - map[1].from, 20);
-  assert.equal(map[2].to - map[2].from, 40);
+test("the stretches widen with distance, so any film is a handful of them", () => {
+  // Near the viewer the difference between now and ten seconds away decides what
+  // is made first; twenty minutes out, one more division changes no decision.
+  const ahead = runsOf(viewer(0)).filter((run) => run.behind === false);
+  for (let index = 1; index < ahead.length; index += 1) {
+    assert.ok(ahead[index].to - ahead[index].from >= ahead[index - 1].to - ahead[index - 1].from,
+      "each stretch is at least as wide as the one before it");
+  }
+  assert.ok(ahead[0].to - ahead[0].from <= ALLOWANCE + 1,
+    "and the first is as wide as the measured allowance");
 });
 
-test("what is behind a viewer is wanted, and wanted last", () => {
-  const map = mapForViewer({ atSeconds: 300, durationSeconds: 3000, allowanceSeconds: 10 });
-  const behind = map.find((zone) => zone.from === 0);
-
-  assert.ok(behind, "it is still in the map");
-  assert.equal(behind.to, 300);
-  assert.ok(
-    map.filter((zone) => zone.from >= 300).every((zone) => zone.priority > behind.priority),
-    "and everything anybody is approaching outranks it"
-  );
+test("the working order is most urgent first, earliest film within one priority", () => {
+  const ordered = inWorkingOrder(runsOf(viewer(600)));
+  for (let index = 0; index < ordered.length - 1; index += 1) {
+    const left = ordered[index];
+    const right = ordered[index + 1];
+    assert.ok(
+      left.priority > right.priority || (left.priority === right.priority && left.from < right.from),
+      "sorted by priority, then by position"
+    );
+  }
+  assert.equal(ordered[0].from, 600, "and the first of all is where the viewer is stopped");
 });
 
-test("a viewer who has stopped the picture is going nowhere", () => {
-  // Nothing is nearer to them than anything else, so nothing in the film is
-  // wanted sooner than the rest — and the work goes to whoever is watching.
-  const map = mapForViewer({
-    atSeconds: 300,
-    durationSeconds: 3000,
-    allowanceSeconds: 10,
-    playing: false
-  });
-
-  assert.equal(map.length, 1);
-  assert.deepEqual({ from: map[0].from, to: map[0].to }, { from: 0, to: 3000 });
+test("a map of no length is a statement, and it says nothing is wanted", () => {
+  const map = emptyMap(0);
+  assert.equal(map.durationSeconds, 0);
+  assert.deepEqual(runsOf(map), []);
 });

package/test/seek-landing.test.js

@@ -1,76 +1,109 @@
-/**
- * @file Ask ffmpeg late enough that it lands where we meant.
- *
- * `fftools/ffmpeg_demux.c` moves an input seek back by `3*AV_TIME_BASE / 23` —
- * 130.435 ms — whenever the container does not declare `AVFMT_SEEK_TO_PTS` and
- * a stream carries B-frames. So asking for a keyframe lands on the one before
- * it, and since `-segment_times` is measured from where the run really began,
- * every cut of that run inherits the shift.
- *
- * Measured 2026-08-21 on Matroska with keyframes every 2 s: `-ss 10` produced a
- * first segment starting at 8.000, `-ss 10.130435` one starting at 10.000. On
- * MP4, where the heuristic does not fire, 10, 10.130435 and 10.2 all produced
- * 10.000 — right in one case, harmless in the other.
- */
-
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import test from "node:test";
-
-import { seekLandingOffsetFor } from "../services/hls-session-manager.js";
-
-const OFFSET = 3 / 23;
-
-test("a copied picture is asked for one heuristic later than the keyframe", () => {
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004, 6.006] }) };
-  assert.equal(seekLandingOffsetFor(session, 2.002), OFFSET);
-});
-
-test("a re-encode is asked for exactly what it should produce", () => {
-  // It decodes from the keyframe and discards frames up to the requested time,
-  // so pushing the request later would start its output late.
-  const session = { transcodeVideo: true, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
-  assert.equal(seekLandingOffsetFor(session, 2.002), 0);
-});
-
-test("the offset never reaches the next keyframe", () => {
-  // Keyframes 0.1 s apart: half of that is the most that can be added without
-  // risking a landing on the NEXT one where the heuristic does not fire.
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2, 0.3] }) };
-  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
-});
-
-test("the last keyframe has nothing after it to collide with", () => {
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
-  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
-});
-
-test("no keyframe list is still answered", () => {
-  assert.equal(seekLandingOffsetFor({ transcodeVideo: false }, 5), OFFSET);
-  assert.equal(seekLandingOffsetFor(null, 5), OFFSET);
-});
-
-test("a grid whose times are approximate is asked for that much later again", () => {
-  // AVI names a keyframe by its frame NUMBER and the time is that number times
-  // the frame duration, so a name can sit just BELOW the keyframe it refers to
-  // — measured 2026-08-21, 10-44 ms out on two files, always under one frame.
-  // Asking at the name alone would seek to before the real keyframe and land on
-  // the one before that, which is the fault this offset exists for.
-  const session = {
-    transcodeVideo: false,
-    file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0.04 })
-  };
-  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET + 0.04);
-});
-
-test("an exact grid claims no tolerance", () => {
-  // Matroska and MP4 state instants outright — measured the same day, nine
-  // files and 11 665 keyframes with not one disagreement.
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008], keyframeTolerance: 0 }) };
-  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
-});
-
-test("the bound still holds once a tolerance is added", () => {
-  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2], keyframeTolerance: 1 }) };
-  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
-});
+/**
+ * @file Ask ffmpeg late enough that it lands where we meant.
+ *
+ * `fftools/ffmpeg_demux.c` moves an input seek back by `3*AV_TIME_BASE / 23` —
+ * 130.435 ms — whenever the container does not declare `AVFMT_SEEK_TO_PTS` and
+ * a stream carries B-frames. So asking for a keyframe lands on the one before
+ * it, and since `-segment_times` is measured from where the run really began,
+ * every cut of that run inherits the shift.
+ *
+ * Measured 2026-08-21 on Matroska with keyframes every 2 s: `-ss 10` produced a
+ * first segment starting at 8.000, `-ss 10.130435` one starting at 10.000. On
+ * MP4, where the heuristic does not fire, 10, 10.130435 and 10.2 all produced
+ * 10.000 — right in one case, harmless in the other.
+ */
+
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/SourceFile.js";
+import test from "node:test";
+
+import { seekLandingOffsetFor } from "../services/hls-session-manager.js";
+
+const OFFSET = 3 / 23;
+
+test("a copied picture is asked for one heuristic later than the keyframe", () => {
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004, 6.006] }) };
+  assert.equal(seekLandingOffsetFor(session, 2.002), OFFSET);
+});
+
+test("a re-encode is asked for exactly what it should produce", () => {
+  // It decodes from the keyframe and discards frames up to the requested time,
+  // so pushing the request later would start its output late.
+  const session = { transcodeVideo: true, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
+  assert.equal(seekLandingOffsetFor(session, 2.002), 0);
+});
+
+test("the offset never reaches the next keyframe", () => {
+  // Keyframes 0.1 s apart: half of that is the most that can be added without
+  // risking a landing on the NEXT one where the heuristic does not fire.
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2, 0.3] }) };
+  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
+});
+
+test("the last keyframe has nothing after it to collide with", () => {
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 2.002, 4.004] }) };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
+});
+
+test("no keyframe list is still answered", () => {
+  assert.equal(seekLandingOffsetFor({ transcodeVideo: false }, 5), OFFSET);
+  assert.equal(seekLandingOffsetFor(null, 5), OFFSET);
+});
+
+test("a grid whose times are approximate is asked for that much later again", () => {
+  // AVI names a keyframe by its frame NUMBER and the time is that number times
+  // the frame duration, so a name can sit just BELOW the keyframe it refers to
+  // — measured 2026-08-21, 10-44 ms out on two files, always under one frame.
+  // Asking at the name alone would seek to before the real keyframe and land on
+  // the one before that, which is the fault this offset exists for.
+  const session = {
+    transcodeVideo: false,
+    file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0.04 })
+  };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET + 0.04);
+});
+
+test("an exact grid claims no tolerance", () => {
+  // Matroska and MP4 state instants outright — measured the same day, nine
+  // files and 11 665 keyframes with not one disagreement.
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 4.004, 8.008], keyframeTolerance: 0 }) };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
+});
+
+test("the bound still holds once a tolerance is added", () => {
+  const session = { transcodeVideo: false, file: new SourceFile({ sourceKey: "s", fileIndex: 0 }).learn({ keyframeTimes: [0, 0.1, 0.2], keyframeTolerance: 1 }) };
+  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
+});
+
+test("an output carrying only sound is not pushed past what it asked for", () => {
+  // The field failure of 2026-09-06: the sound played 130 ms ahead of the
+  // picture from every restart onward, and the viewer saw lips out of step with
+  // the voice from two minutes in.
+  //
+  // The offset exists because ffmpeg's demuxer moves a seek target back for a
+  // container it reads in decode order, after which a COPY lands on the previous
+  // keyframe. A re-encode trims to the requested time itself and is excluded —
+  // and an output with no picture is exactly that, since its one track is
+  // `-c:a aac`. It was not excluded, because the test asked whether the PICTURE
+  // is re-encoded and an output with no picture answers no.
+  const soundtrack = {
+    audioOnly: true,
+    transcodeVideo: false,
+    file: new SourceFile({ sourceKey: "s", fileIndex: 0 })
+      .learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0 })
+  };
+  assert.equal(seekLandingOffsetFor(soundtrack, 4.004), 0);
+});
+
+test("the picture of the same film still gets the offset", () => {
+  // The pair to the check above: the two outputs are repositioned to one
+  // boundary and must be given DIFFERENT requests, because one is copied and one
+  // is re-encoded. Given the same request they land 130 ms apart.
+  const picture = {
+    audioOnly: false,
+    transcodeVideo: false,
+    file: new SourceFile({ sourceKey: "s", fileIndex: 0 })
+      .learn({ keyframeTimes: [0, 4.004, 8.008, 12.012], keyframeTolerance: 0 })
+  };
+  assert.equal(seekLandingOffsetFor(picture, 4.004), OFFSET);
+});