@torrent-tv/proxy 2.87.10 → 2.87.12

package/test/resume-warm.test.js

@@ -1,39 +1,39 @@
-/**
- * @file Where a viewer's resume position falls in the file, in bytes.
- *
- * The warm-up fetches a file's two edges, because that is what the codec probe
- * reads. The region the VIEWER will resume at was asked for by nobody until the
- * encoder opened its input — field 2026-09-03, 53 s after the Retry button on a
- * cold torrent, and the piece it then needed took another 46.3 s to arrive.
- * Turning the position into an offset is the only arithmetic in that path, so it
- * is the only part with anything to get wrong.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { resumeByteOffset } from "../services/torrent/worker/resume-warm.js";
-
-test("a position halfway through a film is halfway through its file", () => {
-  assert.equal(resumeByteOffset(1000, 100, 50), 500);
-});
-
-test("the field case lands where the encoder went looking", () => {
-  // The measured session: 171.338 s into a 23:41 episode of 541 MB, and the
-  // read that blocked was at 63 MB.
-  const at = resumeByteOffset(541 * 1024 * 1024, 23 * 60 + 41, 171.338);
-  const megabytes = at / (1024 * 1024);
-  assert.ok(megabytes > 60 && megabytes < 68, `landed at ${megabytes.toFixed(1)}MB`);
-});
-
-test("a position past the end reads the end, rather than past it", () => {
-  const length = 1000;
-  const at = resumeByteOffset(length, 100, 10_000);
-  assert.equal(at, length - 1);
-});
-
-test("nothing is known, nothing is guessed", () => {
-  assert.equal(resumeByteOffset(0, 100, 50), 0, "no file length");
-  assert.equal(resumeByteOffset(1000, 0, 50), 0, "no duration — the container did not declare one");
-  assert.equal(resumeByteOffset(1000, 100, 0), 0, "the viewer is at the beginning, where the edges already are");
-});
+/**
+ * @file Where a viewer's resume position falls in the file, in bytes.
+ *
+ * The warm-up fetches a file's two edges, because that is what the codec probe
+ * reads. The region the VIEWER will resume at was asked for by nobody until the
+ * encoder opened its input — field 2026-09-03, 53 s after the Retry button on a
+ * cold torrent, and the piece it then needed took another 46.3 s to arrive.
+ * Turning the position into an offset is the only arithmetic in that path, so it
+ * is the only part with anything to get wrong.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { resumeByteOffset } from "../services/torrent/worker/resume-warm.js";
+
+test("a position halfway through a film is halfway through its file", () => {
+  assert.equal(resumeByteOffset(1000, 100, 50), 500);
+});
+
+test("the field case lands where the encoder went looking", () => {
+  // The measured session: 171.338 s into a 23:41 episode of 541 MB, and the
+  // read that blocked was at 63 MB.
+  const at = resumeByteOffset(541 * 1024 * 1024, 23 * 60 + 41, 171.338);
+  const megabytes = at / (1024 * 1024);
+  assert.ok(megabytes > 60 && megabytes < 68, `landed at ${megabytes.toFixed(1)}MB`);
+});
+
+test("a position past the end reads the end, rather than past it", () => {
+  const length = 1000;
+  const at = resumeByteOffset(length, 100, 10_000);
+  assert.equal(at, length - 1);
+});
+
+test("nothing is known, nothing is guessed", () => {
+  assert.equal(resumeByteOffset(0, 100, 50), 0, "no file length");
+  assert.equal(resumeByteOffset(1000, 0, 50), 0, "no duration — the container did not declare one");
+  assert.equal(resumeByteOffset(1000, 100, 0), 0, "the viewer is at the beginning, where the edges already are");
+});

package/test/run-graph-drift.test.js

@@ -1,37 +1,37 @@
-/**
- * @file The drawing cannot disagree with the table.
- *
- * `docs/encode-run-state.md` is generated from `services/encode/encode-run-state.js`.
- * A picture kept beside the code drifts — this repository has the receipts —
- * so the check is mechanical: regenerate it and compare. A behavioural change
- * to the table that forgets `npm run graph` fails here, in the same commit.
- */
-
-import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import test from "node:test";
-
-import { GRAPH_DOC_PATH, renderRunGraphMarkdown } from "../scripts/render-run-graph.js";
-
-/**
- * Line endings are not part of the comparison. Git is configured with
- * `autocrlf=true` on the machine this is developed on, so the same file is LF
- * in the index and CRLF in the working tree — and a test failing on that would
- * point at the generator, whose output is always LF, and be unfixable by the
- * remedy it suggests.
- *
- * @param {string} text
- * @returns {string}
- */
-function withoutLineEndings(text) {
-  return text.replace(/\r\n/g, "\n");
-}
-
-test("the committed picture is the one the table produces", () => {
-  const committed = readFileSync(GRAPH_DOC_PATH, "utf8");
-  assert.equal(
-    withoutLineEndings(committed),
-    withoutLineEndings(renderRunGraphMarkdown()),
-    "docs/encode-run-state.md is out of date — run `npm run graph` and commit the result"
-  );
-});
+/**
+ * @file The drawing cannot disagree with the table.
+ *
+ * `docs/encode-run-state.md` is generated from `services/encode/encode-run-state.js`.
+ * A picture kept beside the code drifts — this repository has the receipts —
+ * so the check is mechanical: regenerate it and compare. A behavioural change
+ * to the table that forgets `npm run graph` fails here, in the same commit.
+ */
+
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import test from "node:test";
+
+import { GRAPH_DOC_PATH, renderRunGraphMarkdown } from "../scripts/render-run-graph.js";
+
+/**
+ * Line endings are not part of the comparison. Git is configured with
+ * `autocrlf=true` on the machine this is developed on, so the same file is LF
+ * in the index and CRLF in the working tree — and a test failing on that would
+ * point at the generator, whose output is always LF, and be unfixable by the
+ * remedy it suggests.
+ *
+ * @param {string} text
+ * @returns {string}
+ */
+function withoutLineEndings(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+
+test("the committed picture is the one the table produces", () => {
+  const committed = readFileSync(GRAPH_DOC_PATH, "utf8");
+  assert.equal(
+    withoutLineEndings(committed),
+    withoutLineEndings(renderRunGraphMarkdown()),
+    "docs/encode-run-state.md is out of date — run `npm run graph` and commit the result"
+  );
+});

package/test/run-inputs.test.js

@@ -1,80 +1,80 @@
-/**
- * @file What an encoder is told to read.
- *
- * The encoder's own read of its source is the one read that tracks where the
- * viewer is (`reader=playback`), and the only one sized in seconds of playback
- * (`windowBytes`). Both travel on the input address. When the address stopped
- * being kept on the session and started being built per run, both were left
- * off it: every encoder read looked to the stream route like a probe, and the
- * read window fell back to the reader's default.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { encoderInputs } from "../services/encode/run-inputs.js";
-
-const BASE = "http://127.0.0.1:9090";
-
-function file(fileIndex) {
-  return {
-    fileIndex,
-    streamUrl(baseUrl, { sessionId = "" } = {}) {
-      const url = new URL("/stream", `${baseUrl}/`);
-      url.searchParams.set("fileIndex", String(fileIndex));
-      if (sessionId) {
-        url.searchParams.set("session", sessionId);
-      }
-      return url;
-    }
-  };
-}
-
-test("the picture's read says it is the playback read, with its window", () => {
-  const picture = file(0);
-  const { inputUrl } = encoderInputs({
-    picture,
-    soundtrack: picture,
-    carries: "video-only",
-    audioSeparate: true,
-    sessionId: "aaaaaaaabbbbcccc",
-    readWindowBytes: 32_000_000,
-    baseUrl: BASE
-  });
-  const url = new URL(inputUrl);
-  assert.equal(url.searchParams.get("reader"), "playback");
-  assert.equal(url.searchParams.get("windowBytes"), "32000000");
-  assert.equal(url.searchParams.get("session"), "aaaaaaaabbbbcccc");
-});
-
-test("with no window measured the read states neither parameter", () => {
-  const picture = file(0);
-  const { inputUrl } = encoderInputs({
-    picture,
-    soundtrack: picture,
-    carries: "muxed",
-    audioSeparate: false,
-    sessionId: "aaaaaaaabbbbcccc",
-    readWindowBytes: 0,
-    baseUrl: BASE
-  });
-  const url = new URL(inputUrl);
-  assert.equal(url.searchParams.get("windowBytes"), null);
-  assert.equal(url.searchParams.get("reader"), null, "exactly as before: both are set together or neither");
-});
-
-test("a soundtrack in its own file is read directly by its rendition, and is a second input only when muxed", () => {
-  const picture = file(0);
-  const dub = file(3);
-  const rendition = encoderInputs({
-    picture, soundtrack: dub, carries: "audio-only", audioSeparate: true,
-    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
-  });
-  assert.equal(new URL(rendition.inputUrl).searchParams.get("fileIndex"), "3");
-  assert.equal(rendition.audioInputUrl, "");
-  const muxed = encoderInputs({
-    picture, soundtrack: dub, carries: "muxed", audioSeparate: false,
-    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
-  });
-  assert.equal(new URL(muxed.inputUrl).searchParams.get("fileIndex"), "0");
-  assert.equal(new URL(muxed.audioInputUrl).searchParams.get("fileIndex"), "3");
-});
+/**
+ * @file What an encoder is told to read.
+ *
+ * The encoder's own read of its source is the one read that tracks where the
+ * viewer is (`reader=playback`), and the only one sized in seconds of playback
+ * (`windowBytes`). Both travel on the input address. When the address stopped
+ * being kept on the session and started being built per run, both were left
+ * off it: every encoder read looked to the stream route like a probe, and the
+ * read window fell back to the reader's default.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { encoderInputs } from "../services/encode/run-inputs.js";
+
+const BASE = "http://127.0.0.1:9090";
+
+function file(fileIndex) {
+  return {
+    fileIndex,
+    streamUrl(baseUrl, { sessionId = "" } = {}) {
+      const url = new URL("/stream", `${baseUrl}/`);
+      url.searchParams.set("fileIndex", String(fileIndex));
+      if (sessionId) {
+        url.searchParams.set("session", sessionId);
+      }
+      return url;
+    }
+  };
+}
+
+test("the picture's read says it is the playback read, with its window", () => {
+  const picture = file(0);
+  const { inputUrl } = encoderInputs({
+    picture,
+    soundtrack: picture,
+    carries: "video-only",
+    audioSeparate: true,
+    sessionId: "aaaaaaaabbbbcccc",
+    readWindowBytes: 32_000_000,
+    baseUrl: BASE
+  });
+  const url = new URL(inputUrl);
+  assert.equal(url.searchParams.get("reader"), "playback");
+  assert.equal(url.searchParams.get("windowBytes"), "32000000");
+  assert.equal(url.searchParams.get("session"), "aaaaaaaabbbbcccc");
+});
+
+test("with no window measured the read states neither parameter", () => {
+  const picture = file(0);
+  const { inputUrl } = encoderInputs({
+    picture,
+    soundtrack: picture,
+    carries: "muxed",
+    audioSeparate: false,
+    sessionId: "aaaaaaaabbbbcccc",
+    readWindowBytes: 0,
+    baseUrl: BASE
+  });
+  const url = new URL(inputUrl);
+  assert.equal(url.searchParams.get("windowBytes"), null);
+  assert.equal(url.searchParams.get("reader"), null, "exactly as before: both are set together or neither");
+});
+
+test("a soundtrack in its own file is read directly by its rendition, and is a second input only when muxed", () => {
+  const picture = file(0);
+  const dub = file(3);
+  const rendition = encoderInputs({
+    picture, soundtrack: dub, carries: "audio-only", audioSeparate: true,
+    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
+  });
+  assert.equal(new URL(rendition.inputUrl).searchParams.get("fileIndex"), "3");
+  assert.equal(rendition.audioInputUrl, "");
+  const muxed = encoderInputs({
+    picture, soundtrack: dub, carries: "muxed", audioSeparate: false,
+    sessionId: "s", readWindowBytes: 1000, baseUrl: BASE
+  });
+  assert.equal(new URL(muxed.inputUrl).searchParams.get("fileIndex"), "0");
+  assert.equal(new URL(muxed.audioInputUrl).searchParams.get("fileIndex"), "3");
+});

package/test/run-intervals.test.js

@@ -1,100 +1,100 @@
-/**
- * @file How far a run may work, and who decides it.
- *
- * These cases used to be asked of `planRunInterval`, a second authority inside
- * the session manager that answered by its own rules: it walked the whole track
- * for the first free number, MOVED the start there, and counted every live run
- * as claiming up to `head + look-ahead`. It contradicted the plan directly, and
- * the two together produced the field oscillation of 2026-09-05 — the plan
- * commanded a start at #46, this moved it to #78, the plan killed the run for
- * standing outside the window it had asked for, and the same start was
- * commanded again, 350-700ms per cycle, no segment ever produced, the viewer's
- * picture stopped for 125 seconds.
- *
- * It is gone. WHERE a run starts is the plan's decision and nothing moves it;
- * HOW FAR it may work is a fact of the one coverage map, and that is what these
- * cases now ask. The map is the same object the plan reads, so there is no
- * second set of rules for the two to disagree about.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-
-/** A stand-in for a run: the map identifies one by being it. */
-function run(name) {
-  return { name };
-}
-
-test("with nothing made, a run gets everything from where it was asked", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-
-  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
-  assert.equal(coverage.firstGapFrom(0), 0);
-});
-
-test("a run stops before material that is already made", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  coverage.setReady([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
-
-  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
-});
-
-test("a run stops before a stretch another live run was given", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const other = run("other");
-  coverage.claim(other, 40, 60);
-
-  assert.equal(coverage.freeRunFrom(0), 40, "0..39, and the other run's claim begins at 40");
-  assert.equal(coverage.firstGapFrom(45), 61, "the first thing nobody holds after it");
-});
-
-test("a run's own claim does not hold it back", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const mine = run("mine");
-  coverage.claim(mine, 40, 60);
-
-  assert.equal(
-    coverage.freeRunFrom(40, mine),
-    60,
-    "asked by the run that holds it, the stretch is its own to work through"
-  );
-});
-
-test("a run that has ended holds nothing back", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const dead = run("dead");
-  coverage.claim(dead, 40, 60);
-  coverage.release(dead);
-
-  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
-});
-
-test("what a dead run DID finish stays made", () => {
-  const coverage = new CoverageMap({ segmentCount: 100 });
-  const dead = run("dead");
-  coverage.claim(dead, 40, 60);
-  coverage.setReady([40, 41, 42]);
-  coverage.release(dead);
-
-  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
-});
-
-test("nothing left to make is answered with nothing", () => {
-  const coverage = new CoverageMap({ segmentCount: 5 });
-  coverage.setReady([0, 1, 2, 3, 4]);
-
-  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
-});
-
-test("a run without an end does not take the film away from a viewer further in", () => {
-  // The case that used to need a second authority's `head + look-ahead` guess.
-  // A run's claim is now the stretch the plan GAVE it, so a viewer opening the
-  // same film in the middle finds their own position free.
-  const coverage = new CoverageMap({ segmentCount: 1000 });
-  const first = run("first");
-  coverage.claim(first, 0, 499);
-
-  assert.equal(coverage.firstGapFrom(500), 500, "the second viewer's own position is free");
-  assert.equal(coverage.freeRunFrom(500), 500, "and everything from there to the end");
-});
+/**
+ * @file How far a run may work, and who decides it.
+ *
+ * These cases used to be asked of `planRunInterval`, a second authority inside
+ * the session manager that answered by its own rules: it walked the whole track
+ * for the first free number, MOVED the start there, and counted every live run
+ * as claiming up to `head + look-ahead`. It contradicted the plan directly, and
+ * the two together produced the field oscillation of 2026-09-05 — the plan
+ * commanded a start at #46, this moved it to #78, the plan killed the run for
+ * standing outside the window it had asked for, and the same start was
+ * commanded again, 350-700ms per cycle, no segment ever produced, the viewer's
+ * picture stopped for 125 seconds.
+ *
+ * It is gone. WHERE a run starts is the plan's decision and nothing moves it;
+ * HOW FAR it may work is a fact of the one coverage map, and that is what these
+ * cases now ask. The map is the same object the plan reads, so there is no
+ * second set of rules for the two to disagree about.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+/** A stand-in for a run: the map identifies one by being it. */
+function run(name) {
+  return { name };
+}
+
+test("with nothing made, a run gets everything from where it was asked", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+
+  assert.equal(coverage.freeRunFrom(0), 100, "the whole track is free");
+  assert.equal(coverage.firstGapFrom(0), 0);
+});
+
+test("a run stops before material that is already made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  coverage.setReady([10, 11, 12, 13, 14, 15, 16, 17, 18, 19]);
+
+  assert.equal(coverage.freeRunFrom(0), 10, "0..9, and it stops where 10 begins");
+});
+
+test("a run stops before a stretch another live run was given", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const other = run("other");
+  coverage.claim(other, 40, 60);
+
+  assert.equal(coverage.freeRunFrom(0), 40, "0..39, and the other run's claim begins at 40");
+  assert.equal(coverage.firstGapFrom(45), 61, "the first thing nobody holds after it");
+});
+
+test("a run's own claim does not hold it back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const mine = run("mine");
+  coverage.claim(mine, 40, 60);
+
+  assert.equal(
+    coverage.freeRunFrom(40, mine),
+    60,
+    "asked by the run that holds it, the stretch is its own to work through"
+  );
+});
+
+test("a run that has ended holds nothing back", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.release(dead);
+
+  assert.equal(coverage.freeRunFrom(0), 100, "what it did not finish is free again");
+});
+
+test("what a dead run DID finish stays made", () => {
+  const coverage = new CoverageMap({ segmentCount: 100 });
+  const dead = run("dead");
+  coverage.claim(dead, 40, 60);
+  coverage.setReady([40, 41, 42]);
+  coverage.release(dead);
+
+  assert.equal(coverage.firstGapFrom(40), 43, "a closed file is closed whoever made it");
+});
+
+test("nothing left to make is answered with nothing", () => {
+  const coverage = new CoverageMap({ segmentCount: 5 });
+  coverage.setReady([0, 1, 2, 3, 4]);
+
+  assert.equal(coverage.firstGapFrom(0), null, "and a run started here would only repeat somebody's work");
+});
+
+test("a run without an end does not take the film away from a viewer further in", () => {
+  // The case that used to need a second authority's `head + look-ahead` guess.
+  // A run's claim is now the stretch the plan GAVE it, so a viewer opening the
+  // same film in the middle finds their own position free.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const first = run("first");
+  coverage.claim(first, 0, 499);
+
+  assert.equal(coverage.firstGapFrom(500), 500, "the second viewer's own position is free");
+  assert.equal(coverage.freeRunFrom(500), 500, "and everything from there to the end");
+});