@torrent-tv/proxy 2.89.5 → 2.89.7

package/test/visible-rung.test.js

@@ -1,37 +1,37 @@
-/**
- * @file The rung the picture a viewer sees asks for: the smallest height of the
- * ladder whose frame is not smaller than it (roadmap item 98).
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { rungForVisiblePicture, visibleHeightCap } from "../services/encode/quality/visible-rung.js";
-import { buildResolutionLadder } from "../services/encode/hwaccel.js";
-
-const LADDER = buildResolutionLadder(1920, 1080);
-
-test("the smallest rung whose frame is not smaller than the picture seen", () => {
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1200, height: 675 }), { width: 1280, height: 720 });
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1280, height: 720 }), { width: 1280, height: 720 });
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1281, height: 720 }), { width: 1920, height: 1080 });
-});
-
-test("a picture seen larger than the source is served at the source's size, never above", () => {
-  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 3840, height: 2160 }), { width: 1920, height: 1080 });
-});
-
-test("both sides count: a wide picture asks for the rung wide enough", () => {
-  // Stretched (object-fit: fill) to 1000 wide and 300 tall.
-  assert.equal(rungForVisiblePicture(LADDER, { width: 1000, height: 300 }).height, 720);
-});
-
-test("nothing measured bounds nothing", () => {
-  assert.equal(rungForVisiblePicture(LADDER, null), null);
-  assert.equal(visibleHeightCap(1920, 1080, null), null);
-  assert.equal(visibleHeightCap(0, 0, { width: 640, height: 360 }), null);
-});
-
-test("the bound is a height of the source's own ladder", () => {
-  assert.equal(visibleHeightCap(1920, 1080, { width: 640, height: 360 }), 360);
-  assert.equal(visibleHeightCap(1920, 800, { width: 900, height: 375 }), 480);
-});
+/**
+ * @file The rung the picture a viewer sees asks for: the smallest height of the
+ * ladder whose frame is not smaller than it (roadmap item 98).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { rungForVisiblePicture, visibleHeightCap } from "../services/encode/quality/visible-rung.js";
+import { buildResolutionLadder } from "../services/encode/hwaccel.js";
+
+const LADDER = buildResolutionLadder(1920, 1080);
+
+test("the smallest rung whose frame is not smaller than the picture seen", () => {
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1200, height: 675 }), { width: 1280, height: 720 });
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1280, height: 720 }), { width: 1280, height: 720 });
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 1281, height: 720 }), { width: 1920, height: 1080 });
+});
+
+test("a picture seen larger than the source is served at the source's size, never above", () => {
+  assert.deepEqual(rungForVisiblePicture(LADDER, { width: 3840, height: 2160 }), { width: 1920, height: 1080 });
+});
+
+test("both sides count: a wide picture asks for the rung wide enough", () => {
+  // Stretched (object-fit: fill) to 1000 wide and 300 tall.
+  assert.equal(rungForVisiblePicture(LADDER, { width: 1000, height: 300 }).height, 720);
+});
+
+test("nothing measured bounds nothing", () => {
+  assert.equal(rungForVisiblePicture(LADDER, null), null);
+  assert.equal(visibleHeightCap(1920, 1080, null), null);
+  assert.equal(visibleHeightCap(0, 0, { width: 640, height: 360 }), null);
+});
+
+test("the bound is a height of the source's own ladder", () => {
+  assert.equal(visibleHeightCap(1920, 1080, { width: 640, height: 360 }), 360);
+  assert.equal(visibleHeightCap(1920, 800, { width: 900, height: 375 }), 480);
+});

package/test/wait-ledger.test.js

@@ -1,100 +1,100 @@
-/**
- * @file Whether the priority map is being served in its own order.
- *
- * The map says what matters most. Until 2026-09-08 nothing said whether what
- * mattered most was delivered first, for either of the two things that read it
- * — so a map read backwards would have looked identical in every log line the
- * proxy writes.
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { bandOf, WaitLedger } from "../services/server/WaitLedger.js";
-import { SegmentDemand } from "../services/encode/SegmentDemand.js";
-
-test("the top rank is its own band, and the rest fall behind it", () => {
-  // The map's ranks are as many as the film needs, and a table with a hundred
-  // rows says nothing a reader can hold. What is being asked is coarse.
-  assert.equal(bandOf(100, 100), "now", "where the viewer is standing");
-  assert.equal(bandOf(95, 100), "soon", "what they reach while watching what they hold");
-  assert.equal(bandOf(50, 100), "later", "the rest of the film");
-  assert.equal(bandOf(0, 100), "later", "in nobody's zone at all");
-});
-
-test("a short map has a top band too", () => {
-  // A film with three bands must not report every wait as `later` because its
-  // numbers are small: a rank is a position in THIS map, not an absolute.
-  assert.equal(bandOf(3, 3), "now");
-  assert.equal(bandOf(1, 3), "later");
-});
-
-test("a band that never waited is said out loud, not reported as zero", () => {
-  const ledger = new WaitLedger();
-  ledger.note("out:1080", 40, 100, 100);
-
-  const said = ledger.describe("out:1080");
-  assert.match(said, /now 1 wait\(s\) median 40ms worst 40ms/);
-  assert.match(said, /soon none/, "silence is not a zero");
-  assert.match(said, /later none/);
-});
-
-test("nothing waited at all reads as nothing, so it cannot be mistaken for good", () => {
-  assert.equal(new WaitLedger().describe("out:1080"), null);
-});
-
-test("the count is the whole run and the median is the recent sample", () => {
-  // Two different questions: how often, and how badly.
-  const ledger = new WaitLedger();
-  for (let n = 0; n < 300; n += 1) {
-    ledger.note("out:1080", n, 100, 100);
-  }
-
-  const said = ledger.describe("out:1080");
-  assert.match(said, /now 300 wait\(s\)/, "every wait is counted");
-  assert.match(said, /worst 299ms/, "and the worst of what is still held");
-});
-
-test("waits of two outputs do not mix", () => {
-  const ledger = new WaitLedger();
-  ledger.note("out:1080", 5000, 100, 100);
-  ledger.note("out:480", 10, 100, 100);
-
-  assert.match(ledger.describe("out:1080"), /now 1 wait\(s\) median 5000ms/);
-  assert.match(ledger.describe("out:480"), /now 1 wait\(s\) median 10ms/);
-});
-
-test("the map answers what it says about one segment, and about itself", () => {
-  // The rank alone cannot be read: a wait means one thing at the top of a map
-  // and another at the bottom, so the highest rank stated comes with it.
-  const demand = new SegmentDemand();
-  demand.state("out:1080", [
-    { from: 10, to: 12, priority: 100, withinSeconds: 0 },
-    { from: 13, to: 20, priority: 97, withinSeconds: 4 },
-    { from: 21, to: 90, priority: 90, withinSeconds: 40 }
-  ]);
-
-  assert.deepEqual(demand.rankOf("out:1080", 11), { rank: 100, topRank: 100 });
-  assert.deepEqual(demand.rankOf("out:1080", 15), { rank: 97, topRank: 100 });
-  assert.deepEqual(
-    demand.rankOf("out:1080", 500),
-    { rank: 0, topRank: 100 },
-    "in nobody's zone is a statement: nothing is coming for it"
-  );
-  assert.deepEqual(
-    demand.rankOf("out:none", 11),
-    { rank: 0, topRank: 0 },
-    "and a map that has not been built says nothing at all, which is different"
-  );
-});
-
-test("overlapping zones give a segment the highest rank that covers it", () => {
-  // Two viewers a few seconds apart state stretches that overlap; the segment
-  // is as urgent as the most urgent claim on it.
-  const demand = new SegmentDemand();
-  demand.state("out:1080", [
-    { from: 0, to: 100, priority: 90, withinSeconds: 40 },
-    { from: 10, to: 12, priority: 100, withinSeconds: 0 }
-  ]);
-
-  assert.equal(demand.rankOf("out:1080", 11).rank, 100);
-});
+/**
+ * @file Whether the priority map is being served in its own order.
+ *
+ * The map says what matters most. Until 2026-09-08 nothing said whether what
+ * mattered most was delivered first, for either of the two things that read it
+ * — so a map read backwards would have looked identical in every log line the
+ * proxy writes.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { bandOf, WaitLedger } from "../services/server/WaitLedger.js";
+import { SegmentDemand } from "../services/encode/SegmentDemand.js";
+
+test("the top rank is its own band, and the rest fall behind it", () => {
+  // The map's ranks are as many as the film needs, and a table with a hundred
+  // rows says nothing a reader can hold. What is being asked is coarse.
+  assert.equal(bandOf(100, 100), "now", "where the viewer is standing");
+  assert.equal(bandOf(95, 100), "soon", "what they reach while watching what they hold");
+  assert.equal(bandOf(50, 100), "later", "the rest of the film");
+  assert.equal(bandOf(0, 100), "later", "in nobody's zone at all");
+});
+
+test("a short map has a top band too", () => {
+  // A film with three bands must not report every wait as `later` because its
+  // numbers are small: a rank is a position in THIS map, not an absolute.
+  assert.equal(bandOf(3, 3), "now");
+  assert.equal(bandOf(1, 3), "later");
+});
+
+test("a band that never waited is said out loud, not reported as zero", () => {
+  const ledger = new WaitLedger();
+  ledger.note("out:1080", 40, 100, 100);
+
+  const said = ledger.describe("out:1080");
+  assert.match(said, /now 1 wait\(s\) median 40ms worst 40ms/);
+  assert.match(said, /soon none/, "silence is not a zero");
+  assert.match(said, /later none/);
+});
+
+test("nothing waited at all reads as nothing, so it cannot be mistaken for good", () => {
+  assert.equal(new WaitLedger().describe("out:1080"), null);
+});
+
+test("the count is the whole run and the median is the recent sample", () => {
+  // Two different questions: how often, and how badly.
+  const ledger = new WaitLedger();
+  for (let n = 0; n < 300; n += 1) {
+    ledger.note("out:1080", n, 100, 100);
+  }
+
+  const said = ledger.describe("out:1080");
+  assert.match(said, /now 300 wait\(s\)/, "every wait is counted");
+  assert.match(said, /worst 299ms/, "and the worst of what is still held");
+});
+
+test("waits of two outputs do not mix", () => {
+  const ledger = new WaitLedger();
+  ledger.note("out:1080", 5000, 100, 100);
+  ledger.note("out:480", 10, 100, 100);
+
+  assert.match(ledger.describe("out:1080"), /now 1 wait\(s\) median 5000ms/);
+  assert.match(ledger.describe("out:480"), /now 1 wait\(s\) median 10ms/);
+});
+
+test("the map answers what it says about one segment, and about itself", () => {
+  // The rank alone cannot be read: a wait means one thing at the top of a map
+  // and another at the bottom, so the highest rank stated comes with it.
+  const demand = new SegmentDemand();
+  demand.state("out:1080", [
+    { from: 10, to: 12, priority: 100, withinSeconds: 0 },
+    { from: 13, to: 20, priority: 97, withinSeconds: 4 },
+    { from: 21, to: 90, priority: 90, withinSeconds: 40 }
+  ]);
+
+  assert.deepEqual(demand.rankOf("out:1080", 11), { rank: 100, topRank: 100 });
+  assert.deepEqual(demand.rankOf("out:1080", 15), { rank: 97, topRank: 100 });
+  assert.deepEqual(
+    demand.rankOf("out:1080", 500),
+    { rank: 0, topRank: 100 },
+    "in nobody's zone is a statement: nothing is coming for it"
+  );
+  assert.deepEqual(
+    demand.rankOf("out:none", 11),
+    { rank: 0, topRank: 0 },
+    "and a map that has not been built says nothing at all, which is different"
+  );
+});
+
+test("overlapping zones give a segment the highest rank that covers it", () => {
+  // Two viewers a few seconds apart state stretches that overlap; the segment
+  // is as urgent as the most urgent claim on it.
+  const demand = new SegmentDemand();
+  demand.state("out:1080", [
+    { from: 0, to: 100, priority: 90, withinSeconds: 40 },
+    { from: 10, to: 12, priority: 100, withinSeconds: 0 }
+  ]);
+
+  assert.equal(demand.rankOf("out:1080", 11).rank, 100);
+});

package/test/webrtc-shim.test.js

@@ -1,149 +1,149 @@
-/**
- * @file The JavaScript WebRTC stack the torrent thread uses instead of the native one.
- *
- * Covers the regression that took the whole proxy down from 2.9.71: a torrent
- * carrying a `wss://` tracker made the worker create a peer connection, and a
- * second isolate touching node-datachannel aborts the process outright.
- *
- * Also covers the two places werift's data channel differs from the browser's,
- * because `simple-peer` depends on both: binary payloads must arrive as
- * `ArrayBuffer` (anything else it pushes through a text decoder, corrupting
- * torrent data), and the buffered-amount-low event must exist (its backpressure
- * never resumes without it).
- */
-
-import test from "node:test";
-import assert from "node:assert/strict";
-import { Worker } from "node:worker_threads";
-import {
-  RTCPeerConnection,
-  RTCSessionDescription
-} from "../services/torrent/worker/webrtc-shim.js";
-
-/**
- * Run a snippet on a worker thread and return what it reports.
- *
- * @param {string} source
- * @returns {Promise<unknown>}
- */
-function onWorker(source) {
-  return new Promise((resolve, reject) => {
-    const worker = new Worker(source, { eval: true });
-    const done = (settle) => (value) => {
-      void worker.terminate();
-      settle(value);
-    };
-    worker.once("message", done(resolve));
-    worker.once("error", done(reject));
-  });
-}
-
-test("the worker resolves webrtc-polyfill to the JavaScript stack", async () => {
-  const installUrl = new URL("../services/torrent/worker/install-webrtc-shim.js", import.meta.url).href;
-  const reported = await onWorker(`
-    import { parentPort } from "node:worker_threads";
-    await import(${JSON.stringify(installUrl)});
-    const polyfill = await import("webrtc-polyfill");
-    const pc = new polyfill.RTCPeerConnection({});
-    const channel = pc.createDataChannel("probe");
-    parentPort.postMessage({
-      connection: pc.constructor.name,
-      channel: channel.constructor.name,
-      hasBinaryType: "binaryType" in channel,
-      hasBufferedAmountLow: "onbufferedamountlow" in channel
-    });
-    pc.close();
-  `);
-
-  assert.equal(reported.connection, "ShimPeerConnection");
-  assert.equal(reported.channel, "ShimDataChannel");
-  assert.ok(reported.hasBinaryType, "simple-peer sets binaryType and would get a silent no-op");
-  assert.ok(reported.hasBufferedAmountLow, "simple-peer's backpressure needs this event");
-});
-
-test("a native connection on this thread does not stop the worker's stack", async () => {
-  // The exact pairing that aborted the process before: native here, JavaScript
-  // there, both live at once.
-  const nodeDataChannel = (await import("node-datachannel")).default;
-  const native = new nodeDataChannel.PeerConnection("main-side", { iceServers: [] });
-  native.createDataChannel("keepalive");
-
-  try {
-    const installUrl = new URL("../services/torrent/worker/install-webrtc-shim.js", import.meta.url).href;
-    const reported = await onWorker(`
-      import { parentPort } from "node:worker_threads";
-      await import(${JSON.stringify(installUrl)});
-      const polyfill = await import("webrtc-polyfill");
-      const pc = new polyfill.RTCPeerConnection({});
-      pc.createDataChannel("probe");
-      const offer = await pc.createOffer();
-      await pc.setLocalDescription(offer);
-      parentPort.postMessage({ ok: String(pc.localDescription.sdp).startsWith("v=0") });
-      pc.close();
-    `);
-    assert.equal(reported.ok, true);
-  } finally {
-    native.close();
-  }
-});
-
-test("a session description is built from one object, as callers write it", async () => {
-  // simple-peer does `new RTCSessionDescription(data)` with `{ type, sdp }`.
-  // werift's own class takes `(sdp, type)` positionally, so the type would land
-  // in the sdp slot and every peer connection would be rejected with
-  // "invalid sessionDescription" — which is exactly what the field showed.
-  const description = new RTCSessionDescription({ type: "offer", sdp: "v=0\r\n" });
-  assert.equal(description.type, "offer");
-  assert.equal(description.sdp, "v=0\r\n");
-
-  const answerer = new RTCPeerConnection({});
-  const offerer = new RTCPeerConnection({});
-  try {
-    offerer.createDataChannel("probe");
-    const offer = await offerer.createOffer();
-    await offerer.setLocalDescription(offer);
-
-    // The round trip a tracker peer actually performs.
-    await answerer.setRemoteDescription(
-      new RTCSessionDescription({ type: offerer.localDescription.type, sdp: offerer.localDescription.sdp })
-    );
-    assert.equal(answerer.remoteDescription.type, "offer");
-  } finally {
-    answerer.close();
-    offerer.close();
-  }
-});
-
-test("binary payloads reach the reader as ArrayBuffer, byte for byte", async () => {
-  const sender = new RTCPeerConnection({});
-  const receiver = new RTCPeerConnection({});
-  const payload = Buffer.from([0xde, 0xad, 0xbe, 0xef, 0x00, 0xff, 0x7f, 0x80]);
-
-  try {
-    const received = new Promise((resolve, reject) => {
-      receiver.ondatachannel = ({ channel }) => {
-        channel.binaryType = "arraybuffer";
-        channel.onmessage = (event) => resolve(event.data);
-      };
-      setTimeout(() => reject(new Error("nothing arrived within 30s")), 30_000);
-    });
-
-    sender.onicecandidate = ({ candidate }) => candidate && receiver.addIceCandidate(candidate);
-    receiver.onicecandidate = ({ candidate }) => candidate && sender.addIceCandidate(candidate);
-
-    const channel = sender.createDataChannel("payload");
-    await sender.setLocalDescription(await sender.createOffer());
-    await receiver.setRemoteDescription(sender.localDescription);
-    await receiver.setLocalDescription(await receiver.createAnswer());
-    await sender.setRemoteDescription(receiver.localDescription);
-
-    channel.onopen = () => channel.send(payload);
-
-    const data = await received;
-    assert.ok(data instanceof ArrayBuffer, `simple-peer would run this through a text decoder: ${Object.prototype.toString.call(data)}`);
-    assert.deepEqual(Buffer.from(data), payload, "payload was altered in transit");
-  } finally {
-    sender.close();
-    receiver.close();
-  }
-});
+/**
+ * @file The JavaScript WebRTC stack the torrent thread uses instead of the native one.
+ *
+ * Covers the regression that took the whole proxy down from 2.9.71: a torrent
+ * carrying a `wss://` tracker made the worker create a peer connection, and a
+ * second isolate touching node-datachannel aborts the process outright.
+ *
+ * Also covers the two places werift's data channel differs from the browser's,
+ * because `simple-peer` depends on both: binary payloads must arrive as
+ * `ArrayBuffer` (anything else it pushes through a text decoder, corrupting
+ * torrent data), and the buffered-amount-low event must exist (its backpressure
+ * never resumes without it).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Worker } from "node:worker_threads";
+import {
+  RTCPeerConnection,
+  RTCSessionDescription
+} from "../services/torrent/worker/webrtc-shim.js";
+
+/**
+ * Run a snippet on a worker thread and return what it reports.
+ *
+ * @param {string} source
+ * @returns {Promise<unknown>}
+ */
+function onWorker(source) {
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(source, { eval: true });
+    const done = (settle) => (value) => {
+      void worker.terminate();
+      settle(value);
+    };
+    worker.once("message", done(resolve));
+    worker.once("error", done(reject));
+  });
+}
+
+test("the worker resolves webrtc-polyfill to the JavaScript stack", async () => {
+  const installUrl = new URL("../services/torrent/worker/install-webrtc-shim.js", import.meta.url).href;
+  const reported = await onWorker(`
+    import { parentPort } from "node:worker_threads";
+    await import(${JSON.stringify(installUrl)});
+    const polyfill = await import("webrtc-polyfill");
+    const pc = new polyfill.RTCPeerConnection({});
+    const channel = pc.createDataChannel("probe");
+    parentPort.postMessage({
+      connection: pc.constructor.name,
+      channel: channel.constructor.name,
+      hasBinaryType: "binaryType" in channel,
+      hasBufferedAmountLow: "onbufferedamountlow" in channel
+    });
+    pc.close();
+  `);
+
+  assert.equal(reported.connection, "ShimPeerConnection");
+  assert.equal(reported.channel, "ShimDataChannel");
+  assert.ok(reported.hasBinaryType, "simple-peer sets binaryType and would get a silent no-op");
+  assert.ok(reported.hasBufferedAmountLow, "simple-peer's backpressure needs this event");
+});
+
+test("a native connection on this thread does not stop the worker's stack", async () => {
+  // The exact pairing that aborted the process before: native here, JavaScript
+  // there, both live at once.
+  const nodeDataChannel = (await import("node-datachannel")).default;
+  const native = new nodeDataChannel.PeerConnection("main-side", { iceServers: [] });
+  native.createDataChannel("keepalive");
+
+  try {
+    const installUrl = new URL("../services/torrent/worker/install-webrtc-shim.js", import.meta.url).href;
+    const reported = await onWorker(`
+      import { parentPort } from "node:worker_threads";
+      await import(${JSON.stringify(installUrl)});
+      const polyfill = await import("webrtc-polyfill");
+      const pc = new polyfill.RTCPeerConnection({});
+      pc.createDataChannel("probe");
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      parentPort.postMessage({ ok: String(pc.localDescription.sdp).startsWith("v=0") });
+      pc.close();
+    `);
+    assert.equal(reported.ok, true);
+  } finally {
+    native.close();
+  }
+});
+
+test("a session description is built from one object, as callers write it", async () => {
+  // simple-peer does `new RTCSessionDescription(data)` with `{ type, sdp }`.
+  // werift's own class takes `(sdp, type)` positionally, so the type would land
+  // in the sdp slot and every peer connection would be rejected with
+  // "invalid sessionDescription" — which is exactly what the field showed.
+  const description = new RTCSessionDescription({ type: "offer", sdp: "v=0\r\n" });
+  assert.equal(description.type, "offer");
+  assert.equal(description.sdp, "v=0\r\n");
+
+  const answerer = new RTCPeerConnection({});
+  const offerer = new RTCPeerConnection({});
+  try {
+    offerer.createDataChannel("probe");
+    const offer = await offerer.createOffer();
+    await offerer.setLocalDescription(offer);
+
+    // The round trip a tracker peer actually performs.
+    await answerer.setRemoteDescription(
+      new RTCSessionDescription({ type: offerer.localDescription.type, sdp: offerer.localDescription.sdp })
+    );
+    assert.equal(answerer.remoteDescription.type, "offer");
+  } finally {
+    answerer.close();
+    offerer.close();
+  }
+});
+
+test("binary payloads reach the reader as ArrayBuffer, byte for byte", async () => {
+  const sender = new RTCPeerConnection({});
+  const receiver = new RTCPeerConnection({});
+  const payload = Buffer.from([0xde, 0xad, 0xbe, 0xef, 0x00, 0xff, 0x7f, 0x80]);
+
+  try {
+    const received = new Promise((resolve, reject) => {
+      receiver.ondatachannel = ({ channel }) => {
+        channel.binaryType = "arraybuffer";
+        channel.onmessage = (event) => resolve(event.data);
+      };
+      setTimeout(() => reject(new Error("nothing arrived within 30s")), 30_000);
+    });
+
+    sender.onicecandidate = ({ candidate }) => candidate && receiver.addIceCandidate(candidate);
+    receiver.onicecandidate = ({ candidate }) => candidate && sender.addIceCandidate(candidate);
+
+    const channel = sender.createDataChannel("payload");
+    await sender.setLocalDescription(await sender.createOffer());
+    await receiver.setRemoteDescription(sender.localDescription);
+    await receiver.setLocalDescription(await receiver.createAnswer());
+    await sender.setRemoteDescription(receiver.localDescription);
+
+    channel.onopen = () => channel.send(payload);
+
+    const data = await received;
+    assert.ok(data instanceof ArrayBuffer, `simple-peer would run this through a text decoder: ${Object.prototype.toString.call(data)}`);
+    assert.deepEqual(Buffer.from(data), payload, "payload was altered in transit");
+  } finally {
+    sender.close();
+    receiver.close();
+  }
+});