@torrent-tv/proxy 2.87.20 → 2.88.0

package/test/segment-cut-times.test.js

@@ -1,63 +1,63 @@
-/**
- * The playlist and the real segments must describe the same thing.
- *
- * They did not. The playlist was built from the container index while ffmpeg
- * chose its own cut points from a target duration, and the two only ever agreed
- * by luck — on a field file the index listed 1902 keyframes, ffmpeg found about
- * twice as many, and segment #876 meant 1:26:50 to the player and roughly
- * minute 58 to ffmpeg. Seeks landed nowhere near where they were aimed.
- *
- * These tests pin the arithmetic that ties the two together.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { segmentCutTimesFrom } from "../services/encode/run-command.js";
-
-test("cut times are the interior boundaries, rebased on the run start", () => {
-  // Segments 0-10, 10-20, 20-30, 30-40 (file ends at 40).
-  const boundaries = [0, 10, 20, 30, 40];
-
-  assert.deepEqual(
-    segmentCutTimesFrom(boundaries, 0),
-    [10, 20, 30],
-    "from the start, the cuts are every boundary except 0 and the file end"
-  );
-
-  // Restarting at segment 2 means the run begins at 20 s; a cut at 30 s is 10 s
-  // into the run. Sending 30 would put it at 50 — `-segment_times` counts from
-  // the run, which is what made a seek land in the wrong place.
-  assert.deepEqual(
-    segmentCutTimesFrom(boundaries, 2),
-    [10],
-    "after a restart the times must be relative to where the run starts"
-  );
-});
-
-test("uneven, real-world boundaries survive the rebasing exactly", () => {
-  // Keyframes never land on round numbers; rounding here is what would push a
-  // cut past its keyframe and silently double a segment.
-  // Starting at segment 1 leaves segments 1, 2 and 3 — three segments, so two
-  // cuts between them, each measured from the run start at 10.427.
-  const boundaries = [0, 10.427, 20.854, 31.281, 41.708];
-  assert.deepEqual(segmentCutTimesFrom(boundaries, 1), [10.427, 20.854]);
-});
-
-test("boundaries that cannot serve are refused rather than half-used", () => {
-  assert.equal(segmentCutTimesFrom(null, 0), null);
-  assert.equal(segmentCutTimesFrom([], 0), null);
-  assert.equal(segmentCutTimesFrom([0], 0), null, "a single boundary describes no segment");
-  assert.equal(
-    segmentCutTimesFrom([0, 10, 20], 2),
-    null,
-    "a start index at or past the last boundary has no run to describe"
-  );
-});
-
-test("the final run has no interior cuts and asks for none", () => {
-  assert.deepEqual(
-    segmentCutTimesFrom([0, 10, 20], 1),
-    [],
-    "starting at the last segment leaves nothing to cut, which is not an error"
-  );
-});
+/**
+ * The playlist and the real segments must describe the same thing.
+ *
+ * They did not. The playlist was built from the container index while ffmpeg
+ * chose its own cut points from a target duration, and the two only ever agreed
+ * by luck — on a field file the index listed 1902 keyframes, ffmpeg found about
+ * twice as many, and segment #876 meant 1:26:50 to the player and roughly
+ * minute 58 to ffmpeg. Seeks landed nowhere near where they were aimed.
+ *
+ * These tests pin the arithmetic that ties the two together.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { segmentCutTimesFrom } from "../services/encode/run-command.js";
+
+test("cut times are the interior boundaries, rebased on the run start", () => {
+  // Segments 0-10, 10-20, 20-30, 30-40 (file ends at 40).
+  const boundaries = [0, 10, 20, 30, 40];
+
+  assert.deepEqual(
+    segmentCutTimesFrom(boundaries, 0),
+    [10, 20, 30],
+    "from the start, the cuts are every boundary except 0 and the file end"
+  );
+
+  // Restarting at segment 2 means the run begins at 20 s; a cut at 30 s is 10 s
+  // into the run. Sending 30 would put it at 50 — `-segment_times` counts from
+  // the run, which is what made a seek land in the wrong place.
+  assert.deepEqual(
+    segmentCutTimesFrom(boundaries, 2),
+    [10],
+    "after a restart the times must be relative to where the run starts"
+  );
+});
+
+test("uneven, real-world boundaries survive the rebasing exactly", () => {
+  // Keyframes never land on round numbers; rounding here is what would push a
+  // cut past its keyframe and silently double a segment.
+  // Starting at segment 1 leaves segments 1, 2 and 3 — three segments, so two
+  // cuts between them, each measured from the run start at 10.427.
+  const boundaries = [0, 10.427, 20.854, 31.281, 41.708];
+  assert.deepEqual(segmentCutTimesFrom(boundaries, 1), [10.427, 20.854]);
+});
+
+test("boundaries that cannot serve are refused rather than half-used", () => {
+  assert.equal(segmentCutTimesFrom(null, 0), null);
+  assert.equal(segmentCutTimesFrom([], 0), null);
+  assert.equal(segmentCutTimesFrom([0], 0), null, "a single boundary describes no segment");
+  assert.equal(
+    segmentCutTimesFrom([0, 10, 20], 2),
+    null,
+    "a start index at or past the last boundary has no run to describe"
+  );
+});
+
+test("the final run has no interior cuts and asks for none", () => {
+  assert.deepEqual(
+    segmentCutTimesFrom([0, 10, 20], 1),
+    [],
+    "starting at the last segment leaves nothing to cut, which is not an error"
+  );
+});

package/test/segment-demand.test.js

@@ -1,80 +1,80 @@
-/**
- * @file What is wanted of one output, in its own segment numbers.
- *
- * The class held a window per viewer per band and merged them itself. That was
- * the priority layer's work done a second time in the wrong place, and it
- * carried the viewer's name as the key of a claim — against the rule that the
- * encoding and the viewer are not connected at all. The behaviours those checks
- * pinned (a viewer's own bands, two viewers as a union) are the priority map's
- * and are checked there.
- *
- * What is left is a holder: one map per output, replaced whole, and an empty one
- * meaning nobody is coming.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SegmentDemand } from "../services/encode/SegmentDemand.js";
-
-const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-const SOUND = "torrent:abc:fmt=fmp4:grid=kf@0:audio-only:a=0/0/aac";
-
-test("an output nothing has been said about wants nothing", () => {
-  const demand = new SegmentDemand();
-  assert.deepEqual(demand.mapOn(PICTURE), []);
-  assert.deepEqual(demand.addresses(), []);
-});
-
-test("a map replaces whatever was wanted before, rather than adding to it", () => {
-  // The map is a statement of what is wanted NOW, built fresh each time from
-  // where the viewers are. Accumulating them would keep serving people who have
-  // moved or gone.
-  const demand = new SegmentDemand();
-  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
-  demand.state(PICTURE, [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
-  assert.deepEqual(demand.mapOn(PICTURE), [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
-});
-
-test("an empty map is a statement, and it is kept as one", () => {
-  // It says nobody is coming anywhere in this output, which is what stops the
-  // encoders on it. Dropped instead of stored, the output would look like one
-  // nothing had ever been said about, and the last map with people in it would
-  // stand as current.
-  const demand = new SegmentDemand();
-  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
-  demand.state(PICTURE, []);
-  assert.deepEqual(demand.mapOn(PICTURE), []);
-  assert.deepEqual(demand.addresses(), [PICTURE], "the output is still one that has been spoken about");
-});
-
-test("each output holds its own map", () => {
-  // Two outputs of one film are cut independently — 454 pieces against 401 on
-  // the field file — so the same second is a different number in each, and one
-  // map cannot serve both.
-  const demand = new SegmentDemand();
-  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
-  demand.state(SOUND, [{ from: 88, to: 115, priority: 32, withinSeconds: 0 }]);
-  assert.equal(demand.mapOn(PICTURE)[0].from, 100);
-  assert.equal(demand.mapOn(SOUND)[0].from, 88);
-  assert.deepEqual(demand.addresses().sort(), [SOUND, PICTURE].sort());
-});
-
-test("an output can be forgotten entirely", () => {
-  const demand = new SegmentDemand();
-  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
-  demand.forget(PICTURE);
-  assert.deepEqual(demand.addresses(), []);
-});
-
-test("nothing about a viewer can be stated, because nothing about one is held", () => {
-  // The check that the rule holds by construction: there is no name to pass and
-  // no way to ask about one.
-  const demand = new SegmentDemand();
-  assert.equal(typeof (/** @type {any} */ (demand).want), "undefined");
-  assert.equal(typeof (/** @type {any} */ (demand).windowsOn), "undefined");
-  assert.equal(
-    demand.state.length,
-    2,
-    "an address and a map, and nothing else"
-  );
-});
+/**
+ * @file What is wanted of one output, in its own segment numbers.
+ *
+ * The class held a window per viewer per band and merged them itself. That was
+ * the priority layer's work done a second time in the wrong place, and it
+ * carried the viewer's name as the key of a claim — against the rule that the
+ * encoding and the viewer are not connected at all. The behaviours those checks
+ * pinned (a viewer's own bands, two viewers as a union) are the priority map's
+ * and are checked there.
+ *
+ * What is left is a holder: one map per output, replaced whole, and an empty one
+ * meaning nobody is coming.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { SegmentDemand } from "../services/encode/SegmentDemand.js";
+
+const PICTURE = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
+const SOUND = "torrent:abc:fmt=fmp4:grid=kf@0:audio-only:a=0/0/aac";
+
+test("an output nothing has been said about wants nothing", () => {
+  const demand = new SegmentDemand();
+  assert.deepEqual(demand.mapOn(PICTURE), []);
+  assert.deepEqual(demand.addresses(), []);
+});
+
+test("a map replaces whatever was wanted before, rather than adding to it", () => {
+  // The map is a statement of what is wanted NOW, built fresh each time from
+  // where the viewers are. Accumulating them would keep serving people who have
+  // moved or gone.
+  const demand = new SegmentDemand();
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(PICTURE, [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
+  assert.deepEqual(demand.mapOn(PICTURE), [{ from: 500, to: 530, priority: 32, withinSeconds: 0 }]);
+});
+
+test("an empty map is a statement, and it is kept as one", () => {
+  // It says nobody is coming anywhere in this output, which is what stops the
+  // encoders on it. Dropped instead of stored, the output would look like one
+  // nothing had ever been said about, and the last map with people in it would
+  // stand as current.
+  const demand = new SegmentDemand();
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(PICTURE, []);
+  assert.deepEqual(demand.mapOn(PICTURE), []);
+  assert.deepEqual(demand.addresses(), [PICTURE], "the output is still one that has been spoken about");
+});
+
+test("each output holds its own map", () => {
+  // Two outputs of one film are cut independently — 454 pieces against 401 on
+  // the field file — so the same second is a different number in each, and one
+  // map cannot serve both.
+  const demand = new SegmentDemand();
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.state(SOUND, [{ from: 88, to: 115, priority: 32, withinSeconds: 0 }]);
+  assert.equal(demand.mapOn(PICTURE)[0].from, 100);
+  assert.equal(demand.mapOn(SOUND)[0].from, 88);
+  assert.deepEqual(demand.addresses().sort(), [SOUND, PICTURE].sort());
+});
+
+test("an output can be forgotten entirely", () => {
+  const demand = new SegmentDemand();
+  demand.state(PICTURE, [{ from: 100, to: 130, priority: 32, withinSeconds: 0 }]);
+  demand.forget(PICTURE);
+  assert.deepEqual(demand.addresses(), []);
+});
+
+test("nothing about a viewer can be stated, because nothing about one is held", () => {
+  // The check that the rule holds by construction: there is no name to pass and
+  // no way to ask about one.
+  const demand = new SegmentDemand();
+  assert.equal(typeof (/** @type {any} */ (demand).want), "undefined");
+  assert.equal(typeof (/** @type {any} */ (demand).windowsOn), "undefined");
+  assert.equal(
+    demand.state.length,
+    2,
+    "an address and a map, and nothing else"
+  );
+});

package/test/segment-hold-supersede.test.js

@@ -1,91 +1,91 @@
-/**
- * @file A held segment request must not outlive the position it was made for.
- *
- * hls.js keeps ONE fragment load outstanding. So a request being held for a
- * segment blocks the request for wherever the viewer has just moved to, and our
- * route held each one for 60 s. Measured 2026-08-04: a backward seek into fully
- * downloaded data waited 57 s for a held request for `#609` to run out its
- * timer, and the segment the viewer actually wanted was then served in 15 ms.
- *
- * `research/hls-seek-prior-art-2026-08-02.md` prescribed this guard from
- * `hls-media-server` — one outstanding wait per session — and it was never
- * built.
- *
- * WHAT IS LEFT HERE IS THE ROUTE'S OWN BEHAVIOUR: a segment that arrives while
- * a request is held must still be served. The release itself moved to
- * `test/seek-frees-the-viewers-requests.test.js`, and the check that stood here
- * is why: it replaced `waitForSegment` with a function returning true and moved
- * the epoch by hand, so it described the route against a stand-in and passed
- * for months while no seek moved that epoch at all.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { handleTranscodeSessionFileGet } from "../routes/transcode/session-file/get.js";
-
-/**
- * A reply that records what the route answered.
- *
- * @returns {{ reply: object, sent: { code: number, headers: Record<string, string>, body: unknown } }}
- */
-function recordingReply() {
-  const sent = { code: 200, headers: {}, body: undefined };
-  const reply = {
-    code(value) {
-      sent.code = value;
-      return reply;
-    },
-    header(name, value) {
-      sent.headers[name.toLowerCase()] = String(value);
-      return reply;
-    },
-    send(body) {
-      sent.body = body;
-      return reply;
-    }
-  };
-  return { reply, sent };
-}
-
-/**
- * What the file route asks of the viewer operations besides the hold itself:
- * whether the request's generation is still taken, the record of what answered
- * it, and the hold a response keeps. Everything is taken and recorded nowhere,
- * because these checks are about the hold.
- *
- * @param {object} serving
- * @returns {object}
- */
-const routeViewerRequests = (serving) => ({
-  ...serving,
-  acceptsRequest: () => true,
-  noteAnsweredDirectly: () => {},
-  holdResponse: () => () => {}
-});
-
-const request = (fileName) => ({
-  params: { sessionId: "1111111122223333", fileName },
-  raw: { on() {}, off() {} }
-});
-
-test("without a seek the request is still held until the segment appears", async () => {
-  let polls = 0;
-  const serving = {
-    seekEpoch: () => 7,
-    // The segment is published between polls.
-    waitForSegment: async () => true,
-    async getFileStream() {
-      polls += 1;
-      if (polls < 3) {
-        return { kind: "warming-up" };
-      }
-      return { kind: "ok", contentType: "video/mp4", stream: "bytes", isPlaylist: false };
-    }
-  };
-
-  const { reply, sent } = recordingReply();
-  await handleTranscodeSessionFileGet(request("segment-00610.mp4"), reply, { serving: serving, viewerRequests: routeViewerRequests(serving) });
-
-  assert.equal(sent.body, "bytes", "a segment that arrives late must still be served");
-  assert.equal(sent.headers["content-type"], "video/mp4");
-});
+/**
+ * @file A held segment request must not outlive the position it was made for.
+ *
+ * hls.js keeps ONE fragment load outstanding. So a request being held for a
+ * segment blocks the request for wherever the viewer has just moved to, and our
+ * route held each one for 60 s. Measured 2026-08-04: a backward seek into fully
+ * downloaded data waited 57 s for a held request for `#609` to run out its
+ * timer, and the segment the viewer actually wanted was then served in 15 ms.
+ *
+ * `research/hls-seek-prior-art-2026-08-02.md` prescribed this guard from
+ * `hls-media-server` — one outstanding wait per session — and it was never
+ * built.
+ *
+ * WHAT IS LEFT HERE IS THE ROUTE'S OWN BEHAVIOUR: a segment that arrives while
+ * a request is held must still be served. The release itself moved to
+ * `test/seek-frees-the-viewers-requests.test.js`, and the check that stood here
+ * is why: it replaced `waitForSegment` with a function returning true and moved
+ * the epoch by hand, so it described the route against a stand-in and passed
+ * for months while no seek moved that epoch at all.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleTranscodeSessionFileGet } from "../routes/transcode/session-file/get.js";
+
+/**
+ * A reply that records what the route answered.
+ *
+ * @returns {{ reply: object, sent: { code: number, headers: Record<string, string>, body: unknown } }}
+ */
+function recordingReply() {
+  const sent = { code: 200, headers: {}, body: undefined };
+  const reply = {
+    code(value) {
+      sent.code = value;
+      return reply;
+    },
+    header(name, value) {
+      sent.headers[name.toLowerCase()] = String(value);
+      return reply;
+    },
+    send(body) {
+      sent.body = body;
+      return reply;
+    }
+  };
+  return { reply, sent };
+}
+
+/**
+ * What the file route asks of the viewer operations besides the hold itself:
+ * whether the request's generation is still taken, the record of what answered
+ * it, and the hold a response keeps. Everything is taken and recorded nowhere,
+ * because these checks are about the hold.
+ *
+ * @param {object} serving
+ * @returns {object}
+ */
+const routeViewerRequests = (serving) => ({
+  ...serving,
+  acceptsRequest: () => true,
+  noteAnsweredDirectly: () => {},
+  holdResponse: () => () => {}
+});
+
+const request = (fileName) => ({
+  params: { sessionId: "1111111122223333", fileName },
+  raw: { on() {}, off() {} }
+});
+
+test("without a seek the request is still held until the segment appears", async () => {
+  let polls = 0;
+  const serving = {
+    seekEpoch: () => 7,
+    // The segment is published between polls.
+    waitForSegment: async () => true,
+    async getFileStream() {
+      polls += 1;
+      if (polls < 3) {
+        return { kind: "warming-up" };
+      }
+      return { kind: "ok", contentType: "video/mp4", stream: "bytes", isPlaylist: false };
+    }
+  };
+
+  const { reply, sent } = recordingReply();
+  await handleTranscodeSessionFileGet(request("segment-00610.mp4"), reply, { serving: serving, viewerRequests: routeViewerRequests(serving) });
+
+  assert.equal(sent.body, "bytes", "a segment that arrives late must still be served");
+  assert.equal(sent.headers["content-type"], "video/mp4");
+});