@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/letting-go-asks-who-is-watching.test.js

@@ -1,191 +0,0 @@
-/**
- * @file Letting go of a step must ask who is on it, at the moment of letting go.
- *
- * Two disposals in the step path reasoned "nobody is on it yet", and neither
- * could know it. An output is addressed by what it PRODUCES, so opening one
- * hands back the output that already makes that picture whenever there is one —
- * which may be a step another viewer has been watching all along. And a
- * genuinely new one is only nobody's until something else reaches it: making a
- * step takes a probe and a keyframe index, seconds in which a second viewer can
- * ask for the same height and be registered onto it.
- *
- * Both are the same fault, so both are one question asked of the registry now.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Renditions } from "../services/encode/Renditions.js";
-import { Viewers } from "../services/viewer/Viewers.js";
-import {
-  chooseOutput,
-  chosenOutputOf,
-  noteServingVerdict,
-  audioBeingWarmedOf,
-  audioChoiceOf,
-  chooseAudioTrack,
-  consumersOn,
-  linkMbpsOf,
-  noteAudioBeingWarmed,
-  noteStepBeingWarmed,
-  noteStepOnScreen,
-  placeOn,
-  presentOn,
-  qualityModeOf,
-  stepBeingWarmedOf,
-  stepOnScreenOf,
-  watches
-} from "../services/viewer/choices.js";
-import { SourceFile } from "../services/media/SourceFile.js";
-
-const BASE_ID = "4444444455556666";
-const STEP_ID = "5555555566667777";
-
-/**
- * A picture with one step of 720p, and whatever `createOrGetSession` is told to
- * hand back for the next request.
- *
- * @param {{ handBack: (() => object) | null, baseIsLive?: boolean, stepProducedHeight?: number }} how
- */
-function renditionsOver(how) {
-  const file = new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" });
-  // THE SAME MATERIAL, stated in full, because that is what the rule compares:
-  // the source, the container, the cut grid, what the output carries and which
-  // tracks. Two outputs of one picture differ in SIZE and in nothing else, and
-  // a stub that leaves those fields out is not a picture with two rungs — it is
-  // two outputs the rule cannot recognise as related.
-  const material = () => ({
-    transcodesAudio: false,
-    sourceKey: "source-1",
-    segmentFormatId: "fmp4",
-    grid: { toKey: () => "kf@0:100" },
-    carries: "video-only",
-    video: { fileIndex: 0 },
-    audio: null
-  });
-  const base = { id: BASE_ID, outputKey: "letting-go:base", file, spec: material(), timeline: { cutGrid: "uniform" }, segmentFormat: { id: "fmp4" } };
-  const step = { id: STEP_ID, outputKey: "letting-go:step", file, spec: material(), timeline: { cutGrid: "uniform" }, segmentFormat: { id: "fmp4" } };
-  const viewers = new Viewers();
-  const disposed = [];
-  const lines = [];
-  const outputs = {
-    get: (id) => (id === BASE_ID ? base : id === STEP_ID ? step : null),
-    touch: () => {},
-    markStep: () => {},
-    stepsOf: () => [step],
-    splicableHeights: () => [1080, 720],
-    // The step is NAMED 540 and may PRODUCE something else: an output answers
-    // for the picture it makes, not for the number in its name.
-    variantHeightOf: (output) => (output === base ? 1080 : 540),
-    // What each actually makes. The picture itself is a rung like any other,
-    // and when it is a re-encode a step can land on exactly its size — which is
-    // the case the adoption below exists for.
-    producedHeightOf: (output) => (output === base ? (how.baseProducedHeight ?? 1080) : (how.stepProducedHeight ?? 540)),
-    values: () => [base, step]
-  };
-  const renditions = new Renditions({
-    outputs,
-    viewerCountOn: (output) => viewers.forOutput(output).size,
-    outputStillNeeded: (output) => viewers.stillNeeded(output),
-    consumersOn: (output) => consumersOn(viewers, output),
-    presentOn: (output) => presentOn(viewers, output),
-    qualityModeOf: (output, consumerId) => qualityModeOf(viewers, output, consumerId),
-    linkMbpsOf: (output, consumerId) => linkMbpsOf(viewers, output, consumerId),
-    audioChoiceOf: (output, consumerId) => audioChoiceOf(viewers, output, consumerId),
-    chooseAudioTrack: (output, consumerId, trackIndex) => chooseAudioTrack(viewers, output, consumerId, trackIndex),
-    stepOnScreenOf: (output, consumerId) => stepOnScreenOf(viewers, output, consumerId),
-    noteStepOnScreen: (output, consumerId, stepId) => noteStepOnScreen(viewers, output, consumerId, stepId),
-    stepBeingWarmedOf: (output, consumerId) => stepBeingWarmedOf(viewers, output, consumerId),
-    noteStepBeingWarmed: (output, consumerId, stepId) => noteStepBeingWarmed(viewers, output, consumerId, stepId),
-    audioBeingWarmedOf: (output, consumerId) => audioBeingWarmedOf(viewers, output, consumerId),
-    noteAudioBeingWarmed: (output, consumerId, id) => noteAudioBeingWarmed(viewers, output, consumerId, id),
-    watches: (output, consumerId) => watches(viewers, output, consumerId),
-    placeOn: (output, consumerId, seconds) => placeOn(viewers, output, consumerId, seconds),
-    // Which output answers a height for a viewer is the viewer's own record.
-    chosenOutputOf: (consumerId, height) => chosenOutputOf(viewers, consumerId, height),
-    chooseOutput: (consumerId, height, key) => chooseOutput(viewers, consumerId, height, key),
-    noteServingVerdict: (consumerId, verdict) => noteServingVerdict(viewers, consumerId, verdict),
-    placeViewerOn: () => {},
-    viewerSecondsOn: () => 0,
-    activeOutputFor: () => base,
-    viewerPositionOf: () => 0,
-    outputTimes: { segmentStartTime: () => 0 },
-    encodeRuns: { isLive: () => how.baseIsLive !== false },
-    quality: { variantsOnScreen: () => new Set() },
-    createOrGetSession: async () => how.handBack(),
-    disposeSession: async (id) => { disposed.push(id); },
-    planEncodersSoon: () => {},
-    viewerLeaves: () => {},
-    logger: { info: (line) => lines.push(line), warn: (line) => lines.push(line), error: (line) => lines.push(line) }
-  });
-  return { renditions, base, step, viewers, disposed, lines };
-}
-
-test("an output handed back because it already makes this picture is not taken from its viewers", async () => {
-  // What `createOrGetSession` returns for a 720p request: the step that is
-  // already producing it, which somebody has been watching all along.
-  // The picture is itself re-encoded at 720 on this machine, so the step asked
-  // for produces the same picture it does: the case adoption is written for,
-  // and the one where what is let go of may be somebody's.
-  const { renditions, step, viewers, disposed } = renditionsOver({
-    handBack: () => step,
-    baseProducedHeight: 720,
-    stepProducedHeight: 720
-  });
-  viewers.of(step, "viewer-b");
-
-  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
-
-  assert.equal(resolved?.id, BASE_ID, "the incumbent making this picture answers for the height");
-  assert.deepEqual(disposed, [], "and the step handed back is not taken from the viewer on it");
-});
-
-test("a step a second viewer reached while it was being made is not disposed under them", async () => {
-  // The picture dies while the step is being prepared — the case the disposal
-  // was written for — but a second viewer has reached the step meanwhile.
-  const made = { id: STEP_ID };
-  const { renditions, viewers, disposed, lines } = renditionsOver({
-    baseIsLive: false,
-    handBack: () => {
-      // Registered onto it inside the window the disposal assumes is empty.
-      viewers.of(made, "viewer-b");
-      return made;
-    }
-  });
-
-  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
-
-  assert.equal(resolved, null, "the viewer who asked has lost the picture it was a step of");
-  assert.deepEqual(disposed, [], "but the step itself is somebody's now");
-  assert.ok(lines.some((line) => line.includes("kept although")), "and the reason is in the log");
-});
-
-test("a step nobody reached is still let go of when its picture dies", async () => {
-  const made = { id: STEP_ID };
-  const { renditions, disposed } = renditionsOver({ baseIsLive: false, handBack: () => made });
-
-  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
-
-  assert.equal(resolved, null);
-  assert.deepEqual(disposed, [STEP_ID], "nothing holds it, and it would hold an encoder until its idle timer");
-});
-
-test("a step nobody is watching is kept while a response from it is still being sent", async () => {
-  // The case the assignment exists for: the last viewer has stopped being
-  // registered on the output, and its bytes are still going out. Asked at the
-  // moment of letting go, which is the only moment at which the answer is
-  // about now.
-  const made = { id: STEP_ID, outputKey: "letting-go:made" };
-  const { renditions, viewers, disposed, lines } = renditionsOver({ baseIsLive: false, handBack: () => made });
-  const elsewhere = viewers.of({ id: "some-other-output" }, "viewer-c");
-  const token = elsewhere.assignments.accept(made.outputKey);
-
-  const resolved = await renditions.resolveVariantSession(BASE_ID, 720, -1, "viewer-a");
-
-  assert.equal(resolved, null, "the viewer who asked has lost the picture it was a step of");
-  assert.deepEqual(disposed, [], "but the output a response is being sent from is not taken away");
-  assert.ok(lines.some((line) => line.includes("kept although")), "and the reason is in the log");
-
-  // And once the response is done, nothing stands on it any more.
-  elsewhere.assignments.release(token);
-  assert.equal(viewers.stillNeeded(made), false);
-});

package/test/limit-row-by-area.test.js

@@ -1,60 +0,0 @@
-/**
- * @file The row of bitrate limits is chosen by the AREA of the frame, not by
- * its height (roadmap item 97, step 14; decided with the user 2026-09-24).
- *
- * The rows are the frames of the ladder at 16:9, as the encode itself sizes
- * them. A frame takes the row nearest by the ratio of areas; on the exact
- * border the larger row wins; a row with no nominal of its own takes the
- * nominal of the nearest row that has one.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { h264LevelFor, limitRowFor, nominalKbpsFor, softwareRateControlFor } from "../services/encode/args.js";
-
-test("a 2.4:1 film in a 1080 box is priced as 1080, not as 720", () => {
-  // 1920x800 is 1.54 million points: 1.35 times below the 1080 row, 1.67
-  // times above the 720 row. A height alone put it in the 720 row.
-  assert.equal(limitRowFor({ width: 1920, height: 800 }), 1080);
-  assert.equal(nominalKbpsFor({ width: 1920, height: 800 }), nominalKbpsFor({ width: 1920, height: 1080 }));
-});
-
-test("the 16:9 frames of the ladder each land in their own row", () => {
-  for (const [width, height] of [[3840, 2160], [2560, 1440], [1920, 1080], [1280, 720], [960, 540], [852, 480], [640, 360], [426, 240]]) {
-    assert.equal(limitRowFor({ width, height }), height, `${width}x${height}`);
-  }
-});
-
-test("a wide 720 frame falls in the 540 row and takes the nominal the 540 row borrows", () => {
-  // 1280x534 is 0.68 million points: 1.32 times above the 540 row and 1.35
-  // times below the 720 row. The 540 row has no nominal of its own yet, and the
-  // nearest row by area that has one is 480.
-  assert.equal(limitRowFor({ width: 1280, height: 534 }), 540);
-  assert.equal(nominalKbpsFor({ width: 1280, height: 534 }), nominalKbpsFor({ width: 852, height: 480 }));
-});
-
-test("on the exact border between two rows the larger row wins", () => {
-  // The border between 1280x720 (921600) and 1920x1080 (2073600) is their
-  // geometric mean, 1382400 = 1440x960, 1.5 times from each.
-  assert.equal(limitRowFor({ width: 1440, height: 960 }), 1080);
-});
-
-test("rows with no nominal of their own borrow the nearest row that has one", () => {
-  assert.equal(nominalKbpsFor({ width: 2560, height: 1440 }), nominalKbpsFor({ width: 1920, height: 1080 }));
-  assert.equal(nominalKbpsFor({ width: 3840, height: 2160 }), nominalKbpsFor({ width: 1920, height: 1080 }));
-  assert.equal(nominalKbpsFor({ width: 960, height: 540 }), nominalKbpsFor({ width: 852, height: 480 }));
-});
-
-test("the level of a wide frame is declared from the nominal of its row", () => {
-  const control = softwareRateControlFor({ width: 1920, height: 800, fps: 24 });
-  const nominal = nominalKbpsFor({ width: 1920, height: 1080 });
-  assert.equal(
-    control.level,
-    h264LevelFor({ width: 1920, height: 800, fps: 24, maxrateKbps: control.maxrateKbps, bufsizeKbps: control.bufsizeKbps })
-  );
-  assert.equal(control.maxrateKbps, Math.round(nominal * 1.3));
-});
-
-test("a frame with no area is refused rather than priced", () => {
-  assert.throws(() => limitRowFor({ width: 0, height: 720 }), RangeError);
-});

package/test/link-budget.test.js

@@ -1,111 +0,0 @@
-/**
- * @file What a viewer's link does with an output's whole load — roadmap item
- * 97, step 11.
- *
- * Pure functions over plain numbers: no session, no viewer, no clock.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import {
-  admissionRank,
-  LINK_VERDICT,
-  linkCouldCarry,
-  loadOf,
-  PEAK_CLASS,
-  soundtrackLoadOf,
-  videoLoadForFrame,
-  videoLoadOfSpec
-} from "../services/encode/quality/link-budget.js";
-import { AUDIO_TRANSCODE_KBPS, maxrateKbpsFor, nominalKbpsFor, softwareRateControlFor } from "../services/encode/args.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const known = (mbps) => ({ mbps, peakClass: PEAK_CLASS.KNOWN });
-const estimated = (mbps) => ({ mbps, peakClass: PEAK_CLASS.ESTIMATED });
-const unknown = () => ({ mbps: null, peakClass: PEAK_CLASS.UNKNOWN });
-
-test("a copied source at its own height is its stated average — an estimate, not a bound", () => {
-  const part = videoLoadForFrame({ sourceHeight: 1080, copiesAtSource: true, sourceMbps: 3.73, encoderKind: "software" }, { width: 1920, height: 1080 });
-  assert.deepEqual(part, estimated(3.73));
-});
-
-test("a height the software encoder makes is bounded by the nominal limit of that height", () => {
-  const part = videoLoadForFrame({ sourceHeight: 1080, copiesAtSource: true, sourceMbps: 3.73, encoderKind: "software" }, { width: 1280, height: 720 });
-  assert.deepEqual(part, known(maxrateKbpsFor(nominalKbpsFor({ width: 1280, height: 720 })) / 1000));
-});
-
-test("a height a hardware encoder makes has no bound at all", () => {
-  // It is given a quality figure and no -maxrate, so there is nothing to
-  // compare a link against.
-  const part = videoLoadForFrame({ sourceHeight: 1080, copiesAtSource: false, sourceMbps: 3.73, encoderKind: "nvenc" }, { width: 1280, height: 720 });
-  assert.deepEqual(part, unknown());
-});
-
-test("an output's picture is read off its own rate control", () => {
-  const rateControl = softwareRateControlFor({ width: 1280, height: 720, fps: 24, capKbps: 1400 });
-  const limited = outputSpec({ transcodeVideo: true, width: 1280, height: 720, rateControl });
-  const unlimited = outputSpec({ transcodeVideo: true, width: 1280, height: 720 });
-  assert.deepEqual(videoLoadOfSpec(limited, 3.73), known(rateControl.maxrateKbps / 1000));
-  assert.deepEqual(videoLoadOfSpec(unlimited, 3.73), unknown(), "no limit, no bound");
-  assert.deepEqual(videoLoadOfSpec(outputSpec(), 3.73), estimated(3.73), "a copy is its source's average");
-});
-
-test("a soundtrack is estimated when re-encoded or copied at a stated rate, known at its codec's bound, unknown when nothing states one", () => {
-  assert.deepEqual(soundtrackLoadOf({ bitrateKbps: null }, true), estimated(AUDIO_TRANSCODE_KBPS / 1000));
-  assert.deepEqual(soundtrackLoadOf({ bitrateKbps: 640 }, false), estimated(0.64));
-  assert.deepEqual(soundtrackLoadOf({ bitrateKbps: 640, peakKbps: 640 }, false), known(0.64));
-  assert.deepEqual(soundtrackLoadOf({ bitrateKbps: null }, false), unknown());
-  assert.equal(soundtrackLoadOf(null, null), null, "no sound, no part");
-});
-
-test("a load is as trustworthy as its least trustworthy part", () => {
-  assert.equal(loadOf(known(3), known(0.128)).peakClass, PEAK_CLASS.KNOWN);
-  assert.equal(loadOf(known(3), estimated(0.64)).peakClass, PEAK_CLASS.ESTIMATED);
-  assert.equal(loadOf(known(3), unknown()).peakClass, PEAK_CLASS.UNKNOWN);
-  assert.equal(loadOf(known(3), unknown()).totalMbps, null, "an unknown part leaves no total");
-  assert.ok(Math.abs(loadOf(known(3), known(0.128)).totalMbps - 3.128) < 1e-9, "the sound is added to the picture");
-});
-
-test("the sound is counted with the picture against the whole measured link", () => {
-  // The picture alone fits the link exactly; with the soundtrack the viewer
-  // hears, it does not. No share of the link is held back.
-  const link = 10;
-  const picture = known(link);
-  assert.equal(linkCouldCarry(link, loadOf(picture, null)).verdict, LINK_VERDICT.FITS, "without sound it would pass");
-  assert.equal(
-    linkCouldCarry(link, loadOf(picture, known(AUDIO_TRANSCODE_KBPS / 1000))).verdict,
-    LINK_VERDICT.DOES_NOT_FIT,
-    "with the 128 kbit/s soundtrack it does not"
-  );
-});
-
-test("a known load that passes fits and is confirmed; an estimated one is admitted and not confirmed", () => {
-  const fits = linkCouldCarry(10, loadOf(known(5), null));
-  assert.equal(fits.verdict, LINK_VERDICT.FITS);
-  assert.equal(fits.confirmed, true);
-  const byEstimate = linkCouldCarry(10, loadOf(estimated(5), null));
-  assert.equal(byEstimate.verdict, LINK_VERDICT.ESTIMATED_TO_FIT);
-  assert.equal(byEstimate.admitted, true);
-  assert.equal(byEstimate.confirmed, false, "an average is not a bound");
-});
-
-test("an unknown load is refused against a measured link, and admitted while nothing measured it", () => {
-  const measured = linkCouldCarry(50, loadOf(unknown(), null));
-  assert.equal(measured.verdict, LINK_VERDICT.NO_SAFE_BOUND);
-  assert.equal(measured.admitted, false, "there is no number to compare, however fast the link");
-  for (const unmeasured of [null, 0, Number.NaN]) {
-    const answer = linkCouldCarry(unmeasured, loadOf(unknown(), null));
-    assert.equal(answer.verdict, LINK_VERDICT.NO_MEASUREMENT);
-    assert.equal(answer.admitted, true, "the link gave no ground to refuse");
-    assert.equal(answer.confirmed, false);
-  }
-});
-
-test("a bound ranks before an average, and a refusal ranks nowhere", () => {
-  const knownAnswer = linkCouldCarry(null, loadOf(known(5), null));
-  const estimatedAnswer = linkCouldCarry(null, loadOf(estimated(5), null));
-  const unknownAnswer = linkCouldCarry(null, loadOf(unknown(), null));
-  assert.ok(admissionRank(knownAnswer) > admissionRank(estimatedAnswer));
-  assert.ok(admissionRank(estimatedAnswer) > admissionRank(unknownAnswer));
-  assert.equal(admissionRank(linkCouldCarry(1, loadOf(known(5), null))), 0);
-});

package/test/link-probe.test.js

@@ -1,56 +0,0 @@
-/**
- * @file The route that hands a browser bytes to time its link with.
- *
- * Only this end's half. How big an ask should be is derived on the page, from
- * what its last ask measured, and is checked where that function lives — a copy
- * of it here would be two owners of one rule, which is the fault this
- * repository keeps recording.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { handleApiLinkProbeGet, MAX_LINK_PROBE_BYTES } from "../routes/api/link-probe/get.js";
-
-/**
- * A reply that records what it was given.
- *
- * @returns {{ code: (n: number) => object, header: () => object, send: (b: unknown) => object, status: number | null, body: unknown }}
- */
-function fakeReply() {
-  const reply = {
-    status: /** @type {number | null} */ (null),
-    body: /** @type {unknown} */ (null),
-    code(n) {
-      reply.status = n;
-      return reply;
-    },
-    header() {
-      return reply;
-    },
-    send(body) {
-      reply.body = body;
-      return reply;
-    }
-  };
-  return reply;
-}
-
-
-
-test("the route answers exactly what was asked for, up to its own ceiling", async () => {
-  const small = fakeReply();
-  await handleApiLinkProbeGet({ query: { bytes: "65536" } }, small);
-  assert.equal(small.status, 200);
-  assert.equal(/** @type {Buffer} */ (small.body).length, 65536);
-
-  const huge = fakeReply();
-  await handleApiLinkProbeGet({ query: { bytes: "999999999" } }, huge);
-  assert.equal(/** @type {Buffer} */ (huge.body).length, MAX_LINK_PROBE_BYTES);
-});
-
-test("the route refuses an ask that is not a size", async () => {
-  const reply = fakeReply();
-  await handleApiLinkProbeGet({ query: { bytes: "none" } }, reply);
-  assert.equal(reply.status, 400);
-});