@torrent-tv/proxy 2.64.6 → 2.64.8

package/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 2.64.8
+
+- **New**: A backward restart says what it costs. Nothing already written is lost — every run keeps its own directory and the session serves the union of all of them — so the price of moving the encoder back is not the files; it is work about to be done twice, because the new run walks forward through segments the old one had already finished and ffmpeg cannot know they exist, and it is the viewer in front, who has nothing produced ahead of them until the run gets back to where it already was. Neither had ever been counted. The line now says how far back it went, how many of the segments it will walk through are already on disk, and the running totals for the session. This is the reading roadmap item 64 needs before a session is allowed more than one concurrent run: if a viewer is behind the head twice a week, that design does not earn its complexity.
+
+## 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.8",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/hls-session-manager.js

@@ -468,6 +468,10 @@ const BEHIND_HEAD_REPAIR_MS = 400;
 // Generous against that measurement, and far short of the hundreds of segments
 // a scan reaches.
 const BEHIND_HEAD_REPAIR_MAX_SEGMENTS = 60;
+// How far the accounting of a backward restart looks for work about to be done
+// twice. It runs on the restart path and a session an hour in has thousands of
+// segments; the figure is for a comparison, not an inventory.
+const BACKWARD_RESTART_SCAN_SEGMENTS = 300;
 // Hard cap on the total settle wait, measured from the first request of a
 // burst, so a still-moving scrubber cannot delay a genuine seek forever.
 const SEEK_SETTLE_MAX_MS = 1_000;
@@ -1257,6 +1261,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 +2440,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);
 
@@ -4660,6 +4703,10 @@ export class HlsSessionManager {
     // 0.54-1.47 s — does not account for it. Before rebuilding the hottest path
     // in the proxy on a guess, make each stage state its own cost.
     const restartEnteredAt = Date.now();
+    // Reads where the old run began BEFORE the new one overwrites it, and does
+    // not await: everything below is the restart path, which is measured in
+    // milliseconds and has been worked on twice to keep it that way.
+    this.#accountBackwardRestart(session, startIndex);
     // One directory per run. Two runs writing the same segment name at once
     // produce a file that is neither, which is the only reason a restart ever
     // had to wait for its predecessor to die.
@@ -7824,10 +7871,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)
@@ -9261,6 +9338,85 @@ export class HlsSessionManager {
     );
   }
 
+  /**
+   * What moving the encoder BACKWARDS costs, said out loud when it happens.
+   *
+   * Nothing already written is lost — every run keeps its own directory and
+   * {@link HlsSessionManager##findProducedFile} serves the union of all of them
+   * — so the price of a restart is not the files. It is two other things, and
+   * neither was ever counted:
+   *
+   *  - **work done twice.** The new run begins at the target and encodes
+   *    forward through segments the old run had already finished. ffmpeg cannot
+   *    know they exist, so it makes them again.
+   *  - **the viewer in front.** While the run walks back up to where it already
+   *    was, nothing new is being made ahead of them, and their cushion drains.
+   *
+   * Both are what decides whether a session should be allowed a SECOND
+   * concurrent run instead — roadmap item 64. That question cannot be answered
+   * from taste, and this is the reading it needs: how often it happens at all,
+   * how far back, and how much of the walk is a repeat.
+   *
+   * Nothing here is awaited by the caller. Everything below the call site is
+   * the restart path, which is measured in milliseconds and has been worked on
+   * twice to keep it that way; a reading that delays the thing it is reading
+   * about is not a reading. The figures that MUST be taken before the new run
+   * exists are taken synchronously, and only the file counting is left to run
+   * on its own — against the directories that existed at this instant, so what
+   * the new run is about to write cannot be counted as already there.
+   *
+   * @param {HlsSession} session
+   * @param {number} startIndex - Where the new run will begin.
+   * @returns {void}
+   */
+  #accountBackwardRestart(session, startIndex) {
+    const previousStart = session.encodeStartIndex;
+    if (!Number.isInteger(previousStart) || !Number.isInteger(startIndex) || startIndex >= previousStart) {
+      // A first run, or one moving forward. Neither costs anything here: a
+      // forward restart skips material it never made.
+      return;
+    }
+    const processed = Number(session.progress?.processedSeconds);
+    const head = Number.isFinite(processed)
+      ? Math.max(previousStart, this.#segmentIndexForTime(session, processed))
+      : previousStart;
+    // Bounded: a session an hour in has thousands of segments, and the count is
+    // for a comparison, not an inventory.
+    const last = Math.min(head, startIndex + BACKWARD_RESTART_SCAN_SEGMENTS);
+    const dirsBefore = this.#runDirs(session);
+    const accounting = session.backwardRestarts ?? { count: 0, segmentsBack: 0, worstBack: 0, remade: 0 };
+    accounting.count += 1;
+    accounting.segmentsBack += previousStart - startIndex;
+    accounting.worstBack = Math.max(accounting.worstBack, previousStart - startIndex);
+    session.backwardRestarts = accounting;
+
+    void (async () => {
+      let alreadyOnDisk = 0;
+      for (let index = startIndex; index <= last; index += 1) {
+        const fileName = session.segmentFormat.segmentFileName(index);
+        for (const dir of dirsBefore) {
+          try {
+            await access(path.join(dir, fileName));
+            alreadyOnDisk += 1;
+            break;
+          } catch {
+            // Not this run's; try an older one.
+          }
+        }
+      }
+      accounting.remade += alreadyOnDisk;
+      logger.info(
+        `transcode ${session.id} moving the encoder BACK from #${previousStart} to #${startIndex} ` +
+        `(head was #${head}): ${alreadyOnDisk} of the ${last - startIndex + 1} segment(s) it will walk through ` +
+        `are already on disk and will be made again, and nothing is produced ahead of #${head} until it gets ` +
+        `back there — ${accounting.count} backward restart(s) this session, worst ${accounting.worstBack} ` +
+        `segment(s) back, ${accounting.remade} segment(s) remade in total (roadmap 64)`
+      );
+    })().catch(() => {
+      // silent-ok: a reading that fails is not worth ending a restart over.
+    });
+  }
+
   /**
    * The directories runs have written into, newest first.
    *

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)}`
+    );
+  }
+});