@torrent-tv/proxy 2.83.8 → 2.85.0

package/test/link-probe.test.js

@@ -0,0 +1,56 @@
+/**
+ * @file The route that hands a browser bytes to time its link with.
+ *
+ * Only this end's half. How big an ask should be is derived on the page, from
+ * what its last ask measured, and is checked where that function lives — a copy
+ * of it here would be two owners of one rule, which is the fault this
+ * repository keeps recording.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { handleApiLinkProbeGet, MAX_LINK_PROBE_BYTES } from "../routes/api/link-probe/get.js";
+
+/**
+ * A reply that records what it was given.
+ *
+ * @returns {{ code: (n: number) => object, header: () => object, send: (b: unknown) => object, status: number | null, body: unknown }}
+ */
+function fakeReply() {
+  const reply = {
+    status: /** @type {number | null} */ (null),
+    body: /** @type {unknown} */ (null),
+    code(n) {
+      reply.status = n;
+      return reply;
+    },
+    header() {
+      return reply;
+    },
+    send(body) {
+      reply.body = body;
+      return reply;
+    }
+  };
+  return reply;
+}
+
+
+
+test("the route answers exactly what was asked for, up to its own ceiling", async () => {
+  const small = fakeReply();
+  await handleApiLinkProbeGet({ query: { bytes: "65536" } }, small);
+  assert.equal(small.status, 200);
+  assert.equal(/** @type {Buffer} */ (small.body).length, 65536);
+
+  const huge = fakeReply();
+  await handleApiLinkProbeGet({ query: { bytes: "999999999" } }, huge);
+  assert.equal(/** @type {Buffer} */ (huge.body).length, MAX_LINK_PROBE_BYTES);
+});
+
+test("the route refuses an ask that is not a size", async () => {
+  const reply = fakeReply();
+  await handleApiLinkProbeGet({ query: { bytes: "none" } }, reply);
+  assert.equal(reply.status, 400);
+});

package/test/orchestrator-wired.test.js

@@ -109,21 +109,27 @@ test("what a viewer waits for reaches the plan without their name", (t) => {
   assert.ok(wanted.some((zone) => zone.to > 5), "and the cushion in front of them");
 });
 
-test("a viewer nothing has been heard from at all stops being waited for", (t) => {
+test("a viewer who has gone stops being waited for, and silence alone never counts", (t) => {
   const { manager, root, dirPath } = managerWithAnOutput();
   t.after(() => rmSync(root, { recursive: true, force: true }));
 
   const session = sessionOn({ id: "one", dirPath });
   manager.sessionsById.set(session.id, session);
-  const gone = viewerOf(session, "gone");
-  gone.position = { segment: 5, seconds: 20, at: Date.now() - 10 * 60 * 1000 };
-  // What decides it is when they were last HEARD FROM, not when they last
-  // asked for a segment: a viewer holding a full cushion asks for nothing for
-  // as long as it takes to drain, and is no less present for it.
-  gone.seen(Date.now() - 10 * 60 * 1000);
-
+  const person = viewerOf(session, "gone");
+  person.moveTo(20, Date.now() - 10 * 60 * 1000);
+  person.playing = false;
+  person.seen(Date.now() - 10 * 60 * 1000);
+
+  // TEN MINUTES OF SILENCE IS NOT LEAVING. A paused viewer, a hidden tab whose
+  // timers the browser has throttled, and one holding a full cushion are all
+  // silent and all still watching, so what they want is still wanted.
   manager.planEncodersNow();
+  assert.ok(manager.encodeOrchestrator.demand.mapOn(KEY).length > 0, "still watching");
 
+  // Something SAYS they are gone — the browser released the session, or their
+  // connection closed. That is the only way out.
+  manager.viewers.leaves(session, "gone");
+  manager.planEncodersNow();
   assert.equal(manager.encodeOrchestrator.demand.mapOn(KEY).length, 0);
 });
 

package/test/output-spec.test.js

@@ -1,157 +1,157 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../services/output/OutputSpec.js";
-
-const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
-
-/**
- * The picture of a file, copied, cut at that file's own keyframes.
- *
- * @param {object} [over]
- * @returns {OutputSpec}
- */
-function copiedPicture(over = {}) {
-  return new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: null,
-    ...over
-  });
-}
-
-test("two viewers who chose different soundtracks share one copied picture", () => {
-  // The measurement of 2026-09-03: both sessions described the same thing word
-  // for word and answered `segment-00000.mp4` with the same 4141899 bytes. The
-  // soundtrack they picked is not a property of a picture that carries no
-  // sound, so it cannot tell the two apart.
-  assert.equal(copiedPicture().toKey(), copiedPicture().toKey());
-  assert.equal(copiedPicture().carries, "video-only");
-});
-
-test("the viewer's viewport does not fork a picture that is copied", () => {
-  // A copy is the source's own size whatever box was asked for, so there is
-  // nowhere for a target to appear in the key.
-  const key = copiedPicture().toKey();
-  assert.ok(!key.includes("x"), `a copied picture states no box: ${key}`);
-});
-
-test("two heights of one picture are two outputs", () => {
-  const at720 = copiedPicture({
-    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, manual: true } })
-  });
-  const at480 = copiedPicture({
-    video: new VideoOutput({ fileIndex: 0, encode: { width: 854, height: 480, manual: true } })
-  });
-  assert.notEqual(at720.toKey(), at480.toKey());
-});
-
-test("a height the viewer forced is not the same output as one the budget may move", () => {
-  const forced = copiedPicture({
-    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, manual: true } })
-  });
-  const chosen = copiedPicture({
-    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, manual: false } })
-  });
-  assert.notEqual(forced.toKey(), chosen.toKey());
-});
-
-test("a soundtrack is named by the file it lives in and the track inside it", () => {
-  // Not by the flat number the browser sends: that number spans the picture's
-  // own tracks and the files beside it, so it means different things for
-  // different pictures of one torrent.
-  const dub = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
-  });
-  assert.equal(dub.carries, "audio-only");
-  assert.ok(dub.toKey().includes("a=7/0/aac"), dub.toKey());
-});
-
-test("one soundtrack cut for two different pictures is two outputs", () => {
-  // The grid of a soundtrack is the picture's, so a rendition made for episode
-  // one cannot stand in for one made for episode two even when the dub is the
-  // same file.
-  const forFirst = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
-  });
-  const forSecond = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 1 }),
-    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
-  });
-  assert.notEqual(forFirst.toKey(), forSecond.toKey());
-});
-
-test("a copied soundtrack and a re-encoded one are two outputs", () => {
-  const copied = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: false })
-  });
-  const encoded = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: true })
-  });
-  assert.notEqual(copied.toKey(), encoded.toKey());
-});
-
-test("a browser without rendition groups gets an output carrying both tracks", () => {
-  const muxed = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "mpegts",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 2, transcode: true })
-  });
-  assert.equal(muxed.carries, "muxed");
-  // And there the soundtrack DOES tell two of them apart, because the output
-  // really carries it.
-  const other = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "mpegts",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    video: new VideoOutput({ fileIndex: 0, encode: null }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 3, transcode: true })
-  });
-  assert.notEqual(muxed.toKey(), other.toKey());
-});
-
-test("the picture, its soundtrack and the two of them muxed are three outputs", () => {
-  const video = copiedPicture();
-  const audio = new OutputSpec({
-    sourceKey: TORRENT,
-    segmentFormatId: "fmp4",
-    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
-  });
-  const muxed = copiedPicture({
-    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
-  });
-  assert.equal(new Set([video.toKey(), audio.toKey(), muxed.toKey()]).size, 3);
-});
-
-test("two containers of the same tracks are two outputs", () => {
-  assert.notEqual(copiedPicture().toKey(), copiedPicture({ segmentFormatId: "mpegts" }).toKey());
-});
-
-test("the same tracks of two different torrents are two outputs", () => {
-  assert.notEqual(copiedPicture().toKey(), copiedPicture({ sourceKey: "torrent:0000" }).toKey());
-});
-
-test("a picture cut at keyframes and the same picture cut on the even grid are two outputs", () => {
-  assert.notEqual(
-    copiedPicture().toKey(),
-    copiedPicture({ grid: new CutGrid({ kind: "uniform", fileIndex: 0 }) }).toKey()
-  );
-});
+import assert from "node:assert/strict";
+import test from "node:test";
+import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../services/output/OutputSpec.js";
+
+const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
+
+/**
+ * The picture of a file, copied, cut at that file's own keyframes.
+ *
+ * @param {object} [over]
+ * @returns {OutputSpec}
+ */
+function copiedPicture(over = {}) {
+  return new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: null,
+    ...over
+  });
+}
+
+test("two viewers who chose different soundtracks share one copied picture", () => {
+  // The measurement of 2026-09-03: both sessions described the same thing word
+  // for word and answered `segment-00000.mp4` with the same 4141899 bytes. The
+  // soundtrack they picked is not a property of a picture that carries no
+  // sound, so it cannot tell the two apart.
+  assert.equal(copiedPicture().toKey(), copiedPicture().toKey());
+  assert.equal(copiedPicture().carries, "video-only");
+});
+
+test("the viewer's viewport does not fork a picture that is copied", () => {
+  // A copy is the source's own size whatever box was asked for, so there is
+  // nowhere for a target to appear in the key.
+  const key = copiedPicture().toKey();
+  assert.ok(!key.includes("x"), `a copied picture states no box: ${key}`);
+});
+
+test("two heights of one picture are two outputs", () => {
+  const at720 = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, exactSize: true } })
+  });
+  const at480 = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 854, height: 480, exactSize: true } })
+  });
+  assert.notEqual(at720.toKey(), at480.toKey());
+});
+
+test("a height produced exactly is not the same output as one the budget may move", () => {
+  const forced = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, exactSize: true } })
+  });
+  const chosen = copiedPicture({
+    video: new VideoOutput({ fileIndex: 0, encode: { width: 1280, height: 720, exactSize: false } })
+  });
+  assert.notEqual(forced.toKey(), chosen.toKey());
+});
+
+test("a soundtrack is named by the file it lives in and the track inside it", () => {
+  // Not by the flat number the browser sends: that number spans the picture's
+  // own tracks and the files beside it, so it means different things for
+  // different pictures of one torrent.
+  const dub = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
+  });
+  assert.equal(dub.carries, "audio-only");
+  assert.ok(dub.toKey().includes("a=7/0/aac"), dub.toKey());
+});
+
+test("one soundtrack cut for two different pictures is two outputs", () => {
+  // The grid of a soundtrack is the picture's, so a rendition made for episode
+  // one cannot stand in for one made for episode two even when the dub is the
+  // same file.
+  const forFirst = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
+  });
+  const forSecond = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 1 }),
+    audio: new AudioOutput({ fileIndex: 7, trackIndex: 0, transcode: true })
+  });
+  assert.notEqual(forFirst.toKey(), forSecond.toKey());
+});
+
+test("a copied soundtrack and a re-encoded one are two outputs", () => {
+  const copied = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: false })
+  });
+  const encoded = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "uniform", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 1, transcode: true })
+  });
+  assert.notEqual(copied.toKey(), encoded.toKey());
+});
+
+test("a browser without rendition groups gets an output carrying both tracks", () => {
+  const muxed = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "mpegts",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 2, transcode: true })
+  });
+  assert.equal(muxed.carries, "muxed");
+  // And there the soundtrack DOES tell two of them apart, because the output
+  // really carries it.
+  const other = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "mpegts",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    video: new VideoOutput({ fileIndex: 0, encode: null }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 3, transcode: true })
+  });
+  assert.notEqual(muxed.toKey(), other.toKey());
+});
+
+test("the picture, its soundtrack and the two of them muxed are three outputs", () => {
+  const video = copiedPicture();
+  const audio = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "fmp4",
+    grid: new CutGrid({ kind: "keyframe", fileIndex: 0 }),
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
+  });
+  const muxed = copiedPicture({
+    audio: new AudioOutput({ fileIndex: 0, trackIndex: 0, transcode: true })
+  });
+  assert.equal(new Set([video.toKey(), audio.toKey(), muxed.toKey()]).size, 3);
+});
+
+test("two containers of the same tracks are two outputs", () => {
+  assert.notEqual(copiedPicture().toKey(), copiedPicture({ segmentFormatId: "mpegts" }).toKey());
+});
+
+test("the same tracks of two different torrents are two outputs", () => {
+  assert.notEqual(copiedPicture().toKey(), copiedPicture({ sourceKey: "torrent:0000" }).toKey());
+});
+
+test("a picture cut at keyframes and the same picture cut on the even grid are two outputs", () => {
+  assert.notEqual(
+    copiedPicture().toKey(),
+    copiedPicture({ grid: new CutGrid({ kind: "uniform", fileIndex: 0 }) }).toKey()
+  );
+});

package/test/plan-is-steady.test.js

@@ -0,0 +1,225 @@
+/**
+ * @file The placement must not move while the facts do not.
+ *
+ * This is the check the field failure of 2026-09-13 had no equivalent of. Two
+ * browsers on one torrent: 77 encoder starts and 141 stops in six minutes
+ * against ONE normal end, both viewers frozen — one at 170.8 s with
+ * `bufferedAhead=0.1s`, the other at 1673.6 s with an empty buffer — while the
+ * swarm delivered 3 MB/s from 129 peers. Nothing was produced because no run
+ * lived long enough to close a piece.
+ *
+ * The plan itself was not at fault and was measured not to be: given a settled
+ * map it returns the same arrangement however often it is asked. What moved was
+ * its INPUT. A viewer's position had two writers — a seek wrote one field, a
+ * segment request wrote another, and the reading preferred whichever was set —
+ * so the priority map jumped backwards and forwards by one or two segments
+ * several times a second:
+ *
+ *   19:58:00.283  p100:#9..#10    p100:#160..#162
+ *   19:58:00.496  p100:#18..#20   p100:#161..#163
+ *   19:58:00.574  p100:#16..#18   p100:#161..#163
+ *   19:58:00.696  p100:#16..#18   p100:#160..#162
+ *   19:58:01.231  p100:#18..#20   p100:#160..#162
+ *
+ * So the property to hold is about the whole chain and not about one function:
+ * what a viewer states must produce a map that only moves the way film moves,
+ * and a plan asked repeatedly against unchanged facts must answer identically.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+import { planEncoders } from "../services/encode/EncodePlan.js";
+import { contentionPenalty, penaltiesFrom } from "../services/encode/contention.js";
+import { mapForViewer, mergeMaps, runsOf } from "../services/priority/PriorityMap.js";
+import { Viewer } from "../services/viewer/Viewer.js";
+
+// Measured on the addon host 2026-09-03: 7.12x alone, 4.18x with a second.
+const PENALTIES = penaltiesFrom(7.12, [{ others: 1, speed: 4.18 }]);
+const penaltyFor = (others) => contentionPenalty(others, PENALTIES).penalty;
+
+const HOST = {
+  contentionPenaltyFor: penaltyFor,
+  speedX: 2,
+  segmentSeconds: 8,
+  killCostSec: 0.5,
+  firstByteWaitSec: 1,
+  refetchSecPerFilmSecond: 0.25
+};
+
+const DURATION = 2896;
+const ALLOWANCE = 30;
+
+/**
+ * The map two viewers produce, exactly as `PriorityOrchestrator` builds it.
+ *
+ * @param {Viewer[]} viewers
+ * @param {number} now
+ * @returns {{ from: number, to: number, priority: number }[]}
+ */
+function zonesFor(viewers, now) {
+  const merged = mergeMaps(
+    viewers.map((viewer) =>
+      mapForViewer({
+        atSeconds: viewer.positionSeconds(now) ?? 0,
+        durationSeconds: DURATION,
+        allowanceSeconds: ALLOWANCE,
+        playing: viewer.wantsFilmNow()
+      })
+    )
+  );
+  return runsOf(merged).map((zone) => ({
+    from: Math.floor(zone.from / HOST.segmentSeconds),
+    to: Math.floor((zone.to - 1) / HOST.segmentSeconds),
+    priority: zone.priority
+  }));
+}
+
+test("a viewer's position only ever moves the way film moves", () => {
+  const viewer = new Viewer("one", 1_000_000);
+  // Stated the way a page states it: where they are, what they hold, and that
+  // the picture is advancing. The cushion is what bounds the extrapolation, so
+  // a viewer who has stated none cannot move at all.
+  viewer.report(
+    { bufferedAheadSec: 120, positionSeconds: 170.8, playing: true, waiting: false },
+    1_000_000
+  );
+
+  let previous = viewer.positionSeconds(1_000_000);
+  for (let tick = 1; tick <= 200; tick += 1) {
+    const now = 1_000_000 + tick * 50;
+    const seconds = viewer.positionSeconds(now);
+    assert.ok(seconds >= previous, `position went backwards at tick ${tick}: ${seconds} < ${previous}`);
+    previous = seconds;
+  }
+  // Fifty ticks of 50 ms is ten seconds of wall clock, and a playing viewer
+  // covers ten seconds of film in it.
+  assert.ok(Math.abs(previous - (170.8 + 10)) < 0.001, `expected 180.8s, got ${previous}`);
+});
+
+test("a segment request does not move a viewer, and a stopped picture does not either", () => {
+  const viewer = new Viewer("one", 1_000_000);
+  viewer.report(
+    { bufferedAheadSec: 120, positionSeconds: 170.8, playing: false, waiting: false },
+    1_000_000
+  );
+
+  // Whatever else happens, only a statement from the viewer moves them. There
+  // is no method here a request could call: `seen` is presence and nothing more.
+  viewer.seen(1_000_500);
+  viewer.seen(1_001_000);
+  assert.equal(viewer.positionSeconds(1_010_000), 170.8);
+});
+
+test("the priority map of two viewers is the same whenever it is asked", () => {
+  const at = 1_000_000;
+  const one = new Viewer("one", at);
+  one.report({ bufferedAheadSec: 120, positionSeconds: 170.8, playing: false, waiting: false }, at);
+  const two = new Viewer("two", at);
+  two.report({ bufferedAheadSec: 120, positionSeconds: 1673.6, playing: false, waiting: false }, at);
+
+  const first = JSON.stringify(zonesFor([one, two], at));
+  for (let tick = 1; tick <= 40; tick += 1) {
+    // Nothing changes: both pictures are stopped, so no time passes for them.
+    assert.equal(JSON.stringify(zonesFor([one, two], at + tick * 100)), first, `map moved at tick ${tick}`);
+  }
+});
+
+test("two viewers far apart settle on one arrangement and stay on it", () => {
+  const at = 1_000_000;
+  const one = new Viewer("one", at);
+  one.report({ bufferedAheadSec: 120, positionSeconds: 170.8, playing: false, waiting: false }, at);
+  const two = new Viewer("two", at);
+  two.report({ bufferedAheadSec: 120, positionSeconds: 1673.6, playing: false, waiting: false }, at);
+
+  const coverage = new CoverageMap({ segmentCount: 362 });
+  /** @type {{ from: number, to: number, head: number, speedX: number, startedAt: number }[]} */
+  let live = [];
+  let started = 0;
+  let stopped = 0;
+
+  for (let tick = 0; tick < 60; tick += 1) {
+    const now = at + tick * 100;
+    const actions = planEncoders({
+      coverage,
+      windows: zonesFor([one, two], now),
+      runs: live,
+      maxRuns: 2,
+      now,
+      ...HOST
+    });
+    for (const action of actions) {
+      if (action.type === "start") {
+        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now });
+        started += 1;
+      } else if (action.type === "stop") {
+        live = live.filter((run) => run !== action.run);
+        stopped += 1;
+      } else if (action.type === "move") {
+        live = live.filter((run) => run !== action.run);
+        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now });
+        started += 1;
+        stopped += 1;
+      }
+    }
+  }
+
+  // One encoder per viewer, placed once. Anything above this is the plan
+  // arguing with itself: in the field the same six minutes cost 77 and 141.
+  assert.equal(started, 2, `expected two starts, got ${started}`);
+  assert.equal(stopped, 0, `expected no stops, got ${stopped}`);
+  assert.equal(live.length, 2);
+});
+
+test("an encoder keeping ahead of a playing viewer is left alone", () => {
+  const at = 1_000_000;
+  const one = new Viewer("one", at);
+  one.report({ bufferedAheadSec: 120, positionSeconds: 0, playing: true, waiting: false }, at);
+
+  const coverage = new CoverageMap({ segmentCount: 362 });
+  const ready = new Set();
+  /** @type {{ from: number, to: number, head: number, speedX: number, startedAt: number, made: number }[]} */
+  let live = [];
+  let moves = 0;
+  let starts = 0;
+
+  for (let tick = 0; tick < 120; tick += 1) {
+    const now = at + tick * 1000;
+    const actions = planEncoders({
+      coverage,
+      windows: zonesFor([one], now),
+      runs: live,
+      maxRuns: 1,
+      now,
+      ...HOST
+    });
+    for (const action of actions) {
+      if (action.type === "start") {
+        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now, made: 0 });
+        starts += 1;
+      } else if (action.type === "move") {
+        live = live.filter((run) => run !== action.run);
+        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now, made: 0 });
+        moves += 1;
+      } else if (action.type === "stop") {
+        live = live.filter((run) => run !== action.run);
+      }
+    }
+    // The encoder works: at 2x, one 8-second piece every four seconds of clock.
+    for (const run of live) {
+      run.made += 1000 * 2;
+      while (run.made >= HOST.segmentSeconds * 1000 && run.head <= run.to) {
+        run.made -= HOST.segmentSeconds * 1000;
+        ready.add(run.head);
+        run.head += 1;
+      }
+    }
+    coverage.setReady(ready);
+  }
+
+  // One encoder, placed once, running twice as fast as the viewer plays: it
+  // stays in front of them for the whole two minutes, so there is nothing to
+  // decide again.
+  assert.equal(starts, 1, `expected one start, got ${starts}`);
+  assert.equal(moves, 0, `expected no moves, got ${moves}`);
+});