@torrent-tv/proxy 2.87.21 → 2.88.0

package/test/playback-start-regressions.test.js

@@ -1,99 +1,99 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { EventEmitter } from "node:events";
-import { EncodeRun } from "../services/encode/EncodeRun.js";
-import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
-import { predictPlaybackReadiness } from "../services/server/playback-readiness.js";
-
-function encode() {
-  const child = new EventEmitter();
-  child.stdio = [null, new EventEmitter(), new EventEmitter(), new EventEmitter()];
-  child.stderr = child.stdio[2];
-  child.kill = () => {};
-  const published = [];
-  const ended = [];
-  const run = new EncodeRun({
-    address: "fake", from: 0, to: 1, encoder: new SoftwareEncoder(),
-    buildArgs: () => [], spawn: () => child, logger: { info() {}, warn() {} },
-    indexOfName: (name) => Number(name),
-    onClosed: (name) => { published.push(name); return name; },
-    onEnded: (value) => ended.push(value)
-  });
-  return { child, run, published, ended };
-}
-
-test("a clean short input never publishes its flushed tail", () => {
-  const { child, published, ended } = encode();
-  child.stderr.emit("data", "Stream ends prematurely at 1048576");
-  child.stdio[3].emit("data", "0\n");
-  child.emit("close", 0, null);
-  assert.deepEqual(published, []);
-  assert.equal(ended[0].ending, "short");
-  assert.equal(ended[0].reached, -1);
-});
-
-test("completed cuts survive a failure but its last flushed file does not", () => {
-  const { child, published } = encode();
-  child.stdio[3].emit("data", "0\n");
-  child.stderr.emit("data", "Stream ends prematurely at 1048576");
-  child.stdio[3].emit("data", "1\n");
-  child.emit("close", 0, null);
-  assert.deepEqual(published, ["0"]);
-});
-
-test("normal completion drains the filename pipe before publishing the tail", () => {
-  const { child, published, ended } = encode();
-  child.emit("exit", 0, null);
-  assert.deepEqual(ended, []);
-  child.stdio[3].emit("data", "0\n1\n");
-  child.emit("close", 0, null);
-  assert.deepEqual(published, ["0", "1"]);
-  assert.equal(ended[0].ending, "complete");
-});
-
-test("stopping retains an earlier closed cut and rejects the signal-flushed tail", () => {
-  const { child, run, published } = encode();
-  child.stdio[3].emit("data", "0\n");
-  run.stop("a different range is needed");
-  child.stdio[3].emit("data", "1\n");
-  child.emit("close", null, "SIGTERM");
-  assert.deepEqual(published, ["0"]);
-});
-
-function state(clientRanges) {
-  return {
-    now: 10_000, positionSeconds: 0, durationSeconds: 8,
-    bufferedAheadSeconds: 8, bufferLimitSeconds: 8, reserveSeconds: 0, lookaheadSeconds: 8,
-    sources: [{ id: "source", complete: true }],
-    linkReadings: [{ at: 10_000, value: 80 }],
-    tracks: [{ id: "video", sourceIds: ["source"], processedSeconds: 8,
-      bitsPerMediaSecond: 80, readings: [{ at: 10_000, value: 2 }],
-      readySegmentIndices: [0, 1], segmentSizesBytes: new Map([[0, 40], [1, 40]]),
-      clientRanges, segments: [{ index: 0, startSeconds: 0, endSeconds: 4 },
-        { index: 1, startSeconds: 4, endSeconds: 8 }] }]
-  };
-}
-
-test("future browser ranges are retained rather than transferred again", () => {
-  const forecast = predictPlaybackReadiness(state([{ start: 4, end: 8 }]));
-  assert.equal(forecast.ready, false);
-  assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Math.abs(forecast.delaySeconds - 4) < 1e-8);
-});
-
-test("a real media hole is not hidden by the scalar buffer or ready file count", () => {
-  const input = state([{ start: 0, end: 3 }, { start: 4, end: 8 }]);
-  input.tracks[0].segments[0].mediaRanges = [{ start: 0, end: 3 }];
-  const forecast = predictPlaybackReadiness(input);
-  assert.equal(forecast.ready, false);
-  assert.equal(forecast.bufferedSeconds, 3);
-  assert.equal(forecast.reason, "no-safe-start-found");
-});
-
-test("missing work before global progress can still be produced", () => {
-  const input = state([]);
-  input.tracks[0].readySegmentIndices = [1];
-  const forecast = predictPlaybackReadiness(input);
-  assert.equal(forecast.reason, "minimum-safe-delay");
-  assert.ok(Number.isFinite(forecast.delaySeconds));
-});
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { EncodeRun } from "../services/encode/EncodeRun.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { predictPlaybackReadiness } from "../services/server/playback-readiness.js";
+
+function encode() {
+  const child = new EventEmitter();
+  child.stdio = [null, new EventEmitter(), new EventEmitter(), new EventEmitter()];
+  child.stderr = child.stdio[2];
+  child.kill = () => {};
+  const published = [];
+  const ended = [];
+  const run = new EncodeRun({
+    address: "fake", from: 0, to: 1, encoder: new SoftwareEncoder(),
+    buildArgs: () => [], spawn: () => child, logger: { info() {}, warn() {} },
+    indexOfName: (name) => Number(name),
+    onClosed: (name) => { published.push(name); return name; },
+    onEnded: (value) => ended.push(value)
+  });
+  return { child, run, published, ended };
+}
+
+test("a clean short input never publishes its flushed tail", () => {
+  const { child, published, ended } = encode();
+  child.stderr.emit("data", "Stream ends prematurely at 1048576");
+  child.stdio[3].emit("data", "0\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, []);
+  assert.equal(ended[0].ending, "short");
+  assert.equal(ended[0].reached, -1);
+});
+
+test("completed cuts survive a failure but its last flushed file does not", () => {
+  const { child, published } = encode();
+  child.stdio[3].emit("data", "0\n");
+  child.stderr.emit("data", "Stream ends prematurely at 1048576");
+  child.stdio[3].emit("data", "1\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, ["0"]);
+});
+
+test("normal completion drains the filename pipe before publishing the tail", () => {
+  const { child, published, ended } = encode();
+  child.emit("exit", 0, null);
+  assert.deepEqual(ended, []);
+  child.stdio[3].emit("data", "0\n1\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, ["0", "1"]);
+  assert.equal(ended[0].ending, "complete");
+});
+
+test("stopping retains an earlier closed cut and rejects the signal-flushed tail", () => {
+  const { child, run, published } = encode();
+  child.stdio[3].emit("data", "0\n");
+  run.stop("a different range is needed");
+  child.stdio[3].emit("data", "1\n");
+  child.emit("close", null, "SIGTERM");
+  assert.deepEqual(published, ["0"]);
+});
+
+function state(clientRanges) {
+  return {
+    now: 10_000, positionSeconds: 0, durationSeconds: 8,
+    bufferedAheadSeconds: 8, bufferLimitSeconds: 8, reserveSeconds: 0, lookaheadSeconds: 8,
+    sources: [{ id: "source", complete: true }],
+    linkReadings: [{ at: 10_000, value: 80 }],
+    tracks: [{ id: "video", sourceIds: ["source"], processedSeconds: 8,
+      bitsPerMediaSecond: 80, readings: [{ at: 10_000, value: 2 }],
+      readySegmentIndices: [0, 1], segmentSizesBytes: new Map([[0, 40], [1, 40]]),
+      clientRanges, segments: [{ index: 0, startSeconds: 0, endSeconds: 4 },
+        { index: 1, startSeconds: 4, endSeconds: 8 }] }]
+  };
+}
+
+test("future browser ranges are retained rather than transferred again", () => {
+  const forecast = predictPlaybackReadiness(state([{ start: 4, end: 8 }]));
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 4) < 1e-8);
+});
+
+test("a real media hole is not hidden by the scalar buffer or ready file count", () => {
+  const input = state([{ start: 0, end: 3 }, { start: 4, end: 8 }]);
+  input.tracks[0].segments[0].mediaRanges = [{ start: 0, end: 3 }];
+  const forecast = predictPlaybackReadiness(input);
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.bufferedSeconds, 3);
+  assert.equal(forecast.reason, "no-safe-start-found");
+});
+
+test("missing work before global progress can still be produced", () => {
+  const input = state([]);
+  input.tracks[0].readySegmentIndices = [1];
+  const forecast = predictPlaybackReadiness(input);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Number.isFinite(forecast.delaySeconds));
+});

package/test/priority-map-download.test.js

@@ -1,174 +1,174 @@
-/**
- * @file What the download is told when the priority map changes.
- *
- * The map states seconds of film against a number. This is the one place those
- * seconds become bytes, and the one place the map's own scale — as many bands
- * as the film needs — is fitted onto the five levels the register has. Both
- * were written on 2026-09-05 to replace the windows the reads themselves used
- * to declare: fifteen reads on one file were fifteen windows on a piece store
- * holding sixteen pieces, and half of all evictions then took a piece a reader
- * had said it wanted.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { TorrentPool } from "../services/torrent/torrent-pool.js";
-import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
-import { Urgency } from "../services/torrent/demand/index.js";
-import { mapForViewer, runsOf } from "../services/viewer/PriorityMap.js";
-
-/** A torrent that is nothing but one file of a known length. */
-function torrentOf({ length = 1_000_000, offset = 0 } = {}) {
-  return {
-    infoHash: `hash-${Math.random().toString(36).slice(2)}`,
-    pieceLength: 1024,
-    files: [{ offset, length, name: "film.mkv" }],
-    _selections: { _items: [] },
-    _select() {},
-    _deselect() {},
-    critical() {}
-  };
-}
-
-/** The pool's method under test, called without building a pool. */
-const applyPriorityMap = TorrentPool.prototype.applyPriorityMap;
-
-test("seconds of film become bytes of the file", () => {
-  const torrent = torrentOf({ length: 1000 });
-  try {
-    applyPriorityMap.call(null, torrent, 0, [
-      { from: 0, to: 100, priority: 5 },
-      { from: 100, to: 200, priority: 3 }
-    ], 200);
-
-    const { register } = demandFor(torrent);
-    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-    assert.equal(stated.length, 2);
-    const first = stated.find((one) => one.byteStart === 0);
-    assert.equal(first.byteEnd, 499, "half the film is half the file");
-    const second = stated.find((one) => one.byteStart === 500);
-    assert.equal(second.byteEnd, 999, "the last byte of the file, not one past it");
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a zone is stated at the level it means, not at the level of its position", () => {
-  const torrent = torrentOf();
-  try {
-    // A viewer 300 s into a 3000 s film: one band behind them that nobody is
-    // approaching, then bands of decreasing urgency ahead.
-    const zones = runsOf(mapForViewer({
-      atSeconds: 300,
-      durationSeconds: 3000,
-      allowanceSeconds: 10
-    }));
-    assert.ok(zones.length > 5, "the map should be finer than the register's levels");
-
-    applyPriorityMap.call(null, torrent, 0, zones, 3000);
-    const { register } = demandFor(torrent);
-    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-
-    const near = stated.filter((one) => one.urgency === Urgency.NEAR);
-    assert.equal(near.length, 1, "exactly one band is where the viewer is");
-    assert.equal(near[0].byteStart, Math.floor((300 / 3000) * 1_000_000));
-
-    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
-    assert.equal(behind.length, 1, "what nobody is approaching is the one thing wanted last");
-    assert.equal(behind[0].byteStart, 0, "and it is the stretch behind the viewer");
-
-    assert.ok(
-      stated.some((one) => one.urgency === Urgency.AHEAD),
-      "the lead being built was stated at no level of its own"
-    );
-    assert.ok(
-      stated.every((one) => one.urgency !== Urgency.BLOCKED),
-      "the map claimed BLOCKED, which only a reader stopped on those bytes may say"
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a viewer who has stopped the picture makes the whole film wanted last", () => {
-  const torrent = torrentOf();
-  try {
-    const zones = runsOf(mapForViewer({
-      atSeconds: 300,
-      durationSeconds: 3000,
-      allowanceSeconds: 10,
-      playing: false
-    }));
-    applyPriorityMap.call(null, torrent, 0, zones, 3000);
-
-    const { register } = demandFor(torrent);
-    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
-    // A PAUSE REMOVES THE TIME, NOT THE DIRECTION. What they have watched is
-    // behind them and what they have not is in front, exactly as while they were
-    // watching; what changes is that nothing has a time any more, so every band
-    // of theirs yields to anybody who is on their way somewhere.
-    assert.ok(stated.length >= 2, "their position survives the pause");
-    for (const one of stated) {
-      assert.ok(
-        one.urgency === Urgency.BEHIND || one.urgency === Urgency.TAIL,
-        "and nothing of theirs is urgent, because nobody is coming"
-      );
-    }
-    const front = stated.filter((one) => one.urgency === Urgency.TAIL);
-    assert.ok(front.length >= 1, "the film in front of them is still in front");
-    assert.ok(
-      front[0].byteStart >= Math.floor((300 / 3000) * 1_000_000),
-      "and it begins where they stopped"
-    );
-    // Wanted last ABSOLUTELY, not relative to this film's own map. The two
-    // speculative levels are withheld across every torrent at once while
-    // anything urgent is missing anywhere, so this has to lose to a film
-    // somebody is actually watching — and judged against itself alone it would
-    // be the most urgent thing there is.
-    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
-    assert.equal(behind.length, 1, "what they have already watched is wanted last of all");
-    assert.equal(behind[0].byteStart, 0, "and it is the stretch from the beginning to where they stopped");
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a map with fewer bands than the last one leaves nothing stated behind", () => {
-  const torrent = torrentOf();
-  try {
-    applyPriorityMap.call(null, torrent, 0, [
-      { from: 0, to: 100, priority: 5 },
-      { from: 100, to: 200, priority: 4 },
-      { from: 200, to: 300, priority: 3 }
-    ], 300);
-    const { register } = demandFor(torrent);
-    assert.equal(
-      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
-      3
-    );
-
-    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 300, priority: 5 }], 300);
-    assert.equal(
-      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
-      1,
-      "bands the map no longer has went on being asked for"
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
-
-test("a file of unknown length or duration is not guessed at", () => {
-  const torrent = torrentOf();
-  try {
-    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 100, priority: 5 }], 0);
-    applyPriorityMap.call(null, torrent, 7, [{ from: 0, to: 100, priority: 5 }], 300);
-    const { register } = demandFor(torrent);
-    assert.equal(
-      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
-      0
-    );
-  } finally {
-    forgetTorrent(torrent);
-  }
-});
+/**
+ * @file What the download is told when the priority map changes.
+ *
+ * The map states seconds of film against a number. This is the one place those
+ * seconds become bytes, and the one place the map's own scale — as many bands
+ * as the film needs — is fitted onto the five levels the register has. Both
+ * were written on 2026-09-05 to replace the windows the reads themselves used
+ * to declare: fifteen reads on one file were fifteen windows on a piece store
+ * holding sixteen pieces, and half of all evictions then took a piece a reader
+ * had said it wanted.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { TorrentPool } from "../services/torrent/torrent-pool.js";
+import { demandFor, forgetTorrent } from "../services/torrent/download/registry.js";
+import { Urgency } from "../services/torrent/demand/index.js";
+import { mapForViewer, runsOf } from "../services/viewer/PriorityMap.js";
+
+/** A torrent that is nothing but one file of a known length. */
+function torrentOf({ length = 1_000_000, offset = 0 } = {}) {
+  return {
+    infoHash: `hash-${Math.random().toString(36).slice(2)}`,
+    pieceLength: 1024,
+    files: [{ offset, length, name: "film.mkv" }],
+    _selections: { _items: [] },
+    _select() {},
+    _deselect() {},
+    critical() {}
+  };
+}
+
+/** The pool's method under test, called without building a pool. */
+const applyPriorityMap = TorrentPool.prototype.applyPriorityMap;
+
+test("seconds of film become bytes of the file", () => {
+  const torrent = torrentOf({ length: 1000 });
+  try {
+    applyPriorityMap.call(null, torrent, 0, [
+      { from: 0, to: 100, priority: 5 },
+      { from: 100, to: 200, priority: 3 }
+    ], 200);
+
+    const { register } = demandFor(torrent);
+    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
+    assert.equal(stated.length, 2);
+    const first = stated.find((one) => one.byteStart === 0);
+    assert.equal(first.byteEnd, 499, "half the film is half the file");
+    const second = stated.find((one) => one.byteStart === 500);
+    assert.equal(second.byteEnd, 999, "the last byte of the file, not one past it");
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a zone is stated at the level it means, not at the level of its position", () => {
+  const torrent = torrentOf();
+  try {
+    // A viewer 300 s into a 3000 s film: one band behind them that nobody is
+    // approaching, then bands of decreasing urgency ahead.
+    const zones = runsOf(mapForViewer({
+      atSeconds: 300,
+      durationSeconds: 3000,
+      allowanceSeconds: 10
+    }));
+    assert.ok(zones.length > 5, "the map should be finer than the register's levels");
+
+    applyPriorityMap.call(null, torrent, 0, zones, 3000);
+    const { register } = demandFor(torrent);
+    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
+
+    const near = stated.filter((one) => one.urgency === Urgency.NEAR);
+    assert.equal(near.length, 1, "exactly one band is where the viewer is");
+    assert.equal(near[0].byteStart, Math.floor((300 / 3000) * 1_000_000));
+
+    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
+    assert.equal(behind.length, 1, "what nobody is approaching is the one thing wanted last");
+    assert.equal(behind[0].byteStart, 0, "and it is the stretch behind the viewer");
+
+    assert.ok(
+      stated.some((one) => one.urgency === Urgency.AHEAD),
+      "the lead being built was stated at no level of its own"
+    );
+    assert.ok(
+      stated.every((one) => one.urgency !== Urgency.BLOCKED),
+      "the map claimed BLOCKED, which only a reader stopped on those bytes may say"
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a viewer who has stopped the picture makes the whole film wanted last", () => {
+  const torrent = torrentOf();
+  try {
+    const zones = runsOf(mapForViewer({
+      atSeconds: 300,
+      durationSeconds: 3000,
+      allowanceSeconds: 10,
+      playing: false
+    }));
+    applyPriorityMap.call(null, torrent, 0, zones, 3000);
+
+    const { register } = demandFor(torrent);
+    const stated = register.windows().filter((one) => String(one.claimant).startsWith("priority-map:"));
+    // A PAUSE REMOVES THE TIME, NOT THE DIRECTION. What they have watched is
+    // behind them and what they have not is in front, exactly as while they were
+    // watching; what changes is that nothing has a time any more, so every band
+    // of theirs yields to anybody who is on their way somewhere.
+    assert.ok(stated.length >= 2, "their position survives the pause");
+    for (const one of stated) {
+      assert.ok(
+        one.urgency === Urgency.BEHIND || one.urgency === Urgency.TAIL,
+        "and nothing of theirs is urgent, because nobody is coming"
+      );
+    }
+    const front = stated.filter((one) => one.urgency === Urgency.TAIL);
+    assert.ok(front.length >= 1, "the film in front of them is still in front");
+    assert.ok(
+      front[0].byteStart >= Math.floor((300 / 3000) * 1_000_000),
+      "and it begins where they stopped"
+    );
+    // Wanted last ABSOLUTELY, not relative to this film's own map. The two
+    // speculative levels are withheld across every torrent at once while
+    // anything urgent is missing anywhere, so this has to lose to a film
+    // somebody is actually watching — and judged against itself alone it would
+    // be the most urgent thing there is.
+    const behind = stated.filter((one) => one.urgency === Urgency.BEHIND);
+    assert.equal(behind.length, 1, "what they have already watched is wanted last of all");
+    assert.equal(behind[0].byteStart, 0, "and it is the stretch from the beginning to where they stopped");
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a map with fewer bands than the last one leaves nothing stated behind", () => {
+  const torrent = torrentOf();
+  try {
+    applyPriorityMap.call(null, torrent, 0, [
+      { from: 0, to: 100, priority: 5 },
+      { from: 100, to: 200, priority: 4 },
+      { from: 200, to: 300, priority: 3 }
+    ], 300);
+    const { register } = demandFor(torrent);
+    assert.equal(
+      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
+      3
+    );
+
+    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 300, priority: 5 }], 300);
+    assert.equal(
+      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
+      1,
+      "bands the map no longer has went on being asked for"
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});
+
+test("a file of unknown length or duration is not guessed at", () => {
+  const torrent = torrentOf();
+  try {
+    applyPriorityMap.call(null, torrent, 0, [{ from: 0, to: 100, priority: 5 }], 0);
+    applyPriorityMap.call(null, torrent, 7, [{ from: 0, to: 100, priority: 5 }], 300);
+    const { register } = demandFor(torrent);
+    assert.equal(
+      register.windows().filter((one) => String(one.claimant).startsWith("priority-map:")).length,
+      0
+    );
+  } finally {
+    forgetTorrent(torrent);
+  }
+});