@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/held-request-width.test.js

@@ -1,157 +0,0 @@
-/**
- * @file How far ahead of the viewer a held segment request may sit.
- *
- * A request is released when the viewer has moved away from it. "Moved away"
- * used to mean more than `MAX_LOOKAHEAD_SEGMENTS` — eight segments, which
- * happened to match a browser holding thirty seconds and would refuse three
- * quarters of the requests of one holding the whole cushion. The width is the
- * encoder's own look-ahead now, which is the same figure the browser sizes its
- * buffer from. Roadmap item 4, step 2.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import { mkdtemp, rm } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-
-const SESSION_ID = "aaaaaaaabbbbcccc";
-const SEGMENT_SECONDS = 4;
-
-/**
- * @returns {Promise<{ manager: object, dirPath: string }>}
- */
-async function managerWithSession() {
-  const dirPath = await mkdtemp(path.join(os.tmpdir(), "held-request-"));
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: SESSION_ID,
-    dirPath,
-    // Where this file is cut, held by the file. A fixture that stated it
-    // on the session was describing what production no longer does.
-    timeline: new Timeline({
-      boundaries: Array.from({ length: 201 }, (_, index) => index * SEGMENT_SECONDS),
-      cutGrid: "uniform"
-    }),
-    state: "ready",
-    segmentFormat: fmp4Format,
-    segmentCount: 200,
-    useSyntheticPlaylist: true
-  };
-  manager.outputs.set(SESSION_ID, session);
-  // The viewer is at segment #25, and says so themselves.
-  manager.viewers.of(session, "viewer").moveTo(25 * SEGMENT_SECONDS);
-  manager.viewers.of(session, "viewer").playing = false;
-  return { manager, dirPath };
-}
-
-/**
- * @param {number} index
- * @returns {string}
- */
-function segment(index) {
-  return `segment-${String(index).padStart(5, "0")}.mp4`;
-}
-
-test("the width is the encoder's own look-ahead, in segments", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  const width = Math.ceil(manager.lookaheadSeconds / manager.segmentDurationSec);
-  assert.equal(width, 30, "120 s of look-ahead over 4 s segments");
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(25 + width)), true, "the far edge");
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, segment(25 + width + 1)),
-    false,
-    "past everything the encoder is allowed to have produced"
-  );
-});
-
-test("a request the old eight-segment width would have refused is kept", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // #34 is nine segments ahead of the viewer — inside a 120 s cushion and
-  // outside the eight the width used to be. This is the request a browser
-  // holding the whole cushion makes constantly.
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(34)), true);
-});
-
-test("a segment behind the viewer is still released", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(24)), false);
-});
-
-test("a seek by one viewer does not release the request held for another", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-  // Both are watching the same copied picture, so both are this one session.
-  // One is at segment #25, the other far ahead at #150 — inside the fixture's
-  // own 200-segment timeline, since a position past the end of the grid is
-  // clamped to it and would prove nothing about the width.
-  manager.viewerRequests.requestSeek(SESSION_ID, 100, "behind");
-  manager.viewerRequests.requestSeek(SESSION_ID, 600, "ahead");
-
-  // A SEEK DOES ONE THING: it puts the viewer where they now are. It used to
-  // write that position into five places, this session's shared field among
-  // them, and every held request was then judged against whoever moved last —
-  // which is exactly what this test exists to refuse. Each viewer's own
-  // position is what decides, and the two below are asked separately.
-  assert.equal(manager.viewers.get("behind").positionSeconds(), 100);
-  assert.equal(manager.viewers.get("ahead").positionSeconds(), 600);
-
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, segment(26), "behind"),
-    true,
-    "the segment the viewer behind is waiting for is still theirs to wait for"
-  );
-  assert.equal(
-    manager.serving.requestStillWanted(SESSION_ID, segment(26), "ahead"),
-    false,
-    "and for the one in front it is a place they have left"
-  );
-});
-
-test("a viewer's own head moves with their seek", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // Their last request was at #25; they jump to 600 s, which is #150. The
-  // segment at the target must be wanted — refusing it there is the freeze of
-  // 2026-08-18.
-  manager.viewerRequests.requestSeek(SESSION_ID, 600, "viewer");
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(150), "viewer"), true);
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(25), "viewer"), false);
-});
-
-test("a viewer nobody can name is judged against the one shared position", async (t) => {
-  const { manager, dirPath } = await managerWithSession();
-  t.after(async () => {
-    await rm(dirPath, { recursive: true, force: true });
-  });
-
-  // A plain HTTP transport builds its own URLs and carries no id. The old
-  // behaviour is what remains, which for a single viewer is the same thing.
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(26), ""), true);
-  assert.equal(manager.serving.requestStillWanted(SESSION_ID, segment(24), ""), false);
-});

package/test/helpers/encode-run.js

@@ -1,248 +0,0 @@
-/**
- * @file A real `EncodeRun` over a process that is not real.
- *
- * Tests used to set a session's process fields by hand — `session.ffmpeg`,
- * `session.runState`, `session.encodeStartIndex` — which is how a test can pass
- * over code that no longer works: the fields were the thing under test as much
- * as the behaviour was. A run is an object now, so a test builds the object the
- * product builds and injects only the one thing a test may not have, which is a
- * child process.
- *
- * The fake has a pid, as a started process does: a run signals only a process
- * that started. The number is never used to signal anything — every signal goes
- * through the child object, and this one records it.
- */
-
-import { EncodeRun } from "../../services/encode/EncodeRun.js";
-
-/** The working time between two closed pieces of a test measurement. */
-const MEASURED_STEP_MS = 1000;
-
-/** Closed pieces in a test measurement: the last two give the reading. */
-const MEASURED_STEPS = 3;
-
-/**
- * The clock each run built by `startRunOn` reads: standing while a measurement
- * is said, the wall clock otherwise. @type {WeakMap<EncodeRun, { at: number | null }>}
- */
-const wallClocks = new WeakMap();
-
-/**
- * Make a run measure a speed the way it does in the product: progress reports
- * and the names of closed pieces on the encoder's own channels, one second of
- * the run's own work apart. A closed piece is published when the next name
- * arrives, and each publication is one reading against the one before, so the
- * last of three steps reads exactly `speedX` whatever the run measured before.
- *
- * @param {EncodeRun} run - Its process exposes `stdout` and `stdio[3]`.
- * @param {number} speedX - Film seconds per second of the run's work.
- * @param {{ at: number } | null} [clock] - What the run's `now` reads; advanced
- *   here. Absent for a run built by `startRunOn` without one: its clock is
- *   stood just behind the wall clock for the measurement and released after,
- *   so the reading is dated now.
- * @param {number} [waitedMs] - How long the run's input waits for the swarm in
- *   each step, on top of its second of work.
- * @returns {void}
- */
-export function measureSpeed(run, speedX, clock = null, waitedMs = 0) {
-  if (clock === null) {
-    const wall = wallClocks.get(run);
-    if (!wall) {
-      throw new TypeError("measureSpeed needs the clock the run reads");
-    }
-    // Never behind the run's start or its own last reading: a step back in
-    // time is no work.
-    wall.at = Math.max(
-      Date.now() - (MEASURED_STEP_MS + waitedMs) * MEASURED_STEPS,
-      run.startedAt,
-      run.speedReading?.at ?? Number.NEGATIVE_INFINITY
-    );
-    measureSpeed(run, speedX, wall, waitedMs);
-    wall.at = null;
-    return;
-  }
-  const { stdout, stdio } = run.process;
-  let produced = run.progress.processedSeconds - run.progress.startPositionSeconds;
-  for (let step = 0; step < MEASURED_STEPS; step += 1) {
-    if (waitedMs > 0) {
-      run.inputWaitBegins();
-      clock.at += waitedMs;
-      run.inputWaitEnds();
-    }
-    clock.at += MEASURED_STEP_MS;
-    produced += (speedX * MEASURED_STEP_MS) / 1000;
-    say(stdout, `out_time_ms=${Math.round(produced * 1_000_000)}\n`);
-    say(stdio[3], `measured-${step}\n`);
-  }
-}
-
-/**
- * @param {{ write?: (text: string) => void, emit?: (event: string, text: string) => void }} channel
- * @param {string} text
- */
-function say(channel, text) {
-  if (typeof channel.write === "function") {
-    channel.write(text);
-  } else {
-    channel.emit("data", text);
-  }
-}
-
-/**
- * A child process that records what was done to it.
- *
- * @param {object} [options]
- * @param {number | null} [options.pid] - Null for a process that did not start.
- * @returns {object}
- */
-export function fakeProcess({ pid = 4242, exitsWhenKilled = true } = {}) {
-  /** @type {Map<string, (...args: unknown[]) => void>} */
-  const listeners = new Map();
-  const stdout = channel();
-  const closedPieces = channel();
-  return {
-    pid,
-    killed: false,
-    exitCode: null,
-    signalCode: null,
-    /** Every signal it was sent, in order. */
-    signals: [],
-    stdout,
-    stderr: { on() {} },
-    // The descriptor the encoder names its closed pieces on (`-segment_list pipe:3`).
-    stdio: [null, stdout, null, closedPieces],
-    on(event, handler) {
-      const kept = listeners.get(event) ?? [];
-      kept.push(handler);
-      listeners.set(event, kept);
-      return this;
-    },
-    once(event, handler) {
-      return this.on(event, handler);
-    },
-    kill(signal = "SIGTERM") {
-      this.signals.push(signal);
-      // Suspending and continuing are not ends.
-      if (signal === "SIGSTOP" || signal === "SIGCONT") {
-        return true;
-      }
-      this.killed = true;
-      // A real process answers a signal by exiting, and it does so on a later
-      // turn. A fake that never exits makes every disposal wait out the grace
-      // period, which is two seconds a test spends proving nothing.
-      if (exitsWhenKilled && this.exitCode === null && this.signalCode === null) {
-        queueMicrotask(() => this.exit(null, signal));
-      }
-      return true;
-    },
-    /**
-     * Report an exit, as the real thing would.
-     *
-     * @param {number | null} code
-     * @param {string | null} [signal]
-     */
-    exit(code, signal = null) {
-      this.exitCode = code;
-      this.signalCode = signal;
-      for (const handler of listeners.get("exit") ?? []) {
-        handler(code, signal);
-      }
-      // A real child process emits `close` after `exit`, once its stdio has
-      // closed, and the run takes its ending from `close`.
-      for (const handler of listeners.get("close") ?? []) {
-        handler(code, signal);
-      }
-    }
-  };
-}
-
-/**
- * A readable side of a pipe that a test writes into.
- *
- * @returns {{ on: (event: string, handler: (chunk: string) => void) => void, write: (text: string) => void }}
- */
-function channel() {
-  /** @type {((chunk: string) => void)[]} */
-  const handlers = [];
-  return {
-    on(event, handler) {
-      if (event === "data") handlers.push(handler);
-    },
-    write(text) {
-      for (const handler of handlers) handler(text);
-    }
-  };
-}
-
-/** A logger that says nothing, for tests that are not about the log. */
-export const silentLogger = { info() {}, warn() {}, error() {} };
-
-/**
- * Add a run to a session, started, over a fake process.
- *
- * A session holds a SET of runs — as many as the machine affords — so a test
- * that wants two heads on one output calls this twice.
- *
- * @param {object} session - The session under test.
- * @param {object} [options]
- * @param {number} [options.from] - First segment number it is making.
- * @param {number} [options.to] - Last, inclusive; below `from` means no end.
- * @param {object} [options.process] - The process it should own.
- * @param {boolean} [options.producing] - Whether it has already made its first
- *   segment, which is what moves it out of starting.
- * @param {number | null} [options.lastSegmentIndex] - The film's last number,
- *   for telling a finished file from an input that dried up.
- * @param {boolean} [options.usesExplicitCuts]
- * @returns {import("../../services/encode/EncodeRun.js").EncodeRun}
- */
-export function startRunOn(session, options = {}) {
-  const {
-    from = 0,
-    to = -1,
-    process: child = fakeProcess(),
-    producing = true,
-    lastSegmentIndex = null,
-    usesExplicitCuts = false,
-    // THE SPEED IT HAS MEASURED: film made over its own working time between
-    // two closed pieces. Left at zero, the plan has no speed to compute an
-    // arrival from, every arrangement of encoders is equally hopeless, they all
-    // tie, and the encoder is taken away for changing nothing.
-    speedX = 0,
-    // What the run reads as now, for a test that drives time itself. Absent,
-    // the run reads the wall clock, which stands still only while a
-    // measurement is said.
-    clock: given = null
-  } = options;
-  const clock = given ?? { at: null };
-  const run = new EncodeRun({
-    address: session.outputKey ?? session.id ?? "output",
-    encoder: { name: "libx264", kind: "software" },
-    from,
-    to,
-    buildArgs: () => [],
-    spawn: () => child,
-    logger: silentLogger,
-    lastSegmentIndex: () => lastSegmentIndex,
-    usesExplicitCuts,
-    now: () => clock.at ?? Date.now(),
-    because: "a test asked for it"
-  });
-  if (given === null) {
-    wallClocks.set(run, clock);
-  }
-  if (speedX > 0) {
-    measureSpeed(run, speedX, given);
-  }
-  if (producing) {
-    // What moves a run out of starting is its first segment, in the product as
-    // here — so a run that is producing has made one, and its head stands one
-    // past where it began. `from` is still where it started, which is what a
-    // test asserting a run's position asks for.
-    run.noteProduced(from);
-  }
-  if (!(session.runs instanceof Set)) {
-    session.runs = new Set();
-  }
-  session.runs.add(run);
-  return run;
-}

package/test/helpers/held-file.js

@@ -1,77 +0,0 @@
-/**
- * @file A torrent reduced to what the subtitle walk may know about one file.
- *
- * Built from the REAL two functions the torrent thread answers with
- * (`torrent/worker/held-bytes.js`), so a check that walks cues exercises both
- * sides of the seam rather than a stand-in for one of them: the bitfield
- * becoming a list of ranges, and a range read that never fetches.
- *
- * The file's container is the one a `ContainerOrchestrator` builds, over a
- * reader that FETCHES — the fake file's own stream, which serves any range —
- * because the head and the Cues table are read that way in the product.
- */
-
-import { heldRangesOf, readHeldBytes } from "../../services/torrent/worker/held-bytes.js";
-import { ContainerOrchestrator } from "../../services/media/ContainerOrchestrator.js";
-
-/**
- * Every byte of a range from the fake file's stream.
- *
- * @param {object} file
- * @param {number} start
- * @param {number} end
- * @returns {Promise<Buffer>}
- */
-async function readThroughStream(file, start, end) {
-  const chunks = [];
-  for await (const chunk of file.createReadStream({ start, end })) {
-    chunks.push(Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks);
-}
-
-/** One orchestrator for the checks that do not bring their own. */
-const sharedContainers = new ContainerOrchestrator();
-
-/**
- * @param {object} torrent - The fake a check builds: `pieceLength`, `bitfield`,
- *   `files[]` with `offset`, `length`, `name`, `createReadStream`.
- * @param {number} fileIndex
- * @param {string} sourceKey
- * @param {{ containers?: ContainerOrchestrator, readRange?: (start: number, end: number) => Promise<Buffer | null>, wantedSeconds?: () => number[], portionBytes?: number }} [options]
- * @returns {import("../../services/media/SubtitleCues.js").HeldFile}
- */
-export function heldFileOver(torrent, fileIndex, sourceKey, options = {}) {
-  const file = torrent?.files?.[fileIndex] ?? {};
-  const containers = options.containers ?? sharedContainers;
-  const readRange = options.readRange ?? ((start, end) => readThroughStream(file, start, end));
-  return {
-    sourceKey,
-    fileIndex,
-    name: String(file.name ?? ""),
-    length: Number(file.length) || 0,
-    portionBytes: options.portionBytes,
-    container: () =>
-      containers.containerFor({
-        sourceKey,
-        fileIndex,
-        readRange,
-        fileSize: Number(file.length) || 0,
-        label: String(file.name ?? ""),
-        portionBytes: options.portionBytes
-      }),
-    heldRanges: async () => heldRangesOf(torrent, fileIndex),
-    readHeld: (start, end) => readHeldBytes(torrent, fileIndex, start, end),
-    wantedSeconds: options.wantedSeconds
-  };
-}
-
-/**
- * Forget what the shared orchestrator built for a source.
- *
- * @param {string} sourceKey
- * @returns {void}
- */
-export function forgetContainers(sourceKey) {
-  sharedContainers.forget(sourceKey);
-}

package/test/helpers/manager.js

@@ -1,62 +0,0 @@
-/**
- * @file A session manager for a test, with a store of its own.
- *
- * ONE MANAGER, ONE ROOT. In production that is true by construction: one
- * process holds one manager, and the store's root is a fixed path so that a
- * restart can find what the process before it finished (`SegmentStore.sweep`).
- * Under `node --test` it is false — the runner starts one PROCESS PER FILE and
- * runs them in parallel, so every manager built without a store of its own
- * shared the one default root with every other file running at that moment.
- *
- * What that cost, measured 2026-09-14: `disposeAll` removes the store's whole
- * root, and four files call it between them 40 times. Running the twenty-one
- * files that build a manager gave 2, 3 and 4 failures on consecutive runs and
- * zero with `--test-concurrency=1`; the victim was always
- * `segment-serve-wiring.test.js`, reporting a segment missing that it had
- * written itself a moment earlier, because another process had deleted the
- * directory under it. `npm test` is `node --test`, so this was the project's
- * own test command, and it is why a red result had become something to read
- * past rather than to act on.
- *
- * A test that fails by luck is worse than one that does not exist: it costs a
- * run every time, and it trains everyone to ignore red.
- */
-
-import { mkdtempSync, rmSync } 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";
-
-/**
- * A manager whose produced segments live where nothing else can reach them.
- *
- * @param {object} [options] - Passed to the manager, over the defaults below.
- *   A `segmentStore` given here wins, for a test that wants to watch the store
- *   itself.
- * @returns {{ manager: object, store: SegmentStore, root: string,
- *   cleanup: () => void }} `cleanup` removes the root; call it from `t.after`.
- */
-export function managerWithOwnStore(options = {}) {
-  const root = mkdtempSync(path.join(os.tmpdir(), "ttv-store-"));
-  const store = options.segmentStore ?? new SegmentStore({ root });
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    // What this host has measured about itself is kept beside the store, not
-    // beside the installed proxy: read from there, one run's figures became
-    // the next run's premises, and a check passed only on a machine that had
-    // run the suite before.
-    stateDir: root,
-    ...options,
-    segmentStore: store
-  });
-  return {
-    manager,
-    store,
-    root,
-    cleanup: () => rmSync(root, { recursive: true, force: true })
-  };
-}