@torrent-tv/proxy 2.64.6 → 2.64.7

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.64.7
+
+- **Fix**: A file opened at a position starts its SOUND at that position. The audio rendition's start is worked out from the picture's read head less the buffer the viewer reports holding — sound, because a read head is the furthest request of any viewer and the picture sits behind it by however deep that buffer is. At a cold open there is no report yet, and the fallback subtracted the WHOLE 120 s look-ahead from a buffer that does not exist: field 2026-08-31, a page opened at 588 s started its sound at 460 s, 131 seconds of film nobody would hear, and the segment the viewer needed took 38.8 s to appear against the picture's 8.4 s — the audio encoder healthy at 2.3-3.1x throughout, simply given a running start it did not need. The reading now says WHICH of its three sources answered (`viewerPositionSource`): a seek and a served segment are request edges and keep the subtraction, while the opening position is not an edge — nothing has been asked for since the session was made, and a browser that has just opened holds nothing by construction (`research/cold-open-audio-start-2026-08-31.md`).
+- **Fix**: The first encode run is positioned from the position the viewer ASKED for, not from the figure rounded to ten seconds. That rounding exists to answer one question — whether two viewers share a session — and `Math.round` can move a position FORWARD: 588 s became 590 s, which falls in segment #85 while the viewer at 588 s is inside #84. The player asked for a segment behind the run, the run was restarted onto it, and the 4.5 s it had already produced were thrown away.
+
 ## 2.64.6
 
 - **New**: The torrent worker reads its own memory once a SECOND, and writes a line only when something moved. A minute cannot see what kills it: three times — 2026-08-30 14:00 and 23:19, 2026-08-31 13:27 — the worker's own line read `heap=28-36MB`, and by the sample after next the thread had been terminated for reaching its heap ceiling, with the whole rise fitting inside a single sixty-second gap. The reading and the line are now separate cadences: taken every second, written when the heap has moved by 25 MB or when a quiet minute is up, so a healthy session costs the same one line a minute it costs today and a runaway is a curve rather than a step.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.64.6",
+  "version": "2.64.7",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/hls-session-manager.js

@@ -1257,6 +1257,34 @@ function headsOf(session) {
   return session.consumerHeads;
 }
 
+/**
+ * WHICH of the three readings answered, which is a different question from what
+ * the answer was.
+ *
+ * It matters for one thing: `openedAt` is not a request edge. The other two are
+ * — a seek and a requested segment are both places a viewer has moved to while
+ * holding a buffer, so the picture is behind them by however deep that buffer
+ * is. `openedAt` is where a session was created and nothing has been asked for
+ * since, so the picture is exactly there and there is nothing to subtract.
+ * Reading the number without knowing which of the three it was is what started
+ * a cold open's audio two minutes early on 2026-08-31.
+ *
+ * @param {{ seeked?: number, lastRequestedStart?: number | null, openedAt?: number }} readings
+ * @returns {"seeked" | "requested" | "opened" | "none"}
+ */
+export function viewerPositionSource({ seeked, lastRequestedStart, openedAt }) {
+  if (Number.isFinite(seeked) && seeked > 0) {
+    return "seeked";
+  }
+  if (Number.isFinite(lastRequestedStart) && lastRequestedStart > 0) {
+    return "requested";
+  }
+  if (Number.isFinite(openedAt) && openedAt > 0) {
+    return "opened";
+  }
+  return "none";
+}
+
 export function resolveViewerPosition({ seeked, lastRequestedStart, openedAt }) {
   if (Number.isFinite(seeked) && seeked > 0) {
     return seeked;
@@ -2408,8 +2436,19 @@ export class HlsSessionManager {
     // asked for #152, and 45 s later the browser gave up with "no data arrived
     // from the proxy" while the transcode ran happily at 9.9x through the
     // opening credits.
-    const firstIndex = normalizedStartPosition > 0
-      ? this.#segmentIndexForTime(session, normalizedStartPosition)
+    // From what the viewer ASKED for, not from the rounded figure. The rounding
+    // exists to answer one question — is this the same session as somebody
+    // else's — and it is the wrong number for this one, because `Math.round`
+    // can move the position FORWARD: 588s became 590s, which falls in segment
+    // #85 while the viewer at 588s is inside #84. The player then asked for a
+    // segment behind the run, the run was restarted onto it, and the 4.5s it
+    // had produced were thrown away (field 2026-08-31,
+    // `research/cold-open-audio-start-2026-08-31.md`).
+    const requestedStart = Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+      ? startPositionSeconds
+      : 0;
+    const firstIndex = requestedStart > 0
+      ? this.#segmentIndexForTime(session, requestedStart)
       : 0;
     await this.#startEncodeRun(session, firstIndex);
 
@@ -7824,10 +7863,40 @@ export class HlsSessionManager {
       // would start the run where no request can ever reach it.
       return Math.max(0, Math.min(earliestStated, readHead) - this.segmentDurationSec);
     }
+    if (this.#viewerPositionSourceOf(watching) === "opened") {
+      // The session has not started. Nobody has seeked, nobody has asked for a
+      // segment, and nobody has reported anything — so the read head is not a
+      // request edge at all, it is where the viewer opened, and a browser that
+      // has just opened holds no buffer by construction. Subtracting one here
+      // is not erring "early, the cheap direction": it is the whole of the
+      // start-up cost. Field 2026-08-31: a page opened at 588s started its
+      // sound at 460s, 131 seconds of film nobody would hear, and the segment
+      // the viewer needed took 38.8s to appear against the picture's 8.4s
+      // (`research/cold-open-audio-start-2026-08-31.md`).
+      return Math.max(0, readHead - this.segmentDurationSec);
+    }
     const buffered = deepestBuffer === null ? LOOKAHEAD_PAUSE_SECONDS : deepestBuffer;
     return Math.max(0, readHead - buffered - this.segmentDurationSec);
   }
 
+  /**
+   * Which reading gave this session's viewer position — see
+   * {@link viewerPositionSource}.
+   *
+   * @param {HlsSession} session
+   * @returns {"seeked" | "requested" | "opened" | "none"}
+   */
+  #viewerPositionSourceOf(session) {
+    const lastRequestedStart = Number.isInteger(session.lastRequestedSegment) && session.lastRequestedSegment > 0
+      ? this.#segmentStartTime(session, session.lastRequestedSegment)
+      : null;
+    return viewerPositionSource({
+      seeked: session.viewerPositionSeconds,
+      lastRequestedStart,
+      openedAt: session.progress?.startPositionSeconds
+    });
+  }
+
   #viewerPositionOf(session) {
     const lastRequestedStart = Number.isInteger(session.lastRequestedSegment) && session.lastRequestedSegment > 0
       ? this.#segmentStartTime(session, session.lastRequestedSegment)

package/test/quality-variants.test.js

@@ -1071,3 +1071,42 @@ test("a rung is never served from the COPY, whatever height the copy happens to
 
   assert.equal(asked.id, VARIANT_ID, "the re-encoded rung is its own session, not the copy");
 });
+
+test("a file opened at a position starts its sound THERE, not a look-ahead earlier", async (t) => {
+  const { manager, base, dirPath } = await managerWithBase();
+  t.after(async () => {
+    await manager.disposeAll();
+    await rm(dirPath, { recursive: true, force: true });
+  });
+  base.audioSeparate = true;
+  // The state at the instant a page is opened at a position: nothing seeked,
+  // no segment served, no report from anybody. The read head is then not a
+  // request edge — it is where the session was made — and a browser that has
+  // just opened holds no buffer at all.
+  base.viewerPositionSeconds = null;
+  base.lastRequestedSegment = null;
+  base.netReports.clear();
+  base.progress.startPositionSeconds = 588;
+  manager.getCachedAudioTracks = () => [
+    { index: 0, language: "rus", title: "", isDefault: true },
+    { index: 1, language: "eng", title: "", isDefault: false }
+  ];
+  const created = [];
+  manager.createOrGetSession = async (params) => {
+    created.push(params);
+    const rendition = fakeSession({ id: VARIANT_ID, encodeHeight: 0, dirPath });
+    rendition.audioOnly = true;
+    return { sessionId: VARIANT_ID, session: rendition };
+  };
+
+  await manager.resolveAudioRenditionFile(BASE_ID, 1, "segment-00010.mp4");
+
+  // Field 2026-08-31: this answered 460 for a page opened at 588 — the whole
+  // 120 s look-ahead subtracted from a buffer that did not exist — and the
+  // segment the viewer needed took 38.8 s to appear against the picture's 8.4 s.
+  assert.equal(
+    created[0].startPositionSeconds,
+    584,
+    "where the viewer opened, less one segment of margin, and nothing else"
+  );
+});

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

@@ -22,7 +22,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { resolveViewerPosition } from "../services/hls-session-manager.js";
+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
@@ -51,3 +51,42 @@ test("with nothing to go on the answer is the beginning", () => {
   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)}`
+    );
+  }
+});