@torrent-tv/proxy 2.87.7 → 2.87.8

package/routes/transcode/audio-file/get.js

@@ -1,64 +1,64 @@
-/**
- * @file GET /transcode/:sessionId/a/:trackIndex/:fileName — one file of an audio
- * rendition.
- *
- * A rendition is one audio track of the file, encoded once and shared by every
- * quality rung, published in the master playlist as `#EXT-X-MEDIA`. It is an
- * ordinary session underneath, living one directory level below the base
- * session so every relative name inside its playlist resolves to it unchanged —
- * the same arrangement quality variants use.
- *
- * Unlike a variant, a rendition is fetched ALONGSIDE the picture rather than
- * instead of it: both encoders run, one for the rung and one for the audio.
- */
-
-import { consumerOf, refusedAsStale, serveSessionFile } from "../../../services/server/transcode-session-files.js";
-
-/**
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
- * @returns {Promise<void>}
- */
-export async function handleTranscodeAudioFileGet(req, reply, { renditions, serving, viewerRequests }) {
-  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const trackIndex = Number(req.params.trackIndex);
-  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
-
-  // Which viewer is asking. One picture serves everyone watching it, and the
-  // soundtrack each of them chose is their own: without this, a segment request
-  // from one viewer would be read as everybody moving to that track, and the
-  // other viewer's encoder would be stopped once per segment.
-  const consumerId = consumerOf(req);
-  // Before resolving, for the same reason as a step's: resolving can make the
-  // soundtrack and registers this viewer on it. A soundtrack keeps no record of
-  // what answered a repeat — it is not a height — but a request for a viewing
-  // that has been left is refused here like any other, and the response that
-  // does go out holds its output while it is being sent (`serveSessionFile`).
-  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
-    return reply;
-  }
-  const resolved = await renditions.resolveAudioRenditionFile(
-    baseSessionId,
-    trackIndex,
-    fileName,
-    consumerId
-  );
-  if (resolved.error) {
-    // Retryable, like every other not-ready answer on this path: a 500 for a
-    // rendition playlist would end the stream over something the next attempt
-    // may well get past.
-    reply.header("Retry-After", "1");
-    return reply.code(503).send({ error: `Could not prepare the audio rendition: ${resolved.error}` });
-  }
-  if (!resolved.sessionId) {
-    return reply.code(404).send({ error: "No such audio rendition for this transcode session." });
-  }
-
-  return serveSessionFile(req, reply, {
-    serving,
-    viewerRequests,
-    sessionId: resolved.sessionId,
-    fileName
-  });
-}
+/**
+ * @file GET /transcode/:sessionId/a/:trackIndex/:fileName — one file of an audio
+ * rendition.
+ *
+ * A rendition is one audio track of the file, encoded once and shared by every
+ * quality rung, published in the master playlist as `#EXT-X-MEDIA`. It is an
+ * ordinary session underneath, living one directory level below the base
+ * session so every relative name inside its playlist resolves to it unchanged —
+ * the same arrangement quality variants use.
+ *
+ * Unlike a variant, a rendition is fetched ALONGSIDE the picture rather than
+ * instead of it: both encoders run, one for the rung and one for the audio.
+ */
+
+import { consumerOf, refusedAsStale, serveSessionFile } from "../../../services/server/transcode-session-files.js";
+
+/**
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleTranscodeAudioFileGet(req, reply, { renditions, serving, viewerRequests }) {
+  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  const trackIndex = Number(req.params.trackIndex);
+  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
+
+  // Which viewer is asking. One picture serves everyone watching it, and the
+  // soundtrack each of them chose is their own: without this, a segment request
+  // from one viewer would be read as everybody moving to that track, and the
+  // other viewer's encoder would be stopped once per segment.
+  const consumerId = consumerOf(req);
+  // Before resolving, for the same reason as a step's: resolving can make the
+  // soundtrack and registers this viewer on it. A soundtrack keeps no record of
+  // what answered a repeat — it is not a height — but a request for a viewing
+  // that has been left is refused here like any other, and the response that
+  // does go out holds its output while it is being sent (`serveSessionFile`).
+  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
+    return reply;
+  }
+  const resolved = await renditions.resolveAudioRenditionFile(
+    baseSessionId,
+    trackIndex,
+    fileName,
+    consumerId
+  );
+  if (resolved.error) {
+    // Retryable, like every other not-ready answer on this path: a 500 for a
+    // rendition playlist would end the stream over something the next attempt
+    // may well get past.
+    reply.header("Retry-After", "1");
+    return reply.code(503).send({ error: `Could not prepare the audio rendition: ${resolved.error}` });
+  }
+  if (!resolved.sessionId) {
+    return reply.code(404).send({ error: "No such audio rendition for this transcode session." });
+  }
+
+  return serveSessionFile(req, reply, {
+    serving,
+    viewerRequests,
+    sessionId: resolved.sessionId,
+    fileName
+  });
+}

package/routes/transcode/audio-warm/get.js

@@ -1,84 +1,84 @@
-/**
- * @file GET /transcode/:sessionId/a/:track/warm?position=<seconds> — prepare an
- * audio track before the player is told to change to it.
- *
- * The picture keeps playing while a quality rung is warmed (`variant-warm`),
- * and a track change deserves the same: the player discards the audio it holds
- * the moment it switches and cannot show a frame until the new track covers the
- * playhead, so switching first and producing second shows the track's cold
- * start as a spinner over a stopped picture (measured 2026-08-15).
- *
- * Answers 204 when the segment at that position is ready, so the caller can
- * switch into bytes that already exist; 503 while it is still being made.
- */
-
-import { waitForSessionFile } from "../../../services/server/transcode-session-files.js";
-
-/** How long to hold the request before telling the caller to retry. */
-const WARM_WAIT_MS = 12_000;
-
-/**
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
- */
-export async function handleTranscodeAudioWarmGet(req, reply, { renditions, serving, viewerRequests }) {
-  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const trackIndex = Number(req.params.track);
-  const positionSeconds = Number(req.query?.position);
-
-  if (
-    !Number.isInteger(trackIndex) ||
-    trackIndex < 0 ||
-    !Number.isFinite(positionSeconds) ||
-    positionSeconds < 0
-  ) {
-    return reply.code(400).send({ error: "A track index and a non-negative position are required." });
-  }
-
-  // Whose track change this is. Another viewer of the same picture may be
-  // listening to something else, and preparing a track must not be read as
-  // everybody moving to it.
-  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  if (!consumerId) {
-    return reply.code(400).send({ error: "A consumer is required." });
-  }
-
-  let prepared;
-  try {
-    prepared = await renditions.prepareAudioTrack(
-      baseSessionId,
-      trackIndex,
-      positionSeconds,
-      consumerId
-    );
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    reply.header("Retry-After", "1");
-    return reply.code(503).send({ error: `Could not prepare the audio track: ${message}` });
-  }
-  if (!prepared) {
-    return reply.code(404).send({ error: "No such audio track for this transcode session." });
-  }
-
-  const result = await waitForSessionFile(
-    serving,
-    prepared.sessionId,
-    prepared.fileName,
-    { holdMs: WARM_WAIT_MS }
-  );
-  if (result.kind === "file") {
-    // The bytes are the player's to fetch; the handle opened to reach them is
-    // ours to close, or a long-running proxy walks to EMFILE one track change
-    // at a time.
-    result.stream?.destroy?.();
-    return reply.code(204).send();
-  }
-  if (result.kind === "failed") {
-    return reply.code(500).send({ error: result.message });
-  }
-  // Still being produced. The caller may switch anyway — it will wait where it
-  // would have waited before — or ask again.
-  reply.header("Retry-After", "1");
-  return reply.code(503).send({ error: "The audio track is still warming up." });
-}
+/**
+ * @file GET /transcode/:sessionId/a/:track/warm?position=<seconds> — prepare an
+ * audio track before the player is told to change to it.
+ *
+ * The picture keeps playing while a quality rung is warmed (`variant-warm`),
+ * and a track change deserves the same: the player discards the audio it holds
+ * the moment it switches and cannot show a frame until the new track covers the
+ * playhead, so switching first and producing second shows the track's cold
+ * start as a spinner over a stopped picture (measured 2026-08-15).
+ *
+ * Answers 204 when the segment at that position is ready, so the caller can
+ * switch into bytes that already exist; 503 while it is still being made.
+ */
+
+import { waitForSessionFile } from "../../../services/server/transcode-session-files.js";
+
+/** How long to hold the request before telling the caller to retry. */
+const WARM_WAIT_MS = 12_000;
+
+/**
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
+ */
+export async function handleTranscodeAudioWarmGet(req, reply, { renditions, serving, viewerRequests }) {
+  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  const trackIndex = Number(req.params.track);
+  const positionSeconds = Number(req.query?.position);
+
+  if (
+    !Number.isInteger(trackIndex) ||
+    trackIndex < 0 ||
+    !Number.isFinite(positionSeconds) ||
+    positionSeconds < 0
+  ) {
+    return reply.code(400).send({ error: "A track index and a non-negative position are required." });
+  }
+
+  // Whose track change this is. Another viewer of the same picture may be
+  // listening to something else, and preparing a track must not be read as
+  // everybody moving to it.
+  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
+  if (!consumerId) {
+    return reply.code(400).send({ error: "A consumer is required." });
+  }
+
+  let prepared;
+  try {
+    prepared = await renditions.prepareAudioTrack(
+      baseSessionId,
+      trackIndex,
+      positionSeconds,
+      consumerId
+    );
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    reply.header("Retry-After", "1");
+    return reply.code(503).send({ error: `Could not prepare the audio track: ${message}` });
+  }
+  if (!prepared) {
+    return reply.code(404).send({ error: "No such audio track for this transcode session." });
+  }
+
+  const result = await waitForSessionFile(
+    serving,
+    prepared.sessionId,
+    prepared.fileName,
+    { holdMs: WARM_WAIT_MS }
+  );
+  if (result.kind === "file") {
+    // The bytes are the player's to fetch; the handle opened to reach them is
+    // ours to close, or a long-running proxy walks to EMFILE one track change
+    // at a time.
+    result.stream?.destroy?.();
+    return reply.code(204).send();
+  }
+  if (result.kind === "failed") {
+    return reply.code(500).send({ error: result.message });
+  }
+  // Still being produced. The caller may switch anyway — it will wait where it
+  // would have waited before — or ask again.
+  reply.header("Retry-After", "1");
+  return reply.code(503).send({ error: "The audio track is still warming up." });
+}

package/routes/transcode/session-file/get.js

@@ -1,52 +1,52 @@
-import {
-  consumerOf,
-  refusedAsStale,
-  serveSessionFile,
-  statedGenerationOf
-} from "../../../services/server/transcode-session-files.js";
-
-/**
- * How long a request for a file not yet produced is held: AS LONG AS THE
- * REQUESTER SAYS IT WILL WAIT, and no longer than it stays.
- *
- * The patience is the requester's. It used to be a figure of this route's own,
- * 60 s, beside the page's own 60 s — two chosen numbers that happened to agree,
- * so the "retry" this route sent at its deadline reached a page that had given
- * up at the same instant. The page now states how long it will hold the answer
- * open (`X-Hold-Ms`, its own deadline less the round trip it has measured), and
- * this route answers by then. A requester that states nothing is held until it
- * closes the connection, which every HTTP client does when it stops waiting.
- */
-
-/**
- * Serve HLS playlist and segment files from an active transcode session.
- *
- * Briefly waits for the requested file to appear, then answers with a
- * retryable 503 rather than holding the connection, so clients — in
- * particular iOS's native HLS player — never hit their own response
- * deadline while a segment is still being produced.
- *
- * GET /transcode/:sessionId/:fileName
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ serving: object, viewerRequests: object }} deps
- * @returns {Promise<void>}
- */
-export async function handleTranscodeSessionFileGet(req, reply, { serving, viewerRequests }) {
-  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
-  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
-    return reply;
-  }
-  // This route names its output outright, so the answer is recorded rather
-  // than chosen — under the height the output is named after, which is where
-  // the step route answers with the picture itself.
-  viewerRequests.noteAnsweredDirectly(
-    sessionId,
-    consumerOf(req),
-    statedGenerationOf(req),
-    fileName
-  );
-  return serveSessionFile(req, reply, { serving, viewerRequests, sessionId, fileName });
-}
+import {
+  consumerOf,
+  refusedAsStale,
+  serveSessionFile,
+  statedGenerationOf
+} from "../../../services/server/transcode-session-files.js";
+
+/**
+ * How long a request for a file not yet produced is held: AS LONG AS THE
+ * REQUESTER SAYS IT WILL WAIT, and no longer than it stays.
+ *
+ * The patience is the requester's. It used to be a figure of this route's own,
+ * 60 s, beside the page's own 60 s — two chosen numbers that happened to agree,
+ * so the "retry" this route sent at its deadline reached a page that had given
+ * up at the same instant. The page now states how long it will hold the answer
+ * open (`X-Hold-Ms`, its own deadline less the round trip it has measured), and
+ * this route answers by then. A requester that states nothing is held until it
+ * closes the connection, which every HTTP client does when it stops waiting.
+ */
+
+/**
+ * Serve HLS playlist and segment files from an active transcode session.
+ *
+ * Briefly waits for the requested file to appear, then answers with a
+ * retryable 503 rather than holding the connection, so clients — in
+ * particular iOS's native HLS player — never hit their own response
+ * deadline while a segment is still being produced.
+ *
+ * GET /transcode/:sessionId/:fileName
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ serving: object, viewerRequests: object }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleTranscodeSessionFileGet(req, reply, { serving, viewerRequests }) {
+  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
+  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
+    return reply;
+  }
+  // This route names its output outright, so the answer is recorded rather
+  // than chosen — under the height the output is named after, which is where
+  // the step route answers with the picture itself.
+  viewerRequests.noteAnsweredDirectly(
+    sessionId,
+    consumerOf(req),
+    statedGenerationOf(req),
+    fileName
+  );
+  return serveSessionFile(req, reply, { serving, viewerRequests, sessionId, fileName });
+}

package/routes/transcode/variant-file/get.js

@@ -1,95 +1,95 @@
-/**
- * @file GET /transcode/:sessionId/v/:height/:fileName — one file of a quality
- * variant.
- *
- * A variant is another encode of the same file at another height, and it is an
- * ordinary session underneath. It lives under the base session's path, one
- * directory level down, so every relative name inside its playlist — its
- * segments and its `#EXT-X-MAP` init — resolves to that variant with nothing in
- * the playlist itself having to change.
- *
- * The variant is created on the first request for it, which is what keeps a
- * weak host running one encoder: the player's own bitrate adaptation is off, so
- * no variant is ever asked for unless the viewer picked it.
- */
-
-import { replyAssignmentLost, replyOutputUnavailable } from "../../../services/server/http-responses.js";
-import {
-  consumerOf,
-  refusedAsStale,
-  serveSessionFile,
-  statedGenerationOf
-} from "../../../services/server/transcode-session-files.js";
-
-/**
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
- * @returns {Promise<void>}
- */
-export async function handleTranscodeVariantFileGet(req, reply, { renditions, serving, viewerRequests }) {
-  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const height = Number(req.params.height);
-  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
-
-  // Which viewer is asking. Two viewers of one picture can be on two rungs, and
-  // a segment request is what says which rung a viewer is watching — read as
-  // the session's own, one of them would take the other off their step.
-  const consumerId = consumerOf(req);
-  // Before resolving: resolving can make a step and registers this viewer on
-  // it, which a request for a viewing they have already left must not do.
-  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
-    return reply;
-  }
-  const resolved = await renditions.resolveVariantFile(
-    baseSessionId,
-    height,
-    fileName,
-    consumerId,
-    // Which viewing this request was made in: a repeat within it is answered
-    // by whatever answered it the first time.
-    statedGenerationOf(req)
-  );
-  if (resolved.unavailable) {
-    return replyOutputUnavailable(reply, resolved.unavailable);
-  }
-  if (resolved.lost) {
-    return replyAssignmentLost(reply, resolved.lost);
-  }
-  if (resolved.recover) {
-    // The very piece that was given, from what its gone output left in the
-    // store — held for as long as it is being sent, like any other answer.
-    const stored = await serving.storedPieceOf(resolved.recover.key, resolved.recover.likeId, fileName);
-    if (!stored) {
-      return replyAssignmentLost(reply, { reason: "the stored piece went while it was being fetched" });
-    }
-    const release = viewerRequests.holdResponseForKey(resolved.recover.key, consumerId);
-    reply.raw?.once?.("finish", release);
-    reply.raw?.once?.("close", release);
-    reply.raw?.once?.("error", release);
-    if (!reply.raw || reply.raw.destroyed || reply.raw.writableEnded) {
-      release();
-    }
-    reply.header("Cache-Control", "public, max-age=60");
-    reply.header("Content-Type", stored.contentType);
-    return reply.send(stored.stream);
-  }
-  if (resolved.error) {
-    // Preparing the variant failed — a probe, a keyframe index, an input that
-    // is not there yet. Retryable, like every other not-ready answer on this
-    // path: a 500 for a level playlist is fatal to hls.js, which would end the
-    // stream over something the next attempt may well get past.
-    reply.header("Retry-After", "1");
-    return reply.code(503).send({ error: `Could not prepare the quality variant: ${resolved.error}` });
-  }
-  if (!resolved.sessionId) {
-    return reply.code(404).send({ error: "No such quality variant for this transcode session." });
-  }
-
-  return serveSessionFile(req, reply, {
-    serving,
-    viewerRequests,
-    sessionId: resolved.sessionId,
-    fileName
-  });
-}
+/**
+ * @file GET /transcode/:sessionId/v/:height/:fileName — one file of a quality
+ * variant.
+ *
+ * A variant is another encode of the same file at another height, and it is an
+ * ordinary session underneath. It lives under the base session's path, one
+ * directory level down, so every relative name inside its playlist — its
+ * segments and its `#EXT-X-MAP` init — resolves to that variant with nothing in
+ * the playlist itself having to change.
+ *
+ * The variant is created on the first request for it, which is what keeps a
+ * weak host running one encoder: the player's own bitrate adaptation is off, so
+ * no variant is ever asked for unless the viewer picked it.
+ */
+
+import { replyAssignmentLost, replyOutputUnavailable } from "../../../services/server/http-responses.js";
+import {
+  consumerOf,
+  refusedAsStale,
+  serveSessionFile,
+  statedGenerationOf
+} from "../../../services/server/transcode-session-files.js";
+
+/**
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleTranscodeVariantFileGet(req, reply, { renditions, serving, viewerRequests }) {
+  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  const height = Number(req.params.height);
+  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
+
+  // Which viewer is asking. Two viewers of one picture can be on two rungs, and
+  // a segment request is what says which rung a viewer is watching — read as
+  // the session's own, one of them would take the other off their step.
+  const consumerId = consumerOf(req);
+  // Before resolving: resolving can make a step and registers this viewer on
+  // it, which a request for a viewing they have already left must not do.
+  if (refusedAsStale(req, reply, viewerRequests, fileName)) {
+    return reply;
+  }
+  const resolved = await renditions.resolveVariantFile(
+    baseSessionId,
+    height,
+    fileName,
+    consumerId,
+    // Which viewing this request was made in: a repeat within it is answered
+    // by whatever answered it the first time.
+    statedGenerationOf(req)
+  );
+  if (resolved.unavailable) {
+    return replyOutputUnavailable(reply, resolved.unavailable);
+  }
+  if (resolved.lost) {
+    return replyAssignmentLost(reply, resolved.lost);
+  }
+  if (resolved.recover) {
+    // The very piece that was given, from what its gone output left in the
+    // store — held for as long as it is being sent, like any other answer.
+    const stored = await serving.storedPieceOf(resolved.recover.key, resolved.recover.likeId, fileName);
+    if (!stored) {
+      return replyAssignmentLost(reply, { reason: "the stored piece went while it was being fetched" });
+    }
+    const release = viewerRequests.holdResponseForKey(resolved.recover.key, consumerId);
+    reply.raw?.once?.("finish", release);
+    reply.raw?.once?.("close", release);
+    reply.raw?.once?.("error", release);
+    if (!reply.raw || reply.raw.destroyed || reply.raw.writableEnded) {
+      release();
+    }
+    reply.header("Cache-Control", "public, max-age=60");
+    reply.header("Content-Type", stored.contentType);
+    return reply.send(stored.stream);
+  }
+  if (resolved.error) {
+    // Preparing the variant failed — a probe, a keyframe index, an input that
+    // is not there yet. Retryable, like every other not-ready answer on this
+    // path: a 500 for a level playlist is fatal to hls.js, which would end the
+    // stream over something the next attempt may well get past.
+    reply.header("Retry-After", "1");
+    return reply.code(503).send({ error: `Could not prepare the quality variant: ${resolved.error}` });
+  }
+  if (!resolved.sessionId) {
+    return reply.code(404).send({ error: "No such quality variant for this transcode session." });
+  }
+
+  return serveSessionFile(req, reply, {
+    serving,
+    viewerRequests,
+    sessionId: resolved.sessionId,
+    fileName
+  });
+}