@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/tracks-begin-together.test.js

@@ -1,209 +0,0 @@
-/**
- * @file Picture and sound must begin their runs at the same real instant.
- *
- * The two branches are asked for the same time and land in different places: a
- * copied picture may only begin at a real keyframe and may not begin before the
- * time asked for, so it moves FORWARD to the next one; a soundtrack has no
- * keyframes and begins exactly where asked. Measured 2026-08-17, the difference
- * was 0.58-2.96 s on one file, and the viewer got sound with no new picture for
- * as long as it lasted.
- *
- * The picture's true start is measured from the piece it produced. This pins
- * that the measurement is carried to the other members of the family.
- */
-
-import assert from "node:assert/strict";
-import { SourceFile } from "../services/media/SourceFile.js";
-import { startRunOn } from "./helpers/encode-run.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { trueStartOf } from "../services/encode/run-command.js";
-import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
-import { ENCODE_RUN_STATE, INITIAL_RUN_STATE } from "../services/encode/encode-run-state.js";
-import { outputSpec } from "./helpers/output-spec.js";
-
-const BOUNDARIES = [0, 4, 8, 12, 16, 20];
-
-/**
- * A film's family: the picture, and a soundtrack rendition of it. Both runs
- * begin at boundary #2, which the container's table puts at 8 s.
- *
- * @returns {{ manager: object, picture: object, sound: object }}
- */
-function familyAtBoundaryTwo() {
-  // ONE table for the film. Where it is cut is a fact about the FILE, so the
-  // picture and its soundtrack hold the same array rather than a copy each.
-  const boundaries = [...BOUNDARIES];
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const picture = {
-    id: "picture",
-    spec: outputSpec({ transcodeVideo: false }),
-    get outputKey() { return this.spec.toKey(); },
-    state: "ready",
-    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.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 — and the
-    // command is built from all three, so a fixture that states only the first
-    // describes a session the product cannot make.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    // How its pieces are packaged. The command asks the format where to cut and
-    // what to name the files, so a session without one is not a session.
-    segmentFormat: fmp4Format,
-    // Where its encoder has got to, which a run writes into as it works.
-    progress: { processedSeconds: 0 },
-    runs: new Set()
-  };
-  // The soundtrack of that picture: the same file, published on its own. Found
-  // by what it is, since no list of ids names it any more.
-  const sound = {
-    id: "sound",
-    spec: outputSpec({ audioOnly: true }),
-    get outputKey() { return this.spec.toKey(); },
-    state: "ready",
-    baseSessionId: "picture",
-    timeline: new Timeline({ boundaries: boundaries, cutGrid: "uniform" }),
-    file: new SourceFile({ sourceKey: "source-1", fileIndex: 0, name: "film.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 — and the
-    // command is built from all three, so a fixture that states only the first
-    // describes a session the product cannot make.
-    get inputFile() { return this.file; },
-    get audioFile() { return this.file; },
-    // How its pieces are packaged. The command asks the format where to cut and
-    // what to name the files, so a session without one is not a session.
-    segmentFormat: fmp4Format,
-    // Where its encoder has got to, which a run writes into as it works.
-    progress: { processedSeconds: 0 },
-    runs: new Set()
-  };
-  const pictureRun = startRunOn(picture, { from: 2 });
-  const soundRun = startRunOn(sound, { from: 2 });
-  manager.encodeOrchestrator.adopt(picture.outputKey, pictureRun);
-  manager.encodeOrchestrator.adopt(sound.outputKey, soundRun);
-  manager.outputs.set("picture", picture);
-  manager.outputs.set("sound", sound);
-
-  return { manager, picture, sound };
-}
-
-test("a soundtrack follows the picture to the instant the picture really began", () => {
-  const { manager, picture, sound } = familyAtBoundaryTwo();
-  const runBefore = [...sound.runs][0];
-
-  manager.outputTimes.correctBoundaryFromSegment(picture, 2, 10.5);
-
-  assert.deepEqual(
-    picture.timeline.boundaries,
-    [0, 4, 10.5, 12, 16, 20],
-    "the family's table must hold what the file itself said"
-  );
-  assert.equal(
-    sound.timeline.boundaries[2],
-    10.5,
-    "and every member's table with it — one film, one table, nothing to keep in step"
-  );
-  // THE RUN AT THE WRONG INSTANT IS STOPPED, and nothing here places its
-  // replacement. What has been learned is that this run is producing in the
-  // wrong place, which nothing but the piece it produced could say — the plan
-  // reasons about numbers and cannot know it. So the fact is acted on as far as
-  // it is known and no further: the run goes, the stretch it held returns to the
-  // map, and where the next one stands follows from where the viewers are.
-  assert.equal(runBefore.state, ENCODE_RUN_STATE.STOPPED, "the run in the wrong place goes");
-  assert.equal(
-    manager.encodeOrchestrator.runsOn(sound.outputKey).filter((run) => run.isAlive).length,
-    0,
-    "and this path places nothing"
-  );
-  // The corrected instant reaches whatever the plan places there through the
-  // table, which every session of the file shares. It used to be passed as an
-  // argument from this one call site, so only a run started by that line ever
-  // had it — a run the plan placed at the same number landed apart again.
-  assert.equal(
-    trueStartOf(sound.timeline, 2),
-    10.5,
-    "the live table holds the measurement and the published one the prediction"
-  );
-});
-
-test("where a number really begins is answered only where it has been measured", () => {
-  const { sound } = familyAtBoundaryTwo();
-
-  assert.equal(
-    trueStartOf(sound.timeline, 2),
-    undefined,
-    "the two tables agree, so there is nothing measured to prefer"
-  );
-  sound.timeline.boundaries[2] = 10.5;
-  assert.equal(trueStartOf(sound.timeline, 2), 10.5);
-  assert.equal(trueStartOf(sound.timeline, 3), undefined, "and only about the number measured");
-  assert.equal(trueStartOf(sound.timeline, 99), undefined, "a number the file does not have");
-  assert.equal(trueStartOf(null, 0), undefined, "and no table at all");
-});
-
-test("a correction the table already holds moves nobody", () => {
-  const { manager, picture, sound } = familyAtBoundaryTwo();
-  const before = [...sound.timeline.boundaries];
-  // Within the tolerance: the reading agrees with the table, so there is
-  // nothing to correct and nothing to move. This is what makes the repositioning
-  // converge instead of repeating on every produced segment.
-  manager.outputTimes.correctBoundaryFromSegment(picture, 2, 8.1);
-  assert.deepEqual(sound.timeline.boundaries, before);
-});
-
-test("a member that is not running is left alone", () => {
-  const { manager, picture, sound } = familyAtBoundaryTwo();
-  // A rung the viewer switched away from has no process. Moving it would start
-  // an encoder for nobody — the failure that put three ffmpeg runs on one file.
-  const soundRun = [...sound.runs][0];
-  soundRun.stop("the viewer switched away");
-  // A stopped run is no longer live, so nothing of this session begins at #2
-  // any more — which is what "left alone" means here.
-  manager.outputTimes.correctBoundaryFromSegment(picture, 2, 10.5);
-  assert.equal(
-    manager.encodeOrchestrator.runsOn(sound.outputKey).filter((run) => run.isAlive).length,
-    0,
-    "a stopped member is not started again for nobody"
-  );
-  assert.equal(soundRun.from, 2, "a stopped member keeps its place and its silence");
-  assert.equal(soundRun.state, ENCODE_RUN_STATE.STOPPED);
-  assert.notEqual(INITIAL_RUN_STATE, ENCODE_RUN_STATE.STOPPED);
-});
-
-test("a soundtrack does not move the grid the picture is cut on", () => {
-  const { manager, picture, sound } = familyAtBoundaryTwo();
-  const pictureBefore = [...picture.timeline.boundaries];
-  const soundBefore = [...sound.timeline.boundaries];
-
-  // The sound reports where IT began, which is where it was asked to begin, to
-  // within one audio frame. The picture's own boundary is a keyframe of the
-  // file and can be seconds away from that — both readings correct, about
-  // different things.
-  //
-  // Field 2026-08-20: boundary #521 of one film was corrected 2086.084 →
-  // 2084.082 by the picture and 2084.082 → 2086.033 by the sound 1.6 s later,
-  // 1.951 s apart, each overwriting the other for as long as the film ran. The
-  // table never converged, so the guard that stops a correction the table
-  // already holds never fired.
-  manager.outputTimes.correctBoundaryFromSegment(sound, 2, 10.5);
-
-  assert.deepEqual(
-    picture.timeline.boundaries,
-    pictureBefore,
-    "the grid is the picture's cut list and a soundtrack may not move it"
-  );
-  assert.deepEqual(sound.timeline.boundaries, soundBefore);
-  assert.equal(
-    manager.encodeOrchestrator.runsOn(picture.outputKey).filter((run) => run.isAlive).length,
-    1,
-    "and nothing is restarted on a soundtrack's say-so"
-  );
-});

package/test/tunnel-renewal.test.js

@@ -1,167 +0,0 @@
-/**
- * @file The tunnel is replaced before anything upstream ends it, and the
- * replacement takes over first.
- *
- * Something between the proxy and the server closes the socket after exactly
- * 100 min 15 s whatever is flowing over it — measured across a day of logs on
- * 2026-08-20, `code=1006` each time, with a 30 s keepalive running throughout,
- * so it is a lifetime cap and not an idle timeout. Reconnecting afterwards
- * costs five seconds in which the proxy does not exist as far as the registry
- * is concerned, and a viewer arriving then is told there is no proxy.
- *
- * What is pinned here is the property that removes that window: at no instant
- * is the server without a registered connection for this proxy.
- */
-
-import assert from "node:assert/strict";
-import test from "node:test";
-import { WebSocketServer } from "ws";
-
-import { createTunnelClient } from "../services/transport/tunnel-client.js";
-
-/**
- * Wait for the thing being asserted, not for a length of time.
- *
- * A chosen interval followed by an assertion does not test — it samples, and
- * what it samples is how busy the machine is. The deadline here is a backstop
- * that turns a hang into a failure; it is never the measurement.
- *
- * @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 stand-in for the registry's tunnel endpoint, with the one behaviour that
- * matters here: a new connection for a proxy REPLACES the previous one, which
- * is what `registerConnection` does in `server/services/proxy-tunnel-server.js`.
- *
- * @returns {Promise<{ url: string, close: () => Promise<void>, registered: () => number, opened: () => number, everEmpty: () => boolean }>}
- */
-async function startRegistry() {
-  const server = new WebSocketServer({ port: 0 });
-  await new Promise((resolve) => { server.on("listening", resolve); });
-  /** @type {import("ws").WebSocket | null} */
-  let current = null;
-  let opened = 0;
-  let everEmpty = false;
-  /** Every socket ever accepted, so the server can be shut without waiting. */
-  const accepted = new Set();
-  server.on("connection", (socket) => {
-    opened += 1;
-    accepted.add(socket);
-    socket.on("close", () => { accepted.delete(socket); });
-    const previous = current;
-    current = socket;
-    // The replacement is registered BEFORE the old one is closed, so a reader
-    // of `current` never sees nothing.
-    if (previous && previous.readyState < 2) {
-      previous.close(1000, "replaced");
-    }
-    socket.on("close", () => {
-      if (current === socket) {
-        current = null;
-        everEmpty = true;
-      }
-    });
-  });
-  const { port } = server.address();
-  return {
-    url: `http://127.0.0.1:${port}`,
-    // `close` waits for every connection to end, and a renewal can leave one
-    // still closing, so they are ended here rather than waited on.
-    close: () => new Promise((resolve) => {
-      for (const socket of accepted) {
-        socket.terminate();
-      }
-      accepted.clear();
-      server.close(() => resolve());
-    }),
-    registered: () => (current && current.readyState === 1 ? 1 : 0),
-    killCurrent: () => { current?.terminate(); },
-    opened: () => opened,
-    everEmpty: () => everEmpty
-  };
-}
-
-test("the connection is replaced before its lifetime runs out, without a gap", async (t) => {
-  const registry = await startRegistry();
-  /** @type {string[]} */
-  const lines = [];
-  const client = createTunnelClient({
-    serverUrl: registry.url,
-    proxyId: "p1",
-    token: "t",
-    proxyPort: 9090,
-    onLog: (line) => lines.push(line),
-    // The real cap is 100 min 15 s and the real renewal is at 90 min; the
-    // ratio is what matters, not the magnitude.
-    connectionLifetimeMs: 150
-  });
-  t.after(async () => {
-    client.disconnect();
-    await registry.close();
-  });
-
-  client.connect();
-  // Until the renewals have happened, however long this machine takes over
-  // them. Waited out as 700 ms instead — about four lifetimes — this asserted
-  // how many the scheduler had got round to.
-  await waitFor(() => registry.opened() >= 3, "three connections");
-
-  assert.ok(registry.opened() >= 3, `expected several renewals, saw ${registry.opened()}`);
-  // The property this exists for: the registry was never left with nothing.
-  assert.equal(registry.everEmpty(), false, "the registry lost its connection at some point");
-  assert.equal(registry.registered(), 1);
-  // And the proxy knows the difference between a handover and going down. A
-  // "Reconnecting in" line here would mean it had treated its own renewal as a
-  // failure and waited five seconds before coming back.
-  assert.ok(lines.some((line) => line.includes("Tunnel renewing")), lines.join("\n"));
-  assert.ok(lines.some((line) => line.includes("Tunnel handed over")), lines.join("\n"));
-  assert.equal(lines.filter((line) => line.includes("Reconnecting in")).length, 0, lines.join("\n"));
-});
-
-test("a connection killed from outside is still reconnected", async (t) => {
-  const registry = await startRegistry();
-  /** @type {string[]} */
-  const lines = [];
-  const client = createTunnelClient({
-    serverUrl: registry.url,
-    proxyId: "p2",
-    token: "t",
-    proxyPort: 9090,
-    onLog: (line) => lines.push(line),
-    // Far longer than this test runs, so nothing renews and the only close is
-    // the one forced below — which is what the upstream cap looks like from
-    // here: an abrupt end nobody asked for.
-    connectionLifetimeMs: 60_000
-  });
-  t.after(async () => {
-    client.disconnect();
-    await registry.close();
-  });
-
-  client.connect();
-  await waitFor(() => registry.opened() === 1, "the first connection");
-  // And exactly one: the lifetime above is far longer than this test runs, so
-  // nothing renews and a second would mean something else had opened it.
-  assert.equal(registry.opened(), 1);
-
-  registry.killCurrent();
-  // The renewal must not have taken the ordinary reconnect away with it.
-  await waitFor(
-    () => lines.some((line) => line.includes("Reconnecting in")),
-    "the reconnect after a connection was killed from outside"
-  );
-});