@torrent-tv/proxy 2.9.76 → 2.9.78

package/services/torrent-worker/worker.js

@@ -24,7 +24,9 @@
 import "./install-webrtc-shim.js";
 import { parentPort, workerData } from "node:worker_threads";
 import { createSendStream } from "./channel.js";
-import { Command, Event, STREAM_CHUNK_BYTES } from "./protocol.js";
+import { createFileClaims } from "./file-claims.js";
+import { readFragments } from "./piece-reader.js";
+import { Command, Event } from "./protocol.js";
 
 // Imported dynamically, and that is load-bearing: static imports are RESOLVED
 // during linking, before any module body runs, so a statically imported pool
@@ -32,7 +34,7 @@ import { Command, Event, STREAM_CHUNK_BYTES } from "./protocol.js";
 // the hook above had a chance to register. Verified the hard way: with a static
 // import the process still aborted, and the stack named the genuine polyfill.
 const { TorrentPool } = await import("../torrent-pool.js");
-const { collectStoreStats } = await import("../piece-store/shared-piece-store.js");
+const { collectStoreStats, findSharedStore } = await import("../piece-store/shared-piece-store.js");
 
 const pool = new TorrentPool({
   maxDiskBytes: workerData?.maxDiskBytes,
@@ -41,8 +43,8 @@ const pool = new TorrentPool({
 
 /** Torrents by sourceKey — the main thread names them, this thread owns them. */
 const torrentsByKey = new Map();
-/** File-claim release callbacks, keyed `${sourceKey}:${fileIndex}`. */
-const releaseByClaim = new Map();
+/** File claims, each with its own identity — see `file-claims.js`. */
+const fileClaims = createFileClaims();
 /** In-flight reads, so a cancel can stop one mid-body. */
 const readsById = new Map();
 
@@ -58,17 +60,80 @@ function log(message) {
 }
 
 /**
- * The torrent for a sourceKey, or throw a message the caller can surface.
+ * The torrent for a sourceKey, waiting for it if it is still being added.
+ *
+ * The map holds a PROMISE, registered the moment the add begins rather than
+ * when it finishes. That distinction is the whole fix: adding a magnet takes as
+ * long as its metadata does — seconds to tens of seconds — and until 2.9.77
+ * everything naming that source in the meantime was told `Unknown source`,
+ * which is false. The source exists; it is not ready. Reproduced with a magnet
+ * nobody seeds: stats, the file listing and a read all failed instantly while
+ * the add was still in flight, which on the loading screen shows up as no
+ * peers, no progress, and a plan request that fails before the torrent has had
+ * a chance to start.
+ *
+ * A source that was never added still throws, which is the honest answer.
  *
  * @param {string} sourceKey
- * @returns {import("webtorrent").Torrent}
+ * @returns {Promise<import("webtorrent").Torrent>}
  */
-function requireTorrent(sourceKey) {
-  const torrent = torrentsByKey.get(sourceKey);
-  if (!torrent) {
+async function requireTorrent(sourceKey) {
+  const pending = torrentsByKey.get(sourceKey);
+  if (!pending) {
     throw new Error(`Unknown source ${sourceKey}.`);
   }
-  return torrent;
+  return pending;
+}
+
+/**
+ * Fragments waiting for the main thread to say it has finished reading them,
+ * keyed by request id. One per read, because only one fragment is in flight.
+ *
+ * @type {Map<number, () => void>}
+ */
+const fragmentWaiters = new Map();
+
+/**
+ * Wake a read that is waiting for a fragment to be confirmed.
+ *
+ * Used both by the confirmation itself and by cancellation — a cancelled read
+ * will never be confirmed, and without this it would wait forever holding a pin.
+ *
+ * @param {number} id
+ * @returns {void}
+ */
+function settleFragment(id) {
+  const done = fragmentWaiters.get(id);
+  if (done) {
+    fragmentWaiters.delete(id);
+    done();
+  }
+}
+
+/**
+ * Send one fragment's position and wait until the main thread is done with it.
+ *
+ * The pin is dropped only after the confirmation, because until then the other
+ * thread may still be reading those exact bytes.
+ *
+ * @param {number} id
+ * @param {import("./piece-reader.js").PieceFragment} fragment
+ * @returns {Promise<void>}
+ */
+function sendFragment(id, fragment) {
+  return new Promise((resolve) => {
+    fragmentWaiters.set(id, () => {
+      fragment.release();
+      resolve();
+    });
+    parentPort.postMessage({
+      type: Event.FRAGMENT,
+      id,
+      pieceIndex: fragment.pieceIndex,
+      offset: fragment.offset,
+      length: fragment.length
+    });
+  });
 }
 
 /**
@@ -89,7 +154,7 @@ function requireTorrent(sourceKey) {
  * @returns {Promise<void>}
  */
 async function streamRange({ id, sourceKey, fileIndex, start, end }) {
-  const torrent = requireTorrent(sourceKey);
+  const torrent = await requireTorrent(sourceKey);
   const file = torrent.files?.[fileIndex];
   if (!file) {
     throw new Error(`File ${fileIndex} not found in ${sourceKey}.`);
@@ -107,39 +172,31 @@ async function streamRange({ id, sourceKey, fileIndex, start, end }) {
   // an empty input.
   const releaseRead = pool.acquireFile(torrent, fileIndex);
 
-  const options = start === null || start === undefined ? {} : { start, end };
-  const source = file.createReadStream(options);
-
-  // Coalesce WebTorrent's own chunking (piece-sized, often much smaller) up to
-  // our chunk size: a round trip costs ~100 µs, so sending its native pieces
-  // straight through would multiply the crossings for no benefit.
-  let pendingParts = [];
-  let pendingBytes = 0;
-
-  const flush = async () => {
-    if (pendingBytes === 0) {
-      return;
-    }
-    const merged = pendingParts.length === 1 ? pendingParts[0] : Buffer.concat(pendingParts, pendingBytes);
-    pendingParts = [];
-    pendingBytes = 0;
-    await sender.send(merged);
-  };
+  const rangeStart = start ?? 0;
+  const rangeEnd = end ?? file.length - 1;
 
   let failed = false;
   try {
-    for await (const part of source) {
+    // Positions in shared memory, not bytes: the main thread maps the same pool
+    // and reads each fragment in place, so nothing is copied and nothing is
+    // transferred. See `piece-reader.js`.
+    for await (const fragment of readFragments({
+      torrent,
+      fileIndex,
+      start: rangeStart,
+      end: rangeEnd,
+      cancellation: sender
+    })) {
       if (sender.isCancelled()) {
+        fragment.release();
         break;
       }
-      pendingParts.push(part);
-      pendingBytes += part.length;
-      if (pendingBytes >= STREAM_CHUNK_BYTES) {
-        await flush();
-      }
-    }
-    if (!sender.isCancelled()) {
-      await flush();
+      // One fragment in flight at a time. Each one holds a piece pinned, and
+      // the store guarantees only two resident pieces at its smallest budget —
+      // holding two pins while asking for a third would deadlock it against
+      // itself. The round trip costs ~100 µs against a piece worth megabytes,
+      // so there is nothing to win by overlapping them.
+      await sendFragment(id, fragment);
     }
   } catch (error) {
     // The end-of-read marker means "the body is complete". Sending it after a
@@ -151,15 +208,16 @@ async function streamRange({ id, sourceKey, fileIndex, start, end }) {
     throw error;
   } finally {
     readsById.delete(id);
+    // Any fragment still awaiting confirmation will never get one now; settling
+    // it here releases its pin rather than leaking a held slot.
+    settleFragment(id);
     releaseRead();
     if (!failed) {
       sender.end();
     }
-    // A cancelled read must stop the underlying torrent stream too, or the
-    // pieces keep being fetched for a viewer who has gone.
-    if (typeof source.destroy === "function") {
-      source.destroy();
-    }
+    // Nothing else to tear down: the reader owns no stream of its own, and a
+    // cancelled read stops at its next fragment boundary because it polls the
+    // same `sender` for cancellation.
   }
 }
 
@@ -174,11 +232,31 @@ async function streamRange({ id, sourceKey, fileIndex, start, end }) {
 async function runCommand(command, params, id) {
   switch (command) {
     case Command.ADD_SOURCE: {
-      const torrent = await pool.getTorrent(params.sourceType, params.source);
-      torrentsByKey.set(params.sourceKey, torrent);
+      // Registered before it resolves, so anything naming this source while it
+      // is being added waits for it instead of being told it does not exist.
+      // Reusing the same promise for a repeated add also collapses two callers
+      // racing to open the same torrent into one.
+      let pending = torrentsByKey.get(params.sourceKey);
+      if (!pending) {
+        pending = pool.getTorrent(params.sourceType, params.source);
+        torrentsByKey.set(params.sourceKey, pending);
+        // A failed add must not be remembered, or every later attempt at this
+        // source replays the same failure. The handler also marks the rejection
+        // as observed, so it cannot surface as an unhandled one.
+        pending.catch(() => {
+          if (torrentsByKey.get(params.sourceKey) === pending) {
+            torrentsByKey.delete(params.sourceKey);
+          }
+        });
+      }
+      const torrent = await pending;
       return {
         infoHash: torrent.infoHash,
         name: torrent.name,
+        // The piece pool itself. A `SharedArrayBuffer` crosses as a reference to
+        // the same memory rather than a copy, which is what lets the main thread
+        // read a piece where it already lies instead of being sent its bytes.
+        sharedBuffer: findSharedStore(torrent)?.sharedBuffer ?? null,
         // Files cross as plain data; the objects stay here.
         files: (torrent.files ?? []).map((file, index) => ({
           index,
@@ -190,7 +268,7 @@ async function runCommand(command, params, id) {
     }
 
     case Command.LIST_FILES: {
-      const torrent = requireTorrent(params.sourceKey);
+      const torrent = await requireTorrent(params.sourceKey);
       return (torrent.files ?? []).map((file, index) => ({
         index,
         name: file.name,
@@ -200,42 +278,42 @@ async function runCommand(command, params, id) {
     }
 
     case Command.ACQUIRE_FILE: {
-      const torrent = requireTorrent(params.sourceKey);
-      const claimKey = `${params.sourceKey}:${params.fileIndex}`;
-      // One claim per key; a second acquire without release would leak the
-      // first release callback and pin the file forever.
-      if (!releaseByClaim.has(claimKey)) {
-        releaseByClaim.set(claimKey, pool.acquireFile(torrent, params.fileIndex));
-      }
-      return true;
+      const torrent = await requireTorrent(params.sourceKey);
+      // Every acquire is its own claim. Sharing one per file meant the first
+      // reader to finish released the hold while others were still reading.
+      return fileClaims.open(
+        params.sourceKey,
+        params.fileIndex,
+        pool.acquireFile(torrent, params.fileIndex)
+      );
     }
 
     case Command.RELEASE_FILE: {
-      const claimKey = `${params.sourceKey}:${params.fileIndex}`;
-      const release = releaseByClaim.get(claimKey);
-      if (release) {
-        releaseByClaim.delete(claimKey);
-        release();
+      const released = fileClaims.close(params.claimId);
+      if (!released) {
+        // Not fatal — but it means a release arrived twice or after teardown,
+        // and silence here is what let the previous scheme look healthy.
+        log(`release for unknown file claim ${params.claimId}`);
       }
-      return true;
+      return released;
     }
 
     case Command.FILE_STATS: {
-      const torrent = requireTorrent(params.sourceKey);
+      const torrent = await requireTorrent(params.sourceKey);
       return pool.getFileStats(torrent, params.fileIndex, {
         resumeAnchorByteStart: params.resumeAnchorByteStart ?? null
       });
     }
 
     case Command.PRIORITIZE: {
-      const torrent = requireTorrent(params.sourceKey);
+      const torrent = await requireTorrent(params.sourceKey);
       pool.prioritizeByteRange(torrent, params.fileIndex, params.byteStart, params.windowBytes);
       return true;
     }
 
     case Command.PREFETCH_EDGES: {
-      const torrent = requireTorrent(params.sourceKey);
-      return pool.prefetchFileEdges(torrent, params.fileIndex, params.headBytes, params.tailBytes, params.timeoutMs);
+      const torrent = await requireTorrent(params.sourceKey);
+      return pool.prefetchFileEdges(torrent, params.fileIndex, params.options ?? {});
     }
 
     case Command.READ_RANGE: {
@@ -253,14 +331,14 @@ async function runCommand(command, params, id) {
 
     case Command.CANCEL_READ: {
       readsById.get(params.readId)?.cancel();
+      // A cancelled read will never have its outstanding fragment confirmed, so
+      // wake it here — otherwise it waits forever with a piece pinned.
+      settleFragment(params.readId);
       return true;
     }
 
     case Command.DESTROY_ALL: {
-      for (const [, release] of releaseByClaim) {
-        release();
-      }
-      releaseByClaim.clear();
+      fileClaims.closeAll();
       torrentsByKey.clear();
       await pool.destroyAll();
       return true;
@@ -279,6 +357,13 @@ parentPort.on("message", async (message) => {
     return;
   }
 
+  // The main thread has finished reading a fragment out of shared memory, so
+  // its piece may be unpinned and the read may continue.
+  if (message?.type === Event.FRAGMENT_DONE) {
+    settleFragment(message.id);
+    return;
+  }
+
   const { command, id, params } = message ?? {};
   try {
     const result = await runCommand(command, params ?? {}, id);

package/test/file-claims.test.js

@@ -0,0 +1,64 @@
+/**
+ * @file File claims must be held per reader, not per file.
+ *
+ * The proxy reads one file from several places at once — ffmpeg's input, the
+ * keyframe index, the codec probe, a second viewer. Keying claims by file made
+ * them shared, so the first reader to finish released the hold while the others
+ * were still reading, and the file's data could then be removed under them.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createFileClaims } from "../services/torrent-worker/file-claims.js";
+
+test("two readers of one file hold two claims", () => {
+  const claims = createFileClaims();
+  let released = 0;
+
+  const first = claims.open("source", 0, () => (released += 1));
+  const second = claims.open("source", 0, () => (released += 1));
+
+  assert.notEqual(first, second, "the second reader reused the first one's claim");
+  assert.equal(claims.size, 2);
+
+  claims.close(first);
+  assert.equal(released, 1, "closing one claim released more than one hold");
+  assert.equal(claims.size, 1, "the second reader's claim went with the first");
+
+  claims.close(second);
+  assert.equal(released, 2);
+  assert.equal(claims.size, 0);
+});
+
+test("a repeated release affects nothing and reports itself", () => {
+  const claims = createFileClaims();
+  let released = 0;
+  const claimId = claims.open("source", 3, () => (released += 1));
+
+  assert.equal(claims.close(claimId), true);
+  assert.equal(claims.close(claimId), false, "a second release was accepted as valid");
+  assert.equal(released, 1, "the hold was released twice");
+});
+
+test("a release naming nothing is rejected rather than guessed at", () => {
+  const claims = createFileClaims();
+  let released = 0;
+  claims.open("source", 0, () => (released += 1));
+
+  assert.equal(claims.close("source:0:999"), false);
+  assert.equal(released, 0, "an unknown claim released a real hold");
+  assert.equal(claims.size, 1);
+});
+
+test("teardown releases every outstanding claim", () => {
+  const claims = createFileClaims();
+  let released = 0;
+  claims.open("a", 0, () => (released += 1));
+  claims.open("a", 1, () => (released += 1));
+  claims.open("b", 0, () => (released += 1));
+
+  claims.closeAll();
+
+  assert.equal(released, 3);
+  assert.equal(claims.size, 0);
+});

package/test/piece-reader.test.js

@@ -0,0 +1,162 @@
+/**
+ * @file Turning a byte range into positions in shared memory.
+ *
+ * This arithmetic fails silently when it is wrong: the response comes back the
+ * right length and full of the wrong bytes. Piece numbers are torrent-wide
+ * while a read is expressed in file coordinates, and the first and last pieces
+ * of a range are almost always partial — so every case here is a boundary.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { readFragments } from "../services/torrent-worker/piece-reader.js";
+import { SharedPieceStore } from "../services/piece-store/shared-piece-store.js";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs/promises";
+
+const PIECE = 1024;
+
+/**
+ * A torrent whose pieces are all present, backed by a real store so that
+ * `locate`/`reside`/`pin` behave as they do in production.
+ *
+ * @param {{ fileOffset: number, fileLength: number, totalLength: number }} shape
+ */
+async function fakeTorrent({ fileOffset, fileLength, totalLength }) {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), "piece-reader-test-"));
+  const store = new SharedPieceStore(PIECE, {
+    length: totalLength,
+    memoryBytes: 64 * PIECE,
+    path: directory,
+    name: "test"
+  });
+
+  const pieceCount = Math.ceil(totalLength / PIECE);
+  for (let index = 0; index < pieceCount; index += 1) {
+    const length = index === pieceCount - 1 ? totalLength - index * PIECE : PIECE;
+    const piece = Buffer.alloc(length);
+    // Each byte encodes its own absolute position, so a misplaced offset is
+    // visible in the value itself rather than only in the length.
+    for (let at = 0; at < length; at += 1) {
+      piece[at] = (index * PIECE + at) % 251;
+    }
+    await new Promise((resolve, reject) => {
+      store.put(index, piece, (error) => (error ? reject(error) : resolve()));
+    });
+  }
+
+  const torrent = Object.assign(new EventEmitter(), {
+    pieceLength: PIECE,
+    store,
+    bitfield: { get: () => true },
+    files: [{ offset: fileOffset, length: fileLength, name: "file.bin" }],
+    select() {},
+    critical() {}
+  });
+
+  return { torrent, store, directory };
+}
+
+/** Collect a range through the reader, as the worker does. */
+async function readRange(torrent, start, end) {
+  const collected = [];
+  const positions = [];
+  const pool = Buffer.from(torrent.store.sharedBuffer);
+  for await (const fragment of readFragments({
+    torrent,
+    fileIndex: 0,
+    start,
+    end,
+    cancellation: { isCancelled: () => false }
+  })) {
+    collected.push(Buffer.from(pool.subarray(fragment.offset, fragment.offset + fragment.length)));
+    positions.push({ piece: fragment.pieceIndex, length: fragment.length });
+    fragment.release();
+  }
+  return { bytes: Buffer.concat(collected), positions };
+}
+
+/** What the bytes at an absolute torrent offset should be. */
+function expectedBytes(absoluteStart, length) {
+  const expected = Buffer.alloc(length);
+  for (let at = 0; at < length; at += 1) {
+    expected[at] = (absoluteStart + at) % 251;
+  }
+  return expected;
+}
+
+test("a range inside one piece is read from that piece only", async () => {
+  const { torrent, store, directory } = await fakeTorrent({
+    fileOffset: 0,
+    fileLength: 4 * PIECE,
+    totalLength: 4 * PIECE
+  });
+  try {
+    const { bytes, positions } = await readRange(torrent, 100, 199);
+    assert.equal(positions.length, 1);
+    assert.deepEqual(bytes, expectedBytes(100, 100));
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a range spanning pieces reassembles in order", async () => {
+  const { torrent, store, directory } = await fakeTorrent({
+    fileOffset: 0,
+    fileLength: 4 * PIECE,
+    totalLength: 4 * PIECE
+  });
+  try {
+    const start = PIECE - 10;
+    const end = 2 * PIECE + 9;
+    const { bytes, positions } = await readRange(torrent, start, end);
+    assert.deepEqual(positions.map((entry) => entry.piece), [0, 1, 2]);
+    assert.deepEqual(bytes, expectedBytes(start, end - start + 1));
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("a file that does not start at a piece boundary is still read correctly", async () => {
+  // The usual case in a multi-file torrent, and the one where using file
+  // offsets as if they were torrent offsets returns the wrong bytes at the
+  // right length.
+  const fileOffset = PIECE + 300;
+  const { torrent, store, directory } = await fakeTorrent({
+    fileOffset,
+    fileLength: 2 * PIECE,
+    totalLength: 5 * PIECE
+  });
+  try {
+    const { bytes } = await readRange(torrent, 0, 1499);
+    assert.deepEqual(bytes, expectedBytes(fileOffset, 1500));
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});
+
+test("every fragment releases its pin, so nothing stays held", async () => {
+  const { torrent, store, directory } = await fakeTorrent({
+    fileOffset: 0,
+    fileLength: 4 * PIECE,
+    totalLength: 4 * PIECE
+  });
+  try {
+    await readRange(torrent, 0, 4 * PIECE - 1);
+    // With every piece unpinned the store can still make room; if a pin leaked
+    // it would eventually refuse.
+    const before = store.stats().blockedByPins;
+    for (let index = 0; index < 200; index += 1) {
+      await store.reside(index % 4);
+    }
+    assert.equal(store.stats().blockedByPins, before, "a pin was left behind");
+  } finally {
+    store.destroy(() => undefined);
+    await fs.rm(directory, { recursive: true, force: true });
+  }
+});

package/test/stream-route.test.js

@@ -0,0 +1,121 @@
+/**
+ * @file What `/stream` does with a HEAD request.
+ *
+ * Fastify answers HEAD from the GET handler, so without an explicit branch a
+ * HEAD started a read of the entire file. Node discards the body, but the read
+ * itself runs on and the response never completes, which blocks the next
+ * request on that keep-alive connection. The keyframe index asks for the file
+ * size with exactly such a HEAD before every transcode session.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { handleStreamGet } from "../routes/stream/get.js";
+
+/**
+ * Minimal stand-ins for the parts of Fastify and the pool this route touches.
+ *
+ * @param {{ method: string, range?: string }} request
+ * @returns {{ req: object, reply: object, sent: object, opened: string[], claims: number }}
+ */
+function harness({ method, range }) {
+  const opened = [];
+  const state = { claims: 0 };
+
+  const sent = { code: 200, headers: {}, body: undefined, called: false };
+  const reply = {
+    code(value) {
+      sent.code = value;
+      return reply;
+    },
+    header(name, value) {
+      sent.headers[name.toLowerCase()] = value;
+      return reply;
+    },
+    send(body) {
+      sent.called = true;
+      sent.body = body;
+      return reply;
+    },
+    hijack() {
+      sent.hijacked = true;
+    },
+    raw: {
+      // `bindRelease` listens here; HEAD writes its response here.
+      once() {},
+      writeHead(code, headers) {
+        sent.code = code;
+        for (const [name, value] of Object.entries(headers)) {
+          sent.headers[name.toLowerCase()] = value;
+        }
+      },
+      end() {
+        sent.called = true;
+      }
+    }
+  };
+
+  const file = {
+    name: "movie.mkv",
+    length: 5_869_669_065,
+    createReadStream(options = {}) {
+      opened.push(`${options.start ?? 0}-${options.end ?? "end"}`);
+      return { on() {} };
+    }
+  };
+
+  const torrentPool = {
+    async getTorrent() {
+      return { files: [file], sourceKey: "key" };
+    },
+    acquireFile() {
+      state.claims += 1;
+      return () => undefined;
+    },
+    prioritizeByteRange() {}
+  };
+
+  const req = {
+    method,
+    query: { sourceType: "magnet", source: "magnet:?xt=urn:btih:abc", fileIndex: "0" },
+    headers: range ? { range } : {},
+    raw: { once() {} }
+  };
+
+  return { req, reply, sent, opened, state, deps: { sourceRegistry: { get: () => null }, torrentPool } };
+}
+
+test("HEAD reports the size without opening a read", async () => {
+  const { req, reply, sent, opened, state, deps } = harness({ method: "HEAD" });
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.deepEqual(opened, [], "HEAD started a read of the file");
+  assert.equal(state.claims, 0, "HEAD claimed the file it never read");
+  // The real size, not the zero Fastify substitutes for an empty payload — the
+  // keyframe index reads this header and treats 0 as "no index".
+  assert.equal(sent.headers["content-length"], "5869669065");
+  assert.equal(sent.headers["accept-ranges"], "bytes");
+  assert.equal(sent.called, true, "HEAD never completed its response");
+  assert.equal(sent.body, undefined, "HEAD answered with a body");
+});
+
+test("GET still streams the bytes", async () => {
+  const { req, reply, sent, opened, deps } = harness({ method: "GET" });
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.equal(opened.length, 1, "GET did not open a read");
+  assert.equal(sent.headers["content-length"], "5869669065");
+});
+
+test("GET with a range streams only that range", async () => {
+  const { req, reply, sent, opened, deps } = harness({ method: "GET", range: "bytes=100-199" });
+
+  await handleStreamGet(req, reply, deps);
+
+  assert.deepEqual(opened, ["100-199"]);
+  assert.equal(sent.code, 206);
+  assert.equal(sent.headers["content-range"], "bytes 100-199/5869669065");
+  assert.equal(sent.headers["content-length"], "100");
+});