@torrent-tv/proxy 2.76.6 → 2.78.0

package/test/sidecar-naming.test.js

@@ -1,17 +1,17 @@
-/**
- * @file What a torrent's own names say about a track shipped as its own file.
- *
- * The rule worth pinning is the releaser one, because getting it wrong invents
- * an author. In the field case — `[HorribleSubs] Drifters - 02 [1080p].mka` in
- * `Rus Sound/`, beside `[HorribleSubs] Drifters - 02 [1080p].mkv` — the dub
- * carries the picture's own brackets and nothing else, so there is nothing
- * truthful to say about who made it. The subtitles of the same release sit in
- * `Sub/[Stan WarHammer & Nesitach]/`, a bracket the picture does not carry, and
- * that one IS their author.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
+/**
+ * @file What a torrent's own names say about a track shipped as its own file.
+ *
+ * The rule worth pinning is the releaser one, because getting it wrong invents
+ * an author. In the field case — `[HorribleSubs] Drifters - 02 [1080p].mka` in
+ * `Rus Sound/`, beside `[HorribleSubs] Drifters - 02 [1080p].mkv` — the dub
+ * carries the picture's own brackets and nothing else, so there is nothing
+ * truthful to say about who made it. The subtitles of the same release sit in
+ * `Sub/[Stan WarHammer & Nesitach]/`, a bracket the picture does not carry, and
+ * that one IS their author.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
 import {
   languageFromFolderNames,
   releaserFrom,
@@ -34,109 +34,109 @@ function readPath(relativePath, videoName = "") {
   });
   return { ...naming, code: naming.code ?? "und", group: naming.releaser };
 }
-
-
-const VIDEO_NAME = "[HorribleSubs] Drifters - 02 [1080p].mkv";
-
-test("a folder naming a language is read, whole segment or word", () => {
-  assert.equal(languageFromFolderNames(["ENG"])?.code, "en");
-  assert.equal(languageFromFolderNames(["Rus Sound"])?.code, "ru");
-  assert.equal(languageFromFolderNames(["Sub", "Russian"])?.code, "ru");
-  assert.equal(languageFromFolderNames([])?.code, undefined);
-});
-
-test("the innermost folder answers first", () => {
-  assert.equal(languageFromFolderNames(["Russian", "English Dub"])?.code, "en");
-});
-
-test("a two-letter word inside a longer folder name is not taken for a language", () => {
-  // "No" is Norwegian as a whole segment, but a word in `No Subs` is a word.
-  assert.equal(languageFromFolderNames(["No Subs"]), null);
-  assert.equal(languageFromFolderNames(["no"])?.code, "no");
-});
-
-test("a bracket the picture also carries is not the sidecar's author", () => {
-  assert.equal(
-    releaserFrom({
-      folders: ["Rus Sound"],
-      fileName: "[HorribleSubs] Drifters - 02 [1080p].mka",
-      videoName: VIDEO_NAME
-    }),
-    null
-  );
-});
-
-test("a bracket only the sidecar carries is its author", () => {
-  assert.equal(
-    releaserFrom({
-      folders: ["Sub", "[Stan WarHammer & Nesitach]"],
-      fileName: "[HorribleSubs] Drifters - 02 [1080p].ass",
-      videoName: VIDEO_NAME
-    }),
-    "Stan WarHammer & Nesitach"
-  );
-});
-
-test("a bracket describing the encode is never an author", () => {
-  for (const token of ["1080p", "x264", "HEVC", "WEB-DL", "AAC", "5.1", "10bit", "78EFD746", "RUS"]) {
-    assert.equal(
-      releaserFrom({ folders: [], fileName: `Film [${token}].mka`, videoName: "Other.mkv" }),
-      null,
-      `[${token}] should not be read as a releaser`
-    );
-  }
-});
-
-test("the innermost folder is preferred to the file name", () => {
-  assert.equal(
-    releaserFrom({ folders: ["[TeamA]"], fileName: "[TeamB] ep.ass", videoName: "ep.mkv" }),
-    "TeamA"
-  );
-});
-
-test("language and author together, for the field case", () => {
-  assert.deepEqual(
-    sidecarNaming({
-      folders: ["Rus Sound"],
-      fileName: "[HorribleSubs] Drifters - 02 [1080p].mka",
-      videoName: VIDEO_NAME
-    }),
-    { code: "ru", name: "Russian", releaser: null, isForced: false, isHearingImpaired: false, isDefault: false }
-  );
-  assert.deepEqual(
-    sidecarNaming({
-      folders: ["Sub", "[Stan WarHammer & Nesitach]"],
-      fileName: "[HorribleSubs] Drifters - 02 [1080p].ass",
-      videoName: VIDEO_NAME
-    }),
-    {
-      code: null,
-      name: null,
-      releaser: "Stan WarHammer & Nesitach",
-      isForced: false,
-      isHearingImpaired: false,
-      isDefault: false
-    }
-  );
-});
-
-test("a subtitle file takes its author from the folder the release put it in", () => {
-  const info = readPath("Sub/[Stan WarHammer & Nesitach]/[HorribleSubs] Drifters - 02 [1080p].ass", VIDEO_NAME);
-  assert.equal(info.group, "Stan WarHammer & Nesitach");
-});
-
-test("the picture's own release group is never reported as the translator", () => {
-  const info = readPath("Sub/[HorribleSubs] Drifters - 02 [1080p].ass", VIDEO_NAME);
-  assert.equal(info.group, null);
-});
-
-test("the language of a subtitle folder is read where the whole segment is not a language", () => {
-  const info = readPath("Rus Sub/ep.srt", "ep.mkv");
-  assert.equal(info.code, "ru");
-});
-
-test("what the rules answer with nothing to go on", () => {
-  const info = readPath("ep.srt");
-  assert.equal(info.code, "und");
-  assert.equal(info.group, null);
-});
+
+
+const VIDEO_NAME = "[HorribleSubs] Drifters - 02 [1080p].mkv";
+
+test("a folder naming a language is read, whole segment or word", () => {
+  assert.equal(languageFromFolderNames(["ENG"])?.code, "en");
+  assert.equal(languageFromFolderNames(["Rus Sound"])?.code, "ru");
+  assert.equal(languageFromFolderNames(["Sub", "Russian"])?.code, "ru");
+  assert.equal(languageFromFolderNames([])?.code, undefined);
+});
+
+test("the innermost folder answers first", () => {
+  assert.equal(languageFromFolderNames(["Russian", "English Dub"])?.code, "en");
+});
+
+test("a two-letter word inside a longer folder name is not taken for a language", () => {
+  // "No" is Norwegian as a whole segment, but a word in `No Subs` is a word.
+  assert.equal(languageFromFolderNames(["No Subs"]), null);
+  assert.equal(languageFromFolderNames(["no"])?.code, "no");
+});
+
+test("a bracket the picture also carries is not the sidecar's author", () => {
+  assert.equal(
+    releaserFrom({
+      folders: ["Rus Sound"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].mka",
+      videoName: VIDEO_NAME
+    }),
+    null
+  );
+});
+
+test("a bracket only the sidecar carries is its author", () => {
+  assert.equal(
+    releaserFrom({
+      folders: ["Sub", "[Stan WarHammer & Nesitach]"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].ass",
+      videoName: VIDEO_NAME
+    }),
+    "Stan WarHammer & Nesitach"
+  );
+});
+
+test("a bracket describing the encode is never an author", () => {
+  for (const token of ["1080p", "x264", "HEVC", "WEB-DL", "AAC", "5.1", "10bit", "78EFD746", "RUS"]) {
+    assert.equal(
+      releaserFrom({ folders: [], fileName: `Film [${token}].mka`, videoName: "Other.mkv" }),
+      null,
+      `[${token}] should not be read as a releaser`
+    );
+  }
+});
+
+test("the innermost folder is preferred to the file name", () => {
+  assert.equal(
+    releaserFrom({ folders: ["[TeamA]"], fileName: "[TeamB] ep.ass", videoName: "ep.mkv" }),
+    "TeamA"
+  );
+});
+
+test("language and author together, for the field case", () => {
+  assert.deepEqual(
+    sidecarNaming({
+      folders: ["Rus Sound"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].mka",
+      videoName: VIDEO_NAME
+    }),
+    { code: "ru", name: "Russian", releaser: null, isForced: false, isHearingImpaired: false, isDefault: false }
+  );
+  assert.deepEqual(
+    sidecarNaming({
+      folders: ["Sub", "[Stan WarHammer & Nesitach]"],
+      fileName: "[HorribleSubs] Drifters - 02 [1080p].ass",
+      videoName: VIDEO_NAME
+    }),
+    {
+      code: null,
+      name: null,
+      releaser: "Stan WarHammer & Nesitach",
+      isForced: false,
+      isHearingImpaired: false,
+      isDefault: false
+    }
+  );
+});
+
+test("a subtitle file takes its author from the folder the release put it in", () => {
+  const info = readPath("Sub/[Stan WarHammer & Nesitach]/[HorribleSubs] Drifters - 02 [1080p].ass", VIDEO_NAME);
+  assert.equal(info.group, "Stan WarHammer & Nesitach");
+});
+
+test("the picture's own release group is never reported as the translator", () => {
+  const info = readPath("Sub/[HorribleSubs] Drifters - 02 [1080p].ass", VIDEO_NAME);
+  assert.equal(info.group, null);
+});
+
+test("the language of a subtitle folder is read where the whole segment is not a language", () => {
+  const info = readPath("Rus Sub/ep.srt", "ep.mkv");
+  assert.equal(info.code, "ru");
+});
+
+test("what the rules answer with nothing to go on", () => {
+  const info = readPath("ep.srt");
+  assert.equal(info.code, "und");
+  assert.equal(info.group, null);
+});

package/test/stale-request-after-seek.test.js

@@ -79,8 +79,8 @@ async function sessionWithRunAt373() {
     holdExplainedAt: new Map(),
     seekSettleTimer: null,
     seekTarget: null,
-    seekFailureTarget: -1,
-    seekFailureCount: 0,
+    failedStartAt: -1,
+    failedStartCount: 0,
     waitEpoch: 0,
     firstSegmentLogged: true,
     progress: { processedSeconds: RUN_STARTS_AT * SEGMENT_SECONDS, speed: "1.0x", startPositionSeconds: RUN_STARTS_AT * SEGMENT_SECONDS }

package/test/two-viewers-one-picture.test.js

@@ -114,8 +114,8 @@ async function pictureWithTwoViewers() {
   base.consumers = new Set([FIRST, SECOND]);
   // Both viewers are watching the picture, which is what keeps their choices
   // alive; a viewer whose head has expired holds no encoder.
-  viewerOf(base, FIRST).head = { segment: 3, seconds: 12, at: Date.now() };
-  viewerOf(base, SECOND).head = { segment: 3, seconds: 12, at: Date.now() };
+  viewerOf(base, FIRST).position = { segment: 3, seconds: 12, at: Date.now() };
+  viewerOf(base, SECOND).position = { segment: 3, seconds: 12, at: Date.now() };
   viewerOf(base, FIRST).audio = { trackIndex: 0, transcode: true };
   viewerOf(base, SECOND).audio = { trackIndex: 1, transcode: true };
   manager.sessionsById.set(BASE_ID, base);

package/test/viewer-outputs.test.js

@@ -83,8 +83,8 @@ function fakeSession({ id, dirPath, file, encodeHeight = 0, audioOnly = false, i
     }),
     encodeRunGeneration: 0,
     lastRestartAt: 0,
-    seekFailureTarget: -1,
-    seekFailureCount: 0,
+    failedStartAt: -1,
+    failedStartCount: 0,
     seekSettleTimer: null,
     seekTarget: null,
     waitEpoch: 0,
@@ -144,7 +144,7 @@ test("a viewer who steps down, back to the picture's own height and down again k
   startRunOn(base, { process: fakeEncoder() });
   const viewer = manager.viewers.of(base, VIEWER);
   viewer.audio = { trackIndex: 1, transcode: true };
-  viewer.head = { segment: 25, seconds: 100, at: Date.now() };
+  viewer.position = { segment: 25, seconds: 100, at: Date.now() };
 
   await manager.resolveVariantFile(BASE_ID, 540, "segment-00025.mp4", VIEWER);
   await manager.resolveVariantFile(BASE_ID, 812, "segment-00026.mp4", VIEWER);
@@ -165,7 +165,7 @@ test("a viewer leaving is subtracted from every output, and one nobody is left w
   t.after(() => rm(dirPath, { recursive: true, force: true }));
   // Watching all three, which is what a viewer who picked a language and a
   // quality is doing.
-  manager.viewers.of(base, VIEWER).head = { segment: 25, seconds: 100, at: Date.now() };
+  manager.viewers.of(base, VIEWER).position = { segment: 25, seconds: 100, at: Date.now() };
   manager.viewers.of(step, VIEWER);
   manager.viewers.of(audio, VIEWER);
   assert.deepEqual(
@@ -195,12 +195,12 @@ test("an output somebody else is still watching is kept when one viewer leaves",
   t.after(() => rm(dirPath, { recursive: true, force: true }));
   const second = "viewer-two";
   base.consumers.add(second);
-  manager.viewers.of(base, VIEWER).head = { segment: 25, seconds: 100, at: Date.now() };
+  manager.viewers.of(base, VIEWER).position = { segment: 25, seconds: 100, at: Date.now() };
   manager.viewers.of(step, VIEWER);
   manager.viewers.of(audio, VIEWER);
   // The second viewer is listening to the same soundtrack and watching the
   // picture at its own height.
-  manager.viewers.of(base, second).head = { segment: 25, seconds: 100, at: Date.now() };
+  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");
@@ -227,7 +227,7 @@ test("an output somebody else is still watching is kept when one viewer leaves",
 test("leaving an output releases what the watching claimed of production", async (t) => {
   const { manager, base, step, audio, dirPath, released } = await pictureWithStepAndSoundtrack();
   t.after(() => rm(dirPath, { recursive: true, force: true }));
-  manager.viewers.of(base, VIEWER).head = { segment: 25, seconds: 100, at: Date.now() };
+  manager.viewers.of(base, VIEWER).position = { segment: 25, seconds: 100, at: Date.now() };
   manager.viewers.of(step, VIEWER);
   manager.viewers.of(audio, VIEWER);
 

package/test/viewer-presence.test.js

@@ -0,0 +1,119 @@
+/**
+ * @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 { HlsSessionManager } from "../services/hls-session-manager.js";
+import { SourceFile } from "../services/source/SourceFile.js";
+import { Viewers } from "../services/viewer/Viewers.js";
+
+const PICTURE = "aaaaaaaa-0000-4000-8000-000000000001";
+const SOUND = "aaaaaaaa-0000-4000-8000-000000000002";
+
+/**
+ * @param {string} id
+ * @param {string} dirPath
+ * @returns {object}
+ */
+function outputOn(id, dirPath) {
+  return {
+    id,
+    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(),
+    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", viewers: new Map() };
+
+  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: new Map() };
+  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", viewers: new Map() };
+  const sound = { id: "sound", viewers: new Map() };
+  const byId = new Map([["picture", picture], ["sound", sound]]);
+
+  viewers.of(picture, "watcher");
+  viewers.of(sound, "watcher");
+  viewers.of(picture, "other");
+
+  const left = viewers.hasGone("watcher", (id) => byId.get(id) ?? null);
+
+  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.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 = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+
+  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.viewers.of(picture, "watcher");
+  manager.viewers.of(sound, "watcher");
+
+  const released = await manager.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({
+    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);
+});

package/test/viewer.test.js

@@ -18,25 +18,42 @@ import { Viewer, viewerOf, viewersOf } from "../services/viewer/Viewer.js";
 
 const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
 
-test("a viewer nobody has heard from is not watching", () => {
-  const viewer = new Viewer("someone");
+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(now, 60_000), true, "and they are still here");
+
+  viewer.seen(now - 10_000);
+  assert.equal(viewer.isPresent(now, 60_000), true);
+
+  // Silence longer than any a watching viewer can produce. This is a backstop
+  // for a connection that failed to say so, not the ordinary way of leaving.
+  viewer.seen(now - 120_000);
+  assert.equal(viewer.isPresent(now, 60_000), false);
 
-  assert.equal(viewer.isLive(now, 60_000), false, "no head at all: they have never asked");
-  viewer.head = { segment: 4, seconds: 16, at: now - 10_000 };
-  assert.equal(viewer.isLive(now, 60_000), true);
-  viewer.head = { segment: 4, seconds: 16, at: now - 120_000 };
-  assert.equal(viewer.isLive(now, 60_000), false, "the tab is gone and nothing released it");
+  // Something SAID they are gone. Then it does not matter how recently they
+  // were heard from.
+  viewer.seen(now);
+  viewer.gone = true;
+  assert.equal(viewer.isPresent(now, 60_000), false, "a statement outranks silence");
 });
 
 test("a stated position outranks the segment they last asked for", () => {
   const viewer = new Viewer("someone");
   assert.equal(viewer.positionSeconds(), null);
 
-  viewer.head = { segment: 10, seconds: 40, at: 1 };
+  viewer.position = { segment: 10, seconds: 40, at: 1 };
   assert.equal(viewer.positionSeconds(), 40, "where their player is reading");
 
-  viewer.head = { segment: 10, seconds: 40, at: 1, seeked: 900 };
+  viewer.position = { segment: 10, seconds: 40, at: 1, seeked: 900 };
   assert.equal(viewer.positionSeconds(), 900, "a seek is the viewer saying where they are");
 });
 
@@ -80,7 +97,7 @@ test("releasing a consumer forgets everything that was true of them alone", asyn
   const leaving = viewerOf(session, "leaving");
   leaving.audio = { trackIndex: 2, transcode: true };
   leaving.activeVariantId = "some-variant";
-  leaving.head = { segment: 40, seconds: 160, at: Date.now() };
+  leaving.position = { segment: 40, seconds: 160, at: Date.now() };
   viewerOf(session, "staying").audio = { trackIndex: 0, transcode: false };
 
   await manager.releaseSessionConsumer(SESSION_ID, "leaving", "the tab was closed");