@torrent-tv/proxy 2.89.7 → 2.89.9

package/test/held-read-ownership.test.js

@@ -1,77 +1,77 @@
-/**
- * @file A read of what is downloaded asks for nothing, and hands the other
- * thread memory that is its own.
- *
- * Until 2026-10-01 the read opened the torrent's own file stream on bytes that
- * had not arrived; that stream selects pieces itself, outside the demand
- * register, and waited up to thirty seconds — 36 such reads at a torrent's open
- * competed with the file being watched. And the bytes it returns are now handed
- * to the main thread instead of copied, which is safe only for a buffer that is
- * the whole of its own memory. Fakes only.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Readable } from "node:stream";
-import { MessageChannel } from "node:worker_threads";
-import { createHash } from "node:crypto";
-
-import { ownsItsMemory, readHeldBytes } from "../services/torrent/worker/held-bytes.js";
-
-const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
-
-/** A torrent of one file whose stream serves views of one shared store buffer. */
-function torrentOver(store, held) {
-  const streams = [];
-  const file = {
-    name: "film.mkv",
-    length: store.length,
-    offset: 0,
-    createReadStream({ start, end }) {
-      streams.push({ start, end });
-      return Readable.from([store.subarray(start, end + 1)]);
-    }
-  };
-  return {
-    streams,
-    torrent: { pieceLength: 16, bitfield: { get: (index) => held(index) }, files: [file] }
-  };
-}
-
-test("a range not wholly downloaded is answered at once with nothing, and no stream is opened", async () => {
-  const store = Buffer.alloc(64, 1);
-  const { torrent, streams } = torrentOver(store, (index) => index !== 2);
-  assert.equal(await readHeldBytes(torrent, 0, 0, 63), null);
-  assert.equal(streams.length, 0, "nothing was asked of the torrent");
-  assert.notEqual(await readHeldBytes(torrent, 0, 0, 31), null, "a range that is here is read");
-});
-
-test("what a held read returns owns its memory; a pool slice and shared memory do not", async () => {
-  const store = Buffer.from(Array.from({ length: 64 }, (_, index) => index));
-  const { torrent } = torrentOver(store, () => true);
-  const bytes = await readHeldBytes(torrent, 0, 3, 40);
-  assert.equal(ownsItsMemory(bytes), true);
-  assert.equal(ownsItsMemory(Buffer.from("small")), false, "a slice of Node's pool");
-  assert.equal(ownsItsMemory(new Uint8Array(new SharedArrayBuffer(8))), false, "shared memory");
-  assert.equal(ownsItsMemory(store.subarray(4, 8)), false, "a view into another buffer");
-});
-
-test("handing a read's bytes to another thread leaves the store and an overlapping read as they were", async () => {
-  const store = Buffer.from(Array.from({ length: 256 }, (_, index) => index % 251));
-  const before = digest(store);
-  const { torrent } = torrentOver(store, () => true);
-  const [first, second] = await Promise.all([readHeldBytes(torrent, 0, 10, 200), readHeldBytes(torrent, 0, 50, 120)]);
-  const secondBefore = digest(second);
-
-  const { port1, port2 } = new MessageChannel();
-  const received = new Promise((resolve) => port2.once("message", resolve));
-  port1.postMessage({ bytes: first }, [first.buffer]);
-  const message = await received;
-  port1.close();
-  port2.close();
-
-  assert.equal(first.byteLength, 0, "the sender no longer holds the memory it handed over");
-  assert.deepEqual(Buffer.from(message.bytes), store.subarray(10, 201), "the receiver has every byte");
-  assert.equal(digest(store), before, "the store's own bytes are untouched");
-  assert.equal(digest(second), secondBefore, "the overlapping read is untouched");
-});
+/**
+ * @file A read of what is downloaded asks for nothing, and hands the other
+ * thread memory that is its own.
+ *
+ * Until 2026-10-01 the read opened the torrent's own file stream on bytes that
+ * had not arrived; that stream selects pieces itself, outside the demand
+ * register, and waited up to thirty seconds — 36 such reads at a torrent's open
+ * competed with the file being watched. And the bytes it returns are now handed
+ * to the main thread instead of copied, which is safe only for a buffer that is
+ * the whole of its own memory. Fakes only.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Readable } from "node:stream";
+import { MessageChannel } from "node:worker_threads";
+import { createHash } from "node:crypto";
+
+import { ownsItsMemory, readHeldBytes } from "../services/torrent/worker/held-bytes.js";
+
+const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+
+/** A torrent of one file whose stream serves views of one shared store buffer. */
+function torrentOver(store, held) {
+  const streams = [];
+  const file = {
+    name: "film.mkv",
+    length: store.length,
+    offset: 0,
+    createReadStream({ start, end }) {
+      streams.push({ start, end });
+      return Readable.from([store.subarray(start, end + 1)]);
+    }
+  };
+  return {
+    streams,
+    torrent: { pieceLength: 16, bitfield: { get: (index) => held(index) }, files: [file] }
+  };
+}
+
+test("a range not wholly downloaded is answered at once with nothing, and no stream is opened", async () => {
+  const store = Buffer.alloc(64, 1);
+  const { torrent, streams } = torrentOver(store, (index) => index !== 2);
+  assert.equal(await readHeldBytes(torrent, 0, 0, 63), null);
+  assert.equal(streams.length, 0, "nothing was asked of the torrent");
+  assert.notEqual(await readHeldBytes(torrent, 0, 0, 31), null, "a range that is here is read");
+});
+
+test("what a held read returns owns its memory; a pool slice and shared memory do not", async () => {
+  const store = Buffer.from(Array.from({ length: 64 }, (_, index) => index));
+  const { torrent } = torrentOver(store, () => true);
+  const bytes = await readHeldBytes(torrent, 0, 3, 40);
+  assert.equal(ownsItsMemory(bytes), true);
+  assert.equal(ownsItsMemory(Buffer.from("small")), false, "a slice of Node's pool");
+  assert.equal(ownsItsMemory(new Uint8Array(new SharedArrayBuffer(8))), false, "shared memory");
+  assert.equal(ownsItsMemory(store.subarray(4, 8)), false, "a view into another buffer");
+});
+
+test("handing a read's bytes to another thread leaves the store and an overlapping read as they were", async () => {
+  const store = Buffer.from(Array.from({ length: 256 }, (_, index) => index % 251));
+  const before = digest(store);
+  const { torrent } = torrentOver(store, () => true);
+  const [first, second] = await Promise.all([readHeldBytes(torrent, 0, 10, 200), readHeldBytes(torrent, 0, 50, 120)]);
+  const secondBefore = digest(second);
+
+  const { port1, port2 } = new MessageChannel();
+  const received = new Promise((resolve) => port2.once("message", resolve));
+  port1.postMessage({ bytes: first }, [first.buffer]);
+  const message = await received;
+  port1.close();
+  port2.close();
+
+  assert.equal(first.byteLength, 0, "the sender no longer holds the memory it handed over");
+  assert.deepEqual(Buffer.from(message.bytes), store.subarray(10, 201), "the receiver has every byte");
+  assert.equal(digest(store), before, "the store's own bytes are untouched");
+  assert.equal(digest(second), secondBefore, "the overlapping read is untouched");
+});

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

@@ -1,157 +1,157 @@
-/**
- * @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);
-});
+/**
+ * @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);
+});