@torrent-tv/proxy 2.85.1 → 2.87.0

package/test/viewer-assignments.test.js

@@ -0,0 +1,143 @@
+/**
+ * @file What a viewer's own assignment to an output must do.
+ *
+ * The property under all of it: one viewer's link, seek or choice never moves
+ * another viewer's output. That is roadmap item 97, and the record it replaces
+ * — one entry per (file, height) for everybody — could not express it.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Assignments } from "../services/viewer/Assignments.js";
+
+const WINDOW_MS = 30_000;
+const make = () => new Assignments({ acceptWindowMs: WINDOW_MS });
+
+test("the acceptance window is given, not invented", () => {
+  assert.throws(() => new Assignments({}), TypeError);
+  assert.throws(() => new Assignments({ acceptWindowMs: -1 }), TypeError);
+});
+
+test("a choice stands until the rule moves it, and a request never moves it", () => {
+  const mine = make();
+
+  mine.choose(720, "out-a");
+  mine.give(mine.generation, 720, 4, "out-a");
+
+  assert.equal(mine.chosenFor(720), "out-a");
+  mine.give(mine.generation, 720, 5, "out-b");
+  assert.equal(mine.chosenFor(720), "out-a", "being given something else does not re-choose");
+  mine.choose(720, "out-b");
+  assert.equal(mine.chosenFor(720), "out-b");
+});
+
+test("two viewers do not share an answer", () => {
+  const thin = make();
+  const thick = make();
+
+  thin.choose(720, "out-540-slow");
+  thick.choose(720, "out-720-full");
+
+  assert.equal(thin.chosenFor(720), "out-540-slow");
+  assert.equal(thick.chosenFor(720), "out-720-full", "the other viewer's link decided nothing here");
+});
+
+test("a repeat of a request is answered by whatever answered it, not decided again", () => {
+  const mine = make();
+  const first = mine.generation;
+
+  mine.give(first, 720, 9, "out-a");
+
+  assert.equal(mine.givenFor(first, 720, 9), "out-a");
+  assert.equal(mine.givenFor(first, 720, 10), "", "a segment nothing answered says so");
+  assert.equal(mine.givenFor(first + 1, 720, 9), "", "and a later generation is not the same question");
+});
+
+test("a request carries its own generation, so a late one is not read against the current", () => {
+  const mine = make();
+  const made = mine.generation;
+
+  mine.statedGeneration(1, 1_000);
+
+  assert.equal(mine.generation, 1);
+  assert.notEqual(mine.generation, made);
+  assert.equal(mine.accepts(made, 1_000 + WINDOW_MS), true, "inside the window it is still answered");
+  assert.equal(mine.accepts(made, 1_000 + WINDOW_MS + 1), false, "past it, a new request is not");
+  assert.equal(mine.accepts(mine.generation, 1_000 + 10 * WINDOW_MS), true, "the current one never runs out");
+});
+
+test("an accepted response keeps its output past its own generation's window", () => {
+  const mine = make();
+  const made = mine.generation;
+  mine.give(made, 720, 3, "out-a");
+  const token = mine.accept("out-a");
+
+  mine.statedGeneration(1, 1_000);
+  mine.choose(720, "out-b");
+
+  const longAfter = 1_000 + 10 * WINDOW_MS;
+  assert.equal(mine.accepts(made, longAfter), false, "no NEW request of that generation is taken");
+  assert.ok(
+    mine.heldKeys(longAfter).has("out-a"),
+    "but the output whose bytes are still going out is held — dropping it is what the second deadline exists to prevent"
+  );
+
+  mine.release(token);
+  assert.equal(mine.heldKeys(longAfter).has("out-a"), false, "and released once the response is done");
+});
+
+test("what was given inside a live generation holds its output, and is forgotten past the window", () => {
+  const mine = make();
+  const made = mine.generation;
+  mine.give(made, 720, 3, "out-a");
+  mine.statedGeneration(1, 1_000);
+
+  assert.ok(mine.heldKeys(1_000 + WINDOW_MS).has("out-a"));
+  assert.equal(
+    mine.heldKeys(1_000 + WINDOW_MS + 1).has("out-a"),
+    false,
+    "past the window nothing stands on it, so it may be let go"
+  );
+  assert.equal(
+    mine.givenFor(made, 720, 3),
+    "",
+    "and the generation is pruned rather than kept for the life of the viewing"
+  );
+});
+
+test("a viewer leaving holds nothing, response in flight included", () => {
+  const mine = make();
+  mine.choose(720, "out-a");
+  mine.accept("out-b");
+  mine.give(mine.generation, 720, 1, "out-c");
+
+  mine.clear();
+
+  assert.equal(mine.heldKeys().size, 0);
+});
+
+test("the page owns the number, so a lower one does not take the viewer back", () => {
+  const mine = make();
+  mine.statedGeneration(4, 1_000);
+
+  assert.equal(mine.statedGeneration(2, 2_000), 4, "a reordered or repeated message changes nothing");
+  assert.equal(mine.statedGeneration(4, 2_000), 4, "and neither does the one already current");
+  assert.equal(mine.generation, 4);
+});
+
+test("a request ahead of what the page has announced is still answered", () => {
+  const mine = make();
+
+  // The page raises its own number before it sends anything, so a segment
+  // request can overtake the seek that announces the new viewing.
+  assert.equal(mine.accepts(1), true, "being behind the page means this side has not heard yet");
+  assert.equal(mine.accepts(7), true);
+});
+
+test("a request that states no generation is answered", () => {
+  const mine = make();
+  mine.statedGeneration(3, 1_000);
+
+  assert.equal(mine.accepts(Number.NaN, 1_000 + 10 * WINDOW_MS), true);
+  assert.equal(mine.accepts(undefined, 1_000 + 10 * WINDOW_MS), true, "a transport with no loader of ours builds no such parameter");
+});

package/test/viewer-outputs.test.js

@@ -1,9 +1,8 @@
 /**
  * @file What a viewer is watching, and what happens to it when they leave.
  *
- * The relation "this person watches this output" is indexed both ways — the
- * output holds its viewers, the viewer holds its outputs — and these checks
- * hold the three things that go wrong when the two indexes come apart.
+ * The relation "this person watches this output" is stored on the viewer, and
+ * these checks hold the operations that derive the opposite direction.
  *
  * 1. The viewer must never be dropped from the PICTURE. Their chosen
  *    soundtrack, their position and their step are recorded there, and the
@@ -20,22 +19,24 @@
  *    leaves a claim that nothing can reach.
  */
 
+import { chooseOutput } from "../services/viewer/choices.js";
 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 { HlsSessionManager, variantConsumerId } from "../services/hls-session-manager.js";
+import { wireOutputs } from "../services/server/wire-outputs.js";
 import { Viewers } from "../services/viewer/Viewers.js";
-import { SourceFile } from "../services/source/SourceFile.js";
-import { Timeline } from "../services/output/Timeline.js";
-import { Output } from "../services/output/Output.js";
-import { fmp4Format } from "../services/segment-formats/fmp4.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { Output } from "../services/encode/output/Output.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
 import { fakeProcess as fakeEncoder, startRunOn } from "./helpers/encode-run.js";
+import { outputSpec } from "./helpers/output-spec.js";
 
-const BASE_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
-const STEP_ID = "11111111-2222-3333-4444-555555555555";
-const AUDIO_ID = "99999999-8888-7777-6666-555555555555";
+const BASE_ID = "aaaaaaaabbbbcccc";
+const STEP_ID = "1111111122223333";
+const AUDIO_ID = "9999999988887777";
 const VIEWER = "viewer-one";
 const SEGMENT_SECONDS = 4;
 
@@ -49,6 +50,13 @@ const SEGMENT_SECONDS = 4;
 function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, isStep = false }) {
   return {
     id,
+    spec: outputSpec({
+      sourceKey: file.sourceKey,
+      fileIndex: file.fileIndex,
+      transcodeVideo: !audioOnly && encodeHeight > 0,
+      audioOnly,
+      height: encodeHeight
+    }),
     dirPath,
     timeline: new Timeline({
       boundaries: Array.from({ length: 101 }, (_, index) => index * SEGMENT_SECONDS),
@@ -59,11 +67,9 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
     get inputFile() { return this.file; },
     get audioFile() { return this.file; },
     startedAt: Date.now(),
-    createEntryMs: Date.now(),
     lastAccessedAt: Date.now(),
     ffmpeg: null,
     lastError: "",
-    consumers: new Set(),
     segmentFormat: fmp4Format,
     transcodeVideo: !audioOnly,
     transcodeAudio: true,
@@ -88,7 +94,6 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
     seekTarget: null,
     waitEpoch: 0,
     runs: new Set(),
-    viewers: new Map(),
     usesExplicitCuts: false,
     useSyntheticPlaylist: true,
     playlistText: "#EXTM3U\n",
@@ -102,12 +107,12 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
  * of one file, and one viewer watching all three — which is what an ordinary
  * session looks like once the viewer has picked a language and a quality.
  *
- * @returns {Promise<{ manager: HlsSessionManager, base: object, step: object,
+ * @returns {Promise<{ manager: object, base: object, step: object,
  *   audio: object, dirPath: string, released: string[] }>}
  */
 async function pictureWithStepAndSoundtrack() {
   const dirPath = await mkdtemp(path.join(os.tmpdir(), "viewer-outputs-"));
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -118,15 +123,12 @@ async function pictureWithStepAndSoundtrack() {
   const base = fakeSession({ id: BASE_ID, dirPath, file, encodeHeight: 812 });
   const step = fakeSession({ id: STEP_ID, dirPath, file, encodeHeight: 540, isStep: true });
   const audio = fakeSession({ id: AUDIO_ID, dirPath, file, audioOnly: true });
-  base.consumers = new Set([VIEWER]);
-  // The family's own claim, which is how a picture holds what it made: the
-  // browser never learns these two ids.
-  step.consumers = new Set([variantConsumerId(BASE_ID)]);
-  audio.consumers = new Set([variantConsumerId(BASE_ID)]);
+  // The browser never learns these two ids: what keeps them is who watches
+  // them, and nothing else.
   for (const session of [base, step, audio]) {
-    manager.sessionsById.set(session.id, session);
+    manager.outputs.set(session.id, session);
   }
-  file.stepHeights.set(540, 540);
+  manager.outputs.markStep(step);
   return { manager, base, step, audio, dirPath };
 }
 
@@ -137,12 +139,17 @@ test("a viewer who steps down, back to the picture's own height and down again k
   const viewer = manager.viewers.of(base, VIEWER);
   viewer.audio = { trackIndex: 1, transcode: true };
   viewer.position = { segment: 25, seconds: 100, at: Date.now() };
+  // The rule chose the step for them at 540p; the record is theirs.
+  chooseOutput(manager.viewers, VIEWER, 540, manager.outputs.get(STEP_ID).outputKey);
 
-  await manager.resolveVariantFile(BASE_ID, 540, "segment-00025.mp4", VIEWER);
-  await manager.resolveVariantFile(BASE_ID, 812, "segment-00026.mp4", VIEWER);
-  await manager.resolveVariantFile(BASE_ID, 540, "segment-00027.mp4", VIEWER);
+  await manager.renditions.resolveVariantFile(BASE_ID, 540, "segment-00025.mp4", VIEWER);
+  manager.renditions.viewerPlays(BASE_ID, VIEWER, 540, 100);
+  await manager.renditions.resolveVariantFile(BASE_ID, 812, "segment-00026.mp4", VIEWER);
+  manager.renditions.viewerPlays(BASE_ID, VIEWER, 812, 104);
+  await manager.renditions.resolveVariantFile(BASE_ID, 540, "segment-00027.mp4", VIEWER);
+  manager.renditions.viewerPlays(BASE_ID, VIEWER, 540, 108);
 
-  const known = base.viewers.get(VIEWER);
+  const known = manager.viewers.forOutput(base).get(VIEWER);
   assert.ok(known, "the picture is the one id the browser holds — a viewer is never dropped from it");
   assert.deepEqual(
     known.audio,
@@ -166,16 +173,16 @@ test("a viewer leaving is subtracted from every output, and one nobody is left w
     "one viewer, one object, and it knows all three outputs it is watching"
   );
 
-  await manager.releaseSessionConsumer(BASE_ID, VIEWER, "the viewer left");
+  await manager.lifecycle.releaseSessionConsumer(BASE_ID, VIEWER, "the viewer left");
 
-  assert.equal(manager.sessionsById.has(BASE_ID), false, "the picture goes with its last consumer");
+  assert.equal(manager.outputs.has(BASE_ID), false, "the picture goes with its last consumer");
   assert.equal(
-    manager.sessionsById.has(STEP_ID),
+    manager.outputs.has(STEP_ID),
     false,
     "and so does the quality step: nobody is watching it, and no one outside this class knows its id"
   );
   assert.equal(
-    manager.sessionsById.has(AUDIO_ID),
+    manager.outputs.has(AUDIO_ID),
     false,
     "and the soundtrack, for the same reason — it used to sit for half an hour holding an encoder, a directory and a claim on the torrent"
   );
@@ -186,7 +193,6 @@ test("an output somebody else is still watching is kept when one viewer leaves",
   const { manager, base, step, audio, dirPath } = await pictureWithStepAndSoundtrack();
   t.after(() => rm(dirPath, { recursive: true, force: true }));
   const second = "viewer-two";
-  base.consumers.add(second);
   manager.viewers.of(base, VIEWER).position = { segment: 25, seconds: 100, at: Date.now() };
   manager.viewers.of(step, VIEWER);
   manager.viewers.of(audio, VIEWER);
@@ -195,25 +201,25 @@ test("an output somebody else is still watching is kept when one viewer leaves",
   manager.viewers.of(base, second).position = { segment: 25, seconds: 100, at: Date.now() };
   manager.viewers.of(audio, second);
 
-  await manager.releaseSessionConsumer(BASE_ID, VIEWER, "the first viewer left");
+  await manager.lifecycle.releaseSessionConsumer(BASE_ID, VIEWER, "the first viewer left");
 
-  assert.equal(manager.sessionsById.has(BASE_ID), true, "the picture stays: it still has a consumer");
+  assert.equal(manager.outputs.has(BASE_ID), true, "the picture stays: it still has a consumer");
   assert.equal(
-    manager.sessionsById.has(AUDIO_ID),
+    manager.outputs.has(AUDIO_ID),
     true,
     "and the soundtrack stays, because having no listeners is what kills it and it has one"
   );
   assert.equal(
-    base.viewers.has(VIEWER),
+    manager.viewers.forOutput(base).has(VIEWER),
     false,
     "the viewer who left is gone from the picture"
   );
   assert.equal(
-    audio.viewers.has(VIEWER),
+    manager.viewers.forOutput(audio).has(VIEWER),
     false,
     "and from the soundtrack, which is the half of the relation the viewer holds"
   );
-  assert.equal(step.viewers.size, 0, "the step they had is watched by nobody");
+  assert.equal(manager.viewers.forOutput(step).size, 0, "the step they had is watched by nobody");
 });
 
 test("nothing is left wanting production once the last viewer has left", async (t) => {
@@ -223,7 +229,7 @@ test("nothing is left wanting production once the last viewer has left", async (
   manager.viewers.of(step, VIEWER);
   manager.viewers.of(audio, VIEWER);
 
-  await manager.releaseSessionConsumer(BASE_ID, VIEWER, "the viewer left");
+  await manager.lifecycle.releaseSessionConsumer(BASE_ID, VIEWER, "the viewer left");
 
   // NOTHING HAS TO BE RELEASED, and that is the point of the shape. A claim per
   // viewer per output used to be held in the encoding layer and taken back one
@@ -232,20 +238,20 @@ test("nothing is left wanting production once the last viewer has left", async (
   // with nobody's name in it, rebuilt from whoever is watching; a viewer who has
   // left is simply not in the next one.
   for (const id of [BASE_ID, STEP_ID, AUDIO_ID]) {
-    const session = manager.sessionsById.get(id);
+    const session = manager.outputs.get(id);
     assert.equal(session, undefined, `${id.slice(0, 8)} is let go with its last viewer`);
   }
-  manager.planEncodersNow();
+  manager.encodeRuns.planEncodersNow();
   for (const address of [base.outputKey, step.outputKey, audio.outputKey]) {
     assert.deepEqual(
-      manager.encodeOrchestrator.demand.mapOn(address),
+      manager.encodeOrchestrator.wantedSegmentsOn(address),
       [],
       "and no output is left asking for an encoder"
     );
   }
 });
 
-test("the two indexes of one relation are written together", () => {
+test("the reverse view is derived from the relation stored on the viewer", () => {
   const viewers = new Viewers();
   const picture = { id: "picture" };
   const soundtrack = { id: "soundtrack" };
@@ -254,24 +260,26 @@ test("the two indexes of one relation are written together", () => {
   viewers.of(soundtrack, VIEWER);
   assert.equal(viewers.of(soundtrack, VIEWER), viewer, "one person is one object, whatever they are watching");
   assert.deepEqual([...viewer.outputs].sort(), ["picture", "soundtrack"]);
-  assert.equal(picture.viewers.get(VIEWER), viewer);
+  assert.equal(viewers.forOutput(picture).get(VIEWER), viewer);
 
   viewers.leaves(soundtrack, VIEWER);
-  assert.deepEqual([...viewer.outputs], ["picture"], "both directions go together");
-  assert.equal(soundtrack.viewers.has(VIEWER), false);
+  assert.deepEqual([...viewer.outputs], ["picture"], "the stored relation changes once");
+  assert.equal(viewers.forOutput(soundtrack).has(VIEWER), false);
   assert.equal(viewers.size, 1, "and the person is still known, because they are still watching something");
 
   viewers.leaves(picture, VIEWER);
   assert.equal(viewers.size, 0, "watching nothing, they are forgotten");
 });
 
-test("a viewer that cannot name itself belongs to the session that met it", () => {
+test("a request that names nobody makes no viewer", () => {
+  // A nameless viewer used to belong to whichever output met it: the same
+  // person was a different object on each output, and two nameless people on
+  // one output were one object. Every viewer has a name now.
   const viewers = new Viewers();
   const oneFilm = { id: "one" };
-  const another = { id: "another" };
 
-  const first = viewers.of(oneFilm, "");
-  const second = viewers.of(another, "");
-  assert.notEqual(first, second, "two anonymous viewers of two films are not one person");
-  assert.equal(viewers.size, 0, "and neither is in the registry, which is keyed by a name they do not have");
+  assert.throws(() => viewers.of(oneFilm, ""), TypeError);
+  assert.equal(viewers.size, 0, "nothing was registered");
+  assert.equal(viewers.forOutput(oneFilm).size, 0, "and nobody watches the output");
+  assert.equal(viewers.getForOutput(oneFilm, ""), null);
 });

package/test/viewer-presence.test.js

@@ -17,12 +17,13 @@ import assert from "node:assert/strict";
 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 { SourceFile } from "../services/source/SourceFile.js";
+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 = "aaaaaaaa-0000-4000-8000-000000000001";
-const SOUND = "aaaaaaaa-0000-4000-8000-000000000002";
+const PICTURE = "aaaaaaaa00004000";
+const SOUND = "aaaaaaaa00004001";
 
 /**
  * @param {string} id
@@ -32,13 +33,13 @@ const SOUND = "aaaaaaaa-0000-4000-8000-000000000002";
 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; },
-    consumers: new Set(),
-    viewers: new Map(),
+    claims: new Set(),
     lastAccessedAt: Date.now()
   };
 }
@@ -46,7 +47,7 @@ function outputOn(id, dirPath) {
 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", viewers: new Map() };
+  const output = { id: "out-1" };
 
   const first = viewers.of(output, "someone");
   assert.equal(changes, 1, "a new relation is a change");
@@ -55,7 +56,7 @@ test("asking for a viewer of an output is that viewer watching it", () => {
   viewers.of(output, "someone");
   assert.equal(changes, 1, "asking again about the same output changes nothing");
 
-  const second = { id: "out-2", viewers: new Map() };
+  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);
@@ -63,20 +64,18 @@ test("asking for a viewer of an output is that viewer watching it", () => {
 
 test("a connection closing takes the person off every output at once", () => {
   const viewers = new Viewers();
-  const picture = { id: "picture", viewers: new Map() };
-  const sound = { id: "sound", viewers: new Map() };
-  const byId = new Map([["picture", picture], ["sound", sound]]);
-
+  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", (id) => byId.get(id) ?? null);
+  const left = viewers.hasGone("watcher");
 
   assert.deepEqual(left.sort(), ["picture", "sound"], "both, not the one the browser holds an id for");
-  assert.equal(picture.viewers.has("watcher"), false);
-  assert.equal(sound.viewers.has("watcher"), false);
-  assert.equal(picture.viewers.has("other"), true, "and nobody else goes with them");
+  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");
 });
 
@@ -85,7 +84,7 @@ test("a viewer whose connection closed is let go of every output they were watch
   t.after(async () => {
     await rm(dirPath, { recursive: true, force: true });
   });
-  const manager = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
@@ -94,26 +93,24 @@ test("a viewer whose connection closed is let go of every output they were watch
 
   const picture = outputOn(PICTURE, dirPath);
   const sound = outputOn(SOUND, dirPath);
-  picture.consumers.add("watcher");
-  sound.consumers.add("watcher");
-  manager.sessionsById.set(PICTURE, picture);
-  manager.sessionsById.set(SOUND, sound);
+  manager.outputs.set(PICTURE, picture);
+  manager.outputs.set(SOUND, sound);
   manager.viewers.of(picture, "watcher");
   manager.viewers.of(sound, "watcher");
 
-  const released = await manager.viewerHasGone("watcher", "the connection closed");
+  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 = new HlsSessionManager({
+  const manager = wireOutputs({
     enabled: true,
     ffmpegBin: "ffmpeg",
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
-  assert.equal(await manager.viewerHasGone("never-seen"), 0);
-  assert.equal(await manager.viewerHasGone(""), 0);
+  assert.equal(await manager.lifecycle.viewerHasGone("never-seen"), 0);
+  assert.equal(await manager.lifecycle.viewerHasGone(""), 0);
 });

package/test/viewer-requests-admission.test.js

@@ -0,0 +1,89 @@
+/**
+ * @file Opening an output admits and places its viewer in one synchronous call.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EncodeAdmission } from "../services/encode/EncodeAdmission.js";
+import { ViewerRequests } from "../services/server/ViewerRequests.js";
+
+test("the first opening holds capacity before a concurrent opening is admitted", async () => {
+  const records = new Map();
+  const outputCosts = new Map([
+    ["source-a:0", 0.6],
+    ["source-b:0", 0.6]
+  ]);
+  const viewers = {
+    get: () => null,
+    forOutput(output) {
+      return new Set(records.get(output.outputKey)?.keys() ?? []);
+    },
+    of(output, consumerId) {
+      let viewersOnOutput = records.get(output.outputKey);
+      if (!viewersOnOutput) {
+        viewersOnOutput = new Map();
+        records.set(output.outputKey, viewersOnOutput);
+      }
+      let viewer = viewersOnOutput.get(consumerId);
+      if (!viewer) {
+        viewer = {
+          position: null,
+          linkReading: () => null,
+          noteVisiblePicture: () => {}
+        };
+        viewersOnOutput.set(consumerId, viewer);
+      }
+      return viewer;
+    },
+    watchedAddresses() {
+      return new Set(
+        [...records]
+          .filter(([, members]) => [...members.values()].some((viewer) => viewer.position !== null))
+          .map(([address]) => address)
+      );
+    }
+  };
+  const admission = new EncodeAdmission({
+    liveRunsByAddress: () => new Map(),
+    preparedAddresses: () => new Set(),
+    watchedAddresses: () => viewers.watchedAddresses(),
+    loadOf: (address) => {
+      const costSec = outputCosts.get(address);
+      return costSec === undefined ? null : { costSec, fileKey: address, fileCostSec: 0 };
+    },
+    availability: () => ({ share: 1, known: true }),
+    finished: () => false
+  });
+  const opening = {
+    async open({ sourceKey, fileIndex, claim }) {
+      const output = { id: `${sourceKey}:${fileIndex}`, outputKey: `${sourceKey}:${fileIndex}` };
+      const answer = claim(output);
+      if (!answer.admitted) {
+        const error = new Error(answer.reason);
+        error.code = "OUTPUT_NO_CAPACITY";
+        throw error;
+      }
+      return { output, existed: false, audio: null, verdict: null };
+    }
+  };
+  const requests = new ViewerRequests({
+    opening,
+    viewers,
+    admitsWatching: (output) => admission.admitsWatching(output.outputKey),
+    outputTimes: { segmentIndexForTime: (_output, seconds) => Math.floor(seconds / 4) },
+    planEncodersSoon: () => {},
+    outputs: { touch: () => {} },
+    noteServingVerdict: () => {},
+    waitUntilReady: async () => {}
+  });
+
+  const first = requests.createOrGetSession({ sourceKey: "source-a", fileIndex: 0, consumerId: "viewer-a" });
+  const second = requests.createOrGetSession({ sourceKey: "source-b", fileIndex: 0, consumerId: "viewer-b" });
+  const [firstResult, secondResult] = await Promise.allSettled([first, second]);
+
+  assert.equal(firstResult.status, "fulfilled");
+  assert.equal(secondResult.status, "rejected");
+  assert.match(secondResult.reason.message, /would make 0\.83x/);
+  assert.equal(viewers.forOutput({ outputKey: "source-a:0" }).has("viewer-a"), true);
+  assert.equal(viewers.forOutput({ outputKey: "source-b:0" }).has("viewer-b"), false);
+});