@torrent-tv/proxy 2.75.0 → 2.76.0

package/test/behind-head-repair.test.js

@@ -14,10 +14,13 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { SourceFile } from "../services/source/SourceFile.js";
+import { Timeline } from "../services/output/Timeline.js";
 import { mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { startRunOn } from "./helpers/encode-run.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
 const SESSION_ID = "bbbbbbbb-cccc-dddd-eeee-ffffffffffff";
@@ -41,8 +44,18 @@ async function managerWithRunAhead() {
   const session = {
     id: SESSION_ID,
     dirPath,
+    // Where this file is cut, held by the file. A fixture that stated it
+    // on the session was describing what production no longer does.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 1937 }, (_, index) => index * SEGMENT_SECONDS),
+      cutGrid: "uniform"
+    }),
     state: "ready",
-    fileName: "film.avi",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.avi" }),
+    // 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; },
     startedAt: Date.now(),
     createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
@@ -52,10 +65,7 @@ async function managerWithRunAhead() {
     transcodeVideo: true,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentBoundaries: Array.from({ length: 1937 }, (_, index) => index * SEGMENT_SECONDS),
     segmentCount: 1936,
-    encodeStartIndex: RUN_STARTS_AT,
-    encodeRunGeneration: 0,
     lastRestartAt: 0,
     seekFailureTarget: -1,
     seekFailureCount: 0,
@@ -63,11 +73,11 @@ async function managerWithRunAhead() {
     seekTarget: null,
     waitEpoch: 0,
     firstWantedAt: new Map(),
-    runState: "PRODUCING",
-    ffmpeg: { pid: 4321, exitCode: null, signalCode: null, kill() {}, once(event, handler) { if (event === "exit") handler(); } },
+    runs: new Set(),
     progress: { state: "running", processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS + 400, startPositionSeconds: RUN_STARTS_AT * SEGMENT_SECONDS }
   };
   manager.sessionsById.set(SESSION_ID, session);
+  startRunOn(session, { from: RUN_STARTS_AT });
   const restarts = [];
   return { manager, session, dirPath, restarts };
 }
@@ -190,7 +200,7 @@ test("a rung whose encoder was stopped is not brought back by a held request", a
     await rm(dirPath, { recursive: true, force: true });
   });
   // What a quality switch leaves behind: the rung nobody is watching, parked.
-  session.ffmpeg = null;
+  session.runs = new Set();
   session.firstWantedAt.set(WANTED, Date.now() - 4000);
 
   await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(WANTED), { requestSeq: 1 });

package/test/coverage-map.test.js

@@ -0,0 +1,153 @@
+/**
+ * @file The three states of a segment number, and the two questions that decide
+ * where an encoder goes.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+/**
+ * A stand-in for a run.
+ *
+ * The map files a claim under the run ITSELF: a run has no name, and needs
+ * none — what identifies it is that it is itself, and what identifies it in a
+ * line is the stretch it was given, which no other live run of one output can
+ * hold.
+ *
+ * @returns {object}
+ */
+function aRun() {
+  return {};
+}
+
+test("a number nobody has made and nobody is making is free", () => {
+  const map = new CoverageMap({ segmentCount: 10 });
+  assert.equal(map.stateOf(3), "free");
+  assert.equal(map.firstGapFrom(0), 0);
+});
+
+test("a closed file is ready whoever made it", () => {
+  const map = new CoverageMap({ segmentCount: 10 });
+  map.markReady(0);
+  map.markReady(1);
+  assert.equal(map.stateOf(1), "ready");
+  assert.equal(map.firstGapFrom(0), 2);
+});
+
+test("a run claims a stretch, and the gap search skips it", () => {
+  // The claim is an interval and not a head, which is the whole reason two runs
+  // can work on one output: the second is sent past what the first will reach.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 40);
+  assert.equal(map.stateOf(20), "making");
+  assert.equal(map.makerOf(20), runA);
+  assert.equal(map.firstGapFrom(0), 41);
+});
+
+test("a run that ends gives back what it did not finish, and keeps what it did", () => {
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 40);
+  map.markReady(0);
+  map.markReady(1);
+  map.release(runA);
+  assert.equal(map.stateOf(0), "ready", "a closed file survives its maker");
+  assert.equal(map.stateOf(2), "free", "the rest of the stretch is free again");
+  assert.equal(map.firstGapFrom(0), 2);
+});
+
+test("a run with no end claims everything ahead of it", () => {
+  // Which is what every run was before ends existed, and is why a second run
+  // could never be placed.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 10, Number.POSITIVE_INFINITY);
+  assert.equal(map.firstGapFrom(10), null);
+  assert.equal(map.firstGapFrom(0), 0, "behind it is still free");
+});
+
+test("claiming again replaces the earlier claim rather than adding to it", () => {
+  // A run moved forward past ready material states its new stretch; if the two
+  // accumulated, the ground it has left would stay unavailable for ever.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 20);
+  map.claim(runA, 50, 70);
+  assert.equal(map.stateOf(10), "free");
+  assert.equal(map.stateOf(60), "making");
+});
+
+test("the covered stretch ahead is measured, which is what prices a move", () => {
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  const runB = aRun();
+  for (let index = 10; index <= 24; index += 1) {
+    map.markReady(index);
+  }
+  map.claim(runB, 25, 30);
+  // Ready 10..24 then another run's 25..30, so fifteen plus six.
+  assert.equal(map.coveredRunFrom(10, runA), 21);
+  assert.equal(map.firstGapFrom(10), 31);
+});
+
+test("a run's own claim is not counted as somebody else's coverage", () => {
+  // Otherwise a run would read its own stretch as a reason to move off it.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 10, 30);
+  assert.equal(map.coveredRunFrom(10, runA), 0);
+});
+
+test("nothing free ahead answers null rather than a number past the end", () => {
+  const map = new CoverageMap({ segmentCount: 5 });
+  map.markReadyAll([0, 1, 2, 3, 4]);
+  assert.equal(map.firstGapFrom(0), null);
+});
+
+test("a file that has gone stops being ready", () => {
+  const map = new CoverageMap({ segmentCount: 10 });
+  map.markReady(4);
+  map.markGone(4);
+  assert.equal(map.stateOf(4), "free");
+});
+
+test("a run's own claim does not hide the gap it is trying to move into", () => {
+  // Found by the plan's own checks: a run that had claimed the rest of the film
+  // — which is what every run did before ends existed — could find no gap
+  // anywhere, so it was stopped instead of moved.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 0, 99);
+  map.markReadyAll([10, 11, 12]);
+  assert.equal(map.firstGapFrom(10, 90), null, "to anybody else its ground is taken");
+  assert.equal(map.firstGapFrom(10, 90, runA), 13, "to itself the ground beyond is a gap");
+});
+
+test("the free stretch ahead is measured, which is what gives a run its end", () => {
+  // A run handed the whole rest of the film would drive through the stretch
+  // another run is making. Handed the free stretch, it stops where the covered
+  // material begins.
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runB = aRun();
+  map.claim(runB, 30, 60);
+  assert.equal(map.freeRunFrom(10), 20, "free from 10 up to 29");
+  map.markReady(15);
+  assert.equal(map.freeRunFrom(10), 5, "a ready segment ends the free stretch too");
+  assert.equal(map.freeRunFrom(15), 0, "a number that is not free has no free stretch");
+});
+
+test("a run's own claim does not end its own free stretch", () => {
+  const map = new CoverageMap({ segmentCount: 100 });
+  const runA = aRun();
+  map.claim(runA, 10, 40);
+  assert.equal(map.freeRunFrom(10, runA), 90, "its own ground is still its to fill");
+  assert.equal(map.freeRunFrom(10), 0, "to anybody else it is taken");
+});
+
+test("with the length unknown, a gap search needs its own bound", () => {
+  const map = new CoverageMap();
+  assert.equal(map.firstGapFrom(0), null, "no length and no bound answers nothing");
+  assert.equal(map.firstGapFrom(0, 3), 0);
+});

package/test/cut-times-timeline.test.js

@@ -13,6 +13,7 @@
  */
 
 import assert from "node:assert/strict";
+import { Timeline } from "../services/output/Timeline.js";
 import test from "node:test";
 
 import { onKeyframeGridFor } from "../services/hls-session-manager.js";
@@ -33,10 +34,10 @@ test("a soundtrack follows the grid it was cut on, not its own encoding", () =>
   // A rendition is re-encoded by definition, so asking `transcodeVideo` about
   // it answers nothing. What decides its timeline is the grid it shares with
   // the picture it plays with.
-  assert.equal(onKeyframeGridFor({ audioOnly: true, cutGrid: "keyframe" }), true);
-  assert.equal(onKeyframeGridFor({ audioOnly: true, cutGrid: "uniform" }), false);
+  assert.equal(onKeyframeGridFor({ audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) }), true);
+  assert.equal(onKeyframeGridFor({ audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "uniform" }) }), false);
   assert.equal(
-    onKeyframeGridFor({ audioOnly: true, cutGrid: "keyframe", transcodeVideo: true }),
+    onKeyframeGridFor({ audioOnly: true, transcodeVideo: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) }),
     true,
     "its own encoding must not decide this — that disagreement is the defect"
   );
@@ -48,8 +49,8 @@ test("one predicate answers for every caller", () => {
   for (const session of [
     { transcodeVideo: false },
     { transcodeVideo: true },
-    { audioOnly: true, cutGrid: "keyframe" },
-    { audioOnly: true, cutGrid: "uniform" },
+    { audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "keyframe" }) },
+    { audioOnly: true, timeline: new Timeline({ boundaries: [], cutGrid: "uniform" }) },
     {}
   ]) {
     assert.equal(onKeyframeGridFor(session), onKeyframeGridFor({ ...session }));

package/test/cuts-follow-published-grid.test.js

@@ -15,6 +15,7 @@
  */
 
 import assert from "node:assert/strict";
+import { Timeline } from "../services/output/Timeline.js";
 import test from "node:test";
 
 import { HlsSessionManager, segmentCutTimesFrom } from "../services/hls-session-manager.js";
@@ -38,8 +39,7 @@ function sessionWithDriftedGrid() {
   });
   const session = {
     id: "picture",
-    segmentBoundaries: [...CORRECTED],
-    publishedBoundaries: [...PUBLISHED]
+    timeline: new Timeline({ boundaries: [...CORRECTED], published: [...PUBLISHED], cutGrid: "uniform" })
   };
   return { manager, session };
 }
@@ -58,7 +58,7 @@ test("the cut list is the one the playlist was written from", () => {
 
 test("a corrected grid does not move the cuts of a session already being read", () => {
   const { manager, session } = sessionWithDriftedGrid();
-  const fromCorrected = segmentCutTimesFrom(session.segmentBoundaries, 1);
+  const fromCorrected = segmentCutTimesFrom(session.timeline.boundaries, 1);
   const fromPublished = segmentCutTimesFrom(manager.publishedGridFor(session), 1);
   assert.notDeepEqual(fromCorrected, fromPublished);
   // The gap the field measured: the corrected table would have cut #2 two
@@ -68,6 +68,6 @@ test("a corrected grid does not move the cuts of a session already being read",
 
 test("a session that published no grid falls back to the live one", () => {
   const { manager } = sessionWithDriftedGrid();
-  const session = { id: "no-playlist", segmentBoundaries: [...CORRECTED], publishedBoundaries: [] };
+  const session = { id: "no-playlist", timeline: new Timeline({ boundaries: [...CORRECTED], published: [], cutGrid: "uniform" }) };
   assert.deepEqual(manager.publishedGridFor(session), CORRECTED);
 });

package/test/decode-cost.test.js

@@ -14,10 +14,12 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { Timeline } from "../services/output/Timeline.js";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
 import { decodeCostOf, decodeFamilyOf } from "../services/decode-cost-fit.js";
+import { Output } from "../services/output/Output.js";
 import os from "node:os";
 import path from "node:path";
 import {
@@ -27,7 +29,8 @@ import {
   predictedRealtimeSpeed,
   speedBar
 } from "../services/hwaccel.js";
-import { HlsSessionManager, sourceDecodeCharacteristics } from "../services/hls-session-manager.js";
+import { HlsSessionManager } from "../services/hls-session-manager.js";
+import { SourceFile, sourceDecodeCharacteristics } from "../services/source/SourceFile.js";
 import { parseFfmpegBitrateKbps, parseFfmpegVideoDimensions, parseFfmpegVideoFps } from "../services/ffmpeg-banner.js";
 import { fmp4Format } from "../services/segment-formats/fmp4.js";
 
@@ -323,8 +326,26 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
   const session = {
     id: "cccccccc-dddd-eeee-ffff-000000000000",
     dirPath,
+    // Where this file is cut, held by the file. A fixture that stated it
+    // on the session was describing what production no longer does.
+    timeline: new Timeline({
+      boundaries: Array.from({ length: 101 }, (_, index) => index * 4),
+      cutGrid: "keyframe"
+    }),
     state: "ready",
-    fileName: "video.mkv",
+    // The file's own facts: the picture's size, and what decoding it costs,
+    // which is derived from them rather than stated beside them. These are the
+    // measured film of MEASURED_FILM above — 1080p24 at 8 Mbit/s.
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }).learn({
+      width: 1920,
+      height: 1080,
+      fps: 24,
+      bitrateKbps: 8000
+    }),
+    // 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; },
     startedAt: Date.now(),
     lastAccessedAt: Date.now(),
     ffmpeg: null,
@@ -334,21 +355,19 @@ test("the OFFER drops the rungs the host cannot hold, and the master keeps addre
     transcodeVideo: false,
     transcodeAudio: true,
     audioTrackIndex: 0,
-    sourceKey: "source-1",
-    fileIndex: 0,
-    sourceWidth: 1920,
-    sourceHeight: 1080,
-    sourceDecode: MEASURED_FILM,
-    outputFps: 24,
     // A copy can only be cut where the source already has a keyframe, and a
     // master is offered only when that grid is real.
-    cutGrid: "keyframe",
-    encodeWidth: 0,
-    encodeHeight: 0,
+    // The shape this output is encoded AS, decided once for the output.
+    output: new Output({
+      encodeWidth: 0,
+      encodeHeight: 0,
+      outputFps: 24,
+      softwarePreset: null,
+      applyTonemap: false
+    }),
     usesExplicitCuts: true,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
-    segmentBoundaries: Array.from({ length: 101 }, (_, index) => index * 4),
     segmentCount: 100,
     progress: { state: "running", processedSeconds: 0, startPositionSeconds: 0, speed: "1.0x" }
   };

package/test/encode-exit.test.js

@@ -9,7 +9,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { ENCODE_EXIT, classifyEncodeExit } from "../services/encode-exit.js";
+import { ENCODE_EXIT, classifyEncodeExit } from "../services/encode/encode-exit.js";
 
 test("the predecessor a seek kills says nothing about the session", () => {
   // The handler decides "is this exit mine" by comparing against the session's

package/test/encode-orchestrator.test.js

@@ -0,0 +1,196 @@
+/**
+ * @file Encoders managed to suit whoever is watching, with no viewer reaching
+ * the decision.
+ *
+ * Runs are built by the test, so nothing here spawns ffmpeg. What is exercised
+ * is the whole path a request takes: a viewer states a window, a plan is made
+ * from the union, runs are started, moved and stopped, and every ending is
+ * counted.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { EncodeRun } from "../services/encode/EncodeRun.js";
+import { ENCODE_EXIT } from "../services/encode/encode-exit.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { EncodeOrchestrator } from "../services/orchestrators/EncodeOrchestrator.js";
+
+const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+
+class FakeProcess extends EventEmitter {
+  constructor() {
+    super();
+    this.pid = 1;
+    this.signals = [];
+  }
+
+  kill(signal) {
+    this.signals.push(signal);
+    // A real ffmpeg dies a moment later; the test wants the bookkeeping to
+    // happen where it can be seen, so the exit is immediate and synchronous.
+    this.emit("exit", null, signal);
+  }
+}
+
+/**
+ * @param {{ maxRuns?: number }} [options]
+ */
+function orchestrator({ maxRuns = 2 } = {}) {
+  const lines = [];
+  const processes = new Map();
+  /** @type {EncodeOrchestrator} */
+  let made;
+  made = new EncodeOrchestrator({
+    maxRunsFor: () => maxRuns,
+    segmentSeconds: 4,
+    restartCostSec: 0.12,
+    now: () => 1000,
+    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
+    makeRun: ({ address, from, to }) => {
+      const process_ = new FakeProcess();
+      const run = new EncodeRun({
+        address,
+        encoder: new SoftwareEncoder(),
+        from,
+        to,
+        buildArgs: () => ["-i", "in", "out"],
+        spawn: () => process_,
+        logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
+        now: () => 1000,
+        onEnded: (ended) => made.noteEnded(ended)
+      });
+      // Filed under the run itself: a run has no name, so a test that has to
+      // reach its process asks with the run in hand.
+      processes.set(run, process_);
+      return run;
+    }
+  });
+  made.setSegmentCount(PICTURE, 1000);
+  return { made, lines, processes };
+}
+
+test("a viewer waiting gets an encoder at what they are waiting for", () => {
+  const { made } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  const runs = made.runsOn(PICTURE);
+  assert.equal(runs.length, 1);
+  assert.equal(runs[0].from, 100, "where the viewer is stopped");
+  assert.equal(runs[0].to, 999, "and on to the end of the film, nothing being in the way");
+});
+
+test("a second viewer at the same place starts nothing more", () => {
+  // One encode serves everyone standing in front of it, which is the whole
+  // reason the decision is made from a union and not per viewer.
+  const { made } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  made.want({ claimant: "two", address: PICTURE, from: 102, to: 132 });
+  made.reconcile();
+  assert.equal(made.runsOn(PICTURE).length, 1);
+});
+
+test("a second viewer far behind gets an encoder of their own", () => {
+  // Nobody is dragged: the run in front keeps its stretch and goes on making it.
+  const { made } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 500, to: 530 });
+  made.reconcile();
+  made.want({ claimant: "two", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  const spans = made.runsOn(PICTURE).map((run) => [run.from, run.to]);
+  assert.equal(spans.length, 2);
+  assert.ok(spans.some(([from]) => from === 500), "the one in front is untouched");
+  assert.ok(spans.some(([from]) => from === 100), "the one behind got its own");
+});
+
+test("a machine that can afford one encoder does not start a second", () => {
+  const { made } = orchestrator({ maxRuns: 1 });
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  made.want({ claimant: "two", address: PICTURE, from: 500, to: 530 });
+  made.reconcile();
+  assert.equal(made.runsOn(PICTURE).length, 1);
+});
+
+test("a viewer asking for what is already made starts nothing", () => {
+  const { made } = orchestrator();
+  made.noteAlreadyMade(PICTURE, [100, 101, 102, 103, 104]);
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 104 });
+  made.reconcile();
+  assert.equal(made.runsOn(PICTURE).length, 0);
+});
+
+test("segments left by a previous life of this process are used, not remade", () => {
+  // The startup sweep tells the map what survived; from there it is material
+  // like any other, whoever made it and whatever became of them.
+  const { made } = orchestrator();
+  made.noteAlreadyMade(PICTURE, [100, 101, 102]);
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 110 });
+  made.reconcile();
+  const runs = made.runsOn(PICTURE);
+  assert.equal(runs.length, 1);
+  assert.equal(runs[0].from, 103, "it starts at the first thing missing");
+});
+
+test("a viewer who leaves takes the encoder with them", () => {
+  const { made } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  assert.equal(made.runsOn(PICTURE).length, 1);
+  made.release("one");
+  made.reconcile();
+  assert.equal(made.runsOn(PICTURE).length, 0);
+  assert.equal(made.endings()[ENCODE_EXIT.STOPPED], 1);
+});
+
+test("a run that meets material made elsewhere is moved past it", () => {
+  const { made } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 200 });
+  made.reconcile();
+  const first = made.runsOn(PICTURE)[0];
+  // It has made a few, and meanwhile 105..150 arrived from somewhere else.
+  made.noteProduced(PICTURE, 100);
+  made.noteProduced(PICTURE, 101);
+  for (let index = 102; index <= 150; index += 1) {
+    made.coverageOf(PICTURE).markReady(index);
+  }
+  first.noteSpeed(1);
+  made.reconcile();
+  const runs = made.runsOn(PICTURE);
+  assert.equal(runs.length, 1, "one encoder, moved rather than joined by another");
+  assert.equal(runs[0].from, 151);
+  assert.notEqual(runs[0], first, "a move is this one ending and another beginning");
+});
+
+test("every ending is counted, and our own kill is not counted as normal", () => {
+  const { made, processes } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  const run = made.runsOn(PICTURE)[0];
+  processes.get(run).emit("exit", 255, null);
+  made.release("one");
+  made.reconcile();
+  const tally = made.endings();
+  assert.equal(tally[ENCODE_EXIT.FAILED], 1);
+  assert.equal(tally[ENCODE_EXIT.COMPLETE], 0);
+});
+
+test("the line says whether anybody is still waiting", () => {
+  // A proxy with encoders running and a viewer stopped at a segment nobody is
+  // making is the failure this layer removes; it has to be readable, not
+  // inferred.
+  const { made } = orchestrator();
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  assert.match(made.describe(), /waiting=#100/);
+  for (let index = 100; index <= 130; index += 1) {
+    made.noteProduced(PICTURE, index);
+  }
+  assert.match(made.describe(), /waiting=nobody/);
+});
+
+test("nothing wanted anywhere is said plainly", () => {
+  const { made } = orchestrator();
+  assert.match(made.describe(), /nothing wanted/);
+});