@torrent-tv/proxy 2.74.1 → 2.76.0

package/test/matroska-cues-track.test.js

@@ -1,192 +1,192 @@
-/**
- * @file The container's table names a track, and only the picture's entries are
- * cut points.
- *
- * Measured 2026-08-18 on the two files the field sessions were recorded from:
- * `Minions.and.Monsters.1080p.mkv` carries 2778 cue entries for its video track
- * — one every 2.002 s — and 4669 more across four subtitle tracks;
- * `Moana.2 … MegaPeer.mkv` carries 1055 for video and 5007 across five subtitle
- * tracks. Read without the track, both sets went into the cut list together,
- * and ffmpeg — which can only cut a copied picture at a real keyframe at or
- * after the time it is asked for — moved every such cut forward to the next
- * keyframe. That is the whole of the disagreement the field reported: 2.002 s
- * on the first file, a median of 6.3 s and a worst case of 21 s on the second,
- * and never once negative.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { readMatroskaKeyframeTimes } from "../services/container-index/matroska.js";
-
-const ID_EBML = 0x1a45dfa3;
-const ID_SEGMENT = 0x18538067;
-const ID_SEEK_HEAD = 0x114d9b74;
-const ID_SEEK = 0x4dbb;
-const ID_SEEK_ID = 0x53ab;
-const ID_SEEK_POSITION = 0x53ac;
-const ID_INFO = 0x1549a966;
-const ID_TIMESTAMP_SCALE = 0x2ad7b1;
-const ID_TRACKS = 0x1654ae6b;
-const ID_TRACK_ENTRY = 0xae;
-const ID_TRACK_NUMBER = 0xd7;
-const ID_TRACK_TYPE = 0x83;
-const ID_CUES = 0x1c53bb6b;
-const ID_CUE_POINT = 0xbb;
-const ID_CUE_TIME = 0xb3;
-const ID_CUE_TRACK_POSITIONS = 0xb7;
-const ID_CUE_TRACK = 0xf7;
-const ID_CUE_CLUSTER_POSITION = 0xf1;
-
-/** An element id, as the bytes the specification gives it. */
-function idBytes(id) {
-  const bytes = [];
-  let rest = id;
-  while (rest > 0) {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  }
-  return Buffer.from(bytes);
-}
-
-/** A size, as a four-byte EBML variable-length integer. */
-function sizeBytes(size) {
-  const buffer = Buffer.alloc(4);
-  buffer.writeUInt32BE(size, 0);
-  buffer[0] |= 0x10;
-  return buffer;
-}
-
-function element(id, payload) {
-  return Buffer.concat([idBytes(id), sizeBytes(payload.length), payload]);
-}
-
-/** An unsigned value, in as few bytes as it needs. */
-function uintElement(id, value) {
-  const bytes = [];
-  let rest = value;
-  do {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  } while (rest > 0);
-  return element(id, Buffer.from(bytes));
-}
-
-function cuePoint(timeMs, tracks) {
-  return element(ID_CUE_POINT, Buffer.concat([
-    uintElement(ID_CUE_TIME, timeMs),
-    ...tracks.map((track) => element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
-      uintElement(ID_CUE_TRACK, track),
-      uintElement(ID_CUE_CLUSTER_POSITION, 4096)
-    ])))
-  ]));
-}
-
-/**
- * A file with the shape the field files have: one picture, one set of subtitles,
- * and a table that indexes both.
- *
- * @param {{ withTracks?: boolean }} [options]
- * @returns {Buffer}
- */
-function buildFile({ withTracks = true, cueTrack = null } = {}) {
-  const info = element(ID_INFO, uintElement(ID_TIMESTAMP_SCALE, 1_000_000));
-  const tracks = element(ID_TRACKS, Buffer.concat([
-    element(ID_TRACK_ENTRY, Buffer.concat([
-      uintElement(ID_TRACK_NUMBER, 1),
-      uintElement(ID_TRACK_TYPE, 1) // video
-    ])),
-    element(ID_TRACK_ENTRY, Buffer.concat([
-      uintElement(ID_TRACK_NUMBER, 2),
-      uintElement(ID_TRACK_TYPE, 17) // subtitles
-    ]))
-  ]));
-  const forPicture = cueTrack ?? 1;
-  const forSubtitles = cueTrack ?? 2;
-  const cues = element(ID_CUES, Buffer.concat([
-    cuePoint(0, [forPicture]),
-    cuePoint(1070, [forSubtitles]),
-    cuePoint(2002, [forPicture]),
-    cuePoint(3141, [forSubtitles]),
-    cuePoint(4004, [forPicture])
-  ]));
-
-  const seekEntry = (targetId, position) => element(ID_SEEK, Buffer.concat([
-    element(ID_SEEK_ID, idBytes(targetId)),
-    element(ID_SEEK_POSITION, (() => {
-      const buffer = Buffer.alloc(4);
-      buffer.writeUInt32BE(position, 0);
-      return buffer;
-    })())
-  ]));
-  // Positions are relative to the Segment's payload, so the SeekHead has to be
-  // measured before they can be stated. Its own length does not change when the
-  // placeholders become real values: every size and position here is written at
-  // a fixed width.
-  const draft = element(ID_SEEK_HEAD, Buffer.concat([
-    seekEntry(ID_INFO, 0),
-    ...(withTracks ? [seekEntry(ID_TRACKS, 0)] : []),
-    seekEntry(ID_CUES, 0)
-  ]));
-  const infoAt = draft.length;
-  const tracksAt = infoAt + info.length;
-  const cuesAt = withTracks ? tracksAt + tracks.length : infoAt + info.length;
-  const seekHead = element(ID_SEEK_HEAD, Buffer.concat([
-    seekEntry(ID_INFO, infoAt),
-    ...(withTracks ? [seekEntry(ID_TRACKS, tracksAt)] : []),
-    seekEntry(ID_CUES, cuesAt)
-  ]));
-
-  const segmentPayload = Buffer.concat(
-    withTracks ? [seekHead, info, tracks, cues] : [seekHead, info, cues]
-  );
-  return Buffer.concat([
-    element(ID_EBML, Buffer.from([0x42, 0x86, 0x81, 0x01])),
-    element(ID_SEGMENT, segmentPayload)
-  ]);
-}
-
-function readerOver(file) {
-  return async (start, end) => {
-    const last = Math.min(end, file.length - 1);
-    return start > last ? null : file.subarray(start, last + 1);
-  };
-}
-
-test("only the picture's entries become cut times", async () => {
-  const file = buildFile();
-
-  const times = await readMatroskaKeyframeTimes(readerOver(file), file.length);
-
-  assert.deepEqual(
-    times.map((time) => Number(time.toFixed(3))),
-    [0, 2.002, 4.004],
-    "the subtitle entries at 1.070 and 3.141 are not keyframes, and a cut asked for there lands late"
-  );
-});
-
-test("a table whose entries name no known track is still used", async () => {
-  // The cue points reference track 9, which Tracks never declares. Filtering
-  // leaves nothing — and returning nothing would put an even grid on a copied
-  // picture, the failure this reader exists to prevent.
-  const file = buildFile({ cueTrack: 9 });
-
-  const times = await readMatroskaKeyframeTimes(readerOver(file), file.length);
-
-  assert.deepEqual(
-    times.map((time) => Number(time.toFixed(3))),
-    [0, 1.07, 2.002, 3.141, 4.004],
-    "an unrecognised table beats no table at all"
-  );
-});
-
-test("a file whose tracks cannot be read keeps every entry", async () => {
-  const file = buildFile({ withTracks: false });
-
-  const times = await readMatroskaKeyframeTimes(readerOver(file), file.length);
-
-  assert.deepEqual(
-    times.map((time) => Number(time.toFixed(3))),
-    [0, 1.07, 2.002, 3.141, 4.004],
-    "with nothing to tell the tracks apart, the old behaviour is the only one available"
-  );
-});
+/**
+ * @file The container's table names a track, and only the picture's entries are
+ * cut points.
+ *
+ * Measured 2026-08-18 on the two files the field sessions were recorded from:
+ * `Minions.and.Monsters.1080p.mkv` carries 2778 cue entries for its video track
+ * — one every 2.002 s — and 4669 more across four subtitle tracks;
+ * `Moana.2 … MegaPeer.mkv` carries 1055 for video and 5007 across five subtitle
+ * tracks. Read without the track, both sets went into the cut list together,
+ * and ffmpeg — which can only cut a copied picture at a real keyframe at or
+ * after the time it is asked for — moved every such cut forward to the next
+ * keyframe. That is the whole of the disagreement the field reported: 2.002 s
+ * on the first file, a median of 6.3 s and a worst case of 21 s on the second,
+ * and never once negative.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { MatroskaContainer } from "../services/container/MatroskaContainer.js";
+
+const ID_EBML = 0x1a45dfa3;
+const ID_SEGMENT = 0x18538067;
+const ID_SEEK_HEAD = 0x114d9b74;
+const ID_SEEK = 0x4dbb;
+const ID_SEEK_ID = 0x53ab;
+const ID_SEEK_POSITION = 0x53ac;
+const ID_INFO = 0x1549a966;
+const ID_TIMESTAMP_SCALE = 0x2ad7b1;
+const ID_TRACKS = 0x1654ae6b;
+const ID_TRACK_ENTRY = 0xae;
+const ID_TRACK_NUMBER = 0xd7;
+const ID_TRACK_TYPE = 0x83;
+const ID_CUES = 0x1c53bb6b;
+const ID_CUE_POINT = 0xbb;
+const ID_CUE_TIME = 0xb3;
+const ID_CUE_TRACK_POSITIONS = 0xb7;
+const ID_CUE_TRACK = 0xf7;
+const ID_CUE_CLUSTER_POSITION = 0xf1;
+
+/** An element id, as the bytes the specification gives it. */
+function idBytes(id) {
+  const bytes = [];
+  let rest = id;
+  while (rest > 0) {
+    bytes.unshift(rest & 0xff);
+    rest = Math.floor(rest / 256);
+  }
+  return Buffer.from(bytes);
+}
+
+/** A size, as a four-byte EBML variable-length integer. */
+function sizeBytes(size) {
+  const buffer = Buffer.alloc(4);
+  buffer.writeUInt32BE(size, 0);
+  buffer[0] |= 0x10;
+  return buffer;
+}
+
+function element(id, payload) {
+  return Buffer.concat([idBytes(id), sizeBytes(payload.length), payload]);
+}
+
+/** An unsigned value, in as few bytes as it needs. */
+function uintElement(id, value) {
+  const bytes = [];
+  let rest = value;
+  do {
+    bytes.unshift(rest & 0xff);
+    rest = Math.floor(rest / 256);
+  } while (rest > 0);
+  return element(id, Buffer.from(bytes));
+}
+
+function cuePoint(timeMs, tracks) {
+  return element(ID_CUE_POINT, Buffer.concat([
+    uintElement(ID_CUE_TIME, timeMs),
+    ...tracks.map((track) => element(ID_CUE_TRACK_POSITIONS, Buffer.concat([
+      uintElement(ID_CUE_TRACK, track),
+      uintElement(ID_CUE_CLUSTER_POSITION, 4096)
+    ])))
+  ]));
+}
+
+/**
+ * A file with the shape the field files have: one picture, one set of subtitles,
+ * and a table that indexes both.
+ *
+ * @param {{ withTracks?: boolean }} [options]
+ * @returns {Buffer}
+ */
+function buildFile({ withTracks = true, cueTrack = null } = {}) {
+  const info = element(ID_INFO, uintElement(ID_TIMESTAMP_SCALE, 1_000_000));
+  const tracks = element(ID_TRACKS, Buffer.concat([
+    element(ID_TRACK_ENTRY, Buffer.concat([
+      uintElement(ID_TRACK_NUMBER, 1),
+      uintElement(ID_TRACK_TYPE, 1) // video
+    ])),
+    element(ID_TRACK_ENTRY, Buffer.concat([
+      uintElement(ID_TRACK_NUMBER, 2),
+      uintElement(ID_TRACK_TYPE, 17) // subtitles
+    ]))
+  ]));
+  const forPicture = cueTrack ?? 1;
+  const forSubtitles = cueTrack ?? 2;
+  const cues = element(ID_CUES, Buffer.concat([
+    cuePoint(0, [forPicture]),
+    cuePoint(1070, [forSubtitles]),
+    cuePoint(2002, [forPicture]),
+    cuePoint(3141, [forSubtitles]),
+    cuePoint(4004, [forPicture])
+  ]));
+
+  const seekEntry = (targetId, position) => element(ID_SEEK, Buffer.concat([
+    element(ID_SEEK_ID, idBytes(targetId)),
+    element(ID_SEEK_POSITION, (() => {
+      const buffer = Buffer.alloc(4);
+      buffer.writeUInt32BE(position, 0);
+      return buffer;
+    })())
+  ]));
+  // Positions are relative to the Segment's payload, so the SeekHead has to be
+  // measured before they can be stated. Its own length does not change when the
+  // placeholders become real values: every size and position here is written at
+  // a fixed width.
+  const draft = element(ID_SEEK_HEAD, Buffer.concat([
+    seekEntry(ID_INFO, 0),
+    ...(withTracks ? [seekEntry(ID_TRACKS, 0)] : []),
+    seekEntry(ID_CUES, 0)
+  ]));
+  const infoAt = draft.length;
+  const tracksAt = infoAt + info.length;
+  const cuesAt = withTracks ? tracksAt + tracks.length : infoAt + info.length;
+  const seekHead = element(ID_SEEK_HEAD, Buffer.concat([
+    seekEntry(ID_INFO, infoAt),
+    ...(withTracks ? [seekEntry(ID_TRACKS, tracksAt)] : []),
+    seekEntry(ID_CUES, cuesAt)
+  ]));
+
+  const segmentPayload = Buffer.concat(
+    withTracks ? [seekHead, info, tracks, cues] : [seekHead, info, cues]
+  );
+  return Buffer.concat([
+    element(ID_EBML, Buffer.from([0x42, 0x86, 0x81, 0x01])),
+    element(ID_SEGMENT, segmentPayload)
+  ]);
+}
+
+function readerOver(file) {
+  return async (start, end) => {
+    const last = Math.min(end, file.length - 1);
+    return start > last ? null : file.subarray(start, last + 1);
+  };
+}
+
+test("only the picture's entries become cut times", async () => {
+  const file = buildFile();
+
+  const times = await MatroskaContainer.readKeyframeTimes(readerOver(file), file.length);
+
+  assert.deepEqual(
+    times.map((time) => Number(time.toFixed(3))),
+    [0, 2.002, 4.004],
+    "the subtitle entries at 1.070 and 3.141 are not keyframes, and a cut asked for there lands late"
+  );
+});
+
+test("a table whose entries name no known track is still used", async () => {
+  // The cue points reference track 9, which Tracks never declares. Filtering
+  // leaves nothing — and returning nothing would put an even grid on a copied
+  // picture, the failure this reader exists to prevent.
+  const file = buildFile({ cueTrack: 9 });
+
+  const times = await MatroskaContainer.readKeyframeTimes(readerOver(file), file.length);
+
+  assert.deepEqual(
+    times.map((time) => Number(time.toFixed(3))),
+    [0, 1.07, 2.002, 3.141, 4.004],
+    "an unrecognised table beats no table at all"
+  );
+});
+
+test("a file whose tracks cannot be read keeps every entry", async () => {
+  const file = buildFile({ withTracks: false });
+
+  const times = await MatroskaContainer.readKeyframeTimes(readerOver(file), file.length);
+
+  assert.deepEqual(
+    times.map((time) => Number(time.toFixed(3))),
+    [0, 1.07, 2.002, 3.141, 4.004],
+    "with nothing to tell the tracks apart, the old behaviour is the only one available"
+  );
+});

package/test/orchestrator-wired.test.js

@@ -0,0 +1,164 @@
+/**
+ * @file The plan is what decides the encoders, and it is asked of real sessions.
+ *
+ * Three rules written into the session manager become one here: where a run
+ * belongs, when it has been overtaken, and how many the machine affords. The
+ * point of wiring rather than duplicating is that the arithmetic has sixteen
+ * checks of its own and no ffmpeg behind it.
+ */
+
+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 { 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 { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { viewerOf } from "../services/viewer/Viewer.js";
+import { startRunOn } from "./helpers/encode-run.js";
+
+const KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+
+function managerWithAnOutput() {
+  const root = mkdtempSync(path.join(os.tmpdir(), "orchestrator-wired-"));
+  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 };
+}
+
+function sessionOn({ id, dirPath, encodeStartIndex = 0, runEndIndex = -1, speed = 0, running = true }) {
+  const session = {
+    id,
+    outputKey: KEY,
+    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: 1001 }, (_, index) => index * 4),
+      cutGrid: "uniform"
+    }),
+    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,
+    segmentCount: 1000,
+    recentSpeed: null,
+    consumers: new Set(),
+    viewers: new Map(),
+    runs: new Set(),
+    lastAccessedAt: Date.now()
+  };
+  if (running) {
+    const run = startRunOn(session, { from: encodeStartIndex, to: runEndIndex });
+    // A speed is a reading taken FROM a run, so it names the run it came from.
+    session.recentSpeed = speed > 0 ? { speed, at: Date.now(), run } : null;
+    run.noteSpeed(speed);
+  }
+  return session;
+}
+
+test("a session is handed to the plan as the run it is", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const session = sessionOn({ id: "one", dirPath, encodeStartIndex: 10, runEndIndex: 40 });
+  manager.sessionsById.set(session.id, session);
+  viewerOf(session, "watching").head = { segment: 12, seconds: 48, at: Date.now() };
+
+  manager.runQualityBudgetOnce;
+  manager.planEncodersNow();
+
+  const runs = manager.encodeOrchestrator.runsOn(KEY);
+  assert.equal(runs.length, 1, "the session the browser already has is a run like any other");
+  assert.equal(runs[0], [...session.runs][0], "and it is the run the session actually holds");
+  assert.equal(runs[0].from, 10);
+  assert.equal(runs[0].to, 40);
+});
+
+test("what a viewer waits for reaches the plan without their name", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  const session = sessionOn({ id: "one", dirPath, encodeStartIndex: 0, runEndIndex: -1 });
+  manager.sessionsById.set(session.id, session);
+  viewerOf(session, "someone").head = { segment: 5, seconds: 20, at: Date.now() };
+
+  manager.planEncodersNow();
+
+  const wanted = manager.encodeOrchestrator.demand.windowsOn(KEY);
+  assert.equal(wanted.length, 1);
+  assert.equal(wanted[0].from, 5, "where they are");
+  assert.ok(wanted[0].to > 5, "and the cushion in front of them");
+});
+
+test("a viewer who has gone quiet stops being waited for", (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);
+  viewerOf(session, "gone").head = { segment: 5, seconds: 20, at: Date.now() - 10 * 60 * 1000 };
+
+  manager.planEncodersNow();
+
+  assert.equal(manager.encodeOrchestrator.demand.windowsOn(KEY).length, 0);
+});
+
+test("how many encoders the machine affords is measured, not chosen", (t) => {
+  const { manager, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  // Nothing measured yet: one is what it has.
+  const cold = sessionOn({ id: "cold", dirPath });
+  manager.sessionsById.set(cold.id, cold);
+  assert.equal(manager.maxRunsForOutput(KEY), 1);
+
+  // Fast, but what a second job costs on THIS machine has not been measured,
+  // and an unmeasured penalty of 1 is not a statement that it is free.
+  cold.recentSpeed = { speed: 7.12 };
+  assert.equal(manager.maxRunsForOutput(KEY), 1, "no measurement, no second encoder");
+
+  // Measured on the addon host 2026-09-03: at 854x480 one run made 7.12x and
+  // two made 4.20x and 4.16x, a penalty of 1.70x, and both stayed far above
+  // realtime.
+  manager.contentionPenalties = new Map([[1, 1.7]]);
+  assert.ok(manager.maxRunsForOutput(KEY) > 1, "measured, and a second fits");
+
+  // The same host at 1920x1080: one made 1.96x, two made 0.99x and 0.98x.
+  manager.contentionPenalties = new Map([[1, 1.98]]);
+  cold.recentSpeed = { speed: 1.96 };
+  assert.equal(manager.maxRunsForOutput(KEY), 1, "the machine is full at one");
+});
+
+test("segments already made are known to the plan, whoever made them", (t) => {
+  const { manager, store, root, dirPath } = managerWithAnOutput();
+  t.after(() => rmSync(root, { recursive: true, force: true }));
+
+  for (const index of [0, 1, 2, 3]) {
+    writeFileSync(path.join(dirPath, fmp4Format.segmentFileName(index)), Buffer.alloc(16, 1));
+  }
+  const session = sessionOn({ id: "one", dirPath });
+  manager.sessionsById.set(session.id, session);
+
+  manager.planEncodersNow();
+
+  const coverage = manager.encodeOrchestrator.coverageOf(KEY);
+  assert.equal(coverage.isReady(0), true);
+  assert.equal(coverage.isReady(2), true);
+  assert.equal(coverage.isReady(3), false, "the highest has no successor to prove it closed");
+  void store;
+});

package/test/output-shape.test.js

@@ -0,0 +1,68 @@
+/**
+ * @file What an output is encoded AS is decided once, for the 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.
+ */
+
+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);
+});
+
+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:
+  // no box asked for can change one byte of it.
+  const copied = new Output({ encodeWidth: 0, encodeHeight: 0, outputFps: 24 });
+
+  assert.equal(copied.encodeWidth, 0);
+  assert.equal(copied.encodeHeight, 0);
+  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);
+});