@torrent-tv/proxy 2.88.3 → 2.88.4

package/routes/api/delivery-sink/get.js

@@ -1,72 +1,72 @@
-/**
- * A stream of bytes with no torrent behind it, for measuring delivery alone.
- *
- * GET /api/delivery-sink?bytes=8388608
- *
- * The delivery freeze (roadmap item 11) takes hundreds of megabytes to appear
- * and needs the real transport to appear at all, so reproducing it means
- * pushing gigabytes through a data channel on demand. Doing that through a real
- * file drags in the swarm, the encoder and the disk, none of which is under
- * test and each of which has its own stalls; this route removes them and leaves
- * the path the question is about: the same handler, the same chunk loop, the
- * same backpressure, the same channel.
- *
- * The body is a repeating pattern rather than zeroes, so a receiver can verify
- * it got the bytes it was promised in the order they were sent — a silent
- * truncation would otherwise read as a successful transfer.
- *
- * Enabled only when the proxy was started with `--delivery-sink`; without the
- * flag the route answers 404, so an ordinary install has no such endpoint.
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ enabled: boolean }} deps
- * @returns {Promise<void>}
- */
-export async function handleApiDeliverySinkGet(req, reply, { enabled } = {}) {
-  if (enabled !== true) {
-    return reply.code(404).send({ error: "Not found." });
-  }
-
-  const requested = Number((req.query ?? {}).bytes);
-  const total = Number.isFinite(requested)
-    ? Math.min(Math.max(Math.trunc(requested), 0), MAX_SINK_BYTES)
-    : DEFAULT_SINK_BYTES;
-  const requestedChunk = Number((req.query ?? {}).chunkBytes);
-  const chunkBytes = Number.isFinite(requestedChunk)
-    ? Math.min(Math.max(Math.trunc(requestedChunk), 1024), CHUNK_BYTES)
-    : CHUNK_BYTES;
-
-  // One buffer, reused: allocating a fresh chunk per iteration would make this
-  // route measure the allocator as much as the transport.
-  const chunk = Buffer.alloc(chunkBytes);
-  for (let i = 0; i < chunkBytes; i += 1) {
-    chunk[i] = i % 251; // 251 is prime, so the pattern does not align to any power of two.
-  }
-
-  reply.header("content-type", "application/octet-stream");
-  reply.header("content-length", String(total));
-  reply.header("cache-control", "no-store");
-
-  let sent = 0;
-  const stream = new ReadableStream({
-    pull(controller) {
-      if (sent >= total) {
-        controller.close();
-        return;
-      }
-      const size = Math.min(chunkBytes, total - sent);
-      controller.enqueue(size === chunkBytes ? chunk : chunk.subarray(0, size));
-      sent += size;
-    }
-  });
-
-  return reply.send(stream);
-}
-
-/** Chunk size, matching what a body read hands the send loop for a real file. */
-const CHUNK_BYTES = 64 * 1024;
-/** Default when no size is asked for: about one segment of 1080p. */
-const DEFAULT_SINK_BYTES = 8 * 1024 * 1024;
-/** Ceiling, so one request cannot ask the proxy for an unbounded stream. */
-const MAX_SINK_BYTES = 64 * 1024 * 1024;
+/**
+ * A stream of bytes with no torrent behind it, for measuring delivery alone.
+ *
+ * GET /api/delivery-sink?bytes=8388608
+ *
+ * The delivery freeze (roadmap item 11) takes hundreds of megabytes to appear
+ * and needs the real transport to appear at all, so reproducing it means
+ * pushing gigabytes through a data channel on demand. Doing that through a real
+ * file drags in the swarm, the encoder and the disk, none of which is under
+ * test and each of which has its own stalls; this route removes them and leaves
+ * the path the question is about: the same handler, the same chunk loop, the
+ * same backpressure, the same channel.
+ *
+ * The body is a repeating pattern rather than zeroes, so a receiver can verify
+ * it got the bytes it was promised in the order they were sent — a silent
+ * truncation would otherwise read as a successful transfer.
+ *
+ * Enabled only when the proxy was started with `--delivery-sink`; without the
+ * flag the route answers 404, so an ordinary install has no such endpoint.
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ enabled: boolean }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleApiDeliverySinkGet(req, reply, { enabled } = {}) {
+  if (enabled !== true) {
+    return reply.code(404).send({ error: "Not found." });
+  }
+
+  const requested = Number((req.query ?? {}).bytes);
+  const total = Number.isFinite(requested)
+    ? Math.min(Math.max(Math.trunc(requested), 0), MAX_SINK_BYTES)
+    : DEFAULT_SINK_BYTES;
+  const requestedChunk = Number((req.query ?? {}).chunkBytes);
+  const chunkBytes = Number.isFinite(requestedChunk)
+    ? Math.min(Math.max(Math.trunc(requestedChunk), 1024), CHUNK_BYTES)
+    : CHUNK_BYTES;
+
+  // One buffer, reused: allocating a fresh chunk per iteration would make this
+  // route measure the allocator as much as the transport.
+  const chunk = Buffer.alloc(chunkBytes);
+  for (let i = 0; i < chunkBytes; i += 1) {
+    chunk[i] = i % 251; // 251 is prime, so the pattern does not align to any power of two.
+  }
+
+  reply.header("content-type", "application/octet-stream");
+  reply.header("content-length", String(total));
+  reply.header("cache-control", "no-store");
+
+  let sent = 0;
+  const stream = new ReadableStream({
+    pull(controller) {
+      if (sent >= total) {
+        controller.close();
+        return;
+      }
+      const size = Math.min(chunkBytes, total - sent);
+      controller.enqueue(size === chunkBytes ? chunk : chunk.subarray(0, size));
+      sent += size;
+    }
+  });
+
+  return reply.send(stream);
+}
+
+/** Chunk size, matching what a body read hands the send loop for a real file. */
+const CHUNK_BYTES = 64 * 1024;
+/** Default when no size is asked for: about one segment of 1080p. */
+const DEFAULT_SINK_BYTES = 8 * 1024 * 1024;
+/** Ceiling, so one request cannot ask the proxy for an unbounded stream. */
+const MAX_SINK_BYTES = 64 * 1024 * 1024;

package/routes/api/link-probe/get.js

@@ -1,51 +1,51 @@
-/**
- * @file `GET /api/link-probe?bytes=N` — bytes to measure the link with.
- *
- * WHY THIS EXISTS. A viewer's link is measured from completed transfers, and
- * the only transfers that counted were segments of the film. So the figure came
- * into being after playback had begun — after the quality offer had been made,
- * and after the start-up decisions that want it. Worse, the page's report of
- * its OWN facts was skipped when there was no figure, so at a cold open — the
- * moment where where-the-viewer-is matters most — the page said nothing at all
- * (2026-09-14).
- *
- * There is nothing to wait for: a proxy can send bytes the moment its channel
- * is up, which is when the page opens rather than when a film is chosen.
- *
- * NOT `delivery-sink`, which is the load stand's and answers any size asked
- * for. This is part of the product, always on, and bounded — the browser's own
- * sizing stops at 2 MiB and this refuses more, so a caller cannot turn it into
- * a way of drawing a proxy owner's uplink.
- *
- * The body is zeros. What is being measured is the wire, and zeros cross it at
- * the same speed as anything else; producing them costs one allocation.
- */
-
-/**
- * The most this route will send for one ask.
- *
- * The figure is only ever used to decide what a link can carry, and the most
- * anything this product offers is a 1080p rung at around 12 Mbit/s. Two
- * mebibytes inside the browser's minimum measurable transfer (50 ms) is
- * 336 Mbit/s, twenty-eight times that rung: a link too fast to time at this
- * size is beyond anything a decision here distinguishes.
- */
-export const MAX_LINK_PROBE_BYTES = 2 * 1024 * 1024;
-
-/**
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @returns {Promise<void>}
- */
-export async function handleApiLinkProbeGet(req, reply) {
-  const asked = Number(/** @type {{ bytes?: string }} */ (req.query)?.bytes);
-  if (!Number.isFinite(asked) || asked <= 0) {
-    return reply.code(400).send({ error: "bytes (>0) is required." });
-  }
-  const bytes = Math.min(Math.floor(asked), MAX_LINK_PROBE_BYTES);
-  return reply
-    .code(200)
-    .header("Content-Type", "application/octet-stream")
-    .header("Cache-Control", "no-store")
-    .send(Buffer.alloc(bytes));
-}
+/**
+ * @file `GET /api/link-probe?bytes=N` — bytes to measure the link with.
+ *
+ * WHY THIS EXISTS. A viewer's link is measured from completed transfers, and
+ * the only transfers that counted were segments of the film. So the figure came
+ * into being after playback had begun — after the quality offer had been made,
+ * and after the start-up decisions that want it. Worse, the page's report of
+ * its OWN facts was skipped when there was no figure, so at a cold open — the
+ * moment where where-the-viewer-is matters most — the page said nothing at all
+ * (2026-09-14).
+ *
+ * There is nothing to wait for: a proxy can send bytes the moment its channel
+ * is up, which is when the page opens rather than when a film is chosen.
+ *
+ * NOT `delivery-sink`, which is the load stand's and answers any size asked
+ * for. This is part of the product, always on, and bounded — the browser's own
+ * sizing stops at 2 MiB and this refuses more, so a caller cannot turn it into
+ * a way of drawing a proxy owner's uplink.
+ *
+ * The body is zeros. What is being measured is the wire, and zeros cross it at
+ * the same speed as anything else; producing them costs one allocation.
+ */
+
+/**
+ * The most this route will send for one ask.
+ *
+ * The figure is only ever used to decide what a link can carry, and the most
+ * anything this product offers is a 1080p rung at around 12 Mbit/s. Two
+ * mebibytes inside the browser's minimum measurable transfer (50 ms) is
+ * 336 Mbit/s, twenty-eight times that rung: a link too fast to time at this
+ * size is beyond anything a decision here distinguishes.
+ */
+export const MAX_LINK_PROBE_BYTES = 2 * 1024 * 1024;
+
+/**
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @returns {Promise<void>}
+ */
+export async function handleApiLinkProbeGet(req, reply) {
+  const asked = Number(/** @type {{ bytes?: string }} */ (req.query)?.bytes);
+  if (!Number.isFinite(asked) || asked <= 0) {
+    return reply.code(400).send({ error: "bytes (>0) is required." });
+  }
+  const bytes = Math.min(Math.floor(asked), MAX_LINK_PROBE_BYTES);
+  return reply
+    .code(200)
+    .header("Content-Type", "application/octet-stream")
+    .header("Cache-Control", "no-store")
+    .send(Buffer.alloc(bytes));
+}

package/routes/api/playback-plan/audio-tracks/post.js

@@ -1,29 +1,29 @@
-/**
- * Refresh metadata for audio tracks whose sidecar headers were unavailable
- * when the playback plan was built.
- *
- * POST /api/playback-plan/audio-tracks
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ playbackPlanner: object }} deps
- */
-export async function handleApiPlaybackPlanAudioTracksPost(req, reply, { playbackPlanner }) {
-  const payload = req.body && typeof req.body === "object" && !Array.isArray(req.body) ? req.body : {};
-  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
-  const fileIndex = Number(payload.fileIndex);
-  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
-    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
-  }
-  try {
-    const { PlaybackController } = await import("../../../../services/server/controllers/PlaybackController.js");
-    const controller = new PlaybackController({ playbackPlanner });
-    return reply.send(await controller.refreshAudioTracks({ sourceKey, fileIndex }));
-  } catch (error) {
-    if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
-      return reply.code(404).send({ error: error.message });
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return reply.code(500).send({ error: `Failed to refresh audio track metadata: ${message}` });
-  }
-}
+/**
+ * Refresh metadata for audio tracks whose sidecar headers were unavailable
+ * when the playback plan was built.
+ *
+ * POST /api/playback-plan/audio-tracks
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ playbackPlanner: object }} deps
+ */
+export async function handleApiPlaybackPlanAudioTracksPost(req, reply, { playbackPlanner }) {
+  const payload = req.body && typeof req.body === "object" && !Array.isArray(req.body) ? req.body : {};
+  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
+  const fileIndex = Number(payload.fileIndex);
+  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
+    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
+  }
+  try {
+    const { PlaybackController } = await import("../../../../services/server/controllers/PlaybackController.js");
+    const controller = new PlaybackController({ playbackPlanner });
+    return reply.send(await controller.refreshAudioTracks({ sourceKey, fileIndex }));
+  } catch (error) {
+    if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
+      return reply.code(404).send({ error: error.message });
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return reply.code(500).send({ error: `Failed to refresh audio track metadata: ${message}` });
+  }
+}

package/routes/api/playback-plan/post.js

@@ -1,53 +1,53 @@
-/**
- * Determine the best playback mode (direct stream or HLS transcode) for a
- * torrent file and return the corresponding plan.
- *
- * POST /api/playback-plan
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ playbackPlanner: ReturnType<import("../../../services/media/playback-planner.js").createPlaybackPlanner> }} deps
- * @returns {Promise<void>}
- */
-
-/**
- * Extract a plain object from the request body, guarding against
- * non-object payloads (arrays, primitives, null).
- *
- * @param {unknown} body
- * @returns {Record<string, unknown>}
- */
-function getPayload(body) {
-  if (body && typeof body === "object" && !Array.isArray(body)) {
-    return body;
-  }
-  return {};
-}
-
-export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl }) {
-  const payload = getPayload(req.body);
-  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
-  const fileIndex = Number(payload.fileIndex);
-  const userAgent = typeof payload.userAgent === "string" ? payload.userAgent : "";
-
-  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
-    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
-  }
-
-  // Interface delegates to PlaybackController (orchestrator + domain). Keeps route thin.
-  const { PlaybackController } = await import("../../../services/server/controllers/PlaybackController.js");
-  const controller = new PlaybackController({ torrentPool, sourceRegistry, ffmpegBin, localBaseUrl, playbackPlanner });
-  try {
-    const plan = await controller.getPlan({ sourceKey, fileIndex, userAgent, maxWaitMs: 8_000 });
-    return reply.send(plan);
-  } catch (error) {
-    if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
-      return reply.code(404).send({ error: error.message });
-    }
-    if (error instanceof Error && error.code === "FILE_NOT_FOUND") {
-      return reply.code(404).send({ error: error.message });
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return reply.code(500).send({ error: `Failed to prepare playback plan: ${message}` });
-  }
-}
+/**
+ * Determine the best playback mode (direct stream or HLS transcode) for a
+ * torrent file and return the corresponding plan.
+ *
+ * POST /api/playback-plan
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ playbackPlanner: ReturnType<import("../../../services/media/playback-planner.js").createPlaybackPlanner> }} deps
+ * @returns {Promise<void>}
+ */
+
+/**
+ * Extract a plain object from the request body, guarding against
+ * non-object payloads (arrays, primitives, null).
+ *
+ * @param {unknown} body
+ * @returns {Record<string, unknown>}
+ */
+function getPayload(body) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    return body;
+  }
+  return {};
+}
+
+export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl }) {
+  const payload = getPayload(req.body);
+  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
+  const fileIndex = Number(payload.fileIndex);
+  const userAgent = typeof payload.userAgent === "string" ? payload.userAgent : "";
+
+  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
+    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
+  }
+
+  // Interface delegates to PlaybackController (orchestrator + domain). Keeps route thin.
+  const { PlaybackController } = await import("../../../services/server/controllers/PlaybackController.js");
+  const controller = new PlaybackController({ torrentPool, sourceRegistry, ffmpegBin, localBaseUrl, playbackPlanner });
+  try {
+    const plan = await controller.getPlan({ sourceKey, fileIndex, userAgent, maxWaitMs: 8_000 });
+    return reply.send(plan);
+  } catch (error) {
+    if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
+      return reply.code(404).send({ error: error.message });
+    }
+    if (error instanceof Error && error.code === "FILE_NOT_FOUND") {
+      return reply.code(404).send({ error: error.message });
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return reply.code(500).send({ error: `Failed to prepare playback plan: ${message}` });
+  }
+}

package/routes/api/sources/post.js

@@ -1,36 +1,36 @@
-/**
- * Register a torrent source with the proxy and receive a stable source key.
- *
- * POST /api/sources
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ sourceRegistry: ReturnType<import("../../../store/source-registry.js").createSourceRegistry> }} deps
- * @returns {Promise<void>}
- */
-
-/**
- * Extract a plain object from the request body, guarding against
- * non-object payloads (arrays, primitives, null).
- *
- * @param {unknown} body
- * @returns {Record<string, unknown>}
- */
-function getPayload(body) {
-  if (body && typeof body === "object" && !Array.isArray(body)) {
-    return body;
-  }
-  return {};
-}
-
-export async function handleApiSourcesPost(req, reply, { sourceRegistry }) {
-  const payload = getPayload(req.body);
-  const sourceType = typeof payload.sourceType === "string" ? payload.sourceType : "";
-  const source = typeof payload.source === "string" ? payload.source : "";
-  if (!sourceType || !source) {
-    return reply.code(400).send({ error: "sourceType and source are required." });
-  }
-
-  const sourceKey = await sourceRegistry.upsert(sourceType, source);
-  return reply.send({ sourceKey });
-}
+/**
+ * Register a torrent source with the proxy and receive a stable source key.
+ *
+ * POST /api/sources
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ sourceRegistry: ReturnType<import("../../../store/source-registry.js").createSourceRegistry> }} deps
+ * @returns {Promise<void>}
+ */
+
+/**
+ * Extract a plain object from the request body, guarding against
+ * non-object payloads (arrays, primitives, null).
+ *
+ * @param {unknown} body
+ * @returns {Record<string, unknown>}
+ */
+function getPayload(body) {
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    return body;
+  }
+  return {};
+}
+
+export async function handleApiSourcesPost(req, reply, { sourceRegistry }) {
+  const payload = getPayload(req.body);
+  const sourceType = typeof payload.sourceType === "string" ? payload.sourceType : "";
+  const source = typeof payload.source === "string" ? payload.source : "";
+  if (!sourceType || !source) {
+    return reply.code(400).send({ error: "sourceType and source are required." });
+  }
+
+  const sourceKey = await sourceRegistry.upsert(sourceType, source);
+  return reply.send({ sourceKey });
+}