@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/segments-are-shared.test.js

@@ -1,176 +0,0 @@
-/**
- * @file Two sessions of one output write into one place, and each serves what
- * the other has made.
- *
- * This is what the whole address change is for. Measured 2026-09-03: two
- * viewers of one copied file got two sessions with byte-identical output —
- * `segment-00000.mp4` of 4141899 bytes, twice — and neither could see the
- * other's work, because the directory was named after the session's own random
- * id (`research/two-viewers-one-file-2026-09-03.md`).
- *
- * The start position is deliberately NOT part of the address: segment 42 covers
- * the same span whoever began where, so two viewers who opened the same film at
- * different places produce interchangeable segments and must share them.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { SegmentStore } from "../services/storage/segment-store/SegmentStore.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const OUTPUT_KEY = "torrent:abc:fmt=fmp4:grid=kf@0:video-only:v=0/copy";
-
-/**
- * @returns {{ manager: object, store: SegmentStore, root: string }}
- */
-function managerOverATempStore() {
-  const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
-  const store = new SegmentStore({ root });
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    segmentStore: store
-  });
-  return { manager, store, root };
-}
-
-/**
- * A session shaped like a live one, sharing an output with any other built
- * from the same key.
- *
- * @param {{ id: string, dirPath: string, outputKey: string }} params
- * @returns {object}
- */
-function sessionOn({ id, dirPath, outputKey }) {
-  return {
-    id,
-    spec: outputSpec({ transcodeVideo: false }),
-    outputKey,
-    dirPath,
-    state: "ready",
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "video.mkv" }),
-    // An ordinary session reads its own file, and its sound is inside it. The
-    // three differ only for a soundtrack shipped as a file of its own.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    segmentFormat: fmp4Format,
-    // Where the file is cut, which every live session holds.
-    timeline: new Timeline({ boundaries: [0, 4, 8], cutGrid: "keyframe" }),
-    lastAccessedAt: Date.now()
-  };
-}
-
-test("a second session of the same output is given the same directory", (t) => {
-  const { store, root } = managerOverATempStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  // Two viewers who opened one film ten minutes apart. Their sessions differ —
-  // the start position is still what keeps their encoders apart — but what they
-  // produce is the same material.
-  assert.equal(store.pathFor(OUTPUT_KEY), store.pathFor(OUTPUT_KEY));
-});
-
-test("each session serves the segments the other one's encoder made", (t) => {
-  const { manager, store, root } = managerOverATempStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dirPath = store.directoryFor(OUTPUT_KEY);
-  store.useFormat(OUTPUT_KEY, fmp4Format);
-
-  // Two runs writing into the ONE directory this output has. They are kept
-  // apart by the stretches they were given, not by a directory each, so neither
-  // can reach the other's numbers and there is nothing to separate.
-  writeFileSync(path.join(dirPath, "segment-00000.mp4"), Buffer.alloc(32, 1));
-  writeFileSync(path.join(dirPath, "segment-00100.mp4"), Buffer.alloc(32, 2));
-
-  const viewerOne = sessionOn({ id: "s-one", dirPath, outputKey: OUTPUT_KEY });
-  const viewerTwo = sessionOn({ id: "s-two", dirPath, outputKey: OUTPUT_KEY });
-  manager.outputs.set(viewerOne.id, viewerOne);
-  manager.outputs.set(viewerTwo.id, viewerTwo);
-
-  const sorted = (numbers) => [...numbers].sort((left, right) => left - right);
-  const heldByOne = sorted(manager.serving.producedSegmentNumbers(viewerOne));
-  const heldByTwo = sorted(manager.serving.producedSegmentNumbers(viewerTwo));
-
-  assert.deepEqual(heldByOne, [0, 100]);
-  assert.deepEqual(heldByTwo, [0, 100], "neither viewer's session is the owner of either run");
-});
-
-test("a session leaving does not take the segments with it", async (t) => {
-  const { manager, store, root } = managerOverATempStore();
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-
-  const dirPath = store.directoryFor(OUTPUT_KEY);
-  store.useFormat(OUTPUT_KEY, fmp4Format);
-  writeFileSync(path.join(dirPath, "segment-00000.mp4"), Buffer.alloc(32, 1));
-
-  const viewerOne = sessionOn({ id: "s-one", dirPath, outputKey: OUTPUT_KEY });
-  const viewerTwo = sessionOn({ id: "s-two", dirPath, outputKey: OUTPUT_KEY });
-  manager.outputs.set(viewerOne.id, viewerOne);
-  manager.outputs.set(viewerTwo.id, viewerTwo);
-
-  await manager.lifecycle.disposeSession(viewerOne.id);
-  await manager.lifecycle.disposeSession(viewerTwo.id);
-
-  // Both sessions are gone and the material is still here. That is the whole
-  // decoupling: a session ending says nothing about whether anybody will ask
-  // for these segments again — the viewer who left may come back, and a viewer
-  // who never had a session here may open the same film in a minute.
-  assert.notEqual(store.pathOf(OUTPUT_KEY, 0), null);
-});
-
-test("what nobody has read for long enough goes, and time is the only judge", (t) => {
-  const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-  let clock = 1_000_000;
-  const store = new SegmentStore({ root, now: () => clock });
-
-  const dirPath = store.directoryFor(OUTPUT_KEY);
-  store.useFormat(OUTPUT_KEY, fmp4Format);
-  writeFileSync(path.join(dirPath, "segment-00000.mp4"), Buffer.alloc(32, 1));
-
-  clock += 60_000;
-  assert.deepEqual(
-    store.enforce({ idleMs: 3_600_000, maxBytes: 1e9 }),
-    { droppedIdle: 0, droppedForRoom: 0, segmentsRemoved: 0, bytes: 32 }
-  );
-
-  clock += 7_200_000;
-  const swept = store.enforce({ idleMs: 3_600_000, maxBytes: 1e9 });
-  assert.equal(swept.droppedIdle, 1);
-  assert.equal(store.pathOf(OUTPUT_KEY, 0), null);
-});
-
-test("over the allowance, what was read longest ago goes first", (t) => {
-  const root = mkdtempSync(path.join(os.tmpdir(), "shared-segments-"));
-  t.after(() => rmSync(root, { recursive: true, force: true }));
-  let clock = 1_000_000;
-  const store = new SegmentStore({ root, now: () => clock });
-
-  const older = OUTPUT_KEY;
-  const newer = `${OUTPUT_KEY}:second`;
-  for (const key of [older, newer]) {
-    const dir = store.directoryFor(key);
-    store.useFormat(key, fmp4Format);
-    writeFileSync(path.join(dir, "segment-00000.mp4"), Buffer.alloc(1000, 1));
-    clock += 1000;
-  }
-  // Reading the newer one again is what puts the older one at the front of the
-  // queue: the judge is the last REQUEST, not when the file was written.
-  clock += 1000;
-  store.pathOf(newer, 0);
-
-  const swept = store.enforce({ idleMs: 3_600_000, maxBytes: 1500 });
-  assert.equal(swept.droppedForRoom, 1);
-  assert.equal(store.pathOf(older, 0), null);
-  assert.notEqual(store.pathOf(newer, 0), null);
-});

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

@@ -1,86 +0,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,111 +0,0 @@
-/**
- * @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";
-import { qualityStateOf } from "../services/encode/quality/OutputQualityState.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 });
-  // The soundtrack the plan listed, at the rate the file states: a copy of it
-  // has a figure, so it stays a copy.
-  manager.getCachedAudioTracks = () => [{ index: 0, fileIndex: 0, sourceTrackIndex: 0, bitrateKbps: 128 }];
-  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);
-  // WHAT ITS ENCODER WAS SEEN DOING. Its first piece is made, so an encoder ran
-  // on it here; a viewer put on it now needs one again, and a place for one is
-  // asked by what one costs — with no measured cost the proxy refuses (roadmap
-  // item 97, step 14).
-  qualityStateOf(made).lastAloneSpeed = 2;
-  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 +0,0 @@
-/**
- * @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");
-});