@torrent-tv/proxy 2.80.13 → 2.80.14

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/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}`);
 });