@torrent-tv/proxy 2.80.5 → 2.80.6

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);
+});

package/test/segment-demand.test.js

@@ -1,5 +1,15 @@
 /**
- * @file What viewers want of an output, stated once each and read as a union.
+ * @file What is wanted of one output, in its own segment numbers.
+ *
+ * The class held a window per viewer per band and merged them itself. That was
+ * the priority layer's work done a second time in the wrong place, and it
+ * carried the viewer's name as the key of a claim — against the rule that the
+ * encoding and the viewer are not connected at all. The behaviours those checks
+ * pinned (a viewer's own bands, two viewers as a union) are the priority map's
+ * and are checked there.
+ *
+ * What is left is a holder: one map per output, replaced whole, and an empty one
+ * meaning nobody is coming.
  */
 
 import test from "node:test";
@@ -7,76 +17,64 @@ import assert from "node:assert/strict";
 import { SegmentDemand } from "../services/encode/SegmentDemand.js";
 
 const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-const SOUND = "torrent:abc:fmt=fmp4:grid=kf@0:audio-only:a=0/1/copy";
+const SOUND = "torrent:abc:fmt=fmp4:grid=kf@0:audio-only:a=0/0/aac";
 
-test("a viewer restating a window replaces it rather than adding to it", () => {
-  // A player restates its window every few seconds. Accumulated, the demand
-  // would grow to the whole film within a minute.
+test("an output nothing has been said about wants nothing", () => {
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 10, statedAt: 1 });
-  demand.state({ claimant: "one", address: PICTURE, from: 30, to: 40, statedAt: 2 });
-  assert.deepEqual(demand.spanOn(PICTURE), { from: 30, to: 40 });
-  assert.equal(demand.stats().windows, 1);
+  assert.deepEqual(demand.mapOn(PICTURE), []);
+  assert.deepEqual(demand.addresses(), []);
 });
 
-test("one viewer states a window per output, and both stand", () => {
+test("a map replaces whatever was wanted before, rather than adding to it", () => {
+  // The map is a statement of what is wanted NOW, built fresh each time from
+  // where the viewers are. Accumulating them would keep serving people who have
+  // moved or gone.
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 10, statedAt: 1 });
-  demand.state({ claimant: "one", address: SOUND, from: 0, to: 10, statedAt: 1 });
-  assert.equal(demand.stats().windows, 2);
-  assert.deepEqual(demand.addresses().sort(), [SOUND, PICTURE].sort());
-});
-
-test("two viewers of one output are a union, not a sum", () => {
-  // Two viewers seconds apart want mostly the same segments; counted twice, a
-  // stretch would look twice as wanted as it is.
-  const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 10, to: 14, statedAt: 1 });
-  demand.state({ claimant: "two", address: PICTURE, from: 12, to: 16, statedAt: 1 });
-  assert.deepEqual(demand.wantedOn(PICTURE), [10, 11, 12, 13, 14, 15, 16]);
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(PICTURE, [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
+  assert.deepEqual(demand.mapOn(PICTURE), [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
 });
 
-test("two viewers far apart make a span that covers the ground between them", () => {
-  // Not so it is all made — so that a search for a gap considers all of it.
+test("an empty map is a statement, and it is kept as one", () => {
+  // It says nobody is coming anywhere in this output, which is what stops the
+  // encoders on it. Dropped instead of stored, the output would look like one
+  // nothing had ever been said about, and the last map with people in it would
+  // stand as current.
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 5, statedAt: 1 });
-  demand.state({ claimant: "two", address: PICTURE, from: 900, to: 905, statedAt: 1 });
-  assert.deepEqual(demand.spanOn(PICTURE), { from: 0, to: 905 });
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(PICTURE, []);
+  assert.deepEqual(demand.mapOn(PICTURE), []);
+  assert.deepEqual(demand.addresses(), [PICTURE], "the output is still one that has been spoken about");
 });
 
-test("a viewer who leaves takes every window they stated", () => {
+test("each output holds its own map", () => {
+  // Two outputs of one film are cut independently — 454 pieces against 401 on
+  // the field file — so the same second is a different number in each, and one
+  // map cannot serve both.
   const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 5, statedAt: 1 });
-  demand.state({ claimant: "one", address: SOUND, from: 0, to: 5, statedAt: 1 });
-  demand.state({ claimant: "two", address: PICTURE, from: 0, to: 5, statedAt: 1 });
-  assert.equal(demand.forget("one"), 2);
-  assert.equal(demand.stats().claimants, 1);
-  assert.equal(demand.addresses().length, 1);
-});
-
-test("expiry is carried out here and decided elsewhere", () => {
-  // The register has no clock on purpose: the rule that says how stale is too
-  // stale lives with whoever measures it, and this stays exercisable with
-  // numbers alone.
-  const demand = new SegmentDemand();
-  demand.state({ claimant: "one", address: PICTURE, from: 0, to: 5, statedAt: 1000 });
-  demand.state({ claimant: "two", address: PICTURE, from: 0, to: 5, statedAt: 9000 });
-  const dropped = demand.forgetStatedBefore(5000);
-  assert.equal(dropped.length, 1);
-  assert.equal(dropped[0].claimant, "one");
-  assert.equal(demand.stats().windows, 1);
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(SOUND, [{ from: 88, to: 115, priority: 32, withinSeconds: 0 }]);
+  assert.equal(demand.mapOn(PICTURE)[0].from, 100);
+  assert.equal(demand.mapOn(SOUND)[0].from, 88);
+  assert.deepEqual(demand.addresses().sort(), [SOUND, PICTURE].sort());
 });
 
-test("a window that is not a window is refused rather than stored", () => {
+test("an output can be forgotten entirely", () => {
   const demand = new SegmentDemand();
-  assert.equal(demand.state({ claimant: "one", address: PICTURE, from: 5, to: 1, statedAt: 1 }), null);
-  assert.equal(demand.state({ claimant: "", address: PICTURE, from: 0, to: 1, statedAt: 1 }), null);
-  assert.equal(demand.state({ claimant: "one", address: "", from: 0, to: 1, statedAt: 1 }), null);
-  assert.equal(demand.stats().windows, 0);
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.forget(PICTURE);
+  assert.deepEqual(demand.addresses(), []);
 });
 
-test("nothing wanted on an output answers null rather than an empty span", () => {
+test("nothing about a viewer can be stated, because nothing about one is held", () => {
+  // The check that the rule holds by construction: there is no name to pass and
+  // no way to ask about one.
   const demand = new SegmentDemand();
-  assert.equal(demand.spanOn(PICTURE), null);
-  assert.deepEqual(demand.wantedOn(PICTURE), []);
+  assert.equal(typeof (/** @type {any} */ (demand).want), "undefined");
+  assert.equal(typeof (/** @type {any} */ (demand).windowsOn), "undefined");
+  assert.equal(
+    demand.state.length,
+    2,
+    "an address and a map, and nothing else"
+  );
 });

package/test/wedge-certainty.test.js

@@ -65,14 +65,14 @@ test("a tiny queue still waits for one round of probes", () => {
   assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
 });
 
-test("nothing queued is not a wedge however long the counter has been still", () => {
+test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
   const verdict = wedgeIsCertain({
     queuedBytes: 0,
     bytesPerSecond: 16 * MEGABYTE,
     flatForMs: 600_000
   });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, null);
+  assert.equal(verdict.certain, true);
+  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
 });
 
 test("with no rate measured the answer is that nothing can be said", () => {