@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/piece-store-slow-disk.test.js

@@ -1,159 +0,0 @@
-/**
- * @file What the allowance has to bound, and why it is not the resident pieces.
- *
- * The field failure of 2026-09-02, in one sentence: a piece being written out
- * leaves the store's own count the moment the eviction begins, while its memory
- * stays held until the write that reads from it has finished. So every
- * admission turned one resident block into one block held by the disk and took
- * a fresh block for the arrival, and the memory in use went UP by one per
- * admission for as long as the disk was behind.
- *
- * It was behind by a factor of two: 233 evictions started against about 119
- * writes completed in the same minute. The store reported 203 blocks held with
- * THREE pieces resident and 68 MB allowed, and the kernel killed the process at
- * 4.37 GB.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
-
-const PIECE = 1024;
-
-/**
- * Wait for the thing being asserted, not for a length of time.
- *
- * @param {() => boolean} until
- * @param {string} what - Named in the failure, since a timeout otherwise says
- *   only that something did not happen.
- * @param {number} [limit]
- * @returns {Promise<void>}
- */
-async function waitFor(until, what, limit = 10_000) {
-  const deadline = Date.now() + limit;
-  while (!until()) {
-    if (Date.now() > deadline) {
-      throw new Error(`${what} never happened`);
-    }
-    await new Promise((resolve) => { setTimeout(resolve, 5); });
-  }
-}
-
-/**
- * A disk that answers only when the test lets it, so writes can be made slower
- * than arrivals on purpose — which is the whole of the field condition.
- */
-function heldDisk() {
-  const stored = new Set();
-  /** @type {Array<() => void>} */
-  const waiting = [];
-  return {
-    pending: waiting,
-    get size() {
-      return stored.size;
-    },
-    get bytes() {
-      return 0;
-    },
-    get path() {
-      return ".";
-    },
-    get allowanceBytes() {
-      return null;
-    },
-    reviseAllowance() {
-      return null;
-    },
-    stats() {
-      return { pieces: stored.size, bytes: 0, allowanceBytes: null, evictions: 0 };
-    },
-    has: (index) => stored.has(index),
-    forget: (index) => stored.delete(index),
-    write(index) {
-      return new Promise((resolve) => {
-        waiting.push(() => {
-          stored.add(index);
-          resolve();
-        });
-      });
-    },
-    async read(index, target) {
-      target.fill(index % 251);
-      return target.length;
-    },
-    async close() { waiting.length = 0; },
-    async destroy() { stored.clear(); waiting.length = 0; }
-  };
-}
-
-/**
- * @param {SharedPieceStore} store
- * @param {number} index
- * @returns {Promise<void>}
- */
-const put = (store, index) =>
-  new Promise((resolve, reject) => {
-    store.put(index, Buffer.alloc(PIECE, index % 251), (error) => (error ? reject(error) : resolve()));
-  });
-
-test("memory in use never runs past the allowance while the disk is behind", async () => {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "slow-disk-test-"));
-  const disk = heldDisk();
-  const capacity = 4;
-  const store = new SharedPieceStore(PIECE, {
-    length: PIECE * 200,
-    memoryBytes: PIECE * capacity,
-    path: directory,
-    name: "slow-disk",
-    disk
-  });
-  try {
-    // Fill it, then keep pieces coming while every write stays unfinished.
-    for (let index = 0; index < capacity; index += 1) {
-      await put(store, index);
-    }
-    const arrivals = [];
-    for (let index = capacity; index < capacity + 40; index += 1) {
-      arrivals.push(put(store, index).catch(() => undefined));
-    }
-    // Until the state being asserted has been reached: a write is outstanding
-    // and admission has waited for the disk rather than evicting. Waited out as
-    // 200 ms instead, this asserted how far the arrivals had got in that time —
-    // and on a machine slow enough that none of them reached a disk write, both
-    // of those figures are zero and the test fails with nothing wrong.
-    //
-    // The bound below is what the wait must NOT decide, so it is checked after
-    // the state is reached rather than after an interval: the store may never
-    // hold more blocks than it is allowed, however many arrivals are in flight.
-    await waitFor(() => {
-      const now = store.stats();
-      return now.blocksInFlight > 0 && now.waitedForDisk > 0;
-    }, "a held write and an admission that waited for it");
-
-    const held = store.stats();
-    // The check the field failure would fail: a store allowed four pieces held
-    // two hundred and three. Blocks held by a pending write count here, because
-    // they are memory whatever the piece count says.
-    assert.ok(
-      held.blocksInUse <= capacity,
-      `${held.blocksInUse} blocks in use with ${capacity} allowed `
-      + `(${held.blocksInFlight} of them held by writes that have not finished)`
-    );
-    assert.ok(held.blocksInFlight > 0, "the disk was supposed to be holding some");
-    assert.ok(held.waitedForDisk > 0, "admission was supposed to wait for the disk, not evict");
-
-    // Let the disk answer: the blocks come back and everything settles.
-    while (disk.pending.length > 0) {
-      disk.pending.shift()?.();
-      await new Promise((resolve) => setTimeout(resolve, 0));
-    }
-    await Promise.all(arrivals);
-    assert.ok(store.stats().blocksInUse <= capacity + 1, "the pool did not settle");
-  } finally {
-    store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  }
-});

package/test/piece-tail.test.js

@@ -1,97 +0,0 @@
-/**
- * @file What a blocked piece's tail looks like, before anything is built on it.
- *
- * The steering shipped in 2.29.0 often places nothing — `steered onto 0 of 9
- * asks (8 peers held it)`, measured 2026-08-18 — because every block of the
- * piece is already reserved and the library will not hand out a second request
- * for the same block. Duplicating those blocks is the standard remedy and costs
- * traffic, so the tail is described first: how much is missing, and on which
- * wires it sits.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { describePieceTail } from "../services/torrent/worker/fastest-wires.js";
-
-/** A torrent whose piece has some blocks in hand and some in flight. */
-function torrentWith({ buffer, wires }) {
-  return {
-    pieces: [{ _buffer: buffer, _chunks: buffer.length }],
-    wires
-  };
-}
-
-function wire({ has = true, blocks = 0, speed = 0, choking = false }) {
-  return {
-    peerPieces: { get: () => has },
-    requests: Array.from({ length: blocks }, () => ({ piece: 0 })),
-    downloadSpeed: () => speed,
-    peerChoking: choking
-  };
-}
-
-test("the tail names how much is missing and who is holding it", () => {
-  const tail = describePieceTail(
-    torrentWith({
-      // Four blocks, two already in hand.
-      buffer: [new Uint8Array(1), new Uint8Array(1), null, null],
-      wires: [
-        wire({ blocks: 1, speed: 900_000 }),
-        wire({ blocks: 1, speed: 12_000 }),
-        wire({ has: true, blocks: 0, speed: 5_000_000 })
-      ]
-    }),
-    0
-  );
-
-  assert.equal(tail.missing, 2);
-  assert.equal(tail.chunks, 4);
-  assert.equal(tail.outstanding.length, 2, "only the wires actually holding a block of it");
-  assert.equal(
-    tail.outstanding[0].bytesPerSecond,
-    12_000,
-    "slowest first — that is the wire the read is waiting on"
-  );
-});
-
-test("a piece nobody is fetching reads as entirely missing, held by nobody", () => {
-  const tail = describePieceTail(
-    torrentWith({ buffer: [null, null], wires: [wire({ has: false, blocks: 0 })] }),
-    0
-  );
-
-  assert.equal(tail.outstanding.length, 0);
-  assert.equal(tail.missing, 2, "and the missing count still says the piece is untouched");
-});
-
-test("a piece no block of which has been reserved is described, not skipped", () => {
-  // `torrent-piece` builds its buffer lazily on the first reserve, so a piece
-  // the picker has not reached has none. Reading that as "no tail" hid the
-  // clearest answer there is: the wait is on nobody having been asked.
-  const tail = describePieceTail(
-    { pieces: [{ _buffer: null, _chunks: 512 }], wires: [wire({ has: true, blocks: 0, speed: 900_000 })] },
-    0
-  );
-
-  assert.equal(tail.missing, 512, "every block of it is missing");
-  assert.equal(tail.chunks, 512);
-  assert.equal(tail.outstanding.length, 0, "and not one of them has been asked for");
-});
-
-test("a completed piece is not described at all", () => {
-  // WebTorrent nulls `pieces[index]` once the piece is verified and stored.
-  assert.equal(describePieceTail({ pieces: [null], wires: [] }, 0), null);
-  assert.equal(describePieceTail({ pieces: [], wires: [] }, 0), null);
-});
-
-test("a wire that is choking us is named as such", () => {
-  const tail = describePieceTail(
-    torrentWith({
-      buffer: [null],
-      wires: [wire({ blocks: 1, speed: 100, choking: true })]
-    }),
-    0
-  );
-
-  assert.equal(tail.outstanding[0].choking, true, "a block reserved by a choking wire is going nowhere");
-});

package/test/plan-host-timings.test.js

@@ -1,68 +0,0 @@
-/**
- * @file The host's own timings must reach the browser for the file that needs
- * them most.
- *
- * The plan carries two figures the browser cannot measure for itself: how long
- * this host takes to create a session, and how long it takes to produce a first
- * segment. Both are medians of sessions that have already finished here, so at
- * the moment a plan is BUILT the very first file opened after a restart has
- * neither — and the plan is cached, so that file kept answering `null` for the
- * life of the process however many sessions ran afterwards. Measured
- * 2026-08-05: a fresh proxy answered `null` for both, then created the session
- * in 6 ms and produced the first segment in 21 479 ms.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { createPlaybackPlanner } from "../services/media/playback-planner.js";
-
-/**
- * A planner whose host timings can be changed between calls, over a source that
- * needs no torrent: transcoding disabled short-circuits to a cached direct plan
- * without probing anything.
- */
-function plannerWithTimings() {
-  const timings = { create: null, first: null };
-  const planner = createPlaybackPlanner({
-    ffmpegBin: "ffmpeg",
-    localBaseUrl: "http://127.0.0.1:9090/stream",
-    sourceRegistry: { get: () => ({ sourceType: "magnet", source: "magnet:?xt=urn:btih:0" }) },
-    torrentPool: { getTorrent: async () => ({ files: [{ name: "a.mkv", length: 10 }] }) },
-    transcodeAudioEnabled: false,
-    expectedSessionCreateMs: () => timings.create,
-    expectedFirstSegmentMs: () => timings.first
-  });
-  return { planner, timings };
-}
-
-test("a plan built before the host had measured anything still reports them later", async () => {
-  const { planner, timings } = plannerWithTimings();
-
-  const cold = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(cold.expectedSessionCreateMs, null, "nothing has finished yet, so there is nothing to report");
-  assert.equal(cold.expectedFirstSegmentMs, null);
-
-  // Sessions run; the host now knows what it costs.
-  timings.create = 6;
-  timings.first = 21_479;
-
-  const warm = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(
-    warm.expectedSessionCreateMs,
-    6,
-    "the cached plan withheld the figure the browser needed"
-  );
-  assert.equal(warm.expectedFirstSegmentMs, 21_479);
-});
-
-test("the figures follow the host as they change", async () => {
-  const { planner, timings } = plannerWithTimings();
-  timings.create = 100;
-  timings.first = 800;
-  const first = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(first.expectedFirstSegmentMs, 800);
-
-  timings.first = 7_000; // a re-encode session — an order of magnitude slower
-  const later = await planner.getPlan({ sourceKey: "src", fileIndex: 0 });
-  assert.equal(later.expectedFirstSegmentMs, 7_000, "the plan reported a stale figure");
-});

package/test/plan-is-steady.test.js

@@ -1,225 +0,0 @@
-/**
- * @file The placement must not move while the facts do not.
- *
- * This is the check the field failure of 2026-09-13 had no equivalent of. Two
- * browsers on one torrent: 77 encoder starts and 141 stops in six minutes
- * against ONE normal end, both viewers frozen — one at 170.8 s with
- * `bufferedAhead=0.1s`, the other at 1673.6 s with an empty buffer — while the
- * swarm delivered 3 MB/s from 129 peers. Nothing was produced because no run
- * lived long enough to close a piece.
- *
- * The plan itself was not at fault and was measured not to be: given a settled
- * map it returns the same arrangement however often it is asked. What moved was
- * its INPUT. A viewer's position had two writers — a seek wrote one field, a
- * segment request wrote another, and the reading preferred whichever was set —
- * so the priority map jumped backwards and forwards by one or two segments
- * several times a second:
- *
- *   19:58:00.283  p100:#9..#10    p100:#160..#162
- *   19:58:00.496  p100:#18..#20   p100:#161..#163
- *   19:58:00.574  p100:#16..#18   p100:#161..#163
- *   19:58:00.696  p100:#16..#18   p100:#160..#162
- *   19:58:01.231  p100:#18..#20   p100:#160..#162
- *
- * So the property to hold is about the whole chain and not about one function:
- * what a viewer states must produce a map that only moves the way film moves,
- * and a plan asked repeatedly against unchanged facts must answer identically.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { CoverageMap } from "../services/encode/CoverageMap.js";
-import { planEncoders } from "../services/encode/EncodePlan.js";
-import { contentionPenalty, penaltiesFrom } from "../services/encode/contention.js";
-import { mapForViewer, mergeMaps, runsOf } from "../services/viewer/PriorityMap.js";
-import { Viewer } from "../services/viewer/Viewer.js";
-
-// Measured on the addon host 2026-09-03: 7.12x alone, 4.18x with a second.
-const PENALTIES = penaltiesFrom(7.12, [{ others: 1, speed: 4.18 }]);
-const penaltyFor = (others) => contentionPenalty(others, PENALTIES).penalty;
-
-const HOST = {
-  contentionPenaltyFor: penaltyFor,
-  speedX: 2,
-  segmentSeconds: 8,
-  killCostSec: 0.5,
-  firstByteWaitSec: 1,
-  refetchSecPerFilmSecond: 0.25
-};
-
-const DURATION = 2896;
-const ALLOWANCE = 30;
-
-/**
- * The map two viewers produce, exactly as `PriorityOrchestrator` builds it.
- *
- * @param {Viewer[]} viewers
- * @param {number} now
- * @returns {{ from: number, to: number, priority: number }[]}
- */
-function zonesFor(viewers, now) {
-  const merged = mergeMaps(
-    viewers.map((viewer) =>
-      mapForViewer({
-        atSeconds: viewer.positionSeconds(now) ?? 0,
-        durationSeconds: DURATION,
-        allowanceSeconds: ALLOWANCE,
-        playing: viewer.wantsFilmNow()
-      })
-    )
-  );
-  return runsOf(merged).map((zone) => ({
-    from: Math.floor(zone.from / HOST.segmentSeconds),
-    to: Math.floor((zone.to - 1) / HOST.segmentSeconds),
-    priority: zone.priority
-  }));
-}
-
-test("a viewer's position only ever moves the way film moves", () => {
-  const viewer = new Viewer("one", 1_000_000);
-  // Stated the way a page states it: where they are, what they hold, and that
-  // the picture is advancing. The cushion is what bounds the extrapolation, so
-  // a viewer who has stated none cannot move at all.
-  viewer.report(
-    { bufferedAheadSec: 120, positionSeconds: 170.8, playing: true, waiting: false },
-    1_000_000
-  );
-
-  let previous = viewer.positionSeconds(1_000_000);
-  for (let tick = 1; tick <= 200; tick += 1) {
-    const now = 1_000_000 + tick * 50;
-    const seconds = viewer.positionSeconds(now);
-    assert.ok(seconds >= previous, `position went backwards at tick ${tick}: ${seconds} < ${previous}`);
-    previous = seconds;
-  }
-  // Fifty ticks of 50 ms is ten seconds of wall clock, and a playing viewer
-  // covers ten seconds of film in it.
-  assert.ok(Math.abs(previous - (170.8 + 10)) < 0.001, `expected 180.8s, got ${previous}`);
-});
-
-test("a segment request does not move a viewer, and a stopped picture does not either", () => {
-  const viewer = new Viewer("one", 1_000_000);
-  viewer.report(
-    { bufferedAheadSec: 120, positionSeconds: 170.8, playing: false, waiting: false },
-    1_000_000
-  );
-
-  // Whatever else happens, only a statement from the viewer moves them. There
-  // is no method here a request could call: `seen` is presence and nothing more.
-  viewer.seen(1_000_500);
-  viewer.seen(1_001_000);
-  assert.equal(viewer.positionSeconds(1_010_000), 170.8);
-});
-
-test("the priority map of two viewers is the same whenever it is asked", () => {
-  const at = 1_000_000;
-  const one = new Viewer("one", at);
-  one.report({ bufferedAheadSec: 120, positionSeconds: 170.8, playing: false, waiting: false }, at);
-  const two = new Viewer("two", at);
-  two.report({ bufferedAheadSec: 120, positionSeconds: 1673.6, playing: false, waiting: false }, at);
-
-  const first = JSON.stringify(zonesFor([one, two], at));
-  for (let tick = 1; tick <= 40; tick += 1) {
-    // Nothing changes: both pictures are stopped, so no time passes for them.
-    assert.equal(JSON.stringify(zonesFor([one, two], at + tick * 100)), first, `map moved at tick ${tick}`);
-  }
-});
-
-test("two viewers far apart settle on one arrangement and stay on it", () => {
-  const at = 1_000_000;
-  const one = new Viewer("one", at);
-  one.report({ bufferedAheadSec: 120, positionSeconds: 170.8, playing: false, waiting: false }, at);
-  const two = new Viewer("two", at);
-  two.report({ bufferedAheadSec: 120, positionSeconds: 1673.6, playing: false, waiting: false }, at);
-
-  const coverage = new CoverageMap({ segmentCount: 362 });
-  /** @type {{ from: number, to: number, head: number, speedX: number, startedAt: number }[]} */
-  let live = [];
-  let started = 0;
-  let stopped = 0;
-
-  for (let tick = 0; tick < 60; tick += 1) {
-    const now = at + tick * 100;
-    const actions = planEncoders({
-      coverage,
-      windows: zonesFor([one, two], now),
-      runs: live,
-      maxRuns: 2,
-      now,
-      ...HOST
-    });
-    for (const action of actions) {
-      if (action.type === "start") {
-        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now });
-        started += 1;
-      } else if (action.type === "stop") {
-        live = live.filter((run) => run !== action.run);
-        stopped += 1;
-      } else if (action.type === "move") {
-        live = live.filter((run) => run !== action.run);
-        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now });
-        started += 1;
-        stopped += 1;
-      }
-    }
-  }
-
-  // One encoder per viewer, placed once. Anything above this is the plan
-  // arguing with itself: in the field the same six minutes cost 77 and 141.
-  assert.equal(started, 2, `expected two starts, got ${started}`);
-  assert.equal(stopped, 0, `expected no stops, got ${stopped}`);
-  assert.equal(live.length, 2);
-});
-
-test("an encoder keeping ahead of a playing viewer is left alone", () => {
-  const at = 1_000_000;
-  const one = new Viewer("one", at);
-  one.report({ bufferedAheadSec: 120, positionSeconds: 0, playing: true, waiting: false }, at);
-
-  const coverage = new CoverageMap({ segmentCount: 362 });
-  const ready = new Set();
-  /** @type {{ from: number, to: number, head: number, speedX: number, startedAt: number, made: number }[]} */
-  let live = [];
-  let moves = 0;
-  let starts = 0;
-
-  for (let tick = 0; tick < 120; tick += 1) {
-    const now = at + tick * 1000;
-    const actions = planEncoders({
-      coverage,
-      windows: zonesFor([one], now),
-      runs: live,
-      maxRuns: 1,
-      now,
-      ...HOST
-    });
-    for (const action of actions) {
-      if (action.type === "start") {
-        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now, made: 0 });
-        starts += 1;
-      } else if (action.type === "move") {
-        live = live.filter((run) => run !== action.run);
-        live.push({ from: action.from, to: action.to, head: action.from, speedX: 2, startedAt: now, made: 0 });
-        moves += 1;
-      } else if (action.type === "stop") {
-        live = live.filter((run) => run !== action.run);
-      }
-    }
-    // The encoder works: at 2x, one 8-second piece every four seconds of clock.
-    for (const run of live) {
-      run.made += 1000 * 2;
-      while (run.made >= HOST.segmentSeconds * 1000 && run.head <= run.to) {
-        run.made -= HOST.segmentSeconds * 1000;
-        ready.add(run.head);
-        run.head += 1;
-      }
-    }
-    coverage.setReady(ready);
-  }
-
-  // One encoder, placed once, running twice as fast as the viewer plays: it
-  // stays in front of them for the whole two minutes, so there is nothing to
-  // decide again.
-  assert.equal(starts, 1, `expected one start, got ${starts}`);
-  assert.equal(moves, 0, `expected no moves, got ${moves}`);
-});