@torrent-tv/proxy 2.9.96 → 2.9.97

package/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 2.9.97
+
+- **Fix**: The generous upload of 2.9.96 did not actually reach the moment it was written for. Only torrents with a registered reader were shown to the upload policy, and the first thing done with a new torrent — fetching the file's head and tail for the codec probe — reads through `createReadStream` without registering one. So for the whole of that wait, 8.36 s of the 11.46 s before playback in the measured session, the torrent looked unused and the upload stayed at the near-silent idle floor, during the exact seconds peers decide whether to serve us. A torrent in a hurry now counts whether or not anything is reading it. The selection is a named function of its own so it can be tested without a live swarm — the fault was in which torrents were considered, not in what was decided about them.
+
 ## 2.9.96
 
 - **New**: The proxy uploads generously at the two moments a viewer is provably waiting — when a torrent is added, and when the viewer seeks — for 25 s, which is two of BitTorrent's unchoke cycles. Peers serve those who serve them: each re-ranks its takers about every 10 s and opens a few slots to whoever uploaded most, plus one at random, so uploading a token 8-50 KB/s means being picked at random, one slot per cycle. Measured on a session where 96 peers were already connected within 2 s: 64 KB/s after 2 s, 1.6 MB/s after 4 s, 4.8 MB/s after 8 s — and the 16 MB the codec probe needs took **8.36 s of the 11.46 s** before playback could start. The existing reciprocity boost could not help, because it waits for the download to be all but dead (below 200 KB/s) with peers visibly choking us, and a ramp is neither: in that same session it first moved the limit 13.3 s after the torrent was added and reached the generous rate at 43.7 s, both after the wait they were meant to shorten. Seeding policy is otherwise unchanged — near-silence when nothing is being watched, a token upload while reading.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.9.96",
+  "version": "2.9.97",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

package/services/torrent-pool.js

@@ -115,6 +115,34 @@ const UPLOAD_HURRY_MS = 25_000;
  * @param {{ floor?: number, idleFloor?: number, boost?: number, starvingSpeed?: number, chokedThreshold?: number, now?: number }} [opts]
  * @returns {{ bytesPerSec: number, reason: string }}
  */
+/**
+ * The torrents the upload policy is allowed to see.
+ *
+ * A torrent with a reader qualifies for the obvious reason. A torrent in a
+ * HURRY qualifies even without one, and that case is the important one: the
+ * first thing done with a new torrent is fetching the file's head and tail for
+ * the codec probe, and that read goes straight to `createReadStream` without
+ * registering a reader. Judged by readers alone the torrent looks unused for
+ * the whole of that wait — 8.36 s of the 11.46 s before playback in the session
+ * measured 2026-08-04 — so the upload stayed at the near-silent idle floor
+ * during the exact seconds peers were deciding whether to serve us.
+ *
+ * @param {Iterable<{ hurryUntil?: number }>} torrents
+ * @param {Map<object, { size: number }>} usageByTorrent - fileIndex sets, keyed by torrent.
+ * @param {number} now
+ * @returns {object[]}
+ */
+export function torrentsForUploadPolicy(torrents, usageByTorrent, now) {
+  const chosen = [];
+  for (const torrent of torrents) {
+    const usage = usageByTorrent?.get?.(torrent);
+    if ((usage && usage.size > 0) || (torrent?.hurryUntil ?? 0) > now) {
+      chosen.push(torrent);
+    }
+  }
+  return chosen;
+}
+
 export function decideUploadLimit(activeTorrents, opts = {}) {
   const floor = opts.floor ?? UPLOAD_FLOOR_BYTES;
   const idleFloor = opts.idleFloor ?? UPLOAD_IDLE_FLOOR_BYTES;
@@ -465,10 +493,11 @@ export class TorrentPool {
     if (!this.client || this.client.destroyed || typeof this.client.throttleUpload !== "function") {
       return;
     }
-    const active = [...this.torrents.values()].filter((torrent) => {
-      const usage = this.fileUsageByTorrent.get(torrent);
-      return usage && usage.size > 0;
-    });
+    const active = torrentsForUploadPolicy(
+      this.torrents.values(),
+      this.fileUsageByTorrent,
+      Date.now()
+    );
     const { bytesPerSec, reason } = decideUploadLimit(active);
     if (bytesPerSec === this.#uploadLimit) {
       return;

package/test/upload-hurry.test.js

@@ -17,7 +17,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { decideUploadLimit } from "../services/torrent-pool.js";
+import { decideUploadLimit, torrentsForUploadPolicy } from "../services/torrent-pool.js";
 
 const NOW = 1_000_000;
 const healthy = (extra = {}) => ({
@@ -64,3 +64,33 @@ test("the reciprocity boost still works when no hurry is on", () => {
   assert.equal(decision.bytesPerSec, 512 * 1024);
   assert.match(decision.reason, /earn unchoke/);
 });
+
+test("a torrent with no reader still reaches the policy while it is in a hurry", () => {
+  // The moment that matters: a torrent has just been added and its head and
+  // tail are being fetched for the codec probe. That read goes straight to
+  // `createReadStream`, so no reader is registered — and the selection only
+  // ever kept torrents that had one, which is where the gap was.
+  const hurrying = { name: "film.mkv", hurryUntil: NOW + 20_000 };
+  const idle = { name: "other.mkv" };
+  const usage = new Map();
+
+  assert.deepEqual(
+    torrentsForUploadPolicy([hurrying, idle], usage, NOW),
+    [hurrying],
+    "a torrent with no reader yet was ignored"
+  );
+
+  assert.deepEqual(
+    torrentsForUploadPolicy([{ ...hurrying, hurryUntil: NOW - 1 }, idle], usage, NOW),
+    [],
+    "and stops counting once the rush is over"
+  );
+
+  const read = { name: "watched.mkv" };
+  usage.set(read, new Set([0]));
+  assert.deepEqual(
+    torrentsForUploadPolicy([read], usage, NOW),
+    [read],
+    "a torrent being read still counts, hurry or not"
+  );
+});