@torrent-tv/proxy 2.89.6 → 2.89.7

package/test/viewer-subtitle-subscription.test.js

@@ -1,96 +1,96 @@
-/**
- * @file Who wants subtitle cues, and why the answer is a person and not a channel.
- *
- * The subscription used to be a `Set<DataChannel>` inside the transport, keyed
- * by `sourceKey:fileIndex`. Two things followed from that, and both are field
- * facts rather than worries:
- *
- * 1. a seamless reconnect lost subtitles for the rest of the session, because
- *    the new channel is a different object and nothing re-subscribed it;
- * 2. the transport had to sniff `/api/subtitles` out of the request path and
- *    derive a torrent key to build that key at all — application routing and
- *    torrent identity, inside the layer that is only supposed to carry bytes.
- *
- * Held against the viewer instead, both go away by construction: whatever
- * channel the person is reachable on next, they are still subscribed, and the
- * transport never learns what a subtitle is.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { Viewers } from "../services/viewer/Viewers.js";
-
-/** An output is only ever held by id here, so the thinnest possible stand-in. */
-const anOutput = (id) => ({ id, viewers: new Set() });
-
-test("a viewer who switched subtitles on is listed for that file", () => {
-  const viewers = new Viewers();
-  viewers.of(anOutput("picture"), "alice");
-
-  assert.equal(viewers.wantsCues("alice", "src-1", 3), true);
-  assert.deepEqual(viewers.wantingCues("src-1", 3), ["alice"]);
-});
-
-test("nobody is listed for a file nobody asked about", () => {
-  const viewers = new Viewers();
-  viewers.of(anOutput("picture"), "alice");
-  viewers.wantsCues("alice", "src-1", 3);
-
-  assert.deepEqual(viewers.wantingCues("src-1", 4), []);
-  assert.deepEqual(viewers.wantingCues("src-2", 3), []);
-});
-
-test("two viewers of one file are both listed, and one file each is kept apart", () => {
-  const viewers = new Viewers();
-  const picture = anOutput("picture");
-  viewers.of(picture, "alice");
-  viewers.of(picture, "bob");
-
-  viewers.wantsCues("alice", "src-1", 0);
-  viewers.wantsCues("bob", "src-1", 0);
-  viewers.wantsCues("bob", "src-1", 1);
-
-  assert.deepEqual(viewers.wantingCues("src-1", 0).sort(), ["alice", "bob"]);
-  assert.deepEqual(viewers.wantingCues("src-1", 1), ["bob"]);
-});
-
-test("the subscription outlives the connection, which is the whole point", () => {
-  // Nothing here mentions a channel, and that is the assertion: the registry
-  // has no way to express "this channel", so a channel dying cannot take a
-  // subscription with it.
-  const viewers = new Viewers();
-  viewers.of(anOutput("picture"), "alice");
-  viewers.wantsCues("alice", "src-1", 3);
-
-  // A reconnect is, from here, nothing at all: the same person is still known.
-  viewers.seen("alice");
-
-  assert.deepEqual(viewers.wantingCues("src-1", 3), ["alice"]);
-});
-
-test("a viewer who has gone is no longer listed", () => {
-  const viewers = new Viewers();
-  const picture = anOutput("picture");
-  viewers.of(picture, "alice");
-  viewers.wantsCues("alice", "src-1", 3);
-
-  viewers.hasGone("alice");
-
-  assert.deepEqual(viewers.wantingCues("src-1", 3), []);
-});
-
-test("an unknown name subscribes to nothing", () => {
-  const viewers = new Viewers();
-  assert.equal(viewers.wantsCues("nobody", "src-1", 3), false);
-  assert.deepEqual(viewers.wantingCues("src-1", 3), []);
-});
-
-test("a request missing the file index registers nothing", () => {
-  const viewers = new Viewers();
-  viewers.of(anOutput("picture"), "alice");
-
-  assert.equal(viewers.wantsCues("alice", "src-1", Number.NaN), false);
-  assert.equal(viewers.wantsCues("alice", "", 3), false);
-  assert.deepEqual(viewers.wantingCues("src-1", 3), []);
-});
+/**
+ * @file Who wants subtitle cues, and why the answer is a person and not a channel.
+ *
+ * The subscription used to be a `Set<DataChannel>` inside the transport, keyed
+ * by `sourceKey:fileIndex`. Two things followed from that, and both are field
+ * facts rather than worries:
+ *
+ * 1. a seamless reconnect lost subtitles for the rest of the session, because
+ *    the new channel is a different object and nothing re-subscribed it;
+ * 2. the transport had to sniff `/api/subtitles` out of the request path and
+ *    derive a torrent key to build that key at all — application routing and
+ *    torrent identity, inside the layer that is only supposed to carry bytes.
+ *
+ * Held against the viewer instead, both go away by construction: whatever
+ * channel the person is reachable on next, they are still subscribed, and the
+ * transport never learns what a subtitle is.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { Viewers } from "../services/viewer/Viewers.js";
+
+/** An output is only ever held by id here, so the thinnest possible stand-in. */
+const anOutput = (id) => ({ id, viewers: new Set() });
+
+test("a viewer who switched subtitles on is listed for that file", () => {
+  const viewers = new Viewers();
+  viewers.of(anOutput("picture"), "alice");
+
+  assert.equal(viewers.wantsCues("alice", "src-1", 3), true);
+  assert.deepEqual(viewers.wantingCues("src-1", 3), ["alice"]);
+});
+
+test("nobody is listed for a file nobody asked about", () => {
+  const viewers = new Viewers();
+  viewers.of(anOutput("picture"), "alice");
+  viewers.wantsCues("alice", "src-1", 3);
+
+  assert.deepEqual(viewers.wantingCues("src-1", 4), []);
+  assert.deepEqual(viewers.wantingCues("src-2", 3), []);
+});
+
+test("two viewers of one file are both listed, and one file each is kept apart", () => {
+  const viewers = new Viewers();
+  const picture = anOutput("picture");
+  viewers.of(picture, "alice");
+  viewers.of(picture, "bob");
+
+  viewers.wantsCues("alice", "src-1", 0);
+  viewers.wantsCues("bob", "src-1", 0);
+  viewers.wantsCues("bob", "src-1", 1);
+
+  assert.deepEqual(viewers.wantingCues("src-1", 0).sort(), ["alice", "bob"]);
+  assert.deepEqual(viewers.wantingCues("src-1", 1), ["bob"]);
+});
+
+test("the subscription outlives the connection, which is the whole point", () => {
+  // Nothing here mentions a channel, and that is the assertion: the registry
+  // has no way to express "this channel", so a channel dying cannot take a
+  // subscription with it.
+  const viewers = new Viewers();
+  viewers.of(anOutput("picture"), "alice");
+  viewers.wantsCues("alice", "src-1", 3);
+
+  // A reconnect is, from here, nothing at all: the same person is still known.
+  viewers.seen("alice");
+
+  assert.deepEqual(viewers.wantingCues("src-1", 3), ["alice"]);
+});
+
+test("a viewer who has gone is no longer listed", () => {
+  const viewers = new Viewers();
+  const picture = anOutput("picture");
+  viewers.of(picture, "alice");
+  viewers.wantsCues("alice", "src-1", 3);
+
+  viewers.hasGone("alice");
+
+  assert.deepEqual(viewers.wantingCues("src-1", 3), []);
+});
+
+test("an unknown name subscribes to nothing", () => {
+  const viewers = new Viewers();
+  assert.equal(viewers.wantsCues("nobody", "src-1", 3), false);
+  assert.deepEqual(viewers.wantingCues("src-1", 3), []);
+});
+
+test("a request missing the file index registers nothing", () => {
+  const viewers = new Viewers();
+  viewers.of(anOutput("picture"), "alice");
+
+  assert.equal(viewers.wantsCues("alice", "src-1", Number.NaN), false);
+  assert.equal(viewers.wantsCues("alice", "", 3), false);
+  assert.deepEqual(viewers.wantingCues("src-1", 3), []);
+});

package/test/viewer.test.js

@@ -1,139 +1,139 @@
-/**
- * @file One object per person watching, and one deletion to forget them.
- *
- * It was six maps hung on the session, each keyed by consumer id, and the
- * forgetting was already wrong: releasing a consumer emptied none of them, so a
- * viewer who had left went on counting as wanting their soundtrack until their
- * head expired, and their entries stayed for the life of the session.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-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 { Viewer } from "../services/viewer/Viewer.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const SESSION_ID = "aaaaaaaabbbbcccc";
-
-test("presence and position are two facts, and presence does not wait for a request", () => {
-  const now = 1_000_000;
-  const viewer = new Viewer("someone", now);
-
-  // The whole of the 2026-09-05 failure in one assertion: a viewer who has
-  // arrived and asked for nothing yet IS watching. Answered from the position
-  // alone — which is written only when a segment is requested — this read
-  // false, every encoder on their output was stopped for having nobody, and
-  // the `init.mp4` they needed in order to request their first segment was
-  // therefore never made.
-  assert.equal(viewer.position, null, "nothing has placed them yet");
-  assert.equal(viewer.isPresent(), true, "and they are still here");
-
-  // SILENCE IS NOT ABSENCE, however long it lasts. A paused viewer, a hidden
-  // tab whose timers the browser has throttled, and one holding two minutes of
-  // cushion all say nothing and are all still watching — so there is no
-  // interval that separates them from someone who has left, and the threshold
-  // that used to try is gone.
-  viewer.seen(now - 600_000);
-  assert.equal(viewer.isPresent(), true, "ten minutes of silence is not leaving");
-
-  // Something SAID they are gone: the browser released the session, or their
-  // connection closed. That is the only way out.
-  viewer.gone = true;
-  assert.equal(viewer.isPresent(), false, "a statement is what ends it");
-});
-
-test("position is one fact with one writer, and a function of time", () => {
-  const viewer = new Viewer("someone");
-  assert.equal(viewer.positionSeconds(), null);
-
-  viewer.report({ bufferedAheadSec: 60, positionSeconds: 40, playing: false }, 1_000_000);
-  assert.equal(viewer.positionSeconds(1_000_000), 40);
-  assert.equal(viewer.positionSeconds(1_060_000), 40, "a stopped picture covers no film");
-
-  viewer.report({ bufferedAheadSec: 60, positionSeconds: 40, playing: true }, 1_000_000);
-  assert.equal(viewer.positionSeconds(1_010_000), 50, "a playing one covers a second a second");
-  assert.equal(
-    viewer.positionSeconds(1_600_000),
-    100,
-    "and no further than the film they said they held"
-  );
-
-  // A seek is the same statement, and there is no second field for it to win
-  // against: two writers taking turns on one reading is what made the priority
-  // map jump backwards several times a second in the field on 2026-09-13.
-  viewer.moveTo(900, 1_010_000);
-  assert.equal(viewer.positionSeconds(1_010_000), 900);
-  assert.equal(
-    viewer.positionSeconds(1_070_000),
-    900,
-    "and a seek carries no cushion from where it left, so nothing is extrapolated"
-  );
-});
-
-test("a viewer who has stated nothing has a position and does not drift from it", () => {
-  const viewer = new Viewer("someone");
-  viewer.moveTo(0, 1_000_000);
-
-  // The whole of the fault of 2026-09-14: `playing` used to start true, and a
-  // page that had measured nothing was never allowed to say otherwise, so a
-  // hidden tab's viewer was carried 146 seconds into a film they had not begun.
-  assert.equal(viewer.playing, false);
-  assert.equal(viewer.waiting, true, "a viewer who has just arrived is waiting on us");
-  assert.equal(viewer.positionSeconds(1_146_000), 0);
-});
-
-test("asking for a viewer twice is the same viewer", () => {
-  const session = { id: "session" };
-  const viewers = new Viewers();
-  const first = viewers.of(session, "one");
-  first.audio = { trackIndex: 3, transcode: false };
-
-  assert.equal(viewers.of(session, "one"), first);
-  assert.equal(viewers.of(session, "one").audio.trackIndex, 3);
-  assert.notEqual(viewers.of(session, "two"), first);
-  assert.equal(viewers.forOutput(session).size, 2);
-});
-
-test("releasing a consumer forgets everything that was true of them alone", async (t) => {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "viewer-"));
-  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 session = {
-    id: SESSION_ID,
-    spec: outputSpec(),
-    dirPath,
-    state: "live",
-    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; },
-    claims: new Set(),
-    lastAccessedAt: Date.now()
-  };
-  manager.outputs.set(SESSION_ID, session);
-
-  const leaving = manager.viewers.of(session, "leaving");
-  leaving.audio = { trackIndex: 2, transcode: true };
-  leaving.activeVariantId = "some-variant";
-  leaving.position = { segment: 40, seconds: 160, at: Date.now() };
-  manager.viewers.of(session, "staying").audio = { trackIndex: 0, transcode: false };
-
-  await manager.lifecycle.releaseSessionConsumer(SESSION_ID, "leaving", "the tab was closed");
-
-  assert.equal(manager.viewers.forOutput(session).has("leaving"), false, "one deletion, not six");
-  assert.equal(manager.viewers.forOutput(session).has("staying"), true, "and it takes nobody else with it");
-  assert.equal(manager.viewers.size, 1);
-});
+/**
+ * @file One object per person watching, and one deletion to forget them.
+ *
+ * It was six maps hung on the session, each keyed by consumer id, and the
+ * forgetting was already wrong: releasing a consumer emptied none of them, so a
+ * viewer who had left went on counting as wanting their soundtrack until their
+ * head expired, and their entries stayed for the life of the session.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SourceFile } from "../services/media/SourceFile.js";
+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 { Viewer } from "../services/viewer/Viewer.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+import { outputSpec } from "./helpers/output-spec.js";
+
+const SESSION_ID = "aaaaaaaabbbbcccc";
+
+test("presence and position are two facts, and presence does not wait for a request", () => {
+  const now = 1_000_000;
+  const viewer = new Viewer("someone", now);
+
+  // The whole of the 2026-09-05 failure in one assertion: a viewer who has
+  // arrived and asked for nothing yet IS watching. Answered from the position
+  // alone — which is written only when a segment is requested — this read
+  // false, every encoder on their output was stopped for having nobody, and
+  // the `init.mp4` they needed in order to request their first segment was
+  // therefore never made.
+  assert.equal(viewer.position, null, "nothing has placed them yet");
+  assert.equal(viewer.isPresent(), true, "and they are still here");
+
+  // SILENCE IS NOT ABSENCE, however long it lasts. A paused viewer, a hidden
+  // tab whose timers the browser has throttled, and one holding two minutes of
+  // cushion all say nothing and are all still watching — so there is no
+  // interval that separates them from someone who has left, and the threshold
+  // that used to try is gone.
+  viewer.seen(now - 600_000);
+  assert.equal(viewer.isPresent(), true, "ten minutes of silence is not leaving");
+
+  // Something SAID they are gone: the browser released the session, or their
+  // connection closed. That is the only way out.
+  viewer.gone = true;
+  assert.equal(viewer.isPresent(), false, "a statement is what ends it");
+});
+
+test("position is one fact with one writer, and a function of time", () => {
+  const viewer = new Viewer("someone");
+  assert.equal(viewer.positionSeconds(), null);
+
+  viewer.report({ bufferedAheadSec: 60, positionSeconds: 40, playing: false }, 1_000_000);
+  assert.equal(viewer.positionSeconds(1_000_000), 40);
+  assert.equal(viewer.positionSeconds(1_060_000), 40, "a stopped picture covers no film");
+
+  viewer.report({ bufferedAheadSec: 60, positionSeconds: 40, playing: true }, 1_000_000);
+  assert.equal(viewer.positionSeconds(1_010_000), 50, "a playing one covers a second a second");
+  assert.equal(
+    viewer.positionSeconds(1_600_000),
+    100,
+    "and no further than the film they said they held"
+  );
+
+  // A seek is the same statement, and there is no second field for it to win
+  // against: two writers taking turns on one reading is what made the priority
+  // map jump backwards several times a second in the field on 2026-09-13.
+  viewer.moveTo(900, 1_010_000);
+  assert.equal(viewer.positionSeconds(1_010_000), 900);
+  assert.equal(
+    viewer.positionSeconds(1_070_000),
+    900,
+    "and a seek carries no cushion from where it left, so nothing is extrapolated"
+  );
+});
+
+test("a viewer who has stated nothing has a position and does not drift from it", () => {
+  const viewer = new Viewer("someone");
+  viewer.moveTo(0, 1_000_000);
+
+  // The whole of the fault of 2026-09-14: `playing` used to start true, and a
+  // page that had measured nothing was never allowed to say otherwise, so a
+  // hidden tab's viewer was carried 146 seconds into a film they had not begun.
+  assert.equal(viewer.playing, false);
+  assert.equal(viewer.waiting, true, "a viewer who has just arrived is waiting on us");
+  assert.equal(viewer.positionSeconds(1_146_000), 0);
+});
+
+test("asking for a viewer twice is the same viewer", () => {
+  const session = { id: "session" };
+  const viewers = new Viewers();
+  const first = viewers.of(session, "one");
+  first.audio = { trackIndex: 3, transcode: false };
+
+  assert.equal(viewers.of(session, "one"), first);
+  assert.equal(viewers.of(session, "one").audio.trackIndex, 3);
+  assert.notEqual(viewers.of(session, "two"), first);
+  assert.equal(viewers.forOutput(session).size, 2);
+});
+
+test("releasing a consumer forgets everything that was true of them alone", async (t) => {
+  const dirPath = await mkdtemp(path.join(os.tmpdir(), "viewer-"));
+  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 session = {
+    id: SESSION_ID,
+    spec: outputSpec(),
+    dirPath,
+    state: "live",
+    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; },
+    claims: new Set(),
+    lastAccessedAt: Date.now()
+  };
+  manager.outputs.set(SESSION_ID, session);
+
+  const leaving = manager.viewers.of(session, "leaving");
+  leaving.audio = { trackIndex: 2, transcode: true };
+  leaving.activeVariantId = "some-variant";
+  leaving.position = { segment: 40, seconds: 160, at: Date.now() };
+  manager.viewers.of(session, "staying").audio = { trackIndex: 0, transcode: false };
+
+  await manager.lifecycle.releaseSessionConsumer(SESSION_ID, "leaving", "the tab was closed");
+
+  assert.equal(manager.viewers.forOutput(session).has("leaving"), false, "one deletion, not six");
+  assert.equal(manager.viewers.forOutput(session).has("staying"), true, "and it takes nobody else with it");
+  assert.equal(manager.viewers.size, 1);
+});

package/test/visible-rung.test.js

@@ -1,37 +1,37 @@
-/**
- * @file The rung the picture a viewer sees asks for: the smallest height of the
- * ladder whose frame is not smaller than it (roadmap item 98).
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { rungForVisiblePicture, visibleHeightCap } from "../services/encode/quality/visible-rung.js";
-import { buildResolutionLadder } from "../services/encode/hwaccel.js";
-
-const LADDER = buildResolutionLadder(1920, 1080);
-
-test("the smallest rung whose frame is not smaller than the picture seen", () => {
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1200, height: 675 }), { width: 1280, height: 720 });
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1280, height: 720 }), { width: 1280, height: 720 });
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1281, height: 720 }), { width: 1920, height: 1080 });
-});
-
-test("a picture seen larger than the source is served at the source's size, never above", () => {
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 3840, height: 2160 }), { width: 1920, height: 1080 });
-});
-
-test("both sides count: a wide picture asks for the rung wide enough", () => {
-  // Stretched (object-fit: fill) to 1000 wide and 300 tall.
-  assert.equal(rungForVisiblePicture(LADDER, { width: 1000, height: 300 }).height, 720);
-});
-
-test("nothing measured bounds nothing", () => {
-  assert.equal(rungForVisiblePicture(LADDER, null), null);
-  assert.equal(visibleHeightCap(1920, 1080, null), null);
-  assert.equal(visibleHeightCap(0, 0, { width: 640, height: 360 }), null);
-});
-
-test("the bound is a height of the source's own ladder", () => {
-  assert.equal(visibleHeightCap(1920, 1080, { width: 640, height: 360 }), 360);
-  assert.equal(visibleHeightCap(1920, 800, { width: 900, height: 375 }), 480);
-});
+/**
+ * @file The rung the picture a viewer sees asks for: the smallest height of the
+ * ladder whose frame is not smaller than it (roadmap item 98).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { rungForVisiblePicture, visibleHeightCap } from "../services/encode/quality/visible-rung.js";
+import { buildResolutionLadder } from "../services/encode/hwaccel.js";
+
+const LADDER = buildResolutionLadder(1920, 1080);
+
+test("the smallest rung whose frame is not smaller than the picture seen", () => {
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1200, height: 675 }), { width: 1280, height: 720 });
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1280, height: 720 }), { width: 1280, height: 720 });
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1281, height: 720 }), { width: 1920, height: 1080 });
+});
+
+test("a picture seen larger than the source is served at the source's size, never above", () => {
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 3840, height: 2160 }), { width: 1920, height: 1080 });
+});
+
+test("both sides count: a wide picture asks for the rung wide enough", () => {
+  // Stretched (object-fit: fill) to 1000 wide and 300 tall.
+  assert.equal(rungForVisiblePicture(LADDER, { width: 1000, height: 300 }).height, 720);
+});
+
+test("nothing measured bounds nothing", () => {
+  assert.equal(rungForVisiblePicture(LADDER, null), null);
+  assert.equal(visibleHeightCap(1920, 1080, null), null);
+  assert.equal(visibleHeightCap(0, 0, { width: 640, height: 360 }), null);
+});
+
+test("the bound is a height of the source's own ladder", () => {
+  assert.equal(visibleHeightCap(1920, 1080, { width: 640, height: 360 }), 360);
+  assert.equal(visibleHeightCap(1920, 800, { width: 900, height: 375 }), 480);
+});