@torrent-tv/proxy 2.78.0 → 2.80.0

package/test/encode-plan.test.js

@@ -14,7 +14,19 @@ import { endOfRun } from "../services/encode/EncodeRun.js";
 import { firstUnmetWant, planEncoders } from "../services/encode/EncodePlan.js";
 
 /** A host that can afford two encoders, four-second segments, a cheap restart. */
-const HOST = { maxRuns: 2, segmentSeconds: 4, restartCostSec: 0.12 };
+// A host that has measured itself: the start and the death from its own runs,
+// and what the swarm charges to fetch a second of film again. All four terms
+// have to be present for the drive-or-move comparison to mean anything, and a
+// host missing any of them keeps its encoders instead — which is its own check
+// below rather than the shape every other check is written against.
+const HOST = {
+  maxRuns: 2,
+  segmentSeconds: 4,
+  restartCostSec: 0.12,
+  killCostSec: 0.5,
+  firstByteWaitSec: 1,
+  refetchSecPerFilmSecond: 0.25
+};
 
 /**
  * @param {Partial<import("../services/encode/EncodePlan.js").LiveRun>} run
@@ -121,9 +133,13 @@ test("a covered stretch shorter than a restart is driven through instead", () =>
   assert.ok(actions.some((action) => action.type === "keep" && action.run === runA));
 });
 
-test("a run whose speed nothing has measured is moved rather than left driving through", () => {
-  // Not a default: driving through is work that is certainly wasted, and the
-  // restart is a known and small cost. What cannot be done is the comparison.
+test("a run whose speed nothing has measured is kept, not taken away", () => {
+  // Moving costs a known amount for an unknown gain, and a run nothing has
+  // measured has produced nothing yet — so taking its work away is certainly a
+  // loss and the comparison cannot be made. It used to answer the other way,
+  // and then every just-started run was moved the moment anything ahead of it
+  // was covered, which, once the film ahead had been made, was always: 684
+  // starts in 482 seconds in the field on 2026-09-05.
   const coverage = new CoverageMap({ segmentCount: 100 });
   const runA = run({ head: 10, speedX: 0 });
   coverage.claim(runA, 0, 100);
@@ -134,9 +150,55 @@ test("a run whose speed nothing has measured is moved rather than left driving t
     runs: [runA],
     ...HOST
   });
+  assert.equal(actions.some((action) => action.type === "move"), false);
+  assert.ok(actions.some((action) => action.type === "keep" && action.run === runA));
+});
+
+test("both sides of the move are counted, not just the encoder's own time", () => {
+  // Driving through costs this run's encode time AND the swarm the same bytes a
+  // second time; moving costs the death, the start and the wait for the first
+  // bytes. Here driving is dear enough to lose: 20 covered segments of 4 s at
+  // 1x is 80 s of encoding, against a move priced at 0.12 + 0.5 + 3 seconds.
+  const coverage = new CoverageMap({ segmentCount: 200 });
+  const runA = run({ head: 10, speedX: 1 });
+  coverage.claim(runA, 0, 200);
+  for (let at = 10; at < 30; at += 1) {
+    coverage.markReady(at);
+  }
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 0, to: 190 }],
+    runs: [runA],
+    ...HOST,
+    killCostSec: 0.5,
+    firstByteWaitSec: 3,
+    refetchSecPerFilmSecond: 0.25
+  });
   const move = actions.find((action) => action.type === "move");
   assert.ok(move);
-  assert.match(move.because, /speed is not measured/);
+  assert.match(move.because, /refetch 20\.00s/);
+  assert.match(move.because, /against 3\.62s to move/);
+});
+
+test("a short covered stretch is driven through rather than paid a restart for", () => {
+  // One covered segment at 1x is 4 s of encoding plus 1 s of refetch, against a
+  // move priced at 0.12 + 0.5 + 30 seconds on a host where the first bytes are
+  // slow to come. The comparison, not a rule, decides it.
+  const coverage = new CoverageMap({ segmentCount: 200 });
+  const runA = run({ head: 10, speedX: 1 });
+  coverage.claim(runA, 0, 200);
+  coverage.markReady(10);
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 0, to: 190 }],
+    runs: [runA],
+    ...HOST,
+    killCostSec: 0.5,
+    firstByteWaitSec: 30,
+    refetchSecPerFilmSecond: 0.25
+  });
+  assert.equal(actions.some((action) => action.type === "move"), false);
+  assert.ok(actions.some((action) => action.type === "keep" && action.run === runA));
 });
 
 test("a run with nothing left to make ahead of it is stopped", () => {

package/test/one-authority.test.js

@@ -0,0 +1,105 @@
+/**
+ * @file One place decides which encoders exist.
+ *
+ * Not a check of behaviour but of shape, and it is here because the shape is
+ * what failed. Three separate places used to decide where an encoder should
+ * work and whether it should go on living, and they disagreed on every pass:
+ * measured in the field on 2026-09-05, 684 starts and 660 stops in 482 seconds,
+ * of which 294 were one place killing what another had just decided to keep,
+ * while the viewer's own segment went unmade for 32.3 seconds.
+ *
+ * Every rule below is one that was broken then. A reader who needs to add a
+ * fourth place should read this file first and then not.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * @param {string} relative
+ * @returns {string}
+ */
+function source(relative) {
+  return readFileSync(path.join(HERE, "..", relative), "utf8");
+}
+
+/**
+ * Lines of code, without comments or blanks: a rule about what the code does
+ * must not be answered by what a comment says about it.
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+function statements(text) {
+  return text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith("//") && !line.startsWith("*") && !line.startsWith("/*"));
+}
+
+test("an encoder is stopped for scheduling reasons in exactly one place", () => {
+  // The orchestrator decides; nobody else may. What is left in the session
+  // manager is teardown — the session is going away and its encoders with it —
+  // which is not a decision about which encoders should exist.
+  const orchestrator = statements(source("services/orchestrators/EncodeOrchestrator.js"));
+  const stopsInOrchestrator = orchestrator.filter((line) => line.includes("run.stop("));
+  assert.equal(stopsInOrchestrator.length, 1, "the orchestrator stops runs in one place");
+
+  const manager = statements(source("services/hls-session-manager.js"));
+  const stopsInManager = manager.filter((line) => line.includes(".stop("));
+  assert.equal(
+    stopsInManager.length,
+    2,
+    "the session manager stops runs only when a session is torn down: " +
+      stopsInManager.join(" / ")
+  );
+});
+
+test("nothing outside the encoding layer starts an encoder", () => {
+  // A run is built in one place. Two places building them is how a start came
+  // to kill what the plan had decided to keep — the killing lived in the
+  // building.
+  const manager = statements(source("services/hls-session-manager.js"));
+  const builds = manager.filter((line) => line.includes("new EncodeRun("));
+  assert.equal(builds.length, 1, "one place builds an encoder");
+});
+
+test("starting an encoder stops nothing", () => {
+  // The rule that broke it: the start path looked for a live run whose own
+  // start was not below the new one's and killed it. It is not enough that the
+  // line is gone — the words it was written with must not come back.
+  const manager = source("services/hls-session-manager.js");
+  assert.equal(
+    manager.includes("previousRun"),
+    false,
+    "there is no such thing as the previous run: a session holds several"
+  );
+  assert.equal(manager.includes("a new run is taking its place"), false);
+});
+
+test("a seek moves the viewer and nothing else", () => {
+  // It used to do eleven things and write the position into five places. What
+  // follows from a viewer moving is the map's business, and the orchestrators
+  // read the map.
+  const manager = source("services/hls-session-manager.js");
+  const seek = manager.slice(
+    manager.indexOf("requestSeek(sessionId, positionSeconds"),
+    manager.indexOf("requestSeek(sessionId, positionSeconds") + 2000
+  );
+  const body = seek.slice(0, seek.indexOf("\n  }\n"));
+  assert.equal(body.includes("#startEncodeRun"), false, "a seek starts no encoder");
+  assert.equal(body.includes("setTimeout"), false, "and waits for nothing");
+});
+
+test("how far an encoder may work is answered once", () => {
+  // The plan computes the stretch and it reaches ffmpeg. A second computation
+  // somewhere else is what made the first one pointless: it was passed and then
+  // dropped by a parameter list that did not name it.
+  const orchestrator = source("services/orchestrators/EncodeOrchestrator.js");
+  assert.ok(orchestrator.includes("makeRun({ address, from, to })"), "the stretch is handed over");
+});

package/test/{demand-map.test.js → priority-map.test.js}

@@ -8,7 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mapForViewer, mergeMaps, inWorkingOrder } from "../services/encode/DemandMap.js";
+import { mapForViewer, mergeMaps, inWorkingOrder } from "../services/priority/PriorityMap.js";
 
 test("a viewer's own position is the most urgent thing there is", () => {
   const map = mapForViewer({
@@ -25,23 +25,60 @@ test("a viewer's own position is the most urgent thing there is", () => {
   }
 });
 
-test("a machine that cannot keep up must have more ready before the viewer sets off", () => {
-  // 900s of film in front. At 0.25x the encoder loses three seconds of film per
-  // second played, so 675s must exist first, or the viewer stalls partway.
-  const slow = mapForViewer({ atSeconds: 100, durationSeconds: 1000, allowanceSeconds: 0, encodeSpeedX: 0.25 });
-  const fast = mapForViewer({ atSeconds: 100, durationSeconds: 1000, allowanceSeconds: 0, encodeSpeedX: 2 });
+test("a machine that cannot keep up needs more encoders, not a longer first zone", () => {
+  // An encoder starting where the viewer stands stays ahead of them for
+  // `held x s / (1 - s)`, so the SLOWER the machine the shorter that is — and
+  // the film is held by more encoders rather than by one working further.
+  const slow = mapForViewer({
+    atSeconds: 0,
+    durationSeconds: 1000,
+    allowanceSeconds: 10,
+    encodeSpeedX: 0.25
+  });
+  const quicker = mapForViewer({
+    atSeconds: 0,
+    durationSeconds: 1000,
+    allowanceSeconds: 10,
+    encodeSpeedX: 0.5
+  });
 
-  assert.equal(slow[0].to, 775, "100 + 900 x 0.75");
   assert.ok(
-    slow[0].to - slow[0].from > fast[0].to - fast[0].from,
-    "the slower the machine, the more of the film must be made in advance"
+    slow[0].to - slow[0].from < quicker[0].to - quicker[0].from,
+    "the slower machine holds the viewer for less"
   );
+  assert.ok(slow.length > quicker.length, "so more encoders are needed to hold the film");
+});
+
+test("the first zone is exactly what one encoder can hold", () => {
+  // `held x s / (1 - s)`: ten seconds held at half speed is ten seconds held,
+  // and the encoder is caught exactly there. A longer first zone would stall
+  // the viewer inside it; a shorter one would start the next encoder nearer,
+  // where its own bound is tighter.
+  const map = mapForViewer({
+    atSeconds: 0,
+    durationSeconds: 100,
+    allowanceSeconds: 10,
+    encodeSpeedX: 0.5
+  });
+
+  assert.equal(map[0].to, 10);
+  assert.equal(map[1].to, 30, "the next holds three times as long, because they arrive later");
+  assert.equal(map[2].to, 70);
 });
 
-test("the allowance is added to the shortfall, not chosen instead of it", () => {
-  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 10, encodeSpeedX: 0.5 });
+test("a viewer holding nothing is told the whole of it is urgent", () => {
+  // With nothing held, no partition holds them: the first encoder stays ahead
+  // for zero seconds. Slicing the film into equal slivers would pretend
+  // otherwise.
+  const map = mapForViewer({
+    atSeconds: 0,
+    durationSeconds: 1000,
+    allowanceSeconds: 0,
+    encodeSpeedX: 0.25
+  });
 
-  assert.equal(map[0].to, 60, "50s of shortfall plus 10s of measured allowance");
+  assert.equal(map.length, 1);
+  assert.equal(map[0].to, 1000);
 });
 
 test("the rest of the track is still wanted, and wanted last", () => {

package/test/usrsctp-state.test.js

@@ -62,7 +62,7 @@ async function waitFor(check) {
   }
 }
 
-test("gdb is invoked attached to this process with the bundled script", async () => {
+test("the deadline is counted outside the process gdb stops", async () => {
   const { spawnProcess, calls } = makeSpawn("state=8 rwnd=95890\n");
   const lines = [];
   const reader = createUsrsctpStateReader({
@@ -74,7 +74,23 @@ test("gdb is invoked attached to this process with the bundled script", async ()
   assert.equal(started, true);
   await waitFor(() => lines.length > 0);
   assert.equal(calls.length, 1);
-  assert.deepEqual(calls[0].args, ["-q", "-batch", "-p", "4242", "-x", SCTPSTATE_SCRIPT_PATH]);
+  // `timeout` is a separate process, so it keeps counting while gdb holds every
+  // thread of this one. A `setTimeout` here cannot fire — measured in the field
+  // on 2026-09-05, where gdb held the proxy for four minutes and the guard set
+  // for fifteen seconds never ran.
+  assert.equal(calls[0].command, "timeout");
+  assert.deepEqual(calls[0].args, [
+    "-s",
+    "KILL",
+    "15",
+    "gdb",
+    "-q",
+    "-batch",
+    "-p",
+    "4242",
+    "-x",
+    SCTPSTATE_SCRIPT_PATH
+  ]);
   assert.match(lines[0], /state=8 rwnd=95890/);
   assert.match(lines[0], /test wedge/);
 });