@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/concurrent-cost.test.js

@@ -1,148 +0,0 @@
-/**
- * @file A rung is judged against the machine it will actually have.
- *
- * The field case of 2026-08-15, in arithmetic: a copy of the picture took about
- * 0.125 s of work per second of video (7.9-8.0x measured), a 240p rung needed
- * about 1.05, and the two together are more than the one second per second the
- * machine has. The budget priced the copy at nothing, offered the rung, and the
- * viewer watched it fail.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { canSustainOutput } from "../services/encode/hwaccel.js";
-
-// A host that encodes 640x360 at 24 fps about eleven times over, and decodes
-// 1080p24 at 2.6x — the addon host's own figures.
-const BENCHMARK = [
-  { preset: "fast", pixelsPerSec: 17.0e6 },
-  { preset: "ultrafast", pixelsPerSec: 67.5e6 }
-];
-const DECODE_MODEL = { pixelTerm: 0.007742, bitrateTerm: 0, constantTerm: 0 };
-const SOURCE = { megapixelsPerSecond: (1920 * 1080 * 24) / 1e6, megabitsPerSecond: 8 };
-const RUNG_240P = 426 * 240 * 24;
-
-test("a rung is judged on the machine it will have, not on an empty one", () => {
-  const alone = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P
-  });
-  const beside = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    // The picture is being copied beside it, at the cost the field measured.
-    concurrentCostSec: 0.125
-  });
-  assert.ok(alone.speed !== null && beside.speed !== null);
-  assert.ok(beside.speed < alone.speed, "sharing the machine cannot make a rung faster");
-});
-
-test("nothing else running leaves the answer exactly as it was", () => {
-  const withZero = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0
-  });
-  const without = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P
-  });
-  assert.equal(withZero.speed, without.speed);
-});
-
-test("a wiring made without the startup calibration judges nothing", () => {
-  const answer = canSustainOutput({
-    benchmark: null,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.125
-  });
-  assert.equal(answer.sustainable, true);
-  assert.equal(answer.speed, null);
-});
-
-test("a host calibrated with no mode qualified refuses a re-encode (roadmap item 97, step 14)", () => {
-  const answer = canSustainOutput({
-    benchmark: [],
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.125
-  });
-  assert.equal(answer.sustainable, false, "unknown capacity is not capacity");
-  assert.equal(answer.speed, null);
-});
-
-test("a cost heavy enough to fill the machine puts a rung below realtime", () => {
-  const answer = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.9
-  });
-  assert.ok(answer.speed !== null && answer.speed < 1, "0.9 of the machine spent elsewhere leaves less than realtime");
-  assert.equal(answer.sustainable, false);
-});
-
-test("a soundtrack encoder is not free once it has been measured", () => {
-  // The second half of roadmap item 6. An audio rendition runs for as long as
-  // the picture does — it is a second encoder by construction, not an extra —
-  // and the budget counted it at nothing. Small beside a picture, and small is
-  // not zero: on a host where a rung needs almost the whole machine, this is
-  // the difference between offering it and refusing it.
-  const withoutAudio = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0.125
-  });
-  const withAudio = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    // The copy, plus a soundtrack measured at about twenty times realtime.
-    concurrentCostSec: 0.125 + 0.05
-  });
-  assert.ok(
-    withAudio.speed < withoutAudio.speed,
-    "charging for the soundtrack must lower what the machine has left for the picture"
-  );
-});
-
-test("two pictures encoding at once are charged as two", () => {
-  // The warm-up that makes a quality switch seamless runs two encoders on
-  // purpose. Measured 2026-08-15: the new rung ran at 0.504x for its first four
-  // seconds, against 0.90-0.99x once it had the machine to itself and 1.58x
-  // predicted for an idle one. Priced as though it were alone, the budget
-  // describes a machine that does not exist at the moment the viewer switches.
-  const alone = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    concurrentCostSec: 0
-  });
-  const besideAnother = canSustainOutput({
-    benchmark: BENCHMARK,
-    decodeModel: DECODE_MODEL,
-    source: SOURCE,
-    outputPixelsPerSec: RUNG_240P,
-    // Another rung of the same family, already running at about realtime.
-    concurrentCostSec: 1 / 1.05
-  });
-  assert.ok(alone.sustainable, "the rung must be offerable on an idle machine, or the case is not the one meant");
-  assert.equal(
-    besideAnother.sustainable,
-    false,
-    "a machine already spending a second per second of video has nothing left for a second picture"
-  );
-});

package/test/container-media-info.test.js

@@ -1,228 +0,0 @@
-/**
- * @file What a file declares about ITSELF — format, duration, and where its own
- * timeline begins — read from its header by the container layer.
- *
- * These fixtures are built byte by byte rather than produced by ffmpeg, on
- * purpose: a test that runs a real encoder measures the machine it runs on, and
- * two such tests in this suite have failed four times in one day for exactly
- * that reason (roadmap item 54). The numbers here are checked against ffmpeg
- * ONCE, by hand, and the result is recorded rather than re-measured on every
- * run — 2026-09-03, a Matroska file offset by 0.130435 s: ffmpeg reported
- * `Duration: 00:00:02.13, start: 0.130000` and this reader answered
- * `durationSeconds 2.131, startTimeSeconds 0.13`, which is the same number at
- * the precision each prints. The same file as MP4: `start: 0.000000` from
- * ffmpeg, 0 from this reader.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { MatroskaContainer } from "../services/media/container/MatroskaContainer.js";
-import { Mp4Container } from "../services/media/container/Mp4Container.js";
-import { AviContainer } from "../services/media/container/AviContainer.js";
-
-/**
- * An EBML element: its id bytes, a four-byte size, then the payload.
- *
- * @param {number[]} idBytes
- * @param {Buffer} payload
- * @returns {Buffer}
- */
-function ebml(idBytes, payload) {
-  const size = Buffer.alloc(4);
-  // Four-byte size form: `0001xxxx` in the leading byte marks the width.
-  size.writeUInt32BE(payload.length);
-  size[0] |= 0x10;
-  return Buffer.concat([Buffer.from(idBytes), size, payload]);
-}
-
-/** @param {number} value @param {number} bytes @returns {Buffer} */
-function uint(value, bytes) {
-  const out = Buffer.alloc(bytes);
-  out.writeUIntBE(value, 0, bytes);
-  return out;
-}
-
-/** @param {number} value @returns {Buffer} */
-function float64(value) {
-  const out = Buffer.alloc(8);
-  out.writeDoubleBE(value);
-  return out;
-}
-
-const ID_EBML_HEADER = [0x1a, 0x45, 0xdf, 0xa3];
-const ID_SEGMENT = [0x18, 0x53, 0x80, 0x67];
-const ID_SEEK_HEAD = [0x11, 0x4d, 0x9b, 0x74];
-const ID_SEEK = [0x4d, 0xbb];
-const ID_SEEK_ID = [0x53, 0xab];
-const ID_SEEK_POSITION = [0x53, 0xac];
-const ID_INFO = [0x15, 0x49, 0xa9, 0x66];
-const ID_TIMESTAMP_SCALE = [0x2a, 0xd7, 0xb1];
-const ID_DURATION = [0x44, 0x89];
-const ID_CLUSTER = [0x1f, 0x43, 0xb6, 0x75];
-const ID_TIMESTAMP = [0xe7];
-const ID_VOID = [0xec];
-
-/**
- * A reader over a buffer, in the shape the container layer takes.
- *
- * @param {Buffer} bytes
- * @returns {(start: number, end: number) => Promise<Buffer>}
- */
-function readerOver(bytes) {
-  return async (start, end) => bytes.subarray(start, Math.min(end + 1, bytes.length));
-}
-
-test("a Matroska file states its duration in ticks and its start in the first cluster", async () => {
-  const info = ebml(ID_INFO, Buffer.concat([
-    ebml(ID_TIMESTAMP_SCALE, uint(1_000_000, 3)),
-    // 2131 ticks of a millisecond each.
-    ebml(ID_DURATION, float64(2131))
-  ]));
-  const cluster = ebml(ID_CLUSTER, ebml(ID_TIMESTAMP, uint(130, 1)));
-  const file = Buffer.concat([
-    ebml(ID_EBML_HEADER, Buffer.alloc(4)),
-    ebml(ID_SEGMENT, Buffer.concat([info, cluster]))
-  ]);
-
-  const container = new MatroskaContainer({ readRange: readerOver(file), fileSize: file.length });
-  const read = await container.readMediaInfo();
-
-  assert.equal(read.format, "matroska");
-  assert.ok(Math.abs(read.durationSeconds - 2.131) < 1e-9, `duration was ${read.durationSeconds}`);
-  assert.ok(Math.abs(read.startTimeSeconds - 0.13) < 1e-9, `start was ${read.startTimeSeconds}`);
-});
-
-test("a cluster past the head window is found through the SeekHead", async () => {
-  // Everything before the cluster is padded past the 64 KB the head read covers,
-  // which is the case this second path exists for: a file whose Tracks element
-  // is large enough to push the first cluster out of reach.
-  const info = ebml(ID_INFO, ebml(ID_TIMESTAMP_SCALE, uint(1_000_000, 3)));
-  const padding = ebml(ID_VOID, Buffer.alloc(70 * 1024));
-  const cluster = ebml(ID_CLUSTER, ebml(ID_TIMESTAMP, uint(2500, 2)));
-  // The SeekHead is written first, so its own length is known before the
-  // position it names can be computed — build it with a placeholder, measure,
-  // then write the real position.
-  const seekHeadFor = (position) => ebml(ID_SEEK_HEAD, ebml(ID_SEEK, Buffer.concat([
-    ebml(ID_SEEK_ID, Buffer.from(ID_CLUSTER)),
-    ebml(ID_SEEK_POSITION, uint(position, 4))
-  ])));
-  const seekHeadLength = seekHeadFor(0).length;
-  const clusterPosition = seekHeadLength + info.length + padding.length;
-  const segmentPayload = Buffer.concat([seekHeadFor(clusterPosition), info, padding, cluster]);
-  const file = Buffer.concat([
-    ebml(ID_EBML_HEADER, Buffer.alloc(4)),
-    ebml(ID_SEGMENT, segmentPayload)
-  ]);
-
-  const container = new MatroskaContainer({ readRange: readerOver(file), fileSize: file.length });
-  const read = await container.readMediaInfo();
-
-  assert.ok(Math.abs(read.startTimeSeconds - 2.5) < 1e-9, `start was ${read.startTimeSeconds}`);
-});
-
-test("a Matroska file that declares no duration says so, rather than saying zero", async () => {
-  const cluster = ebml(ID_CLUSTER, ebml(ID_TIMESTAMP, uint(0, 1)));
-  const file = Buffer.concat([
-    ebml(ID_EBML_HEADER, Buffer.alloc(4)),
-    ebml(ID_SEGMENT, cluster)
-  ]);
-
-  const container = new MatroskaContainer({ readRange: readerOver(file), fileSize: file.length });
-  const read = await container.readMediaInfo();
-
-  assert.equal(read.durationSeconds, null);
-  assert.equal(read.startTimeSeconds, 0);
-});
-
-/**
- * An ISO/IEC 14496-12 box.
- *
- * @param {string} type
- * @param {Buffer} payload
- * @returns {Buffer}
- */
-function box(type, payload) {
-  const header = Buffer.alloc(8);
-  header.writeUInt32BE(payload.length + 8);
-  header.write(type, 4, "latin1");
-  return Buffer.concat([header, payload]);
-}
-
-test("an MP4 states its duration in mvhd and its start in an empty edit", async () => {
-  const mvhd = box("mvhd", Buffer.concat([
-    Buffer.alloc(4), // version 0 + flags
-    Buffer.alloc(8), // creation, modification
-    uint(1000, 4), // timescale: ticks per second
-    uint(2000, 4), // duration: two seconds
-    Buffer.alloc(80)
-  ]));
-  const elst = box("elst", Buffer.concat([
-    Buffer.alloc(4), // version 0 + flags
-    uint(1, 4), // one entry
-    uint(130, 4), // segment_duration: 0.130 s at the movie timescale
-    Buffer.from([0xff, 0xff, 0xff, 0xff]), // media_time -1: an EMPTY edit
-    uint(0x00010000, 4) // media_rate 1.0
-  ]));
-  const trak = box("trak", box("edts", elst));
-  const file = Buffer.concat([
-    box("ftyp", Buffer.from("isom", "latin1")),
-    box("moov", Buffer.concat([mvhd, trak]))
-  ]);
-
-  const container = new Mp4Container({ readRange: readerOver(file), fileSize: file.length });
-  const read = await container.readMediaInfo();
-
-  assert.equal(read.format, "mp4");
-  assert.ok(Math.abs(read.durationSeconds - 2) < 1e-9, `duration was ${read.durationSeconds}`);
-  assert.ok(Math.abs(read.startTimeSeconds - 0.13) < 1e-9, `start was ${read.startTimeSeconds}`);
-});
-
-test("an MP4 with no edit list begins at zero, and that is an answer", async () => {
-  const mvhd = box("mvhd", Buffer.concat([
-    Buffer.alloc(4),
-    Buffer.alloc(8),
-    uint(600, 4),
-    uint(1200, 4),
-    Buffer.alloc(80)
-  ]));
-  const file = Buffer.concat([
-    box("ftyp", Buffer.from("isom", "latin1")),
-    box("moov", mvhd)
-  ]);
-
-  const container = new Mp4Container({ readRange: readerOver(file), fileSize: file.length });
-  const read = await container.readMediaInfo();
-
-  assert.ok(Math.abs(read.durationSeconds - 2) < 1e-9, `duration was ${read.durationSeconds}`);
-  assert.equal(read.startTimeSeconds, 0);
-});
-
-test("an AVI states its length as microseconds per frame times the frame count", async () => {
-  const avih = Buffer.concat([
-    Buffer.from("avih", "latin1"),
-    uint(56, 4),
-    Buffer.from(new Uint8Array(new Uint32Array([
-      40_000, // dwMicroSecPerFrame: 25 fps
-      0, 0, 0,
-      50 // dwTotalFrames: two seconds of them
-    ]).buffer)),
-    Buffer.alloc(36)
-  ]);
-  const file = Buffer.concat([
-    Buffer.from("RIFF", "latin1"),
-    uint(0, 4),
-    Buffer.from("AVI ", "latin1"),
-    Buffer.from("LIST", "latin1"),
-    uint(avih.length + 4, 4),
-    Buffer.from("hdrl", "latin1"),
-    avih
-  ]);
-
-  const container = new AviContainer({ readRange: readerOver(file), fileSize: file.length });
-  const read = await container.readMediaInfo();
-
-  assert.equal(read.format, "avi");
-  assert.ok(Math.abs(read.durationSeconds - 2) < 1e-9, `duration was ${read.durationSeconds}`);
-  assert.equal(read.startTimeSeconds, 0);
-});

package/test/contention.test.js

@@ -1,76 +0,0 @@
-/**
- * @file The price of a second job, with the readings it was derived from.
- *
- * Measured on the addon host 2026-08-18: decoding the same clip ran at 2.20x
- * alone, 0.85x with one encoder beside it and 0.60x with two. The budget has
- * been adding independent prices, and these say two jobs that each fit alone do
- * not fit together.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { contentionPenalty, costWithContention, penaltiesFrom } from "../services/encode/contention.js";
-
-/** The addon host's own readings. */
-const ALONE = 2.2;
-const BESIDE = [
-  { others: 1, speed: 0.85 },
-  { others: 2, speed: 0.6 }
-];
-
-test("the penalties are the ratios of the measured speeds", () => {
-  const penalties = penaltiesFrom(ALONE, BESIDE);
-
-  assert.ok(penalties);
-  // 2.2 / 0.85 = 2.59: the same work costs two and a half times more with one
-  // encoder beside it.
-  assert.ok(Math.abs(penalties.get(1) - 2.588) < 0.01, `${penalties.get(1)}`);
-  assert.ok(Math.abs(penalties.get(2) - 3.667) < 0.01, `${penalties.get(2)}`);
-});
-
-test("alone on the machine is what the benchmarks measure, so nothing is corrected", () => {
-  const penalties = penaltiesFrom(ALONE, BESIDE);
-  const answer = contentionPenalty(0, penalties);
-  assert.equal(answer.penalty, 1);
-  assert.equal(answer.measured, true);
-  assert.equal(costWithContention(0.45, 0, penalties), 0.45);
-});
-
-test("a cost beside one other job is the measured multiple, not the sum of two prices", () => {
-  const penalties = penaltiesFrom(ALONE, BESIDE);
-  // Decoding priced at 0.45 s/s alone becomes 1.17 s/s beside an encoder —
-  // which is what the field measured (1.18), and what additivity cannot say.
-  const corrected = costWithContention(0.45, 1, penalties);
-  assert.ok(Math.abs(corrected - 1.165) < 0.01, `${corrected}`);
-});
-
-test("beyond the readings it holds the largest instead of extrapolating", () => {
-  const penalties = penaltiesFrom(ALONE, BESIDE);
-  const four = contentionPenalty(4, penalties);
-  assert.equal(four.penalty, penalties.get(2), "two readings say nothing about a fourth job");
-  assert.equal(four.from, 2, "and the answer says which reading it came from");
-  assert.equal(four.measured, true);
-});
-
-test("with nothing measured the prediction is left alone, not guessed at", () => {
-  const answer = contentionPenalty(1, null);
-  assert.equal(answer.penalty, 1);
-  assert.equal(answer.measured, false, "the caller must be able to say the figure is uncorrected");
-  assert.equal(costWithContention(0.45, 1, null), 0.45);
-  assert.equal(contentionPenalty(1, new Map()).measured, false);
-});
-
-test("a machine that got faster for being busier has no penalty to measure", () => {
-  // Noise on a fast host, not a discovery. Measured on the developer's desktop,
-  // the difference between one and two jobs is inside the scatter.
-  const penalties = penaltiesFrom(20, [{ others: 1, speed: 21 }]);
-  assert.equal(penalties.get(1), 1);
-});
-
-test("readings that are not measurements are left out", () => {
-  assert.equal(penaltiesFrom(0, BESIDE), null, "every penalty is relative to the alone reading");
-  assert.equal(penaltiesFrom(ALONE, []), null);
-  assert.equal(penaltiesFrom(ALONE, [{ others: 0, speed: 2 }]), null, "zero others is not a penalty");
-  assert.equal(penaltiesFrom(ALONE, [{ others: 1, speed: Number.NaN }]), null);
-});

package/test/core-dumps.test.js

@@ -1,57 +0,0 @@
-/**
- * @file Keep the last few core dumps and no more.
- *
- * Each is the worker thread's whole address space — 4.18 GB on the field host —
- * and four of them had nearly filled a 235 GB disk by 2026-08-21. The newest
- * are evidence for a fault that is still open, so they stay; the rest go.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { dumpsToRemove, isCoreDump } from "../services/storage/core-dumps.js";
-
-const dumps = [
-  { name: "core.WorkerThread.81.1787176646", writtenAt: 1787176646000 },
-  { name: "core.WorkerThread.81.1787224562", writtenAt: 1787224562000 },
-  { name: "core.WorkerThread.81.1787237468", writtenAt: 1787237468000 },
-  { name: "core.WorkerThread.81.1787243278", writtenAt: 1787243278000 },
-  { name: "core.WorkerThread.81.1787292750", writtenAt: 1787292750000 }
-];
-
-test("the newest two stay and the rest go, oldest first", () => {
-  assert.deepEqual(dumpsToRemove(dumps), [
-    "core.WorkerThread.81.1787176646",
-    "core.WorkerThread.81.1787224562",
-    "core.WorkerThread.81.1787237468"
-  ]);
-});
-
-test("fewer than the limit leaves everything alone", () => {
-  assert.deepEqual(dumpsToRemove(dumps.slice(0, 2)), []);
-  assert.deepEqual(dumpsToRemove([]), []);
-});
-
-test("order on disk does not decide; the time written does", () => {
-  const shuffled = [dumps[3], dumps[0], dumps[4], dumps[2], dumps[1]];
-  assert.deepEqual(dumpsToRemove(shuffled, 1), [
-    "core.WorkerThread.81.1787176646",
-    "core.WorkerThread.81.1787224562",
-    "core.WorkerThread.81.1787237468",
-    "core.WorkerThread.81.1787243278"
-  ]);
-});
-
-test("only core dumps are considered", () => {
-  assert.equal(isCoreDump("core.WorkerThread.81.1787292750"), true);
-  assert.equal(isCoreDump("proxy.log"), false);
-  assert.equal(isCoreDump("host-timings.json"), false);
-  // Not a path, and not a directory called core.
-  assert.equal(isCoreDump("core.foo/bar"), false);
-  assert.equal(isCoreDump(""), false);
-});
-
-test("nothing readable is not a reason to delete anything", () => {
-  assert.deepEqual(dumpsToRemove(null), []);
-  assert.deepEqual(dumpsToRemove([{ name: 5, writtenAt: "x" }]), []);
-});