@torrent-tv/proxy 2.86.0 → 2.87.1

package/test/output-catalog.test.js

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { OutputCatalog } from "../services/encode/output/OutputCatalog.js";
+
+test("the catalog owns creation and access times", () => {
+  let now = 100;
+  const registry = new OutputCatalog({ now: () => now });
+  const output = { id: "picture" };
+  registry.set(output.id, output);
+
+  now = 250;
+  registry.touch(output);
+
+  assert.equal(registry.startedAt(output), 100);
+  assert.equal(registry.lastAccessedAt(output), 250);
+  assert.equal("startedAt" in output, false);
+  assert.equal("lastAccessedAt" in output, false);
+});
+
+test("expiry is decided from the catalog's access time", () => {
+  let now = 100;
+  const registry = new OutputCatalog({ now: () => now });
+  registry.set("old", { id: "old" });
+  now = 200;
+  registry.set("fresh", { id: "fresh" });
+
+  assert.deepEqual(registry.expiredBefore(150), ["old"]);
+});
+
+test("removal deletes both the output and its lifetime", () => {
+  const registry = new OutputCatalog({ now: () => 100 });
+  const output = { id: "picture" };
+  registry.set(output.id, output);
+  registry.delete(output.id);
+
+  assert.equal(registry.get(output.id), undefined);
+  assert.equal(registry.startedAt(output), null);
+  assert.equal(registry.touch(output, 200), false);
+});

package/test/output-shape.test.js

@@ -1,51 +1,13 @@
 /**
- * @file What an output is encoded AS is decided once, for the output.
+ * @file The shape an encoder is given for an output.
  *
- * The realtime budget decides the box, the frame rate and the speed setting
- * from what the machine could hold at that moment. Decided per SESSION, two
- * sessions of one output made minutes apart could be given different pictures
- * while claiming the same identity — and everything downstream assumes they
- * cannot be, from a segment of one standing in for a segment of the other to
- * the single RESOLUTION the master names for both.
+ * The format itself is the output's identity (`OutputSpec`), decided before
+ * the output is named; this is that format in the terms the encoder takes.
  */
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { Output, Outputs } from "../services/output/Output.js";
-
-const KEY = "torrent:abc:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:auto";
-
-test("the second session of one output is given the shape the first was", () => {
-  const outputs = new Outputs();
-  const first = outputs.get(KEY, () => new Output({
-    encodeWidth: 1280,
-    encodeHeight: 720,
-    outputFps: 24,
-    softwarePreset: "veryfast",
-    applyTonemap: false
-  }));
-  // A minute later the machine is busier and the budget would answer 480p. It
-  // is not asked: the shape of this output was settled when it was first made.
-  const second = outputs.get(KEY, () => {
-    throw new Error("deciding twice is how two sessions of one output diverge");
-  });
-
-  assert.equal(second, first);
-  assert.equal(second.encodeHeight, 720);
-});
-
-test("two outputs are two shapes", () => {
-  const outputs = new Outputs();
-  const tall = outputs.get(KEY, () => new Output({ encodeWidth: 1280, encodeHeight: 720, outputFps: 24 }));
-  const short = outputs.get(`${KEY}:other`, () => new Output({
-    encodeWidth: 854,
-    encodeHeight: 480,
-    outputFps: 24
-  }));
-
-  assert.notEqual(short, tall);
-  assert.equal(short.encodeHeight, 480);
-});
+import { Output } from "../services/encode/output/Output.js";
 
 test("a copied picture has no box of its own, and says so with zeroes", () => {
   // Zero means the source's own size, which is what a copy is by definition:
@@ -57,12 +19,3 @@ test("a copied picture has no box of its own, and says so with zeroes", () => {
   assert.equal(copied.softwarePreset, null, "and no speed setting, having no encoder");
 });
 
-test("a shape nobody holds is dropped", () => {
-  const outputs = new Outputs();
-  const kept = outputs.get(KEY, () => new Output({ encodeWidth: 1280, encodeHeight: 720, outputFps: 24 }));
-  outputs.get(`${KEY}:other`, () => new Output({ encodeWidth: 854, encodeHeight: 480, outputFps: 24 }));
-
-  assert.equal(outputs.size, 2);
-  assert.equal(outputs.forgetUnused(new Set([kept])), 1);
-  assert.equal(outputs.size, 1);
-});

package/test/output-spec.test.js

@@ -1,157 +1,251 @@
-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()
-  );
-});
+import assert from "node:assert/strict";
+import { softwareRateControlFor } from "../services/encode/args.js";
+import test from "node:test";
+import { createHash } from "node:crypto";
+import { AudioOutput, CutGrid, isOutputName, OutputSpec, VideoOutput } from "../services/encode/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}`);
+});
+
+function encoded(over = {}) {
+  return copiedPicture({
+    video: new VideoOutput({
+      fileIndex: 0,
+      encode: { encoder: "libx264", width: 1280, height: 720, fps: 24, preset: "veryfast", tonemap: false, ...over }
+    })
+  });
+}
+
+test("two heights of one picture are two outputs", () => {
+  assert.notEqual(encoded().toKey(), encoded({ width: 854, height: 480 }).toKey());
+});
+
+test("an output is the format produced, and every part of it that reaches the header tells two apart", () => {
+  const base = encoded().toKey();
+  assert.notEqual(base, encoded({ preset: "ultrafast" }).toKey(), "the speed setting changes the PPS");
+  assert.notEqual(base, encoded({ encoder: "h264_nvenc" }).toKey(), "another encoder writes another SPS");
+  assert.notEqual(base, encoded({ fps: 30 }).toKey(), "the frame rate");
+  assert.notEqual(base, encoded({ tonemap: true }).toKey(), "a tone-mapped picture");
+});
+
+test("how the format was asked for is not part of it", () => {
+  const asked = new VideoOutput({
+    fileIndex: 0,
+    encode: { encoder: "libx264", width: 1280, height: 720, fps: 24, preset: "veryfast", tonemap: false, exactSize: true }
+  });
+  assert.equal(copiedPicture({ video: asked }).toKey(), encoded().toKey());
+});
+
+test("a key reads back into the output it names", () => {
+  const muxed = new OutputSpec({
+    sourceKey: TORRENT,
+    segmentFormatId: "mpegts",
+    grid: new CutGrid({ kind: "uniform", fileIndex: 2 }),
+    video: new VideoOutput({
+      fileIndex: 2,
+      encode: { encoder: "libx264", width: 854, height: 480, fps: 25, preset: null, tonemap: true }
+    }),
+    audio: new AudioOutput({ fileIndex: 5, trackIndex: 1, transcode: true })
+  });
+  for (const spec of [copiedPicture(), encoded(), muxed]) {
+    assert.equal(OutputSpec.fromKey(spec.toKey())?.toKey(), spec.toKey());
+  }
+});
+
+test("a key naming the box a viewer asked for does not read back, because it cannot say what format is inside", () => {
+  assert.equal(OutputSpec.fromKey(`${TORRENT}:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:exact`), null);
+  assert.equal(OutputSpec.fromKey(`${TORRENT}:fmt=fmp4:grid=even@0:video-only:v=0/enc:1280x720:budget`), null);
+});
+
+test("the bitrate limit is part of the output: two limits are two outputs, and the key reads back", () => {
+  // Roadmap item 97, step 10. A limit changes the bytes of every piece, so it
+  // names the output; the level is the nominal output's, so it is the same for
+  // both limits of one size and their headers agree.
+  const nominal = softwareRateControlFor({ width: 1280, height: 720, fps: 24 });
+  const lower = softwareRateControlFor({ width: 1280, height: 720, fps: 24, capKbps: 1400 });
+  const atNominal = encoded({ rateControl: nominal });
+  const atLower = encoded({ rateControl: lower });
+
+  assert.notEqual(atNominal.toKey(), atLower.toKey());
+  assert.notEqual(atNominal.toKey(), encoded().toKey(), "a limit and none are two outputs too");
+  assert.equal(nominal.level, lower.level);
+  for (const spec of [atNominal, atLower, encoded()]) {
+    assert.equal(OutputSpec.fromKey(spec.toKey())?.toKey(), spec.toKey());
+  }
+  assert.deepEqual(OutputSpec.fromKey(atLower.toKey()).video.encode.rateControl, lower);
+});
+
+test("a key written before the limit was part of it does not read back", () => {
+  // Its directory could hold pieces made under any limit the budget had moved
+  // it to, so nothing can say what is inside, and it is not served.
+  const current = encoded().toKey();
+  assert.equal(OutputSpec.fromKey(current.replace("/vbv=-", "")), null);
+});
+
+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()
+  );
+});
+
+test("an output's name follows from its identity and from nothing else", () => {
+  // MANY VIEWERS OF ONE OUTPUT address one name because the name is the
+  // output's. Nobody arranges it, and nothing about the request enters it: two
+  // people opening the same film at different moments and at different places
+  // are handed the same name.
+  assert.equal(copiedPicture().toName(), copiedPicture().toName());
+  assert.notEqual(
+    copiedPicture().toName(),
+    copiedPicture({ video: new VideoOutput({ fileIndex: 1, encode: null }) }).toName(),
+    "and two different outputs are two different names"
+  );
+  // Stated against the key itself, which is the one thing that proves nothing
+  // ELSE got mixed in. Two specs built in one test run agree even if the name
+  // secretly carried the clock, because the clock has not moved between them —
+  // and "however far apart they arrive" is the whole property.
+  assert.equal(
+    copiedPicture().toName(),
+    createHash("sha256").update(copiedPicture().toKey()).digest("hex").slice(0, 16)
+  );
+});
+
+test("a name is safe to carry whole, and the guard that admits it agrees", () => {
+  // The name reaches the filesystem: it is what the produced pieces of this
+  // output are found under. So the shape is asserted here AND where a request
+  // is admitted, and the two must be changed together — they were not, the
+  // first time this name was minted, and every guarded route would have refused
+  // every request while no check said a word.
+  const name = copiedPicture().toName();
+
+  assert.ok(isOutputName(name), "the guard admits what the minting produces");
+  assert.equal(encodeURIComponent(name), name, "and it needs no escaping to be carried whole");
+  // What the guard is FOR.
+  assert.equal(isOutputName("../../etc/passwd"), false);
+  assert.equal(isOutputName("aaaaaaaa1111222"), false, "fifteen is not sixteen");
+  assert.equal(isOutputName("11111111-2222-3333-4444-555555555555"), false, "and the old shape is gone");
+});

package/test/output-speed.test.js

@@ -9,8 +9,9 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { EncodeCost } from "../services/quality/EncodeCost.js";
-import { LiveOutputs } from "../services/output/LiveOutputs.js";
+import { EncodeCost } from "../services/encode/quality/EncodeCost.js";
+import { OutputCatalog } from "../services/encode/output/OutputCatalog.js";
+import { outputSpec } from "./helpers/output-spec.js";
 
 const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
 
@@ -19,9 +20,13 @@ const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
  * @param {{ copySpeedX?: number | null, benchmark?: object[] | null }} host
  */
 function costOf(sessions, host = {}) {
-  const sessionsById = new Map(sessions.map((session, index) => [String(index), session]));
+  const outputs = new OutputCatalog();
+  sessions.forEach((session, index) => outputs.set(String(index), session));
   return new EncodeCost({
-    liveOutputs: new LiveOutputs({ sessionsById }),
+    runsFor: () => [],
+    stateFor: () => "IDLE",
+    progressFor: () => null,
+    outputs,
     host: () => ({
       benchmark: host.benchmark ?? null,
       decodeModel: null,
@@ -40,7 +45,7 @@ test("a run on this output outranks every prediction", () => {
   // It is this machine, this material and these settings. Nothing said before
   // the fact beats something seen happening.
   const cost = costOf(
-    [{ outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: 9.5 }],
+    [{ outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: 9.5 }],
     { copySpeedX: 600 }
   );
   assert.equal(cost.speedForOutput(PICTURE), 9.5);
@@ -52,7 +57,7 @@ test("a copied picture is priced by the startup copy measurement", () => {
   // describes it, and a copied output was planned with no speed until its own
   // run had been running long enough to report one.
   const cost = costOf(
-    [{ outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: null }],
+    [{ outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: null }],
     { copySpeedX: 602 }
   );
   assert.equal(cost.speedForOutput(PICTURE), 602);
@@ -62,25 +67,22 @@ test("the fastest reading wins where several sessions produce one output", () =>
   // Two sessions whose output parameters agree ARE one output, so what either
   // of them measured about this machine is true of the other.
   const cost = costOf([
-    { outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: 4 },
-    { outputKey: PICTURE, state: "ready", transcodeVideo: false, lastAloneSpeed: 7 }
+    { outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: 4 },
+    { outputKey: PICTURE, spec: outputSpec(), lastAloneSpeed: 7 }
   ]);
   assert.equal(cost.speedForOutput(PICTURE), 7);
 });
 
-test("a disposed session says nothing about what the machine is doing", () => {
-  const cost = costOf(
-    [{ outputKey: PICTURE, state: "disposed", transcodeVideo: false, lastAloneSpeed: 4 }],
-    { copySpeedX: 602 }
-  );
-  assert.equal(cost.speedForOutput(PICTURE), 0, "no live session, so nothing to say");
+test("an output absent from the live registry says nothing about what the machine is doing", () => {
+  const cost = costOf([], { copySpeedX: 602 });
+  assert.equal(cost.speedForOutput(PICTURE), 0, "no registered output, so nothing to say");
 });
 
 test("another output's reading is not borrowed", () => {
   // Two outputs are two different pieces of work — a picture re-encoded to 480p
   // and the same picture copied are not the same speed.
   const cost = costOf([
-    { outputKey: "other", state: "ready", transcodeVideo: false, lastAloneSpeed: 40 }
+    { outputKey: "other", spec: outputSpec(), lastAloneSpeed: 40 }
   ]);
   assert.equal(cost.speedForOutput(PICTURE), 0);
 });

package/test/outputs-being-prepared.test.js

@@ -0,0 +1,40 @@
+/**
+ * @file The places preparations hold on the machine are read off the viewers'
+ * own records (roadmap item 97, step 13): a step being warmed and a move to
+ * another limit of the height on screen are one list, and a place ends with
+ * the record — or the viewer — that holds it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Viewers } from "../services/viewer/Viewers.js";
+import { outputsBeingPrepared } from "../services/viewer/choices.js";
+
+const PICTURE = { id: "1111111122223333", outputKey: "picture" };
+
+test("a warmed step and a move between limits are one list of places", () => {
+  const viewers = new Viewers();
+  const warming = viewers.of(PICTURE, "viewer-a");
+  warming.warmingVariantId = "2222222233334444";
+  const moving = viewers.of(PICTURE, "viewer-b");
+  moving.sameHeightSwitch = { outputId: "3333333344445555", outputKey: "limit", askedHeights: [720] };
+  assert.deepEqual([...outputsBeingPrepared(viewers)].sort(), ["2222222233334444", "3333333344445555"]);
+});
+
+test("one output prepared for two viewers is one place", () => {
+  const viewers = new Viewers();
+  viewers.of(PICTURE, "viewer-a").warmingVariantId = "2222222233334444";
+  viewers.of(PICTURE, "viewer-b").sameHeightSwitch = { outputId: "2222222233334444", outputKey: "step" };
+  assert.equal(outputsBeingPrepared(viewers).size, 1);
+});
+
+test("a place ends with its record, and with the viewer", () => {
+  const viewers = new Viewers();
+  const viewer = viewers.of(PICTURE, "viewer-a");
+  viewer.warmingVariantId = "2222222233334444";
+  viewer.warmingVariantId = null;
+  assert.equal(outputsBeingPrepared(viewers).size, 0, "the record cleared");
+  viewers.of(PICTURE, "viewer-b").warmingVariantId = "2222222233334444";
+  viewers.hasGone("viewer-b");
+  assert.equal(outputsBeingPrepared(viewers).size, 0, "the viewer gone");
+});