@torrent-tv/proxy 2.89.6 → 2.89.7

package/test/viewer-presence.test.js

@@ -1,116 +1,116 @@
-/**
- * @file Presence is a fact of the connection, and it is not the same fact as
- * position.
- *
- * Both halves failed together on 2026-09-05. A viewer who had arrived and asked
- * for nothing counted as absent, so a soundtrack's encoder was stopped 1.25 s
- * after starting with nothing produced — and its `init.mp4` was therefore never
- * made, which is the one file the viewer needed in order to ask for the segment
- * that would have marked them present. And nothing anywhere let a viewer go
- * when their connection closed: the only exits were the browser's own release,
- * which a killed tab never sends, and a silence that a paused viewer produces
- * just as well as a departed one.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const PICTURE = "aaaaaaaa00004000";
-const SOUND = "aaaaaaaa00004001";
-
-/**
- * @param {string} id
- * @param {string} dirPath
- * @returns {object}
- */
-function outputOn(id, dirPath) {
-  return {
-    id,
-    spec: outputSpec(),
-    dirPath,
-    state: "live",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    claims: new Set(),
-    lastAccessedAt: Date.now()
-  };
-}
-
-test("asking for a viewer of an output is that viewer watching it", () => {
-  let changes = 0;
-  const viewers = new Viewers({ onChange: () => { changes += 1; } });
-  const output = { id: "out-1" };
-
-  const first = viewers.of(output, "someone");
-  assert.equal(changes, 1, "a new relation is a change");
-  assert.equal(first.outputs.has("out-1"), true);
-
-  viewers.of(output, "someone");
-  assert.equal(changes, 1, "asking again about the same output changes nothing");
-
-  const second = { id: "out-2" };
-  viewers.of(second, "someone");
-  assert.equal(changes, 2, "a second output is a change");
-  assert.equal(viewers.get("someone")?.outputs.size, 2);
-});
-
-test("a connection closing takes the person off every output at once", () => {
-  const viewers = new Viewers();
-  const picture = { id: "picture" };
-  const sound = { id: "sound" };
-  viewers.of(picture, "watcher");
-  viewers.of(sound, "watcher");
-  viewers.of(picture, "other");
-
-  const left = viewers.hasGone("watcher");
-
-  assert.deepEqual(left.sort(), ["picture", "sound"], "both, not the one the browser holds an id for");
-  assert.equal(viewers.forOutput(picture).has("watcher"), false);
-  assert.equal(viewers.forOutput(sound).has("watcher"), false);
-  assert.equal(viewers.forOutput(picture).has("other"), true, "and nobody else goes with them");
-  assert.equal(viewers.get("watcher"), null, "the registry does not keep what it has let go");
-});
-
-test("a viewer whose connection closed is let go of every output they were watching", async (t) => {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "presence-"));
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-
-  const picture = outputOn(PICTURE, dirPath);
-  const sound = outputOn(SOUND, dirPath);
-  manager.outputs.set(PICTURE, picture);
-  manager.outputs.set(SOUND, sound);
-  manager.viewers.of(picture, "watcher");
-  manager.viewers.of(sound, "watcher");
-
-  const released = await manager.lifecycle.viewerHasGone("watcher", "the connection closed");
-
-  assert.equal(released, 2, "the picture and the soundtrack, from one statement");
-  assert.equal(manager.viewers.get("watcher"), null);
-});
-
-test("a viewer nobody knows costs nothing to let go of", async () => {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  assert.equal(await manager.lifecycle.viewerHasGone("never-seen"), 0);
-  assert.equal(await manager.lifecycle.viewerHasGone(""), 0);
-});
+/**
+ * @file Presence is a fact of the connection, and it is not the same fact as
+ * position.
+ *
+ * Both halves failed together on 2026-09-05. A viewer who had arrived and asked
+ * for nothing counted as absent, so a soundtrack's encoder was stopped 1.25 s
+ * after starting with nothing produced — and its `init.mp4` was therefore never
+ * made, which is the one file the viewer needed in order to ask for the segment
+ * that would have marked them present. And nothing anywhere let a viewer go
+ * when their connection closed: the only exits were the browser's own release,
+ * which a killed tab never sends, and a silence that a paused viewer produces
+ * just as well as a departed one.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const PICTURE = "aaaaaaaa00004000";
+const SOUND = "aaaaaaaa00004001";
+
+/**
+ * @param {string} id
+ * @param {string} dirPath
+ * @returns {object}
+ */
+function outputOn(id, dirPath) {
+  return {
+    id,
+    spec: outputSpec(),
+    dirPath,
+    state: "live",
+    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
+    get inputFile() { return this.file; },
+    get audioFile() { return this.file; },
+    claims: new Set(),
+    lastAccessedAt: Date.now()
+  };
+}
+
+test("asking for a viewer of an output is that viewer watching it", () => {
+  let changes = 0;
+  const viewers = new Viewers({ onChange: () => { changes += 1; } });
+  const output = { id: "out-1" };
+
+  const first = viewers.of(output, "someone");
+  assert.equal(changes, 1, "a new relation is a change");
+  assert.equal(first.outputs.has("out-1"), true);
+
+  viewers.of(output, "someone");
+  assert.equal(changes, 1, "asking again about the same output changes nothing");
+
+  const second = { id: "out-2" };
+  viewers.of(second, "someone");
+  assert.equal(changes, 2, "a second output is a change");
+  assert.equal(viewers.get("someone")?.outputs.size, 2);
+});
+
+test("a connection closing takes the person off every output at once", () => {
+  const viewers = new Viewers();
+  const picture = { id: "picture" };
+  const sound = { id: "sound" };
+  viewers.of(picture, "watcher");
+  viewers.of(sound, "watcher");
+  viewers.of(picture, "other");
+
+  const left = viewers.hasGone("watcher");
+
+  assert.deepEqual(left.sort(), ["picture", "sound"], "both, not the one the browser holds an id for");
+  assert.equal(viewers.forOutput(picture).has("watcher"), false);
+  assert.equal(viewers.forOutput(sound).has("watcher"), false);
+  assert.equal(viewers.forOutput(picture).has("other"), true, "and nobody else goes with them");
+  assert.equal(viewers.get("watcher"), null, "the registry does not keep what it has let go");
+});
+
+test("a viewer whose connection closed is let go of every output they were watching", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "presence-"));
+  t.after(async () => {
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+
+  const picture = outputOn(PICTURE, dirPath);
+  const sound = outputOn(SOUND, dirPath);
+  manager.outputs.set(PICTURE, picture);
+  manager.outputs.set(SOUND, sound);
+  manager.viewers.of(picture, "watcher");
+  manager.viewers.of(sound, "watcher");
+
+  const released = await manager.lifecycle.viewerHasGone("watcher", "the connection closed");
+
+  assert.equal(released, 2, "the picture and the soundtrack, from one statement");
+  assert.equal(manager.viewers.get("watcher"), null);
+});
+
+test("a viewer nobody knows costs nothing to let go of", async () => {
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  assert.equal(await manager.lifecycle.viewerHasGone("never-seen"), 0);
+  assert.equal(await manager.lifecycle.viewerHasGone(""), 0);
+});

package/test/viewer-states.test.js

@@ -1,189 +1,189 @@
-/**
- * @file The three states a viewer can be in, and what each is worth.
- *
- * Written against the failure of 2026-09-14: a page whose tab was hidden for
- * 145 seconds, which had measured nothing and therefore said nothing, was
- * carried 146 seconds into a film it had not begun — and the soundtrack's
- * encoder was placed there while the browser asked for segment #0 and was
- * refused for sixty seconds.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { Viewer } from "../services/viewer/Viewer.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-
-const AT = 1_000_000;
-
-test("a viewer who has stated nothing does not move, however long they are silent", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.moveTo(0, AT);
-
-  // 146 seconds of silence — the field figure exactly.
-  assert.equal(viewer.positionSeconds(AT + 146_000), 0);
-});
-
-test("a viewer who has stated nothing is waiting, and their work is due now", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.moveTo(0, AT);
-
-  assert.equal(viewer.playing, false);
-  assert.equal(viewer.waiting, true);
-  assert.equal(viewer.wantsFilmNow(), true);
-});
-
-test("a playing viewer moves with the film, and no further than what they hold", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report({ bufferedAheadSec: 30, positionSeconds: 100, playing: true, waiting: false }, AT);
-
-  // Ten seconds of silence, ten seconds of film.
-  assert.equal(viewer.positionSeconds(AT + 10_000), 110);
-  // Two minutes of silence buys only the thirty seconds they said they held.
-  assert.equal(viewer.positionSeconds(AT + 120_000), 130);
-});
-
-test("a viewer holding nothing cannot move at all, even reported as playing", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report({ bufferedAheadSec: 0, positionSeconds: 0, playing: true, waiting: false }, AT);
-
-  assert.equal(viewer.positionSeconds(AT + 146_000), 0);
-});
-
-test("a viewer who stopped the picture is not waiting, and nothing of theirs falls due", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report({ bufferedAheadSec: 42, positionSeconds: 100, playing: false, waiting: false }, AT);
-
-  assert.equal(viewer.wantsFilmNow(), false);
-  assert.equal(viewer.positionSeconds(AT + 60_000), 100);
-});
-
-test("a viewer starved of material is waiting, and is as urgent as one playing", () => {
-  const playing = new Viewer("playing", AT);
-  playing.report({ bufferedAheadSec: 30, positionSeconds: 100, playing: true, waiting: false }, AT);
-  const starved = new Viewer("starved", AT);
-  starved.report({ bufferedAheadSec: 0, positionSeconds: 100, playing: false, waiting: true }, AT);
-
-  // Both want film now, and that is the whole point: the starved one used to
-  // count as somebody who had chosen to stop.
-  assert.equal(starved.wantsFilmNow(), true);
-  assert.equal(playing.wantsFilmNow(), true);
-  // And the starved one cannot be carried forward from where they stand,
-  // because they hold nothing to play.
-  assert.equal(starved.positionSeconds(AT + 60_000), 100);
-});
-
-test("a report without a link measurement still states everything about the viewer", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report({ bufferedAheadSec: 0, positionSeconds: 12, playing: false, waiting: true }, AT);
-
-  assert.equal(viewer.positionSeconds(AT), 12);
-  assert.equal(viewer.waiting, true);
-  // Nothing was measured, so nothing is claimed about the link.
-  assert.equal(viewer.netReport, null);
-});
-
-test("a page one release behind, which cannot say `waiting`, is read from what it does say", () => {
-  const starved = new Viewer("starved", AT);
-  starved.report({ linkMbps: 5, bufferedAheadSec: 0, positionSeconds: 0, playing: false }, AT);
-  assert.equal(starved.waiting, true, "stopped and holding nothing is starved");
-
-  const paused = new Viewer("paused", AT);
-  paused.report({ linkMbps: 5, bufferedAheadSec: 40, positionSeconds: 0, playing: false }, AT);
-  assert.equal(paused.waiting, false, "stopped while holding film is a viewer's own pause");
-});
-
-test("a seek does not carry the cushion of the place it left", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report({ bufferedAheadSec: 120, positionSeconds: 100, playing: true, waiting: false }, AT);
-
-  viewer.moveTo(2000, AT + 1000);
-  // Nothing is held at the new place until they say so, so the position stands.
-  assert.equal(viewer.positionSeconds(AT + 61_000), 2000);
-});
-
-test("a page that is not on screen wants nothing now, whatever else it says", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report(
-    { bufferedAheadSec: 0, positionSeconds: 100, playing: false, waiting: true, onScreen: false },
-    AT
-  );
-
-  assert.equal(viewer.wantsFilmNow(), false);
-});
-
-test("the intake hands the statement to the viewer on the output they are watching", async () => {
-  const { recordViewerReport } = await import("../services/viewer/report-intake.js");
-  const picture = { id: "picture" };
-  const rung = { id: "rung" };
-  const sessions = new Map([
-    ["picture", picture],
-    ["rung", rung]
-  ]);
-  const viewers = new Viewers();
-  viewers.of(picture, "one", AT).activeVariantId = "rung";
-
-  // The page always addresses the PICTURE — it is never told which rung it is
-  // on — and the statement belongs to the rung actually on screen.
-  const taken = recordViewerReport({
-    outputs: sessions,
-    viewers,
-    sessionId: "picture",
-    report: { linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true, consumerId: "one" },
-    now: AT
-  });
-
-  assert.equal(taken, true);
-  assert.equal(viewers.forOutput(rung).get("one").positionSeconds(AT), 5);
-  assert.equal(viewers.forOutput(picture).has("one"), true);
-});
-
-test("a link reading does not expire — presence is what decides whose it is", () => {
-  const viewer = new Viewer("one", AT);
-  viewer.report({ linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true }, AT);
-
-  // A link does not stop being what it was measured to be because nobody
-  // measured it for a while. The page says as much by keeping its own last
-  // figure rather than reporting nothing.
-  assert.equal(viewer.linkReading()?.linkMbps, 8);
-  assert.equal(viewer.linkReading()?.linkMbps, 8, "and an hour later it is still the last thing known");
-
-  // What ends it is the person leaving, which is a different fact with a
-  // different owner.
-  assert.equal(viewer.isPresent(), true);
-});
-
-test("each viewer's link is read for that viewer alone, never as a worst over several", async () => {
-  // Roadmap item 97, step 11: a thin link decides for the person on it. The
-  // worst reading across everybody watching used to decide for all of them.
-  const { linkReportOf, presentOn } = await import("../services/viewer/choices.js");
-  const output = { id: "out" };
-  const viewers = new Viewers();
-  const slow = viewers.of(output, "slow", AT);
-  const fast = viewers.of(output, "fast", AT);
-  slow.report({ linkMbps: 2, bufferedAheadSec: 3, playing: true }, AT);
-  fast.report({ linkMbps: 40, bufferedAheadSec: 90, playing: true }, AT);
-
-  assert.equal(linkReportOf(viewers, output, "slow")?.linkMbps, 2);
-  assert.equal(linkReportOf(viewers, output, "fast")?.linkMbps, 40, "the slow link says nothing about this one");
-  assert.equal(linkReportOf(viewers, output, "nobody"), null);
-
-  // The slow one leaves: they are no longer among the viewers asked about.
-  slow.gone = true;
-  assert.deepEqual(presentOn(viewers, output), ["fast"]);
-});
-
-test("a report into an output absent from the live registry is refused rather than invented", async () => {
-  const { recordViewerReport } = await import("../services/viewer/report-intake.js");
-  const sessions = new Map();
-  const viewers = { of() { throw new Error("must not be asked"); } };
-
-  assert.equal(
-    recordViewerReport({ outputs: sessions, viewers, sessionId: "dead", report: { bufferedAheadSec: 0 }, now: AT }),
-    false
-  );
-  assert.equal(
-    recordViewerReport({ outputs: sessions, viewers, sessionId: "never", report: { bufferedAheadSec: 0 }, now: AT }),
-    false
-  );
-});
+/**
+ * @file The three states a viewer can be in, and what each is worth.
+ *
+ * Written against the failure of 2026-09-14: a page whose tab was hidden for
+ * 145 seconds, which had measured nothing and therefore said nothing, was
+ * carried 146 seconds into a film it had not begun — and the soundtrack's
+ * encoder was placed there while the browser asked for segment #0 and was
+ * refused for sixty seconds.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { Viewer } from "../services/viewer/Viewer.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+
+const AT = 1_000_000;
+
+test("a viewer who has stated nothing does not move, however long they are silent", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.moveTo(0, AT);
+
+  // 146 seconds of silence — the field figure exactly.
+  assert.equal(viewer.positionSeconds(AT + 146_000), 0);
+});
+
+test("a viewer who has stated nothing is waiting, and their work is due now", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.moveTo(0, AT);
+
+  assert.equal(viewer.playing, false);
+  assert.equal(viewer.waiting, true);
+  assert.equal(viewer.wantsFilmNow(), true);
+});
+
+test("a playing viewer moves with the film, and no further than what they hold", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ bufferedAheadSec: 30, positionSeconds: 100, playing: true, waiting: false }, AT);
+
+  // Ten seconds of silence, ten seconds of film.
+  assert.equal(viewer.positionSeconds(AT + 10_000), 110);
+  // Two minutes of silence buys only the thirty seconds they said they held.
+  assert.equal(viewer.positionSeconds(AT + 120_000), 130);
+});
+
+test("a viewer holding nothing cannot move at all, even reported as playing", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ bufferedAheadSec: 0, positionSeconds: 0, playing: true, waiting: false }, AT);
+
+  assert.equal(viewer.positionSeconds(AT + 146_000), 0);
+});
+
+test("a viewer who stopped the picture is not waiting, and nothing of theirs falls due", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ bufferedAheadSec: 42, positionSeconds: 100, playing: false, waiting: false }, AT);
+
+  assert.equal(viewer.wantsFilmNow(), false);
+  assert.equal(viewer.positionSeconds(AT + 60_000), 100);
+});
+
+test("a viewer starved of material is waiting, and is as urgent as one playing", () => {
+  const playing = new Viewer("playing", AT);
+  playing.report({ bufferedAheadSec: 30, positionSeconds: 100, playing: true, waiting: false }, AT);
+  const starved = new Viewer("starved", AT);
+  starved.report({ bufferedAheadSec: 0, positionSeconds: 100, playing: false, waiting: true }, AT);
+
+  // Both want film now, and that is the whole point: the starved one used to
+  // count as somebody who had chosen to stop.
+  assert.equal(starved.wantsFilmNow(), true);
+  assert.equal(playing.wantsFilmNow(), true);
+  // And the starved one cannot be carried forward from where they stand,
+  // because they hold nothing to play.
+  assert.equal(starved.positionSeconds(AT + 60_000), 100);
+});
+
+test("a report without a link measurement still states everything about the viewer", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ bufferedAheadSec: 0, positionSeconds: 12, playing: false, waiting: true }, AT);
+
+  assert.equal(viewer.positionSeconds(AT), 12);
+  assert.equal(viewer.waiting, true);
+  // Nothing was measured, so nothing is claimed about the link.
+  assert.equal(viewer.netReport, null);
+});
+
+test("a page one release behind, which cannot say `waiting`, is read from what it does say", () => {
+  const starved = new Viewer("starved", AT);
+  starved.report({ linkMbps: 5, bufferedAheadSec: 0, positionSeconds: 0, playing: false }, AT);
+  assert.equal(starved.waiting, true, "stopped and holding nothing is starved");
+
+  const paused = new Viewer("paused", AT);
+  paused.report({ linkMbps: 5, bufferedAheadSec: 40, positionSeconds: 0, playing: false }, AT);
+  assert.equal(paused.waiting, false, "stopped while holding film is a viewer's own pause");
+});
+
+test("a seek does not carry the cushion of the place it left", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ bufferedAheadSec: 120, positionSeconds: 100, playing: true, waiting: false }, AT);
+
+  viewer.moveTo(2000, AT + 1000);
+  // Nothing is held at the new place until they say so, so the position stands.
+  assert.equal(viewer.positionSeconds(AT + 61_000), 2000);
+});
+
+test("a page that is not on screen wants nothing now, whatever else it says", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report(
+    { bufferedAheadSec: 0, positionSeconds: 100, playing: false, waiting: true, onScreen: false },
+    AT
+  );
+
+  assert.equal(viewer.wantsFilmNow(), false);
+});
+
+test("the intake hands the statement to the viewer on the output they are watching", async () => {
+  const { recordViewerReport } = await import("../services/viewer/report-intake.js");
+  const picture = { id: "picture" };
+  const rung = { id: "rung" };
+  const sessions = new Map([
+    ["picture", picture],
+    ["rung", rung]
+  ]);
+  const viewers = new Viewers();
+  viewers.of(picture, "one", AT).activeVariantId = "rung";
+
+  // The page always addresses the PICTURE — it is never told which rung it is
+  // on — and the statement belongs to the rung actually on screen.
+  const taken = recordViewerReport({
+    outputs: sessions,
+    viewers,
+    sessionId: "picture",
+    report: { linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true, consumerId: "one" },
+    now: AT
+  });
+
+  assert.equal(taken, true);
+  assert.equal(viewers.forOutput(rung).get("one").positionSeconds(AT), 5);
+  assert.equal(viewers.forOutput(picture).has("one"), true);
+});
+
+test("a link reading does not expire — presence is what decides whose it is", () => {
+  const viewer = new Viewer("one", AT);
+  viewer.report({ linkMbps: 8, bufferedAheadSec: 10, positionSeconds: 5, playing: true }, AT);
+
+  // A link does not stop being what it was measured to be because nobody
+  // measured it for a while. The page says as much by keeping its own last
+  // figure rather than reporting nothing.
+  assert.equal(viewer.linkReading()?.linkMbps, 8);
+  assert.equal(viewer.linkReading()?.linkMbps, 8, "and an hour later it is still the last thing known");
+
+  // What ends it is the person leaving, which is a different fact with a
+  // different owner.
+  assert.equal(viewer.isPresent(), true);
+});
+
+test("each viewer's link is read for that viewer alone, never as a worst over several", async () => {
+  // Roadmap item 97, step 11: a thin link decides for the person on it. The
+  // worst reading across everybody watching used to decide for all of them.
+  const { linkReportOf, presentOn } = await import("../services/viewer/choices.js");
+  const output = { id: "out" };
+  const viewers = new Viewers();
+  const slow = viewers.of(output, "slow", AT);
+  const fast = viewers.of(output, "fast", AT);
+  slow.report({ linkMbps: 2, bufferedAheadSec: 3, playing: true }, AT);
+  fast.report({ linkMbps: 40, bufferedAheadSec: 90, playing: true }, AT);
+
+  assert.equal(linkReportOf(viewers, output, "slow")?.linkMbps, 2);
+  assert.equal(linkReportOf(viewers, output, "fast")?.linkMbps, 40, "the slow link says nothing about this one");
+  assert.equal(linkReportOf(viewers, output, "nobody"), null);
+
+  // The slow one leaves: they are no longer among the viewers asked about.
+  slow.gone = true;
+  assert.deepEqual(presentOn(viewers, output), ["fast"]);
+});
+
+test("a report into an output absent from the live registry is refused rather than invented", async () => {
+  const { recordViewerReport } = await import("../services/viewer/report-intake.js");
+  const sessions = new Map();
+  const viewers = { of() { throw new Error("must not be asked"); } };
+
+  assert.equal(
+    recordViewerReport({ outputs: sessions, viewers, sessionId: "dead", report: { bufferedAheadSec: 0 }, now: AT }),
+    false
+  );
+  assert.equal(
+    recordViewerReport({ outputs: sessions, viewers, sessionId: "never", report: { bufferedAheadSec: 0 }, now: AT }),
+    false
+  );
+});