@torrent-tv/proxy 2.91.0 → 2.92.1

package/services/server/SegmentServing.js

@@ -28,11 +28,6 @@ const SEGMENT_READ_HIGH_WATER_MARK = 4 * 1024 * 1024;
  * @param {number} ms
  * @returns {Promise<void>}
  */
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
 /**
  * Guard against path traversal by restricting file names to the known
  * playlist and segment patterns produced by ffmpeg. Which segment names are
@@ -83,6 +78,18 @@ export class SegmentServing {
     state.waitListeners.clear();
   }
 
+  /** Observe storage and lifecycle before a request checks file availability. */
+  subscribeFileChange(sessionId) {
+    const output = isOutputName(sessionId) ? this.#host.outputs.get(sessionId) : null;
+    if (!output) return { changed: Promise.resolve(), release: () => {} };
+    const state = this.#stateFor(output);
+    let wake;
+    const changed = new Promise((resolve) => { wake = resolve; });
+    state.waitListeners.add(wake);
+    const stop = this.#host.segmentStore.subscribeChanges(output.outputKey ?? "", wake);
+    return { changed, release: () => { state.waitListeners.delete(wake); stop(); } };
+  }
+
   /**
    * Open a read stream for an HLS segment or playlist file from a session.
    *
@@ -295,6 +302,14 @@ export class SegmentServing {
       if (!isPlaylist && session.segmentFormat.needsSegmentRewrite) {
         const index = session.segmentFormat.segmentIndexFromName(fileName);
         const raw = await readFile(filePath);
+        // Players may fetch the init and first media segment concurrently.
+        // Both responses must use the same retained init before rewriting.
+        if (!this.#host.segmentStore.initOf(session.outputKey ?? "")) {
+          const init = cutsAtGivenTimes(session)
+            ? await this.#initFromFirstSegment(session)
+            : await readFile(path.join(this.#host.segmentStore.pathFor(session.outputKey ?? ""), session.segmentFormat.initFileName));
+          if (!this.#host.segmentStore.keepInit(session.outputKey ?? "", init)) return this.#failedOrWarming(session);
+        }
         // Self-contained pieces carry the init header; a media segment must not.
         const bytes = cutsAtGivenTimes(session) && session.segmentFormat.stripInit
           ? session.segmentFormat.stripInit(raw)
@@ -615,6 +630,16 @@ export class SegmentServing {
   }
 
   #holdForProduction(session, fileName, isPlaylist, options) {
+    let ranked = null;
+    if (!isPlaylist) {
+      const index = session.segmentFormat.segmentIndexFromName(fileName);
+      const address = session.outputKey ?? "";
+      const { rank, topRank } = this.#host.encodeOrchestrator.rankAt(address, index);
+      ranked = { address, rank, topRank };
+      if (Number.isFinite(index) && topRank > 0 && rank === 0) {
+        return { kind: "superseded", ranked };
+      }
+    }
     // The file is not there and production has ended in an error: nothing is
     // going to write it, so the viewer is told instead of held.
     if (this.#host.encodeRuns.hasFailed(session)) {
@@ -625,10 +650,8 @@ export class SegmentServing {
       // the truthful answer: nothing is broken and there is nothing for the
       // viewer to retry. Only what is NOT on disk is held for it — a piece that
       // exists is whole, and it is served whatever the encoder is doing.
-      return { kind: "warming-up" };
+      return { kind: "warming-up", ranked };
     }
-    /** @type {{ address: string, rank: number, topRank: number } | null} */
-    let ranked = null;
     if (!isPlaylist) {
       this.#explainHold(session, fileName, "the file is not on disk");
     }
@@ -654,22 +677,6 @@ export class SegmentServing {
       // discarded at the one point where a viewer measurably waits for a named
       // segment; it goes back out with the answer, because the wait is measured
       // by whoever holds the request.
-      const address = session.outputKey ?? "";
-      const { rank, topRank } = this.#host.encodeOrchestrator.rankAt(address, requestedIndex);
-      ranked = { address, rank, topRank };
-      const nobodyIsComing = topRank > 0 && rank === 0;
-      if (
-        Number.isFinite(requestedIndex) &&
-        requestedIndex < (this.#host.encodeRuns.earliestStartOf(session) ?? 0) &&
-        nobodyIsComing &&
-        this.#host.encodeRuns.liveRunsOf(session).length > 0
-      ) {
-        logger.info(
-          `transcode ${session.id} segment #${requestedIndex} is ${(this.#host.encodeRuns.earliestStartOf(session) ?? 0) - requestedIndex} ` +
-          "segments behind the run and in nobody's zone; answered as absent rather than held"
-        );
-        return { kind: "not-found", ranked };
-      }
       this.#noteWanted(session, requestedIndex);
     }
     return { kind: "warming-up", ranked };
@@ -996,9 +1003,7 @@ export class SegmentServing {
   }
 
   /**
-   * Poll until the HLS playlist file exists and contains a valid `#EXTM3U`
-   * header, or until the session fails, or until the startup timeout elapses.
-   * Throws with message `"HLS playlist is still warming up."` on timeout.
+   * Wait for a valid HLS playlist or a terminal output state, without polling.
    *
    * @param {HlsSession} session
    * @returns {Promise<void>}
@@ -1016,9 +1021,9 @@ export class SegmentServing {
     }
 
     const playlistPath = path.join(this.#host.segmentStore.pathFor(session.outputKey ?? ""), PLAYLIST_FILE_NAME);
-    const deadline = Date.now() + this.#host.startupWaitMs;
-
-    while (Date.now() < deadline) {
+    while (this.#host.outputs.get(session.id) === session) {
+      const change = this.subscribeFileChange(session.id);
+      try {
       if (this.#host.encodeRuns.hasFailed(session)) {
         throw new Error(this.#host.encodeRuns.lastErrorOf(session) || "ffmpeg failed to start HLS session.");
       }
@@ -1031,10 +1036,12 @@ export class SegmentServing {
       } catch (_error) {
         // Playlist is not ready yet.
       }
-      await delay(250);
+      await change.changed;
+      } finally {
+        change.release();
+      }
     }
-
-    throw new Error("HLS playlist is still warming up.");
+    throw new Error("HLS output was disposed before its playlist became available.");
   }
 
   /**

package/services/server/ViewerRequests.js

@@ -71,6 +71,7 @@ export class ViewerRequests {
    * @returns {Promise<import("../encode/output/EncodedOutput.js").EncodedOutput>}
    */
   async createOrGetSession({ consumerId = "", ...request }) {
+    request.signal?.throwIfAborted();
     const requestStartedAt = Date.now();
     // What this viewer's link last measured, where the request does not say:
     // a viewer who comes back to open another film has a link this proxy has
@@ -90,6 +91,7 @@ export class ViewerRequests {
     // state nothing has every encoder on it stopped.
     const claim = consumerId
       ? (candidate) => {
+          request.signal?.throwIfAborted();
           alreadyOn = this.#host.viewers.forOutput(candidate).has(consumerId);
           const answer = alreadyOn
             ? { admitted: true, reason: "already watching it", speedX: null }
@@ -105,6 +107,7 @@ export class ViewerRequests {
       viewerLinkMbps,
       claim
     });
+    request.signal?.throwIfAborted();
     if (consumerId) {
       const joined = existed && !alreadyOn;
       // What THIS viewer wants of the sound, which an output they are joining
@@ -558,6 +561,7 @@ export class ViewerRequests {
     }
 
     const sourceMeasurements = new Map();
+    const sourceForecasts = new Map();
     const tracks = [];
     for (const output of outputs) {
       const trackProgress = output === session ? progress : this.#host.encodeRuns.progressOf(output);
@@ -580,6 +584,7 @@ export class ViewerRequests {
           index,
           startSeconds: timeline.publishedStartOf(index),
           endSeconds: timeline.publishedStartOf(index + 1),
+          sourceInputs: this.#host.sourceInputsFor?.(output, index) ?? undefined,
           mediaRanges: ranges && output.segmentFormat?.servedMediaRanges ?
             output.segmentFormat.servedMediaRanges(ranges, { initBytes: sessionInit }) : undefined
         };
@@ -596,34 +601,25 @@ export class ViewerRequests {
         if (sourceMeasurements.has(sourceId)) {
           continue;
         }
-        const sourceFile = fileIndex === output.file.fileIndex
-          ? output.file
-          : this.#host.sourceFiles.get(output.file.sourceKey, fileIndex);
         let stats = null;
         try {
-          stats = await this.#host.getSourceStats?.(output.file.sourceKey, fileIndex) ?? null;
+          stats = await this.#host.getSourceStats?.(output.file.sourceKey, fileIndex,
+            { forecast: !sourceForecasts.has(output.file.sourceKey) }) ?? null;
         } catch {
           stats = null;
         }
-        const sourceTrend = this.#downloadRateReadings(
-          measurement,
-          output.file.sourceKey,
-          stats?.downloadSpeed,
-          now
-        );
-        const fileLength = Number(stats?.fileLength);
-        const downloaded = Number(stats?.fileDownloaded);
-        const sourceDuration = Number(sourceFile?.durationSeconds);
+        if (!sourceForecasts.has(output.file.sourceKey)) sourceForecasts.set(output.file.sourceKey, stats?.downloadForecast ?? { ranges: [] });
+        const sharedForecast = sourceForecasts.get(output.file.sourceKey);
+        const downloadForecast = sharedForecast.global ? { measuredAt: sharedForecast.measuredAt,
+          ranges: !stats ? [] : sharedForecast.ranges.map(range => ({ ...range,
+            start: Math.max(0, range.start - stats.fileOffset),
+            end: Math.min(stats.fileLength, range.end - stats.fileOffset)
+          })).filter(range => range.end > range.start) } : sharedForecast;
         sourceMeasurements.set(sourceId, {
           id: sourceId,
-          serviceId: output.file.sourceKey,
-          complete: Number.isFinite(fileLength) && fileLength > 0 && downloaded >= fileLength,
-          bytesPerMediaSecond: Number.isFinite(fileLength) && fileLength > 0 &&
-            Number.isFinite(sourceDuration) && sourceDuration > 0
-            ? fileLength / sourceDuration
-            : 0,
-          readings: sourceTrend,
+          complete: stats?.fileAvailable === true,
           residence: stats?.residence,
+          downloadForecast,
         });
       }
 
@@ -661,12 +657,6 @@ export class ViewerRequests {
         measurement.tracks.delete(id);
       }
     }
-    const activeDownloadServices = new Set([...sourceMeasurements.values()].map(({ serviceId }) => serviceId));
-    for (const id of measurement.downloads.keys()) {
-      if (!activeDownloadServices.has(id)) {
-        measurement.downloads.delete(id);
-      }
-    }
     const bufferedAheadSeconds = Number(viewerReading?.bufferedAheadSec);
     const positionSeconds = Number.isFinite(viewerReading?.positionSeconds)
       ? viewerReading.positionSeconds
@@ -727,7 +717,11 @@ export class ViewerRequests {
         bufferLimitSeconds: input.bufferLimitSeconds,
         lookaheadSeconds: input.lookaheadSeconds,
         link: input.linkReadings,
-        sources: input.sources,
+        sources: input.sources.map(({ id, complete, residence, downloadForecast }) => ({
+          id, complete, residenceRanges: residence?.length ?? 0,
+          forecastAt: downloadForecast?.measuredAt ?? null, plannedPieces: downloadForecast?.ranges.length ?? 0,
+          unknownPieces: downloadForecast?.ranges.filter(range => range.availableAt === null).length ?? 0
+        })),
         tracks: tracks.map(({ id, processedSeconds, readings, segments, readySegmentIndices }) => ({
           id, processedSeconds, readings, segments: segments.length, prepared: readySegmentIndices.length
         }))
@@ -745,25 +739,12 @@ export class ViewerRequests {
     const id = typeof consumerId === "string" ? consumerId : "";
     let state = byViewer.get(id);
     if (!state) {
-      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), downloads: new Map(), tracks: new Map() };
+      state = { link: new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds), tracks: new Map() };
       byViewer.set(id, state);
     }
     return state;
   }
 
-  #downloadRateReadings(state, serviceId, downloadSpeed, now) {
-    let trend = state.downloads.get(serviceId);
-    if (!trend) {
-      trend = new this.#host.playbackReadiness.RateTrend(this.#host.lookaheadSeconds);
-      state.downloads.set(serviceId, trend);
-    }
-    const speed = Number(downloadSpeed);
-    if (Number.isFinite(speed) && speed >= 0) {
-      trend.add(now, speed);
-    }
-    return trend.snapshot();
-  }
-
   #trackRateReadings(state, output, now) {
     const id = output.outputKey;
     let trend = state.tracks.get(id);

package/services/server/controllers/PlaybackController.js

@@ -34,6 +34,10 @@ export class PlaybackController {
     return this.playbackPlanner.getPlan(params);
   }
 
+  async getReadyPlan(params, options) {
+    return this.playbackPlanner.getReadyPlan(params, options);
+  }
+
   async refreshAudioTracks(params) {
     return this.playbackPlanner.refreshAudioTracks(params);
   }

package/services/server/controllers/SubtitleController.js

@@ -7,23 +7,6 @@
  * language detection) stays in orchestrator/domain.
  */
 
-const EXTERNAL_MAX_BYTES = 8 * 1024 * 1024;
-
-function readFileFully(file, maxBytes) {
-  return new Promise((resolve, reject) => {
-    const stream = file.createReadStream();
-    const chunks = [];
-    let total = 0;
-    stream.on("data", (chunk) => {
-      total += chunk.length;
-      if (total > maxBytes) { stream.destroy(); reject(new Error("subtitle file exceeds size cap")); return; }
-      chunks.push(chunk);
-    });
-    stream.on("end", () => resolve(Buffer.concat(chunks)));
-    stream.on("error", reject);
-  });
-}
-
 export class SubtitleController {
   /**
    * @param {object} deps
@@ -45,25 +28,19 @@ export class SubtitleController {
    * Serve external subtitle file or embedded track.
    * Returns { vtt, language, headers } or { error, status }.
    */
-  async getSubtitle({ sourceKey, fileIndex, trackIndex, since, after }) {
+  async getSubtitle({ sourceKey, fileIndex, trackIndex, since, after, signal }) {
     const rec = this.sourceRegistry.get(sourceKey);
     if (!rec) return { error: "Source key was not found.", status: 404 };
-    const torrent = await this.torrentPool.getTorrent(rec.sourceType, rec.source);
+    const torrent = this.torrentPool.knownTorrent(sourceKey);
+    if (!torrent) return { pending: true, status: 202 };
     const file = torrent.files[fileIndex];
     if (!file) return { error: "File index was not found in torrent.", status: 404 };
 
     const hasTrack = trackIndex !== undefined && trackIndex !== "" && Number.isFinite(Number(trackIndex));
     if (!hasTrack) {
-      const name = file.name ?? "";
-      const ext = name.slice(name.lastIndexOf(".")).toLowerCase();
-      try {
-        const bytes = await readFileFully(file, EXTERNAL_MAX_BYTES);
-        const converted = this.orchestrator.fileAsVtt(bytes, ext);
-        if (!converted) return { error: `Unsupported subtitle format: ${ext}`, status: 422 };
-        return { ...converted, headers: {} };
-      } catch (e) {
-        return { error: `Could not read subtitle file: ${e?.message ?? e}`, status: 502 };
-      }
+      const document = await this.orchestrator.waitForDocument(sourceKey, fileIndex, signal);
+      if (document.kind === "terminal") return { error: document.message ?? document.reason, status: 422 };
+      return { ...document.value, headers: {} };
     }
 
     const idx = Number(trackIndex);
@@ -72,6 +49,8 @@ export class SubtitleController {
     // Resolve via orchestrator (domain: cluster walk or MP4 sample ranges)
     const tracks = await this.orchestrator.getTracks(torrent, fileIndex, sourceKey);
     const track = Array.isArray(tracks) ? tracks.find((c) => c.declaredIndex === idx) ?? null : null;
+    if (!track && this.orchestrator.hasTrackDeclaration(sourceKey, fileIndex)) return { error: "Subtitle track index was not found.", status: 422 };
+    if (track?.isTextBased?.() === false) return { error: "The subtitle track is not supported.", status: 422 };
     // Also try domain's declaredIndex-agnostic lookup via getCues path — keep compat with existing subtitle-cues declaredIndex
     let held = null;
     try {

package/services/server/transcode-session-files.js

@@ -1,7 +1,6 @@
 import { logger } from "../../utils/logger.js";
 import { bandOf, waits } from "./WaitLedger.js";
 
-const HOLD_HEADER = "x-hold-ms";
 /**
  * Which viewer is asking, or an empty string where the transport names nobody.
  *
@@ -57,8 +56,7 @@ export function refusedAsStale(req, reply, viewerRequests, fileName) {
     `[hold] ${fileName} refused: made in generation ${stated} of ${consumerId}, ` +
     `a viewing they have left and whose window for new requests has passed`
   );
-  reply.header("Retry-After", "0");
-  reply.code(503).send({ error: "Made for a viewing that has been left." });
+  reply.code(409).send({ error: "Made for a viewing that has been left.", reason: "request-obsolete", canRetry: false });
   return true;
 }
 
@@ -83,22 +81,8 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
   // 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 = consumerOf(req);
-  // 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.
+  // Readiness or a terminal state ends the wait. A caller leaving cancels it;
+  // elapsed time is not evidence that media preparation failed.
   const holdStartedAt = Date.now();
   let clientAborted = false;
   let onClientAbort = () => {};
@@ -108,17 +92,26 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
       resolve();
     };
   });
-  req.raw.on("close", onClientAbort);
-  const statedHoldMs = Number(req.headers?.[HOLD_HEADER]);
+  const onResponseClose = () => { if (!reply.raw?.writableEnded) onClientAbort(); };
+  req.raw.on("aborted", onClientAbort);
+  reply.raw?.on("close", onResponseClose);
 
-  const result = await waitForSessionFile(serving, sessionId, fileName, {
-    holdMs: Number.isFinite(statedHoldMs) && statedHoldMs > 0 ? statedHoldMs : Number.POSITIVE_INFINITY,
-    until: clientGone,
-    consumerId
-  });
-
-  req.raw.off("close", onClientAbort);
+  let result;
+  try {
+    result = await waitForSessionFile(serving, sessionId, fileName, {
+      until: clientGone,
+      consumerId
+    });
+  } finally {
+    req.raw.off("aborted", onClientAbort);
+    reply.raw?.off("close", onResponseClose);
+  }
   const heldMs = Date.now() - holdStartedAt;
+  if (clientAborted || result.kind === "cancelled") {
+    logger.info(`[hold] request=${req.id ?? "unknown"} ${fileName} cancelled after ${heldMs}ms`);
+    result.stream?.destroy?.();
+    return;
+  }
   if (result.isPlaylist !== true) {
     const outcome = clientAborted
       ? "client-aborted"
@@ -156,36 +149,10 @@ export async function serveSessionFile(req, reply, { serving, viewerRequests, se
       `[hold] ${fileName} refused: the viewer is at ` +
       `${viewerRequests.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)
-    });
+    return reply.code(409).send({ error: "Superseded by a seek.", reason: "request-obsolete", canRetry: false });
   }
   if (result.kind === "failed") {
-    return reply.code(500).send({ error: result.message });
+    return reply.code(500).send({ error: result.message, canRetry: false });
   }
 
   if (result.isPlaylist) {
@@ -230,8 +197,7 @@ function holdWhileSending(reply, stream, release) {
 /**
  * Ask `serving.getFileStream()` again each time the file may have become
  * available — a segment's publication, or a waited-on invalidation — until it
- * is, the session fails, the requester's stated wait runs out, or the
- * requester goes.
+ * is, the session fails, the request becomes obsolete, or the requester goes.
  *
  * @param {object} serving - `services/server/SegmentServing.js`
  * @param {string} sessionId
@@ -246,8 +212,29 @@ function holdWhileSending(reply, stream, release) {
  *   viewers, and the seek epoch belongs to all of them.
  * @returns {Promise<Awaited<ReturnType<import("./SegmentServing.js").SegmentServing["getFileStream"]>>>}
  */
-export async function waitForSessionFile(serving, sessionId, fileName, { holdMs, until = null, consumerId = "" }) {
-  const startedAt = Date.now();
+export async function waitForRequestedFile(req, reply, serving, sessionId, fileName, consumerId) {
+  let cancel;
+  const until = new Promise(resolve => { cancel = resolve; });
+  let gone = false;
+  const aborted = () => { gone = true; cancel(); };
+  const closed = () => { if (!reply.raw?.writableEnded) aborted(); };
+  req.raw?.on?.("aborted", aborted);
+  reply.raw?.on?.("close", closed);
+  if (req.raw?.aborted || reply.raw?.destroyed) aborted();
+  try {
+    const result = await waitForSessionFile(serving, sessionId, fileName, { until, consumerId });
+    if (gone) {
+      result.stream?.destroy?.();
+      return { kind: "cancelled" };
+    }
+    return result;
+  } finally {
+    req.raw?.off?.("aborted", aborted);
+    reply.raw?.off?.("close", closed);
+  }
+}
+
+export async function waitForSessionFile(serving, sessionId, fileName, { until = null, consumerId = "" } = {}) {
   let gone = false;
   const requesterGone = until ? until.then(() => { gone = true; }) : new Promise(() => {});
   // The viewer's position when this request was made. A seek makes every held
@@ -259,8 +246,14 @@ export async function waitForSessionFile(serving, sessionId, fileName, { holdMs,
   let seekEpoch = serving.seekEpoch(sessionId);
   /** @type {{ address: string, rank: number, topRank: number } | null} */
   let lastRanked = null;
-  while (!gone && Date.now() - startedAt < holdMs) {
+  while (!gone) {
+    const change = serving.subscribeFileChange(sessionId);
+    try {
     const result = await serving.getFileStream(sessionId, fileName, { consumerId });
+    if (gone) {
+      result.stream?.destroy?.();
+      return { kind: "cancelled" };
+    }
     if (result.kind !== "warming-up") {
       return result;
     }
@@ -282,44 +275,10 @@ export async function waitForSessionFile(serving, sessionId, fileName, { holdMs,
     // 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;
-    const remaining = Math.max(0, holdMs - (Date.now() - startedAt));
-    const waitedForSegment = await serving.waitForSegment(sessionId, fileName, remaining, until);
-    if (!waitedForSegment && !gone) {
-      // Playlists and init files are not segment publications.
-      await Promise.race([delay(Math.min(300, remaining)), requesterGone]);
+    await Promise.race([change.changed, requesterGone]);
+    } finally {
+      change.release();
     }
   }
-  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.";
+  return { kind: "cancelled", ranked: lastRanked };
 }