@torrent-tv/proxy 2.80.13 → 2.80.15

package/test/declared-rates.test.js

@@ -0,0 +1,116 @@
+/**
+ * @file What the master playlist declares a variant carries.
+ *
+ * Measured, and the measurement was available all along: it used to be
+ * `height * height * 3.2`, justified by a comment saying no measurement existed
+ * before encoding starts. Field 2026-09-08: 3.73 Mbit/s declared for a file
+ * carrying 18.4, and the browser sizes its cushion in BYTES from that figure —
+ * 120 s asked bought 26 s of film, and the deepest it ever held was 17.1 s.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { declaredRates } from "../services/output/rates.js";
+import { bitrateFor } from "../services/output/playlists.js";
+
+// The field file: 2 806 246 976 bytes over 20:18, cut into 291 pieces.
+const FIELD = { fileLength: 2_806_246_976, durationSeconds: 1218.73 };
+
+test("the average is the file's own length over its duration", () => {
+  const { averageBitsPerSecond } = declaredRates(FIELD);
+
+  // 18.4 Mbit/s, against the 3.73 that was declared.
+  assert.ok(
+    Math.abs(averageBitsPerSecond / 1_000_000 - 18.42) < 0.01,
+    `got ${averageBitsPerSecond}`
+  );
+});
+
+test("nothing measured is stated as nothing, not as a guess", () => {
+  assert.deepEqual(
+    declaredRates({ fileLength: 0, durationSeconds: 0 }),
+    { averageBitsPerSecond: 0, peakOverAverage: 1 }
+  );
+  assert.deepEqual(
+    declaredRates({ fileLength: 100, durationSeconds: 0 }),
+    { averageBitsPerSecond: 0, peakOverAverage: 1 }
+  );
+});
+
+test("the peak comes from the biggest piece made and the span it covers", () => {
+  // The field peak: 38.4 MB over 4.2 s is 73 Mbit/s, four times the average.
+  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
+  const { averageBitsPerSecond, peakOverAverage } = declaredRates({
+    ...FIELD,
+    largest: { index: 2, size: 40_288_299 },
+    boundaries
+  });
+
+  const peak = averageBitsPerSecond * peakOverAverage;
+  assert.ok(Math.abs(peak / 1_000_000 - 76.7) < 0.5, `got ${peak / 1_000_000}Mbit/s`);
+});
+
+test("no piece made yet means the peak is not yet measured, so it equals the average", () => {
+  // A ratio invented meanwhile is exactly the fabrication this replaced.
+  assert.equal(declaredRates(FIELD).peakOverAverage, 1);
+  assert.equal(
+    declaredRates({ ...FIELD, largest: { index: -1, size: 0 }, boundaries: [0, 4] }).peakOverAverage,
+    1
+  );
+});
+
+test("the peak is never below the average", () => {
+  // A short session whose only piece happens to be a small one must not lower
+  // the figure the player sizes its cushion from.
+  const boundaries = Array.from({ length: 292 }, (_, index) => index * 4.2);
+  assert.equal(
+    declaredRates({ ...FIELD, largest: { index: 5, size: 1000 }, boundaries }).peakOverAverage,
+    1
+  );
+});
+
+test("a smaller picture is declared at the pixel share of the source's rate", () => {
+  const measured = 18_420_000;
+
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: measured, height: 1080, sourceHeight: 1080 }),
+    Math.round(measured),
+    "the source's own height carries the source's bits"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: measured, height: 2160, sourceHeight: 1080 }),
+    Math.round(measured),
+    "and a height above it carries no more — there is nothing to upscale from"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: measured, height: 540, sourceHeight: 1080 }),
+    Math.round(measured / 4),
+    "half the height is a quarter of the pixels"
+  );
+});
+
+test("a capped height is declared at its cap, which is exact", () => {
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 720, sourceHeight: 1080, capKbps: 2500 }),
+    2_500_000,
+    "what we impose is known, not estimated"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 1_000_000, height: 1080, sourceHeight: 1080, capKbps: 99_000 }),
+    1_000_000,
+    "and a cap above what the source carries takes nothing away from it"
+  );
+});
+
+test("the floor is a floor on what may be declared, not a belief about content", () => {
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 0, height: 1080, sourceHeight: 1080 }),
+    400_000,
+    "a file whose rate is not known yet"
+  );
+  assert.equal(
+    bitrateFor({ averageBitsPerSecond: 18_420_000, height: 4, sourceHeight: 1080 }),
+    400_000,
+    "and a variant so small the arithmetic would go under it"
+  );
+});

package/test/encode-plan.test.js

@@ -367,9 +367,15 @@ test("the one machine goes to whoever is due soonest, not to the smallest number
     ...HOST,
     maxRuns: 2
   });
-  const started = actions.filter((action) => action.type === "start").map((action) => action.from);
-
-  assert.deepEqual(started, [500], "the one machine goes where somebody is stopped");
+  // WHERE the machine ends up, not how it got there. A run standing at #900
+  // reaches nothing anybody wants, so it is taken to #500 rather than killed and
+  // replaced — one process instead of a death and a cold start, which is
+  // strictly better and is what the plan now answers.
+  const placed = actions
+    .filter((action) => action.type === "start" || action.type === "move")
+    .map((action) => action.from);
+
+  assert.deepEqual(placed, [500], "the one machine goes where somebody is stopped");
 });
 
 test("two viewers far apart are both served, by however many encoders serve them soonest", () => {

package/test/move-cost.test.js

@@ -0,0 +1,138 @@
+/**
+ * @file What moving a running encoder costs, and what the plan does while
+ * nobody has measured it.
+ *
+ * Field 2026-09-08: 39 moves in one session, 24 of them between three adjacent
+ * numbers — #58 to #59, #59 to #58, #58 to #60, #60 to #58, six times each,
+ * about 0.8 s apart — while the viewer's picture stood still for 116.7 s in
+ * three interruptions, the worst of them 91.8 s. The zone the viewer's own
+ * position defines slides forward one number at a time, and every slide made
+ * standing one number behind it score worse than standing in it.
+ *
+ * FOUR THINGS, and the first is the one that mattered.
+ *
+ * 1. The map states `withinSeconds: null` for the film BEHIND the viewers —
+ *    nobody is waiting there. `deadlineReaderFor` read it through `Number()`,
+ *    where `null` is 0, so that film was due NOW and was the most urgent
+ *    material in the file. It bought encoders and it took the run standing in
+ *    front of the viewer, because that run was the nearest body to it.
+ * 2. Residual work took a live run. A zone with no deadline is done with
+ *    capacity that is left over, and a run already serving a viewer is not left
+ *    over.
+ * 3. `moveSec` was 0 until measured, so a move was free in the arithmetic — and
+ *    the blindness sustained itself, because the first-output figure takes a
+ *    reading only from a run that produced something and every run in a thrash
+ *    is killed before it finishes anything.
+ * 4. A staying run was priced as though it would produce instantly, however
+ *    recently it had started, so the score had no memory of a decision it was
+ *    still carrying out.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { RunCosts } from "../services/encode/run-costs.js";
+import { planEncoders } from "../services/encode/EncodePlan.js";
+import { CoverageMap } from "../services/encode/CoverageMap.js";
+
+test("nothing measured means a move is refused, not priced at zero", () => {
+  const costs = new RunCosts();
+
+  const { moveCostSec, firstByteWaitSec, killCostSec } = costs.seconds();
+  assert.equal(moveCostSec, Number.POSITIVE_INFINITY, "moving is not free while unpriced");
+  // Placing one where there is none is the OTHER question, and it has no
+  // alternative: the film gets made or it does not.
+  assert.equal(firstByteWaitSec, 0, "placing an encoder is not blocked by an unknown price");
+  assert.equal(killCostSec, 0);
+});
+
+test("a run killed before producing anything is a lower bound on the first output", () => {
+  const costs = new RunCosts();
+
+  // Exactly what a thrash supplies: a run that lived 800 ms and finished
+  // nothing. It says the first output takes AT LEAST that long, which is a fact.
+  costs.note({ livedMs: 800, dyingMs: 40 });
+
+  const { moveCostSec } = costs.seconds();
+  assert.ok(Number.isFinite(moveCostSec), "one killed run is enough to stop the blindness");
+  assert.ok(Math.abs(moveCostSec - 0.84) < 0.001, `got ${moveCostSec}`);
+});
+
+test("a run that produced something is measured by its first output, not its life", () => {
+  const costs = new RunCosts();
+
+  costs.note({ livedMs: 60_000, firstOutputMs: 900, dyingMs: 100 });
+
+  const { moveCostSec, firstByteWaitSec } = costs.seconds();
+  assert.ok(Math.abs(firstByteWaitSec - 0.9) < 0.001, `got ${firstByteWaitSec}`);
+  assert.ok(Math.abs(moveCostSec - 1.0) < 0.001, `got ${moveCostSec}`);
+});
+
+test("the zone sliding one number does not move an encoder that is already reaching it", () => {
+  // The field shape exactly: a run standing at #58 with the viewer's urgent zone
+  // sliding #58..#59 → #59..#60. Driving through one segment costs the encoder a
+  // fraction of a second; moving costs a kill and a cold start.
+  const coverage = new CoverageMap();
+  coverage.setSegmentCount(482);
+  const run = { from: 58, to: 481, head: 58, speedX: 4.45, isAlive: true };
+  coverage.claim(run, 58, 481);
+
+  const actions = planEncoders({
+    coverage,
+    windows: [
+      { from: 0, to: 57, priority: 1, withinSeconds: null, behind: true },
+      { from: 59, to: 60, priority: 100, withinSeconds: 0, behind: false }
+    ],
+    runs: [run],
+    maxRuns: 3,
+    segmentSeconds: 4.2,
+    speedX: 4.45,
+    // Measured on this host: killing takes 40 ms, a fresh encoder's first piece
+    // 900 ms. Against that, driving one segment at 4.45x costs 0.94 s — so the
+    // two are close, and what settles it is that the move ALSO has to encode
+    // the same segment afterwards.
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1
+  });
+
+  assert.deepEqual(
+    actions.filter((one) => one.type === "move"),
+    [],
+    "a run one number behind the zone is already on its way into it"
+  );
+});
+
+test("a move that genuinely saves the viewer time still happens", () => {
+  // The other half: the viewer jumped fourteen segments ahead, and driving there
+  // at 4.45x would take 13 s while a cold start takes 0.94 s. Refusing this
+  // would be the opposite fault.
+  const coverage = new CoverageMap();
+  coverage.setSegmentCount(482);
+  const run = { from: 0, to: 481, head: 44, speedX: 4.45, isAlive: true };
+  coverage.claim(run, 0, 481);
+
+  const actions = planEncoders({
+    coverage,
+    windows: [{ from: 58, to: 59, priority: 100, withinSeconds: 0, behind: false }],
+    runs: [run],
+    maxRuns: 3,
+    segmentSeconds: 4.2,
+    speedX: 4.45,
+    killCostSec: 0.04,
+    firstByteWaitSec: 0.9,
+    moveCostSec: 0.94,
+    refetchSecPerFilmSecond: 0,
+    contentionPenaltyFor: () => 1
+  });
+
+  // WHERE the encoder ends up, not how it got there: the run at #44 reaches
+  // nothing anybody waits for, so the plan may either take it to #58 or stop it
+  // and start one there. Both are one process at #58, and which is cheaper is
+  // the measured difference between a kill and a cold start.
+  const placed = actions
+    .filter((one) => one.type === "move" || one.type === "start")
+    .map((one) => one.from);
+  assert.deepEqual(placed, [58], "fourteen segments of driving is worth a cold start");
+});

package/test/piece-lru.test.js

@@ -199,6 +199,10 @@ test("the demand is the union of the readers' windows, not their sum", () => {
 
   const demand = lru.demand();
   assert.equal(demand.readers, 2);
+  // NAMED, because the count read as five encoders on a session that had two:
+  // four of the five were zones of the priority map, and only the names could
+  // say so.
+  assert.deepEqual(demand.names, ["audio", "video"]);
   assert.equal(demand.unionPieces, 80, "100..179 is eighty pieces, not a hundred");
   assert.equal(demand.widestPieces, 50);
   assert.equal(demand.capacity, 88);
@@ -211,7 +215,7 @@ test("the demand is the union of the readers' windows, not their sum", () => {
   lru.unprotect("video");
   assert.deepEqual(
     lru.demand(),
-    { readers: 0, unionPieces: 0, widestPieces: 0, capacity: 88 },
+    { readers: 0, names: [], unionPieces: 0, widestPieces: 0, capacity: 88 },
     "no reader asking for anything is not the same as asking for one piece"
   );
 });

package/test/supply-margin.test.js

@@ -50,10 +50,22 @@ test("the margin is what the supply's own interruptions demand", () => {
   // derivation calls T: `(v - 1) x T > W` prices what is GAINED between
   // interruptions, and nothing is gained during one.
   assert.ok(Math.abs(answer.medianIntervalSec - 0.73) < 0.001, `got ${answer.medianIntervalSec}`);
-  // 1 + 3.16 / 0.73 = 5.33. Measuring end-to-end instead gave 2.42, and the
-  // symptom that this whole file was written against is that a step admitted at
-  // 1.5 ran at 1.05x and stalled — so the bar was too low, not too high.
-  assert.ok(Math.abs(answer.requiredSpeed - 5.3288) < 0.001, `got ${answer.requiredSpeed}`);
+  // THE SHARE OF ITS TIME THE SUPPLY LOST, over whole cycles: from the first
+  // interruption's start to the last one's, 12.77 s, of which 9.12 s was
+  // interruption. So the reading delivered for 3.65 s of every 12.77, and
+  // producing film at that share costs 1/(1 - 0.714) = 3.50x.
+  //
+  // The formula it replaced divided the WORST interruption by the TYPICAL gap —
+  // 1 + 3.16/0.73 = 5.33 — which asks what would happen if the worst recurred
+  // at the typical rate, a case that never occurred in this data, and which
+  // divides by a gap that goes to zero whenever interruptions arrive in a burst.
+  // Field 2026-09-08: 0.79 s over 0.01 s gave 158.60x on a file already
+  // downloaded whole, and every quality step was refused against it.
+  //
+  // The failure this file was written for is still caught: a step admitted at
+  // 1.5 ran at 1.05x and stalled, and 3.91x refuses 1.5 exactly as 5.33x did.
+  assert.ok(Math.abs(answer.lostShare - 0.7142) < 0.001, `got ${answer.lostShare}`);
+  assert.ok(Math.abs(answer.requiredSpeed - 3.4986) < 0.001, `got ${answer.requiredSpeed}`);
 });
 
 test("one stall seen by three readers is one interruption, not three", () => {
@@ -87,7 +99,11 @@ test("overlapping waits merge, and the gap between stalls is what is left", () =
   assert.equal(answer.waits, 4, "from four waits");
   assert.equal(answer.worstWaitSec, 10, "the merged stall, not one reader's view of it");
   assert.equal(answer.medianIntervalSec, 10, "20s to 30s is when the encoder ran");
-  assert.equal(answer.requiredSpeed, 2, "1 + 10/10");
+  // One whole cycle: 10 s to 30 s, of which the 10 s interruption is half. The
+  // supply delivered for the other half, so a step must run at twice realtime.
+  assert.equal(answer.spanSec, 20);
+  assert.equal(answer.lostSec, 10);
+  assert.equal(answer.requiredSpeed, 2);
 });
 
 test("a copy at 8x clears its own supply with room to spare", () => {
@@ -95,9 +111,10 @@ test("a copy at 8x clears its own supply with room to spare", () => {
   const waits = evenlySpaced(6, 15.5, 4.82);
   const answer = requiredSpeedFrom(waits);
   assert.ok(answer);
-  // Waits end 15.5 s apart and last 4.82 s, so the encoder runs 10.68 s between
-  // them: 1 + 4.82/10.68 = 1.45, against 8x measured. Which is why a copy is the
-  // step a stranded viewer is always able to return to.
+  // Waits end 15.5 s apart and last 4.82 s, so the supply delivers for 10.68 s
+  // of every 15.5: 0.311 of its time lost, and 1/(1 - 0.311) = 1.45 against the
+  // 8x measured. Which is why a copy is the step a stranded viewer is always
+  // able to return to.
   assert.ok(answer.requiredSpeed < 1.5, `got ${answer.requiredSpeed}`);
 });