@torrent-tv/proxy 2.83.7 → 2.84.0

package/test/seek-target-not-superseded.test.js

@@ -42,7 +42,7 @@ async function managerAfterSeek() {
     localBindHost: "127.0.0.1",
     localPort: 9090
   });
-  manager.sessionsById.set(SESSION_ID, {
+  const session = {
     id: SESSION_ID,
     dirPath,
     // Where this file is cut, held by the file. A fixture that stated it
@@ -66,9 +66,11 @@ async function managerAfterSeek() {
     segmentCount: 399,
     encodeStartIndex: SEGMENT_AT_SEEK,
     waitEpoch: 1,
-    furthestViewerSeconds: SEEK_TO_SECONDS,
     runState: "PRODUCING"
-  });
+  };
+  manager.sessionsById.set(SESSION_ID, session);
+  viewerOf(session, "").moveTo(SEEK_TO_SECONDS);
+  viewerOf(session, "").playing = false;
   return { manager, dirPath };
 }
 
@@ -141,15 +143,15 @@ test("the viewer who made the request is the one it is judged against", async ()
   const { manager, dirPath } = await managerAfterSeek();
   const session = manager.sessionsById.get(SESSION_ID);
   session.viewers = new Map();
-  // Two people watching one copied picture. The shared position belongs to the
-  // one in front — it is the furthest segment anybody asked for — and the one
-  // behind is a hundred segments back, waiting for a segment there.
+  // Two people watching one copied picture: one at the seek target, one a
+  // hundred segments back and waiting for a segment there. Asked about nobody
+  // in particular the answer is the FURTHEST of them, because what lies behind
+  // that one has already been made.
   const behind = SEGMENT_AT_SEEK - 100;
-  viewerOf(session, "behind").position = {
-    segment: behind,
-    seconds: behind * SEGMENT_SECONDS,
-    at: Date.now()
-  };
+  viewerOf(session, "behind").moveTo(behind * SEGMENT_SECONDS);
+  viewerOf(session, "behind").playing = false;
+  viewerOf(session, "ahead").moveTo(SEEK_TO_SECONDS);
+  viewerOf(session, "ahead").playing = false;
 
   assert.equal(
     manager.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`, "behind"),
@@ -159,7 +161,7 @@ test("the viewer who made the request is the one it is judged against", async ()
   assert.equal(
     manager.requestStillWanted(SESSION_ID, `segment-${String(behind).padStart(5, "0")}.mp4`),
     false,
-    "unnamed, it can only be judged against the shared position — which is the leader's"
+    "unnamed, it is judged against the furthest viewer, which is the leader"
   );
 
   await rm(dirPath, { recursive: true, force: true });

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

@@ -155,9 +155,8 @@ test("a request cannot move the viewer's position backwards", async (t) => {
   manager.requestSeek(SESSION_ID, 2083.4, "viewer-1");
   await manager.getFileStream(SESSION_ID, fmp4Format.segmentFileName(BEHIND_INDEX), { requestSeq: 1 });
 
-  assert.equal(
-    manager.viewers.get("viewer-1")?.positionSeconds(),
-    2083.4,
+  assert.ok(
+    Math.abs((manager.viewers.get("viewer-1")?.positionSeconds() ?? -1) - 2083.4) < 1,
     "a stale request must not rewrite what the viewer said about themselves"
   );
 });

package/test/viewer.test.js

@@ -1,108 +1,115 @@
-/**
- * @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/source/SourceFile.js";
-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 { Viewer, viewerOf, viewersOf } from "../services/viewer/Viewer.js";
-
-const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
-
-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);
-
-  // 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.position = { segment: 10, seconds: 40, at: 1 };
-  assert.equal(viewer.positionSeconds(), 40, "where their player is reading");
-
-  viewer.position = { segment: 10, seconds: 40, at: 1, seeked: 900 };
-  assert.equal(viewer.positionSeconds(), 900, "a seek is the viewer saying where they are");
-});
-
-test("asking for a viewer twice is the same viewer", () => {
-  const session = {};
-  const first = viewerOf(session, "one");
-  first.audio = { trackIndex: 3, transcode: false };
-
-  assert.equal(viewerOf(session, "one"), first);
-  assert.equal(viewerOf(session, "one").audio.trackIndex, 3);
-  assert.notEqual(viewerOf(session, "two"), first);
-  assert.equal(viewersOf(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 = new HlsSessionManager({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    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; },
-    consumers: new Set(["staying", "leaving"]),
-    viewers: new Map(),
-    lastAccessedAt: Date.now()
-  };
-  manager.sessionsById.set(SESSION_ID, session);
-
-  const leaving = viewerOf(session, "leaving");
-  leaving.audio = { trackIndex: 2, transcode: true };
-  leaving.activeVariantId = "some-variant";
-  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");
-
-  assert.equal(session.viewers.has("leaving"), false, "one deletion, not six");
-  assert.equal(session.viewers.has("staying"), true, "and it takes nobody else with it");
-  assert.equal(session.consumers.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/source/SourceFile.js";
+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 { Viewer, viewerOf, viewersOf } from "../services/viewer/Viewer.js";
+
+const SESSION_ID = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+
+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.moveTo(40, 1_000_000);
+  viewer.playing = false;
+  assert.equal(viewer.positionSeconds(1_000_000), 40);
+  assert.equal(viewer.positionSeconds(1_060_000), 40, "a stopped picture covers no film");
+
+  viewer.playing = true;
+  assert.equal(viewer.positionSeconds(1_010_000), 50, "a playing one covers a second a second");
+
+  // 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);
+});
+
+test("asking for a viewer twice is the same viewer", () => {
+  const session = {};
+  const first = viewerOf(session, "one");
+  first.audio = { trackIndex: 3, transcode: false };
+
+  assert.equal(viewerOf(session, "one"), first);
+  assert.equal(viewerOf(session, "one").audio.trackIndex, 3);
+  assert.notEqual(viewerOf(session, "two"), first);
+  assert.equal(viewersOf(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 = new HlsSessionManager({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: SESSION_ID,
+    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; },
+    consumers: new Set(["staying", "leaving"]),
+    viewers: new Map(),
+    lastAccessedAt: Date.now()
+  };
+  manager.sessionsById.set(SESSION_ID, session);
+
+  const leaving = viewerOf(session, "leaving");
+  leaving.audio = { trackIndex: 2, transcode: true };
+  leaving.activeVariantId = "some-variant";
+  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");
+
+  assert.equal(session.viewers.has("leaving"), false, "one deletion, not six");
+  assert.equal(session.viewers.has("staying"), true, "and it takes nobody else with it");
+  assert.equal(session.consumers.size, 1);
+});

package/utils/client-log-file.js

@@ -0,0 +1,151 @@
+/**
+ * @file Where a browser's own log lands: a file beside the proxy's, per session.
+ *
+ * WHY THIS EXISTS. Both halves of every failure this project investigates live
+ * in two places at once — what the proxy did, and what the page saw — and until
+ * now the second half went to the SERVER's standard output on the droplet.
+ * Every release recreates that container and destroys it. On 2026-09-13 a
+ * viewer reported a desync and a frozen picture, and the analysis ran on half
+ * the evidence for exactly this reason.
+ *
+ * Written here instead, next to the proxy's own log, on the same durable
+ * directory (`/data` on the addon host). One file per viewing session, named so
+ * the two halves join without guessing: the session's start, then the torrent.
+ */
+
+import { createWriteStream, mkdirSync, renameSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+/** One file may reach this before it is rotated. */
+const MAX_BYTES = 16 * 1024 * 1024;
+
+/**
+ * Make a name safe for a file and short enough to read in a directory listing.
+ *
+ * Deliberately strict: a torrent name is arbitrary bytes chosen by a stranger,
+ * and it is about to become a path.
+ *
+ * @param {string} value
+ * @param {number} max
+ * @returns {string}
+ */
+function safeName(value, max) {
+  const cleaned = String(value ?? "")
+    .replace(/[^\p{L}\p{N}._-]+/gu, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[-.]+|[-.]+$/g, "");
+  return cleaned.slice(0, max);
+}
+
+/**
+ * `2026-09-13T16:05:24.123Z` → `20260913-160524`, which sorts and reads.
+ *
+ * @param {string} iso
+ * @returns {string}
+ */
+function stamp(iso) {
+  const when = new Date(iso);
+  const at = Number.isNaN(when.getTime()) ? new Date() : when;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${at.getUTCFullYear()}${pad(at.getUTCMonth() + 1)}${pad(at.getUTCDate())}` +
+    `-${pad(at.getUTCHours())}${pad(at.getUTCMinutes())}${pad(at.getUTCSeconds())}`;
+}
+
+/**
+ * A sink that writes one session's browser lines to its own file.
+ *
+ * @param {string} proxyLogPath - The proxy's own log file; its directory is
+ *   used, so the two halves are always side by side.
+ * @returns {{ write: (session: object, lines: string[]) => void, close: () => void }}
+ */
+export function createClientLogFiles(proxyLogPath) {
+  const directory = typeof proxyLogPath === "string" && proxyLogPath.length > 0
+    ? dirname(proxyLogPath)
+    : "";
+  /** @type {Map<string, { stream: import("node:fs").WriteStream, path: string, bytes: number }>} */
+  const open = new Map();
+
+  /**
+   * The file for this session, opened on first use.
+   *
+   * Keyed by the session's own id rather than by the name, because the name
+   * gains the torrent the moment one is chosen and the earlier lines — the
+   * page opening, the proxy being chosen, a connection failing — belong to the
+   * same session and must not start a second file.
+   *
+   * @param {{ sessionId: string, startedAt: string, torrentName: string, infoHash: string }} session
+   * @returns {{ stream: import("node:fs").WriteStream, path: string, bytes: number } | null}
+   */
+  function fileFor(session) {
+    if (!directory) return null;
+    const key = session.sessionId;
+    const existing = open.get(key);
+    if (existing) return existing;
+    const film = session.torrentName
+      ? `${safeName(session.torrentName, 60)}-${safeName(session.infoHash, 8)}`
+      : "no-torrent-yet";
+    const path = join(directory, `client-${stamp(session.startedAt)}-${safeName(session.sessionId, 8)}-${film}.log`);
+    try {
+      mkdirSync(directory, { recursive: true });
+      const record = {
+        stream: createWriteStream(path, { flags: "a" }),
+        path,
+        bytes: statSync(path, { throwIfNoEntry: false })?.size ?? 0
+      };
+      // A file that stops being writable must not take the proxy down with it,
+      // and must not be retried on every line.
+      record.stream.on("error", () => open.delete(key));
+      open.set(key, record);
+      return record;
+    } catch {
+      return null;
+    }
+  }
+
+  return {
+    write(session, lines) {
+      const record = fileFor(session);
+      if (!record) return;
+      for (const line of lines) {
+        const text = `${line}\n`;
+        record.bytes += Buffer.byteLength(text);
+        record.stream.write(text);
+      }
+      if (record.bytes >= MAX_BYTES) {
+        try {
+          record.stream.end(() => {
+            try {
+              renameSync(record.path, `${record.path}.1`);
+            } catch {
+              // Renaming a file that has gone leaves nothing to do.
+            }
+          });
+        } catch {
+          // A rotation that cannot happen leaves the file growing, which is
+          // better than losing the session's log to an exception.
+        }
+        open.delete(session.sessionId);
+      }
+    },
+    /**
+     * Finish every open file.
+     *
+     * Awaitable, and that is not a convenience: a write stream opens and
+     * flushes asynchronously, so a process that ends without waiting loses the
+     * last lines of every session — which are the ones a crash is explained by.
+     *
+     * @returns {Promise<void>}
+     */
+    async close() {
+      const ending = [...open.values()].map((record) => new Promise((resolve) => {
+        try {
+          record.stream.end(resolve);
+        } catch {
+          resolve(undefined);
+        }
+      }));
+      open.clear();
+      await Promise.all(ending);
+    }
+  };
+}

package/test/viewer-position-on-open.test.js

@@ -1,92 +0,0 @@
-/**
- * @file Opening a file at a position puts the SOUND there too.
- *
- * The audio rendition is a session of its own, and where it starts is computed
- * from where the viewer is. That reading had three sources and only two were
- * consulted — a position seeked to, and the last segment this session served —
- * both of which are written by things that have not happened yet at the moment
- * a file is opened at a position. So the answer was zero.
- *
- * Field 2026-08-21, `Minions.and.Monsters.1080p.mkv` reopened from the address
- * bar at 52:07:
- *
- *   18:02:55.124  8ed85605  start=3130s  -ss 3125.25  -an -map 0:v:0 -c:v copy
- *   18:02:55.632  33b0b046  start=0s     no -ss       -vn -map 0:a:0 -c:a aac
- *
- * The picture went to segment #781, the sound to #0. The player asked both for
- * #782; the picture had it, the sound re-encoded 57.5 s of a 3130 s film in the
- * 45 s the request lasted and then answered 404 — shown to the viewer as "the
- * proxy accepted the request but sent no video".
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { resolveViewerPosition, viewerPositionSource } from "../services/hls-session-manager.js";
-
-test("a file opened at a position has its viewer at that position", () => {
-  // Nothing has been seeked and nothing served yet — the state at the instant
-  // the audio rendition is created.
-  assert.equal(resolveViewerPosition({ openedAt: 3130 }), 3130);
-});
-
-test("a seek beats everything else", () => {
-  assert.equal(
-    resolveViewerPosition({ seeked: 900, lastRequestedStart: 400, openedAt: 3130 }),
-    900
-  );
-});
-
-test("what has been served beats where the file was opened", () => {
-  // The opening position is the oldest of the three readings: once a segment
-  // has been served, that is where the reading is.
-  assert.equal(resolveViewerPosition({ lastRequestedStart: 400, openedAt: 3130 }), 400);
-});
-
-test("with nothing to go on the answer is the beginning", () => {
-  assert.equal(resolveViewerPosition({}), 0);
-  assert.equal(resolveViewerPosition({ seeked: 0, lastRequestedStart: 0, openedAt: 0 }), 0);
-  // Values that are not readings must not become one.
-  assert.equal(resolveViewerPosition({ seeked: Number.NaN, openedAt: Number.NaN }), 0);
-  assert.equal(resolveViewerPosition({ seeked: -5, openedAt: -5 }), 0);
-  assert.equal(resolveViewerPosition({ lastRequestedStart: null, openedAt: undefined }), 0);
-});
-
-/**
- * Which of the three answered is a separate question, and the audio start needs
- * it. A seek and a served segment are request edges — the picture is behind
- * them by however deep the viewer's buffer is, which is what the subtraction in
- * `#audioStartSecondsFor` converts. The opening position is not an edge: it is
- * where the session was made, nothing has been asked for since, and a browser
- * that has just opened holds nothing.
- *
- * Field 2026-08-31: a page opened at 588s, no report yet, and the whole 120 s
- * look-ahead was subtracted — the sound started at 460s and its first segment
- * took 38.8 s to appear against the picture's 8.4 s.
- */
-test("the reading says which of the three it came from", () => {
-  assert.equal(viewerPositionSource({ seeked: 900, lastRequestedStart: 400, openedAt: 3130 }), "seeked");
-  assert.equal(viewerPositionSource({ lastRequestedStart: 400, openedAt: 3130 }), "requested");
-  assert.equal(viewerPositionSource({ openedAt: 3130 }), "opened");
-  assert.equal(viewerPositionSource({}), "none");
-});
-
-test("the source agrees with the position, reading for reading", () => {
-  const readings = [
-    { seeked: 900, lastRequestedStart: 400, openedAt: 3130 },
-    { lastRequestedStart: 400, openedAt: 3130 },
-    { openedAt: 3130 },
-    { seeked: Number.NaN, openedAt: Number.NaN },
-    { seeked: -5, openedAt: -5 },
-    {}
-  ];
-  for (const reading of readings) {
-    const position = resolveViewerPosition(reading);
-    const source = viewerPositionSource(reading);
-    assert.equal(
-      source === "none",
-      position === 0,
-      `no source must mean no position, and the other way round: ${JSON.stringify(reading)}`
-    );
-  }
-});