@torrent-tv/proxy 2.89.6 → 2.89.7

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

@@ -1,84 +1,84 @@
-/**
- * @file GET /transcode/:sessionId/v/:height/warm?position=<seconds> — prepare a
- * quality rung before the player is told to switch to it.
- *
- * A rung is an encoder that does not exist until someone asks for it, so a
- * switch made first and waited for second shows the viewer a spinner for as
- * long as the first segment takes to produce — 15 988 ms, measured 2026-08-11
- * on a rung producing at 1.2x. Asking first and switching second moves that
- * wait to where it cannot be seen: the rung on screen goes on playing, and it
- * keeps its own encoder until the player actually moves.
- *
- * Answers when the segment at that position is ready, so the caller can switch
- * knowing there is something to fetch.
- */
-
-import { replyOutputUnavailable } from "../../../services/server/http-responses.js";
-import { waitForSessionFile } from "../../../services/server/transcode-session-files.js";
-import { OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
-
-/** How long to hold the warm-up request before telling the caller to retry. */
-const WARM_WAIT_MS = 30_000;
-
-/**
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
- * @returns {Promise<void>}
- */
-export async function handleTranscodeVariantWarmGet(req, reply, { renditions, serving, viewerRequests }) {
-  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const height = Number(req.params.height);
-  const positionSeconds = Number(req.query?.position);
-
-  if (!Number.isInteger(height) || height <= 0 || !Number.isFinite(positionSeconds) || positionSeconds < 0) {
-    return reply.code(400).send({ error: "A height and a non-negative position are required." });
-  }
-  // Whose warm-up this is. It was not passed at all, so every warm-up was
-  // written onto a nameless viewer instead of the person who asked for 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.prepareVariant(baseSessionId, height, positionSeconds, consumerId);
-  } catch (error) {
-    if (error?.code === OUTPUT_UNAVAILABLE) {
-      // Nothing at that height suits this viewer's link. Said at once and not
-      // as "retry": the page tells the viewer and keeps what is playing.
-      return replyOutputUnavailable(reply, error.details);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    reply.header("Retry-After", "1");
-    return reply.code(503).send({ error: `Could not prepare the quality variant: ${message}` });
-  }
-  if (!prepared) {
-    return reply.code(404).send({ error: "No such quality variant for this transcode session." });
-  }
-
-  const result = await waitForSessionFile(
-    serving,
-    prepared.sessionId,
-    prepared.fileName,
-    { holdMs: WARM_WAIT_MS }
-  );
-  if (result.kind === "file") {
-    // The bytes are not sent — the player fetches them itself the moment it
-    // switches, and by then they are on disk — but the handle opened to reach
-    // them is ours to close. Some formats answer with a real file descriptor
-    // rather than bytes already in memory, and one left behind per quality pick
-    // walks a long-running proxy to EMFILE, where every read fails, segments
-    // included.
-    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 simply wait
-  // where it would have waited before — or ask again.
-  reply.header("Retry-After", "1");
-  return reply.code(503).send({ error: "The quality variant is still warming up." });
-}
+/**
+ * @file GET /transcode/:sessionId/v/:height/warm?position=<seconds> — prepare a
+ * quality rung before the player is told to switch to it.
+ *
+ * A rung is an encoder that does not exist until someone asks for it, so a
+ * switch made first and waited for second shows the viewer a spinner for as
+ * long as the first segment takes to produce — 15 988 ms, measured 2026-08-11
+ * on a rung producing at 1.2x. Asking first and switching second moves that
+ * wait to where it cannot be seen: the rung on screen goes on playing, and it
+ * keeps its own encoder until the player actually moves.
+ *
+ * Answers when the segment at that position is ready, so the caller can switch
+ * knowing there is something to fetch.
+ */
+
+import { replyOutputUnavailable } from "../../../services/server/http-responses.js";
+import { waitForSessionFile } from "../../../services/server/transcode-session-files.js";
+import { OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
+
+/** How long to hold the warm-up request before telling the caller to retry. */
+const WARM_WAIT_MS = 30_000;
+
+/**
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleTranscodeVariantWarmGet(req, reply, { renditions, serving, viewerRequests }) {
+  const baseSessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  const height = Number(req.params.height);
+  const positionSeconds = Number(req.query?.position);
+
+  if (!Number.isInteger(height) || height <= 0 || !Number.isFinite(positionSeconds) || positionSeconds < 0) {
+    return reply.code(400).send({ error: "A height and a non-negative position are required." });
+  }
+  // Whose warm-up this is. It was not passed at all, so every warm-up was
+  // written onto a nameless viewer instead of the person who asked for 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.prepareVariant(baseSessionId, height, positionSeconds, consumerId);
+  } catch (error) {
+    if (error?.code === OUTPUT_UNAVAILABLE) {
+      // Nothing at that height suits this viewer's link. Said at once and not
+      // as "retry": the page tells the viewer and keeps what is playing.
+      return replyOutputUnavailable(reply, error.details);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    reply.header("Retry-After", "1");
+    return reply.code(503).send({ error: `Could not prepare the quality variant: ${message}` });
+  }
+  if (!prepared) {
+    return reply.code(404).send({ error: "No such quality variant for this transcode session." });
+  }
+
+  const result = await waitForSessionFile(
+    serving,
+    prepared.sessionId,
+    prepared.fileName,
+    { holdMs: WARM_WAIT_MS }
+  );
+  if (result.kind === "file") {
+    // The bytes are not sent — the player fetches them itself the moment it
+    // switches, and by then they are on disk — but the handle opened to reach
+    // them is ours to close. Some formats answer with a real file descriptor
+    // rather than bytes already in memory, and one left behind per quality pick
+    // walks a long-running proxy to EMFILE, where every read fails, segments
+    // included.
+    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 simply wait
+  // where it would have waited before — or ask again.
+  reply.header("Retry-After", "1");
+  return reply.code(503).send({ error: "The quality variant is still warming up." });
+}

package/scripts/render-run-graph.js

@@ -1,173 +1,173 @@
-#!/usr/bin/env node
-/**
- * @file Render the encoder-run table as a document, FROM the table.
- *
- * The picture is not drawn beside the code — it is produced from the same data
- * the code executes, so it cannot describe a machine that no longer exists. A
- * test regenerates it and compares, which is what makes "the table is the
- * single source" enforceable rather than a promise.
- *
- * Run it with `npm run graph`.
- */
-
-import { writeFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import {
-  ABSENT_EDGE_INVARIANTS,
-  ENCODE_RUN_EVENT,
-  ENCODE_RUN_STATE,
-  EVENT_MEANING,
-  INITIAL_RUN_STATE,
-  STATE_MEANING,
-  answerForMissingSegment,
-  declaredContainment,
-  declaredEdges,
-  isInputBeingRead,
-  mayRestart,
-  processCanBeSignalled,
-  wireState
-} from "../services/encode/encode-run-state.js";
-
-/** Where the rendered document lives. */
-export const GRAPH_DOC_PATH = path.join(
-  path.dirname(fileURLToPath(import.meta.url)),
-  "..",
-  "docs",
-  "encode-run-state.md"
-);
-
-const ALL_STATES = Object.values(ENCODE_RUN_STATE);
-const ALL_EVENTS = Object.values(ENCODE_RUN_EVENT);
-
-/**
- * Children of each node of the containment tree, in declaration order.
- *
- * @returns {{ root: string, childrenOf: Map<string, string[]> }}
- */
-function containmentTree() {
-  const childrenOf = new Map();
-  let root = null;
-  for (const { state, parent } of declaredContainment()) {
-    if (parent === null) {
-      root = state;
-      continue;
-    }
-    if (!childrenOf.has(parent)) {
-      childrenOf.set(parent, []);
-    }
-    childrenOf.get(parent).push(state);
-  }
-  return { root, childrenOf };
-}
-
-/**
- * One composite block, and everything nested inside it.
- *
- * @param {string} node
- * @param {Map<string, string[]>} childrenOf
- * @param {number} depth
- * @returns {string[]} Lines, already indented.
- */
-function renderBlock(node, childrenOf, depth) {
-  const pad = "    ".repeat(depth);
-  const children = childrenOf.get(node) ?? [];
-  if (children.length === 0) {
-    return [`${pad}${node}`];
-  }
-  const lines = [`${pad}state ${node} {`];
-  if (children.includes(INITIAL_RUN_STATE)) {
-    lines.push(`${pad}    [*] --> ${INITIAL_RUN_STATE}`);
-  }
-  for (const child of children) {
-    lines.push(...renderBlock(child, childrenOf, depth + 1));
-  }
-  lines.push(`${pad}}`);
-  return lines;
-}
-
-/**
- * The whole document.
- *
- * @returns {string}
- */
-export function renderRunGraphMarkdown() {
-  const { root, childrenOf } = containmentTree();
-  const lines = [];
-
-  lines.push(
-    "<!-- GENERATED from services/encode/encode-run-state.js by scripts/render-run-graph.js.",
-    "     Do not edit by hand: change the table and run `npm run graph`. -->",
-    "",
-    "# The encoder run — states and transitions",
-    "",
-    "One run of one ffmpeg inside one transcode session. The table this is drawn",
-    "from is executed by `services/encode/EncodeRuns.js`; every transition a real",
-    "run makes is logged as state, event and target, so a run that takes an edge",
-    "absent here is a violation the log names.",
-    "",
-    "```mermaid",
-    "stateDiagram-v2"
-  );
-  lines.push(...renderBlock(root, childrenOf, 1));
-  lines.push("");
-  for (const edge of declaredEdges()) {
-    lines.push(`    ${edge.from} --> ${edge.to} : ${edge.event}`);
-  }
-  lines.push("```", "");
-
-  lines.push("## States", "", "| state | means |", "|---|---|");
-  for (const state of ALL_STATES) {
-    lines.push(`| \`${state}\` | ${STATE_MEANING[state]} |`);
-  }
-  lines.push("");
-
-  lines.push("## Events", "", "| event | means |", "|---|---|");
-  for (const event of ALL_EVENTS) {
-    lines.push(`| \`${event}\` | ${EVENT_MEANING[event]} |`);
-  }
-  lines.push("");
-
-  lines.push(
-    "## What each state answers",
-    "",
-    "Outputs depend on the state alone — computed here by calling the same",
-    "functions the session manager calls.",
-    "",
-    "| state | reads its input | can be signalled | a missing segment | on the wire | may restart |",
-    "|---|---|---|---|---|---|"
-  );
-  for (const state of ALL_STATES) {
-    lines.push(
-      `| \`${state}\` | ${isInputBeingRead(state) ? "yes" : "no"} | ` +
-        `${processCanBeSignalled(state) ? "yes" : "no"} | ${answerForMissingSegment(state)} | ` +
-        `\`${wireState(state)}\` | ${mayRestart(state) ? "yes" : "no"} |`
-    );
-  }
-  lines.push("");
-
-  lines.push(
-    "## Edges that must never exist",
-    "",
-    "The machine's real content: a near-complete digraph asserts nothing.",
-    "",
-    "| from | event | must not reach | because |",
-    "|---|---|---|---|"
-  );
-  for (const invariant of ABSENT_EDGE_INVARIANTS) {
-    lines.push(
-      `| \`${invariant.from}\` | \`${invariant.event}\` | \`${invariant.mustNotReach}\` | ${invariant.because} |`
-    );
-  }
-  lines.push("");
-
-  return `${lines.join("\n")}`;
-}
-
-// Written only when this file is the program being run, so importing it from a
-// test cannot rewrite the very file the test is about to compare against.
-if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  writeFileSync(GRAPH_DOC_PATH, renderRunGraphMarkdown(), "utf8");
-  process.stdout.write(`wrote ${GRAPH_DOC_PATH}\n`);
-}
+#!/usr/bin/env node
+/**
+ * @file Render the encoder-run table as a document, FROM the table.
+ *
+ * The picture is not drawn beside the code — it is produced from the same data
+ * the code executes, so it cannot describe a machine that no longer exists. A
+ * test regenerates it and compares, which is what makes "the table is the
+ * single source" enforceable rather than a promise.
+ *
+ * Run it with `npm run graph`.
+ */
+
+import { writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import {
+  ABSENT_EDGE_INVARIANTS,
+  ENCODE_RUN_EVENT,
+  ENCODE_RUN_STATE,
+  EVENT_MEANING,
+  INITIAL_RUN_STATE,
+  STATE_MEANING,
+  answerForMissingSegment,
+  declaredContainment,
+  declaredEdges,
+  isInputBeingRead,
+  mayRestart,
+  processCanBeSignalled,
+  wireState
+} from "../services/encode/encode-run-state.js";
+
+/** Where the rendered document lives. */
+export const GRAPH_DOC_PATH = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "..",
+  "docs",
+  "encode-run-state.md"
+);
+
+const ALL_STATES = Object.values(ENCODE_RUN_STATE);
+const ALL_EVENTS = Object.values(ENCODE_RUN_EVENT);
+
+/**
+ * Children of each node of the containment tree, in declaration order.
+ *
+ * @returns {{ root: string, childrenOf: Map<string, string[]> }}
+ */
+function containmentTree() {
+  const childrenOf = new Map();
+  let root = null;
+  for (const { state, parent } of declaredContainment()) {
+    if (parent === null) {
+      root = state;
+      continue;
+    }
+    if (!childrenOf.has(parent)) {
+      childrenOf.set(parent, []);
+    }
+    childrenOf.get(parent).push(state);
+  }
+  return { root, childrenOf };
+}
+
+/**
+ * One composite block, and everything nested inside it.
+ *
+ * @param {string} node
+ * @param {Map<string, string[]>} childrenOf
+ * @param {number} depth
+ * @returns {string[]} Lines, already indented.
+ */
+function renderBlock(node, childrenOf, depth) {
+  const pad = "    ".repeat(depth);
+  const children = childrenOf.get(node) ?? [];
+  if (children.length === 0) {
+    return [`${pad}${node}`];
+  }
+  const lines = [`${pad}state ${node} {`];
+  if (children.includes(INITIAL_RUN_STATE)) {
+    lines.push(`${pad}    [*] --> ${INITIAL_RUN_STATE}`);
+  }
+  for (const child of children) {
+    lines.push(...renderBlock(child, childrenOf, depth + 1));
+  }
+  lines.push(`${pad}}`);
+  return lines;
+}
+
+/**
+ * The whole document.
+ *
+ * @returns {string}
+ */
+export function renderRunGraphMarkdown() {
+  const { root, childrenOf } = containmentTree();
+  const lines = [];
+
+  lines.push(
+    "<!-- GENERATED from services/encode/encode-run-state.js by scripts/render-run-graph.js.",
+    "     Do not edit by hand: change the table and run `npm run graph`. -->",
+    "",
+    "# The encoder run — states and transitions",
+    "",
+    "One run of one ffmpeg inside one transcode session. The table this is drawn",
+    "from is executed by `services/encode/EncodeRuns.js`; every transition a real",
+    "run makes is logged as state, event and target, so a run that takes an edge",
+    "absent here is a violation the log names.",
+    "",
+    "```mermaid",
+    "stateDiagram-v2"
+  );
+  lines.push(...renderBlock(root, childrenOf, 1));
+  lines.push("");
+  for (const edge of declaredEdges()) {
+    lines.push(`    ${edge.from} --> ${edge.to} : ${edge.event}`);
+  }
+  lines.push("```", "");
+
+  lines.push("## States", "", "| state | means |", "|---|---|");
+  for (const state of ALL_STATES) {
+    lines.push(`| \`${state}\` | ${STATE_MEANING[state]} |`);
+  }
+  lines.push("");
+
+  lines.push("## Events", "", "| event | means |", "|---|---|");
+  for (const event of ALL_EVENTS) {
+    lines.push(`| \`${event}\` | ${EVENT_MEANING[event]} |`);
+  }
+  lines.push("");
+
+  lines.push(
+    "## What each state answers",
+    "",
+    "Outputs depend on the state alone — computed here by calling the same",
+    "functions the session manager calls.",
+    "",
+    "| state | reads its input | can be signalled | a missing segment | on the wire | may restart |",
+    "|---|---|---|---|---|---|"
+  );
+  for (const state of ALL_STATES) {
+    lines.push(
+      `| \`${state}\` | ${isInputBeingRead(state) ? "yes" : "no"} | ` +
+        `${processCanBeSignalled(state) ? "yes" : "no"} | ${answerForMissingSegment(state)} | ` +
+        `\`${wireState(state)}\` | ${mayRestart(state) ? "yes" : "no"} |`
+    );
+  }
+  lines.push("");
+
+  lines.push(
+    "## Edges that must never exist",
+    "",
+    "The machine's real content: a near-complete digraph asserts nothing.",
+    "",
+    "| from | event | must not reach | because |",
+    "|---|---|---|---|"
+  );
+  for (const invariant of ABSENT_EDGE_INVARIANTS) {
+    lines.push(
+      `| \`${invariant.from}\` | \`${invariant.event}\` | \`${invariant.mustNotReach}\` | ${invariant.because} |`
+    );
+  }
+  lines.push("");
+
+  return `${lines.join("\n")}`;
+}
+
+// Written only when this file is the program being run, so importing it from a
+// test cannot rewrite the very file the test is about to compare against.
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  writeFileSync(GRAPH_DOC_PATH, renderRunGraphMarkdown(), "utf8");
+  process.stdout.write(`wrote ${GRAPH_DOC_PATH}\n`);
+}