@torrent-tv/proxy 2.87.7 → 2.87.8

package/test/cuts-follow-published-grid.test.js

@@ -1,109 +1,109 @@
-/**
- * @file A run cuts where the player was told the cuts are.
- *
- * There are two boundary tables. The live one is corrected as produced segments
- * reveal where the file's cuts truly are; the published one is the snapshot the
- * playlist text was written from, and a player places every fragment by that
- * text and nothing else. The cut list handed to ffmpeg used to come from the
- * live table, so every correction moved the run away from the timeline the
- * player is reading.
- *
- * Field 2026-08-20, `Minions.and.Monsters.1080p.mkv`: the picture's segments
- * arrived a uniform 2.002 s before the times its playlist named — 119 of 125 of
- * them — against the 0.5 s hls.js bridges. A fragment that does not land is
- * fetched again, and on 2026-08-17 two of them were fetched 1908 times each.
- */
-
-import assert from "node:assert/strict";
-import { computeCutGrid } from "../services/encode/output/cut-grid.js";
-import { Timeline } from "../services/encode/output/Timeline.js";
-import test from "node:test";
-
-import { wireOutputs } from "../services/server/wire-outputs.js";
-import { segmentCutTimesFrom } from "../services/encode/run-command.js";
-
-/** What the playlist in the player's hands says. */
-const PUBLISHED = [0, 4.004, 8.008, 12.012, 16.016, 20.02];
-/** The same grid after produced segments moved two of its cuts. */
-const CORRECTED = [0, 4.004, 6.006, 12.012, 14.014, 20.02];
-
-/**
- * A session that has published one grid and since corrected another.
- *
- * @returns {{ manager: object, session: object }}
- */
-function sessionWithDriftedGrid() {
-  const manager = wireOutputs({
-    enabled: true,
-    ffmpegBin: "ffmpeg",
-    localBindHost: "127.0.0.1",
-    localPort: 9090
-  });
-  const session = {
-    id: "picture",
-    timeline: new Timeline({ boundaries: [...CORRECTED], published: [...PUBLISHED], cutGrid: "uniform" })
-  };
-  return { manager, session };
-}
-
-test("the cut list is the one the playlist was written from", () => {
-  const { manager, session } = sessionWithDriftedGrid();
-  const grid = manager.outputTimes.publishedGridFor(session);
-  assert.deepEqual(grid, PUBLISHED);
-  // Interior cuts of a run starting at #1, rebased on the run's own start
-  // (4.004 s), and stopping before the last entry, which is the file's end.
-  assert.deepEqual(
-    segmentCutTimesFrom(grid, 1).map((time) => Number(time.toFixed(3))),
-    [4.004, 8.008, 12.012]
-  );
-});
-
-test("a corrected grid does not move the cuts of a session already being read", () => {
-  const { manager, session } = sessionWithDriftedGrid();
-  const fromCorrected = segmentCutTimesFrom(session.timeline.boundaries, 1);
-  const fromPublished = segmentCutTimesFrom(manager.outputTimes.publishedGridFor(session), 1);
-  assert.notDeepEqual(fromCorrected, fromPublished);
-  // The gap the field measured: the corrected table would have cut #2 two
-  // seconds early, which is four times what a player bridges.
-  assert.equal(Number((fromPublished[0] - fromCorrected[0]).toFixed(3)), 2.002);
-});
-
-test("a session that published no grid falls back to the live one", () => {
-  const { manager } = sessionWithDriftedGrid();
-  const session = { id: "no-playlist", timeline: new Timeline({ boundaries: [...CORRECTED], published: [], cutGrid: "uniform" }) };
-  assert.deepEqual(manager.outputTimes.publishedGridFor(session), CORRECTED);
-});
-
-test("no segment is left shorter than a segment at the end of the film", () => {
-  // The field case of 2026-09-11, to the millisecond: a 54-minute film whose
-  // last keyframe sits 160 ms before the end. Taking it as a cut leaves a
-  // segment of 0.16 s — one the sound has no data in at all, which is how one
-  // output came to have 542 segments and the other 541.
-  const total = 3246.12;
-  const keyframes = [];
-  for (let at = 0; at < total - 1; at += 2) {
-    keyframes.push(Number(at.toFixed(3)));
-  }
-  keyframes.push(3245.96);
-
-  const grid = computeCutGrid({
-    useKeyframeGrid: true,
-    durationSeconds: total,
-    segDur: 6,
-    keyframeTimes: keyframes,
-    startTime: 0
-  });
-
-  const last = grid.boundaries[grid.boundaries.length - 1];
-  const before = grid.boundaries[grid.boundaries.length - 2];
-  assert.equal(last, total, "the film still ends where it ends");
-  assert.ok(
-    last - before >= 6,
-    `the last segment is ${(last - before).toFixed(3)}s, shorter than the 6s every other cut is held to`
-  );
-  // And the rule is the one every cut obeys, so no segment anywhere is short.
-  for (let index = 1; index < grid.boundaries.length; index += 1) {
-    const span = grid.boundaries[index] - grid.boundaries[index - 1];
-    assert.ok(span >= 6 - 0.05, `segment ${index - 1} lasts ${span.toFixed(3)}s`);
-  }
-});
+/**
+ * @file A run cuts where the player was told the cuts are.
+ *
+ * There are two boundary tables. The live one is corrected as produced segments
+ * reveal where the file's cuts truly are; the published one is the snapshot the
+ * playlist text was written from, and a player places every fragment by that
+ * text and nothing else. The cut list handed to ffmpeg used to come from the
+ * live table, so every correction moved the run away from the timeline the
+ * player is reading.
+ *
+ * Field 2026-08-20, `Minions.and.Monsters.1080p.mkv`: the picture's segments
+ * arrived a uniform 2.002 s before the times its playlist named — 119 of 125 of
+ * them — against the 0.5 s hls.js bridges. A fragment that does not land is
+ * fetched again, and on 2026-08-17 two of them were fetched 1908 times each.
+ */
+
+import assert from "node:assert/strict";
+import { computeCutGrid } from "../services/encode/output/cut-grid.js";
+import { Timeline } from "../services/encode/output/Timeline.js";
+import test from "node:test";
+
+import { wireOutputs } from "../services/server/wire-outputs.js";
+import { segmentCutTimesFrom } from "../services/encode/run-command.js";
+
+/** What the playlist in the player's hands says. */
+const PUBLISHED = [0, 4.004, 8.008, 12.012, 16.016, 20.02];
+/** The same grid after produced segments moved two of its cuts. */
+const CORRECTED = [0, 4.004, 6.006, 12.012, 14.014, 20.02];
+
+/**
+ * A session that has published one grid and since corrected another.
+ *
+ * @returns {{ manager: object, session: object }}
+ */
+function sessionWithDriftedGrid() {
+  const manager = wireOutputs({
+    enabled: true,
+    ffmpegBin: "ffmpeg",
+    localBindHost: "127.0.0.1",
+    localPort: 9090
+  });
+  const session = {
+    id: "picture",
+    timeline: new Timeline({ boundaries: [...CORRECTED], published: [...PUBLISHED], cutGrid: "uniform" })
+  };
+  return { manager, session };
+}
+
+test("the cut list is the one the playlist was written from", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  const grid = manager.outputTimes.publishedGridFor(session);
+  assert.deepEqual(grid, PUBLISHED);
+  // Interior cuts of a run starting at #1, rebased on the run's own start
+  // (4.004 s), and stopping before the last entry, which is the file's end.
+  assert.deepEqual(
+    segmentCutTimesFrom(grid, 1).map((time) => Number(time.toFixed(3))),
+    [4.004, 8.008, 12.012]
+  );
+});
+
+test("a corrected grid does not move the cuts of a session already being read", () => {
+  const { manager, session } = sessionWithDriftedGrid();
+  const fromCorrected = segmentCutTimesFrom(session.timeline.boundaries, 1);
+  const fromPublished = segmentCutTimesFrom(manager.outputTimes.publishedGridFor(session), 1);
+  assert.notDeepEqual(fromCorrected, fromPublished);
+  // The gap the field measured: the corrected table would have cut #2 two
+  // seconds early, which is four times what a player bridges.
+  assert.equal(Number((fromPublished[0] - fromCorrected[0]).toFixed(3)), 2.002);
+});
+
+test("a session that published no grid falls back to the live one", () => {
+  const { manager } = sessionWithDriftedGrid();
+  const session = { id: "no-playlist", timeline: new Timeline({ boundaries: [...CORRECTED], published: [], cutGrid: "uniform" }) };
+  assert.deepEqual(manager.outputTimes.publishedGridFor(session), CORRECTED);
+});
+
+test("no segment is left shorter than a segment at the end of the film", () => {
+  // The field case of 2026-09-11, to the millisecond: a 54-minute film whose
+  // last keyframe sits 160 ms before the end. Taking it as a cut leaves a
+  // segment of 0.16 s — one the sound has no data in at all, which is how one
+  // output came to have 542 segments and the other 541.
+  const total = 3246.12;
+  const keyframes = [];
+  for (let at = 0; at < total - 1; at += 2) {
+    keyframes.push(Number(at.toFixed(3)));
+  }
+  keyframes.push(3245.96);
+
+  const grid = computeCutGrid({
+    useKeyframeGrid: true,
+    durationSeconds: total,
+    segDur: 6,
+    keyframeTimes: keyframes,
+    startTime: 0
+  });
+
+  const last = grid.boundaries[grid.boundaries.length - 1];
+  const before = grid.boundaries[grid.boundaries.length - 2];
+  assert.equal(last, total, "the film still ends where it ends");
+  assert.ok(
+    last - before >= 6,
+    `the last segment is ${(last - before).toFixed(3)}s, shorter than the 6s every other cut is held to`
+  );
+  // And the rule is the one every cut obeys, so no segment anywhere is short.
+  for (let index = 1; index < grid.boundaries.length; index += 1) {
+    const span = grid.boundaries[index] - grid.boundaries[index - 1];
+    assert.ok(span >= 6 - 0.05, `segment ${index - 1} lasts ${span.toFixed(3)}s`);
+  }
+});

package/test/data-channel-frame.test.js

@@ -1,63 +1,63 @@
-/**
- * @file The wire format of a body frame.
- *
- * The browser parses these bytes, so the layout is a contract:
- * `[flags(1)][idLen(1)][requestId][payload]`. The framing was rewritten to stop
- * copying every chunk twice (75.9 ms per 13 MB segment against 40.0 on the
- * field host), and a rewrite of something a client parses needs the format
- * pinned down, not just the timing.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { encodeFrame } from "../services/transport/data-channel-handler.js";
-
-const requestId = Buffer.from("abc123", "ascii");
-
-test("a body frame carries the id and the payload unchanged", () => {
-  const payload = Buffer.from([1, 2, 3, 4, 250, 255]);
-  const frame = encodeFrame(requestId, payload, false);
-
-  assert.equal(frame[0], 0, "flagged as done");
-  assert.equal(frame[1], requestId.length);
-  assert.deepEqual(frame.subarray(2, 2 + requestId.length), requestId);
-  assert.deepEqual(frame.subarray(2 + requestId.length), payload);
-  assert.equal(frame.length, 2 + requestId.length + payload.length);
-});
-
-test("the done frame carries no payload", () => {
-  const frame = encodeFrame(requestId, null, true);
-
-  assert.equal(frame[0], 1);
-  assert.equal(frame.length, 2 + requestId.length);
-});
-
-test("an empty payload is treated as no payload", () => {
-  const frame = encodeFrame(requestId, new Uint8Array(0), false);
-  assert.equal(frame.length, 2 + requestId.length);
-});
-
-test("a payload that is a view into a larger buffer is copied correctly", () => {
-  // Chunks arrive as views into a bigger allocation, so copying the whole
-  // underlying buffer instead of the view would send the wrong bytes at the
-  // wrong length — silently.
-  const backing = Buffer.alloc(64, 9);
-  backing.fill(42, 16, 32);
-  const view = new Uint8Array(backing.buffer, backing.byteOffset + 16, 16);
-
-  const frame = encodeFrame(requestId, view, false);
-
-  assert.equal(frame.length, 2 + requestId.length + 16);
-  assert.deepEqual(frame.subarray(2 + requestId.length), Buffer.alloc(16, 42));
-});
-
-test("a large payload survives framing byte for byte", () => {
-  const payload = Buffer.allocUnsafeSlow(64 * 1024);
-  for (let at = 0; at < payload.length; at += 1) {
-    payload[at] = at % 251;
-  }
-
-  const frame = encodeFrame(requestId, payload, false);
-
-  assert.deepEqual(frame.subarray(2 + requestId.length), payload);
-});
+/**
+ * @file The wire format of a body frame.
+ *
+ * The browser parses these bytes, so the layout is a contract:
+ * `[flags(1)][idLen(1)][requestId][payload]`. The framing was rewritten to stop
+ * copying every chunk twice (75.9 ms per 13 MB segment against 40.0 on the
+ * field host), and a rewrite of something a client parses needs the format
+ * pinned down, not just the timing.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { encodeFrame } from "../services/transport/data-channel-handler.js";
+
+const requestId = Buffer.from("abc123", "ascii");
+
+test("a body frame carries the id and the payload unchanged", () => {
+  const payload = Buffer.from([1, 2, 3, 4, 250, 255]);
+  const frame = encodeFrame(requestId, payload, false);
+
+  assert.equal(frame[0], 0, "flagged as done");
+  assert.equal(frame[1], requestId.length);
+  assert.deepEqual(frame.subarray(2, 2 + requestId.length), requestId);
+  assert.deepEqual(frame.subarray(2 + requestId.length), payload);
+  assert.equal(frame.length, 2 + requestId.length + payload.length);
+});
+
+test("the done frame carries no payload", () => {
+  const frame = encodeFrame(requestId, null, true);
+
+  assert.equal(frame[0], 1);
+  assert.equal(frame.length, 2 + requestId.length);
+});
+
+test("an empty payload is treated as no payload", () => {
+  const frame = encodeFrame(requestId, new Uint8Array(0), false);
+  assert.equal(frame.length, 2 + requestId.length);
+});
+
+test("a payload that is a view into a larger buffer is copied correctly", () => {
+  // Chunks arrive as views into a bigger allocation, so copying the whole
+  // underlying buffer instead of the view would send the wrong bytes at the
+  // wrong length — silently.
+  const backing = Buffer.alloc(64, 9);
+  backing.fill(42, 16, 32);
+  const view = new Uint8Array(backing.buffer, backing.byteOffset + 16, 16);
+
+  const frame = encodeFrame(requestId, view, false);
+
+  assert.equal(frame.length, 2 + requestId.length + 16);
+  assert.deepEqual(frame.subarray(2 + requestId.length), Buffer.alloc(16, 42));
+});
+
+test("a large payload survives framing byte for byte", () => {
+  const payload = Buffer.allocUnsafeSlow(64 * 1024);
+  for (let at = 0; at < payload.length; at += 1) {
+    payload[at] = at % 251;
+  }
+
+  const frame = encodeFrame(requestId, payload, false);
+
+  assert.deepEqual(frame.subarray(2 + requestId.length), payload);
+});

package/test/data-channel-viewer-lifecycle.test.js

@@ -0,0 +1,92 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createDataChannelHandler } from "../services/transport/data-channel-handler.js";
+
+class FakeDataChannel {
+  constructor(label) {
+    this.label = label;
+    this.messages = [];
+    this.closed = null;
+  }
+
+  getLabel() {
+    return this.label;
+  }
+
+  onMessage(callback) {
+    this.message = callback;
+  }
+
+  onClosed(callback) {
+    this.closed = callback;
+  }
+
+  onError() {}
+
+  sendMessage(message) {
+    this.messages.push(message);
+  }
+
+  close() {
+    this.closed?.();
+  }
+}
+
+test("a viewer remains present until every data channel on the connection closes", () => {
+  const gone = [];
+  const handler = createDataChannelHandler({
+    proxyPort: 9090,
+    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
+    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
+  });
+  const media = new FakeDataChannel("proxy");
+  const control = new FakeDataChannel("proxy-control");
+  const probe = new FakeDataChannel("proxy-fast");
+
+  handler.handleChannel("peer-session", media);
+  handler.handleChannel("peer-session", control);
+  handler.handleChannel("peer-session", probe);
+  control.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
+
+  control.close();
+  assert.deepEqual(gone, [], "closing the control channel alone does not release the viewer");
+
+  media.close();
+  assert.deepEqual(gone, [], "the viewer remains while the probe channel is still open");
+
+  probe.close();
+  assert.deepEqual(gone, [
+    { consumerId: "viewer-1", reason: "the connection closed" }
+  ]);
+});
+
+test("a closing connection does not release a viewer already named on its replacement", () => {
+  const gone = [];
+  const handler = createDataChannelHandler({
+    proxyPort: 9090,
+    getTransportSnapshot: () => ({ bytesSent: 0, bytesReceived: 0 }),
+    onViewerGone: (consumerId, reason) => gone.push({ consumerId, reason })
+  });
+  const oldControl = new FakeDataChannel("proxy-control");
+  const oldMedia = new FakeDataChannel("proxy");
+  const newControl = new FakeDataChannel("proxy-control");
+  const newMedia = new FakeDataChannel("proxy");
+
+  handler.handleChannel("old-peer", oldControl);
+  handler.handleChannel("old-peer", oldMedia);
+  oldControl.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
+  handler.handleChannel("new-peer", newControl);
+  handler.handleChannel("new-peer", newMedia);
+  newControl.message(JSON.stringify({ type: "viewer", consumerId: "viewer-1" }));
+
+  oldControl.close();
+  oldMedia.close();
+  assert.deepEqual(gone, [], "the old connection no longer owns the viewer");
+
+  newControl.close();
+  assert.deepEqual(gone, [], "the replacement still has its media channel");
+  newMedia.close();
+  assert.deepEqual(gone, [
+    { consumerId: "viewer-1", reason: "the connection closed" }
+  ]);
+});

package/test/dead-torrent-handle.test.js

@@ -1,52 +1,52 @@
-/**
- * @file A torrent that was destroyed must not be handed to a reader.
- *
- * The worker remembers each source as a promise, and only ever forgot one when
- * the ADD failed. But the pool destroys a torrent that has gone unread for a
- * quarter of an hour, and under disk pressure — clearing its own map, not this
- * one. The promise then went on resolving to a corpse: a destroyed torrent
- * keeps its object and loses its files.
- *
- * What that did to a viewer, measured 2026-08-06 on two sessions in a row: the
- * plan answered from cache in 23 ms, the session was created from cache in
- * 2 ms, nothing waited for metadata because everything believed the torrent was
- * known, and ffmpeg's first read died 130 ms in with `File 0 not found`. Every
- * request for the playlist then answered 500 until the viewer gave up.
- *
- * The rule under test is the whole fix: a handle that cannot be read from is
- * not returned, it is replaced.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { isUsableTorrentHandle } from "../services/torrent/worker/handle-state.js";
-
-test("a live torrent is usable", () => {
-  assert.equal(isUsableTorrentHandle({ destroyed: false, files: [{ name: "a.mkv" }] }), true);
-});
-
-test("a destroyed torrent is not, even while it still lists files", () => {
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: true, files: [{ name: "a.mkv" }] }),
-    false,
-    "WebTorrent's own flag is the earliest signal that a handle is finished"
-  );
-});
-
-test("a torrent with no files is not — that is what the reader actually hits", () => {
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: false, files: [] }),
-    false,
-    "an empty file list is what produced `File 0 not found` in the field"
-  );
-  assert.equal(
-    isUsableTorrentHandle({ destroyed: false }),
-    false,
-    "and a handle with no file list at all is the same case"
-  );
-});
-
-test("nothing at all is not usable", () => {
-  assert.equal(isUsableTorrentHandle(null), false);
-  assert.equal(isUsableTorrentHandle(undefined), false);
-});
+/**
+ * @file A torrent that was destroyed must not be handed to a reader.
+ *
+ * The worker remembers each source as a promise, and only ever forgot one when
+ * the ADD failed. But the pool destroys a torrent that has gone unread for a
+ * quarter of an hour, and under disk pressure — clearing its own map, not this
+ * one. The promise then went on resolving to a corpse: a destroyed torrent
+ * keeps its object and loses its files.
+ *
+ * What that did to a viewer, measured 2026-08-06 on two sessions in a row: the
+ * plan answered from cache in 23 ms, the session was created from cache in
+ * 2 ms, nothing waited for metadata because everything believed the torrent was
+ * known, and ffmpeg's first read died 130 ms in with `File 0 not found`. Every
+ * request for the playlist then answered 500 until the viewer gave up.
+ *
+ * The rule under test is the whole fix: a handle that cannot be read from is
+ * not returned, it is replaced.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { isUsableTorrentHandle } from "../services/torrent/worker/handle-state.js";
+
+test("a live torrent is usable", () => {
+  assert.equal(isUsableTorrentHandle({ destroyed: false, files: [{ name: "a.mkv" }] }), true);
+});
+
+test("a destroyed torrent is not, even while it still lists files", () => {
+  assert.equal(
+    isUsableTorrentHandle({ destroyed: true, files: [{ name: "a.mkv" }] }),
+    false,
+    "WebTorrent's own flag is the earliest signal that a handle is finished"
+  );
+});
+
+test("a torrent with no files is not — that is what the reader actually hits", () => {
+  assert.equal(
+    isUsableTorrentHandle({ destroyed: false, files: [] }),
+    false,
+    "an empty file list is what produced `File 0 not found` in the field"
+  );
+  assert.equal(
+    isUsableTorrentHandle({ destroyed: false }),
+    false,
+    "and a handle with no file list at all is the same case"
+  );
+});
+
+test("nothing at all is not usable", () => {
+  assert.equal(isUsableTorrentHandle(null), false);
+  assert.equal(isUsableTorrentHandle(undefined), false);
+});