@torrent-tv/proxy 2.89.6 → 2.89.8

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/helpers/encode-run.js

@@ -8,9 +8,9 @@
  * product builds and injects only the one thing a test may not have, which is a
  * child process.
  *
- * The pid is deliberately absent unless a test asks for one. `pause` and
- * `resume` send signals by pid, and a made-up number is somebody else's process
- * on the machine running the tests.
+ * The fake has a pid, as a started process does: a run signals only a process
+ * that started. The number is never used to signal anything — every signal goes
+ * through the child object, and this one records it.
  */
 
 import { EncodeRun } from "../../services/encode/EncodeRun.js";
@@ -92,11 +92,10 @@ function say(channel, text) {
  * A child process that records what was done to it.
  *
  * @param {object} [options]
- * @param {number | null} [options.pid] - Only where a test genuinely exercises
- *   suspend or resume, and then it must be this process's own.
+ * @param {number | null} [options.pid] - Null for a process that did not start.
  * @returns {object}
  */
-export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
+export function fakeProcess({ pid = 4242, exitsWhenKilled = true } = {}) {
   /** @type {Map<string, (...args: unknown[]) => void>} */
   const listeners = new Map();
   const stdout = channel();
@@ -123,6 +122,10 @@ export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
     },
     kill(signal = "SIGTERM") {
       this.signals.push(signal);
+      // Suspending and continuing are not ends.
+      if (signal === "SIGSTOP" || signal === "SIGCONT") {
+        return true;
+      }
       this.killed = true;
       // A real process answers a signal by exiting, and it does so on a later
       // turn. A fake that never exits makes every disposal wait out the grace
@@ -144,6 +147,11 @@ export function fakeProcess({ pid = null, exitsWhenKilled = true } = {}) {
       for (const handler of listeners.get("exit") ?? []) {
         handler(code, signal);
       }
+      // A real child process emits `close` after `exit`, once its stdio has
+      // closed, and the run takes its ending from `close`.
+      for (const handler of listeners.get("close") ?? []) {
+        handler(code, signal);
+      }
     }
   };
 }

package/test/helpers/held-file.js

@@ -1,77 +1,77 @@
-/**
- * @file A torrent reduced to what the subtitle walk may know about one file.
- *
- * Built from the REAL two functions the torrent thread answers with
- * (`torrent/worker/held-bytes.js`), so a check that walks cues exercises both
- * sides of the seam rather than a stand-in for one of them: the bitfield
- * becoming a list of ranges, and a range read that never fetches.
- *
- * The file's container is the one a `ContainerOrchestrator` builds, over a
- * reader that FETCHES — the fake file's own stream, which serves any range —
- * because the head and the Cues table are read that way in the product.
- */
-
-import { heldRangesOf, readHeldBytes } from "../../services/torrent/worker/held-bytes.js";
-import { ContainerOrchestrator } from "../../services/media/ContainerOrchestrator.js";
-
-/**
- * Every byte of a range from the fake file's stream.
- *
- * @param {object} file
- * @param {number} start
- * @param {number} end
- * @returns {Promise<Buffer>}
- */
-async function readThroughStream(file, start, end) {
-  const chunks = [];
-  for await (const chunk of file.createReadStream({ start, end })) {
-    chunks.push(Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks);
-}
-
-/** One orchestrator for the checks that do not bring their own. */
-const sharedContainers = new ContainerOrchestrator();
-
-/**
- * @param {object} torrent - The fake a check builds: `pieceLength`, `bitfield`,
- *   `files[]` with `offset`, `length`, `name`, `createReadStream`.
- * @param {number} fileIndex
- * @param {string} sourceKey
- * @param {{ containers?: ContainerOrchestrator, readRange?: (start: number, end: number) => Promise<Buffer | null>, wantedSeconds?: () => number[], portionBytes?: number }} [options]
- * @returns {import("../../services/media/SubtitleCues.js").HeldFile}
- */
-export function heldFileOver(torrent, fileIndex, sourceKey, options = {}) {
-  const file = torrent?.files?.[fileIndex] ?? {};
-  const containers = options.containers ?? sharedContainers;
-  const readRange = options.readRange ?? ((start, end) => readThroughStream(file, start, end));
-  return {
-    sourceKey,
-    fileIndex,
-    name: String(file.name ?? ""),
-    length: Number(file.length) || 0,
-    portionBytes: options.portionBytes,
-    container: () =>
-      containers.containerFor({
-        sourceKey,
-        fileIndex,
-        readRange,
-        fileSize: Number(file.length) || 0,
-        label: String(file.name ?? ""),
-        portionBytes: options.portionBytes
-      }),
-    heldRanges: async () => heldRangesOf(torrent, fileIndex),
-    readHeld: (start, end) => readHeldBytes(torrent, fileIndex, start, end),
-    wantedSeconds: options.wantedSeconds
-  };
-}
-
-/**
- * Forget what the shared orchestrator built for a source.
- *
- * @param {string} sourceKey
- * @returns {void}
- */
-export function forgetContainers(sourceKey) {
-  sharedContainers.forget(sourceKey);
-}
+/**
+ * @file A torrent reduced to what the subtitle walk may know about one file.
+ *
+ * Built from the REAL two functions the torrent thread answers with
+ * (`torrent/worker/held-bytes.js`), so a check that walks cues exercises both
+ * sides of the seam rather than a stand-in for one of them: the bitfield
+ * becoming a list of ranges, and a range read that never fetches.
+ *
+ * The file's container is the one a `ContainerOrchestrator` builds, over a
+ * reader that FETCHES — the fake file's own stream, which serves any range —
+ * because the head and the Cues table are read that way in the product.
+ */
+
+import { heldRangesOf, readHeldBytes } from "../../services/torrent/worker/held-bytes.js";
+import { ContainerOrchestrator } from "../../services/media/ContainerOrchestrator.js";
+
+/**
+ * Every byte of a range from the fake file's stream.
+ *
+ * @param {object} file
+ * @param {number} start
+ * @param {number} end
+ * @returns {Promise<Buffer>}
+ */
+async function readThroughStream(file, start, end) {
+  const chunks = [];
+  for await (const chunk of file.createReadStream({ start, end })) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+
+/** One orchestrator for the checks that do not bring their own. */
+const sharedContainers = new ContainerOrchestrator();
+
+/**
+ * @param {object} torrent - The fake a check builds: `pieceLength`, `bitfield`,
+ *   `files[]` with `offset`, `length`, `name`, `createReadStream`.
+ * @param {number} fileIndex
+ * @param {string} sourceKey
+ * @param {{ containers?: ContainerOrchestrator, readRange?: (start: number, end: number) => Promise<Buffer | null>, wantedSeconds?: () => number[], portionBytes?: number }} [options]
+ * @returns {import("../../services/media/SubtitleCues.js").HeldFile}
+ */
+export function heldFileOver(torrent, fileIndex, sourceKey, options = {}) {
+  const file = torrent?.files?.[fileIndex] ?? {};
+  const containers = options.containers ?? sharedContainers;
+  const readRange = options.readRange ?? ((start, end) => readThroughStream(file, start, end));
+  return {
+    sourceKey,
+    fileIndex,
+    name: String(file.name ?? ""),
+    length: Number(file.length) || 0,
+    portionBytes: options.portionBytes,
+    container: () =>
+      containers.containerFor({
+        sourceKey,
+        fileIndex,
+        readRange,
+        fileSize: Number(file.length) || 0,
+        label: String(file.name ?? ""),
+        portionBytes: options.portionBytes
+      }),
+    heldRanges: async () => heldRangesOf(torrent, fileIndex),
+    readHeld: (start, end) => readHeldBytes(torrent, fileIndex, start, end),
+    wantedSeconds: options.wantedSeconds
+  };
+}
+
+/**
+ * Forget what the shared orchestrator built for a source.
+ *
+ * @param {string} sourceKey
+ * @returns {void}
+ */
+export function forgetContainers(sourceKey) {
+  sharedContainers.forget(sourceKey);
+}

package/test/helpers/manager.js

@@ -1,62 +1,62 @@
-/**
- * @file A session manager for a test, with a store of its own.
- *
- * ONE MANAGER, ONE ROOT. In production that is true by construction: one
- * process holds one manager, and the store's root is a fixed path so that a
- * restart can find what the process before it finished (`SegmentStore.sweep`).
- * Under `node --test` it is false — the runner starts one PROCESS PER FILE and
- * runs them in parallel, so every manager built without a store of its own
- * shared the one default root with every other file running at that moment.
- *
- * What that cost, measured 2026-09-14: `disposeAll` removes the store's whole
- * root, and four files call it between them 40 times. Running the twenty-one
- * files that build a manager gave 2, 3 and 4 failures on consecutive runs and
- * zero with `--test-concurrency=1`; the victim was always
- * `segment-serve-wiring.test.js`, reporting a segment missing that it had
- * written itself a moment earlier, because another process had deleted the
- * directory under it. `npm test` is `node --test`, so this was the project's
- * own test command, and it is why a red result had become something to read
- * past rather than to act on.
- *
- * A test that fails by luck is worse than one that does not exist: it costs a
- * run every time, and it trains everyone to ignore red.
- */
-
-import { mkdtempSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { wireOutputs } from "../../services/server/wire-outputs.js";
-import { SegmentStore } from "../../services/storage/segment-store/SegmentStore.js";
-
-/**
- * A manager whose produced segments live where nothing else can reach them.
- *
- * @param {object} [options] - Passed to the manager, over the defaults below.
- *   A `segmentStore` given here wins, for a test that wants to watch the store
- *   itself.
- * @returns {{ manager: object, store: SegmentStore, root: string,
- *   cleanup: () => void }} `cleanup` removes the root; call it from `t.after`.
- */
-export function managerWithOwnStore(options = {}) {
-  const root = mkdtempSync(path.join(os.tmpdir(), "ttv-store-"));
-  const store = options.segmentStore ?? new SegmentStore({ root });
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090,
-    // What this host has measured about itself is kept beside the store, not
-    // beside the installed proxy: read from there, one run's figures became
-    // the next run's premises, and a check passed only on a machine that had
-    // run the suite before.
-    stateDir: root,
-    ...options,
-    segmentStore: store
-  });
-  return {
-    manager,
-    store,
-    root,
-    cleanup: () => rmSync(root, { recursive: true, force: true })
-  };
-}
+/**
+ * @file A session manager for a test, with a store of its own.
+ *
+ * ONE MANAGER, ONE ROOT. In production that is true by construction: one
+ * process holds one manager, and the store's root is a fixed path so that a
+ * restart can find what the process before it finished (`SegmentStore.sweep`).
+ * Under `node --test` it is false — the runner starts one PROCESS PER FILE and
+ * runs them in parallel, so every manager built without a store of its own
+ * shared the one default root with every other file running at that moment.
+ *
+ * What that cost, measured 2026-09-14: `disposeAll` removes the store's whole
+ * root, and four files call it between them 40 times. Running the twenty-one
+ * files that build a manager gave 2, 3 and 4 failures on consecutive runs and
+ * zero with `--test-concurrency=1`; the victim was always
+ * `segment-serve-wiring.test.js`, reporting a segment missing that it had
+ * written itself a moment earlier, because another process had deleted the
+ * directory under it. `npm test` is `node --test`, so this was the project's
+ * own test command, and it is why a red result had become something to read
+ * past rather than to act on.
+ *
+ * A test that fails by luck is worse than one that does not exist: it costs a
+ * run every time, and it trains everyone to ignore red.
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { wireOutputs } from "../../services/server/wire-outputs.js";
+import { SegmentStore } from "../../services/storage/segment-store/SegmentStore.js";
+
+/**
+ * A manager whose produced segments live where nothing else can reach them.
+ *
+ * @param {object} [options] - Passed to the manager, over the defaults below.
+ *   A `segmentStore` given here wins, for a test that wants to watch the store
+ *   itself.
+ * @returns {{ manager: object, store: SegmentStore, root: string,
+ *   cleanup: () => void }} `cleanup` removes the root; call it from `t.after`.
+ */
+export function managerWithOwnStore(options = {}) {
+  const root = mkdtempSync(path.join(os.tmpdir(), "ttv-store-"));
+  const store = options.segmentStore ?? new SegmentStore({ root });
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090,
+    // What this host has measured about itself is kept beside the store, not
+    // beside the installed proxy: read from there, one run's figures became
+    // the next run's premises, and a check passed only on a machine that had
+    // run the suite before.
+    stateDir: root,
+    ...options,
+    segmentStore: store
+  });
+  return {
+    manager,
+    store,
+    root,
+    cleanup: () => rmSync(root, { recursive: true, force: true })
+  };
+}