@torrent-tv/proxy 2.86.0 → 2.87.1

package/routes/api/transcode-sessions/seek/post.js

@@ -23,10 +23,10 @@
 /**
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ viewerRequests: object }} deps
  * @returns {Promise<void>}
  */
-export async function handleApiTranscodeSessionSeekPost(req, reply, { hlsSessionManager }) {
+export async function handleApiTranscodeSessionSeekPost(req, reply, { viewerRequests }) {
   const sessionId = req.params?.sessionId;
   const body = req.body && typeof req.body === "object" ? req.body : {};
   const positionSeconds = Number(body.positionSeconds);
@@ -40,7 +40,16 @@ export async function handleApiTranscodeSessionSeekPost(req, reply, { hlsSession
   // has to move with them or their next request is judged against where they
   // were before the jump.
   const consumerId = typeof body.consumerId === "string" ? body.consumerId.trim() : "";
-  const applied = hlsSessionManager.requestSeek(sessionId, positionSeconds, consumerId);
+  if (!consumerId) {
+    reply.code(400);
+    return reply.send({ error: "consumerId is required." });
+  }
+  // Which viewing their requests now belong to. The page raises this before it
+  // sends anything and stamps every request with it, so a request that crosses
+  // this message is still read against the viewing it was made in. A page that
+  // states nothing leaves the generation where it is.
+  const generation = Number(body.generation);
+  const applied = viewerRequests.requestSeek(sessionId, positionSeconds, consumerId, generation);
   if (!applied) {
     // Unknown or disposed session — nothing to steer. Not an error worth
     // surfacing to the viewer: the seek will be handled by whatever session

package/routes/stream/get.js

@@ -45,7 +45,7 @@ const TORRENT_READY_TIMEOUT_MS = 10_000;
  * The underlying add is NOT cancelled: it keeps running and warms the pool, so
  * the client's next attempt is likely to find it ready.
  *
- * @param {import("../../services/torrent-pool.js").TorrentPool} torrentPool
+ * @param {import("../../services/torrent/torrent-pool.js").TorrentPool} torrentPool
  * @param {string} sourceType
  * @param {string} source
  * @returns {Promise<import("webtorrent").Torrent>}
@@ -76,7 +76,7 @@ async function waitForTorrent(torrentPool, sourceType, source) {
  *
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ sourceRegistry: ReturnType<import("../../store/source-registry.js").createSourceRegistry>, torrentPool: import("../../services/torrent-pool.js").TorrentPool }} deps
+ * @param {{ sourceRegistry: ReturnType<import("../../store/source-registry.js").createSourceRegistry>, torrentPool: import("../../services/torrent/torrent-pool.js").TorrentPool }} deps
  * @returns {Promise<void>}
  */
 /**

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

@@ -12,15 +12,15 @@
  * instead of it: both encoders run, one for the rung and one for the audio.
  */
 
-import { serveSessionFile } from "../session-file/get.js";
+import { consumerOf, refusedAsStale, serveSessionFile } from "../../../services/server/transcode-session-files.js";
 
 /**
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
  * @returns {Promise<void>}
  */
-export async function handleTranscodeAudioFileGet(req, reply, { hlsSessionManager }) {
+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 : "";
@@ -29,8 +29,16 @@ export async function handleTranscodeAudioFileGet(req, reply, { hlsSessionManage
   // 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 = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  const resolved = await hlsSessionManager.resolveAudioRenditionFile(
+  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,
@@ -48,7 +56,8 @@ export async function handleTranscodeAudioFileGet(req, reply, { hlsSessionManage
   }
 
   return serveSessionFile(req, reply, {
-    hlsSessionManager,
+    serving,
+    viewerRequests,
     sessionId: resolved.sessionId,
     fileName
   });

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

@@ -12,7 +12,7 @@
  * switch into bytes that already exist; 503 while it is still being made.
  */
 
-import { waitForSessionFile } from "../session-file/get.js";
+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;
@@ -20,9 +20,9 @@ const WARM_WAIT_MS = 12_000;
 /**
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
  */
-export async function handleTranscodeAudioWarmGet(req, reply, { hlsSessionManager }) {
+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);
@@ -40,10 +40,13 @@ export async function handleTranscodeAudioWarmGet(req, reply, { hlsSessionManage
   // 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 hlsSessionManager.prepareAudioTrack(
+    prepared = await renditions.prepareAudioTrack(
       baseSessionId,
       trackIndex,
       positionSeconds,
@@ -59,10 +62,10 @@ export async function handleTranscodeAudioWarmGet(req, reply, { hlsSessionManage
   }
 
   const result = await waitForSessionFile(
-    hlsSessionManager,
+    serving,
     prepared.sessionId,
     prepared.fileName,
-    WARM_WAIT_MS
+    { holdMs: WARM_WAIT_MS }
   );
   if (result.kind === "file") {
     // The bytes are the player's to fetch; the handle opened to reach them is

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

@@ -1,268 +1,52 @@
-import { logger } from "../../../utils/logger.js";
-import { bandOf, waits } from "../../../services/priority/WaitLedger.js";
-
-/**
- * How long a request for a not-yet-produced file is held before answering with
- * a retryable 503.
- *
- * MEASUREMENT MODE (2026-08-02): deliberately far above any plausible player
- * deadline, so OUR limit never fires first. Whatever ends the wait is then the
- * player's own behaviour — which is exactly what we need to observe. The
- * `[hold]` log line at the call site records, per request, whether the segment
- * arrived, whether we gave up, or whether the CLIENT aborted, and after how
- * long.
- *
- * The previous value (2 s) was chosen to dodge a reported iOS AVPlayer ~3.5 s
- * response-header deadline. That deadline never appears in our own logs (no
- * -12889 across six hours of production logs), and every reference project
- * holds rather than refusing: Jellyfin and hls-vod-too hold unbounded,
- * hls-media-server holds 10 s. The early refusal is what made the player probe
- * scattered positions, which then steered the encoder off target. Choose the
- * final value from what this measurement shows, not from a number read
- * elsewhere.
- */
-const SEGMENT_WAIT_MS = 60_000;
-
-/**
- * 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 {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
- * @returns {Promise<void>}
- */
-export async function handleTranscodeSessionFileGet(req, reply, { hlsSessionManager }) {
-  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const fileName = typeof req.params.fileName === "string" ? req.params.fileName : "";
-  return serveSessionFile(req, reply, { hlsSessionManager, sessionId, fileName });
-}
-
-/**
- * Serve one playlist or segment from a named session.
- *
- * Split from the route above because the variant route
- * (`/transcode/:sessionId/v/:height/:fileName`) serves the same files from
- * another session of the same family, and must hold, log and answer them
- * identically — a switch of quality must not go through a different code path
- * from the stream it switches away from.
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager, sessionId: string, fileName: string }} params
- * @returns {Promise<void>}
- */
-export async function serveSessionFile(req, reply, { hlsSessionManager, sessionId, fileName }) {
-  // Which viewer is asking. One session serves everyone watching a copied
-  // picture, so without it their positions collapse into one and a seek by the
-  // viewer in front releases the requests held for the viewer behind. Absent on
-  // a plain HTTP transport, where no loader of ours builds the URL, and then
-  // the single shared position decides as it always did.
-  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  // Hold the request only briefly, then answer "retry" instead of waiting for
-  // the segment. iOS's native HLS player (AVPlayer) enforces a hard ~3.5 s
-  // deadline on RESPONSE HEADERS and raises -12889 ("No response for media
-  // file") when it passes — it then cancels in-flight requests, probes
-  // neighbouring positions and can restart the stream from the beginning. That
-  // is exactly the post-seek "player thrashing" seen in the field, because a
-  // seek restarts ffmpeg and the first segment then takes far longer than 3.5 s
-  // to appear. Holding the connection for 30 s (as this did) guaranteed the
-  // timeout on every seek. A short hold keeps the fast path intact (a ready or
-  // nearly-ready segment is still served on the first request) while a slow one
-  // gets a prompt retryable answer, which resets the player's own deadline.
-  // hls.js is unaffected: it consumes the 503 through its retry policy, whose
-  // budget the client widens to match (see hls-player.js fragLoadPolicy).
-  // Instrumented wait. `clientAborted` flips when the player drops the
-  // connection while we are still holding it — the single most informative
-  // signal about its real patience, and observable only from this side.
-  const holdStartedAt = Date.now();
-  let clientAborted = false;
-  const onClientAbort = () => { clientAborted = true; };
-  req.raw.on("close", onClientAbort);
-
-  const result = await waitForSessionFile(
-    hlsSessionManager,
-    sessionId,
-    fileName,
-    SEGMENT_WAIT_MS,
-    consumerId
-  );
-
-  req.raw.off("close", onClientAbort);
-  const heldMs = Date.now() - holdStartedAt;
-  if (result.isPlaylist !== true) {
-    const outcome = clientAborted
-      ? "client-aborted"
-      : result.kind === "ok" ? "served" : result.kind;
-    // AGAINST THE RANK THE MAP GAVE IT. A wait is the only thing that says
-    // whether the prioritisation is being used well, and this is the one place
-    // in the proxy where a viewer is measurably waiting for a named segment.
-    // Recorded even when the segment was served at once: a run of short waits
-    // at the top rank is what "the urgent zone is being served first" looks
-    // like, and without them the table would hold only the failures.
-    const ranked = result.ranked ?? null;
-    if (ranked) {
-      waits.note(ranked.address, heldMs, ranked.rank, ranked.topRank);
-    }
-    logger.info(
-      `[hold] ${fileName} ${outcome} after ${heldMs}ms` +
-      (ranked ? ` (the map wants it ${bandOf(ranked.rank, ranked.topRank)}, rank ${ranked.rank} of ${ranked.topRank})` : "")
-    );
-  }
-
-  if (result.kind === "not-found") {
-    return reply.code(404).send({ error: "Transcode session file was not found." });
-  }
-  if (result.kind === "superseded") {
-    // The viewer moved while this was being held, and this segment is not the
-    // one they moved TO — that case is kept and waited out, see
-    // `waitForSessionFile`. Answer at once so the player can ask for where it
-    // is now; `Retry-After: 0` because there is nothing to wait for.
-    //
-    // Named in the log, because a refusal that says only "superseded" is what
-    // made the 2026-08-18 freeze take a day to explain: the player was refused
-    // the segment at its own seek target and nothing recorded which segment or
-    // where the viewer was.
-    logger.info(
-      `[hold] ${fileName} refused: the viewer is at ` +
-      `${hlsSessionManager.viewerPositionOf(sessionId, consumerId).toFixed(1)}s and this is not the segment there`
-    );
-    reply.header("Retry-After", "0");
-    return reply.code(503).send({ error: "Superseded by a seek." });
-  }
-  if (result.kind === "warming-up") {
-    // The segment is still being produced (e.g. just after a seek-restart).
-    // Return a retryable 503 — never 202, which hls.js cannot consume as a
-    // media segment — so the player retries the fetch shortly.
-    reply.header("Retry-After", "1");
-    // `Retry-After` tells the player to re-request THIS segment after a short
-    // pause. Without it a bare 503 reads as "nothing here", and the player goes
-    // looking elsewhere: because our synthetic VOD playlist lists every segment
-    // of the file, it believes they all exist and SCANS them (field log: one
-    // user seek produced probes at #617, #717, #732…). That scan is what used
-    // to steer the encoder off the real target. Whether iOS's native player
-    // honours the hint is not guaranteed — its behaviour is closed — but this
-    // is the standard, correct way to say "wait, don't look elsewhere", and
-    // hls.js already retries the same fragment regardless.
-    reply.header("Retry-After", "1");
-    // SAY WHY, to the viewer and not only to the log. The same refusal is
-    // written into `proxy.log` with the rank the priority map gave this
-    // segment; the page had no access to that and told the viewer it did not
-    // know why. Field 2026-09-14: `rank 1 of 100` — nothing was making it —
-    // printed sixty seconds before the page gave up saying the opposite.
-    return reply.code(503).send({
-      error: "Transcode segment is still being produced.",
-      reason: warmingReason(result.ranked ?? null)
-    });
-  }
-  if (result.kind === "failed") {
-    return reply.code(500).send({ error: result.message });
-  }
-
-  if (result.isPlaylist) {
-    reply.header("Cache-Control", "no-store");
-  } else {
-    reply.header("Cache-Control", "public, max-age=60");
-  }
-  reply.header("Content-Type", result.contentType);
-  return reply.send(result.stream);
-}
-
-/**
- * Poll `hlsSessionManager.getFileStream()` until the file is available,
- * the session fails, or the timeout elapses.
- *
- * @param {import("../../../services/hls-session-manager.js").HlsSessionManager} hlsSessionManager
- * @param {string} sessionId
- * @param {string} fileName
- * @param {number} timeoutMs
- * @param {string} [consumerId] - Which viewer is asking, where the transport
- *   carries it. Their own position is what decides whether a held request has
- *   been made pointless by a seek — a session can have several viewers, and
- *   the seek epoch belongs to all of them.
- * @returns {Promise<Awaited<ReturnType<import("../../../services/hls-session-manager.js").HlsSessionManager["getFileStream"]>>>}
- */
-export async function waitForSessionFile(hlsSessionManager, sessionId, fileName, timeoutMs, consumerId = "") {
-  const startedAt = Date.now();
-  // One sequence number for THIS request, reused by every poll below, so the
-  // session can tell a newly-arrived request apart from an old one polling
-  // again — see HlsSessionManager#ensureEncodingFor for the encoder ping-pong
-  // this prevents when one seek-bar scrub fires several segment requests.
-  const requestSeq = hlsSessionManager.nextRequestSeq(sessionId);
-  // The viewer's position when this request was made. A seek makes every held
-  // request stale — it asks for a segment nobody is going to watch — and hls.js
-  // keeps only ONE fragment load outstanding, so holding on blocks the request
-  // the player actually needs now. Measured: 57 s of a 58 s backward seek was
-  // this wait, and the segment the viewer wanted took 15 ms once it was asked
-  // for.
-  let seekEpoch = hlsSessionManager.seekEpoch(sessionId);
-  /** @type {{ address: string, rank: number, topRank: number } | null} */
-  let lastRanked = null;
-  while (Date.now() - startedAt < timeoutMs) {
-    const result = await hlsSessionManager.getFileStream(sessionId, fileName, {
-      requestSeq,
-      consumerId
-    });
-    if (result.kind !== "warming-up") {
-      return result;
-    }
-    if (hlsSessionManager.seekEpoch(sessionId) !== seekEpoch) {
-      // A seek moved the epoch. Whether THIS request is stale depends on which
-      // segment it asks for: the one the viewer has just landed on races the
-      // seek notification and would otherwise be refused at the exact moment it
-      // is needed — measured 2026-08-18, two 503s within 80 ms on the segment
-      // at the seek target, after which the player never asked for it again.
-      if (!hlsSessionManager.requestStillWanted(sessionId, fileName, consumerId)) {
-        return { kind: "superseded" };
-      }
-      logger.info(
-        `[hold] ${fileName} kept across a seek: it is the segment the viewer now needs`
-      );
-      seekEpoch = hlsSessionManager.seekEpoch(sessionId);
-    }
-    // The rank the map last gave this segment, so a request that runs out of
-    // patience is still counted against what it was promised. Kept across the
-    // polls because the timeout path has no result of its own.
-    lastRanked = result.ranked ?? lastRanked;
-    await delay(300);
-  }
-  return { kind: "warming-up", ranked: lastRanked };
-}
-
-/**
- * Resolve after a given number of milliseconds.
- *
- * @param {number} ms
- * @returns {Promise<void>}
- */
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-
-/**
- * What to tell the VIEWER when a segment is not there yet.
- *
- * In their terms — the film, and what is being done about it — never in ours: a
- * viewer cannot read a log, does not know what a rank is, and is not helped by
- * being told which of our parts is waiting for which other.
- *
- * @param {{ rank: number, topRank: number } | null} ranked - What the priority
- *   map thought of this segment while the request was held.
- * @returns {string}
- */
-function warmingReason(ranked) {
-  if (ranked && ranked.rank < ranked.topRank) {
-    // The map is working somewhere else in the film. That is the answer the
-    // failure of 2026-09-14 needed and nobody was given.
-    return "This part of the film is not being prepared yet — the proxy is working further along.";
-  }
-  return "This part of the film is still being prepared.";
-}
+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

@@ -13,15 +13,21 @@
  * no variant is ever asked for unless the viewer picked it.
  */
 
-import { serveSessionFile } from "../session-file/get.js";
+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 {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
  * @returns {Promise<void>}
  */
-export async function handleTranscodeVariantFileGet(req, reply, { hlsSessionManager }) {
+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 : "";
@@ -29,13 +35,45 @@ export async function handleTranscodeVariantFileGet(req, reply, { hlsSessionMana
   // 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 = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  const resolved = await hlsSessionManager.resolveVariantFile(
+  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
+    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
@@ -49,7 +87,8 @@ export async function handleTranscodeVariantFileGet(req, reply, { hlsSessionMana
   }
 
   return serveSessionFile(req, reply, {
-    hlsSessionManager,
+    serving,
+    viewerRequests,
     sessionId: resolved.sessionId,
     fileName
   });

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

@@ -13,7 +13,9 @@
  * knowing there is something to fetch.
  */
 
-import { waitForSessionFile } from "../session-file/get.js";
+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;
@@ -21,10 +23,10 @@ const WARM_WAIT_MS = 30_000;
 /**
  * @param {import("fastify").FastifyRequest} req
  * @param {import("fastify").FastifyReply} reply
- * @param {{ hlsSessionManager: import("../../../services/hls-session-manager.js").HlsSessionManager }} deps
+ * @param {{ renditions: object, serving: object, viewerRequests: object }} deps
  * @returns {Promise<void>}
  */
-export async function handleTranscodeVariantWarmGet(req, reply, { hlsSessionManager }) {
+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);
@@ -32,11 +34,22 @@ export async function handleTranscodeVariantWarmGet(req, reply, { hlsSessionMana
   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 hlsSessionManager.prepareVariant(baseSessionId, height, positionSeconds);
+    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}` });
@@ -46,10 +59,10 @@ export async function handleTranscodeVariantWarmGet(req, reply, { hlsSessionMana
   }
 
   const result = await waitForSessionFile(
-    hlsSessionManager,
+    serving,
     prepared.sessionId,
     prepared.fileName,
-    WARM_WAIT_MS
+    { holdMs: WARM_WAIT_MS }
   );
   if (result.kind === "file") {
     // The bytes are not sent — the player fetches them itself the moment it

package/scripts/render-run-graph.js

@@ -103,7 +103,7 @@ export function renderRunGraphMarkdown() {
     "# 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/hls-session-manager.js`; every transition a real",
+    "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.",
     "",