@torrent-tv/proxy 2.73.0 → 2.74.0

package/services/controllers/SubtitleController.js

@@ -1,127 +1,128 @@
-/**
- * @file Subtitle controller — interface layer over SubtitleOrchestrator.
- *
- * Routes (HTTP or data-channel) call this, not the domain module directly.
- * Handles external files vs embedded tracks branching, header setting, and
- * cursor/covered-cluster bookkeeping. Domain work (cluster walk, conversion,
- * language detection) stays in orchestrator/domain.
- */
-
-import { subtitleOrchestrator } from "../orchestrators/SubtitleOrchestrator.js";
-import { convertSubtitleToVtt, cuesToVtt, decodeSubtitleBytes, finalizeCues } from "../subtitle-convert.js";
-import { detectLanguage, detectLanguageFromVtt } from "../language-detect.js";
-
-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 {
-  constructor({ sourceRegistry, torrentPool }) {
-    this.sourceRegistry = sourceRegistry;
-    this.torrentPool = torrentPool;
-    this.orchestrator = subtitleOrchestrator;
-  }
-
-  /**
-   * Serve external subtitle file or embedded track.
-   * Returns { vtt, language, headers } or { error, status }.
-   */
-  async getSubtitle({ sourceKey, fileIndex, trackIndex, since, after }) {
-    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 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();
-      const release = this.torrentPool.acquireFile(torrent, fileIndex);
-      try {
-        const bytes = await readFileFully(file, EXTERNAL_MAX_BYTES);
-        const text = decodeSubtitleBytes(bytes);
-        const vtt = convertSubtitleToVtt(text, ext);
-        if (!vtt) return { error: `Unsupported subtitle format: ${ext}`, status: 422 };
-        // The language is read from the CONVERTED document, not from the file.
-        // The conversion has already dropped everything that is not the words —
-        // and on an ASS file that is half of it, in Latin letters, which is what
-        // made a Russian track answer `en` (field 2026-09-01, and the whole of
-        // `research/subtitle-language-ass-markup-2026-09-01.md`).
-        return { vtt, language: detectLanguageFromVtt(vtt), headers: {} };
-      } catch (e) {
-        return { error: `Could not read subtitle file: ${e?.message ?? e}`, status: 502 };
-      } finally {
-        release();
-      }
-    }
-
-    const idx = Number(trackIndex);
-    if (!Number.isInteger(idx) || idx < 0) return { error: "trackIndex must be a non-negative integer.", status: 400 };
-
-    // 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;
-    // Also try domain's declaredIndex-agnostic lookup via getCues path — keep compat with existing subtitle-cues declaredIndex
-    let held = null;
-    try {
-      // Need trackNumber for domain call — find via declared workspace
-      const domainTracks = await this.orchestrator.getDeclaredTracks(torrent, fileIndex, sourceKey);
-      // If not found, fall back to direct cuesHeldFor via trackNumber from tracks list
-      const target = track ?? domainTracks.find((t) => t.declaredIndex === idx) ?? null;
-      const trackNumber = target?.trackNumber ?? track?.trackNumber;
-      if (trackNumber != null) {
-        held = await this.orchestrator.getCues(torrent, fileIndex, sourceKey, trackNumber);
-      }
-    } catch {}
-    if (held && Array.isArray(held.cues)) {
-      const cursor = held.cues.reduce((h, c) => Math.max(h, Number(c.seq) || 0), 0);
-      const fresh = Number.isInteger(since) ? held.cues.filter((c) => (Number(c.seq) || 0) > since)
-        : Number.isFinite(after) ? held.cues.filter((c) => c.startSeconds > after) : held.cues;
-      const codecId = held.track?.codecId ?? track?.codecId ?? "";
-      const vtt = cuesToVtt(fresh, codecId);
-      // Two things this reads, and each of them was wrong before 2.68.1.
-      //
-      // It reads the cues through `finalizeCues`, so what reaches the detector
-      // is the words and not ASS's `{\…}` override groups, which are Latin on a
-      // Russian track. (The dialogue row's own fields are gone earlier now, in
-      // the container that framed them — before 2.72.1 they were not gone at
-      // all, and the detector was reading them too.)
-      //
-      // And it reads EVERY cue held so far, not the `fresh` subset that is
-      // being sent. A re-subscription after a reconnect asks only for what this
-      // page missed, which can be three lines, and three lines are not a sample
-      // of a language.
-      const language = detectLanguage(
-        finalizeCues(held.cues, codecId).map((cue) => cue.text).join("\n")
-      );
-      return {
-        vtt,
-        language,
-        headers: {
-          "X-Subtitle-Covered-Clusters": String(held.coveredClusters ?? 0),
-          "X-Subtitle-Indexed-Clusters": String(held.indexedClusters ?? 0),
-          "X-Subtitle-Cursor": String(cursor)
-        }
-      };
-    }
-    return { pending: true, status: 202 };
-  }
-
-  async warm(torrent, fileIndex, sourceKey) {
-    return this.orchestrator.warm(torrent, fileIndex, sourceKey);
-  }
-}
+/**
+ * @file Subtitle controller — interface layer over SubtitleOrchestrator.
+ *
+ * Routes (HTTP or data-channel) call this, not the domain module directly.
+ * Handles external files vs embedded tracks branching, header setting, and
+ * cursor/covered-cluster bookkeeping. Domain work (cluster walk, conversion,
+ * language detection) stays in orchestrator/domain.
+ */
+
+import { subtitleOrchestrator } from "../orchestrators/SubtitleOrchestrator.js";
+import { SubtitleFileContainer } from "../container/SubtitleFileContainer.js";
+import { TextSubtitleTrack } from "../tracks/TextSubtitleTrack.js";
+import { detectLanguage } from "../language-detect.js";
+
+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 {
+  constructor({ sourceRegistry, torrentPool }) {
+    this.sourceRegistry = sourceRegistry;
+    this.torrentPool = torrentPool;
+    this.orchestrator = subtitleOrchestrator;
+  }
+
+  /**
+   * Serve external subtitle file or embedded track.
+   * Returns { vtt, language, headers } or { error, status }.
+   */
+  async getSubtitle({ sourceKey, fileIndex, trackIndex, since, after }) {
+    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 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();
+      const release = this.torrentPool.acquireFile(torrent, fileIndex);
+      try {
+        const bytes = await readFileFully(file, EXTERNAL_MAX_BYTES);
+        const text = SubtitleFileContainer.decodeBytes(bytes);
+        const vtt = SubtitleFileContainer.toVtt(text, ext);
+        if (!vtt) return { error: `Unsupported subtitle format: ${ext}`, status: 422 };
+        // The language is read from the CONVERTED document, not from the file.
+        // The conversion has already dropped everything that is not the words —
+        // and on an ASS file that is half of it, in Latin letters, which is what
+        // made a Russian track answer `en` (field 2026-09-01, and the whole of
+        // `research/subtitle-language-ass-markup-2026-09-01.md`).
+        return { vtt, language: TextSubtitleTrack.detectLanguageFromVtt(vtt), headers: {} };
+      } catch (e) {
+        return { error: `Could not read subtitle file: ${e?.message ?? e}`, status: 502 };
+      } finally {
+        release();
+      }
+    }
+
+    const idx = Number(trackIndex);
+    if (!Number.isInteger(idx) || idx < 0) return { error: "trackIndex must be a non-negative integer.", status: 400 };
+
+    // 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;
+    // Also try domain's declaredIndex-agnostic lookup via getCues path — keep compat with existing subtitle-cues declaredIndex
+    let held = null;
+    try {
+      // Need trackNumber for domain call — find via declared workspace
+      const domainTracks = await this.orchestrator.getDeclaredTracks(torrent, fileIndex, sourceKey);
+      // If not found, fall back to direct cuesHeldFor via trackNumber from tracks list
+      const target = track ?? domainTracks.find((t) => t.declaredIndex === idx) ?? null;
+      const trackNumber = target?.trackNumber ?? track?.trackNumber;
+      if (trackNumber != null) {
+        held = await this.orchestrator.getCues(this.torrentPool, torrent, fileIndex, sourceKey, trackNumber);
+      }
+    } catch {}
+    if (held && Array.isArray(held.cues)) {
+      const cursor = held.cues.reduce((h, c) => Math.max(h, Number(c.seq) || 0), 0);
+      const fresh = Number.isInteger(since) ? held.cues.filter((c) => (Number(c.seq) || 0) > since)
+        : Number.isFinite(after) ? held.cues.filter((c) => c.startSeconds > after) : held.cues;
+      const codecId = held.track?.codecId ?? track?.codecId ?? "";
+      const vtt = TextSubtitleTrack.cuesToVtt(fresh, codecId);
+      // Two things this reads, and each of them was wrong before 2.68.1.
+      //
+      // It reads the cues through `finalizeCues`, so what reaches the detector
+      // is the words and not ASS's `{\…}` override groups, which are Latin on a
+      // Russian track. (The dialogue row's own fields are gone earlier now, in
+      // the container that framed them — before 2.72.1 they were not gone at
+      // all, and the detector was reading them too.)
+      //
+      // And it reads EVERY cue held so far, not the `fresh` subset that is
+      // being sent. A re-subscription after a reconnect asks only for what this
+      // page missed, which can be three lines, and three lines are not a sample
+      // of a language.
+      const language = detectLanguage(
+        TextSubtitleTrack.finalizeCues(held.cues, codecId).map((cue) => cue.text).join("\n")
+      );
+      return {
+        vtt,
+        language,
+        headers: {
+          "X-Subtitle-Covered-Clusters": String(held.coveredClusters ?? 0),
+          "X-Subtitle-Indexed-Clusters": String(held.indexedClusters ?? 0),
+          "X-Subtitle-Cursor": String(cursor)
+        }
+      };
+    }
+    return { pending: true, status: 202 };
+  }
+
+  async warm(torrent, fileIndex, sourceKey) {
+    return this.orchestrator.warm(torrent, fileIndex, sourceKey);
+  }
+}

package/services/delivery-probe.js

@@ -69,7 +69,22 @@ export const PROBE_INTERVAL_MS = 500;
  * measurable on the same connection, so it is measured and added rather than
  * assumed.
  *
- * @param {{ queuedBytes: number, bytesPerSecond: number, rttMs: number, echoIntervalMs?: number, intervalMs?: number }} state
+ * There is a fourth term, and without it the third one arrives too late to
+ * help. `echoIntervalMs` is the widest gap between two echoes this connection
+ * has SHOWN, so it can only grow after a late echo has landed — and a browser
+ * whose tab has just been hidden goes quiet before it has taught us anything.
+ * The browser measures its own event-loop delay and puts it in every echo, so
+ * the delay is known BEFORE the silence rather than after it: an echo timer
+ * set for half a second cannot fire until the loop runs, and a loop reported
+ * as 4297 ms behind cannot answer sooner than that. Field 2026-09-03: a viewer
+ * paused at 15:24:21, the tab went hidden at 15:24:35, `loopLag` climbed
+ * 681 → 1881 → 4297 → 5957 ms, and at 15:26:05 the probes read `gap 12 of 11`
+ * and printed `association-stopped` on a connection that was `flowing` again
+ * seven seconds later. Adding the peer's own reported lag makes that allowance
+ * 15 instead of 11, and the gap of 12 is then what it was — a browser whose
+ * timers are frozen, not an association that stopped.
+ *
+ * @param {{ queuedBytes: number, bytesPerSecond: number, rttMs: number, echoIntervalMs?: number, peerLoopLagMs?: number, intervalMs?: number }} state
  * @returns {number | null} Probes that may legitimately be outstanding, or null
  *   when no rate has been measured yet and nothing can be said.
  */
@@ -78,13 +93,18 @@ export function allowedGap({
   bytesPerSecond,
   rttMs,
   echoIntervalMs = 0,
+  peerLoopLagMs = 0,
   intervalMs = PROBE_INTERVAL_MS
 }) {
   if (!(bytesPerSecond > 0) || !(intervalMs > 0)) {
     return null;
   }
   const drainMs = (Math.max(queuedBytes, 0) / bytesPerSecond) * 1000;
-  const waitMs = drainMs + Math.max(rttMs, 0) + Math.max(echoIntervalMs, 0);
+  const waitMs =
+    drainMs +
+    Math.max(rttMs, 0) +
+    Math.max(echoIntervalMs, 0) +
+    Math.max(peerLoopLagMs, 0);
   // At least one: a probe sent and not yet echoed is the ordinary state.
   return Math.max(1, Math.ceil(waitMs / intervalMs));
 }
@@ -149,6 +169,8 @@ export function probeWedgeIsCertain({ stuckForMs, longestHealthySeenGapMs, inter
  * @property {number} longestHealthySeenGapMs - The longest gap between two advances this connection has shown while not flagged as a wedge.
  * @property {number | null} peerBytes - The far end's transport-level received total, as last reported.
  * @property {number | null} peerBytesAtTick - The same, as it stood at the previous tick.
+ * @property {number | null} peerLoopLagMs - The far end's own event-loop delay, as last reported.
+ * @property {string | null} peerVisibility - Whether the far end's tab is visible or hidden, as last reported.
  * @property {boolean} probeCaptureStarted - One evidence-gathering attempt per wedge; reset once `seen` advances again.
  * @property {ReturnType<typeof setInterval> | null} timer
  */
@@ -185,7 +207,12 @@ export function probeWedgeIsCertain({ stuckForMs, longestHealthySeenGapMs, inter
  * behind the probes are. `null` where the far end does not report it, and then
  * the rule falls back to what it says without the term.
  *
- * @param {{ seq: number, seen: Map<string, number> | Record<string, number>, labels: string[], echoes: number, echoAgeMs: number | null, allowed?: Map<string, number | null> | Record<string, number | null>, echoStaleMs?: number, peerBytesAdvancing?: boolean | null }} state
+ * `peerLoopLagMs` and `peerVisibility` are printed but never compared against
+ * anything here: they are what made the allowance as wide as it is, and a
+ * reader of the log cannot check that arithmetic unless the terms are on the
+ * same line as the result.
+ *
+ * @param {{ seq: number, seen: Map<string, number> | Record<string, number>, labels: string[], echoes: number, echoAgeMs: number | null, allowed?: Map<string, number | null> | Record<string, number | null>, echoStaleMs?: number, peerBytesAdvancing?: boolean | null, peerLoopLagMs?: number | null, peerVisibility?: string | null }} state
  * @returns {{ verdict: string, detail: string }}
  */
 export function readProbeState(state) {
@@ -224,7 +251,9 @@ export function readProbeState(state) {
     `echoAge=${state.echoAgeMs === null ? "never" : `${state.echoAgeMs}ms`}` +
     (state.peerBytesAdvancing === null || state.peerBytesAdvancing === undefined
       ? ""
-      : ` peerBytes=${advancing ? "advancing" : "still"}`);
+      : ` peerBytes=${advancing ? "advancing" : "still"}`) +
+    (Number.isFinite(state.peerLoopLagMs) ? ` peerLoopLag=${Math.round(Number(state.peerLoopLagMs))}ms` : "") +
+    (state.peerVisibility ? ` peerTab=${state.peerVisibility}` : "");
 
   if (state.echoes === 0) {
     return { verdict: "no-echo-yet", detail };
@@ -326,6 +355,7 @@ export function createDeliveryProbe({
         bytesPerSecond,
         rttMs,
         echoIntervalMs: connection.echoIntervalMs,
+        peerLoopLagMs: connection.peerLoopLagMs ?? 0,
         intervalMs
       });
       // Several channels can carry one label only in malformed cases; the
@@ -354,10 +384,18 @@ export function createDeliveryProbe({
       labels: [...new Set(connection.channels.values())],
       echoes: connection.echoes,
       echoAgeMs: connection.echoAt === 0 ? null : now - connection.echoAt,
+      peerLoopLagMs: connection.peerLoopLagMs,
+      peerVisibility: connection.peerVisibility,
       allowed,
       // Same arithmetic for the echo's own age: the peer cannot answer sooner
-      // than its own cadence allows, and a hidden tab's is about a second.
-      echoStaleMs: widest > 0 ? widest * intervalMs + rttMs + connection.echoIntervalMs : 0
+      // than its own cadence allows, nor sooner than its own event loop runs.
+      echoStaleMs:
+        widest > 0
+          ? widest * intervalMs +
+            rttMs +
+            connection.echoIntervalMs +
+            Math.max(connection.peerLoopLagMs ?? 0, 0)
+          : 0
     });
     if (verdict !== connection.verdict || now - connection.reportedAt >= REPORT_INTERVAL_MS) {
       connection.verdict = verdict;
@@ -430,6 +468,13 @@ export function createDeliveryProbe({
           peerBytes: null,
           /** @type {number | null} */
           peerBytesAtTick: null,
+          // The far end's own event-loop delay and tab state, as last reported.
+          // The lag is a term in every allowance below; the tab state is only
+          // printed, so that a wide allowance can be read back to its cause.
+          /** @type {number | null} */
+          peerLoopLagMs: null,
+          /** @type {string | null} */
+          peerVisibility: null,
           verdict: "",
           reportedAt: 0,
           lastSeenAdvanceAt: 0,
@@ -509,6 +554,19 @@ export function createDeliveryProbe({
       if (Number.isFinite(peerBytes) && peerBytes >= 0) {
         connection.peerBytes = peerBytes;
       }
+      // How far behind the far end's own event loop is running. A browser that
+      // cannot run its timers cannot answer a probe, and every allowance here
+      // is a wait the answer has to fit inside — so this is a term in the
+      // arithmetic, not a note. It is the peer's own measurement, taken on the
+      // peer, and it arrives on the direction that survives a freeze.
+      const peerLoopLag = Number(echo?.report?.loopLagMs);
+      if (Number.isFinite(peerLoopLag) && peerLoopLag >= 0) {
+        connection.peerLoopLagMs = peerLoopLag;
+      }
+      const peerVisibility = echo?.report?.visibility;
+      if (typeof peerVisibility === "string" && peerVisibility.length > 0) {
+        connection.peerVisibility = peerVisibility;
+      }
       if (connection.echoAt !== 0) {
         const sinceLast = now - connection.echoAt;
         if (sinceLast > connection.echoIntervalMs) {

package/services/hls-session-manager.js

@@ -60,6 +60,7 @@ import {
 } from "./ffmpeg-banner.js";
 import { resolveSegmentFormat, SEGMENT_FORMAT_IDS } from "./segment-formats/index.js";
 import { audioRenditionName } from "./audio-inventory.js";
+import { ProducedIndex } from "./produced-index.js";
 
 /**
  * Whether an encoder run died because its INPUT went away, rather than because
@@ -2862,9 +2863,8 @@ export class HlsSessionManager {
     const pieces = new Map();
     let names;
     try {
-      names = (this.#runDirs(session).flatMap((dir) => {
-        try { return readdirSync(dir, { withFileTypes: false }); } catch { return []; }
-      }))
+      names = this.#producedIndex(session)
+        .fileNames()
         .filter((name) => session.segmentFormat.isSegmentFileName(name))
         .sort();
     } catch {
@@ -3439,9 +3439,7 @@ export class HlsSessionManager {
   async #observedStreamMbps(session) {
     let names;
     try {
-      names = this.#runDirs(session).flatMap((dir) => {
-        try { return readdirSync(dir, { withFileTypes: false }); } catch { return []; }
-      });
+      names = this.#producedIndex(session).fileNames();
     } catch {
       return null;
     }
@@ -3858,14 +3856,7 @@ export class HlsSessionManager {
   #contiguousAheadSeconds(session, viewerSegment) {
     let present;
     try {
-      if (!(session.knownNonEmptySegments instanceof Set)) {
-        session.knownNonEmptySegments = new Set();
-      }
-      present = usableSegmentIndices(
-        this.#runDirs(session),
-        this.segmentFormat,
-        session.knownNonEmptySegments
-      );
+      present = this.#producedIndex(session).segmentNumbers();
     } catch {
       return null;
     }
@@ -6669,9 +6660,7 @@ export class HlsSessionManager {
    */
   #latestProducedSegment(session) {
     let highest = null;
-    for (const name of this.#runDirs(session).flatMap((dir) => {
-      try { return readdirSync(dir, { withFileTypes: false }); } catch { return []; }
-    })) {
+    for (const name of this.#producedIndex(session).fileNames()) {
       if (!this.segmentFormat.isSegmentFileName(name)) {
         continue;
       }
@@ -9834,6 +9823,9 @@ export class HlsSessionManager {
             } catch {
               // Already gone, or being rewritten: either way nothing to do.
             }
+            // The index answers from what it read; a file removed on purpose
+            // must not still be an answer in the same tick.
+            this.#producedIndex(session).invalidate();
           }
           return { kind: "warming-up" };
         }
@@ -10111,15 +10103,27 @@ export class HlsSessionManager {
    * @returns {string[]}
    */
   #runDirs(session) {
-    try {
-      return readdirSync(session.dirPath, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory() && entry.name.startsWith("run-"))
-        .map((entry) => entry.name)
-        .sort((a, b) => Number(b.slice(4)) - Number(a.slice(4)))
-        .map((name) => path.join(session.dirPath, name));
-    } catch {
-      return [];
+    return this.#producedIndex(session).runDirs();
+  }
+
+  /**
+   * This session's one statement of what it has produced.
+   *
+   * Made on first use and kept on the session, so the directory times it
+   * remembers survive between requests — which is the whole of what makes it
+   * cheaper than the walk it replaces.
+   *
+   * @param {HlsSession} session
+   * @returns {ProducedIndex}
+   */
+  #producedIndex(session) {
+    if (!(session.producedIndex instanceof ProducedIndex)) {
+      session.producedIndex = new ProducedIndex({
+        dirPath: session.dirPath,
+        segmentFormat: session.segmentFormat ?? this.segmentFormat
+      });
     }
+    return session.producedIndex;
   }
 
   /**
@@ -10130,16 +10134,7 @@ export class HlsSessionManager {
    * @returns {Promise<string | null>}
    */
   async #findProducedFile(session, fileName) {
-    for (const dir of this.#runDirs(session)) {
-      const candidate = path.join(dir, fileName);
-      try {
-        await access(candidate);
-        return candidate;
-      } catch {
-        // Not this run's; try an older one.
-      }
-    }
-    return null;
+    return this.#producedIndex(session).pathOf(fileName);
   }
 
   /**
@@ -10185,6 +10180,8 @@ export class HlsSessionManager {
         : null
     );
     if (removed !== null) {
+      // Removed on purpose, so the index must not go on answering with it.
+      this.#producedIndex(session).invalidate();
       logger.info(
         `transcode ${session.id} discarded segment #${removed}: ` +
           "the run ended while it was open, so it holds no usable piece"