@torrent-tv/proxy 2.107.55 → 2.107.57

package/server.js

@@ -11,7 +11,6 @@ import fastifyCors from "@fastify/cors";
 import fastifyHelmet from "@fastify/helmet";
 import getPort from "get-port";
 import { createRequire } from "node:module";
-import { performance } from "node:perf_hooks";
 import { SourceWaitTrace } from "./utils/wait-trace.js";
 import { handleHealthGet } from "./routes/health/get.js";
 import { handleMediaGet } from "./routes/media/get.js";
@@ -19,11 +18,14 @@ import { ProbeRequests } from "./services/media/ProbeRequests.js";
 import { IndexMemory } from "./services/storage/IndexMemory.js";
 import { LARGEST_GROWTH_BYTES } from "./services/media/container/PacketRecords.js";
 import { probePackets } from "./services/media/probe-packets.js";
-import { trackChoicesOf } from "./services/viewer/segment-demands.js";
-import { PlaybackProjection } from "./services/torrent/PlaybackProjection.js";
 import { SegmentInputTable } from "./services/viewer/segment-input-table.js";
 import { SourcePreparation, preparationInterval } from "./services/viewer/SourcePreparation.js";
 import { publishPlaybackBeforePreparationRefresh } from "./services/server/publish-playback-before-preparation-refresh.js";
+import { WorkTagsReport } from "./services/media/WorkTagsReport.js";
+import { PreparationReads } from "./services/server/PreparationReads.js";
+import { MediaReadParams } from "./services/server/MediaReadParams.js";
+import { torrentPoolPorts } from "./services/server/torrent-pool-ports.js";
+import { installForwardedResponseLog } from "./services/server/forwarded-response-log.js";
 import { handleHealthzGet } from "./routes/healthz/get.js";
 import { handleApiDeliverySinkGet } from "./routes/api/delivery-sink/get.js";
 import { handleApiLinkProbeGet } from "./routes/api/link-probe/get.js";
@@ -63,34 +65,23 @@ import { wireOutputs } from "./services/server/wire-outputs.js";
 import { createPlaybackPlanner } from "./services/media/playback-planner.js";
 import { KeyframeTables } from "./services/media/KeyframeTables.js";
 import { contentsOf } from "./services/torrent/Contents.js";
-import { joinedWithinPieces } from "./services/torrent/demand/pieces.js";
 import { coalescedZones, withoutRepeatedZones } from "./services/torrent/map-zones.js";
-import { SubtitleOrchestrator } from "./services/media/SubtitleOrchestrator.js";
-import { containerOrchestrator, CONTAINER_HEAD_BYTES, describeWorkTags } from "./services/media/ContainerOrchestrator.js";
+import { SubtitleWalk } from "./services/media/SubtitleWalk.js";
+import { containerOrchestrator, CONTAINER_HEAD_BYTES } from "./services/media/ContainerOrchestrator.js";
 import { readPlaybackDeclarations } from "./services/media/read-playback-declarations.js";
 import { DownloadMaps } from "./services/viewer/DownloadMaps.js";
 import { nativeSourceMap, nativeOriginalSourceMap } from "./services/viewer/NativeSourceMap.js";
 import { MediaReadRequests } from "./services/media/MediaReadRequests.js";
+import { EncodeInputResolution } from "./services/encode/EncodeInputResolution.js";
 import { SegmentInputs } from "./services/media/SegmentInputs.js";
-import { directSegmentInput } from "./services/media/direct-segment-input.js";
-import { ContainerTrack } from "./services/media/tracks/ContainerTrack.js";
+import { PlaybackResolution } from "./services/torrent/PlaybackResolution.js";
+import { SegmentSourceRanges } from "./services/media/SegmentSourceRanges.js";
+import { readingInterval, segmentReading, selectTracks, trackFor } from "./services/media/segment-reading.js";
 import { pauseCoefficient, viewerStartsOn } from "./services/viewer/PriorityMap.js";
-import { coalescing } from "./utils/coalesce.js";
-import {
-  warmSubtitleCues,
-  cuesHeldFor,
-  subtitleTracksOf,
-  declaredSubtitleTracksOf,
-  forgetSubtitles
-} from "./services/media/SubtitleCues.js";
-import { detectVideoEncoder, benchmarkDecodeCost, benchmarkContention, benchmarkCopySpeed, detectTonemapSupport, softwareDescriptor } from "./services/encode/hwaccel.js";
-import { calibrateEncoder, HostCalibration } from "./services/encode/calibration.js";
-import { readHostFingerprint } from "./services/encode/fingerprint.js";
-import { measureStartAndStop } from "./services/encode/start-stop-cost.js";
-import { benchmarkAudio } from "./services/encode/audio-calibration.js";
+import { measureHost } from "./services/encode/measure-host.js";
 import { logger } from "./utils/logger.js";
-import { takeTurns } from "./utils/take-turns.js";
 import { completedFilesRoot } from "./services/storage/files/CompletedFiles.js";
+import { startPlayback } from "./services/server/start-playback.js";
 import { startupCpuProfile } from "./services/storage/cpu-profile.js";
 import { startProcessorReport } from "./services/storage/processor-report.js";
 import { processorBound } from "./services/storage/machine-processor.js";
@@ -154,17 +145,8 @@ export async function startProxyServer({
     // receives torrent source payloads that may be arbitrarily large.
     bodyLimit: 256 * 1024 * 1024 // 256 MB
   });
-  const forwardedSessionResponseStarts = new WeakMap();
   const waitTrace = new SourceWaitTrace({ emit: value => logger.info(`[wait-trace] ${JSON.stringify(value)}`) });
   waitTrace.install(app);
-  const logForwardedSessionResponseStage = (stage, req) => {
-    const startedAt = forwardedSessionResponseStarts.get(req);
-    const requestId = req.headers["x-ttv-forwarded-request-id"];
-    if (startedAt === undefined || typeof requestId !== "string") return;
-    const at = performance.now();
-    logger.info(`[forecast-http] stage=${stage} requestId=${requestId} atMs=${at.toFixed(3)} ` +
-      `elapsedMs=${(at - startedAt).toFixed(3)}`);
-  };
 
   await app.register(fastifyHelmet, {
     // Proxy serves media to a different origin (registry UI), so CORP must allow cross-origin usage.
@@ -184,34 +166,7 @@ export async function startProxyServer({
   app.addHook("onRequest", async (_req, reply) => {
     reply.header("Access-Control-Allow-Private-Network", "true");
   });
-  app.addHook("onRequest", async (req, reply) => {
-    const requestId = req.headers["x-ttv-forwarded-request-id"];
-    if (typeof requestId !== "string" || req.method !== "POST" || req.url !== "/api/transcode-sessions") return;
-    const startedAt = performance.now();
-    forwardedSessionResponseStarts.set(req, startedAt);
-    logForwardedSessionResponseStage("onRequest", req);
-    reply.raw.once("finish", () => {
-      logForwardedSessionResponseStage("finish", req);
-      logger.info(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
-        `responseMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode} ` +
-        `contentLength=${reply.raw.getHeader("content-length") ?? "unknown"}`);
-    });
-    reply.raw.once("close", () => {
-      if (!reply.raw.writableFinished) {
-        logForwardedSessionResponseStage("close", req);
-        logger.warn(`[http-response] requestId=${requestId} method=${req.method} url=${req.url} ` +
-          `closedMs=${(performance.now() - startedAt).toFixed(1)} status=${reply.statusCode}`);
-      }
-    });
-  });
-  app.addHook("preSerialization", async (req, _reply, payload) => {
-    logForwardedSessionResponseStage("preSerialization", req);
-    return payload;
-  });
-  app.addHook("onSend", async (req, _reply, payload) => {
-    logForwardedSessionResponseStage("onSend", req);
-    return payload;
-  });
+  installForwardedResponseLog(app, { log: line => logger.info(line), warn: line => logger.warn(line) });
 
   const sourceRegistry = createSourceRegistry(200);
   // The torrent runs on its own thread. Profiling a live seek (2026-08-02)
@@ -235,21 +190,19 @@ export async function startProxyServer({
     heapSnapshots,
     onHoldingsChanged: () => onStateChanged(),
     onSourceForgotten: ({ sourceKey }) => {
-      sourcePreparation?.forget(sourceKey);
+      sourcePreparation.forget(sourceKey);
       mediaReads.forget(sourceKey);
       chapters.forget(sourceKey);
       probeReads.forget(sourceKey);
-      subtitles.forget(sourceKey);
+      subtitleWalk.subtitles.forget(sourceKey);
       keyframeTables.forget(sourceKey);
       playbackPlanner.forget(sourceKey);
       indexMemory.forget(sourceKey);
       downloadMaps.retire(sourceKey);
-      for (const key of segmentSourceRanges.keys()) if (key.startsWith(`${sourceKey}:`)) segmentSourceRanges.delete(key);
-      for (const key of segmentReadings.keys()) if (key.startsWith(`${sourceKey}:`)) segmentReadings.delete(key);
-      for (const key of playbackProjections.keys()) if (key.startsWith(`${sourceKey}:`)) playbackProjections.delete(key);
-      for (const key of madeRates.keys()) if (key.startsWith(`${sourceKey}:`)) madeRates.delete(key);
+      sourceRanges.forget(sourceKey);
+      resolution.forget(sourceKey);
       segmentInputs.forget(sourceKey);
-      outputParts.encodeInputs?.bytesChanged();
+      encodeInputs?.bytesChanged();
     },
     // Pieces arriving is ANNOUNCED by the thread that owns the swarm; what is
     // done about it — walking a file's new subtitle clusters and pushing what
@@ -265,121 +218,27 @@ export async function startProxyServer({
       for (const fileIndex of fileIndexes) {
         mediaReads.bytesChanged(sourceKey, fileIndex);
         probeReads.bytesChanged(sourceKey, fileIndex);
-        void sourcePreparation?.bytesChanged(sourceKey, fileIndex).catch(error =>
+        void sourcePreparation.bytesChanged(sourceKey, fileIndex).catch(error =>
           logger.warn(`source input readiness failed: ${error.message}`));
-        void pushFreshCues(`${sourceKey}:${fileIndex}`, sourceKey, fileIndex);
+        void subtitleWalk.pushFreshCues(sourceKey, fileIndex);
         // A keyframe table somebody asked for while its bytes had not arrived
         // is read again now; nothing was recorded for that wait.
         keyframeTables.readAgainIfUnanswered({ sourceKey, fileIndex, logName: String(fileIndex) });
       }
       // Which bytes arrived, when the event names them: an input waiting for
       // named bytes is tried again only when some of them have come.
-      outputParts.encodeInputs?.bytesChanged(Array.isArray(arrived) ? { sourceKey, ranges: arrived } : null);
+      encodeInputs?.bytesChanged(Array.isArray(arrived) ? { sourceKey, ranges: arrived } : null);
     }
   });
   const selectedPort = await getPort({
     port: buildPortCandidates(port)
   });
-  // Auto-detect the best available H.264 encoder (hardware-accelerated or
-  // software) once at startup, with a real test-encode and graceful fallback.
-  // Only needed when transcoding can occur.
-  let videoEncoder = transcodeAudio
-    ? await detectVideoEncoder({ ffmpegBin, logger })
-    : null;
   // The cores this process may use (a container's quota or CPU set): the
-  // readings below divide out a share of those, the unit every later share of
-  // the machine is in (torrent-tv/meta#180, phase 3).
+  // readings divide out a share of those, the unit every later share of the
+  // machine is in (torrent-tv/meta#180, phase 3).
   const processorCores = processorBound().cores;
-  // WHAT THIS HOST DOES, measured before any viewer exists. Every one of these
-  // was gated on the chosen encoder being SOFTWARE, and two of the three are
-  // not about the encoder at all: a host with a GPU decodes in software just
-  // the same — no hardware decoder is asked for anywhere — and what a second
-  // job costs is a property of the machine. So a GPU host had no decode cost,
-  // no contention penalty and no encoder throughput, and the quality offer,
-  // which is arithmetic over those three, had nothing to compute from.
-  //
-  // The decode model first and the throughput second — they are independent
-  // (the rungs are timed on raw frames), but the order keeps the two figures
-  // side by side in the log.
-  const decodeCostModel = transcodeAudio
-    ? await benchmarkDecodeCost({ ffmpegBin, logger, processorCores })
-    : null;
-  // What a second job costs on this host. Measured because the budget adds
-  // independent prices and this host says two jobs that each fit alone do not
-  // fit together — 2.6× on the addon box (2026-08-18).
-  const contentionPenalties = transcodeAudio
-    ? await benchmarkContention({ ffmpegBin, logger })
-    : null;
-  // WHICH MODES THIS HOST MAY ENCODE WITH, AND WHAT EACH COSTS AT EVERY SIZE
-  // (roadmap item 97, step 14). Every setting an output can actually be
-  // encoded at is put through the product's own arguments and its segments
-  // decoded, then timed at the sizes of the ladder; a mode that fails either is
-  // not used, and a size nothing was timed at is not offered. Software is
-  // calibrated too when detection chose a device: it is what a failing device
-  // falls back to for the rest of the process, and it must not be priced by
-  // the device's figures.
-  //
-  // And WHICH CONFIGURATION all of it describes — the ffmpeg and x264 builds,
-  // the processor and the threads, the device and its driver — which is what
-  // decides whether anything kept from an earlier run still applies.
-  const fingerprint = videoEncoder
-    ? await readHostFingerprint({ ffmpegBin, encoder: videoEncoder, processorCores })
-    : null;
-  /** @type {Record<string, object[]>} */
-  const calibratedModes = {};
-  if (videoEncoder) {
-    const selectedCalibration = await calibrateEncoder({ ffmpegBin, encoder: videoEncoder, logger, processorCores });
-    if (selectedCalibration.assessmentComplete) {
-      calibratedModes[videoEncoder.kind] = selectedCalibration.modes;
-    }
-    if (videoEncoder.kind !== "software") {
-      const softwareCalibration = await calibrateEncoder({ ffmpegBin, encoder: softwareDescriptor(), logger, processorCores });
-      if (softwareCalibration.assessmentComplete) {
-        calibratedModes.software = softwareCalibration.modes;
-      }
-      // A device that passed detection's own test and then none of whose modes
-      // passed the product's is not used: detection encodes a synthetic pattern
-      // with arguments of its own, and it is the product's arguments a viewer
-      // is served with.
-      if (Array.isArray(calibratedModes[videoEncoder.kind]) && calibratedModes[videoEncoder.kind].length === 0) {
-        logger.warn(
-          `calibration: ${videoEncoder.name} passed detection but none of its modes produced correct segments ` +
-          "through the product's own arguments; encoding in software instead"
-        );
-        videoEncoder = softwareDescriptor();
-      }
-    }
-  }
-  const calibration = videoEncoder ? new HostCalibration({ byKind: calibratedModes, fingerprint }) : null;
-  // What this host does with a picture it does NOT re-encode. Every other
-  // startup measurement prices encoding or decoding, and a copied picture does
-  // neither — it reads packets and writes them out again — so that whole branch
-  // had no speed until its own run had been running long enough to report one.
-  // The encoding layer decides where encoders go from arrivals, and an arrival
-  // cannot be computed without a speed, so the moment it mattered most was the
-  // moment nothing was known. Measured whatever the encoder is: copying does not
-  // touch it.
-  const copySpeedX = transcodeAudio
-    ? await benchmarkCopySpeed({ ffmpegBin, logger })
-    : null;
-  const audioCalibration = transcodeAudio
-    ? await benchmarkAudio({ ffmpegBin, logger })
-    : [];
-  // WHAT A START AND A STOP COST HERE, before any viewer exists. Both decide one
-  // thing — leave an encoder where it stands, or kill it and start another —
-  // and both used to be learned only from runs that had ENDED, so at a cold
-  // open they were zero. Zero does not read as "not measured": it reads as
-  // "free", and a free move is always taken. Field 2026-09-08: an encoder moved
-  // between two adjacent numbers every half second and produced nothing.
-  const startStopCost = transcodeAudio
-    ? await measureStartAndStop({ ffmpegBin, encoder: videoEncoder, logger })
-    : null;
-  // Whether this ffmpeg build can tone-map HDR→SDR (zscale + tonemap filters).
-  // Detected once; the session manager applies the tonemap chain only for HDR
-  // sources on the software path when available.
-  const tonemapSupported = transcodeAudio
-    ? await detectTonemapSupport({ ffmpegBin, logger })
-    : false;
+  const { videoEncoder, decodeCostModel, contentionPenalties, calibration, copySpeedX, audioCalibration, startStopCost,
+    tonemapSupported } = await measureHost({ ffmpegBin, logger, transcode: transcodeAudio, processorCores });
   // Where every file's keyframe table lives, and the only thing that reads one.
   // Built here rather than inside the session manager because it is not a fact
   // about a session: the playback planner warms it while a file is being opened
@@ -390,18 +249,6 @@ export async function startProxyServer({
   // written out is the media layer's, while which clusters may be read, where
   // the cursor stands and what one walk at a time means are the TORRENT's own
   // rules. The media layer used to import the second directly.
-  /**
-   * One file of one torrent, reduced to what the subtitle walk may know: a
-   * name, a length, its one container, which ranges are downloaded whole, how
-   * to read one of those without asking the swarm, the portion one read may
-   * span, and where the viewers stand. File offsets and the bitfield stay in
-   * the torrent's thread; the piece length crosses as a plain number.
-   *
-   * @param {string} sourceKey
-   * @param {number} fileIndex
-   * @param {object} [known] - The torrent handle when the caller already has it.
-   * @returns {Promise<import("./services/media/SubtitleCues.js").HeldFile | null>}
-   */
   const chapters = new ChapterOrchestrator({
     containers: containerOrchestrator,
     subscribe: (sourceKey, fileIndex, listener) => mediaReads.subscribe(sourceKey, fileIndex, listener),
@@ -416,99 +263,18 @@ export async function startProxyServer({
       const torrent = torrentPool.knownTorrent(sourceKey);
       const file = torrent?.files?.[fileIndex];
       if (!file) return torrent ? { invalid: true } : null;
-      return containerOver({ sourceKey, fileIndex });
+      return mediaParams.paramsFor({ sourceKey, fileIndex });
     }
   });
   const chapterController = new ChapterController({ sourceRegistry, chapters });
-  const heldFileFor = async (sourceKey, fileIndex, known = null) => {
-    let torrent = known;
-    if (!torrent) {
-      torrent = torrentPool.knownTorrent(sourceKey);
-      if (!torrent) return null;
-    }
-    const file = torrent?.files?.[fileIndex];
-    if (!file || !(file.length > 0)) {
-      return null;
-    }
-    return {
-      sourceKey,
-      fileIndex,
-      name: String(file.name ?? ""),
-      length: file.length,
-      portionBytes: Number(torrent.pieceLength) > 0 ? Number(torrent.pieceLength) : undefined,
-      // The file's ONE container — the one the track table, the media info and
-      // the keyframe table are read from. Built here only when nobody has built
-      // it yet, so a pass of the walk does not fetch the file's edges again.
-      container: async () => {
-        const known = containerOrchestrator.known(sourceKey, fileIndex);
-        if (known !== undefined) {
-          return known;
-        }
-        const params = await containerOver({ sourceKey, fileIndex, tailBytes: CONTAINER_HEAD_BYTES });
-        return params ? containerOrchestrator.containerFor(params) : null;
-      },
-      heldRanges: () => torrentPool.heldRangesOf(torrent, fileIndex),
-      readHeld: (start, end) => torrentPool.readHeldOf(torrent, fileIndex, start, end),
-      // Where the viewers of this file stand: the start of every urgent stretch
-      // of its priority map, which is where each viewer's own need begins.
-      wantedSeconds: () => viewerStartsOn(outputParts.priority?.mapFor(sourceKey, fileIndex)),
-      // A pass left readable clusters for the next one: run it.
-      askAgain: () => {
-        void pushFreshCues(`${sourceKey}:${fileIndex}`, sourceKey, fileIndex);
-      }
-    };
-  };
-  /**
-   * Walk whatever new cues a file now holds and push them to the viewers.
-   *
-   * One walk of a file at a time, and one more after it whenever pieces
-   * arrived meanwhile (`coalescing`): `verified` fires per piece, so a queue of
-   * identical passes would only postpone the one with something new to find,
-   * and dropping them — as this used to — lost the pass that would have found
-   * the last pieces of a file.
-   */
-  const pushFreshCues = coalescing(async (sourceKey, fileIndex) => {
-    try {
-      const file = await heldFileFor(sourceKey, fileIndex);
-      if (!file) {
-        return;
-      }
-      for (const entry of await warmSubtitleCues(file)) {
-        if (subtitles.hasPacketCues(sourceKey, fileIndex, entry.trackIndex)) continue;
-        const span = entry.spanStartSeconds === null
-          ? "empty"
-          : `${entry.spanStartSeconds.toFixed(1)}-${entry.spanEndSeconds.toFixed(1)}s`;
-        logger.info(
-          `subtitle push ${sourceKey.slice(0, 8)}:${fileIndex} track ${entry.trackIndex}: ` +
-          `${entry.cues.length} new cue(s) covering ${span}` +
-          (entry.withdrawn.length > 0 ? `, ${entry.withdrawn.length} taken back` : "") +
-          `, clusters walked ${entry.walkedClusters}/${entry.indexedClusters}, cursor ${entry.cursor}`
-        );
-        onSubtitleCues?.({ sourceKey, fileIndex, ...entry });
-      }
-    } catch (error) {
-      logger.warn(`subtitle push ${sourceKey.slice(0, 8)}:${fileIndex} failed: ${error?.message ?? error}`);
-    }
-  });
-  const subtitles = new SubtitleOrchestrator(containerOrchestrator, {
+  const subtitleWalk = new SubtitleWalk({
+    torrents: torrentPool,
+    containers: containerOrchestrator,
+    paramsFor: request => mediaParams.paramsFor(request),
+    wantedSeconds: (sourceKey, fileIndex) => viewerStartsOn(outputParts.priority?.mapFor(sourceKey, fileIndex)),
     publish: entry => onSubtitleCues?.(entry),
-    warm: async (torrent, fileIndex, sourceKey) => {
-      const file = await heldFileFor(sourceKey, fileIndex, torrent);
-      return file ? warmSubtitleCues(file) : [];
-    },
-    held: async (torrent, fileIndex, sourceKey, trackNumber) => {
-      const file = await heldFileFor(sourceKey, fileIndex, torrent);
-      return file ? cuesHeldFor(file, trackNumber) : null;
-    },
-    tracksOf: async (torrent, fileIndex, sourceKey) => {
-      const file = await heldFileFor(sourceKey, fileIndex, torrent);
-      return file ? subtitleTracksOf(file) : [];
-    },
-    declaredTracksOf: async (torrent, fileIndex, sourceKey) => {
-      const file = await heldFileFor(sourceKey, fileIndex, torrent);
-      return file ? declaredSubtitleTracksOf(file) : [];
-    },
-    forget: forgetSubtitles
+    log: line => logger.info(line),
+    warn: line => logger.warn(line)
   });
   // WHAT A FILE STATES ABOUT ITSELF IS READ HERE, ON THIS THREAD.
   //
@@ -523,389 +289,13 @@ export async function startProxyServer({
   //
   // Missing metadata bytes are demand in the same file map as playback.
   // Readers never start their own downloads or wait for source bytes.
-  /** Source byte ranges of one segment interval, by file and interval; forgotten with the source. */
-  const segmentSourceRanges = new Map();
-  /**
-   * WHAT ONE SEGMENT OF AN OUTPUT IS, kept from pass to pass: where it lies in
-   * the source, what it reads — its tracks and the key its bytes are kept under
-   * — and, once known, those bytes joined at the precision the torrent fetches,
-   * by output and segment. Worked out again only when the output's timeline,
-   * the tracks, the file's start time or the output's choices change; forgotten
-   * with the source. None of it depends on where a viewer stands, and a pass is
-   * made every time one moves: looked up, made and joined again for each of a
-   * film's 3500 segments on every pass, they were 6 s of the 40 s the passes
-   * cost the main thread in fifteen minutes on Home Assistant (r30,
-   * torrent-tv/meta#178).
-   */
-  const segmentReadings = new Map();
-  /** One output's segments, by index. */
-  const segmentRecordsOf = (map, output) => {
-    const key = `${map.sourceKey}:${map.fileIndex}:${output.outputKey}`;
-    let records = segmentReadings.get(key);
-    if (!records) segmentReadings.set(key, records = new Map());
-    return records;
-  };
-  /** The choices of one output's tracks as a key, worked out once for the list of them a pass shares. */
-  const choicesKeys = new WeakMap();
-  const choicesKeyOf = (choices) => {
-    let key = choicesKeys.get(choices);
-    if (key === undefined) choicesKeys.set(choices, key = choices.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(","));
-    return key;
-  };
-  const segmentRecordOf = (records, demand, { timeline, trackList, shift, map }) => {
-    const choicesKey = choicesKeyOf(demand.tracks);
-    const kept = records.get(demand.index);
-    if (kept && kept.timeline === timeline && kept.trackList === trackList && kept.shift === shift && kept.choicesKey === choicesKey) return kept;
-    const sourceInterval = timeline.sourceInterval(demand.index, demand.index, shift);
-    const selected = demand.tracks.map(choice => ({ choice, track: choice.type === "video"
-      ? ContainerTrack.firstUsable(trackList, "video")
-      : trackList.filter(track => track.type === choice.type)[choice.index] }));
-    let reading = null;
-    if (!selected.some(({ track }) => !track)) {
-      const wanted = selected.map(({ track }) => track);
-      const modes = new Map(selected.map(({ choice, track }) => [track, choice.mode]));
-      const interval = { ...sourceInterval, trackIds: wanted.map(track => track.trackNumber),
-        modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
-      reading = { wanted, modes, interval, rangesKey: `${map.sourceKey}:${map.fileIndex}:${JSON.stringify(interval)}` };
-    }
-    // `joined` is the segment's ranges as the torrent is told them, made from
-    // the list `ranges` at `pieceLength`; `registered` is the list the input
-    // table was last given.
-    const record = { timeline, trackList, shift, choicesKey, sourceInterval, reading,
-      ranges: null, pieceLength: Number.NaN, joined: null, registered: null };
-    records.set(demand.index, record);
-    return record;
-  };
-  /** What the torrent is told of each played file, kept from map to map (`PlaybackProjection`); forgotten with the source. */
-  const playbackProjections = new Map();
+  /** Source byte ranges of one segment interval; the cache is the resolver's, forgotten with the source. */
+  const sourceRanges = new SegmentSourceRanges({ orchestrator: containerOrchestrator });
   /** Which source bytes each segment of an output reads, for the forecast (`segment-input-table.js`). */
   const segmentInputs = new SegmentInputTable();
-  /** An output's cut grid, checked once for each timeline. */
-  const checkedGrids = new WeakMap();
-  const gridOf = (output) => {
-    const timeline = output.timeline;
-    if (!timeline || typeof timeline !== "object") return null;
-    if (checkedGrids.has(timeline)) return checkedGrids.get(timeline);
-    const grid = timeline.published ?? timeline.boundaries;
-    if (!Array.isArray(grid)) {
-      checkedGrids.set(timeline, null);
-      return null;
-    }
-    for (let index = 0; index + 1 < grid.length; index++) {
-      if (!Number.isFinite(grid[index]) || !Number.isFinite(grid[index + 1]) || !(grid[index + 1] > grid[index])) {
-        throw new Error("An output segment needs a valid interval.");
-      }
-    }
-    checkedGrids.set(timeline, grid);
-    return grid;
-  };
-  /**
-   * How many bytes a second of an output's film takes, from what it has made,
-   * read again only when what it has made changes (`SegmentStore.revisionOf`):
-   * summed over every made segment on every pass, it was a walk of the whole
-   * film a second (torrent-tv/meta#178).
-   */
-  const madeRates = new Map();
-  const bytesPerSecondOf = (output, revision) => {
-    const kept = madeRates.get(output.outputKey);
-    if (kept && kept.revision === revision && kept.timeline === output.timeline) return kept.bytesPerSecond;
-    let bytes = 0, seconds = 0;
-    for (const [index, size] of outputParts.segmentStore.sizesOf(output.outputKey)) {
-      const span = output.timeline.publishedStartOf(index + 1) - output.timeline.publishedStartOf(index);
-      if (span > 0) { bytes += size; seconds += span; }
-    }
-    const bytesPerSecond = seconds > 0 ? bytes / seconds : null;
-    madeRates.set(output.outputKey, { revision, timeline: output.timeline, bytesPerSecond });
-    return bytesPerSecond;
-  };
-  // WHAT THE PASSES COST, said once a minute: how many maps were taken, how
-  // many segments a map made the projection work out again and how many of
-  // those maps it worked out whole, how many segments had their ranges worked
-  // out, the windows told, and the time from a pass's start to its result —
-  // which includes waits for reads, so it bounds the main thread's share
-  // rather than measuring it (torrent-tv/meta#178).
-  const passCosts = { since: Date.now(), passes: 0, whole: 0, reworked: 0, resolved: 0, windows: 0, ms: 0, maxMs: 0 };
-  const notePass = ({ whole = false, reworked = 0, resolved = 0, windows = 0, ms = 0 }) => {
-    passCosts.passes += 1;
-    if (whole) passCosts.whole += 1;
-    passCosts.reworked += reworked; passCosts.resolved += resolved; passCosts.windows += windows;
-    passCosts.ms += ms; passCosts.maxMs = Math.max(passCosts.maxMs, ms);
-    const now = Date.now();
-    if (now - passCosts.since < 60_000) return;
-    logger.info(`download map passes in ${((now - passCosts.since) / 1000).toFixed(1)}s: ${passCosts.passes} map(s), ` +
-      `${passCosts.whole} worked out whole, ${passCosts.reworked} segment(s) worked out again, ` +
-      `${passCosts.resolved} segment(s) had their ranges worked out, ${passCosts.windows} window(s) told; ` +
-      `${Math.round(passCosts.ms)}ms from start to result in all, longest ${Math.round(passCosts.maxMs)}ms`);
-    Object.assign(passCosts, { since: now, passes: 0, whole: 0, reworked: 0, resolved: 0, windows: 0, ms: 0, maxMs: 0 });
-  };
-  // A container whose packet table a pass did not wait for builds the map
-  // again once, when the table is built or refused (`directSegmentInput`).
-  const refreshAfterTable = new WeakSet();
-  const refreshWhenBuilt = (container, built, { sourceKey, fileIndex }) => {
-    if (refreshAfterTable.has(container)) return;
-    refreshAfterTable.add(container);
-    void built.then(() => {
-      refreshAfterTable.delete(container);
-      return downloadMaps.refresh(sourceKey, fileIndex);
-    }).catch(error => logger.warn(`download map after a packet table: ${error?.message ?? error}`));
-  };
-  let outputPartsReady = false;
-  const downloadMaps = new DownloadMaps({
-    // The ranges a picture reads at open are named again by every segment;
-    // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
-    // Left out of what is SENT and nowhere else: every segment's own zones are
-    // also what says which bytes that segment needs, and a segment whose zones
-    // all repeat another's — two of one group of pictures in an AVI read the
-    // same bytes — lost them with 2.96.11, and the start forecast answered
-    // "source-input-ranges-unavailable" for ever (Home Assistant 2026-10-11).
-    publish: (map) => torrentPool.setPriorityMap({ ...map, zones: withoutRepeatedZones(map.zones) }),
-    // And what is sent is packed: a stretch of one level and priority is one
-    // window, not one zone per range of each of its segments
-    // (`coalescedZones`, torrent-tv/meta#178). The playback zones come packed
-    // already from the projection; this packs them with the native ones.
-    pack: (zones) => coalescedZones(zones),
-    log: (line) => logger.info(line),
-    observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
-    // A file's own reads are wanted while a present viewer has the file chosen
-    // or on screen. The viewers are assembled below; until they exist no read
-    // can have been asked for by one.
-    fileWanted: (sourceKey, fileIndex) => (outputPartsReady ? outputParts.viewers.forSource(sourceKey) : [])
-      .some(viewer => viewer.source?.selectedFileIndex === fileIndex ||
-        viewer.source?.visibleFileIndices?.includes(fileIndex)),
-    resolvePlayback: async (map) => {
-      const fileKey = `${map.sourceKey}:${map.fileIndex}`;
-      if (map.zones.length === 0) {
-        playbackProjections.get(fileKey)?.clear();
-        return [];
-      }
-      const params = await containerOver(map);
-      if (!params || !map.isCurrent()) return [];
-      const tracks = await containerOrchestrator.inspect(params, "tracks");
-      if (tracks.kind !== "result" || !map.isCurrent()) return [];
-      const container = containerOrchestrator.known(map.sourceKey, map.fileIndex);
-      if (typeof container?.readSourceRanges !== "function" && typeof container?.readPacketIndex !== "function") return [];
-      const media = await containerOrchestrator.inspect(params, "media-info");
-      if (media.kind !== "result" || !map.isCurrent()) return [];
-      const shift = Number(media.value?.startTimeSeconds) || 0;
-      // A zone's ranges are stated to the torrent at the precision it fetches:
-      // ranges closer than a piece hold the same pieces as one.
-      const pieceLength = Number(torrentPool.knownTorrent(map.sourceKey)?.pieceLength);
-      const passStartedAt = performance.now();
-      // THE PROJECTION IS KEPT while what it was made from stands: the file's
-      // tracks, where its clock starts and how the torrent fetches. Any of them
-      // changed, every segment's ranges are other ranges.
-      let projection = playbackProjections.get(fileKey);
-      if (!projection || projection.trackList !== tracks.value || projection.shift !== shift ||
-        !Object.is(projection.pieceLength, pieceLength)) {
-        projection?.clear();
-        projection = new PlaybackProjection();
-        Object.assign(projection, { trackList: tracks.value, shift, pieceLength });
-        playbackProjections.set(fileKey, projection);
-      }
-      // Every output of this file somebody is watching, with what decides how
-      // long its segments take to make and deliver, what it has made, and what
-      // its next run would copy.
-      const played = [];
-      /** By output: what its segments read and how they are looked up. */
-      const readers = new Map();
-      for (const output of outputParts.outputs.values()) {
-        if (output.file.sourceKey !== map.sourceKey) continue;
-        const consumers = [...outputParts.viewers.forOutput(output).values()].filter(viewer =>
-          viewer.isPresent() && !outputParts.outputs.supersededBy(output, viewer.activeVariantId ?? null));
-        if (consumers.length === 0) continue;
-        const choices = trackChoicesOf(output, map.fileIndex);
-        if (choices.length === 0) continue;
-        const grid = gridOf(output);
-        if (!grid) continue;
-        const revision = outputParts.segmentStore.revisionOf(output.outputKey);
-        const links = consumers.map(viewer => viewer.linkReading()?.linkMbps)
-          .filter(value => Number.isFinite(value) && value > 0);
-        // Every piece answers for its exact ending boundary, as the encode
-        // plan reads it: the player may request the preceding piece there.
-        played.push({ outputKey: output.outputKey, grid,
-          encodeSpeed: outputParts.encodeCost.latestSpeedReadingOf(output)?.speed,
-          bytesPerSecond: bytesPerSecondOf(output, revision), linkMbps: links.length ? Math.min(...links) : null,
-          readyRevision: revision, ready: () => outputParts.segmentStore.sizesOf(output.outputKey),
-          target: outputParts.encodeInputs?.targetInputBytes?.(output) ?? null });
-        readers.set(output.outputKey, { records: segmentRecordsOf(map, output), choices,
-          facts: { timeline: output.timeline, trackList: tracks.value, shift, map } });
-      }
-      // WHAT THE MAP CHANGED, and only that, is worked out again here.
-      projection.update({ zones: map.zones, outputs: played });
-      const reworked = projection.lastUpdate;
-      let resolved = 0;
-      // A container that names the bytes of an interval from an index it holds
-      // answers every segment by arithmetic: once that index is read
-      // ("source-navigation"), the ranges are computed here directly instead of
-      // through the file's queue of reads, three steps per segment. On Home
-      // Assistant those steps made a pass over a two-hour AVI take minutes while
-      // the arithmetic takes milliseconds (torrent-tv/meta#151).
-      const navigated = await containerOrchestrator.inspect(params, "source-navigation");
-      if (!map.isCurrent()) return [];
-      const direct = navigated.kind === "result" && navigated.value === true &&
-        typeof container?.readSourceRanges === "function" ? container : null;
-      // An output whose file-level reading is not there in this pass — the
-      // index or Cues that say where a segment is, not yet downloaded, or the
-      // table its segments read, refused memory — answers its other segments
-      // the same way. One unanswered request is kept to be retried when the
-      // bytes or the memory change, and the map is built again when it
-      // answers; asking every segment held the main thread for 3.3 s on a cold
-      // two-hour AVI (torrent-tv/meta#178).
-      const waiting = new Set();
-      const turn = takeTurns();
-      // ONLY THE SEGMENTS WHOSE RANGES ARE NOT KNOWN are worked out, in the
-      // order the swarm is to fetch them. Range resolution can use either a
-      // direct source index or the fallback reads below; yield between zones
-      // in both cases so a large map cannot hold the main thread across its
-      // full projection.
-      for (const zone of projection.unresolved()) {
-        if (!map.isCurrent()) return [];
-        await turn();
-        if (!map.isCurrent()) return [];
-        const resolutionStartedAt = performance.now();
-        const resolution = { outcome: "unresolved", method: null, trackCount: null, rangeCount: null, rangeBytes: null };
-        const resolutionId = `${map.fileIndex}:${zone.outputKey}:${zone.index}:${passStartedAt.toFixed(3)}`;
-        waitTrace.source(map.sourceKey, "process", { process: "P4.1", phase: "begin", resolutionId,
-          sourceId: `${map.sourceKey}:${map.fileIndex}`, fileIndex: map.fileIndex, outputKey: zone.outputKey,
-          segment: zone.index, priority: zone.priority, deadlineAt: zone.deadlineAt });
-        try {
-          const reader = readers.get(zone.outputKey);
-          if (!reader) {
-            resolution.outcome = "reader-missing";
-            continue;
-          }
-        // WHAT A SEGMENT READS IS WORKED OUT ONCE (`segmentRecordOf`). Rebuilt
-        // for every segment of the film on every map, this pass held the main
-        // thread up to 1.5 s at a time on Home Assistant (torrent-tv/meta#178).
-          const record = segmentRecordOf(reader.records, { index: zone.index, tracks: reader.choices }, reader.facts);
-          const reading = record.reading;
-          if (!reading) {
-            resolution.outcome = "segment-reading-unavailable";
-            projection.setUnreadable(zone.outputKey, zone.index);
-            continue;
-          }
-          const { wanted, modes, interval, rangesKey } = reading;
-          resolution.trackCount = wanted.length;
-          resolution.trackIds = wanted.map(track => track.trackNumber);
-          resolution.sourceInterval = { from: interval.from, to: interval.to };
-          const convert = (ranges, method) => {
-            if (record.ranges !== ranges || record.pieceLength !== pieceLength) {
-              record.ranges = ranges;
-              record.pieceLength = pieceLength;
-              record.joined = joinedWithinPieces(ranges, pieceLength);
-            }
-            const joined = record.joined;
-            resolution.method = method;
-            resolution.rangeCount = joined.length;
-            resolution.rangeBytes = joined.reduce((total, [start, end]) => total + end - start + 1, 0);
-            // What the segment reads is kept for the forecast in a table of its
-            // own, whatever form the torrent is told it in.
-            if (record.registered !== joined) {
-              segmentInputs.set(map.sourceKey, map.fileIndex, zone.outputKey, zone.index, joined);
-              record.registered = joined;
-            }
-            projection.setRanges(zone.outputKey, zone.index, joined);
-            resolution.outcome = "resolved";
-            resolved += 1;
-          };
-        // The bytes one segment needs are a fact of the file and the output, so
-        // they are worked out once. A whole film is thousands of segments and
-        // the map changes every few seconds; worked out afresh on every change,
-        // a pass over a two-hour AVI never finished and the next segment's bytes
-        // were never asked for (Home Assistant 2026-10-08, torrent-tv/meta#151).
-          const known = record.ranges ?? segmentSourceRanges.get(rangesKey);
-          if (known) { convert(known, record.ranges ? "segment-record-cache" : "source-range-cache"); continue; }
-          if (waiting.has(zone.outputKey)) {
-            resolution.outcome = "waiting-for-output-input";
-            continue;
-          }
-        // What is resolved so far is stated before a lower zone is worked out
-        // (DownloadMaps, torrent-tv/meta#178).
-          map.workingOut?.(zone.priority, () => projection.windows());
-          if (direct) {
-          // Asked per zone too: a soundtrack of an AVI is read from its own
-          // packets, which the same index states (torrent-tv/meta#166).
-            let value = null;
-            try {
-              value = await directSegmentInput(direct, { interval, tracks: wanted, mode: track => modes.get(track) },
-                built => refreshWhenBuilt(direct, built, map));
-            } catch { value = null; }
-          // A table still being built holds this output's segments, and only
-          // this output's: the map is built again when it is.
-            if (value?.kind === "pending") {
-              resolution.method = "direct-source-index";
-              resolution.outcome = "source-index-pending";
-              waiting.add(zone.outputKey);
-              continue;
-            }
-            if (value?.kind === "result") segmentSourceRanges.set(rangesKey, value.ranges);
-            if (value?.kind === "result") {
-              convert(value.ranges, "direct-source-index");
-              continue;
-            }
-          }
-          resolution.method = "container-index-fallback";
-          const intervalParams = await containerOver({ ...map, packetInterval: interval,
-            requestId: `download:${map.sourceKey}:${map.fileIndex}:${zone.outputKey}:${zone.index}`,
-            demand: { ...zone.owner, leadSeconds: zone.leadSeconds } });
-          if (!map.isCurrent()) {
-            resolution.outcome = "map-replaced";
-            return [];
-          }
-          if (!intervalParams) {
-            resolution.outcome = "source-file-unavailable";
-            continue;
-          }
-          const navigation = await containerOrchestrator.inspect(intervalParams, "source-navigation");
-          if (!map.isCurrent()) {
-            resolution.outcome = "map-replaced";
-            return [];
-          }
-          if (navigation.kind !== "result") {
-            resolution.outcome = `source-navigation-${navigation.kind}`;
-            if (navigation.kind === "needs-ranges" || navigation.kind === "needs-memory") waiting.add(zone.outputKey);
-            continue;
-          }
-          const originalRanges = navigation.value;
-          const packets = await containerOrchestrator.inspect(intervalParams, originalRanges ? "source-ranges" : "packets");
-          if (!map.isCurrent()) {
-            resolution.outcome = "map-replaced";
-            return [];
-          }
-          if (packets.kind === "needs-memory") waiting.add(zone.outputKey);
-          if (packets.kind !== "result") {
-            resolution.outcome = `source-packets-${packets.kind}`;
-            continue;
-          }
-          const input = originalRanges ? packets.value : new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({ ...interval, mode: track => modes.get(track) });
-          if (input.kind !== "result") {
-            resolution.outcome = `segment-input-${input.kind}`;
-            continue;
-          }
-          segmentSourceRanges.set(rangesKey, input.ranges);
-          convert(input.ranges, originalRanges ? "container-source-ranges" : "packet-index");
-        } catch (error) {
-          resolution.outcome = "error";
-          resolution.error = error?.message ?? String(error);
-          throw error;
-        } finally {
-          const resolutionEndedAt = performance.now();
-          waitTrace.source(map.sourceKey, "process", { process: "P4.1", phase: "end", resolutionId,
-            sourceId: `${map.sourceKey}:${map.fileIndex}`, fileIndex: map.fileIndex, outputKey: zone.outputKey,
-            segment: zone.index, priority: zone.priority,
-            startedAt: resolutionStartedAt, endedAt: resolutionEndedAt, durationMs: resolutionEndedAt - resolutionStartedAt,
-            ...resolution });
-        }
-      }
-      const result = projection.windows();
-      notePass({ whole: reworked.whole, reworked: reworked.segments, resolved, windows: result.length,
-        ms: performance.now() - passStartedAt });
-      return result;
-    }
-  });
   const mediaReads = new MediaReadRequests({
-    read: (params, statement) => statement === "subtitle-file" ? subtitles.inspectFile(params)
-      : statement === "subtitle-cues" ? subtitles.inspectPackets(params) : containerOrchestrator.inspect(params, statement),
+    read: (params, statement) => statement === "subtitle-file" ? subtitleWalk.subtitles.inspectFile(params)
+      : statement === "subtitle-cues" ? subtitleWalk.subtitles.inspectPackets(params) : containerOrchestrator.inspect(params, statement),
     failed: (params, statement, error) => logger.warn(`media source=${params.sourceKey} file=${params.fileIndex} statement=${statement} retry failed: ${error?.message ?? error}`)
   });
   const probeReads = new ProbeRequests({
@@ -918,116 +308,41 @@ export async function startProxyServer({
   });
   const indexMemory = new IndexMemory({
     growthBytes: LARGEST_GROWTH_BYTES,
-    reviseBudget: () => { void outputParts.machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
-    changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); outputParts.encodeInputs?.memoryChanged(); }
+    reviseBudget: () => { void machineBudget.revise("memory", "media metadata").catch(error => logger.warn(`packet index budget: ${error.message}`)); },
+    changed: () => { mediaReads.memoryChanged(); probeReads.memoryChanged(); encodeInputs?.memoryChanged(); }
+  });
+  const mediaParams = new MediaReadParams({
+    heldFile: (sourceKey, fileIndex) => {
+      if (!sourceRegistry.get(sourceKey)) return null;
+      const torrent = torrentPool.knownTorrent(sourceKey);
+      const file = torrent?.files?.[fileIndex];
+      if (!file || !(file.length > 0)) return null;
+      return { length: file.length, name: String(file.name ?? ""), offset: file.offset,
+        portionBytes: Number(torrent.pieceLength) > 0 ? Number(torrent.pieceLength) : undefined,
+        readHeld: (start, end) => torrentPool.readHeldOf(torrent, fileIndex, start, end),
+        noteVideo: hasVideo => contentsOf(torrent).noteVideo(fileIndex, hasVideo) };
+    },
+    packetMemory: (sourceKey, fileIndex) => indexMemory.forFile(sourceKey, fileIndex),
+    readProbe: request => probeReads.read(request),
+    probePackets,
+    baseUrl: () => localBaseUrl,
+    observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
+    reads: { revision: (...a) => mediaReads.revision(...a), memoryRevision: () => mediaReads.memoryRevision(),
+      record: (...a) => mediaReads.record(...a) },
+    maps: { epoch: (...a) => downloadMaps.epoch(...a), wantsInterval: (...a) => downloadMaps.wantsInterval(...a),
+      metadata: entry => downloadMaps.metadata(entry), withdrawMetadata: (...a) => downloadMaps.withdrawMetadata(...a),
+      refresh: (...a) => downloadMaps.refresh(...a) },
+    learnKeyframes: (params, table) => keyframeTables.learn(params, table),
+    formatOf: (sourceKey, fileIndex) => containerOrchestrator.known(sourceKey, fileIndex)?.formatName ?? "unrecognised",
+    warn: line => logger.warn(line)
   });
-  const encodeMetadataRequests = new WeakMap();
-  const containerOver = async ({ sourceKey, fileIndex, requestId, packetInterval, demand, readPriority, signal }) => {
-    const record = sourceRegistry.get(sourceKey);
-    if (!record) {
-      return null;
-    }
-    const torrent = torrentPool.knownTorrent(sourceKey);
-    const file = torrent?.files?.[fileIndex];
-    if (!file || !(file.length > 0)) {
-      return null;
-    }
-    let metadataTracker = null;
-    let trackersForSignal = null;
-    const trackerKey = `${sourceKey}:${fileIndex}`;
-    if (readPriority?.requestId && signal) {
-      trackersForSignal = encodeMetadataRequests.get(signal);
-      if (!trackersForSignal) encodeMetadataRequests.set(signal, trackersForSignal = new Map());
-      metadataTracker = trackersForSignal.get(trackerKey);
-      if (!metadataTracker) {
-        metadataTracker = { statements: new Set(), abort: null };
-        metadataTracker.abort = () => {
-          for (const statement of metadataTracker.statements) {
-            void downloadMaps.withdrawMetadata(sourceKey, fileIndex, statement).catch(error =>
-              logger.warn(`encode input demand withdrawal failed: ${error.message}`));
-          }
-          metadataTracker.statements.clear();
-          trackersForSignal.delete(trackerKey);
-          if (trackersForSignal.size === 0) encodeMetadataRequests.delete(signal);
-        };
-        trackersForSignal.set(trackerKey, metadataTracker);
-        if (signal.aborted) metadataTracker.abort();
-        else signal.addEventListener("abort", metadataTracker.abort, { once: true });
-      }
-    }
-    const params = {
-      sourceKey,
-      fileIndex,
-      requestId,
-      signal,
-      packetInterval,
-      readPriority,
-      packetMemory: indexMemory.forFile(sourceKey, fileIndex),
-      downloadInterval: demand ? { from: demand.from, to: demand.to } : null,
-      readRange: (start, end) =>
-        torrentPool.readHeldOf(torrent, fileIndex, start, Math.min(end, file.length - 1)),
-      fileSize: file.length,
-      probe: (statement, onRecord) => probeReads.read({ sourceKey, fileIndex, statement: `ffprobe:${statement}`,
-        probe: ({ requestId, signal }) => {
-          const url = new URL("/media", outputParts.localBaseUrl);
-          url.searchParams.set("sourceKey", sourceKey);
-          url.searchParams.set("fileIndex", String(fileIndex));
-          url.searchParams.set("readId", requestId);
-          return probePackets({ url: url.toString(), statement, signal, onRecord });
-        } }),
-      label: String(file.name ?? ""),
-      fileOffset: file.offset,
-      onObserved: fields => {
-        const process = fields.statement === "keyframes" ? "P5"
-          : String(fields.statement).startsWith("ffprobe:") ? "X1" : "P2";
-        const details = { process, fileIndex, requestId, statement: fields.statement, cached: fields.cached,
-          result: fields.result, reason: fields.reason, ranges: fields.ranges,
-          queuedMs: fields.queuedMs, readMs: fields.readMs };
-        waitTrace.source(sourceKey, "process", { ...details, phase: "begin", at: fields.askedAt });
-        waitTrace.source(sourceKey, "process", { ...details, phase: "end", at: fields.endedAt,
-          startedAt: fields.askedAt, endedAt: fields.endedAt });
-      },
-      onTracks: (tracks) => contentsOf(torrent).noteVideo(fileIndex, tracks.some((track) => track.type === "video")),
-      onReadStart: () => ({ storage: mediaReads.revision(sourceKey, fileIndex), memory: mediaReads.memoryRevision(), demand: downloadMaps.epoch(sourceKey, fileIndex) }),
-      onReadResult: async (statement, result, revision) => {
-        if (revision.demand !== downloadMaps.epoch(sourceKey, fileIndex)) return;
-        if (demand && !downloadMaps.wantsInterval(sourceKey, fileIndex, demand)) return;
-        if (statement === "keyframes" && result.kind === "result") {
-          keyframeTables.learn(params, { times: result.value?.times ?? null, tolerance: result.value?.tolerance ?? 0,
-            format: containerOrchestrator.known(sourceKey, fileIndex)?.formatName ?? "unrecognised" });
-        }
-        const finished = mediaReads.record(params, statement, result, revision.storage, revision.memory);
-        if (statement === "chapters" && result.passive) await downloadMaps.withdrawMetadata(sourceKey, fileIndex, statement);
-        else {
-          const metadataStatement = requestId ? `${statement}:${requestId}` : statement;
-          if (metadataTracker && result.kind === "needs-ranges") metadataTracker.statements.add(metadataStatement);
-          if (metadataTracker && result.kind !== "needs-ranges") metadataTracker.statements.delete(metadataStatement);
-          await downloadMaps.metadata({ sourceKey, fileIndex, statement: metadataStatement, result,
-            ...(statement === "chapters" ? { priority: 1, urgent: false, deadlineAt: null } : {}),
-            ...(demand ? { priority: demand.priority, urgent: demand.urgent, deadlineAt: demand.deadlineAt, interval: demand, leadSeconds: demand.leadSeconds ?? 0 } : {}),
-            ...(readPriority?.requestId ? { priority: readPriority.rank, urgent: readPriority.urgent === true,
-              deadlineAt: Number.isFinite(readPriority.deadlineAt) ? readPriority.deadlineAt : Number.POSITIVE_INFINITY,
-              scope: "preparation" } : {}),
-            // Neither a viewer's interval nor an encode input asked for it: the
-            // file read itself, and that read is wanted while the file is.
-            ...(!demand && !readPriority?.requestId ? { owner: "file" } : {}) });
-        }
-        if (finished && result.kind === "result") {
-          void downloadMaps.refresh(sourceKey, fileIndex).catch(error =>
-            logger.warn(`download map source=${sourceKey} file=${fileIndex} metadata refresh failed: ${error?.message ?? error}`));
-        }
-      },
-      portionBytes: Number(torrent.pieceLength) > 0 ? Number(torrent.pieceLength) : undefined
-    };
-    return params;
-  };
   const keyframeTables = new KeyframeTables({
     // Read by the same container that answers the track table and the media
     // info, from the same header, and now in the same thread as the session
     // that is waiting for it.
     readTable: async ({ sourceKey, fileIndex }) => {
       // Both edges: the Cues of a Matroska file are at the end.
-      const params = await containerOver({ sourceKey, fileIndex, tailBytes: CONTAINER_HEAD_BYTES });
+      const params = await mediaParams.paramsFor({ sourceKey, fileIndex, tailBytes: CONTAINER_HEAD_BYTES });
       if (!params) {
         return null;
       }
@@ -1043,17 +358,19 @@ export async function startProxyServer({
       };
     }
   });
-  let sourcePreparation;
+  const encodeInputResolution = new EncodeInputResolution({
+    paramsFor: request => mediaParams.paramsFor(request), sourceRanges,
+    selectTracks, readingInterval, trackFor,
+    declaredTracks: (sourceKey, fileIndex) => containerOrchestrator.tracks.get(`${sourceKey}:${fileIndex}`),
+    known: (sourceKey, fileIndex) => containerOrchestrator.known(sourceKey, fileIndex),
+    outputs: () => outputs.values(), // lazy: the catalog of the graph built next
+    log: line => logger.info(line), warn: line => logger.warn(line)
+  });
   const outputParts = wireOutputs({
     observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
     pinnedPreset,
     indexMemory,
     readMetadataActivity: () => containerOrchestrator.activity(),
-    onViewerChanged: () => {
-      void sourcePreparation?.refresh();
-      void downloadMaps.viewersChanged().catch(error => logger.warn(`download maps after a viewer change: ${error.message}`));
-      onStateChanged();
-    },
     onEncodersChanged: () => onStateChanged(),
     sourceInputsFor: (output, index) => segmentInputs.inputsFor(output.file.sourceKey, output.outputKey, index),
     readSourceMedia: async (params) => {
@@ -1065,143 +382,9 @@ export async function startProxyServer({
       error.canRetry = true;
       throw error;
     },
-    // `timing`, when given, is told how long each read of a file waited behind
-    // the reads asked before it and how long it took (torrent-tv/meta#166).
-    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null, isCurrent = null, signal = null, readPriority = null) => {
-      const grid = output.timeline?.published ?? output.timeline?.boundaries;
-      const from = grid?.[fromIndex], to = grid?.[toIndex + 1];
-      if (!Number.isFinite(from) || !(to > from)) return { kind: "terminal", reason: "output-interval-not-declared" };
-      const selected = new Map();
-      for (const type of ["video", "audio"]) {
-        const spec = output.spec[type];
-        if (!spec) continue;
-        const list = selected.get(spec.fileIndex) ?? [];
-        list.push({ type, index: type === "video" ? null : spec.trackIndex,
-          mode: type === "video" ? spec.encode ? "transcode" : "copy" : spec.transcode ? "transcode" : "copy" });
-        selected.set(spec.fileIndex, list);
-      }
-      // Every selected file is read the same way in one run: from the original
-      // file when each container can name the bytes the interval needs, from
-      // reassembled packets otherwise.
-      const files = [];
-      for (const [fileIndex, choices] of selected) {
-        const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex,
-          requestId: readPriority?.requestId, readPriority, signal });
-        if (!params) return { kind: "needs-source" };
-        if (isCurrent) params.isCurrent = isCurrent;
-        if (signal) params.signal = signal;
-        if (timing) {
-          params.walkAccount = timing.walk ??= { lockMs: 0, reads: 0, bytes: 0 };
-          params.onTimed = (statement, waitedMs, readMs) => {
-            timing.reads += 1;
-            timing.queuedMs += waitedMs;
-            timing.readMs += readMs;
-            const measured = timing.readsByStatement[statement] ??= { queuedMs: 0, readMs: 0 };
-            measured.queuedMs += waitedMs;
-            measured.readMs += readMs;
-          };
-        }
-        const tracks = await containerOrchestrator.inspect(params, "tracks");
-        if (tracks.kind !== "result") return tracks;
-        const container = containerOrchestrator.known(params.sourceKey, fileIndex);
-        if (typeof container?.readPacketIndex !== "function" && typeof container?.readSourceRanges !== "function") {
-          return { kind: "needs-index", reason: "packet-index-not-yet-available" };
-        }
-        const modes = new Map(), wanted = [];
-        for (const choice of choices) {
-          // The picture is the first usable video track (torrent-tv/meta#49);
-          // a soundtrack keeps the number every list of them uses.
-          const track = choice.type === "video" ? ContainerTrack.firstUsable(tracks.value, "video")
-            : tracks.value.filter(track => track.type === choice.type)[choice.index];
-          if (!track) return { kind: "terminal", reason: "selected-track-is-absent" };
-          wanted.push(track); modes.set(track, choice.mode);
-        }
-        const media = await containerOrchestrator.inspect(params, "media-info");
-        if (media.kind !== "result") return media;
-        const timeShiftSeconds = Number(media.value?.startTimeSeconds) || 0;
-        const sourceInterval = output.timeline.sourceInterval(fromIndex, toIndex, timeShiftSeconds);
-        params.packetInterval = { ...sourceInterval,
-          trackIds: wanted.map(track => track.trackNumber),
-          modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
-        const navigation = await containerOrchestrator.inspect(params, "source-navigation");
-        if (navigation.kind !== "result") return navigation;
-        files.push({ fileIndex, choices, params, wanted, modes, timeShiftSeconds, sourceInterval, navigable: navigation.value === true });
-      }
-      const original = output.segmentFormat.supportsOriginalInput === true && files.every(file => file.navigable);
-      const sources = [];
-      for (const { fileIndex, choices, params, wanted, modes, timeShiftSeconds, sourceInterval } of files) {
-        if (original) {
-          const ranges = await containerOrchestrator.inspect(params, "source-ranges");
-          if (ranges.kind !== "result") return ranges;
-          sources.push({ sourceKey: params.sourceKey, fileIndex, timeShiftSeconds,
-            input: { ...ranges.value, original: true, selections: wanted.map(track => ({ track,
-              index: track.declaredIndex ?? choices.find(choice => choice.type === track.type)?.index ?? 0 })) } });
-          continue;
-        }
-        const packets = await containerOrchestrator.inspect(params, "packets");
-        if (packets.kind !== "result") return packets;
-        const input = new SegmentInputs({ index: packets.value, tracks: wanted }).forInterval({
-          ...sourceInterval, mode: track => modes.get(track) });
-        if (input.kind !== "result") return input;
-        sources.push({ sourceKey: params.sourceKey, fileIndex, input, timeShiftSeconds });
-      }
-      return { kind: "result", sources };
-    },
-    // THE SOUND'S PACKETS FROM THE PICTURE'S COPY. A Matroska soundtrack is
-    // fed to its encoder packet by packet, and finding its packets walks the
-    // clusters the Cues name for the piece — picture and sound together,
-    // about 20 MB for 0.3 MB of sound on the field's 1080p film. The picture's
-    // input copies those same clusters through the torrent thread first, and
-    // walked a second time there each soundtrack piece took 6-11 s, slower
-    // than the film plays (r61, torrent-tv/meta#178). Walked from the copy
-    // while it is held, the sound reads only its own packets later.
-    stretchCopied: (output, from, to, input) => {
-      for (const source of input.sources ?? []) {
-        const container = containerOrchestrator.known(source.sourceKey, source.fileIndex);
-        const tracks = containerOrchestrator.tracks.get(`${source.sourceKey}:${source.fileIndex}`);
-        if (typeof container?.learnPackets !== "function" || !Array.isArray(tracks)) continue;
-        const carried = new Set((source.input.selections ?? []).map(selection => selection.track?.trackNumber));
-        const sounds = new Set();
-        for (const other of outputParts.outputs.values()) {
-          const sound = other.spec?.audio;
-          if (other.spec?.video || !sound || other.file?.sourceKey !== source.sourceKey || sound.fileIndex !== source.fileIndex) continue;
-          const track = tracks.filter(candidate => candidate.type === "audio")[sound.trackIndex];
-          if (track && !carried.has(track.trackNumber)) sounds.add(track.trackNumber);
-        }
-        if (!sounds.size || !Number.isFinite(source.input.from) || !(source.input.to > source.input.from)) continue;
-        const read = (start, end) => {
-          const answer = input.read(source.fileIndex, start, end);
-          return answer && typeof answer.then !== "function" && answer.end === end ? answer.bytes : null;
-        };
-        const holdsUntil = start => {
-          if (input.heldUntil) return input.heldUntil(source.fileIndex, start);
-          const range = source.input.ranges.find(([first, last]) => first <= start && start <= last);
-          return range ? range[1] + 1 : null;
-        };
-        const startedAt = Date.now();
-        const releaseInput = input.retain?.();
-        void container.learnPackets({ from: source.input.from, to: source.input.to, trackIds: [...sounds] }, read, holdsUntil).then(learned =>
-          logger.info(`encode input #${from}..#${to} of ${output.outputKey}: soundtrack packets of track(s) ${[...sounds].join(",")} ` +
-            `over ${source.input.from.toFixed(3)}-${source.input.to.toFixed(3)}s ` +
-            (learned === "walked" ? "walked" : `not all walked (${learned === "memory" ? "memory refused" : "the copy does not hold the rest"})`) +
-            ` from its copy in ${Date.now() - startedAt}ms`),
-        error => logger.warn(`encode input #${from}..#${to} of ${output.outputKey}: walking the soundtrack from its copy failed: ${error?.message ?? error}`))
-          .finally(() => releaseInput?.());
-      }
-    },
+    encodeInputResolution,
     repriceEncodeDemand: demand => downloadMaps.repriceRequest(demand.requestId, demand),
-    readEncodeRanges: async (source, ranges, maxBytes) => {
-      const torrent = torrentPool.knownTorrent(source.sourceKey);
-      return torrent ? torrentPool.readHeldRangesOf(torrent, source.fileIndex, ranges, maxBytes) : null;
-    },
-    openEncodeWholeFile: source => torrentPool.acquireWholeFile(source),
-    // Which bytes of a file are downloaded whole now — what an original
-    // input's stretch may extend over. A snapshot: the copy that follows
-    // holds the pieces it reads, and refuses where one has gone since.
-    readEncodeHeldRanges: async (source) => {
-      const torrent = torrentPool.knownTorrent(source.sourceKey);
-      return torrent ? torrentPool.heldRangesOf(torrent, source.fileIndex) : [];
-    },
+    ...torrentPoolPorts({ torrentPool, sourceRegistry, wholeFilesRoot: completedFilesRoot() }),
     enabled: transcodeAudio,
     keyframeTables,
     ffmpegBin,
@@ -1222,50 +405,12 @@ export async function startProxyServer({
     // CPU-bound transcode from a download-starved input before downscaling.
     // What every torrent here has moved, so the proxy can price its own
     // downloading, hashing and delivery against the machine (roadmap item 7).
-    // What the spilled pieces weigh on the torrent thread, and how to tell them
-    // their share of the disk. The owner of the disk is on this side, where the
-    // segments are; the pieces are on the other.
-    spillDisk: typeof torrentPool.allowSpillBytes === "function"
-      ? {
-          held: () => torrentPool.spilledBytes ?? 0,
-          allow: (bytes) => torrentPool.allowSpillBytes(bytes)
-        }
-      : null,
-    // Files downloaded whole, kept as files. They live on the torrent thread
-    // too, and until 2026-09-14 they had no bound of any kind — a 2.8 GB film
-    // on a host whose disk is often a 32 GB card.
-    wholeFiles: typeof torrentPool.allowWholeFileBytes === "function"
-      ? {
-          held: () => torrentPool.wholeFileBytes ?? 0,
-          required: () => torrentPool.wholeFileRequiredBytes ?? 0,
-          allow: (bytes) => torrentPool.allowWholeFileBytes(bytes),
-          root: completedFilesRoot()
-        }
-      : null,
-    // The pieces held IN memory, on the torrent thread. Told their share by the
-    // same owner that divides the disk: what does not fit here is spilled
-    // there, so the two cannot be divided apart.
-    memoryClaimant: typeof torrentPool.allowMemoryBytes === "function"
-      ? {
-          held: () => torrentPool.memoryClaim?.held ?? 0,
-          wanted: () => torrentPool.memoryClaim?.wanted ?? 0,
-          allow: (bytes) => torrentPool.allowMemoryBytes(bytes)
-        }
-      : null,
     diagnosticsRoot: stateDir || "",
     budgetPolicy,
-    getTorrentTotals: async () => {
-      if (typeof torrentPool.getTorrentTotals !== "function") {
-        return null;
-      }
-      return torrentPool.getTorrentTotals();
-    },
     // The priority map, on its way to the downloading. It lives in another
     // thread, so the map crosses the worker channel; what it does with it —
     // seconds into bytes, what to ask the swarm for, what to keep in memory —
     // is its own business.
-    setDownloadRate: (bytesPerSecond, because) => torrentPool.setDownloadRate?.(bytesPerSecond, because),
-    setSpeculativeHold: (held, because) => torrentPool.setSpeculativeHold?.(held, because),
     setPriorityMap: async ({ sourceKey, fileIndex, durationSeconds, zones }) => {
       const record = sourceRegistry.get(sourceKey);
       if (!record) {
@@ -1274,15 +419,15 @@ export async function startProxyServer({
       try {
         if (zones.length === 0) {
           mediaReads.retain(sourceKey, fileIndex, params => params.requestId?.startsWith("prepare:"));
-          if (!outputParts.viewers.forSource(sourceKey).length) probeReads.forget(sourceKey, fileIndex);
+          if (!viewers.forSource(sourceKey).length) probeReads.forget(sourceKey, fileIndex);
           await downloadMaps.forget(sourceKey, fileIndex, { keepPreparation: true });
-          playbackProjections.get(`${sourceKey}:${fileIndex}`)?.clear();
-          void sourcePreparation?.refresh();
+          resolution.clear(sourceKey, fileIndex);
+          void sourcePreparation.refresh();
           return;
         }
         await publishPlaybackBeforePreparationRefresh(
           () => downloadMaps.playback({ sourceKey, fileIndex, durationSeconds, zones }),
-          () => { void sourcePreparation?.refresh(); }
+          () => { void sourcePreparation.refresh(); }
         );
         mediaReads.retain(sourceKey, fileIndex, params => !params.requestId?.startsWith("download:") ||
           zones.some(zone => zone.from === params.downloadInterval?.from && zone.to === params.downloadInterval?.to));
@@ -1290,21 +435,6 @@ export async function startProxyServer({
         logger.warn(`download map source=${sourceKey} file=${fileIndex} publication failed: ${error?.message ?? error}`);
       }
     },
-    getSourceStats: async (sourceKey, fileIndex, options) => {
-      const record = sourceRegistry.get(sourceKey);
-      if (!record) {
-        return null;
-      }
-      try {
-        const torrent = torrentPool.knownTorrent(sourceKey);
-        if (!torrent) return null;
-        // Awaited for the same reason as the stats route: this now crosses a
-        // thread boundary and returns a promise.
-        return await torrentPool.getFileStats(torrent, Number.isInteger(fileIndex) ? fileIndex : null, options);
-      } catch {
-        return null;
-      }
-    },
     // Reuse the media info the planner already probed for this file (same
     // ffmpeg scan) so createSession skips its own probe. Late-bound: invoked
     // only at session-create time, after playbackPlanner is initialised.
@@ -1319,35 +449,55 @@ export async function startProxyServer({
     // bytes, and that read cost 8.1 s of every cold start (field 2026-09-03).
     getContainerMediaInfo: async ({ sourceKey, fileIndex }) => {
       try {
-        const params = await containerOver({ sourceKey, fileIndex });
+        const params = await mediaParams.paramsFor({ sourceKey, fileIndex });
         return params ? await containerOrchestrator.getMediaInfo(params) : null;
       } catch {
         return null;
       }
-    },
-    // Pull one whole file onto the disk. Used for a soundtrack that ships beside
-    // the picture, once the encoder is as far ahead of the viewer as it is
-    // allowed to get — the one moment the swarm's capacity is demonstrably
-    // spare. A bounded read of the file's whole length, NOT `file.select()`:
-    // selecting a file alongside the readers' own windows is what made a seek
-    // wait 93 s while the swarm fetched 2.47 GB in file order (see
-    // `#syncSelections` in `torrent/torrent-pool.js`).
-    fetchWholeFile: async ({ sourceKey, fileIndex }) => {
-      const record = sourceRegistry.get(sourceKey);
-      if (!record) {
-        return;
-      }
-      const torrent = await torrentPool.getTorrent(record.sourceType, record.source);
-      // The same background fill the warm-up starts when a file is chosen, not a
-      // second way of doing it. It is guarded against running twice on one file,
-      // so the two triggers converge instead of putting two readers on the same
-      // soundtrack — and only one of them would have stood aside for the
-      // picture. This trigger remains for the session that never had a warm-up
-      // before it.
-      await torrentPool.fillFileInBackground?.(torrent, fileIndex);
     }
   });
-  outputPartsReady = true;
+  const { viewers, viewerRequests, outputs, encodeRuns, serving, renditions, encodeInputs, quality,
+    lifecycle, outputTimes, machineBudget, lookaheadSeconds, segmentDurationSec, localBaseUrl,
+    encodeOrchestrator, playedOutputsOf } = outputParts;
+  /**
+   * The download map's pass: what the torrent is told about the file a viewer
+   * plays, worked out from the viewers' map (torrent-tv/meta#273).
+   */
+  const resolution = new PlaybackResolution({
+    paramsFor: request => mediaParams.paramsFor(request),
+    sourceRanges,
+    segmentReading,
+    playedOutputsOf,
+    pieceLengthOf: sourceKey => Number(torrentPool.knownTorrent(sourceKey)?.pieceLength),
+    noteSegmentInput: (...args) => segmentInputs.set(...args),
+    refresh: (sourceKey, fileIndex) => downloadMaps.refresh(sourceKey, fileIndex),
+    observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
+    log: line => logger.info(line),
+    warn: line => logger.warn(line)
+  });
+  const downloadMaps = new DownloadMaps({
+    // The ranges a picture reads at open are named again by every segment;
+    // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
+    // Left out of what is SENT and nowhere else: every segment's own zones are
+    // also what says which bytes that segment needs, and a segment whose zones
+    // all repeat another's — two of one group of pictures in an AVI read the
+    // same bytes — lost them with 2.96.11, and the start forecast answered
+    // "source-input-ranges-unavailable" for ever (Home Assistant 2026-10-11).
+    publish: (map) => torrentPool.setPriorityMap({ ...map, zones: withoutRepeatedZones(map.zones) }),
+    // And what is sent is packed: a stretch of one level and priority is one
+    // window, not one zone per range of each of its segments
+    // (`coalescedZones`, torrent-tv/meta#178). The playback zones come packed
+    // already from the projection; this packs them with the native ones.
+    pack: (zones) => coalescedZones(zones),
+    log: (line) => logger.info(line),
+    observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields),
+    // A file's own reads are wanted while a present viewer has the file chosen
+    // or on screen.
+    fileWanted: (sourceKey, fileIndex) => viewers.forSource(sourceKey)
+      .some(viewer => viewer.source?.selectedFileIndex === fileIndex ||
+        viewer.source?.visibleFileIndices?.includes(fileIndex)),
+    resolvePlayback: map => resolution.resolve(map)
+  });
   // Where the processor goes, and at a cold start what the main thread does
   // with it, when the operator asks (torrent-tv/meta#177).
   const startupProfile = startupCpuProfile({
@@ -1359,8 +509,8 @@ export async function startProxyServer({
   });
   startProcessorReport({
     log: (line) => logger.info(line),
-    ffmpegRuns: () => [...outputParts.outputs.values()]
-      .flatMap((output) => outputParts.encodeRuns.liveRunsOf(output).map((run) => ({
+    ffmpegRuns: () => [...outputs.values()]
+      .flatMap((output) => encodeRuns.liveRunsOf(output).map((run) => ({
         pid: run.process?.pid,
         label: `${output.outputKey} #${run.from}..#${run.to}`,
         film: Number(run.progress?.processedSeconds) - Number(run.progress?.startPositionSeconds ?? 0)
@@ -1368,7 +518,7 @@ export async function startProxyServer({
       .filter((run) => Number.isInteger(run.pid)),
     detailed: () => startupProfile.active(),
     // What the pause rule judges from (torrent-tv/meta#180, phase 4).
-    onRunSeconds: (seconds) => outputParts.encodeOrchestrator?.noteRunSeconds(seconds)
+    onRunSeconds: (seconds) => encodeOrchestrator?.noteRunSeconds(seconds)
   });
   // What the last life of this process left on the disk. The kernel kills this
   // one often enough for that to be an ordinary state rather than an odd one —
@@ -1377,20 +527,24 @@ export async function startProxyServer({
   // record that those encoders ended at all: it says what it found before it
   // decides anything, keeps the segments whose closure is proven, and removes
   // the one piece per output that was being written when the process died.
-  outputParts.lifecycle.adoptSegmentsLeftBehind();
-  const publishNative = async work => {
-    if (!work.nativeInput || !sourcePreparation.accepts(work)) return Promise.resolve();
-    const viewers = outputParts.viewers.forSource(work.sourceKey)
-      .filter(viewer => viewer.source.selectedFileIndex === work.fileIndex && viewer.outputs.size === 0);
-    const convert = work.nativeInput.container ? nativeOriginalSourceMap : nativeSourceMap;
-    const zones = await convert({ ...work.nativeInput, viewers,
-      allowanceSeconds: outputParts.segmentDurationSec,
-      urgentReadyFor: viewer => sourcePreparation.urgentReadyFor(viewer) });
-    if (!sourcePreparation.accepts(work)) return;
-    return downloadMaps.native({ sourceKey: work.sourceKey, fileIndex: work.fileIndex, zones });
-  };
-  sourcePreparation = new SourcePreparation({
-    viewers: outputParts.viewers,
+  startPlayback({ outputParts, downloadMaps, preparation: () => sourcePreparation, onStateChanged,
+    warn: line => logger.warn(line) });
+  const preparationReads = new PreparationReads({
+    paramsFor: request => mediaParams.paramsFor(request),
+    containers: containerOrchestrator,
+    subtitles: subtitleWalk.subtitles,
+    fileLengthOf: (sourceKey, fileIndex) => torrentPool.knownTorrent(sourceKey)?.files?.[fileIndex]?.length,
+    viewersOf: sourceKey => viewers.forSource(sourceKey),
+    segmentSeconds: segmentDurationSec,
+    preparationInterval,
+    segmentInputs: input => new SegmentInputs(input),
+    nativeMaps: { packets: input => nativeSourceMap(input), original: input => nativeOriginalSourceMap(input) },
+    maps: downloadMaps,
+    record: (...args) => mediaReads.record(...args),
+    planEncodersSoon: () => encodeRuns.planEncodersSoon()
+  });
+  const sourcePreparation = new SourcePreparation({
+    viewers,
     candidatesFor: async sourceKey => {
       const record = sourceRegistry.get(sourceKey);
       if (!record) return [];
@@ -1413,15 +567,15 @@ export async function startProxyServer({
     priorityFor: (viewer, priority, work) => {
       if (!sourcePreparation.subtitleReadyFor(viewer)) return priority;
       const fileIndex = work.ownerFileIndex ?? work.fileIndex;
-      const output = [...outputParts.outputs.values()].find(output => output.file?.sourceKey === work.sourceKey &&
-        output.file?.fileIndex === fileIndex && outputParts.viewers.forOutput(output).has(viewer.id) &&
-        !outputParts.outputs.supersededBy(output, viewer.activeVariantId ?? null));
-      const viewerCount = outputParts.viewers.forSource(work.sourceKey)
+      const output = [...outputs.values()].find(output => output.file?.sourceKey === work.sourceKey &&
+        output.file?.fileIndex === fileIndex && viewers.forOutput(output).has(viewer.id) &&
+        !outputs.supersededBy(output, viewer.activeVariantId ?? null));
+      const viewerCount = viewers.forSource(work.sourceKey)
         .filter(person => person.source.selectedFileIndex === fileIndex).length;
       if (!output) {
         const coefficient = pauseCoefficient({ playing: viewer.playing || viewer.waiting, viewerCount,
           pauseSeconds: viewer.pausedAt === null ? 0 : (Date.now() - viewer.pausedAt) / 1000,
-          allowanceSeconds: outputParts.segmentDurationSec,
+          allowanceSeconds: segmentDurationSec,
           urgentReady: sourcePreparation.urgentReadyFor(viewer) });
         return Math.max(1, 1 + Math.floor((priority - 1) * coefficient));
       }
@@ -1433,107 +587,13 @@ export async function startProxyServer({
       const held = await torrentPool.heldRangesOf(torrent, work.fileIndex);
       return work.inputRanges.every(([start, end]) => held.some(([from, to]) => from <= start && to >= end));
     },
-    sourceRestNeededFor: (sourceKey, fileIndex) => ![...outputParts.outputs.values()].some(output =>
+    sourceRestNeededFor: (sourceKey, fileIndex) => ![...outputs.values()].some(output =>
       output.file?.sourceKey === sourceKey && output.file?.fileIndex === fileIndex &&
-      outputParts.viewers.forOutput(output).size > 0),
+      viewers.forOutput(output).size > 0),
     playbackAppliedFor: (sourceKey, fileIndex) => downloadMaps.hasAppliedPlayback(sourceKey, fileIndex),
     readyChanged: (work, ready) => logger.info(`source urgent request=${work.requestId} viewer=${work.ownerId} ` +
       `source=${work.sourceKey} file=${work.fileIndex} inputReady=${ready}`),
-    inspect: async work => {
-      const params = await containerOver(work);
-      if (!params) return { kind: "needs-source" };
-      params.isCurrent = () => sourcePreparation.accepts(work);
-      const originalContainer = work.statement === "packets" ? await containerOrchestrator.containerFor(params) : null;
-      const navigation = work.statement === "packets" && work.role !== "subtitle-embedded"
-        ? await containerOrchestrator.inspect(params, "source-navigation") : { kind: "result", value: false };
-      if (navigation.kind !== "result") return navigation;
-      const originalRanges = navigation.value;
-      if (!originalRanges && work.statement === "packets" && work.role === "source-rest" && sourcePreparation.accepts(work)) {
-        const file = torrentPool.knownTorrent(work.sourceKey)?.files?.[work.fileIndex];
-        if (file?.length > 0) {
-          const statement = `${work.statement}:${work.requestId}:input`;
-          await downloadMaps.metadata({ sourceKey: work.sourceKey, fileIndex: work.fileIndex, statement,
-            result: { kind: "needs-ranges", ranges: [[0, file.length - 1]], requestId: statement },
-            scope: "preparation", ...sourcePreparation.demandFor(work) });
-        }
-      }
-      if ((work.statement === "packets" && (work.role !== "source-rest" || originalRanges)) || work.role === "subtitle-embedded" && work.statement === "subtitle-cues") {
-        const info = await containerOrchestrator.inspect({ ...params, onReadResult: undefined }, "media-info");
-        if (info.kind !== "result") return info;
-        const positions = outputParts.viewers.forSource(work.sourceKey)
-          .filter(viewer => viewer.source.selectedFileIndex === work.fileIndex &&
-            (work.ownerId === undefined || viewer.id === work.ownerId))
-          .map(viewer => viewer.positionSeconds() ?? 0);
-        const from = (positions.length ? Math.min(...positions) : 0) + (Number(info.value?.startTimeSeconds) || 0);
-        params.packetInterval = preparationInterval(work.role, from, outputParts.segmentDurationSec);
-        if (work.role === "subtitle-embedded") {
-          const tracks = await containerOrchestrator.containerFor(params).then(container => container.readTracks());
-          const track = tracks.find(track => track.type === "subtitle" && track.declaredIndex === work.trackIndex);
-          if (!track || track.isTextBased?.() !== true) return { kind: "terminal", reason: "subtitle-track-not-supported" };
-          params.packetInterval.trackIds = [track.trackNumber];
-          params.subtitleTrackIndex = work.trackIndex;
-        }
-      }
-      params.onReadResult = async (statement, result, revision) => {
-        if (!sourcePreparation.accepts(work)) return;
-        mediaReads.record(params, statement, result, revision.storage, revision.memory);
-        const inputStatement = `${work.statement}:${work.requestId}:input`;
-        if (statement === "source-ranges" && result.kind === "result") {
-          if (work.selected) work.inputRanges = result.value.ranges;
-          if (work.role === "source-rest") {
-            const info = await containerOrchestrator.inspect({ ...params, onReadResult: undefined }, "media-info");
-            if (!sourcePreparation.accepts(work)) return;
-            if (info.kind === "result") {
-              work.nativeInput = { container: originalContainer, durationSeconds: info.value.durationSeconds,
-                startTimeSeconds: info.value.startTimeSeconds ?? 0 };
-              await publishNative(work);
-            }
-          } else {
-            await downloadMaps.metadata({ sourceKey: work.sourceKey, fileIndex: work.fileIndex,
-              statement: inputStatement, result: { kind: "needs-ranges", ranges: result.value.ranges, requestId: inputStatement },
-              scope: "preparation", ...sourcePreparation.demandFor(work) });
-            if (work.selected) await sourcePreparation.bytesChanged(work.sourceKey, work.fileIndex);
-          }
-        }
-        if (statement === "packets" && work.role === "source-rest" && result.kind === "result") {
-          const tracks = await containerOrchestrator.containerFor(params).then(container => container.readTracks());
-          const info = await containerOrchestrator.inspect({ ...params, onReadResult: undefined }, "media-info");
-          if (!sourcePreparation.accepts(work)) return;
-          if (info.kind === "result") {
-            work.nativeInput = { index: result.value, tracks, durationSeconds: info.value.durationSeconds,
-              startTimeSeconds: info.value.startTimeSeconds ?? 0 };
-            await publishNative(work);
-          }
-        }
-        if (statement === "packets" && work.role !== "source-rest" && result.kind === "result" && (work.selected || work.ownerFileIndex !== undefined)) {
-          const tracks = await containerOrchestrator.containerFor(params).then(container => container.readTracks());
-          if (!sourcePreparation.accepts(work)) return;
-          const bounds = tracks.filter(track => ["video", "audio"].includes(track.type))
-            .map(track => result.value.boundsOf(track.trackNumber)).filter(Boolean);
-          const interval = params.packetInterval ?? (bounds.length ? {
-            from: Math.max(0, Math.min(...bounds.map(bound => bound.start))), to: Math.max(...bounds.map(bound => bound.end))
-          } : null);
-          if (interval && interval.to > interval.from) {
-            const input = work.role === "subtitle-embedded"
-              ? result.value.inputFor({ trackId: params.packetInterval.trackIds[0], ...interval })
-              : new SegmentInputs({ index: result.value, tracks }).forInterval(interval);
-            if (work.selected) work.inputRanges = input.kind === "result" ? input.ranges : null;
-            await downloadMaps.metadata({ sourceKey: work.sourceKey, fileIndex: work.fileIndex,
-              statement: inputStatement, result: input.kind === "result" ? { kind: "needs-ranges", ranges: input.ranges, requestId: inputStatement } : input,
-              scope: "preparation", ...sourcePreparation.demandFor(work) });
-            if (work.selected) await sourcePreparation.bytesChanged(work.sourceKey, work.fileIndex);
-          }
-        }
-        if (!sourcePreparation.accepts(work)) return;
-        await downloadMaps.metadata({ sourceKey: work.sourceKey, fileIndex: work.fileIndex,
-          statement: `${work.statement}:${work.requestId}`, result, scope: "preparation", ...sourcePreparation.demandFor(work) });
-        sourcePreparation.result(work, result);
-        if (["subtitle-file", "subtitle-cues"].includes(statement)) outputParts.encodeRuns.planEncodersSoon();
-      };
-      return work.statement === "subtitle-file"
-        ? subtitles.inspectFile(params) : work.statement === "subtitle-cues"
-          ? subtitles.inspectPackets(params) : containerOrchestrator.inspect(params, originalRanges ? "source-ranges" : work.statement);
-    },
+    inspect: work => preparationReads.inspect(work, sourcePreparation),
     withdraw: work => {
       if (work.role === "source-rest" && work.statement === "packets") {
         void downloadMaps.native({ sourceKey: work.sourceKey, fileIndex: work.fileIndex, zones: [] })
@@ -1551,7 +611,7 @@ export async function startProxyServer({
       }
     },
     reprice: (work, demand) => {
-      if (work.nativeInput) void publishNative(work)
+      if (work.nativeInput) void preparationReads.publishNative(work, sourcePreparation)
         .catch(error => logger.warn(`native source map repricing failed: ${error.message}`));
       void downloadMaps.repriceMetadata(work.sourceKey, work.fileIndex, `${work.statement}:${work.requestId}`, demand)
         .catch(error => logger.warn(`source preparation request=${work.requestId} repricing failed: ${error.message}`));
@@ -1564,12 +624,12 @@ export async function startProxyServer({
   const playbackPlanner = createPlaybackPlanner({
     ffmpegBin,
     transcodeAudioEnabled: transcodeAudio,
-    localBaseUrl: outputParts.localBaseUrl,
+    localBaseUrl,
     sourceRegistry,
     torrentPool,
     subscribeSource: (sourceKey, fileIndex, listener) => mediaReads.subscribe(sourceKey, fileIndex, listener),
     readDeclarations: async ({ sourceKey, fileIndex }) => {
-      const params = await containerOver({ sourceKey, fileIndex });
+      const params = await mediaParams.paramsFor({ sourceKey, fileIndex });
       if (!params) return { kind: "terminal", reason: "source-forgotten" };
       return readPlaybackDeclarations(containerOrchestrator, params);
     },
@@ -1580,14 +640,14 @@ export async function startProxyServer({
     // container on its behalf, in the other thread, with the answer carried
     // back over the channel.
     declaredTracksOf: async ({ sourceKey, fileIndex }) => {
-      const params = await containerOver({ sourceKey, fileIndex });
+      const params = await mediaParams.paramsFor({ sourceKey, fileIndex });
       return params ? await containerOrchestrator.getTracks(params) : [];
     },
     warmKeyframeIndex: (params) => keyframeTables.warm(params),
     // The quality menu is on screen from the moment a file is opened, so the
     // heights this host can actually serve have to be answerable before any
     // encoder exists — from the probe and the startup benchmarks alone.
-    predictOfferedHeights: (mediaInfo) => outputParts.quality.predictOfferedHeights(mediaInfo)
+    predictOfferedHeights: (mediaInfo) => quality.predictOfferedHeights(mediaInfo)
   });
 
   app.get("/health", async (req, reply) => handleHealthGet(req, reply, { version }));
@@ -1611,39 +671,35 @@ export async function startProxyServer({
   app.post("/api/sources", async (req, reply) => {
     // A cold start begins with the first source opened (torrent-tv/meta#177).
     startupProfile.begin();
-    return handleApiSourcesPost(req, reply, { sourceRegistry, viewers: outputParts.viewers,
+    return handleApiSourcesPost(req, reply, { sourceRegistry, viewers,
       associateWaitTrace: (request, sourceKey) => waitTrace.associate(request, sourceKey) });
   });
   app.get("/api/sources/:sourceKey/stats", async (req, reply) =>
-    handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool, viewerRequests: outputParts.viewerRequests })
+    handleApiSourceStatsGet(req, reply, { sourceRegistry, torrentPool, viewerRequests })
   );
   app.get("/api/sources/:sourceKey/files", async (req, reply) =>
-    handleApiSourceFilesGet(req, reply, { sourceRegistry, torrentPool, viewers: outputParts.viewers,
-      viewerRequests: outputParts.viewerRequests })
+    handleApiSourceFilesGet(req, reply, { sourceRegistry, torrentPool, viewers,
+      viewerRequests })
   );
   app.get("/api/sources/:sourceKey/files/:fileIndex/fingerprint", async (req, reply) =>
     handleApiSourceFingerprintGet(req, reply, {
       sourceRegistry,
       inspectFingerprint: async (address) => {
-        const params = await containerOver(address);
+        const params = await mediaParams.paramsFor(address);
         return params ? containerOrchestrator.inspect(params, "fingerprint") : { kind: "pending" };
       }
     })
   );
   // What the opened file states about the work, and its cover: read only from
   // the edges of the file, which opening it fetches anyway (meta#139).
-  const workTagsLogged = new Set();
+  const workTagsReport = new WorkTagsReport({ log: line => logger.info(line) });
   app.get("/api/sources/:sourceKey/files/:fileIndex/container-metadata", async (req, reply) =>
     handleApiSourceContainerMetadataGet(req, reply, {
       sourceRegistry,
       inspectWorkTags: async (address) => {
-        const params = await containerOver(address);
+        const params = await mediaParams.paramsFor(address);
         const result = params ? await containerOrchestrator.inspect(params, "work-tags") : { kind: "pending" };
-        const key = `${address.sourceKey}:${address.fileIndex}`;
-        if (result.kind !== "pending" && result.kind !== "needs-ranges" && !workTagsLogged.has(key)) {
-          workTagsLogged.add(key);
-          logger.info(`container metadata "${params?.label ?? ""}": ${describeWorkTags(result)}`);
-        }
+        workTagsReport.note(address, params?.label ?? "", result);
         return result;
       }
     })
@@ -1652,7 +708,7 @@ export async function startProxyServer({
     handleApiSourceCoverGet(req, reply, {
       sourceRegistry,
       inspectCover: async (address) => {
-        const params = await containerOver(address);
+        const params = await mediaParams.paramsFor(address);
         return params ? containerOrchestrator.inspect(params, "cover") : { kind: "pending" };
       }
     })
@@ -1660,11 +716,11 @@ export async function startProxyServer({
   app.post("/api/sources/:sourceKey/warm", async (req, reply) =>
     handleApiSourceWarmPost(req, reply, {
       sourceRegistry,
-      viewers: outputParts.viewers
+      viewers
     })
   );
   app.post("/api/sources/:sourceKey/files/:fileIndex/viewer", async (req, reply) =>
-    handleApiSourceViewerPost(req, reply, { sourceRegistry, viewers: outputParts.viewers })
+    handleApiSourceViewerPost(req, reply, { sourceRegistry, viewers })
   );
   // The browser's own log, kept beside the proxy's: a file per session when
   // the proxy writes its log to a file, its console otherwise. See the route's
@@ -1673,17 +729,17 @@ export async function startProxyServer({
     ? createClientLogFiles(logFile)
     : createClientLogConsole((message) => logger.info(message));
   app.post("/api/client-logs", async (req, reply) =>
-    handleApiClientLogsPost(req, reply, { clientLogs, viewerRequests: outputParts.viewerRequests })
+    handleApiClientLogsPost(req, reply, { clientLogs, viewerRequests })
   );
   app.post("/api/playback-plan", async (req, reply) =>
-    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers,
+    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers,
       observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields) })
   );
   app.post("/api/playback-plan/audio-tracks", async (req, reply) =>
     handleApiPlaybackPlanAudioTracksPost(req, reply, { playbackPlanner })
   );
   app.post("/api/subtitles", async (req, reply) => handleApiSubtitlesPost(req, reply, {
-    viewers: outputParts.viewers, sourceRegistry,
+    viewers, sourceRegistry,
     subtitleTracksFor: (sourceKey, fileIndex) =>
       (containerOrchestrator.tracks.get(`${sourceKey}:${fileIndex}`) ?? []).filter(track => track.type === "subtitle"),
     subtitleFilesFor: (sourceKey, fileIndex) => {
@@ -1696,13 +752,13 @@ export async function startProxyServer({
     handleApiSubtitlesGet(req, reply, {
       sourceRegistry,
       torrentPool,
-      viewers: outputParts.viewers,
-      subtitles
+      viewers,
+      subtitles: subtitleWalk.subtitles
     })
   );
   app.get("/encode-input/:token/:fileIndex", (req, reply) =>
-    handleEncodeInputGet(req, reply, { inputOf: token => outputParts.encodeRuns.originalInputOf(token),
-      noteFirstInputBytes: (token, fileIndex, bytes) => outputParts.encodeRuns.noteFirstInputBytes(token, fileIndex, bytes),
+    handleEncodeInputGet(req, reply, { inputOf: token => encodeRuns.originalInputOf(token),
+      noteFirstInputBytes: (token, fileIndex, bytes) => encodeRuns.noteFirstInputBytes(token, fileIndex, bytes),
       refused: ({ fileIndex, start, runTag }) => logger.warn(`encode input: run ${runTag ?? "?"} asked for byte ${start} of file ${fileIndex}, which it was not given`) })
   );
   app.get("/stream", async (req, reply) =>
@@ -1712,47 +768,47 @@ export async function startProxyServer({
       // So a session that has produced nothing yet can still show it is being
       // fed. The route knows only files; the session id rides on the URL the
       // session itself built.
-      noteInputBytes: (sessionId, bytes) => outputParts.encodeRuns.noteInputBytes(sessionId, bytes),
-      noteFirstInputBytes: (token, fileIndex, bytes) => outputParts.encodeRuns.noteFirstInputBytes(token, fileIndex, bytes),
+      noteInputBytes: (sessionId, bytes) => encodeRuns.noteInputBytes(sessionId, bytes),
+      noteFirstInputBytes: (token, fileIndex, bytes) => encodeRuns.noteFirstInputBytes(token, fileIndex, bytes),
       // When the encoder reading this waits for its input, so its speed is
       // measured over its own work and not over the swarm's.
-      noteInputWaiting: (runToken, waiting) => outputParts.encodeRuns.noteInputWaiting(runToken, waiting)
+      noteInputWaiting: (runToken, waiting) => encodeRuns.noteInputWaiting(runToken, waiting)
     })
   );
   app.post("/api/transcode-sessions", async (req, reply) =>
-    handleApiTranscodeSessionsPost(req, reply, { viewerRequests: outputParts.viewerRequests, renditions: outputParts.renditions, quality: outputParts.quality, outputs: outputParts.outputs, lookaheadSeconds: outputParts.lookaheadSeconds, sourceRegistry, torrentPool,
+    handleApiTranscodeSessionsPost(req, reply, { viewerRequests, renditions, quality, outputs, lookaheadSeconds, sourceRegistry, torrentPool,
       subscribeSource: (sourceKey, fileIndex, listener) => mediaReads.subscribe(sourceKey, fileIndex, listener) })
   );
   app.post("/api/transcode-sessions/:sessionId/release", async (req, reply) =>
-    handleApiTranscodeSessionReleasePost(req, reply, { lifecycle: outputParts.lifecycle })
+    handleApiTranscodeSessionReleasePost(req, reply, { lifecycle })
   );
   app.get("/api/transcode-sessions/:sessionId/progress", async (req, reply) =>
-    handleApiTranscodeSessionsProgressGet(req, reply, { viewerRequests: outputParts.viewerRequests })
+    handleApiTranscodeSessionsProgressGet(req, reply, { viewerRequests })
   );
   app.post("/api/transcode-sessions/:sessionId/net-report", async (req, reply) =>
     // A viewer's statement about itself goes to the VIEWER layer, not through
     // the session manager: what it needs is the live sessions and the registry
     // of viewers, and nothing about encoding.
     handleApiTranscodeSessionNetReportPost(req, reply, {
-      outputs: outputParts.outputs,
-      viewers: outputParts.viewers,
-      renditions: outputParts.renditions,
-      quality: outputParts.quality,
-      planSoon: () => outputParts.encodeRuns.planEncodersSoon(),
+      outputs,
+      viewers,
+      renditions,
+      quality,
+      planSoon: () => encodeRuns.planEncodersSoon(),
       segmentAt: (output, seconds) => {
         // A cut table not built yet has no pieces to move between.
-        try { return outputParts.outputTimes.segmentIndexForTime(output, seconds); } catch { return null; }
+        try { return outputTimes.segmentIndexForTime(output, seconds); } catch { return null; }
       }
     })
   );
   app.post("/api/transcode-sessions/:sessionId/fragment-far", async (req, reply) =>
-    handleApiTranscodeSessionFragmentFarPost(req, reply, { serving: outputParts.serving })
+    handleApiTranscodeSessionFragmentFarPost(req, reply, { serving })
   );
   app.post("/api/transcode-sessions/:sessionId/seek", async (req, reply) =>
-    handleApiTranscodeSessionSeekPost(req, reply, { viewerRequests: outputParts.viewerRequests })
+    handleApiTranscodeSessionSeekPost(req, reply, { viewerRequests })
   );
   app.get("/transcode/:sessionId/:fileName", async (req, reply) =>
-    handleTranscodeSessionFileGet(req, reply, { serving: outputParts.serving, viewerRequests: outputParts.viewerRequests })
+    handleTranscodeSessionFileGet(req, reply, { serving, viewerRequests })
   );
   // A quality variant's files. Registered before the static handler for the
   // same reason as the line above, and kept a separate route rather than a
@@ -1761,22 +817,22 @@ export async function startProxyServer({
   // Fastify matches a static segment ahead of a parameter either way — stated
   // here so the order is not "tidied" into a bug.
   app.get("/transcode/:sessionId/v/:height/warm", async (req, reply) =>
-    handleTranscodeVariantWarmGet(req, reply, { renditions: outputParts.renditions, serving: outputParts.serving, viewerRequests: outputParts.viewerRequests })
+    handleTranscodeVariantWarmGet(req, reply, { renditions, serving, viewerRequests })
   );
   app.get("/transcode/:sessionId/a/:track/warm", async (req, reply) =>
-    handleTranscodeAudioWarmGet(req, reply, { renditions: outputParts.renditions, serving: outputParts.serving, viewerRequests: outputParts.viewerRequests })
+    handleTranscodeAudioWarmGet(req, reply, { renditions, serving, viewerRequests })
   );
   app.get("/transcode/:sessionId/a/:trackIndex/:fileName", async (req, reply) =>
-    handleTranscodeAudioFileGet(req, reply, { renditions: outputParts.renditions, serving: outputParts.serving, viewerRequests: outputParts.viewerRequests })
+    handleTranscodeAudioFileGet(req, reply, { renditions, serving, viewerRequests })
   );
   app.get("/transcode/:sessionId/v/:height/:fileName", async (req, reply) =>
-    handleTranscodeVariantFileGet(req, reply, { renditions: outputParts.renditions, serving: outputParts.serving, viewerRequests: outputParts.viewerRequests })
+    handleTranscodeVariantFileGet(req, reply, { renditions, serving, viewerRequests })
   );
 
   app.addHook("onClose", async () => {
     // Order matters: stop the ffmpeg readers (HLS sessions) before destroying
     // the torrents whose files they read from, then remove the torrent data.
-    await outputParts.lifecycle.disposeAll();
+    await lifecycle.disposeAll();
     await torrentPool.destroyAll();
   });