@torrent-tv/proxy 2.89.17 → 2.89.19

package/test/wedge-certainty.test.js

@@ -1,131 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-
-import { wedgeIsCertain } from "../services/transport/data-channel-handler.js";
-import { PROBE_INTERVAL_MS } from "../services/transport/delivery-probe.js";
-
-const MEGABYTE = 1024 * 1024;
-
-test("a queue draining at the rate this link was measured at is not a wedge", () => {
-  // 8 MB at 16 MB/s is half a second of draining. Half a second in is normal.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 200
-  });
-  assert.equal(verdict.certain, false);
-});
-
-test("the counter standing still past the queue's own drain time is a wedge", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 4000
-  });
-  assert.equal(verdict.certain, true);
-  assert.equal(verdict.needMs, 500);
-});
-
-test("a big queue on a slow link is given the time it genuinely needs", () => {
-  // 67 MB at 1 MB/s is 67 seconds of honest draining — the field's own numbers
-  // for the wedged channel, at a rate a thin link could really be running at.
-  const patient = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: MEGABYTE,
-    flatForMs: 30_000
-  });
-  assert.equal(patient.certain, false);
-  const later = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: MEGABYTE,
-    flatForMs: 70_000
-  });
-  assert.equal(later.certain, true);
-});
-
-test("the same queue on the link the field actually had is called quickly", () => {
-  // 67 MB at 18 MB/s is under four seconds. The field episode stood still for
-  // 3217 s; the previous rule waited a flat 30 s before recording anything.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 67 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 5000
-  });
-  assert.equal(verdict.certain, true);
-  assert.ok(verdict.needMs < 30_000);
-});
-
-test("a tiny queue still waits for one round of probes", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 512,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: PROBE_INTERVAL_MS - 1
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("nothing queued is still a wedge when the counter has been flat long enough — the channel queue was 0 on the real wedge while usrsctp held 399 MB", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 0,
-    bytesPerSecond: 16 * MEGABYTE,
-    flatForMs: 600_000
-  });
-  assert.equal(verdict.certain, true);
-  assert.equal(verdict.needMs, PROBE_INTERVAL_MS);
-});
-
-test("with no rate measured the answer is that nothing can be said", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 0,
-    flatForMs: 600_000
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, null);
-});
-
-test("a pause no longer than this link's own longest healthy pause is not a wedge", () => {
-  // A retransmission timeout stops the accepted-byte counter dead: a full send
-  // buffer accepts nothing. If this connection has already paused 3 s while
-  // healthy, a 3 s pause says nothing.
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 2500,
-    longestHealthyFlatMs: 3000
-  });
-  assert.equal(verdict.certain, false);
-  assert.equal(verdict.needMs, 3000);
-});
-
-test("a pause longer than any this link has shown is a wedge", () => {
-  const verdict = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 3500,
-    longestHealthyFlatMs: 3000
-  });
-  assert.equal(verdict.certain, true);
-});
-
-test("the quiet-probe rate cannot be what the queue is divided by", () => {
-  // With the browser's buffer full, the only traffic is the probe: three
-  // channels, a few dozen bytes, twice a second. Dividing 8 MB by that gives
-  // six hours, and the wedge would never be called. The BEST rate seen is what
-  // the watcher keeps, so this case must not arise — pinned here as the
-  // arithmetic that made it matter.
-  const wrong = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 360,
-    flatForMs: 60_000
-  });
-  assert.equal(wrong.certain, false);
-  assert.ok(wrong.needMs > 6 * 60 * 60 * 1000 - 1);
-  const right = wedgeIsCertain({
-    queuedBytes: 8 * MEGABYTE,
-    bytesPerSecond: 18 * MEGABYTE,
-    flatForMs: 60_000
-  });
-  assert.equal(right.certain, true);
-});

package/test/whole-file-held-read.test.js

@@ -1,30 +0,0 @@
-/**
- * @file A file kept whole is read from the disk by the subtitle walk.
- *
- * Once a file is kept whole its pieces leave the torrent's store while the
- * bitfield still says they are held, and a read through the torrent waited on
- * a store that no longer had them (field 2026-10-01). The reading itself is
- * checked here over a temporary file; the client that uses it starts the
- * torrent thread and is not built.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-
-import { readWholeFile } from "../services/torrent/worker/client.js";
-
-test("a range of a whole file is read from the disk, and a range past it is not here", async (t) => {
-  const dir = await mkdtemp(path.join(os.tmpdir(), "ttv-whole-"));
-  t.after(() => rm(dir, { recursive: true, force: true }));
-  const file = path.join(dir, "film.mkv");
-  await writeFile(file, Buffer.from("0123456789"));
-  const whole = { path: file, length: 10, name: "film.mkv" };
-
-  assert.equal((await readWholeFile(whole, 2, 5)).toString(), "2345");
-  assert.equal((await readWholeFile(whole, 8, 20)).toString(), "89", "clamped to the file");
-  assert.equal(await readWholeFile(whole, 12, 20), null);
-  await assert.rejects(readWholeFile({ ...whole, path: path.join(dir, "gone.mkv") }, 0, 1), { code: "ENOENT" });
-});

package/test/withdraw-piece-claim.test.js

@@ -1,212 +0,0 @@
-/**
- * @file One owner of the fact "this proxy has piece N".
- *
- * The store holds the bytes, so it owns the fact. The library keeps a second
- * copy of it in its completion bitfield, and until 2026-09-12 nothing
- * reconciled them: the disk tier dropped a piece once every reader was past it
- * — correctly, that is what bounds the spill — and the bitfield went on saying
- * the piece was verified. A read then concluded the piece was had, asked for it,
- * was told it was absent, and failed; nothing fetched it again either, because
- * the library does not download what it believes it owns. Field: a film played
- * 80 seconds and then answered `Piece 0 is verified but absent from the store`
- * for 92 minutes.
- *
- * Pinned here: the announcement and its one rule — said when the piece has gone
- * from EVERYWHERE, never when one tier alone lost it — and the withdrawal.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import os from "node:os";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { SharedPieceStore } from "../services/storage/piece-store/shared-piece-store.js";
-import { withdrawClaim } from "../services/torrent/download/withdraw-claim.js";
-
-const PIECE = 1024;
-
-/**
- * A store of four pieces with room for one, so every admission spills the last,
- * plus the announcements it made.
- */
-async function storeWithGone(extras = {}) {
-  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "withdraw-test-"));
-  /** @type {number[]} */
-  const gone = [];
-  const store = new SharedPieceStore(PIECE, {
-    length: 4 * PIECE,
-    memoryBytes: PIECE,
-    path: directory,
-    name: "test",
-    files: [{ offset: 0, length: 4 * PIECE, name: "file.bin" }],
-    onPieceGone: ({ index }) => gone.push(index),
-    ...extras
-  });
-  const put = (index) => new Promise((resolve, reject) => {
-    store.put(index, Buffer.alloc(PIECE, index + 1), (error) => (error ? reject(error) : resolve()));
-  });
-  const clean = async () => {
-    store.destroy(() => undefined);
-    await fs.rm(directory, { recursive: true, force: true, maxRetries: 10, retryDelay: 20 });
-  };
-  return { store, gone, put, clean };
-}
-
-/**
- * Wait for the CONDITION, with a deadline only as a backstop. A fixed pause
- * here would measure the machine rather than the store.
- *
- * @param {() => boolean} ready
- * @param {string} what
- */
-async function until(ready, what) {
-  const deadline = Date.now() + 5_000;
-  while (!ready()) {
-    if (Date.now() > deadline) {
-      throw new Error(`timed out waiting for ${what}`);
-    }
-    await new Promise((resolve) => setImmediate(resolve));
-  }
-}
-
-test("a piece left behind every reader is dropped AND the claim withdrawn", async () => {
-  const { store, gone, put, clean } = await storeWithGone();
-  try {
-    await put(0);
-    await put(1);
-    await put(2);
-    // WHERE THE READERS STAND, which is the whole trigger: the encoder ran
-    // ahead, so pieces 0-1 are behind every one of them. This is the production
-    // path — `reviseSpillCeiling` asks `forgetBehind(readHeads)` — and it is
-    // what dropped 565 pieces in the field.
-    store.protectRange("reader", 2, 3, 0);
-    const revision = store.reviseSpillCeiling(null);
-
-    assert.ok(revision.behind >= 1, `something should have been dropped, got ${revision.behind}`);
-    assert.ok(gone.includes(0), `piece 0 has gone and should say so, got ${JSON.stringify(gone)}`);
-    assert.ok(
-      gone.every((index) => index < 2),
-      `nothing a reader still wants may be announced, got ${JSON.stringify(gone)}`
-    );
-  } finally {
-    await clean();
-  }
-});
-
-test("a piece dropped as a duplicate of a file held whole is NOT announced", async () => {
-  const { store, gone, put, clean } = await storeWithGone({
-    // Every piece can be had from the assembled file, which is exactly why the
-    // spilled copy is being dropped. Nothing has been lost, so nothing is said.
-    isPieceElsewhere: () => true
-  });
-  try {
-    await put(0);
-    await put(1);
-    await put(2);
-    // The spill is what puts a piece on disk, and it finishes on its own time;
-    // dropping duplicates deliberately leaves a piece whose spill is still in
-    // flight alone, so the precondition is waited for rather than assumed.
-    await until(() => store.stats().spilled >= 1, "a piece to reach the disk");
-    const dropped = store.dropDuplicatesHeldElsewhere();
-    assert.ok(dropped >= 1, "the spilled duplicate should have been dropped");
-    assert.deepEqual(gone, [], "a piece still readable from a whole file has not gone");
-  } finally {
-    await clean();
-  }
-});
-
-test("a closing store announces nothing, because its torrent is going too", async () => {
-  const { store, gone, put, clean } = await storeWithGone();
-  try {
-    await put(0);
-    await put(1);
-    store.protectRange("reader", 2, 3, 0);
-    store.close(() => undefined);
-    store.reviseSpillCeiling(null);
-    assert.deepEqual(gone, [], "a claim withdrawn against a dying torrent reaches nothing useful");
-  } finally {
-    await clean();
-  }
-});
-
-test("the withdrawal is counted in the store's own figures", async () => {
-  const { store, put, clean } = await storeWithGone();
-  try {
-    await put(0);
-    await put(1);
-    await put(2);
-    store.protectRange("reader", 2, 3, 0);
-    store.reviseSpillCeiling(null);
-    assert.ok(
-      store.stats().withdrawn >= 1,
-      "the figure that makes the eviction's bargain checkable must move"
-    );
-  } finally {
-    await clean();
-  }
-});
-
-test("a piece the library thinks it has is withdrawn", () => {
-  const asked = [];
-  const torrent = {
-    name: "film.mkv",
-    destroyed: false,
-    bitfield: { get: () => true },
-    _markUnverified: (index) => asked.push(index)
-  };
-  assert.equal(withdrawClaim({ index: 3, files: [{ _torrent: torrent }] }), "withdrawn");
-  assert.deepEqual(asked, [3]);
-});
-
-test("a piece the library already knows is missing is left alone", () => {
-  let touched = 0;
-  const torrent = {
-    destroyed: false,
-    bitfield: { get: () => false },
-    _markUnverified: () => { touched += 1; }
-  };
-  assert.equal(
-    withdrawClaim({ index: 7, torrent }),
-    "nothing-to-withdraw",
-    "re-creating a piece the library is already fetching would discard its blocks in flight"
-  );
-  assert.equal(touched, 0);
-});
-
-test("a destroyed torrent is left alone", () => {
-  let touched = 0;
-  const torrent = {
-    destroyed: true,
-    bitfield: { get: () => true },
-    _markUnverified: () => { touched += 1; }
-  };
-  assert.equal(withdrawClaim({ index: 1, torrent }), "no-torrent");
-  assert.equal(touched, 0);
-});
-
-test("a library that refuses says so instead of failing the eviction", () => {
-  const said = [];
-  const torrent = {
-    name: "film.mkv",
-    destroyed: false,
-    bitfield: { get: () => true },
-    _markUnverified: () => { throw new Error("no such method any more"); }
-  };
-  assert.equal(withdrawClaim({ index: 2, torrent, warn: (line) => said.push(line) }), "refused");
-  assert.equal(said.length, 1);
-  assert.match(said[0], /piece 2 of film\.mkv/);
-});
-
-test("a store with nobody listening evicts exactly as it did before", async () => {
-  const { store, put, clean } = await storeWithGone({ onPieceGone: undefined });
-  try {
-    await put(0);
-    await put(1);
-    await put(2);
-    store.protectRange("reader", 2, 3, 0);
-    const revision = store.reviseSpillCeiling(null);
-    assert.ok(revision.behind >= 1, "the eviction does not depend on anybody listening");
-  } finally {
-    await clean();
-  }
-});

package/test/worker-channel.test.js

@@ -1,158 +0,0 @@
-/**
- * @file The worker transport's memory contract.
- *
- * These cover the defect that broke playback in 2.9.71-2.9.73: the worker
- * handed the main thread ownership of memory it did not own. WebTorrent's piece
- * cache keeps the buffer it returns and slices it again on the next read, so
- * transferring it detached the cache's own memory and every later read failed
- * with "Cannot perform %TypedArray%.prototype.slice on a detached ArrayBuffer".
- *
- * The field could not tell us this, because the error never reached anyone: the
- * worker sent READ_END from its `finally` before the error was posted, and the
- * main thread had no handler for a read error at all. So a failed read looked
- * exactly like an empty file.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { MessageChannel } from "node:worker_threads";
-import { createSendStream, createReceiveStream, createCaller } from "../services/torrent/worker/channel.js";
-
-/**
- * A buffer standing in for one owned by WebTorrent's piece cache: allocated
- * outside Node's shared pool, covering its whole region, and still referenced
- * by its owner after we hand it on.
- *
- * @param {number} size
- * @param {number} fill
- * @returns {Buffer}
- */
-function foreignPiece(size, fill) {
-  const piece = Buffer.allocUnsafeSlow(size);
-  piece.fill(fill);
-  return piece;
-}
-
-test("sending a chunk leaves the source buffer usable by its owner", async () => {
-  const { port1, port2 } = new MessageChannel();
-  try {
-    const sender = createSendStream({ port: port1, requestId: 1 });
-    const piece = foreignPiece(1024 * 1024, 7);
-
-    await sender.send(piece);
-
-    // The owner reads its own buffer again, exactly as the piece cache does on
-    // the next request for the same piece.
-    assert.equal(piece.length, 1024 * 1024, "buffer was detached by the send");
-    assert.equal(piece[0], 7);
-    assert.equal(piece.subarray(0, 16).length, 16, "slicing the source failed");
-  } finally {
-    port1.close();
-    port2.close();
-  }
-});
-
-test("a second read of the same piece still returns its bytes", async () => {
-  const { port1, port2 } = new MessageChannel();
-  try {
-    const piece = foreignPiece(512 * 1024, 3);
-
-    for (const requestId of [1, 2]) {
-      const sender = createSendStream({ port: port1, requestId });
-      await sender.send(piece);
-      sender.end();
-    }
-
-    assert.equal(piece[0], 3, "the piece did not survive being sent twice");
-  } finally {
-    port1.close();
-    port2.close();
-  }
-});
-
-test("chunks arrive with their contents intact", async () => {
-  const { port1, port2 } = new MessageChannel();
-  try {
-    const received = [];
-    // Waited on rather than slept through. This test used to sleep 50 ms and
-    // then assert, so it failed whenever the run was busy — recorded as flaky in
-    // roadmap items 53 and 54, and it failed again on 2026-09-02 for a reason
-    // that shows exactly how little a chosen interval is worth: the worker had
-    // gained one more module to load, and 50 ms stopped being enough.
-    let arrived;
-    const firstChunk = new Promise((resolve) => { arrived = resolve; });
-    port2.on("message", (message) => {
-      if (message?.type === "chunk") {
-        received.push(Buffer.from(message.bytes));
-        arrived();
-      }
-    });
-
-    const sender = createSendStream({ port: port1, requestId: 1 });
-    const piece = foreignPiece(256 * 1024, 42);
-    await sender.send(piece);
-    sender.end();
-
-    await firstChunk;
-    assert.equal(received.length, 1);
-    assert.equal(received[0].length, 256 * 1024);
-    assert.equal(received[0][0], 42);
-    assert.equal(received[0][received[0].length - 1], 42);
-  } finally {
-    port1.close();
-    port2.close();
-  }
-});
-
-test("reads and commands never share a request id", () => {
-  const { port1, port2 } = new MessageChannel();
-  try {
-    const commandIds = [];
-    port2.on("message", (message) => commandIds.push(message.id));
-
-    const caller = createCaller(port1);
-    const readIds = [];
-
-    // Interleaved exactly as the real client does it: commands through `call`,
-    // reads taking an id directly, both over the same channel.
-    for (let round = 0; round < 50; round += 1) {
-      void caller.call("noop", {});
-      readIds.push(caller.nextId());
-    }
-
-    // A repeat between the two sequences is the collision that let a read's
-    // reply resolve a command — with its result, silently.
-    const everyId = [...commandIds, ...readIds];
-    assert.equal(
-      new Set(everyId).size,
-      everyId.length,
-      "an id was handed out to both a command and a read"
-    );
-  } finally {
-    port1.close();
-    port2.close();
-  }
-});
-
-test("a failed read surfaces on the reader instead of ending quietly", async () => {
-  const { port1, port2 } = new MessageChannel();
-  try {
-    const receive = createReceiveStream({
-      port: port1,
-      requestId: 1,
-      onCancel: () => undefined
-    });
-
-    receive.fail(new Error("read failed in the worker"));
-
-    const reader = receive.stream.getReader();
-    await assert.rejects(
-      () => reader.read(),
-      /read failed in the worker/,
-      "the reader saw a clean end instead of the failure"
-    );
-  } finally {
-    port1.close();
-    port2.close();
-  }
-});