@torrent-tv/proxy 2.78.0 → 2.80.0

package/services/hls-session-manager.js

@@ -23,7 +23,7 @@ import { speedFromReadings } from "./encoder-readings.js";
 import { availableShareFrom } from "./available-share.js";
 import { contentionPenalty } from "./contention.js";
 import { minimumBufferFrom } from "./supply-margin.js";
-import { mapForViewer } from "./encode/DemandMap.js";
+import { mapForViewer } from "./priority/PriorityMap.js";
 import { baseDrawFrom, costPerMegabyteFrom } from "./torrent-cost.js";
 import { medianOf, movedBeyondScatter, scatterOf } from "./learned-median.js";
 import {
@@ -69,6 +69,7 @@ import { Output, Outputs } from "./output/Output.js";
 import { masterPlaylistText, mediaPlaylistText, segmentIndexForTime } from "./output/playlists.js";
 import { SourceFiles, sourceDecodeCharacteristics } from "./source/SourceFile.js";
 import { ProducedIndex } from "./produced-index.js";
+import { discardOpenPiece } from "./encode/open-piece.js";
 import { SegmentStore } from "./encode/SegmentStore.js";
 import { EncodeCost } from "./quality/EncodeCost.js";
 import {
@@ -148,82 +149,6 @@ export function contiguousEnd(present, from) {
   return last;
 }
 
-/**
- * Remove the piece a run had open when it ended, if that piece is unusable.
- *
- * The `segment` muxer creates its output file when it OPENS it and writes into
- * it until the next cut, so at any instant exactly one file in a run's
- * directory is unfinished: the highest-numbered one. A run that reaches the end
- * of its work closes that file and it is a good piece; a run killed for a seek
- * does not — measured 2026-09-03, ffmpeg exited 19 ms after SIGTERM and left
- * `segment-00025.mp4` at zero bytes, which then closed the only hole in the
- * numbering and convinced the look-ahead to keep the encoder stopped for having
- * "produced" it.
- *
- * Only an unusable piece goes. A run stopped between two cuts leaves a finished
- * file behind, and deleting good output would mean making it a second time.
- *
- * @param {string | null | undefined} runDirPath
- * @param {{ isSegmentFileName: (name: string) => boolean, segmentIndexFromName: (name: string) => number }} segmentFormat
- * @param {((raw: Buffer) => boolean) | null} judgeUsable - Whether a non-empty
- *   piece carries what it should. Null where nothing can say, and then only an
- *   empty file is removed.
- * @returns {Promise<number | null>} The segment number removed, or null.
- */
-export async function discardOpenPiece(runDirPath, segmentFormat, within, judgeUsable) {
-  if (!runDirPath || typeof segmentFormat?.isSegmentFileName !== "function") {
-    return null;
-  }
-  // Only inside the stretch the ended run was given. Every run of an output
-  // writes into one directory now — they are kept apart by their intervals
-  // rather than by a directory each — so the highest-numbered file in there may
-  // belong to a run that is still going, and removing it would take away a
-  // piece somebody is producing.
-  const from = Number.isInteger(within?.from) ? within.from : 0;
-  const to = Number.isInteger(within?.to) && within.to >= from ? within.to : Number.MAX_SAFE_INTEGER;
-  let highest = null;
-  try {
-    for (const name of await readdir(runDirPath)) {
-      if (!segmentFormat.isSegmentFileName(name)) {
-        continue;
-      }
-      const index = segmentFormat.segmentIndexFromName(name);
-      if (index < from || index > to) {
-        continue;
-      }
-      if (index >= 0 && (highest === null || index > highest.index)) {
-        highest = { index, name };
-      }
-    }
-  } catch {
-    return null; // The run wrote nothing, or its directory is already gone.
-  }
-  if (highest === null) {
-    return null;
-  }
-  const filePath = path.join(runDirPath, highest.name);
-  let unusable = false;
-  try {
-    const info = await stat(filePath);
-    if (info.size === 0) {
-      unusable = true;
-    } else if (typeof judgeUsable === "function") {
-      unusable = !judgeUsable(await readFile(filePath));
-    }
-  } catch {
-    return null; // Gone between the listing and the question.
-  }
-  if (!unusable) {
-    return null;
-  }
-  try {
-    await unlink(filePath);
-    return highest.index;
-  } catch {
-    return null; // Already removed.
-  }
-}
-
 /**
  * Which segment numbers a session actually holds, across every run it has had.
  *
@@ -1746,10 +1671,10 @@ export class HlsSessionManager {
     });
     this.encodeOrchestrator = new EncodeOrchestrator({
       maxRunsFor: (address) => this.maxRunsForOutput(address),
-      makeRun: ({ address, from }) => this.#makeRunAt(address, from),
+      makeRun: ({ address, from, to }) => this.#makeRunAt(address, from, to),
       segmentSeconds: this.segmentDurationSec,
       restartCostSec: RUN_RESTART_COST_SEC,
-      lookaheadSegments: Math.ceil(this.lookaheadSeconds / this.segmentDurationSec),
+      segmentStore: this.segmentStore,
       logger
     });
     // Where each file is cut, held once per file and grid rather than once per
@@ -2006,8 +1931,7 @@ export class HlsSessionManager {
         if (normalizedStartPosition > 0 || existing.runs.size === 0) {
           const at = this.#segmentIndexForTime(existing, normalizedStartPosition);
           if (runStartingAt(existing, at) === null && ownRunMaking(existing, at) === null) {
-            void this.#startEncodeRun(existing, at, normalizedStartPosition, "a viewer opened the film here")
-              .catch(() => {});
+            this.#startEncodeRun(existing, at, normalizedStartPosition, "a viewer opened the film here");
           }
         }
         existing.lastAccessedAt = Date.now();
@@ -3371,7 +3295,7 @@ export class HlsSessionManager {
    * @param {{ linkMbps: number, bufferedAheadSec: number, consumerId?: string, positionSeconds?: number }} report
    * @returns {boolean}
    */
-  recordNetReport(sessionId, { linkMbps, bufferedAheadSec, consumerId, positionSeconds }) {
+  recordNetReport(sessionId, { linkMbps, bufferedAheadSec, consumerId, positionSeconds, playing }) {
     const named = this.sessionsById.get(sessionId);
     if (!named || named.state === "disposed") {
       return false;
@@ -3387,15 +3311,9 @@ export class HlsSessionManager {
     // report of one of them says nothing about the other's encoder.
     const session = this.#activeVariant(named, typeof consumerId === "string" ? consumerId : "");
     const now = Date.now();
-    this.viewers.of(session, typeof consumerId === "string" && consumerId.length > 0 ? consumerId : "").netReport = {
-      linkMbps,
-      bufferedAheadSec,
-      // Where the picture is, said by the viewer rather than worked out from
-      // their buffer. Null from a browser that does not send it.
-      positionSeconds:
-        Number.isFinite(positionSeconds) && positionSeconds >= 0 ? positionSeconds : null,
-      at: now
-    };
+    this.viewers
+      .of(session, typeof consumerId === "string" && consumerId.length > 0 ? consumerId : "")
+      .report({ linkMbps, bufferedAheadSec, positionSeconds, playing }, now);
     // A stale reading must not go on deciding for the viewers still here: a
     // report describes a link at a moment, and a viewer who seeked since then
     // is somewhere else entirely.
@@ -3445,8 +3363,7 @@ export class HlsSessionManager {
     // `viewerPositionSource`. Only a seek writes it, so a request does not erase
     // it.
     const viewer = this.viewers.of(session, consumerId, now);
-    const seeked = viewer.position?.seeked ?? null;
-    viewer.position = { segment, seconds, at: now, seeked };
+    viewer.moveTo(seconds, now);
     this.planEncodersSoon();
     const staleAfterMs = this.presenceStaleAfterMs();
     let furthest = { segment, seconds };
@@ -3459,8 +3376,9 @@ export class HlsSessionManager {
         this.#viewerLeaves(session, key);
         continue;
       }
-      if (other.position !== null && other.position.segment > furthest.segment) {
-        furthest = { segment: other.position.segment, seconds: other.position.seconds };
+      const theirs = other.positionSeconds();
+      if (theirs !== null && theirs > furthest.seconds) {
+        furthest = { segment: this.#segmentIndexForTime(session, theirs), seconds: theirs };
       }
     }
     return furthest;
@@ -3775,7 +3693,7 @@ export class HlsSessionManager {
    * One viewer's demand map, translated into this output's segment numbers.
    *
    * The map itself is seconds of film and knows nothing about cut grids
-   * (`services/encode/DemandMap.js`). The translation is this output's own
+   * (`services/priority/PriorityMap.js`). The translation is this output's own
    * business, and it is exact: the timeline holds the boundaries.
    *
    * Two measurements feed it, and neither is chosen here:
@@ -3792,9 +3710,13 @@ export class HlsSessionManager {
    * @returns {{from: number, to: number, priority: number}[]} In segment
    *   numbers, both ends inclusive.
    */
-  #demandZonesFor(session, atSegment) {
+  #demandZonesFor(session, atSeconds) {
     const boundaries = session.timeline?.boundaries ?? [];
     const segmentCount = Number(session.timeline?.segmentCount) || 0;
+    // Where they are, in this output's own numbering. The viewer holds seconds;
+    // every cut grid turns them into its own numbers, and two grids of one film
+    // give different numbers for the same second.
+    const atSegment = segmentCount > 0 ? this.#segmentIndexForTime(session, atSeconds) : 0;
     if (segmentCount <= 0) {
       // No playlist yet: the only thing that can be said is that they want
       // where they are.
@@ -3803,7 +3725,7 @@ export class HlsSessionManager {
     const durationSeconds = Number(boundaries[boundaries.length - 1]) ||
       segmentCount * this.segmentDurationSec;
     const zones = mapForViewer({
-      atSeconds: this.#segmentStartTime(session, atSegment),
+      atSeconds,
       durationSeconds,
       allowanceSeconds: minimumBufferFrom({
         segmentSeconds: this.segmentDurationSec,
@@ -4008,7 +3930,11 @@ export class HlsSessionManager {
           // named. A viewer with no position is one assembled by hand outside
           // this class; they want the beginning, which is where an output
           // starts when nobody says otherwise.
-          const at = viewer.position?.segment ?? 0;
+          // SECONDS, and turned into this output's own numbering below. A
+          // segment number taken off the viewer would mean two different
+          // moments of film on the picture and on the soundtrack, which are cut
+          // independently: 454 pieces against 401 on the field file.
+          const at = viewer.positionSeconds() ?? 0;
           // Their own map, in seconds of film, from measurements: how much must
           // be ready before they set off so that they never stop — the observed
           // allowance for this file plus what an encoder at THIS machine's
@@ -4048,7 +3974,7 @@ export class HlsSessionManager {
    * @param {number} from
    * @returns {object | null}
    */
-  #makeRunAt(address, from) {
+  #makeRunAt(address, from, to) {
     let base = null;
     for (const session of this.sessionsById.values()) {
       if (session.outputKey === address && session.state !== "disposed") {
@@ -4079,13 +4005,18 @@ export class HlsSessionManager {
     if (base.failedStartAt === from && base.failedStartCount >= MAX_FAILED_STARTS) {
       return null;
     }
-    // Answered with nothing straight away and the run started behind it,
-    // because the plan is arithmetic and must not wait on a spawn.
-    void this.#startEncodeRun(base, from, undefined, "the plan asked for an encoder here").catch((error) => {
+    // The encoder is built and handed back in this same call. Nothing here
+    // waits: the one thing this path used to wait for was the death of the run
+    // it was replacing, and that killing is gone. Answering with nothing while
+    // the encoder was built behind the answer is what let the same stretch be
+    // started over and over — 684 starts in 482 seconds of field 2026-09-05.
+    try {
+      return this.#startEncodeRun(base, from, undefined, "the plan asked for an encoder here", { to });
+    } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       logger.warn(`transcode could not start a run at #${from} of ${address}: ${message}`);
-    });
-    return null;
+      return null;
+    }
   }
 
   /**
@@ -5657,7 +5588,16 @@ export class HlsSessionManager {
     return segmentCount > 0 && end >= segmentCount - 1 ? -1 : end;
   }
 
-  async #startEncodeRun(session, startIndex, positionSecondsOverride, because = "a viewer needs it") {
+  // Returns the encoder it built, or nothing when there was nothing to build.
+  // It waits for nothing: the one thing it used to wait for was the death of
+  // the run it was replacing, and that killing is gone.
+  #startEncodeRun(
+    session,
+    startIndex,
+    positionSecondsOverride,
+    because = "a viewer needs it",
+    ordered = null
+  ) {
     // A new run starts its own reckoning: a pair spanning the restart would
     // count the gap between two runs as slow encoding.
     session.learnSample = null;
@@ -5670,25 +5610,21 @@ export class HlsSessionManager {
     // does not await: everything below is the restart path, which is measured
     // in milliseconds and has been worked on twice to keep it that way.
     this.#accountBackwardRestart(session, startIndex);
-    // Which run, if any, is being REPLACED. A run is replaced only when the new
-    // one begins at or before it: that is a reposition of the same work. A run
-    // starting further on is a second encoder beside it, which is the whole
-    // point of a session holding a set.
-    const previousRun = liveRunsOf(session).find((run) => run.from >= startIndex) ?? null;
-    const previousProcess = previousRun?.process ?? null;
-    // The stretch the run being replaced was given, read before the new one
-    // takes over: with every run of an output writing into one directory, the
-    // piece to discard has to be looked for inside that run's own numbers.
-    const previousRunDirPath = previousRun ? session.dirPath : null;
-    const previousRunSpan = {
-      from: Number.isInteger(previousRun?.from) ? previousRun.from : 0,
-      to: Number.isInteger(previousRun?.to) ? previousRun.to : -1
-    };
-    // WHERE it starts was decided by whoever called, and is not touched here.
-    // Only how far it may work is answered, and it is answered by reading the
-    // one coverage map. Moving the start was the second authority's doing and
-    // is gone with it.
-    const runEnd = this.#runEndFrom(session, startIndex, previousRun);
+    // STARTING AN ENCODER STOPS NOTHING. It used to stop any live run whose own
+    // start was not below this one's — a rule left over from when a session
+    // held exactly one run and "the previous one" meant "the only one". Once a
+    // session could hold several, that rule began killing runs the plan had
+    // decided to keep: 294 stops for this reason in eight minutes of field
+    // 2026-09-05, against four starts asked for by a viewer. Who is stopped is
+    // decided in one place, and it is not this one.
+    //
+    // HOW FAR IT MAY WORK is decided by the same one place and arrives here as
+    // an argument. Reading it off the coverage map a second time was the last
+    // remaining second answer to that question: the plan computed `to`, passed
+    // it, and the parameter list did not name it.
+    const runEnd = Number.isInteger(ordered?.to)
+      ? ordered.to
+      : this.#runEndFrom(session, startIndex, null);
     // The restart backs off a segment or two from what was asked for, so the
     // request that prompted it is recorded under a HIGHER index than the run
     // starts at. Looking it up by the start index alone found nothing and the
@@ -5727,31 +5663,6 @@ export class HlsSessionManager {
     // current run failing. On any host with a hardware encoder that meant a
     // downgrade to libx264 for good on every seek. A run writes its own state,
     // so there is nothing left to mistake.
-    if (previousRun && previousProcess && !hasChildExited(previousProcess)) {
-      previousRun.stop("a new run is taking its place");
-      // NOT awaited. Runs are kept apart by their stretches, so the predecessor
-      // cannot corrupt this one's output by still writing; letting it die in the
-      // background removes 0.7-1.3 s from every seek (measured 2.9.132, where
-      // that wait was essentially the whole cost of a restart).
-      const termSentAt = Date.now();
-      void waitForChildExit(previousProcess, ENCODE_RUN_TERMINATE_GRACE_MS).then(async () => {
-        logger.info(
-          `transcode ${session.id} restart: previous run took ${Date.now() - termSentAt}ms to exit after SIGTERM`
-        );
-        // Only now: while the process lives it may still close the file, and a
-        // piece removed from under it would be written on into nothing.
-        await this.#discardUnfinishedPiece(session, previousRunDirPath, previousRunSpan);
-      });
-      if (!hasChildExited(previousProcess)) {
-        try {
-          previousProcess.kill("SIGKILL");
-        } catch {
-          // Best effort.
-        }
-        await waitForChildExit(previousProcess, ENCODE_RUN_TERMINATE_GRACE_MS);
-        await this.#discardUnfinishedPiece(session, previousRunDirPath, previousRunSpan);
-      }
-    }
     // A newer restart (or disposal) won the race while we were waiting for the
     // old process to die — it either already spawned its own replacement or
     // there is nothing left to start. Do not also spawn from this stale call.
@@ -5824,7 +5735,9 @@ export class HlsSessionManager {
       spawn: (spawnArgs) =>
         spawn(this.ffmpegBin, spawnArgs, {
           cwd: session.dirPath,
-          stdio: ["ignore", "pipe", "pipe"]
+          // A fourth channel: the encoder names every piece it has CLOSED on it,
+          // which is the only proof a piece is whole.
+          stdio: ["ignore", "pipe", "pipe", "pipe"]
         }),
       logger,
       // The film's last segment number, which is what tells "it reached the
@@ -5834,6 +5747,7 @@ export class HlsSessionManager {
         session.timeline?.segmentCount > 0 ? session.timeline.segmentCount - 1 : null,
       inputUnavailable: (message) => isInputUnavailable(message),
       onProgress: (report) => this.#noteRunProgress(session, run, report),
+      onClosed: (name) => this.segmentStore.markClosed(session.outputKey ?? "", session.segmentFormat.segmentIndexFromName(name)),
       onEnded: (ended) => this.noteRunEnded(session, run, ended)
     });
     session.runs.add(run);
@@ -5866,6 +5780,7 @@ export class HlsSessionManager {
         `live ${liveStart.toFixed(3)}s, apart ${(liveStart - startSeconds).toFixed(3)}s), ` +
         `numbering from #${safeIndex}`
     );
+    return run;
   }
 
   /**
@@ -6047,7 +5962,7 @@ export class HlsSessionManager {
         const at = Number.isInteger(session.lastRequestedSegment)
           ? session.lastRequestedSegment
           : ended.from;
-        this.#startEncodeRun(session, at, undefined, "its input came back").catch(() => {});
+        this.#startEncodeRun(session, at, undefined, "its input came back");
       }, delayMs);
       session.inputRetryTimer.unref?.();
       return;
@@ -6449,141 +6364,28 @@ export class HlsSessionManager {
     if (!named || named.state === "disposed") {
       return false;
     }
-    // The seeking viewer's OWN head moves with them. Without this their head
-    // would still hold the segment they asked for before the jump, and the very
-    // next thing they ask for — the segment at the seek target — would be
-    // judged stale against it and refused. That refusal, from the shared field,
-    // is the freeze of 2026-08-18; keeping per-viewer heads without moving them
-    // on a seek would bring it back one viewer at a time.
-    if (consumerId) {
-      this.viewers.of(named, consumerId).position = {
-        segment: this.#segmentIndexForTime(named, positionSeconds),
-        seconds: positionSeconds,
-        at: Date.now(),
-        // Stated, not inferred. It is what makes this viewer's position a
-        // "seeked" one for as long as they stay there.
-        seeked: positionSeconds
-      };
-    }
-    // The browser holds one session id for the whole file and knows nothing of
-    // variants, so a seek it reports means the stream on screen.
+    // A SEEK DOES ONE THING: it puts the viewer where they now are.
     //
-    // The session's own figure, which is what an encode run is placed by. It is
-    // NOT this viewer's position — that is their head above — and the two used
-    // to be one field called `viewerPositionSeconds`: with two viewers the name
-    // was a falsehood, since a session has one of these and as many positions
-    // as it has viewers.
-    named.furthestViewerSeconds = positionSeconds;
-    // What the viewer SAID, kept apart from what requests imply. A request is
-    // evidence about where the player is reading; a reported seek is the viewer
-    // stating where they are, and after one, requests already in flight
-    // describe a place that no longer exists. Field 2026-08-17: a seek to
-    // 2083.4 s restarted both runs at #373, a request for #371 issued before it
-    // arrived a second later, and the encoder was dragged back to #370 — three
-    // segments behind the viewer, who then waited for it to return.
-    named.viewerReportedSeconds = positionSeconds;
-    named.lastAccessedAt = Date.now();
-    // The audio the viewer is listening to moves with them. It is a separate
-    // encoder on a separate session that the browser cannot name, and nothing
-    // else would ever reposition it: a request far AHEAD of its run is not
-    // treated as a seek anywhere in this class, so after a forward jump the
-    // audio would be held, refused, and left grinding forward from where it
-    // was — the picture playing over silence for as long as the jump was.
-    // Only the track being LISTENED to. A track the viewer left keeps its place
-    // but not an encoder, and seeking it would start one for nobody — which is
-    // how a single viewer came to have three ffmpeg processes and three readers
-    // on one file (2026-08-15), enough to pin every resident piece and kill the
-    // session outright.
-    // The seeking viewer's OWN soundtrack, not every soundtrack the session
-    // has: with two viewers, moving the other one's audio to a position they
-    // are not at would take their sound away and produce for nobody.
-    const listening = this.#audioChoiceOf(named, consumerId);
-    const rendition = this.liveOutputs.renditionsOf(named).find(
-      (other) =>
-        (other.audioTrackIndex ?? 0) === listening.trackIndex &&
-        (other.transcodeAudio === true) === listening.transcode
-    );
-    if (rendition) {
-      rendition.lastAccessedAt = Date.now();
-      this.#seekSession(rendition, positionSeconds);
-    }
-    const onScreen = this.#activeVariant(named, consumerId);
-    // A seek backwards while somebody else is watching ahead must not drag
-    // their picture back with it: field shape of 2026-09-04, two viewers who
-    // opened a film together, one jumps back an hour, and the other's segments
-    // stop being made.
+    // It used to do eleven, and wrote that position into five places: two
+    // fields on this session, two more on the soundtrack's, and the viewer. It
+    // also asked whether the jump would drag another viewer back, started an
+    // encoder itself, cancelled outstanding requests, backed off a segment to
+    // the preceding keyframe, and set a timer to restart ffmpeg. So it was a
+    // third authority over the encoders beside the plan and the start path, and
+    // not one of its branches ever asked what had already been made — a viewer
+    // jumping into a stretch that was finished and on disk got a fresh encoder
+    // for it.
     //
-    // The answer is not to refuse the seek but to give it a run of its own. A
-    // session holds as many runs as the machine affords, they write into the
-    // output's one directory, and each viewer is served whatever any of them
-    // has made.
-    if (this.#wouldDragAnotherViewerBack(onScreen, consumerId, positionSeconds)) {
-      const target = this.#segmentIndexForTime(onScreen, positionSeconds);
-      if (runStartingAt(onScreen, target) !== null || ownRunMaking(onScreen, target) !== null) {
-        logger.info(
-          `transcode ${onScreen.id} seek to ${positionSeconds.toFixed(1)}s for ${consumerId} is ` +
-          `already being made by a run of its own "${onScreen.file.name}"`
-        );
-        return true;
-      }
-      logger.info(
-        `transcode ${onScreen.id} seek to ${positionSeconds.toFixed(1)}s starting a run of its ` +
-        `own for ${consumerId}: another viewer is watching ahead, and one run cannot be in two ` +
-        `places "${onScreen.file.name}"`
-      );
-      // Not awaited: this call answers the browser, and what the viewer waits
-      // for afterwards is the segment, which the ordinary loading flow already
-      // knows how to wait for. The other viewer's picture is left alone, which
-      // is the whole point.
-      void this.#startEncodeRun(onScreen, target, positionSeconds, "a viewer jumped back past another")
-        .catch((error) => {
-          const message = error instanceof Error ? error.message : String(error);
-          logger.warn(`transcode ${onScreen.id} could not start a run at that position: ${message}`);
-        });
-      return true;
-    }
-    return this.#seekSession(onScreen, positionSeconds);
-  }
-
-  /**
-   * Whether repositioning this session would take the picture away from
-   * somebody else.
-   *
-   * Two things have to hold. The seek has to be one that actually restarts the
-   * run — a position the run already covers going forward costs nobody
-   * anything. And another viewer has to be live and AHEAD of it, since a run
-   * only ever moves forward: what lies behind the furthest viewer has already
-   * been made, and dragging the run back is what stops it being made for them.
-   *
-   * @param {HlsSession} session
-   * @param {string} consumerId - The one seeking, who does not count.
-   * @param {number} positionSeconds
-   * @returns {boolean}
-   */
-  #wouldDragAnotherViewerBack(session, consumerId, positionSeconds) {
-    if (!session || !consumerId || !processCanBeSignalled(runStateOf(session))) {
-      return false;
-    }
-    const target = this.#segmentIndexForTime(session, positionSeconds);
-    const head = earliestRunStart(session);
-    if (!Number.isInteger(head) || target >= head) {
-      return false;
-    }
-    const staleAfterMs = this.presenceStaleAfterMs();
-    const now = Date.now();
-    for (const [otherId, viewer] of viewersOf(session)) {
-      if (otherId === consumerId || !viewer.isPresent(now, staleAfterMs)) {
-        continue;
-      }
-      if (viewer.position.segment > target) {
-        return true;
-      }
+    // What follows from the move happens by itself: the priority map is built
+    // from where the viewers are, and both orchestrators read the map.
+    if (consumerId) {
+      this.viewers.of(named, consumerId).moveTo(positionSeconds);
     }
-    return false;
+    named.lastAccessedAt = Date.now();
+    this.planEncodersSoon();
+    return true;
   }
 
-
-
   /**
    * Reposition THIS session, with no forwarding.
    *
@@ -7276,7 +7078,7 @@ export class HlsSessionManager {
       // run would be discarded for nothing, which is the shape the field
       // already showed (eleven restarts in four minutes, eight of them dying
       // with `run had produced 0.0s`).
-      void this.#startEncodeRun(member, index, trueStart).catch(() => {});
+      this.#startEncodeRun(member, index, trueStart);
     }
   }
 
@@ -9835,70 +9637,23 @@ export class HlsSessionManager {
       // running happily ahead. A segment is finished once the NEXT one has been
       // started, or once the run producing it has ended.
       if (!isPlaylist && cutsAtGivenTimes(session)) {
+        // WHAT PROVES A PIECE IS WHOLE is the encoder's own word for it: it
+        // names each file on a channel of its own the moment it closes it, and
+        // the store keeps those names.
+        //
+        // What stood here instead was the existence of the NEXT file, with two
+        // exceptions bolted on because it is not true. It is never true of the
+        // last piece of a run — nothing is producing a next one — so the first
+        // segment of every run was held: measured 2026-08-09, #807 held while
+        // it lay on disk, and in August the same shape held #317 for 46 seconds
+        // and then answered 404 to a browser that had given up.
         const index = session.segmentFormat.segmentIndexFromName(fileName);
-        const isLast = index >= Math.max(0, (session.timeline.boundaries?.length ?? 1) - 2);
-        // Only the CURRENT run can have a file open, and only its own next
-        // piece is evidence that it has moved on. A run that has ended closed
-        // everything it wrote, so its files need no such proof — and taking the
-        // proof from whichever run happened to hold the next number is how a
-        // file being written came to be read as finished.
-        if (!isLast && liveRunsOf(session).length > 0) {
-          const nextName = session.segmentFormat.segmentFileName(index + 1);
-          const nextPath = path.join(session.dirPath, nextName);
-          // The FIRST segment of a run cannot be judged by "the next one
-          // exists": nothing is producing a next one yet, because the run has
-          // only just begun here. Waiting for it holds precisely the segment a
-          // resume depends on — measured 2026-08-09, #807 held while it lay on
-          // disk, and in August the same shape held #317 for 46 s and then
-          // answered 404 to a browser that had given up.
-          //
-          // What "finished" means for it is that the encoder has moved PAST the
-          // end of its span. ffmpeg reports the output timestamp of its last
-          // encoded frame, so a run whose position is beyond this segment's end
-          // has necessarily closed it.
-          const isRunStart = runStartingAt(session, index) !== null;
-          const encoderPosition = Number(session.progress?.processedSeconds);
-          const segmentEnd = this.#segmentStartTime(session, index + 1);
-          if (isRunStart && Number.isFinite(encoderPosition) && encoderPosition > segmentEnd) {
-            // Past its end — it is complete, whatever the directory says about
-            // what comes next.
-          } else {
-          try {
-            await access(nextPath);
-          } catch {
-            this.#explainHold(
-              session,
-              fileName,
-              `it exists, but the next segment (#${index + 1}) has not been started yet`
-            );
-            return { kind: "warming-up" };
-          }
-          }
-        }
-      }
-      // A run that has walked into a stretch another run was given stops here.
-      //
-      // A run's own end is set when it starts, from the gaps of that moment,
-      // and a viewer who opened the same film somewhere else afterwards is not
-      // in that picture: their run took the stretch in front, and this one is
-      // now producing numbers they are producing too. Nothing may write a name
-      // another run wants — that is the whole reason runs used to be kept in
-      // separate directories, and this is what replaces it now that they share
-      // one.
-      if (!isPlaylist) {
-        const served = session.segmentFormat.segmentIndexFromName(fileName);
-        // The run that made this number, and whether ANOTHER run was given it.
-        // A run may not write a name another run wants — that is the whole
-        // reason runs used to be kept in separate directories — so the one that
-        // walked in stops where it got to.
-        const mine = Number.isInteger(served) && served >= 0 ? ownRunMaking(session, served) : null;
-        const madeByAnother = mine === null
-          ? null
-          : this.runMakingSegment(session, served, mine);
-        if (madeByAnother !== null) {
-          mine.stop(`it reached #${served}, which #${madeByAnother.from}..#${madeByAnother.to} was given`);
+        if (!this.segmentStore.isClosed(session.outputKey ?? "", index)) {
+          this.#explainHold(session, fileName, "the encoder has not closed it yet");
+          return { kind: "warming-up" };
         }
       }
+
       // Cold-start: log the first servable SEGMENT of this session exactly once
       // — the time from session-create entry to a playable first segment.
       if (!isPlaylist && !session.firstSegmentLogged) {