@torrent-tv/proxy 2.89.0 → 2.89.2

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-requests-admission.test.js

@@ -1,89 +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);
-});
+/**
+ * @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);
+});