@torrent-tv/proxy 2.89.6 → 2.89.7

package/test/send-chunk-bytes.test.js

@@ -1,86 +1,86 @@
-import assert from "node:assert/strict";
-import test from "node:test";
-import { bodySender } from "../services/transport/data-channel-handler.js";
-
-/**
- * Drives the sender over a body arriving in the given read sizes, and answers
- * both what reached the far end and what was written — so "the body is
- * unchanged" is asserted against the body rather than against a length.
- *
- * @param {number}   sizeBytes
- * @param {number[]} readSizes - The sizes the body read hands over, in order.
- * @returns {{ sent: Buffer[], counted: number, written: Buffer }}
- */
-function sendBody(sizeBytes, readSizes) {
-  /** @type {Buffer[]} */
-  const sent = [];
-  const sender = bodySender((bytes) => sent.push(Buffer.from(bytes)), sizeBytes);
-  /** @type {Buffer[]} */
-  const written = [];
-  let counted = 0;
-  let next = 0;
-  for (const size of readSizes) {
-    const block = Buffer.alloc(size);
-    for (let index = 0; index < size; index += 1) {
-      block[index] = next & 0xff;
-      next += 1;
-    }
-    written.push(block);
-    counted += sender.push(block);
-  }
-  counted += sender.flush();
-  return { sent, counted, written: Buffer.concat(written) };
-}
-
-test("with no size chosen, one body read is one message", () => {
-  const { sent, counted } = sendBody(0, [1000, 2000, 3]);
-  assert.deepEqual(
-    sent.map((message) => message.length),
-    [1000, 2000, 3]
-  );
-  assert.equal(counted, 3);
-});
-
-test("a smaller size cuts a body read into messages of exactly that size", () => {
-  const { sent, counted } = sendBody(400, [1000]);
-  assert.deepEqual(
-    sent.map((message) => message.length),
-    [400, 400, 200]
-  );
-  assert.equal(counted, 3);
-});
-
-test("a larger size joins body reads until it is filled", () => {
-  const { sent } = sendBody(2500, [1000, 1000, 1000, 1000]);
-  assert.deepEqual(
-    sent.map((message) => message.length),
-    [2500, 1500]
-  );
-});
-
-test("every byte arrives once, in order, whatever the size", () => {
-  for (const size of [0, 1, 7, 400, 2500, 999_999]) {
-    const { sent, written } = sendBody(size, [1000, 3, 5000, 17]);
-    assert.deepEqual(Buffer.concat(sent), written, `size ${size} changed the body`);
-  }
-});
-
-test("a size larger than the whole body still sends it, once, on flush", () => {
-  const { sent, written, counted } = sendBody(10_000, [100, 200]);
-  assert.equal(sent.length, 1);
-  assert.equal(counted, 1);
-  assert.deepEqual(sent[0], written);
-});
-
-test("the count is of messages, which is what a reading is attributed to", () => {
-  // 163 messages for 10 657 210 bytes is the field reading of 2026-09-12; at
-  // 16 KB the same body is 651 of them, and that difference is the measurement.
-  const { counted } = sendBody(16 * 1024, [10_657_210]);
-  assert.equal(counted, Math.ceil(10_657_210 / (16 * 1024)));
-});
-
-test("nothing is sent for an empty body, and flush has nothing to release", () => {
-  const { sent, counted } = sendBody(400, []);
-  assert.deepEqual(sent, []);
-  assert.equal(counted, 0);
-});
+import assert from "node:assert/strict";
+import test from "node:test";
+import { bodySender } from "../services/transport/data-channel-handler.js";
+
+/**
+ * Drives the sender over a body arriving in the given read sizes, and answers
+ * both what reached the far end and what was written — so "the body is
+ * unchanged" is asserted against the body rather than against a length.
+ *
+ * @param {number}   sizeBytes
+ * @param {number[]} readSizes - The sizes the body read hands over, in order.
+ * @returns {{ sent: Buffer[], counted: number, written: Buffer }}
+ */
+function sendBody(sizeBytes, readSizes) {
+  /** @type {Buffer[]} */
+  const sent = [];
+  const sender = bodySender((bytes) => sent.push(Buffer.from(bytes)), sizeBytes);
+  /** @type {Buffer[]} */
+  const written = [];
+  let counted = 0;
+  let next = 0;
+  for (const size of readSizes) {
+    const block = Buffer.alloc(size);
+    for (let index = 0; index < size; index += 1) {
+      block[index] = next & 0xff;
+      next += 1;
+    }
+    written.push(block);
+    counted += sender.push(block);
+  }
+  counted += sender.flush();
+  return { sent, counted, written: Buffer.concat(written) };
+}
+
+test("with no size chosen, one body read is one message", () => {
+  const { sent, counted } = sendBody(0, [1000, 2000, 3]);
+  assert.deepEqual(
+    sent.map((message) => message.length),
+    [1000, 2000, 3]
+  );
+  assert.equal(counted, 3);
+});
+
+test("a smaller size cuts a body read into messages of exactly that size", () => {
+  const { sent, counted } = sendBody(400, [1000]);
+  assert.deepEqual(
+    sent.map((message) => message.length),
+    [400, 400, 200]
+  );
+  assert.equal(counted, 3);
+});
+
+test("a larger size joins body reads until it is filled", () => {
+  const { sent } = sendBody(2500, [1000, 1000, 1000, 1000]);
+  assert.deepEqual(
+    sent.map((message) => message.length),
+    [2500, 1500]
+  );
+});
+
+test("every byte arrives once, in order, whatever the size", () => {
+  for (const size of [0, 1, 7, 400, 2500, 999_999]) {
+    const { sent, written } = sendBody(size, [1000, 3, 5000, 17]);
+    assert.deepEqual(Buffer.concat(sent), written, `size ${size} changed the body`);
+  }
+});
+
+test("a size larger than the whole body still sends it, once, on flush", () => {
+  const { sent, written, counted } = sendBody(10_000, [100, 200]);
+  assert.equal(sent.length, 1);
+  assert.equal(counted, 1);
+  assert.deepEqual(sent[0], written);
+});
+
+test("the count is of messages, which is what a reading is attributed to", () => {
+  // 163 messages for 10 657 210 bytes is the field reading of 2026-09-12; at
+  // 16 KB the same body is 651 of them, and that difference is the measurement.
+  const { counted } = sendBody(16 * 1024, [10_657_210]);
+  assert.equal(counted, Math.ceil(10_657_210 / (16 * 1024)));
+});
+
+test("nothing is sent for an empty body, and flush has nothing to release", () => {
+  const { sent, counted } = sendBody(400, []);
+  assert.deepEqual(sent, []);
+  assert.equal(counted, 0);
+});

package/test/serving-output.test.js

@@ -1,102 +1,102 @@
-/**
- * @file Which existing output serves a viewer: the rules decided with the user
- * 2026-09-16, with the viewer's own link asked in every mode and on every
- * branch (roadmap item 97, step 11).
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { chooseServingOutput } from "../services/encode/quality/serving-output.js";
-import { linkCouldCarry, loadOf, PEAK_CLASS } from "../services/encode/quality/link-budget.js";
-
-const WANTED = { width: 1824, height: 1026 };
-const NEXT_LOWER = 1280 * 720;
-
-/**
- * @param {string} key
- * @param {number} width
- * @param {number} height
- * @param {{ mbps?: number | null, peakClass?: string, readyHere?: boolean }} [over]
- */
-function candidate(key, width, height, { mbps = 5, peakClass = PEAK_CLASS.KNOWN, readyHere = true } = {}) {
-  return { key, width, height, readyHere, load: loadOf({ mbps, peakClass: mbps === null ? PEAK_CLASS.UNKNOWN : peakClass }, null) };
-}
-
-/**
- * @param {object} over
- * @param {number | null} [linkMbps] - What this viewer's link measured.
- */
-function choose(over, linkMbps = null) {
-  return chooseServingOutput({
-    mode: "auto",
-    wanted: WANTED,
-    nextLowerArea: NEXT_LOWER,
-    atRisk: false,
-    judge: (one) => linkCouldCarry(linkMbps, one.load),
-    candidates: [],
-    ...over
-  })?.key ?? null;
-}
-
-test("the same quality or higher is served, the nearest of them", () => {
-  assert.equal(choose({ candidates: [candidate("2160", 3840, 2160), candidate("1080", 1920, 1080)] }), "1080");
-});
-
-test("higher quality is not served over a link it does not fit", () => {
-  assert.equal(choose({ candidates: [candidate("1080", 1920, 1080, { mbps: 12 })] }, 10), null);
-});
-
-test("a little lower — above the next rung down — is served, and only if the link admits it", () => {
-  assert.equal(choose({ candidates: [candidate("1000", 1776, 1000)] }), "1000");
-  assert.equal(
-    choose({ candidates: [candidate("1000", 1776, 1000, { mbps: 12 })] }, 10),
-    null,
-    "a smaller picture proves nothing by itself: its own load is asked"
-  );
-});
-
-test("the next rung down or lower is served only when making the wanted format risks a wait, and only if it fits", () => {
-  const lower = [candidate("720", 1280, 720), candidate("480", 854, 480)];
-  assert.equal(choose({ candidates: lower }), null);
-  assert.equal(choose({ candidates: lower, atRisk: true }), "720");
-  assert.equal(
-    choose({ candidates: [candidate("720", 1280, 720, { mbps: 12 }), candidate("480", 854, 480, { mbps: 3 })], atRisk: true }, 10),
-    "480",
-    "the larger one does not fit this link, so it is not taken"
-  );
-});
-
-test("an output without the piece at the viewer's position spares them nothing", () => {
-  assert.equal(choose({ candidates: [candidate("1080", 1920, 1080, { readyHere: false })] }), null);
-});
-
-test("a size chosen by hand is served only exactly, and only if the link admits it", () => {
-  const candidates = [candidate("1080", 1920, 1080), candidate("exact", 1824, 1026)];
-  assert.equal(choose({ mode: "manual", candidates }), "exact");
-  assert.equal(choose({ mode: "manual", candidates: [candidate("1080", 1920, 1080)], atRisk: true }), null);
-  assert.equal(
-    choose({ mode: "manual", candidates: [candidate("exact", 1824, 1026, { mbps: 12 })] }, 10),
-    null,
-    "the size they picked, but more than their link carries: not handed over"
-  );
-});
-
-test("of two outputs of the size picked by hand, the higher limit the link admits is served", () => {
-  const candidates = [candidate("2800", 1824, 1026, { mbps: 3.64 }), candidate("1400", 1824, 1026, { mbps: 1.82 })];
-  assert.equal(choose({ mode: "manual", candidates }, 10), "2800");
-  assert.equal(choose({ mode: "manual", candidates }, 3), "1400", "the link admits only the lower limit");
-});
-
-test("a bound is taken before an average, even when the average's limit is higher", () => {
-  const candidates = [
-    candidate("estimated", 1824, 1026, { mbps: 6, peakClass: PEAK_CLASS.ESTIMATED }),
-    candidate("known", 1824, 1026, { mbps: 4, peakClass: PEAK_CLASS.KNOWN })
-  ];
-  assert.equal(choose({ mode: "manual", candidates }, 10), "known");
-});
-
-test("an output with no bound is not served against a measured link, and is while nothing measured it", () => {
-  const candidates = [candidate("hardware", 1824, 1026, { mbps: null })];
-  assert.equal(choose({ mode: "manual", candidates }, 50), null);
-  assert.equal(choose({ mode: "manual", candidates }, null), "hardware");
-});
+/**
+ * @file Which existing output serves a viewer: the rules decided with the user
+ * 2026-09-16, with the viewer's own link asked in every mode and on every
+ * branch (roadmap item 97, step 11).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { chooseServingOutput } from "../services/encode/quality/serving-output.js";
+import { linkCouldCarry, loadOf, PEAK_CLASS } from "../services/encode/quality/link-budget.js";
+
+const WANTED = { width: 1824, height: 1026 };
+const NEXT_LOWER = 1280 * 720;
+
+/**
+ * @param {string} key
+ * @param {number} width
+ * @param {number} height
+ * @param {{ mbps?: number | null, peakClass?: string, readyHere?: boolean }} [over]
+ */
+function candidate(key, width, height, { mbps = 5, peakClass = PEAK_CLASS.KNOWN, readyHere = true } = {}) {
+  return { key, width, height, readyHere, load: loadOf({ mbps, peakClass: mbps === null ? PEAK_CLASS.UNKNOWN : peakClass }, null) };
+}
+
+/**
+ * @param {object} over
+ * @param {number | null} [linkMbps] - What this viewer's link measured.
+ */
+function choose(over, linkMbps = null) {
+  return chooseServingOutput({
+    mode: "auto",
+    wanted: WANTED,
+    nextLowerArea: NEXT_LOWER,
+    atRisk: false,
+    judge: (one) => linkCouldCarry(linkMbps, one.load),
+    candidates: [],
+    ...over
+  })?.key ?? null;
+}
+
+test("the same quality or higher is served, the nearest of them", () => {
+  assert.equal(choose({ candidates: [candidate("2160", 3840, 2160), candidate("1080", 1920, 1080)] }), "1080");
+});
+
+test("higher quality is not served over a link it does not fit", () => {
+  assert.equal(choose({ candidates: [candidate("1080", 1920, 1080, { mbps: 12 })] }, 10), null);
+});
+
+test("a little lower — above the next rung down — is served, and only if the link admits it", () => {
+  assert.equal(choose({ candidates: [candidate("1000", 1776, 1000)] }), "1000");
+  assert.equal(
+    choose({ candidates: [candidate("1000", 1776, 1000, { mbps: 12 })] }, 10),
+    null,
+    "a smaller picture proves nothing by itself: its own load is asked"
+  );
+});
+
+test("the next rung down or lower is served only when making the wanted format risks a wait, and only if it fits", () => {
+  const lower = [candidate("720", 1280, 720), candidate("480", 854, 480)];
+  assert.equal(choose({ candidates: lower }), null);
+  assert.equal(choose({ candidates: lower, atRisk: true }), "720");
+  assert.equal(
+    choose({ candidates: [candidate("720", 1280, 720, { mbps: 12 }), candidate("480", 854, 480, { mbps: 3 })], atRisk: true }, 10),
+    "480",
+    "the larger one does not fit this link, so it is not taken"
+  );
+});
+
+test("an output without the piece at the viewer's position spares them nothing", () => {
+  assert.equal(choose({ candidates: [candidate("1080", 1920, 1080, { readyHere: false })] }), null);
+});
+
+test("a size chosen by hand is served only exactly, and only if the link admits it", () => {
+  const candidates = [candidate("1080", 1920, 1080), candidate("exact", 1824, 1026)];
+  assert.equal(choose({ mode: "manual", candidates }), "exact");
+  assert.equal(choose({ mode: "manual", candidates: [candidate("1080", 1920, 1080)], atRisk: true }), null);
+  assert.equal(
+    choose({ mode: "manual", candidates: [candidate("exact", 1824, 1026, { mbps: 12 })] }, 10),
+    null,
+    "the size they picked, but more than their link carries: not handed over"
+  );
+});
+
+test("of two outputs of the size picked by hand, the higher limit the link admits is served", () => {
+  const candidates = [candidate("2800", 1824, 1026, { mbps: 3.64 }), candidate("1400", 1824, 1026, { mbps: 1.82 })];
+  assert.equal(choose({ mode: "manual", candidates }, 10), "2800");
+  assert.equal(choose({ mode: "manual", candidates }, 3), "1400", "the link admits only the lower limit");
+});
+
+test("a bound is taken before an average, even when the average's limit is higher", () => {
+  const candidates = [
+    candidate("estimated", 1824, 1026, { mbps: 6, peakClass: PEAK_CLASS.ESTIMATED }),
+    candidate("known", 1824, 1026, { mbps: 4, peakClass: PEAK_CLASS.KNOWN })
+  ];
+  assert.equal(choose({ mode: "manual", candidates }, 10), "known");
+});
+
+test("an output with no bound is not served against a measured link, and is while nothing measured it", () => {
+  const candidates = [candidate("hardware", 1824, 1026, { mbps: null })];
+  assert.equal(choose({ mode: "manual", candidates }, 50), null);
+  assert.equal(choose({ mode: "manual", candidates }, null), "hardware");
+});