@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/helpers/matroska-file.js

@@ -1,296 +0,0 @@
-/**
- * @file Synthetic Matroska files for the checks — built element by element,
- * so every check states exactly what the file says and where.
- *
- * Positions inside the Segment are known only after the elements before them
- * are built, so a file is described as a list of top-level elements, and the
- * SeekHead and Cues that point at others are built from the lengths of the
- * rest (all positions are fixed-width, so they do not change the lengths they
- * are computed from).
- */
-
-import { crc32 } from "node:zlib";
-
-export const ID = {
-  EBML: 0x1a45dfa3,
-  SEGMENT: 0x18538067,
-  SEEK_HEAD: 0x114d9b74,
-  SEEK: 0x4dbb,
-  SEEK_ID: 0x53ab,
-  SEEK_POSITION: 0x53ac,
-  INFO: 0x1549a966,
-  TIMESTAMP_SCALE: 0x2ad7b1,
-  TRACKS: 0x1654ae6b,
-  TRACK_ENTRY: 0xae,
-  TRACK_NUMBER: 0xd7,
-  TRACK_TYPE: 0x83,
-  CODEC_ID: 0x86,
-  LANGUAGE: 0x22b59c,
-  LANGUAGE_BCP47: 0x22b59d,
-  NAME: 0x536e,
-  CUES: 0x1c53bb6b,
-  CUE_POINT: 0xbb,
-  CUE_TIME: 0xb3,
-  CUE_TRACK_POSITIONS: 0xb7,
-  CUE_TRACK: 0xf7,
-  CUE_CLUSTER_POSITION: 0xf1,
-  CLUSTER: 0x1f43b675,
-  TIMESTAMP: 0xe7,
-  CRC32: 0xbf,
-  SIMPLE_BLOCK: 0xa3,
-  BLOCK_GROUP: 0xa0,
-  BLOCK: 0xa1,
-  BLOCK_DURATION: 0x9b,
-  VOID: 0xec
-};
-
-/** @param {number} id @returns {Buffer} */
-export function idBytes(id) {
-  const bytes = [];
-  let rest = id;
-  while (rest > 0) {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  }
-  return Buffer.from(bytes);
-}
-
-/** A four-byte size: a valid vint whatever the payload. @param {number} size */
-function sizeBytes(size) {
-  const buffer = Buffer.alloc(4);
-  buffer.writeUInt32BE(size, 0);
-  buffer[0] |= 0x10;
-  return buffer;
-}
-
-/** @param {number} id @param {Buffer} payload @returns {Buffer} */
-export function element(id, payload) {
-  return Buffer.concat([idBytes(id), sizeBytes(payload.length), payload]);
-}
-
-/** An element whose size field says "unknown" (one byte, all value bits set). */
-export function unknownSizeElement(id, payload) {
-  return Buffer.concat([idBytes(id), Buffer.from([0xff]), payload]);
-}
-
-/** @param {number} id @param {number} value */
-export function uintElement(id, value) {
-  const bytes = [];
-  let rest = value;
-  do {
-    bytes.unshift(rest & 0xff);
-    rest = Math.floor(rest / 256);
-  } while (rest > 0);
-  return element(id, Buffer.from(bytes));
-}
-
-/** A fixed-width unsigned integer, so a position computed twice keeps its length. */
-export function uint32Element(id, value) {
-  const payload = Buffer.alloc(4);
-  payload.writeUInt32BE(value, 0);
-  return element(id, payload);
-}
-
-/** @param {number} id @param {string} value */
-export function stringElement(id, value) {
-  return element(id, Buffer.from(value, "utf8"));
-}
-
-/**
- * @param {{ number: number, type: number, codecId: string, language?: string | null, languageBcp47?: string, name?: string }} track
- * @returns {Buffer}
- */
-export function trackEntry({ number, type, codecId, language = null, languageBcp47 = "", name = "" }) {
-  const parts = [uintElement(ID.TRACK_NUMBER, number), uintElement(ID.TRACK_TYPE, type), stringElement(ID.CODEC_ID, codecId)];
-  if (language !== null) {
-    parts.push(stringElement(ID.LANGUAGE, language));
-  }
-  if (languageBcp47) {
-    parts.push(stringElement(ID.LANGUAGE_BCP47, languageBcp47));
-  }
-  if (name) {
-    parts.push(stringElement(ID.NAME, name));
-  }
-  return element(ID.TRACK_ENTRY, Buffer.concat(parts));
-}
-
-/**
- * One cue, as a BlockGroup carrying its own duration.
- *
- * @param {{ track: number, relativeTicks: number, durationTicks: number, text: string }} params
- */
-export function cueBlock({ track, relativeTicks, durationTicks, text }) {
-  const header = Buffer.alloc(4);
-  header[0] = 0x80 | track;
-  header.writeInt16BE(relativeTicks, 1);
-  header[3] = 0;
-  const block = element(ID.BLOCK, Buffer.concat([header, Buffer.from(text, "utf8")]));
-  return element(ID.BLOCK_GROUP, Buffer.concat([block, uintElement(ID.BLOCK_DURATION, durationTicks)]));
-}
-
-/**
- * A picture block: a SimpleBlock of `payload` bytes on `track`.
- *
- * @param {{ track: number, payload: Buffer }} params
- */
-export function pictureBlock({ track, payload }) {
-  const header = Buffer.alloc(4);
-  header[0] = 0x80 | track;
-  header.writeInt16BE(0, 1);
-  header[3] = 0x80;
-  return element(ID.SIMPLE_BLOCK, Buffer.concat([header, payload]));
-}
-
-/**
- * A cluster's DATA: its Timestamp (optionally after a CRC-32) and its blocks.
- *
- * @param {{ ticks: number, blocks: Buffer[], crc?: boolean | "wrong" }} params
- * @returns {Buffer}
- */
-export function clusterData({ ticks, blocks, crc = false }) {
-  const rest = Buffer.concat([uintElement(ID.TIMESTAMP, ticks), ...blocks]);
-  if (!crc) {
-    return rest;
-  }
-  const value = Buffer.alloc(4);
-  value.writeUInt32LE(crc === "wrong" ? (crc32(rest) ^ 0xffffffff) >>> 0 : crc32(rest), 0);
-  return Buffer.concat([Buffer.concat([idBytes(ID.CRC32), Buffer.from([0x84]), value]), rest]);
-}
-
-/**
- * A whole file.
- *
- * `clusters` are each `{ data, unknownSize? }`. `cues` says which tracks the
- * Cues table names for every cluster: an array of track numbers, or null for
- * no Cues element at all. `cuesBeforeClusters` puts the Cues element ahead of
- * the clusters with no SeekHead entry for it.
- *
- * @param {object} params
- * @param {Buffer[]} params.tracks - TrackEntry elements.
- * @param {Array<{ data: Buffer, unknownSize?: boolean, ticks: number }>} params.clusters
- * @param {number[] | null} [params.cues]
- * @param {boolean} [params.cuesBeforeClusters]
- * @returns {{ file: Buffer, clusterAt: number[], cuesAt: number | null, segmentDataOffset: number }}
- */
-export function buildMatroska({ tracks, clusters, cues = [], cuesBeforeClusters = false }) {
-  const info = element(ID.INFO, uintElement(ID.TIMESTAMP_SCALE, 1_000_000));
-  const tracksElement = element(ID.TRACKS, Buffer.concat(tracks));
-  const clusterElements = clusters.map((cluster) =>
-    cluster.unknownSize ? unknownSizeElement(ID.CLUSTER, cluster.data) : element(ID.CLUSTER, cluster.data)
-  );
-
-  const cuesWith = (positions) =>
-    cues === null
-      ? Buffer.alloc(0)
-      : element(
-          ID.CUES,
-          Buffer.concat(
-            clusters.map((cluster, index) =>
-              element(
-                ID.CUE_POINT,
-                Buffer.concat([
-                  uint32Element(ID.CUE_TIME, cluster.ticks),
-                  ...cues.map((track) =>
-                    element(
-                      ID.CUE_TRACK_POSITIONS,
-                      Buffer.concat([uintElement(ID.CUE_TRACK, track), uint32Element(ID.CUE_CLUSTER_POSITION, positions[index])])
-                    )
-                  )
-                ])
-              )
-            )
-          )
-        );
-  const seekEntry = (targetId, position) =>
-    element(ID.SEEK, Buffer.concat([element(ID.SEEK_ID, idBytes(targetId)), uint32Element(ID.SEEK_POSITION, position)]));
-  const seekHeadWith = (infoAt, tracksAt, cuesAt) =>
-    element(
-      ID.SEEK_HEAD,
-      Buffer.concat([
-        seekEntry(ID.INFO, infoAt),
-        seekEntry(ID.TRACKS, tracksAt),
-        ...(cues !== null && !cuesBeforeClusters ? [seekEntry(ID.CUES, cuesAt)] : [])
-      ])
-    );
-
-  const zeros = clusters.map(() => 0);
-  const headLength = seekHeadWith(0, 0, 0).length;
-  const infoAt = headLength;
-  const tracksAt = infoAt + info.length;
-  const cuesLength = cuesWith(zeros).length;
-  const firstClusterAt = tracksAt + tracksElement.length + (cuesBeforeClusters ? cuesLength : 0);
-  const positions = [];
-  let at = firstClusterAt;
-  for (const cluster of clusterElements) {
-    positions.push(at);
-    at += cluster.length;
-  }
-  const cuesAt = cues === null ? null : cuesBeforeClusters ? tracksAt + tracksElement.length : at;
-  const parts = [seekHeadWith(infoAt, tracksAt, cuesAt ?? 0), info, tracksElement];
-  if (cuesBeforeClusters) {
-    parts.push(cuesWith(positions));
-  }
-  parts.push(...clusterElements);
-  if (!cuesBeforeClusters) {
-    parts.push(cuesWith(positions));
-  }
-  const payload = Buffer.concat(parts);
-  const ebml = element(ID.EBML, Buffer.from([0x42, 0x86, 0x81, 0x01]));
-  const segment = element(ID.SEGMENT, payload);
-  const segmentDataOffset = ebml.length + segment.length - payload.length;
-  return {
-    file: Buffer.concat([ebml, segment]),
-    clusterAt: positions.map((position) => segmentDataOffset + position),
-    cuesAt: cuesAt === null ? null : segmentDataOffset + cuesAt,
-    segmentDataOffset
-  };
-}
-
-/**
- * A reader over a buffer that answers null for the ranges a check says are
- * not here, and records every range asked for.
- *
- * @param {Buffer} bytes
- * @param {{ missing?: (start: number, end: number) => boolean, short?: boolean }} [options]
- */
-export function readerOver(bytes, options = {}) {
-  const reads = [];
-  const read = async (start, end) => {
-    reads.push({ start, end });
-    if (options.missing?.(start, end)) {
-      return null;
-    }
-    const slice = bytes.subarray(start, end + 1);
-    return options.short ? slice.subarray(0, Math.max(0, slice.length - 1)) : Buffer.from(slice);
-  };
-  return { read, reads };
-}
-
-/**
- * What the cue walk may read: the held ranges, a strict read of them, a
- * portion and where viewers stand.
- *
- * @param {Buffer} bytes
- * @param {Array<[number, number]>} ranges
- * @param {{ portionBytes?: number, wantedSeconds?: number[], reads?: Array<{ start: number, end: number }> }} [options]
- * @returns {import("../../services/media/container/Container.js").HeldReader}
- */
-export function heldOver(bytes, ranges, options = {}) {
-  const holds = (start, end) => ranges.some(([from, to]) => start >= from && end <= to);
-  return {
-    ranges,
-    isHeld: (start, end) => holds(start, Math.min(end, bytes.length - 1)),
-    read: async (start, end) => {
-      options.reads?.push({ start, end });
-      const last = Math.min(end, bytes.length - 1);
-      if (!holds(start, last)) {
-        const error = new Error(`bytes ${start}-${last} are not available yet`);
-        error.name = "BytesUnavailable";
-        throw error;
-      }
-      return Buffer.from(bytes.subarray(start, last + 1));
-    },
-    portionBytes: options.portionBytes ?? Number.POSITIVE_INFINITY,
-    wantedSeconds: options.wantedSeconds ?? []
-  };
-}

package/test/helpers/output-spec.js

@@ -1,63 +0,0 @@
-import { AudioOutput, CutGrid, OutputSpec, VideoOutput } from "../../services/encode/output/OutputSpec.js";
-
-/**
- * Build the output identity used by production objects in focused tests.
- *
- * @param {object} [params]
- * @param {string} [params.sourceKey]
- * @param {number} [params.fileIndex]
- * @param {boolean} [params.transcodeVideo]
- * @param {boolean} [params.transcodeAudio]
- * @param {boolean} [params.audioOnly]
- * @param {boolean} [params.audioSeparate]
- * @param {number} [params.audioFileIndex]
- * @param {number} [params.audioSourceTrackIndex]
- * @param {number} [params.width]
- * @param {number} [params.height]
- * @param {string} [params.encoder]
- * @param {number} [params.fps]
- * @param {string | null} [params.preset]
- * @param {boolean} [params.tonemap]
- * @param {{ maxrateKbps: number, bufsizeKbps: number, level: string | null } | null} [params.rateControl]
- * @param {"keyframe" | "uniform"} [params.cutGrid]
- * @param {string} [params.segmentFormatId]
- * @returns {OutputSpec}
- */
-export function outputSpec({
-  sourceKey = "source-1",
-  fileIndex = 0,
-  transcodeVideo = false,
-  transcodeAudio = true,
-  audioOnly = false,
-  audioSeparate = false,
-  audioFileIndex = fileIndex,
-  audioSourceTrackIndex = 0,
-  width = 0,
-  height = 0,
-  encoder = "libx264",
-  fps = 24,
-  preset = null,
-  tonemap = false,
-  rateControl = null,
-  cutGrid = "uniform",
-  segmentFormatId = "fmp4"
-} = {}) {
-  return new OutputSpec({
-    sourceKey,
-    segmentFormatId,
-    grid: new CutGrid({ kind: cutGrid, fileIndex }),
-    video: audioOnly
-      ? null
-      : new VideoOutput({
-          fileIndex,
-          encode: transcodeVideo ? { encoder, width, height, fps, preset, tonemap, rateControl } : null
-        }),
-    audio: audioSeparate
-      ? null
-      : new AudioOutput({
-          fileIndex: audioFileIndex,
-          trackIndex: audioSourceTrackIndex,
-          transcode: transcodeAudio
-        })
-  });
-}

package/test/host-load.test.js

@@ -1,68 +0,0 @@
-/**
- * @file The arithmetic that turns two readings of the machine into shares.
- *
- * The readings themselves are files this host may or may not have; what is
- * tested here is what is DERIVED from them, because that is where a wrong
- * number would quietly become a wrong conclusion about why an encoder is slow.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-
-import { readProcessCpuSeconds, readSystemCpu, sampleHost, shareOfMachine } from "../services/encode/host-load.js";
-
-test("a process using one core of four for a second reports a quarter of the machine", () => {
-  const before = { takenAt: 1_000, processCpuSeconds: 10, system: null };
-  const after = { takenAt: 2_000, processCpuSeconds: 11, system: null };
-  const share = shareOfMachine(before, after, 4);
-  assert.equal(share?.elapsedSec, 1);
-  assert.equal(share?.processShare, 0.25);
-});
-
-test("a process using every core reports the whole machine", () => {
-  const share = shareOfMachine(
-    { takenAt: 0, processCpuSeconds: 0, system: null },
-    { takenAt: 2_000, processCpuSeconds: 8, system: null },
-    4
-  );
-  assert.equal(share?.processShare, 1);
-});
-
-test("waiting for a disk is counted apart from working", () => {
-  const before = { takenAt: 0, processCpuSeconds: null, system: { busySeconds: 100, idleSeconds: 900, iowaitSeconds: 10 } };
-  const after = { takenAt: 1_000, processCpuSeconds: null, system: { busySeconds: 101, idleSeconds: 902, iowaitSeconds: 11 } };
-  const share = shareOfMachine(before, after, 4);
-  assert.equal(share?.systemShare, 0.25);
-  assert.equal(share?.iowaitShare, 0.25);
-});
-
-test("two readings taken at the same instant say nothing rather than dividing by zero", () => {
-  assert.equal(shareOfMachine({ takenAt: 5, processCpuSeconds: 1, system: null }, { takenAt: 5, processCpuSeconds: 2, system: null }, 4), null);
-});
-
-test("a missing reading leaves that share unknown, not zero", () => {
-  const share = shareOfMachine(
-    { takenAt: 0, processCpuSeconds: null, system: null },
-    { takenAt: 1_000, processCpuSeconds: 1, system: null },
-    4
-  );
-  assert.equal(share?.processShare, null);
-  assert.equal(share?.systemShare, null);
-});
-
-test("a process that does not exist reports nothing at all", async () => {
-  assert.equal(await readProcessCpuSeconds(0), null);
-  assert.equal(await readProcessCpuSeconds(-1), null);
-  // A pid far above any real one on this machine.
-  assert.equal(await readProcessCpuSeconds(4_000_000), null);
-});
-
-test("on a host without /proc the readings are null and the sampler still answers", async () => {
-  // This runs on Linux in CI and on Windows here; both must be safe. What is
-  // asserted is the SHAPE — a reading is either a number or null, never a throw.
-  const system = await readSystemCpu();
-  assert.ok(system === null || typeof system.busySeconds === "number");
-  const sample = await sampleHost(null);
-  assert.equal(typeof sample.takenAt, "number");
-  assert.equal(sample.processCpuSeconds, null);
-});

package/test/index-accuracy-is-about-the-file.test.js

@@ -1,128 +0,0 @@
-/**
- * @file What a produced piece reveals, and WHOSE fact it is.
- *
- * One reading is taken — how far a produced piece began from where its grid
- * said it would — and three different facts are drawn from it, which the code
- * that draws them already stated in its own three branches:
- *
- * 1. a COPIED picture can only be cut where a keyframe already is, so a
- *    disagreement says the container's keyframe TABLE describes times the file
- *    does not have. A fact of the FILE;
- * 2. a RE-ENCODED rung was told to put a keyframe at that instant and did not,
- *    so its pieces no longer stand where the stream it accompanies would have
- *    put them. A fact of that OUTPUT;
- * 3. a SOUNDTRACK is cut exactly where it is asked to be, to within an audio
- *    frame, so it says nothing about any keyframe at all — only that the
- *    picture's grid has moved under a run already going. A fact of that OUTPUT.
- *
- * Until 2026-09-15 all three went into ONE tally, and the tally was on the cut
- * table — which is held per (file, grid), so a picture and the soundtrack muxed
- * into the same file shared it. Three consequences, and these checks are about
- * all of them: the file's finding died with a grid it does not belong to, one
- * output's reading of a piece number silenced another's reading of its own, and
- * the summary could not say which of the three facts it was summarising.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Timeline, Timelines } from "../services/encode/output/Timeline.js";
-import { Output } from "../services/encode/output/Output.js";
-import { KeyframeTable } from "../services/media/container/KeyframeTable.js";
-
-const KEYFRAMES = [0, 4.004, 8.008, 12.012, 16.016];
-const TOLERANCE = 0.25;
-
-/**
- * @param {number[]} boundaries
- * @returns {Timeline}
- */
-function timelineOver(boundaries) {
-  return new Timeline({ boundaries: [...boundaries], cutGrid: "keyframe" });
-}
-
-/**
- * @returns {Output}
- */
-function anOutput() {
-  return new Output({
-    encodeWidth: 0,
-    encodeHeight: 0,
-    outputFps: 25,
-    softwarePreset: null,
-    applyTonemap: false
-  });
-}
-
-test("a picture and the soundtrack inside the same file share one cut table, and no longer one tally", () => {
-  // Sharing the table is right — it is what makes them cut at the same instants
-  // and is the whole reason it is held per file and grid. What must not be
-  // shared is what each of them LEARNS, since the two learn different things.
-  const tables = new Timelines();
-  const key = Timelines.keyFor("torrent:abc", 3, "keyframe");
-
-  const picture = tables.get(key, () => timelineOver(KEYFRAMES));
-  const sound = tables.get(key, () => timelineOver(KEYFRAMES));
-
-  assert.equal(sound, picture, "one table, so the cuts cannot drift apart");
-  assert.equal(
-    Object.keys(picture).some((field) => /check|tally|deviation|landing/i.test(field)),
-    false,
-    "and nothing on it counts what anybody found, which two outputs would have shared"
-  );
-});
-
-test("two outputs each keep their own reading of the same piece number", () => {
-  // `seen` exists so that a piece asked for twice is not counted twice — right
-  // for one producer, and wrong across two. Shared, it dropped whichever of the
-  // two finished second, so which reading survived was decided by a race.
-  const picture = anOutput();
-  const sound = anOutput();
-
-  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
-  sound.noteLanding({ index: 7, deviationSec: 0, toleranceSec: TOLERANCE });
-
-  assert.equal(picture.landing.checked, 1);
-  assert.equal(picture.landing.disagreed, 1, "the picture's piece did begin away from its grid");
-  assert.equal(sound.landing.checked, 1, "and the sound's reading of its own #7 is not a repeat");
-  assert.equal(sound.landing.disagreed, 0, "the sound was cut exactly where it was asked");
-
-  // What `seen` is FOR, which the split must not lose: within one output a
-  // piece is produced and served over and over while a viewer is refused it,
-  // and the same piece is one reading however many times it is read.
-  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
-  picture.noteLanding({ index: 7, deviationSec: 0.9, toleranceSec: TOLERANCE });
-
-  assert.equal(picture.landing.checked, 1, "its own repeat is still the same piece, counted once");
-  assert.equal(picture.landing.disagreed, 1);
-});
-
-test("only a copy's reading reaches the file's table, and it outlives any one grid", () => {
-  // The whole point of moving it: the table is one per FILE, so what a copy
-  // showed about it is there for every step and every later session of those
-  // bytes — while a tally on a cut table died with the grid, and a grid is not
-  // what the reading is about.
-  const table = new KeyframeTable().learn({ times: KEYFRAMES, format: "matroska" });
-
-  table.witness({ index: 2, trueStart: 12.012, deviationSec: 4.004, toleranceSec: TOLERANCE });
-
-  assert.equal(table.evidence.checked, 1);
-  assert.equal(table.evidence.disagreed, 1);
-  assert.equal(
-    table.evidence.landedOnAnotherKeyframe,
-    1,
-    "and the table itself says the piece began at another time it names — the grid was built over a gap"
-  );
-});
-
-test("each tally answers one question, so a summary of it cannot be a mixture", () => {
-  // The distinction the three branches make when they WARN is now kept in what
-  // they count, so the summary can restate it — and the summary is what is read
-  // when nobody was watching the log live.
-  const sound = anOutput();
-  const table = new KeyframeTable().learn({ times: KEYFRAMES, format: "matroska" });
-
-  sound.noteLanding({ index: 1, deviationSec: 0.8, toleranceSec: TOLERANCE });
-
-  assert.equal(sound.landing.disagreed, 1, "the sound's grid moved under its run, and that is all it says");
-  assert.equal(table.evidence, null, "nothing a soundtrack produced is evidence about the file's keyframes");
-});