@torrent-tv/proxy 2.77.0 → 2.79.0

package/test/encode-orchestrator.test.js

@@ -45,6 +45,12 @@ function orchestrator({ maxRuns = 2 } = {}) {
     maxRunsFor: () => maxRuns,
     segmentSeconds: 4,
     restartCostSec: 0.12,
+    // A host that has measured what the swarm charges to fetch a second of film
+    // again. Without it the drive-or-move comparison has only one side and the
+    // plan keeps the encoder rather than paying an unknown price — which is its
+    // own check in `encode-plan.test.js` rather than the shape every check here
+    // is written against.
+    refetchSecPerFilmSecond: () => 0.25,
     now: () => 1000,
     logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line) },
     makeRun: ({ address, from, to }) => {
@@ -195,22 +201,25 @@ test("nothing wanted anywhere is said plainly", () => {
   assert.match(made.describe(), /nothing wanted/);
 });
 
-test("a run adopted with no end holds the look-ahead, not the rest of the film", () => {
+test("a run adopted with no end holds what it has made, not the rest of the film", () => {
   // A session's own encoder is handed to the plan rather than built by it, and
-  // it carries `to = -1` — no end. Claiming the film from there would leave a
-  // viewer further in with no encoder at all: they would wait for this run to
-  // encode its way to them, which on a long film is an hour. What bounds it is
-  // the look-ahead, because a run is suspended once it is that far in front of
-  // its viewer and produces nothing until somebody asks.
+  // it carries `to = -1` — no end, which means the film's length is not known.
+  // Claiming the film from there would leave a viewer further in with no
+  // encoder at all: they would wait for this run to encode its way to them,
+  // which on a long film is an hour. What it holds is what it has produced,
+  // which is a fact rather than a distance nobody measured.
   const { made } = orchestrator({ maxRuns: 2 });
-  made.lookaheadSegments = 30;
   const adopted = {
     from: 0,
     to: -1,
     head: 3,
     isAlive: true,
     isStopping: false,
-    speedX: 8,
+    // Slow enough that the swarm is not what limits the count here: at 0.25
+    // seconds of swarm time per second of film, one encoder at 1x takes a
+    // quarter of what is delivered and four may run. The swarm's own limit has
+    // its own check below.
+    speedX: 1,
     stop() {
       this.isAlive = false;
     }
@@ -225,3 +234,22 @@ test("a run adopted with no end holds the look-ahead, not the rest of the film",
   assert.ok(adopted.isAlive, "and the adopted run was not stopped to make room");
   assert.equal(runs.some((run) => run.from === 200), true, "started where that viewer is waiting");
 });
+
+test("the swarm limits the encoders, whatever the processor allows", () => {
+  // Every encoder reads the same torrent, so together they cannot consume
+  // faster than it is delivered. At 0.25 seconds of swarm time per second of
+  // film, one encoder running at 8x takes twice everything there is — so a
+  // machine whose processor would allow two gets one.
+  const { made, lines } = orchestrator({ maxRuns: 2 });
+  made.want({ claimant: "one", address: PICTURE, from: 100, to: 130 });
+  made.reconcile();
+  made.runsOn(PICTURE)[0].noteSpeed(8);
+  made.want({ claimant: "two", address: PICTURE, from: 500, to: 530 });
+  made.reconcile();
+
+  assert.equal(made.runsOn(PICTURE).length, 1);
+  assert.ok(
+    lines.some((line) => line.includes("what the swarm delivers")),
+    "and the line says which limit decided it"
+  );
+});

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", () => {
@@ -176,7 +238,12 @@ test("every encoder stops when nobody is watching the output", () => {
   );
 });
 
-test("a run making material nobody asked for is stopped", () => {
+test("a run standing outside every window keeps working: the file is encoded whole", () => {
+  // The rule, stated by the user 2026-09-05: while a file is being encoded it
+  // is encoded whole, and a viewer decides the ORDER, not whether a run may
+  // live. Stopping a run for standing outside a window is what produced the
+  // field oscillation of that day — placed by one rule, killed by another,
+  // 350-700ms per cycle, nothing ever produced.
   const coverage = new CoverageMap({ segmentCount: 1000 });
   const runA = run({ from: 500, to: 600, head: 520 });
   coverage.claim(runA, 500, 600);
@@ -186,7 +253,44 @@ test("a run making material nobody asked for is stopped", () => {
     runs: [runA],
     ...HOST
   });
-  assert.ok(actions.some((action) => action.type === "stop" && action.run === runA));
+  assert.ok(
+    !actions.some((action) => action.type === "stop" && action.run === runA),
+    "it is making film that will be wanted, and nothing else is making it"
+  );
+});
+
+test("the same plan run twice on an unchanged state gives the same answer", () => {
+  // What the oscillation actually was: two passes over one state disagreeing
+  // with each other. Nothing about the state changes between them here.
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const runA = run({ from: 500, to: 600, head: 520 });
+  coverage.claim(runA, 500, 600);
+  const input = { coverage, windows: [{ from: 0, to: 40 }], runs: [runA], ...HOST };
+
+  const first = planEncoders(input).map((action) => action.type);
+  const second = planEncoders(input).map((action) => action.type);
+
+  assert.deepEqual(first, second);
+  assert.ok(!first.includes("stop"), "and neither pass kills what the other would start");
+});
+
+test("a viewer's most urgent zone is filled before a less urgent one", () => {
+  const coverage = new CoverageMap({ segmentCount: 1000 });
+  const actions = planEncoders({
+    coverage,
+    // The far zone is lower in number and lower in priority: the order must
+    // come from the priority, not from the number.
+    windows: [
+      { from: 0, to: 100, priority: 1 },
+      { from: 500, to: 530, priority: 3 }
+    ],
+    runs: [],
+    ...HOST,
+    maxRuns: 1
+  });
+  const started = actions.filter((action) => action.type === "start").map((action) => action.from);
+
+  assert.deepEqual(started, [500], "the one machine goes where somebody is stopped");
 });
 
 test("two viewers far apart get an encoder each, when the machine can hold two", () => {

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/priority-map.test.js

@@ -0,0 +1,139 @@
+/**
+ * @file A map per viewer, merged into one, in the order the work is taken.
+ *
+ * In seconds of film throughout: it is the only unit every term of the
+ * arithmetic is already stated in, and the one two consumers with different
+ * states can both be translated from.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+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({
+    atSeconds: 100,
+    durationSeconds: 1000,
+    allowanceSeconds: 8,
+    encodeSpeedX: 2
+  });
+
+  assert.equal(map[0].from, 100);
+  assert.equal(map[0].to, 108, "above realtime, only the measured allowance");
+  for (const zone of map.slice(1)) {
+    assert.ok(zone.priority < map[0].priority);
+  }
+});
+
+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.ok(
+    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("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.length, 1);
+  assert.equal(map[0].to, 1000);
+});
+
+test("the rest of the track is still wanted, and wanted last", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 4, encodeSpeedX: 2 });
+
+  assert.equal(map[map.length - 1].to, 1000, "the map reaches the end of the film");
+  assert.ok(map[map.length - 1].priority > 0, "and the far end is still wanted");
+  let previousEnd = 0;
+  for (const zone of map) {
+    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
+    previousEnd = zone.to;
+  }
+});
+
+test("nothing is measured yet: the middle zone is left out rather than invented", () => {
+  const map = mapForViewer({ atSeconds: 0, durationSeconds: 100, allowanceSeconds: 4, encodeSpeedX: 0 });
+
+  assert.equal(map.length, 2, "what must be ready, and the rest");
+});
+
+test("two viewers merge to the highest priority per second, with no overlaps", () => {
+  const first = mapForViewer({ atSeconds: 0, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
+  const second = mapForViewer({ atSeconds: 500, durationSeconds: 1000, allowanceSeconds: 8, encodeSpeedX: 2 });
+
+  const merged = mergeMaps([first, second]);
+
+  let previousEnd = merged[0].from;
+  for (const zone of merged) {
+    assert.equal(zone.from, previousEnd, "no gaps and no overlaps");
+    previousEnd = zone.to;
+  }
+  const priorityAt = (at) => merged.find((zone) => at >= zone.from && at < zone.to)?.priority;
+  assert.equal(priorityAt(0), priorityAt(500), "both viewers' own positions are equally urgent");
+  assert.ok(priorityAt(500) > priorityAt(300), "a viewer at 500 outranks the far zone of the one at 0");
+});
+
+test("the second viewer's position is not buried under the first viewer's far zone", () => {
+  // The case that used to leave a viewer opening the same film further in with
+  // no encoder at all, because the first run claimed everything in front of it.
+  const first = mapForViewer({ atSeconds: 0, durationSeconds: 4000, allowanceSeconds: 8, encodeSpeedX: 2 });
+  const second = mapForViewer({ atSeconds: 2000, durationSeconds: 4000, allowanceSeconds: 8, encodeSpeedX: 2 });
+
+  const order = inWorkingOrder(mergeMaps([first, second]));
+  const firstTwo = order.slice(0, 2).map((zone) => zone.from);
+
+  assert.ok(firstTwo.includes(0), "the first viewer's own position is taken first");
+  assert.ok(firstTwo.includes(2000), "so is the second viewer's, before anything less urgent");
+});
+
+test("within one priority the earliest film goes first — that is where somebody is stopped", () => {
+  const order = inWorkingOrder([
+    { from: 900, to: 1000, priority: 2 },
+    { from: 100, to: 200, priority: 2 },
+    { from: 0, to: 10, priority: 3 }
+  ]);
+
+  assert.deepEqual(order.map((zone) => zone.from), [0, 100, 900]);
+});