@torrent-tv/proxy 2.87.10 → 2.87.12

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

@@ -1,160 +1,173 @@
-/**
- * Create or return an existing HLS transcode session for a torrent file.
- *
- * POST /api/transcode-sessions
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ viewerRequests: object, renditions: object, quality: object, outputs: object, lookaheadSeconds: number, sourceRegistry: object, torrentPool: object }} deps
- * @returns {Promise<void>}
- */
-
-import { logger } from "../../../utils/logger.js";
-import { OUTPUT_NO_CAPACITY, OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
-import { replyNoCapacity, replyOutputUnavailable } from "../../../services/server/http-responses.js";
-
-/**
- * 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 handleApiTranscodeSessionsPost(req, reply, { viewerRequests, renditions, quality, outputs, lookaheadSeconds, sourceRegistry, torrentPool }) {
-  const payload = getPayload(req.body);
-  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
-  const fileIndex = Number(payload.fileIndex);
-  const transcodeVideo = payload.transcodeVideo === true;
-  const transcodeAudio = payload.transcodeAudio === true;
-  const consumerId = typeof payload.consumerId === "string" ? payload.consumerId.trim() : "";
-  const fileName = typeof payload.fileName === "string" ? payload.fileName.trim() : "";
-  const targetWidth = Number(payload.targetWidth);
-  const targetHeight = Number(payload.targetHeight);
-  // The picture as the viewer sees it, in physical pixels. For a re-encoded
-  // picture the height made is the smallest rung whose frame is not smaller
-  // than this (roadmap item 98); it takes the place of a target box.
-  const visibleWidth = Number(payload.visiblePicture?.width);
-  const visibleHeight = Number(payload.visiblePicture?.height);
-  const visiblePicture = visibleWidth > 0 && visibleHeight > 0
-    ? { width: Math.round(visibleWidth), height: Math.round(visibleHeight) }
-    : null;
-  // The target box is produced exactly (capped to source), with the realtime
-  // budget's auto-downscale and runtime downswitch off for this session.
-  //
-  // It says nothing about WHO asked — a rung sets it whether the viewer picked
-  // that rung or the player moved itself onto one.
-  const exactSize = payload.exactSize === true;
-  // Whether this browser will take its audio from a separate rendition group in
-  // the master playlist rather than muxed into the picture. It has to say so:
-  // publishing renditions AND muxing the same audio would play it twice, while
-  // a browser that does not know about them would get no sound at all.
-  const audioRenditions = payload.audioRenditions === true;
-  const startPositionSeconds = Number(payload.startPositionSeconds);
-  const audioTrackIndex = Number(payload.audioTrackIndex);
-  // Which container to produce. The browser knows what its media stack will
-  // accept for the tracks it asked to be copied; an absent or unknown value
-  // leaves the proxy's own `--segment-format` in charge.
-  const segmentFormatId =
-    typeof payload.segmentFormat === "string" ? payload.segmentFormat.trim() : "";
-
-  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
-    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
-  }
-  // The output is opened FOR somebody, and a viewer always has a name.
-  if (!consumerId) {
-    return reply.code(400).send({ error: "consumerId is required." });
-  }
-
-  try {
-    const session = await viewerRequests.createOrGetSession({
-      sourceKey,
-      fileIndex,
-      transcodeVideo,
-      transcodeAudio,
-      consumerId,
-      fileName,
-      targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
-      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
-      exactSize,
-      visiblePicture,
-      audioRenditions,
-      startPositionSeconds:
-        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
-          ? startPositionSeconds
-          : 0,
-      audioTrackIndex:
-        Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
-      segmentFormatId
-    });
-    // The index of quality variants, when this session has more than one to
-    // offer. Its presence is what tells the browser it can change quality
-    // without a new session: the player switches variants itself, appending the
-    // new one after what is already buffered. Absent for a copied video, whose
-    // segments are cut at the source's own keyframes and so cannot be spliced
-    // with a re-encoded rung.
-    const hasVariants = renditions.buildMasterPlaylist(session.id) !== null;
-    return reply.send({
-      sessionId: session.id,
-      playlistPath: `/transcode/${session.id}/index.m3u8`,
-      ...(hasVariants
-        ? {
-            masterPath: `/transcode/${session.id}/master.m3u8`,
-            // Which of the master's variants this session IS. The browser pins
-            // the player to it, so loading the master costs nothing: an encoder
-            // is already producing that height, and any other rung would be a
-            // second cold start before the first frame.
-            variantHeight: outputs.variantHeightOf(session)
-          }
-        : {}),
-      // The heights this host will actually serve this file at, largest first
-      // — the ladder minus every rung it cannot produce faster than it is
-      // watched. The browser needs it whether or not a master exists: without
-      // it, it fell back to a ladder of its own invention and offered rungs the
-      // proxy had just refused, and picking one re-opened the session at a
-      // height measured at a third of realtime.
-      offeredHeights: quality.offeredHeights(session),
-      // What this session's output will carry, stated rather than left to be
-      // discovered. The browser checks what it actually got against this: a
-      // track that never arrives is otherwise noticed only by its absence,
-      // minutes later, as a black picture with working sound.
-      tracks: renditions.declaredTracks(session),
-      // How far ahead of the viewer this proxy lets the encoder run, in seconds
-      // of playback. The browser sizes its own forward buffer from it, so the
-      // two sides agree by construction instead of each carrying a constant of
-      // its own — which is how the browser came to hold thirty seconds while
-      // two minutes stood produced on disk (roadmap item 4).
-      lookaheadSeconds: lookaheadSeconds
-    });
-  } catch (error) {
-    if (error instanceof Error && error.code === "TRANSCODE_DISABLED") {
-      return reply.code(409).send({ error: error.message });
-    }
-    if (error?.code === OUTPUT_UNAVAILABLE) {
-      return replyOutputUnavailable(reply, error.details);
-    }
-    if (error?.code === OUTPUT_NO_CAPACITY) {
-      return replyNoCapacity(reply, error.details);
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    // Say why on the proxy's own log, not only in the answer. This route
-    // answered 500 for every viewer of proxy 2.9.101-2.9.102 (an undeclared
-    // constant) and the addon log carried nothing but the data-channel layer's
-    // bare "→ 500": the cause had to be recovered by replaying the request
-    // against the live proxy. The stack is worth the two lines it costs — a
-    // programming error here is invisible to the viewer, who only sees that
-    // nothing plays.
-    logger.error(
-      `transcode-sessions: ${sourceKey}:${fileIndex} failed to prepare: ${message}\n` +
-        `${error instanceof Error ? (error.stack ?? "") : ""}`
-    );
-    return reply.code(500).send({ error: `Failed to prepare transcode session: ${message}` });
-  }
-}
+/**
+ * Create or return an existing HLS transcode session for a torrent file.
+ *
+ * POST /api/transcode-sessions
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ viewerRequests: object, renditions: object, quality: object, outputs: object, lookaheadSeconds: number, sourceRegistry: object, torrentPool: object }} deps
+ * @returns {Promise<void>}
+ */
+
+import { logger } from "../../../utils/logger.js";
+import { OUTPUT_NO_CAPACITY, OUTPUT_UNAVAILABLE } from "../../../services/encode/output/index.js";
+import { replyNoCapacity, replyOutputUnavailable } from "../../../services/server/http-responses.js";
+
+/**
+ * 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 handleApiTranscodeSessionsPost(req, reply, { viewerRequests, renditions, quality, outputs, lookaheadSeconds, sourceRegistry, torrentPool }) {
+  const payload = getPayload(req.body);
+  const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
+  const fileIndex = Number(payload.fileIndex);
+  const transcodeVideo = payload.transcodeVideo === true;
+  const transcodeAudio = payload.transcodeAudio === true;
+  const consumerId = typeof payload.consumerId === "string" ? payload.consumerId.trim() : "";
+  const fileName = typeof payload.fileName === "string" ? payload.fileName.trim() : "";
+  const targetWidth = Number(payload.targetWidth);
+  const targetHeight = Number(payload.targetHeight);
+  // The picture as the viewer sees it, in physical pixels. For a re-encoded
+  // picture the height made is the smallest rung whose frame is not smaller
+  // than this (roadmap item 98); it takes the place of a target box.
+  const visibleWidth = Number(payload.visiblePicture?.width);
+  const visibleHeight = Number(payload.visiblePicture?.height);
+  const visiblePicture = visibleWidth > 0 && visibleHeight > 0
+    ? { width: Math.round(visibleWidth), height: Math.round(visibleHeight) }
+    : null;
+  // The target box is produced exactly (capped to source), with the realtime
+  // budget's auto-downscale and runtime downswitch off for this session.
+  //
+  // It says nothing about WHO asked — a rung sets it whether the viewer picked
+  // that rung or the player moved itself onto one.
+  const exactSize = payload.exactSize === true;
+  // Whether this browser will take its audio from a separate rendition group in
+  // the master playlist rather than muxed into the picture. It has to say so:
+  // publishing renditions AND muxing the same audio would play it twice, while
+  // a browser that does not know about them would get no sound at all.
+  const audioRenditions = payload.audioRenditions === true;
+  const startPositionSeconds = Number(payload.startPositionSeconds);
+  const viewerLinkMbps = Number(payload.viewerLinkMbps);
+  const linkSampleMbps = Number(payload.linkSampleMbps);
+  const linkSampleAt = Number(payload.linkSampleAt);
+  const linkSampleAgeMs = Number(payload.linkSampleAgeMs);
+  const bufferedAheadSec = Number(payload.bufferedAheadSec);
+  const bufferLimitSeconds = Number(payload.bufferLimitSeconds);
+  const audioTrackIndex = Number(payload.audioTrackIndex);
+  // Which container to produce. The browser knows what its media stack will
+  // accept for the tracks it asked to be copied; an absent or unknown value
+  // leaves the proxy's own `--segment-format` in charge.
+  const segmentFormatId =
+    typeof payload.segmentFormat === "string" ? payload.segmentFormat.trim() : "";
+
+  if (!sourceKey || !Number.isInteger(fileIndex) || fileIndex < 0) {
+    return reply.code(400).send({ error: "sourceKey and valid fileIndex are required." });
+  }
+  // The output is opened FOR somebody, and a viewer always has a name.
+  if (!consumerId) {
+    return reply.code(400).send({ error: "consumerId is required." });
+  }
+
+  try {
+    const session = await viewerRequests.createOrGetSession({
+      sourceKey,
+      fileIndex,
+      transcodeVideo,
+      transcodeAudio,
+      consumerId,
+      fileName,
+      targetWidth: Number.isInteger(targetWidth) && targetWidth > 0 ? targetWidth : 0,
+      targetHeight: Number.isInteger(targetHeight) && targetHeight > 0 ? targetHeight : 0,
+      exactSize,
+      visiblePicture,
+      audioRenditions,
+      startPositionSeconds:
+        Number.isFinite(startPositionSeconds) && startPositionSeconds > 0
+          ? startPositionSeconds
+          : 0,
+      viewerLinkMbps: Number.isFinite(viewerLinkMbps) && viewerLinkMbps > 0 ? viewerLinkMbps : null,
+      linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : null,
+      linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : null,
+      linkSampleAgeMs: Number.isFinite(linkSampleAgeMs) && linkSampleAgeMs >= 0 ? linkSampleAgeMs : null,
+      bufferedAheadSec: Number.isFinite(bufferedAheadSec) && bufferedAheadSec >= 0 ? bufferedAheadSec : 0,
+      bufferLimitSeconds:
+        Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : null,
+      audioTrackIndex:
+        Number.isInteger(audioTrackIndex) && audioTrackIndex > 0 ? audioTrackIndex : 0,
+      segmentFormatId
+    });
+    // The index of quality variants, when this session has more than one to
+    // offer. Its presence is what tells the browser it can change quality
+    // without a new session: the player switches variants itself, appending the
+    // new one after what is already buffered. Absent for a copied video, whose
+    // segments are cut at the source's own keyframes and so cannot be spliced
+    // with a re-encoded rung.
+    const hasVariants = renditions.buildMasterPlaylist(session.id) !== null;
+    return reply.send({
+      sessionId: session.id,
+      playlistPath: `/transcode/${session.id}/index.m3u8`,
+      ...(hasVariants
+        ? {
+            masterPath: `/transcode/${session.id}/master.m3u8`,
+            // Which of the master's variants this session IS. The browser pins
+            // the player to it, so loading the master costs nothing: an encoder
+            // is already producing that height, and any other rung would be a
+            // second cold start before the first frame.
+            variantHeight: outputs.variantHeightOf(session)
+          }
+        : {}),
+      // The heights this host will actually serve this file at, largest first
+      // — the ladder minus every rung it cannot produce faster than it is
+      // watched. The browser needs it whether or not a master exists: without
+      // it, it fell back to a ladder of its own invention and offered rungs the
+      // proxy had just refused, and picking one re-opened the session at a
+      // height measured at a third of realtime.
+      offeredHeights: quality.offeredHeights(session),
+      // What this session's output will carry, stated rather than left to be
+      // discovered. The browser checks what it actually got against this: a
+      // track that never arrives is otherwise noticed only by its absence,
+      // minutes later, as a black picture with working sound.
+      tracks: renditions.declaredTracks(session),
+      // How far ahead of the viewer this proxy lets the encoder run, in seconds
+      // of playback. The browser sizes its own forward buffer from it, so the
+      // two sides agree by construction instead of each carrying a constant of
+      // its own — which is how the browser came to hold thirty seconds while
+      // two minutes stood produced on disk (roadmap item 4).
+      lookaheadSeconds: lookaheadSeconds
+    });
+  } catch (error) {
+    if (error instanceof Error && error.code === "TRANSCODE_DISABLED") {
+      return reply.code(409).send({ error: error.message });
+    }
+    if (error?.code === OUTPUT_UNAVAILABLE) {
+      return replyOutputUnavailable(reply, error.details);
+    }
+    if (error?.code === OUTPUT_NO_CAPACITY) {
+      return replyNoCapacity(reply, error.details);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    // Say why on the proxy's own log, not only in the answer. This route
+    // answered 500 for every viewer of proxy 2.9.101-2.9.102 (an undeclared
+    // constant) and the addon log carried nothing but the data-channel layer's
+    // bare "→ 500": the cause had to be recovered by replaying the request
+    // against the live proxy. The stack is worth the two lines it costs — a
+    // programming error here is invisible to the viewer, who only sees that
+    // nothing plays.
+    logger.error(
+      `transcode-sessions: ${sourceKey}:${fileIndex} failed to prepare: ${message}\n` +
+        `${error instanceof Error ? (error.stack ?? "") : ""}`
+    );
+    return reply.code(500).send({ error: `Failed to prepare transcode session: ${message}` });
+  }
+}

package/routes/api/transcode-sessions/progress/get.js

@@ -1,27 +1,27 @@
-/**
- * Return the current encoding progress for an active HLS transcode session.
- *
- * GET /api/transcode-sessions/:sessionId/progress
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ viewerRequests: object }} deps
- * @returns {Promise<void>}
- */
-export async function handleApiTranscodeSessionsProgressGet(req, reply, { viewerRequests }) {
-  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  if (!sessionId) {
-    return reply.code(400).send({ error: "sessionId is required." });
-  }
-
-  // Whose progress. One picture serves everyone watching it, and after a
-  // quality change the stream on screen is another session — a different one
-  // for each viewer who changed.
-  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
-  const progress = await viewerRequests.getSessionProgress(sessionId, consumerId);
-  if (!progress) {
-    return reply.code(404).send({ error: "Transcode session was not found." });
-  }
-
-  return reply.send(progress);
-}
+/**
+ * Return the current encoding progress for an active HLS transcode session.
+ *
+ * GET /api/transcode-sessions/:sessionId/progress
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ viewerRequests: object }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleApiTranscodeSessionsProgressGet(req, reply, { viewerRequests }) {
+  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  if (!sessionId) {
+    return reply.code(400).send({ error: "sessionId is required." });
+  }
+
+  // Whose progress. One picture serves everyone watching it, and after a
+  // quality change the stream on screen is another session — a different one
+  // for each viewer who changed.
+  const consumerId = typeof req.query?.consumer === "string" ? req.query.consumer : "";
+  const progress = await viewerRequests.getSessionProgress(sessionId, consumerId);
+  if (!progress) {
+    return reply.code(404).send({ error: "Transcode session was not found." });
+  }
+
+  return reply.send(progress);
+}

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

@@ -1,41 +1,41 @@
-/**
- * Release a consumer from a transcode session.
- * When the last consumer is released the session is disposed automatically.
- *
- * POST /api/transcode-sessions/:sessionId/release
- *
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ lifecycle: object }} 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 handleApiTranscodeSessionReleasePost(req, reply, { lifecycle }) {
-  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
-  const payload = getPayload(req.body);
-  const consumerId = typeof payload.consumerId === "string" ? payload.consumerId.trim() : "";
-  const reason = typeof payload.reason === "string" ? payload.reason.trim() : "";
-  if (!sessionId || !consumerId) {
-    return reply.code(400).send({ error: "sessionId and consumerId are required." });
-  }
-
-  const released = await lifecycle.releaseSessionConsumer(sessionId, consumerId, reason);
-  if (!released) {
-    return reply.code(404).send({ error: "Transcode session was not found." });
-  }
-  return reply.send({ ok: true });
-}
+/**
+ * Release a consumer from a transcode session.
+ * When the last consumer is released the session is disposed automatically.
+ *
+ * POST /api/transcode-sessions/:sessionId/release
+ *
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ lifecycle: object }} 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 handleApiTranscodeSessionReleasePost(req, reply, { lifecycle }) {
+  const sessionId = typeof req.params.sessionId === "string" ? req.params.sessionId : "";
+  const payload = getPayload(req.body);
+  const consumerId = typeof payload.consumerId === "string" ? payload.consumerId.trim() : "";
+  const reason = typeof payload.reason === "string" ? payload.reason.trim() : "";
+  if (!sessionId || !consumerId) {
+    return reply.code(400).send({ error: "sessionId and consumerId are required." });
+  }
+
+  const released = await lifecycle.releaseSessionConsumer(sessionId, consumerId, reason);
+  if (!released) {
+    return reply.code(404).send({ error: "Transcode session was not found." });
+  }
+  return reply.send({ ok: true });
+}

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

@@ -1,63 +1,63 @@
-/**
- * @file POST /api/transcode-sessions/:sessionId/seek — the viewer's seek target.
- *
- * The browser reports WHERE THE VIEWER ACTUALLY SEEKED, explicitly, the moment
- * the scrub ends. This is the only authoritative source of that intent: the
- * position lives in the browser (`video.currentTime`) and nowhere else.
- *
- * Why this route exists at all: our synthetic VOD playlist advertises every
- * segment of the file, but segments only exist once ffmpeg has produced them.
- * A player is entitled by the HLS contract to fetch any advertised segment and
- * get it immediately, so when one 503s it legitimately probes elsewhere —
- * field log 2026-08-02 shows a correct target burst (#973..#985, the real seek)
- * followed by scattered probing across the whole file (#125, #173, #251, #326,
- * #478...). Inferring the target from that request stream made the encoder
- * restart at #519 — a probe, not the seek — and the viewer waited ten seconds
- * for a segment nobody wanted. Segment requests are data fetches, not commands;
- * the seek target now arrives here instead of being guessed from them.
- *
- * Mirrors how Jellyfin/Plex handle server-side seeking (an explicit start
- * position from the client), rather than heuristics over request patterns.
- */
-
-/**
- * @param {import("fastify").FastifyRequest} req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ viewerRequests: object }} deps
- * @returns {Promise<void>}
- */
-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);
-
-  if (!Number.isFinite(positionSeconds) || positionSeconds < 0) {
-    reply.code(400);
-    return reply.send({ error: "positionSeconds must be a non-negative number." });
-  }
-
-  // Who moved. A session can be shared, and the seeking viewer's own position
-  // 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() : "";
-  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
-    // replaces it.
-    reply.code(404);
-    return reply.send({ error: "No such transcode session." });
-  }
-
-  reply.code(204);
-  return reply.send();
-}
+/**
+ * @file POST /api/transcode-sessions/:sessionId/seek — the viewer's seek target.
+ *
+ * The browser reports WHERE THE VIEWER ACTUALLY SEEKED, explicitly, the moment
+ * the scrub ends. This is the only authoritative source of that intent: the
+ * position lives in the browser (`video.currentTime`) and nowhere else.
+ *
+ * Why this route exists at all: our synthetic VOD playlist advertises every
+ * segment of the file, but segments only exist once ffmpeg has produced them.
+ * A player is entitled by the HLS contract to fetch any advertised segment and
+ * get it immediately, so when one 503s it legitimately probes elsewhere —
+ * field log 2026-08-02 shows a correct target burst (#973..#985, the real seek)
+ * followed by scattered probing across the whole file (#125, #173, #251, #326,
+ * #478...). Inferring the target from that request stream made the encoder
+ * restart at #519 — a probe, not the seek — and the viewer waited ten seconds
+ * for a segment nobody wanted. Segment requests are data fetches, not commands;
+ * the seek target now arrives here instead of being guessed from them.
+ *
+ * Mirrors how Jellyfin/Plex handle server-side seeking (an explicit start
+ * position from the client), rather than heuristics over request patterns.
+ */
+
+/**
+ * @param {import("fastify").FastifyRequest} req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ viewerRequests: object }} deps
+ * @returns {Promise<void>}
+ */
+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);
+
+  if (!Number.isFinite(positionSeconds) || positionSeconds < 0) {
+    reply.code(400);
+    return reply.send({ error: "positionSeconds must be a non-negative number." });
+  }
+
+  // Who moved. A session can be shared, and the seeking viewer's own position
+  // 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() : "";
+  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
+    // replaces it.
+    reply.code(404);
+    return reply.send({ error: "No such transcode session." });
+  }
+
+  reply.code(204);
+  return reply.send();
+}

package/routes/health/get.js

@@ -1,13 +1,13 @@
-/**
- * Basic liveness check for load balancers and container orchestrators.
- *
- * GET /health
- *
- * @param {import("fastify").FastifyRequest} _req
- * @param {import("fastify").FastifyReply} reply
- * @param {{ version: string }} deps
- * @returns {Promise<void>}
- */
-export async function handleHealthGet(_req, reply, { version } = {}) {
-  return reply.send({ ok: true, version });
-}
+/**
+ * Basic liveness check for load balancers and container orchestrators.
+ *
+ * GET /health
+ *
+ * @param {import("fastify").FastifyRequest} _req
+ * @param {import("fastify").FastifyReply} reply
+ * @param {{ version: string }} deps
+ * @returns {Promise<void>}
+ */
+export async function handleHealthGet(_req, reply, { version } = {}) {
+  return reply.send({ ok: true, version });
+}