@torrent-tv/proxy 2.77.0 → 2.78.0

package/services/orchestrators/EncodeOrchestrator.js

@@ -121,9 +121,14 @@ export class EncodeOrchestrator {
    * @param {string} params.address
    * @param {number} params.from
    * @param {number} params.to
+   * @param {number} [params.priority] - Higher is sooner. One viewer states
+   *   several stretches at once — what must be ready before they set off, what
+   *   is reachable while they watch it, the rest of the track — and the filling
+   *   takes them in this order. Absent means one undifferentiated want, which
+   *   is what a caller that knows only a position states.
    */
-  want({ claimant, address, from, to }) {
-    this.demand.state({ claimant, address, from, to, statedAt: this.now() });
+  want({ claimant, address, from, to, priority = 0 }) {
+    this.demand.state({ claimant, address, from, to, priority, statedAt: this.now() });
   }
 
   /**
@@ -196,9 +201,14 @@ export class EncodeOrchestrator {
         });
       }
     }
+    // Carrying the priority through, because the filling takes the work in that
+    // order: what a viewer must have before they set off comes before what is
+    // merely in front of them, which comes before the rest of the track. Passed
+    // as a plain number so the plan stays arithmetic.
     const windows = this.demand.windowsOn(address).map((window) => ({
       from: window.from,
-      to: window.to
+      to: window.to,
+      priority: Number(window.priority) || 0
     }));
     const live = this.runsOn(address).filter((run) => run.isAlive);
     const actions = planEncoders({

package/test/demand-map.test.js

@@ -0,0 +1,102 @@
+/**
+ * @file A map per viewer, merged into one, in the order the work is taken.
+ *
+ * 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.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mapForViewer, mergeMaps, inWorkingOrder } from "../services/encode/DemandMap.js";
+
+test("a viewer's own position is the most urgent thing there is", () => {
+  const map = mapForViewer({
+    atSeconds: 100,
+    durationSeconds: 1000,
+    allowanceSeconds: 8,
+    encodeSpeedX: 2
+  });
+
+  assert.equal(map[0].from, 100);
+  assert.equal(map[0].to, 108, "above realtime, only the measured allowance");
+  for (const zone of map.slice(1)) {
+    assert.ok(zone.priority < map[0].priority);
+  }
+});
+
+test("a machine that cannot keep up must have more ready before the viewer sets off", () => {
+  // 900s of film in front. At 0.25x the encoder loses three seconds of film per
+  // second played, so 675s must exist first, or the viewer stalls partway.
+  const slow = mapForViewer({ atSeconds: 100, durationSeconds: 1000, allowanceSeconds: 0, encodeSpeedX: 0.25 });
+  const fast = mapForViewer({ atSeconds: 100, durationSeconds: 1000, allowanceSeconds: 0, encodeSpeedX: 2 });
+
+  assert.equal(slow[0].to, 775, "100 + 900 x 0.75");
+  assert.ok(
+    slow[0].to - slow[0].from > fast[0].to - fast[0].from,
+    "the slower the machine, the more of the film must be made in advance"
+  );
+});
+
+test("the allowance is added to the shortfall, not chosen instead of it", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 10, encodeSpeedX: 0.5 });
+
+  assert.equal(map[0].to, 60, "50s of shortfall plus 10s of measured allowance");
+});
+
+test("the rest of the track is still wanted, and wanted last", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 4, encodeSpeedX: 2 });
+
+  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("nothing is measured yet: the middle zone is left out rather than invented", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 4, encodeSpeedX: 0 });
+
+  assert.equal(map.length, 2, "what must be ready, and the rest");
+});
+
+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 });
+
+  const merged = mergeMaps([first, second]);
+
+  let previousEnd = merged[0].from;
+  for (const zone of merged) {
+    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
+    previousEnd = zone.to;
+  }
+  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("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 }
+  ]);
+
+  assert.deepEqual(order.map((zone) => zone.from), [0, 100, 900]);
+});

package/test/encode-plan.test.js

@@ -176,7 +176,12 @@ test("every encoder stops when nobody is watching the output", () => {
   );
 });
 
-test("a run making material nobody asked for is stopped", () => {
+test("a run standing outside every window keeps working: the file is encoded whole", () => {
+  // The rule, stated by the user 2026-09-05: while a file is being encoded it
+  // is encoded whole, and a viewer decides the ORDER, not whether a run may
+  // live. Stopping a run for standing outside a window is what produced the
+  // field oscillation of that day — placed by one rule, killed by another,
+  // 350-700ms per cycle, nothing ever produced.
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const runA = run({ from: 500, to: 600, head: 520 });
   coverage.claim(runA, 500, 600);
@@ -186,7 +191,44 @@ test("a run making material nobody asked for is stopped", () => {
     runs: [runA],
     ...HOST
   });
-  assert.ok(actions.some((action) => action.type === "stop" && action.run === runA));
+  assert.ok(
+    !actions.some((action) => action.type === "stop" && action.run === runA),
+    "it is making film that will be wanted, and nothing else is making it"
+  );
+});
+
+test("the same plan run twice on an unchanged state gives the same answer", () => {
+  // What the oscillation actually was: two passes over one state disagreeing
+  // with each other. Nothing about the state changes between them here.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const runA = run({ from: 500, to: 600, head: 520 });
+  coverage.claim(runA, 500, 600);
+  const input = { coverage, windows: [{ from: 0, to: 40 }], runs: [runA], ...HOST };
+
+  const first = planEncoders(input).map((action) => action.type);
+  const second = planEncoders(input).map((action) => action.type);
+
+  assert.deepEqual(first, second);
+  assert.ok(!first.includes("stop"), "and neither pass kills what the other would start");
+});
+
+test("a viewer's most urgent zone is filled before a less urgent one", () => {
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const actions = planEncoders({
+    coverage,
+    // The far zone is lower in number and lower in priority: the order must
+    // come from the priority, not from the number.
+    windows: [
+      { from: 0, to: 100, priority: 1 },
+      { from: 500, to: 530, priority: 3 }
+    ],
+    runs: [],
+    ...HOST,
+    maxRuns: 1
+  });
+  const started = actions.filter((action) => action.type === "start").map((action) => action.from);
+
+  assert.deepEqual(started, [500], "the one machine goes where somebody is stopped");
 });
 
 test("two viewers far apart get an encoder each, when the machine can hold two", () => {

package/test/run-intervals.test.js

@@ -1,336 +1,100 @@
 /**
- * @file A run is given a stretch nobody else holds, and stops at the end of it.
+ * @file How far a run may work, and who decides it.
  *
- * This is what removes the per-run directories. Runs used to be kept apart by a
- * directory each, because two of them writing one segment name at the same time
- * produce a file belonging to neither — which was also the only reason a restart
- * ever had to wait for its predecessor to die. Intervals remove that by
- * construction, so one flat directory per output is correct.
+ * These cases used to be asked of `planRunInterval`, a second authority inside
+ * the session manager that answered by its own rules: it walked the whole track
+ * for the first free number, MOVED the start there, and counted every live run
+ * as claiming up to `head + look-ahead`. It contradicted the plan directly, and
+ * the two together produced the field oscillation of 2026-09-05 — the plan
+ * commanded a start at #46, this moved it to #78, the plan killed the run for
+ * standing outside the window it had asked for, and the same start was
+ * commanded again, 350-700ms per cycle, no segment ever produced, the viewer's
+ * picture stopped for 125 seconds.
  *
- * The other half is the argument that states the end, and WHICH argument it is
- * belongs to the branch — measured, not reasoned:
- * `research/encoder-layer-2026-09-04.md` §11.
+ * It is gone. WHERE a run starts is the plan's decision and nothing moves it;
+ * HOW FAR it may work is a fact of the one coverage map, and that is what these
+ * cases now ask. The map is the same object the plan reads, so there is no
+ * second set of rules for the two to disagree about.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { SourceFile } from "../services/source/SourceFile.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { HlsSessionManager } from "../services/hls-session-manager.js";
-import { SegmentStore } from "../services/encode/SegmentStore.js";
-import { Timeline } from "../services/output/Timeline.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
-import { viewerOf } from "../services/viewer/Viewer.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
 
-const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-/**
- * @returns {{ manager: HlsSessionManager, store: SegmentStore, root: string, dirPath: string }}
- */
-function managerWithAnEmptyOutput() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "run-intervals-"));
-  const store = new SegmentStore({ root });
-  const manager = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    segmentStore: store
-  });
-  const dirPath = store.directoryFor(KEY);
-  store.useFormat(KEY, fmp4Format);
-  return { manager, store, root, dirPath };
-}
-
-/**
- * @param {object} params
- * @returns {object}
- */
-function sessionOn({ id, dirPath, segmentCount = 100, runState = null, encodeStartIndex = 0, runEndIndex = -1 }) {
-  const session = {
-    id,
-    outputKey: KEY,
-    dirPath,
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
-    // An ordinary session reads its own file, and its sound is inside it. The
-    // three differ only for a soundtrack shipped as a file of its own.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    segmentFormat: fmp4Format,
-    // How the file is cut, held by the TIMELINE. A fixture that stated it on the
-    // session was describing a shape the product had left, and it kept a defect
-    // alive for a release: `session.segmentCount` is undefined on every real
-    // session, so runs were given no end and the coverage map had no length.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: segmentCount + 1 }, (_, index) => index * 4),
-      cutGrid: "uniform"
-    }),
-    runs: new Set(),
-    consumers: new Set(),
-    lastAccessedAt: Date.now()
-  };
-  if (runState !== null) {
-    const run = startRunOn(session, { from: encodeStartIndex, to: runEndIndex });
-    if (runState === "ENDED_FAILED") {
-      // A run that failed, said so, and left what it had made behind.
-      run.process?.exit(255, null);
-    }
-  }
-  return session;
-}
-
-/**
- * @param {string} dirPath
- * @param {number[]} indexes
- */
-function alreadyMade(dirPath, indexes) {
-  for (const index of indexes) {
-    writeFileSync(path.join(dirPath, fmp4Format.segmentFileName(index)), Buffer.alloc(16, 1));
-  }
+/** A stand-in for a run: the map identifies one by being it. */
+function run(name) {
+  return { name };
 }
 
-test("with nothing made, a run gets everything from where it was asked", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "s", dirPath });
-  // -1 for the end means "to the end of the film", which is what every run had
-  // before ends existed — and the only case where that is still right.
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: -1 });
-});
-
-test("a run stops before material that is already made", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // 10..20 on the disk. Only 10..19 are PROVEN — the highest has no successor,
-  // so nothing shows whether it was closed or was being written when its run
-  // died.
-  alreadyMade(dirPath, [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]);
-  const session = sessionOn({ id: "s", dirPath });
-
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: 9 });
-});
-
-test("a run asked to start inside made material is moved forward to the gap", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  alreadyMade(dirPath, [10, 11, 12, 13, 14, 15]);
-  const session = sessionOn({ id: "s", dirPath });
-
-  // Asked for 11, which is made, and so is everything to 14. The first thing
-  // worth encoding is 15 — unproven, because 16 does not exist.
-  assert.deepEqual(manager.planRunInterval(session, 11), { from: 15, to: -1 });
-});
-
-test("a run stops before a stretch another live run was given", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const other = sessionOn({
-    id: "other",
-    dirPath,
-    runState: "PRODUCING",
-    encodeStartIndex: 40,
-    runEndIndex: 60
-  });
-  manager.sessionsById.set(other.id, other);
-  const session = sessionOn({ id: "s", dirPath });
+test("with nothing made, a run gets everything from where it was asked", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
 
-  // Two viewers of one film, one already encoding 40..60. The second run takes
-  // what is free in front of it and stops where the other one begins, so
-  // neither ever writes a name the other wants.
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: 39 });
-  assert.deepEqual(manager.planRunInterval(session, 45), { from: 61, to: -1 });
+  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
+  assert.equal(coverage.firstGapFrom(0), 0);
 });
 
-test("a run that has died holds nothing back", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // The same stretch, but the process cannot be signalled — it has ended. What
-  // it did not finish is free again, without anything having to release it.
-  const dead = sessionOn({
-    id: "dead",
-    dirPath,
-    runState: "ENDED_FAILED",
-    encodeStartIndex: 40,
-    runEndIndex: 60
-  });
-  manager.sessionsById.set(dead.id, dead);
-  const session = sessionOn({ id: "s", dirPath });
+test("a run stops before material that is already made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  coverage.markReadyAll([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
 
-  assert.deepEqual(manager.planRunInterval(session, 0), { from: 0, to: -1 });
+  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
 });
 
-test("nothing left to make is answered with nothing, not with a run", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+test("a run stops before a stretch another live run was given", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const other = run("other");
+  coverage.claim(other, 40, 60);
 
-  const session = sessionOn({ id: "s", dirPath, segmentCount: 5 });
-  alreadyMade(dirPath, [0, 1, 2, 3, 4]);
-  const other = sessionOn({
-    id: "other",
-    dirPath,
-    segmentCount: 5,
-    runState: "PRODUCING",
-    encodeStartIndex: 4,
-    runEndIndex: 4
-  });
-  manager.sessionsById.set(other.id, other);
-
-  // Starting an encoder here would only repeat somebody else's work, which is
-  // what three ffmpeg processes making one identical picture cost on a CM4.
-  assert.equal(manager.planRunInterval(session, 0), null);
+  assert.equal(coverage.freeRunFrom(0), 40, "0..39, and the other run's claim begins at 40");
+  assert.equal(coverage.firstGapFrom(45), 61, "the first thing nobody holds after it");
 });
 
-test("a session with no address keeps the old shape: start here, no end", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const session = sessionOn({ id: "s", dirPath });
-  session.outputKey = "";
-
-  assert.deepEqual(manager.planRunInterval(session, 7), { from: 7, to: -1 });
-});
-
-test("a run without an end does not claim the whole film away from a later viewer", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // The first viewer's run, at the beginning, with no end — which is every run
-  // whose output was empty when it started.
-  const first = sessionOn({
-    id: "first",
-    dirPath,
-    segmentCount: 1000,
-    runState: "PRODUCING",
-    encodeStartIndex: 0,
-    runEndIndex: -1
-  });
-  manager.sessionsById.set(first.id, first);
-  const second = sessionOn({ id: "second", dirPath, segmentCount: 1000 });
-
-  // A second viewer opens the same film in the middle. Counting the first run's
-  // claim as the whole film would leave them with no encoder at all, waiting for
-  // it to encode its way there — an hour on a long film. It only claims as far
-  // as it will actually get, which is its head plus the look-ahead.
-  const planned = manager.planRunInterval(second, 500);
-  assert.notEqual(planned, null);
-  assert.equal(planned.from, 500);
-});
+test("a run's own claim does not hold it back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const mine = run("mine");
+  coverage.claim(mine, 40, 60);
 
-test("a run stops when it reaches a stretch another run was given", async (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const stopped = [];
-  const ahead = sessionOn({
-    id: "ahead",
-    dirPath,
-    runState: "PRODUCING",
-    encodeStartIndex: 500,
-    runEndIndex: 600
-  });
-  manager.sessionsById.set(ahead.id, ahead);
-  const behind = sessionOn({
-    id: "behind",
-    dirPath,
-    runState: "PRODUCING",
-    encodeStartIndex: 0,
-    runEndIndex: -1
-  });
-  manager.sessionsById.set(behind.id, behind);
-
-  // Its own end was set from the gaps of the moment it began, and the viewer who
-  // opened the film further on was not in that picture. Walking into their
-  // stretch means writing names they are writing.
-  const behindRun = [...behind.runs][0];
-  const aheadRun = [...ahead.runs][0];
-  assert.equal(manager.runMakingSegment(behind, 550, behindRun), aheadRun);
-  assert.equal(manager.runMakingSegment(behind, 499, behindRun), null);
   assert.equal(
-    manager.runMakingSegment(ahead, 550, aheadRun),
-    null,
-    "a run without an end owns only as far as it will get, not the rest of the film"
+    coverage.freeRunFrom(40, mine),
+    60,
+    "asked by the run that holds it, the stretch is its own to work through"
   );
-  void stopped;
 });
 
-test("a seek backwards does not drag the picture away from a viewer watching ahead", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const shared = sessionOn({
-    id: "shared",
-    dirPath,
-    segmentCount: 1000,
-    runState: "PRODUCING",
-    encodeStartIndex: 200,
-    runEndIndex: -1
-  });
-  shared.sourceKey = "torrent:abc";
-  shared.fileIndex = 0;
-  shared.timeline = new Timeline({ boundaries: Array.from({ length: 1001 }, (_, index) => index * 4), cutGrid: "uniform" });
-  shared.acquireSource = null;
-  shared.progress = { processedSeconds: 900, startPositionSeconds: 800 };
-  manager.sessionsById.set(shared.id, shared);
+test("a run that has ended holds nothing back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.release(dead);
 
-  // One viewer is at segment 250 and being served. The other jumps back an hour.
-  viewerOf(shared, "ahead").position = { segment: 250, seconds: 1000, at: Date.now() };
-  viewerOf(shared, "back").position = { segment: 250, seconds: 1000, at: Date.now() };
+  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
+});
 
-  const servingAhead = [...shared.runs][0];
-  const startedAt = servingAhead.from;
-  manager.requestSeek("shared", 40, "back");
+test("what a dead run DID finish stays made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.markReadyAll([40, 41, 42]);
+  coverage.release(dead);
 
-  assert.equal(
-    servingAhead.from,
-    startedAt,
-    "the run serving the viewer in front is left exactly where it was"
-  );
-  assert.ok(shared.runs.has(servingAhead), "and it is not stopped");
-  // A run start claims its attempt before it awaits anything, so the assertion
-  // holds without the test needing an ffmpeg. 40 s is segment #10 on this grid.
-  assert.equal(
-    shared.pendingRun?.startIndex,
-    10,
-    "and the one who jumped is given a run of their own, there"
-  );
+  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
 });
 
-test("a seek backwards with nobody else watching still moves the run", (t) => {
-  const { manager, root, dirPath } = managerWithAnEmptyOutput();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
+test("nothing left to make is answered with nothing", () => {
+  const coverage = new CoverageMap({ segmentCount: 5 });
+  coverage.markReadyAll([0, 1, 2, 3, 4]);
 
-  let created = 0;
-  manager.createOrGetSession = async () => {
-    created += 1;
-    return null;
-  };
-
-  const alone = sessionOn({
-    id: "alone",
-    dirPath,
-    segmentCount: 1000,
-    runState: "PRODUCING",
-    encodeStartIndex: 200,
-    runEndIndex: -1
-  });
-  alone.timeline = new Timeline({ boundaries: Array.from({ length: 1001 }, (_, index) => index * 4), cutGrid: "uniform" });
-  alone.progress = { processedSeconds: 900, startPositionSeconds: 800 };
-  manager.sessionsById.set(alone.id, alone);
-  viewerOf(alone, "only").position = { segment: 250, seconds: 1000, at: Date.now() };
+  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
+});
 
-  manager.requestSeek("alone", 40, "only");
+test("a run without an end does not take the film away from a viewer further in", () => {
+  // The case that used to need a second authority's `head + look-ahead` guess.
+  // A run's claim is now the stretch the plan GAVE it, so a viewer opening the
+  // same film in the middle finds their own position free.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const first = run("first");
+  coverage.claim(first, 0, 499);
 
-  // Nobody is left behind, so a second run would be an encoder for one viewer
-  // who is not there any more.
-  assert.equal(created, 0);
-  assert.equal(alone.seekTarget !== undefined, true, "the run itself is repositioned, as before");
+  assert.equal(coverage.firstGapFrom(500), 500, "the second viewer's own position is free");
+  assert.equal(coverage.freeRunFrom(500), 500, "and everything from there to the end");
 });