@torrent-tv/proxy 2.87.10 → 2.87.11

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-existing-output.test.js

@@ -1,102 +1,102 @@
-/**
- * @file An output already made serves a viewer when the rules decided with the
- * user 2026-09-16 allow it, through the paths a real request takes.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { writeFileSync } from "node:fs";
-import path from "node:path";
-import { managerWithOwnStore } from "./helpers/manager.js";
-import { outputSpec } from "./helpers/output-spec.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { Output } from "../services/encode/output/Output.js";
-
-const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
-
-function hostWithA1080pOutput(t) {
-  const { manager, store, cleanup } = managerWithOwnStore({
-    startupWaitMs: 0,
-    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
-  });
-  t.after(async () => {
-    await manager.lifecycle.disposeAll();
-    cleanup();
-  });
-  manager.encodeRuns.planEncodersNow = () => {};
-  manager.encodeRuns.planEncodersSoon = () => {};
-  manager.getCachedMediaInfo = () => ({ durationSeconds: 400, width: 1920, height: 1080, fps: 24 });
-  const spec = outputSpec({
-    sourceKey: TORRENT,
-    transcodeVideo: true,
-    transcodeAudio: false,
-    encoder: "h264_vaapi",
-    width: 1920,
-    height: 1080,
-    fps: 24,
-    cutGrid: "uniform"
-  });
-  const key = spec.toKey();
-  store.useFormat(key, fmp4Format);
-  // The piece at the start of the film is made.
-  writeFileSync(path.join(store.directoryFor(key), fmp4Format.segmentFileName(0)), Buffer.alloc(100));
-  const file = new SourceFile({ sourceKey: TORRENT, fileIndex: 0, name: "film.mkv" }).learn({ width: 1920, height: 1080, durationSeconds: 400 });
-  const made = {
-    id: spec.toName(),
-    spec,
-    get outputKey() { return this.spec.toKey(); },
-    file,
-    timeline: new Timeline({ boundaries: Array.from({ length: 101 }, (_, index) => index * 4), cutGrid: "uniform" }),
-    output: new Output({ encodeWidth: 1920, encodeHeight: 1080, outputFps: 24 }),
-    segmentFormat: fmp4Format,
-    useSyntheticPlaylist: true
-  };
-  manager.outputs.set(made.id, made);
-  return { manager, made };
-}
-
-function request(over) {
-  return {
-    sourceKey: TORRENT,
-    fileIndex: 0,
-    fileName: "film.mkv",
-    transcodeVideo: true,
-    transcodeAudio: false,
-    segmentFormatId: "fmp4",
-    ...over
-  };
-}
-
-test("the automatic choice is served by a better output whose piece at the viewer's position is made", async (t) => {
-  const { manager, made } = hostWithA1080pOutput(t);
-  const answered = await manager.viewerRequests.createOrGetSession(
-    request({ consumerId: "auto-viewer", targetWidth: 1280, targetHeight: 720 })
-  );
-  assert.equal(answered, made);
-});
-
-test("a size picked by hand is not served by another size", async (t) => {
-  const { manager, made } = hostWithA1080pOutput(t);
-  let answered = null;
-  try {
-    answered = await manager.viewerRequests.createOrGetSession(
-      request({ consumerId: "picker", targetWidth: 1280, targetHeight: 720, exactSize: true })
-    );
-  } catch {
-    answered = null;
-  }
-  assert.notEqual(answered, made);
-});
-
-test("a step asked for by an automatic viewer and served by the picture leaves the picture a picture", async (t) => {
-  const { manager, made } = hostWithA1080pOutput(t);
-  manager.viewers.of(made, "auto-viewer").qualityMode = "auto";
-
-  const variant = await manager.renditions.resolveVariantSession(made.id, 720, 0, "auto-viewer");
-
-  assert.equal(variant, made, "the picture already made at 1080p serves the 720p request");
-  assert.notEqual(made.isStep, true, "and is not turned into a step of itself");
-  assert.ok(manager.viewers.forOutput(made).has("auto-viewer"));
-});
+/**
+ * @file An output already made serves a viewer when the rules decided with the
+ * user 2026-09-16 allow it, through the paths a real request takes.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { managerWithOwnStore } from "./helpers/manager.js";
+import { outputSpec } from "./helpers/output-spec.js";
+import { SourceFile } from "../services/media/SourceFile.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { Output } from "../services/encode/output/Output.js";
+
+const TORRENT = "torrent:11f0929918e2b5aa2e5b71ecdbe5c0f1a4bbf7d1";
+
+function hostWithA1080pOutput(t) {
+  const { manager, store, cleanup } = managerWithOwnStore({
+    startupWaitMs: 0,
+    videoEncoder: { kind: "vaapi", name: "h264_vaapi", inputArgs: [] }
+  });
+  t.after(async () => {
+    await manager.lifecycle.disposeAll();
+    cleanup();
+  });
+  manager.encodeRuns.planEncodersNow = () => {};
+  manager.encodeRuns.planEncodersSoon = () => {};
+  manager.getCachedMediaInfo = () => ({ durationSeconds: 400, width: 1920, height: 1080, fps: 24 });
+  const spec = outputSpec({
+    sourceKey: TORRENT,
+    transcodeVideo: true,
+    transcodeAudio: false,
+    encoder: "h264_vaapi",
+    width: 1920,
+    height: 1080,
+    fps: 24,
+    cutGrid: "uniform"
+  });
+  const key = spec.toKey();
+  store.useFormat(key, fmp4Format);
+  // The piece at the start of the film is made.
+  writeFileSync(path.join(store.directoryFor(key), fmp4Format.segmentFileName(0)), Buffer.alloc(100));
+  const file = new SourceFile({ sourceKey: TORRENT, fileIndex: 0, name: "film.mkv" }).learn({ width: 1920, height: 1080, durationSeconds: 400 });
+  const made = {
+    id: spec.toName(),
+    spec,
+    get outputKey() { return this.spec.toKey(); },
+    file,
+    timeline: new Timeline({ boundaries: Array.from({ length: 101 }, (_, index) => index * 4), cutGrid: "uniform" }),
+    output: new Output({ encodeWidth: 1920, encodeHeight: 1080, outputFps: 24 }),
+    segmentFormat: fmp4Format,
+    useSyntheticPlaylist: true
+  };
+  manager.outputs.set(made.id, made);
+  return { manager, made };
+}
+
+function request(over) {
+  return {
+    sourceKey: TORRENT,
+    fileIndex: 0,
+    fileName: "film.mkv",
+    transcodeVideo: true,
+    transcodeAudio: false,
+    segmentFormatId: "fmp4",
+    ...over
+  };
+}
+
+test("the automatic choice is served by a better output whose piece at the viewer's position is made", async (t) => {
+  const { manager, made } = hostWithA1080pOutput(t);
+  const answered = await manager.viewerRequests.createOrGetSession(
+    request({ consumerId: "auto-viewer", targetWidth: 1280, targetHeight: 720 })
+  );
+  assert.equal(answered, made);
+});
+
+test("a size picked by hand is not served by another size", async (t) => {
+  const { manager, made } = hostWithA1080pOutput(t);
+  let answered = null;
+  try {
+    answered = await manager.viewerRequests.createOrGetSession(
+      request({ consumerId: "picker", targetWidth: 1280, targetHeight: 720, exactSize: true })
+    );
+  } catch {
+    answered = null;
+  }
+  assert.notEqual(answered, made);
+});
+
+test("a step asked for by an automatic viewer and served by the picture leaves the picture a picture", async (t) => {
+  const { manager, made } = hostWithA1080pOutput(t);
+  manager.viewers.of(made, "auto-viewer").qualityMode = "auto";
+
+  const variant = await manager.renditions.resolveVariantSession(made.id, 720, 0, "auto-viewer");
+
+  assert.equal(variant, made, "the picture already made at 1080p serves the 720p request");
+  assert.notEqual(made.isStep, true, "and is not turned into a step of itself");
+  assert.ok(manager.viewers.forOutput(made).has("auto-viewer"));
+});

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");
+});