@torrent-tv/proxy 2.87.15 → 2.87.16

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 2.87.16
+
+- **Fix**: Hold spilled source bytes across memory reservation so concurrent eviction cannot terminate ffmpeg input with a missing disk piece.
+- **Fix**: Publish a run's final closed segment only after complete input termination, retain earlier completed cuts, and drain output notifications before classifying an exit.
+- **Fix**: Preserve copied media presentation times when replacing per-segment headers with one shared init, including backward seeks after opening at a later position.
+- **Fix**: Feed measured segment intervals and separate browser track ranges into the service integral; retain media beyond holes, avoid duplicate transfer estimates, and price missing segments independently of another run's progress.
+
 ## 2.87.15
 
 - **Fix**: Integrate a bounded, nonnegative forecast of recent measured service rates, so an old faster link sample cannot predict permanent delivery failure and prevent playback of fully prepared media.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@torrent-tv/proxy",
-  "version": "2.87.15",
+  "version": "2.87.16",
   "description": "Torrent proxy client that exposes webseed-like HTTP stream endpoint.",
   "license": "GPL-3.0-or-later",
   "publishConfig": {

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

@@ -109,6 +109,7 @@ export async function handleApiTranscodeSessionNetReportPost(req, reply, { outpu
       linkSampleMbps: Number.isFinite(linkSampleMbps) && linkSampleMbps > 0 ? linkSampleMbps : undefined,
       linkSampleAt: Number.isFinite(linkSampleAt) && linkSampleAt > 0 ? linkSampleAt : undefined,
       bufferedAheadSec,
+      bufferedRanges: body.bufferedRanges,
       bufferLimitSeconds:
         Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0 ? bufferLimitSeconds : undefined,
       consumerId,

package/services/encode/EncodeRun.js

@@ -103,6 +103,10 @@ export class EncodeRun {
 
   /** Half a name left over from the last chunk of the encoder's own channel. */
   #closedTail = "";
+  #pendingClosed = null;
+  #inputTruncated = false;
+  #stderrReadTail = "";
+  #processExited = false;
 
   /**
    * The last piece named on the ready channel while the run was still running
@@ -242,7 +246,7 @@ export class EncodeRun {
     this.onProgress = typeof onProgress === "function" ? onProgress : () => {};
     // Told the NAME of every piece the encoder has closed. The name is the
     // proof it is whole; nothing else here can prove that.
-    this.onClosed = typeof onClosed === "function" ? onClosed : () => {};
+    this.onClosed = typeof onClosed === "function" ? onClosed : (name) => name;
     this.lastSegmentIndex = typeof lastSegmentIndex === "function" ? lastSegmentIndex : () => null;
     this.inputUnavailable = typeof inputUnavailable === "function" ? inputUnavailable : () => false;
     this.argsDescribed = argsDescribed;
@@ -420,6 +424,9 @@ export class EncodeRun {
       const line = String(chunk).trim();
       if (line.length > 0) {
         this.lastError = line;
+        const errorText = this.#stderrReadTail + String(chunk);
+        this.#inputTruncated ||= /Stream ends prematurely|Input\/output error|Error during demuxing/i.test(errorText);
+        this.#stderrReadTail = errorText.slice(-512);
         this.logger.warn(`ffmpeg #${this.from}..#${this.to} of ${this.address}: ${line}`);
       }
     });
@@ -428,7 +435,9 @@ export class EncodeRun {
       this.lastError = message;
       this.#finish(ENCODE_EXIT.FAILED, `the process could not be started: ${message}`, null, null);
     });
-    process.on("exit", (code, signal) => this.#onExit(code, signal));
+    // `close` follows drained stdio; `exit` can precede the final filename.
+    process.on("exit", () => { this.#processExited = true; });
+    process.on("close", (code, signal) => this.#onExit(code, signal));
   }
 
   /**
@@ -504,11 +513,23 @@ export class EncodeRun {
       if (name.length === 0) {
         continue;
       }
+      if (this.#stopping) continue;
+      // A subsequent closed file proves the previous one reached a cut.
+      // The last file can instead have been flushed by an input failure.
+      if (this.#pendingClosed !== null) {
+        this.#publishClosed(this.#pendingClosed);
+      }
+      this.#pendingClosed = name;
+    }
+  }
+
+  #publishClosed(name) {
       // ITS SERVED NAME, which is what whoever owns the disk gives it in answer.
       // ffmpeg writes a piece under a working name and reports that; the piece
       // becomes servable by being renamed, and everything below works in the
       // name a request can actually ask for.
-      const served = this.onClosed(name) ?? name;
+      const served = this.onClosed(name);
+      if (!served) return false;
       if (!this.#stopping) {
         this.#provenName = served;
       }
@@ -524,7 +545,7 @@ export class EncodeRun {
       if (Number.isInteger(index)) {
         this.noteProduced(index);
       }
-    }
+      return true;
   }
 
   noteSpeed(speedX) {
@@ -545,6 +566,12 @@ export class EncodeRun {
     if (this.#process === null || this.#ended) {
       return;
     }
+    // A cut closed before our stop stays complete; the file flushed by the
+    // subsequent signal must never be published as that same proof.
+    if (this.#pendingClosed !== null && !this.#processExited && !this.#inputTruncated) {
+      this.#publishClosed(this.#pendingClosed);
+      this.#pendingClosed = null;
+    }
     this.#stopping = true;
     this.#stopReason = because;
     this.#stopOrderedAt = this.now();
@@ -646,14 +673,24 @@ export class EncodeRun {
     // that exits cleanly at #11 has not finished, whatever the film's length;
     // and a run with no end has nothing but the film to be measured against.
     const endOfWork = Number.isFinite(endOfRun(this)) ? this.to : this.lastSegmentIndex();
+    const pendingIndex = this.#pendingClosed === null ? null :
+      this.indexOfName(this.#pendingClosed);
     const outcome = classifyEncodeExit({
       code,
-      producedThrough: this.#produced.size > 0 ? this.reached : null,
-      producedCount: this.#produced.size,
+      producedThrough: this.#inputTruncated ? this.reached :
+        (pendingIndex === this.head ? pendingIndex : this.reached),
+      producedCount: this.#produced.size + Number(pendingIndex === this.head && !this.#inputTruncated),
       lastSegmentIndex: endOfWork,
       inputUnavailable: this.inputUnavailable(this.lastError)
     });
     if (outcome === ENCODE_EXIT.COMPLETE) {
+      if (this.#pendingClosed !== null && !this.#inputTruncated) {
+        if (!this.#publishClosed(this.#pendingClosed)) {
+          this.#finish(ENCODE_EXIT.SHORT, "its final file could not be published", code, signal);
+          return;
+        }
+        this.#pendingClosed = null;
+      }
       this.#finish(ENCODE_EXIT.COMPLETE, "it reached the end of what it was given", code, signal);
       return;
     }

package/services/encode/EncodeRuns.js

@@ -827,7 +827,8 @@ export class EncodeRuns {
         session.timeline?.segmentCount > 0 ? session.timeline.segmentCount - 1 : null,
       inputUnavailable: (message) => isInputUnavailable(message),
       onProgress: (report) => this.#noteRunProgress(session, run, report),
-      indexOfName: (name) => session.segmentFormat.segmentIndexFromName(name),
+      indexOfName: (name) => session.segmentFormat.segmentIndexFromName(
+        session.segmentFormat.servedNameOf?.(name) ?? name),
       // Why this encoder exists, recorded with its argument list. It used to be
       // handed to a separate `start` call; there is no separate call now.
       because,

package/services/encode/segment-formats/fmp4.js

@@ -11,6 +11,9 @@
  */
 
 import {
+  rebaseSegmentDecodeTimes,
+  neutralizeEmptyEdits,
+  readPresentationRanges,
   readSelfContainedStartSeconds,
   readTrackTimescales,
   readVideoSampleSize,
@@ -210,6 +213,7 @@ export const fmp4Format = {
     const { firstFragment } = findFragmentBounds(bytes);
     return firstFragment > 0 ? bytes.subarray(0, firstFragment) : null;
   },
+  prepareSharedInit: neutralizeEmptyEdits,
 
   /**
    * A piece with its init header removed, and the trailing random-access index
@@ -275,6 +279,7 @@ export const fmp4Format = {
    * transcode itself; the box walk never descends into `mdat`.
    */
   needsSegmentRewrite: true,
+  readMediaRanges: readPresentationRanges,
 
   /**
    * Whether a segment carries every track the init promises.
@@ -425,13 +430,16 @@ export const fmp4Format = {
     return readVideoSampleSize(initBytes);
   },
 
-  prepareSegmentBytes(bytes, { startSeconds, initBytes }) {
+  prepareSegmentBytes(bytes, { startSeconds, initBytes, rawBytes }) {
     if (!initBytes || initBytes.length === 0) {
       // No init cached yet — nothing to read timescales from. The player always
       // fetches `#EXT-X-MAP` before any segment, so this is not reachable in
       // practice; serve unmodified rather than guess a timescale.
       return bytes;
     }
-    return stampSegmentStartTime(bytes, startSeconds, readTrackTimescales(initBytes));
+    const ownInit = rawBytes ? this.extractInit(rawBytes) : null;
+    return ownInit
+      ? rebaseSegmentDecodeTimes(bytes, ownInit, initBytes)
+      : stampSegmentStartTime(bytes, startSeconds, readTrackTimescales(initBytes));
   }
 };

package/services/encode/segment-formats/index.js

@@ -20,6 +20,7 @@ import { mpegtsFormat } from "./mpegts.js";
  *   output timeline, from the session's segment-boundary table.
  * @property {Buffer | null} initBytes - The init segment being served for this
  *   session, when the format has one (fMP4 needs it to read track timescales).
+ * @property {Buffer} [rawBytes] - Self-contained bytes before removing their init.
  */
 
 /**

package/services/encode/segment-formats/mp4-boxes.js

@@ -15,7 +15,7 @@
  *
  * @type {ReadonlySet<string>}
  */
-const CONTAINER_BOXES = new Set(["moov", "trak", "mdia", "minf", "stbl", "edts", "moof", "traf"]);
+const CONTAINER_BOXES = new Set(["moov", "mvex", "trak", "mdia", "minf", "stbl", "edts", "moof", "traf"]);
 
 /**
  * Walk the box tree, invoking `visit` for every box encountered.
@@ -95,6 +95,142 @@ export function readTrackTimescales(initSegment) {
   return timescales;
 }
 
+/** Movie presentation time minus track media time, in seconds per track. */
+export function readTrackEditOffsets(initSegment) {
+  const scales = readTrackTimescales(initSegment);
+  const offsets = new Map([...scales.keys()].map((id) => [id, 0]));
+  let movieScale = 0;
+  let trackId = null;
+  walkBoxes(initSegment, (type, start, end) => {
+    const version = initSegment[start];
+    if (type === "mvhd") {
+      const at = start + (version === 1 ? 20 : 12);
+      if (at + 4 <= end) movieScale = initSegment.readUInt32BE(at);
+    } else if (type === "tkhd") {
+      const at = start + (version === 1 ? 20 : 12);
+      if (at + 4 <= end) trackId = initSegment.readUInt32BE(at);
+    } else if (type === "elst" && scales.has(trackId) && movieScale > 0 && start + 8 <= end) {
+      const count = initSegment.readUInt32BE(start + 4);
+      const width = version === 1 ? 20 : 12;
+      let movieStart = 0;
+      for (let entry = 0, at = start + 8; entry < count && at + width <= end; entry++, at += width) {
+        const duration = version === 1 ? Number(initSegment.readBigUInt64BE(at)) : initSegment.readUInt32BE(at);
+        const mediaTime = version === 1 ? Number(initSegment.readBigInt64BE(at + 8)) : initSegment.readInt32BE(at + 4);
+        if (mediaTime === -1) {
+          movieStart += duration / movieScale;
+        } else {
+          offsets.set(trackId, movieStart - mediaTime / scales.get(trackId));
+          break;
+        }
+      }
+    }
+  });
+  return offsets;
+}
+
+/** An init shared across seeks has no segment-specific empty edit. */
+export function neutralizeEmptyEdits(initSegment) {
+  const neutral = Buffer.from(initSegment);
+  walkBoxes(neutral, (type, start, end) => {
+    if (type !== "elst" || start + 8 > end) return;
+    const version = neutral[start];
+    const width = version === 1 ? 20 : 12;
+    const count = neutral.readUInt32BE(start + 4);
+    for (let entry = 0, at = start + 8; entry < count && at + width <= end; entry++, at += width) {
+      const mediaTime = version === 1 ? neutral.readBigInt64BE(at + 8) : BigInt(neutral.readInt32BE(at + 4));
+      if (mediaTime !== -1n) continue;
+      if (version === 1) neutral.writeBigUInt64BE(0n, at);
+      else neutral.writeUInt32BE(0, at);
+    }
+  });
+  return neutral;
+}
+
+/** Preserve sample presentation times when replacing a piece's own init. */
+export function rebaseSegmentDecodeTimes(segment, ownInit, sessionInit) {
+  const scales = readTrackTimescales(sessionInit);
+  const ownOffsets = readTrackEditOffsets(ownInit);
+  const sessionOffsets = readTrackEditOffsets(sessionInit);
+  const stamped = Buffer.from(segment);
+  let trackId = null;
+  walkBoxes(stamped, (type, start, end) => {
+    if (type === "tfhd" && start + 8 <= end) {
+      trackId = stamped.readUInt32BE(start + 4);
+    } else if (type === "tfdt" && scales.has(trackId) && ownOffsets.has(trackId)) {
+      const version = stamped[start];
+      if (start + (version === 1 ? 12 : 8) > end) return;
+      const existing = version === 1 ? Number(stamped.readBigUInt64BE(start + 4)) : stamped.readUInt32BE(start + 4);
+      const value = existing + Math.round((ownOffsets.get(trackId) - sessionOffsets.get(trackId)) * scales.get(trackId));
+      if (value < 0) throw new Error("A fragment cannot be placed before its shared init's decode origin.");
+      if (version === 1) stamped.writeBigUInt64BE(BigInt(value), start + 4);
+      else if (value <= 0xffffffff) stamped.writeUInt32BE(value, start + 4);
+      else throw new Error("Fragment decode time exceeds its 32-bit field.");
+    }
+  });
+  return stamped;
+}
+
+/** Presentation intervals from the durations and composition times of samples. */
+export function readPresentationRanges(raw) {
+  const scales = readTrackTimescales(raw);
+  const edits = readTrackEditOffsets(raw);
+  const byTrack = new Map();
+  const defaultDurations = new Map();
+  let trackId = null;
+  let decodeTime = 0;
+  let defaultDuration = 0;
+  walkBoxes(raw, (type, start, end) => {
+    if (type === "trex" && start + 20 <= end) {
+      defaultDurations.set(raw.readUInt32BE(start + 4), raw.readUInt32BE(start + 12));
+    } else if (type === "tfhd" && start + 8 <= end) {
+      const flags = raw.readUIntBE(start + 1, 3);
+      trackId = raw.readUInt32BE(start + 4);
+      const at = start + 8 + ((flags & 1) ? 8 : 0) + ((flags & 2) ? 4 : 0);
+      defaultDuration = (flags & 8) && at + 4 <= end ? raw.readUInt32BE(at) :
+        defaultDurations.get(trackId) ?? 0;
+    } else if (type === "tfdt" && start + (raw[start] === 1 ? 12 : 8) <= end) {
+      decodeTime = raw[start] === 1 ? Number(raw.readBigUInt64BE(start + 4)) : raw.readUInt32BE(start + 4);
+    } else if (type === "trun" && scales.has(trackId) && start + 8 <= end) {
+      const scale = scales.get(trackId);
+      const flags = raw.readUIntBE(start + 1, 3);
+      const count = raw.readUInt32BE(start + 4);
+      let at = start + 8 + ((flags & 1) ? 4 : 0) + ((flags & 4) ? 4 : 0);
+      const width = Number(Boolean(flags & 0x100)) * 4 + Number(Boolean(flags & 0x200)) * 4 +
+        Number(Boolean(flags & 0x400)) * 4 + Number(Boolean(flags & 0x800)) * 4;
+      const ranges = byTrack.get(trackId) ?? [];
+      for (let sample = 0; sample < count && at + width <= end; sample++) {
+        const duration = flags & 0x100 ? raw.readUInt32BE(at) : defaultDuration;
+        if (flags & 0x100) at += 4;
+        if (flags & 0x200) at += 4;
+        if (flags & 0x400) at += 4;
+        const composition = flags & 0x800 ?
+          (raw[start] === 1 ? raw.readInt32BE(at) : raw.readUInt32BE(at)) : 0;
+        if (flags & 0x800) at += 4;
+        if (!(duration > 0)) return;
+        const position = (decodeTime + composition) / scale + (edits.get(trackId) ?? 0);
+        ranges.push({ start: position, end: position + duration / scale });
+        decodeTime += duration;
+      }
+      byTrack.set(trackId, ranges);
+    }
+  });
+  // Merge in presentation order: B frames arrive in decode order.
+  const mergedTracks = [...byTrack.values()].map((samples) => {
+    const merged = [];
+    for (const sample of samples.sort((left, right) => left.start - right.start)) {
+      const previous = merged.at(-1);
+      if (previous && sample.start - previous.end <= Number.EPSILON * Math.max(1, sample.end) * 8) {
+        previous.end = Math.max(previous.end, sample.end);
+      } else merged.push({ ...sample });
+    }
+    return merged;
+  });
+  // A multiplexed segment is playable only where every declared track exists.
+  return mergedTracks.reduce((common, ranges) => common.flatMap((left) => ranges
+    .map((right) => ({ start: Math.max(left.start, right.start), end: Math.min(left.end, right.end) }))
+    .filter(({ start, end }) => end > start)), mergedTracks[0] ?? []);
+}
+
 /**
  * Rewrite every fragment's `tfdt` so the segment declares that it starts at
  * `startSeconds` on the media timeline.

package/services/server/SegmentServing.js

@@ -419,6 +419,7 @@ export class SegmentServing {
         }
         const prepared = session.segmentFormat.prepareSegmentBytes(bytes, {
           startSeconds: stampStart,
+          rawBytes: raw,
           initBytes: this.#host.segmentStore.initOf(session.outputKey ?? "")
         });
         this.#host.encodeRuns.noteRunProducedSegment(session, filePath);
@@ -541,6 +542,7 @@ export class SegmentServing {
     const trueStart = selfContained ? format.readSegmentStartSeconds?.(raw) ?? null : null;
     const prepared = format.prepareSegmentBytes(bytes, {
       startSeconds: trueStart ?? this.#host.outputTimes.publishedStartTime(like, index),
+      rawBytes: raw,
       initBytes: this.#host.segmentStore.initOf(goneKey)
     });
     logger.info(`[hold] ${fileName} served from the stored pieces of ${goneKey}, the output that first answered it`);
@@ -802,7 +804,9 @@ export class SegmentServing {
         if (!found) {
           continue;
         }
-        const init = session.segmentFormat.extractInit(cached ?? await readFile(found));
+        const ownInit = session.segmentFormat.extractInit(cached ?? await readFile(found));
+        const init = ownInit && session.segmentFormat.prepareSharedInit ?
+          session.segmentFormat.prepareSharedInit(ownInit) : ownInit;
         if (!init || init.length === 0) {
           continue;
         }

package/services/server/ViewerRequests.js

@@ -568,7 +568,8 @@ export class ViewerRequests {
       const segments = Array.from({ length: timeline?.segmentCount ?? 0 }, (_, index) => ({
         index,
         startSeconds: timeline.publishedStartOf(index),
-        endSeconds: timeline.publishedStartOf(index + 1)
+        endSeconds: timeline.publishedStartOf(index + 1),
+        mediaRanges: this.#host.segmentStore.mediaRangesOf(output.outputKey, index)
       }));
       const sourceIndexes = [output.spec.video?.fileIndex, output.spec.audio?.fileIndex]
         .filter((fileIndex) => Number.isInteger(fileIndex) && fileIndex >= 0);
@@ -618,6 +619,8 @@ export class ViewerRequests {
         : await this.#host.quality.observedStreamMbps(output);
       tracks.push({
         id: output.outputKey,
+        clientRanges: viewerReading?.bufferedRanges?.[output === session ? "video" : "audio"] ??
+          viewerReading?.bufferedRanges?.media,
         sourceIds,
         processedSeconds: trackProgress?.processedSeconds,
         bitsPerMediaSecond: Number.isFinite(observedMbps) && observedMbps > 0 ? observedMbps * 1_000_000 : 0,

package/services/server/playback-readiness.js

@@ -85,16 +85,24 @@ export class RateTrend {
  */
 export function predictPlaybackReadiness(input = {}) {
   const now = Number.isFinite(input.now) ? input.now : Date.now();
-  const position = finiteNonNegative(input.positionSeconds);
+  const tracks = Array.isArray(input.tracks) ? input.tracks : [];
+  const mediaOrigin = Math.max(0, ...tracks.map((track) =>
+    track.segments?.find(({ index }) => index === 0)?.mediaRanges?.[0]?.start ?? 0));
+  const position = Math.max(mediaOrigin, finiteNonNegative(input.positionSeconds));
   const duration = finiteNonNegative(input.durationSeconds);
   const remaining = Math.max(0, duration - position);
-  const buffered = finiteNonNegative(input.bufferedAheadSeconds);
+  const measuredRanges = tracks.map((track) => Array.isArray(track.clientRanges) ?
+    normalizedRanges(track.clientRanges) : null);
+  const buffered = measuredRanges.length > 0 && measuredRanges.every(Boolean) ?
+    Math.max(0, Math.min(...measuredRanges.map((ranges) => contiguousEnd(ranges, position) - position))) :
+    finiteNonNegative(input.bufferedAheadSeconds);
   // A loader target can be lowered after a fragment retry. Bytes already held
   // prove a larger capacity, even when an older page reports only that target.
-  const capacity = Math.max(buffered, finiteNonNegative(input.bufferLimitSeconds));
+  const capacity = Math.max(buffered, finiteNonNegative(input.bufferLimitSeconds),
+    ...measuredRanges.map((ranges) => ranges ? ranges.reduce((total, range) =>
+      total + Math.max(0, range.end - Math.max(position, range.start)), 0) : 0));
   const reserve = Math.min(remaining, finiteNonNegative(input.reserveSeconds));
   const lookahead = finiteNonNegative(input.lookaheadSeconds);
-  const tracks = Array.isArray(input.tracks) ? input.tracks : [];
   const sources = new Map((Array.isArray(input.sources) ? input.sources : [])
     .filter((source) => typeof source?.id === "string")
     .map((source) => [source.id, source]));
@@ -114,6 +122,8 @@ export function predictPlaybackReadiness(input = {}) {
 
   const trackState = tracks.map((track) => ({
     track,
+    clientRanges: Array.isArray(track.clientRanges) ? normalizedRanges(track.clientRanges) :
+      [{ start: position, end: position + buffered }],
     ready: new Set(Array.isArray(track.readySegmentIndices) ? track.readySegmentIndices : []),
     curve: rateCurve(track.readings, now),
     bitsPerMediaSecond: averageBitsPerMediaSecond(track, track.segments,
@@ -157,11 +167,13 @@ export function predictPlaybackReadiness(input = {}) {
     const { track, segments } = state;
     const measuredBitsPerMediaSecond = state.bitsPerMediaSecond;
     for (const segment of segments) {
-      if (segment.endSeconds <= position + buffered) {
+      if (coveredSeconds(state.clientRanges, Math.max(position, segment.startSeconds), segment.endSeconds) >=
+        segment.endSeconds - Math.max(position, segment.startSeconds) - Number.EPSILON * duration) {
         continue;
       }
       const exactBytes = sizeOf(track.segmentSizesBytes, segment.index);
       const segmentSeconds = segment.endSeconds - segment.startSeconds;
+      // HLS fetches the complete file when any required part is absent.
       const sizeBits = exactBytes > 0
         ? exactBytes * 8
         : measuredBitsPerMediaSecond * segmentSeconds;
@@ -170,9 +182,9 @@ export function predictPlaybackReadiness(input = {}) {
       }
 
       const produced = state.ready.has(segment.index);
-      const processed = Number(track.processedSeconds);
-      const workStart = Math.max(position, segment.startSeconds,
-        Number.isFinite(processed) ? processed : segment.startSeconds);
+      // Global encode progress may belong to another run beyond a missing
+      // segment. Only publication proves this segment's work is complete.
+      const workStart = Math.max(position, segment.startSeconds);
       const encodeWork = produced ? 0 : Math.max(0, segment.endSeconds - workStart);
       if (!produced && !(encodeWork > 0)) {
         unknownReason ??= "segment-production-delay-unavailable";
@@ -479,8 +491,8 @@ function isSafeSchedule(completions, productions, trackState, position, duration
   startDelay) {
   // Client continuity is constrained by its buffer limit; source-stall reserve
   // is covered by the larger union of client data and output already prepared here.
-  const clientRanges = trackState.map(() => [{ start: position, end: position + buffered }]);
-  const preparedRanges = trackState.map(() => [{ start: position, end: position + buffered }]);
+  const clientRanges = trackState.map((state) => state.clientRanges.map((range) => ({ ...range })));
+  const preparedRanges = trackState.map((state) => state.clientRanges.map((range) => ({ ...range })));
   const orderedCompletions = [...completions]
     .filter(({ at }) => Number.isFinite(at))
     .sort((left, right) => left.at - right.at || left.trackIndex - right.trackIndex);
@@ -502,13 +514,17 @@ function isSafeSchedule(completions, productions, trackState, position, duration
   const addThrough = (time) => {
     while (productionIndex < orderedProductions.length && orderedProductions[productionIndex].at <= time) {
       const { trackIndex, segment } = orderedProductions[productionIndex];
-      addRange(preparedRanges[trackIndex], segment.startSeconds, segment.endSeconds);
+      for (const range of segment.mediaRanges ?? [{ start: segment.startSeconds, end: segment.endSeconds }]) {
+        addRange(preparedRanges[trackIndex], range.start, range.end);
+      }
       productionIndex += 1;
     }
     while (completionIndex < orderedCompletions.length && orderedCompletions[completionIndex].at <= time) {
       const { trackIndex, segment } = orderedCompletions[completionIndex];
-      addRange(clientRanges[trackIndex], segment.startSeconds, segment.endSeconds);
-      addRange(preparedRanges[trackIndex], segment.startSeconds, segment.endSeconds);
+      for (const range of segment.mediaRanges ?? [{ start: segment.startSeconds, end: segment.endSeconds }]) {
+        addRange(clientRanges[trackIndex], range.start, range.end);
+        addRange(preparedRanges[trackIndex], range.start, range.end);
+      }
       completionIndex += 1;
     }
   };
@@ -517,13 +533,18 @@ function isSafeSchedule(completions, productions, trackState, position, duration
     if (playerPosition >= duration) {
       return { safe: true, stockSafe: true, available: 0, neededSeconds: 0 };
     }
-    const available = Math.min(capacity, ...clientRanges.map((trackRanges) =>
-      Math.max(0, contiguousEnd(trackRanges, playerPosition) - playerPosition)));
+    const trackEnd = (index) => {
+      const last = trackState[index].segments.at(-1);
+      return last?.mediaRanges?.at(-1)?.end ?? duration;
+    };
+    const available = Math.min(capacity, ...clientRanges.map((trackRanges, index) =>
+      playerPosition >= trackEnd(index) ? Number.POSITIVE_INFINITY :
+        Math.max(0, contiguousEnd(trackRanges, playerPosition) - playerPosition)));
     let neededSeconds = 0;
     let stockSafe = true;
     for (let trackIndex = 0; trackIndex < trackState.length; trackIndex += 1) {
       const required = time <= reserveUntil[trackIndex]
-        ? Math.min(reserve, Math.max(0, duration - playerPosition))
+        ? Math.min(reserve, Math.max(0, trackEnd(trackIndex) - playerPosition))
         : 0;
       const preparedAhead = Math.max(0,
         contiguousEnd(preparedRanges[trackIndex], playerPosition) - playerPosition);
@@ -547,6 +568,9 @@ function isSafeSchedule(completions, productions, trackState, position, duration
 
   const playbackEnd = startDelay + Math.max(0, duration - position);
   const playbackBoundaries = [position + buffered,
+    ...trackState.flatMap(({ clientRanges }) => clientRanges.flatMap(({ start, end }) => [start, end])),
+    ...trackState.flatMap(({ segments }) => segments.flatMap((segment) =>
+      (segment.mediaRanges ?? []).flatMap(({ start, end }) => [start, end]))),
     ...trackState.flatMap(({ segments }) => segments.map(({ endSeconds }) => endSeconds))]
     .filter((boundary) => boundary > position && boundary < duration)
     .map((boundary) => startDelay + boundary - position);
@@ -598,6 +622,21 @@ function addRange(ranges, start, end) {
   ranges.splice(0, ranges.length, ...merged);
 }
 
+function normalizedRanges(ranges) {
+  const result = [];
+  for (const range of ranges) {
+    if (Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.end > range.start) {
+      addRange(result, range.start, range.end);
+    }
+  }
+  return result;
+}
+
+function coveredSeconds(ranges, start, end) {
+  return ranges.reduce((total, range) => total + Math.max(0,
+    Math.min(end, range.end) - Math.max(start, range.start)), 0);
+}
+
 function contiguousEnd(ranges, position) {
   for (const range of ranges) {
     if (range.start <= position && position <= range.end) {

package/services/storage/piece-store/piece-disk-store.js

@@ -300,6 +300,26 @@ export class PieceDiskStore {
    * @param {number} [at] - Offset within the piece to start at.
    * @returns {Promise<number>} Bytes read.
    */
+  hold(index) {
+    if (!this.#stored.has(index)) {
+      return null;
+    }
+    this.#reading.set(index, (this.#reading.get(index) ?? 0) + 1);
+    let held = true;
+    return () => {
+      if (!held) {
+        return;
+      }
+      held = false;
+      const outstanding = (this.#reading.get(index) ?? 1) - 1;
+      if (outstanding > 0) {
+        this.#reading.set(index, outstanding);
+      } else {
+        this.#reading.delete(index);
+      }
+    };
+  }
+
   async read(index, target, at = 0) {
     if (!this.#stored.has(index)) {
       throw new Error(`Piece ${index} is not on disk.`);
@@ -338,6 +358,9 @@ export class PieceDiskStore {
    * @returns {void}
    */
   forget(index) {
+    if (this.#reading.has(index)) {
+      return;
+    }
     const length = this.#stored.get(index);
     if (length === undefined) {
       return;

package/services/storage/piece-store/shared-piece-store.js

@@ -1407,8 +1407,12 @@ export class SharedPieceStore {
       }
     }
 
-    const release = await this.#claimSlot();
+    // Hold the disk bytes before waiting for memory: another reader may move
+    // the eviction boundary while this read is waiting for a slot.
+    const releaseDisk = this.#disk.hold?.(index) ?? (() => {});
+    let release = null;
     try {
+      release = await this.#claimSlot();
       // Another caller may have brought it back while this one waited for a
       // slot. Registering a second buffer for the same piece would leave
       // whoever holds the first reading memory nothing evicts.
@@ -1434,7 +1438,8 @@ export class SharedPieceStore {
       this.#noteRevival(index);
       return target;
     } finally {
-      release();
+      release?.();
+      releaseDisk();
     }
   }
 

package/services/storage/segment-store/SegmentStore.js

@@ -83,6 +83,7 @@ export class SegmentStore {
 
   /** Output key → what its directory holds. @type {Map<string, HeldContents>} */
   #held = new Map();
+  #mediaRanges = new Map();
 
   /** Output key → how to read its file names. @type {Map<string, object>} */
   #formats = new Map();
@@ -431,6 +432,17 @@ export class SegmentStore {
       return null;
     }
     const dir = path.join(this.#root, directoryNameFor(key));
+    const index = format?.segmentIndexFromName?.(served) ?? -1;
+    let mediaRanges = null;
+    if (format?.readMediaRanges && index >= 0) {
+      try {
+        mediaRanges = format.readMediaRanges(readFileSync(path.join(dir, makingName)));
+        if (mediaRanges.length === 0) throw new Error("The closed file contains no playable media intervals.");
+      } catch (error) {
+        this.#logger?.warn?.(`segment store: could not read media coverage of ${makingName}: ${error.message}`);
+        return null;
+      }
+    }
     try {
       renameSync(path.join(dir, makingName), path.join(dir, served));
     } catch (error) {
@@ -445,8 +457,12 @@ export class SegmentStore {
     }
     // What the directory holds has changed, so the memory of it is stale.
     this.#held.delete(key);
-    const index = format?.segmentIndexFromName?.(served) ?? -1;
     if (index >= 0) {
+      if (mediaRanges) {
+        const byIndex = this.#mediaRanges.get(key) ?? new Map();
+        byIndex.set(index, mediaRanges);
+        this.#mediaRanges.set(key, byIndex);
+      }
       this.announce(key, index);
       for (const listener of this.#publishedListeners) {
         listener(key, index);
@@ -455,6 +471,24 @@ export class SegmentStore {
     return served;
   }
 
+  mediaRangesOf(key, index) {
+    const known = this.#mediaRanges.get(key)?.get(index);
+    if (known) return known;
+    const format = this.#formats.get(key);
+    if (!format?.readMediaRanges) return undefined;
+    const filePath = this.pathOf(key, index);
+    if (!filePath) return undefined;
+    try {
+      const ranges = format.readMediaRanges(readFileSync(filePath));
+      const byIndex = this.#mediaRanges.get(key) ?? new Map();
+      byIndex.set(index, ranges);
+      this.#mediaRanges.set(key, byIndex);
+      return ranges;
+    } catch {
+      return [];
+    }
+  }
+
   /**
    * The init segment kept for this output, or null until one was read whole.
    *
@@ -842,6 +876,7 @@ export class SegmentStore {
     }
     this.#held.delete(key);
     this.#formats.delete(key);
+    this.#mediaRanges.delete(key);
     this.#touched.delete(key);
     this.#inits.delete(key);
     this.#logger.info(`segment-store dropped ${directoryNameFor(key)} (${because})`);

package/services/viewer/Viewer.js

@@ -391,6 +391,7 @@ export class Viewer {
       linkSampleAt = null,
       linkSampleAgeMs = null,
       bufferedAheadSec,
+      bufferedRanges,
       bufferLimitSeconds,
       positionSeconds = null,
       playing,
@@ -434,6 +435,11 @@ export class Viewer {
           : now
         : this.netReport?.linkSampleMeasuredAt ?? null,
       bufferedAheadSec: held,
+      bufferedRanges: bufferedRanges && typeof bufferedRanges === "object" ?
+        Object.fromEntries(["video", "audio", "media"].filter((key) => Array.isArray(bufferedRanges[key]))
+          .map((key) => [key, bufferedRanges[key].slice(0, 256).filter((range) =>
+            Number.isFinite(range?.start) && Number.isFinite(range?.end) && range.start >= 0 && range.end > range.start)
+            .map(({ start, end }) => ({ start, end }))])) : null,
       bufferLimitSeconds: Number.isFinite(bufferLimitSeconds) && bufferLimitSeconds > 0
         ? bufferLimitSeconds
         : this.netReport?.bufferLimitSeconds ?? null,

package/test/encode-orchestrator.test.js

@@ -44,7 +44,7 @@ class FakeProcess extends EventEmitter {
     this.signals.push(signal);
     // A real ffmpeg dies a moment later; the test wants the bookkeeping to
     // happen where it can be seen, so the exit is immediate and synchronous.
-    this.emit("exit", null, signal);
+    this.emit("close", null, signal);
   }
 }
 
@@ -172,7 +172,7 @@ test("how many encoders are running is answered by the one thing that makes them
   assert.equal(made.runningCount(), 2, "two processes on one output are two encoders, not one");
 
   // And a run that has ended is forgotten as it ends, not at the next pass.
-  processes.get(first).emit("exit", 0, null);
+  processes.get(first).emit("close", 0, null);
   assert.equal(made.runningCount(), 1);
 
   // A SUSPENDED run is stopped where it stands and is using nothing, so a cost
@@ -372,7 +372,7 @@ test("every ending is counted, and our own kill is not counted as normal", () =>
   wants(made, [{ from: 100, to: 130 }]);
   made.reconcile();
   const run = made.runsOn(PICTURE)[0];
-  processes.get(run).emit("exit", 255, null);
+  processes.get(run).emit("close", 255, null);
   wants(made, []);
   made.reconcile();
   const tally = made.endings();

package/test/encode-plan-viewers.test.js

@@ -59,7 +59,7 @@ class FakeProcess extends EventEmitter {
   }
 
   kill(signal) {
-    this.emit("exit", null, signal);
+    this.emit("close", null, signal);
   }
 }
 

package/test/encode-run.test.js

@@ -30,6 +30,7 @@ class FakeProcess extends EventEmitter {
 
   exitWith(code, signal = null) {
     this.emit("exit", code, signal);
+    this.emit("close", code, signal);
   }
 }
 

package/test/fmp4-presentation-clock.test.js

@@ -0,0 +1,72 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { fmp4Format } from "../services/encode/segment-formats/fmp4.js";
+import { readPresentationRanges, walkBoxes } from "../services/encode/segment-formats/mp4-boxes.js";
+
+function box(type, body) {
+  const header = Buffer.alloc(8);
+  header.writeUInt32BE(body.length + 8);
+  header.write(type, 4);
+  return Buffer.concat([header, body]);
+}
+
+function init(emptyMs, mediaTime) {
+  const mvhd = Buffer.alloc(24);
+  mvhd.writeUInt32BE(1000, 12);
+  const tkhd = Buffer.alloc(20);
+  tkhd.writeUInt32BE(1, 12);
+  const mdhd = Buffer.alloc(24);
+  mdhd.writeUInt32BE(24000, 12);
+  const elst = Buffer.alloc(32);
+  elst.writeUInt32BE(2, 4);
+  elst.writeUInt32BE(emptyMs, 8);
+  elst.writeInt32BE(-1, 12);
+  elst.writeUInt32BE(1000, 20);
+  elst.writeInt32BE(mediaTime, 24);
+  return box("moov", Buffer.concat([box("mvhd", mvhd), box("trak", Buffer.concat([
+    box("tkhd", tkhd), box("edts", box("elst", elst)), box("mdia", box("mdhd", mdhd))
+  ]))]));
+}
+
+function fragment(decodeTime, composition) {
+  const tfhd = Buffer.alloc(12);
+  tfhd.writeUIntBE(8, 1, 3);
+  tfhd.writeUInt32BE(1, 4);
+  tfhd.writeUInt32BE(1000, 8);
+  const tfdt = Buffer.alloc(12);
+  tfdt[0] = 1;
+  tfdt.writeBigUInt64BE(BigInt(decodeTime), 4);
+  const trun = Buffer.alloc(12);
+  trun.writeUIntBE(0x800, 1, 3);
+  trun.writeUInt32BE(1, 4);
+  trun.writeUInt32BE(composition, 8);
+  return box("moof", box("traf", Buffer.concat([
+    box("tfhd", tfhd), box("tfdt", tfdt), box("trun", trun)
+  ])));
+}
+
+test("a shared init preserves presentation times without adding composition delay twice", () => {
+  const shared = fmp4Format.prepareSharedInit(init(83, 2000));
+  const own = init(4125, 3000);
+  const media = Buffer.concat([fragment(0, 3000), fragment(48000, 3000)]);
+  const raw = Buffer.concat([own, media]);
+  const prepared = fmp4Format.prepareSegmentBytes(media, {
+    startSeconds: 4.125, initBytes: shared, rawBytes: raw
+  });
+  assert.deepEqual(readPresentationRanges(Buffer.concat([shared, prepared])), readPresentationRanges(raw));
+  const times = [];
+  walkBoxes(prepared, (type, start) => {
+    if (type === "tfdt") times.push(Number(prepared.readBigUInt64BE(start + 4)));
+  });
+  assert.deepEqual(times, [98000, 146000]);
+});
+
+test("a shared init first read after a seek also supports returning to the beginning", () => {
+  const shared = fmp4Format.prepareSharedInit(init(304083, 2000));
+  const media = fragment(0, 2000);
+  const raw = Buffer.concat([init(83, 2000), media]);
+  const prepared = fmp4Format.prepareSegmentBytes(media, {
+    startSeconds: 0.083, initBytes: shared, rawBytes: raw
+  });
+  assert.deepEqual(readPresentationRanges(Buffer.concat([shared, prepared])), readPresentationRanges(raw));
+});

package/test/piece-disk-store.test.js

@@ -18,6 +18,26 @@ import { PieceDiskStore } from "../services/storage/piece-store/piece-disk-store
 
 const PIECE = 4096;
 
+test("bytes held before a memory wait cannot be forgotten or evicted", async () => {
+  const { store } = await makeStore(PIECE);
+  try {
+    await store.write(0, Buffer.alloc(PIECE, 7));
+    const release = store.hold(0);
+    store.forget(0);
+    store.forgetBehind([1]);
+    await store.write(1, Buffer.alloc(PIECE, 8));
+    const target = Buffer.alloc(PIECE);
+    assert.equal(await store.read(0, target), PIECE);
+    assert.equal(target[0], 7);
+    release();
+    release();
+    store.forget(0);
+    assert.equal(store.has(0), false);
+  } finally {
+    await store.destroy();
+  }
+});
+
 /**
  * @param {number | null} allowanceBytes
  * @returns {Promise<{ store: PieceDiskStore, directory: string, clock: { at: number } }>}

package/test/piece-store-reservations.test.js

@@ -22,6 +22,7 @@ const CHUNK = 1024;
  */
 function makeDisk({ failWrite = false, failRead = false, holdWrites = false } = {}) {
   const stored = new Map();
+  const reading = new Map();
   /** @type {Array<() => void>} */
   const held = [];
   return {
@@ -61,6 +62,15 @@ function makeDisk({ failWrite = false, failRead = false, holdWrites = false } =
     has(index) {
       return stored.has(index);
     },
+    hold(index) {
+      if (!stored.has(index)) return null;
+      reading.set(index, (reading.get(index) ?? 0) + 1);
+      return () => {
+        const count = reading.get(index) - 1;
+        if (count > 0) reading.set(index, count);
+        else reading.delete(index);
+      };
+    },
     async write(index, bytes) {
       if (holdWrites) {
         await new Promise((resolve) => held.push(resolve));
@@ -82,7 +92,7 @@ function makeDisk({ failWrite = false, failRead = false, holdWrites = false } =
       return bytes.length;
     },
     forget(index) {
-      stored.delete(index);
+      if (!reading.has(index)) stored.delete(index);
     },
     async close() {},
     async destroy() {
@@ -123,6 +133,21 @@ const get = (store, index) =>
     store.get(index, undefined, (error, bytes) => (error ? reject(error) : resolve(bytes)))
   );
 
+test("a revival holds disk bytes across the asynchronous memory reservation", async () => {
+  const { store, disk } = makeStore();
+  disk.stored.set(0, piece(0));
+  try {
+    const revival = store.reside(0);
+    disk.forget(0);
+    const located = await revival;
+    assert.deepEqual(Buffer.from(located.buffer, located.offset, located.length), piece(0));
+    disk.forget(0);
+    assert.equal(disk.has(0), false);
+  } finally {
+    await new Promise((resolve) => store.destroy(resolve));
+  }
+});
+
 /**
  * Wait until a condition holds, rather than for a chosen interval — a test that
  * sleeps samples, it does not check (roadmap item 54).

package/test/playback-start-regressions.test.js

@@ -0,0 +1,99 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { EncodeRun } from "../services/encode/EncodeRun.js";
+import { SoftwareEncoder } from "../services/encode/SoftwareEncoder.js";
+import { predictPlaybackReadiness } from "../services/server/playback-readiness.js";
+
+function encode() {
+  const child = new EventEmitter();
+  child.stdio = [null, new EventEmitter(), new EventEmitter(), new EventEmitter()];
+  child.stderr = child.stdio[2];
+  child.kill = () => {};
+  const published = [];
+  const ended = [];
+  const run = new EncodeRun({
+    address: "fake", from: 0, to: 1, encoder: new SoftwareEncoder(),
+    buildArgs: () => [], spawn: () => child, logger: { info() {}, warn() {} },
+    indexOfName: (name) => Number(name),
+    onClosed: (name) => { published.push(name); return name; },
+    onEnded: (value) => ended.push(value)
+  });
+  return { child, run, published, ended };
+}
+
+test("a clean short input never publishes its flushed tail", () => {
+  const { child, published, ended } = encode();
+  child.stderr.emit("data", "Stream ends prematurely at 1048576");
+  child.stdio[3].emit("data", "0\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, []);
+  assert.equal(ended[0].ending, "short");
+  assert.equal(ended[0].reached, -1);
+});
+
+test("completed cuts survive a failure but its last flushed file does not", () => {
+  const { child, published } = encode();
+  child.stdio[3].emit("data", "0\n");
+  child.stderr.emit("data", "Stream ends prematurely at 1048576");
+  child.stdio[3].emit("data", "1\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, ["0"]);
+});
+
+test("normal completion drains the filename pipe before publishing the tail", () => {
+  const { child, published, ended } = encode();
+  child.emit("exit", 0, null);
+  assert.deepEqual(ended, []);
+  child.stdio[3].emit("data", "0\n1\n");
+  child.emit("close", 0, null);
+  assert.deepEqual(published, ["0", "1"]);
+  assert.equal(ended[0].ending, "complete");
+});
+
+test("stopping retains an earlier closed cut and rejects the signal-flushed tail", () => {
+  const { child, run, published } = encode();
+  child.stdio[3].emit("data", "0\n");
+  run.stop("a different range is needed");
+  child.stdio[3].emit("data", "1\n");
+  child.emit("close", null, "SIGTERM");
+  assert.deepEqual(published, ["0"]);
+});
+
+function state(clientRanges) {
+  return {
+    now: 10_000, positionSeconds: 0, durationSeconds: 8,
+    bufferedAheadSeconds: 8, bufferLimitSeconds: 8, reserveSeconds: 0, lookaheadSeconds: 8,
+    sources: [{ id: "source", complete: true }],
+    linkReadings: [{ at: 10_000, value: 80 }],
+    tracks: [{ id: "video", sourceIds: ["source"], processedSeconds: 8,
+      bitsPerMediaSecond: 80, readings: [{ at: 10_000, value: 2 }],
+      readySegmentIndices: [0, 1], segmentSizesBytes: new Map([[0, 40], [1, 40]]),
+      clientRanges, segments: [{ index: 0, startSeconds: 0, endSeconds: 4 },
+        { index: 1, startSeconds: 4, endSeconds: 8 }] }]
+  };
+}
+
+test("future browser ranges are retained rather than transferred again", () => {
+  const forecast = predictPlaybackReadiness(state([{ start: 4, end: 8 }]));
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Math.abs(forecast.delaySeconds - 4) < 1e-8);
+});
+
+test("a real media hole is not hidden by the scalar buffer or ready file count", () => {
+  const input = state([{ start: 0, end: 3 }, { start: 4, end: 8 }]);
+  input.tracks[0].segments[0].mediaRanges = [{ start: 0, end: 3 }];
+  const forecast = predictPlaybackReadiness(input);
+  assert.equal(forecast.ready, false);
+  assert.equal(forecast.bufferedSeconds, 3);
+  assert.equal(forecast.reason, "no-safe-start-found");
+});
+
+test("missing work before global progress can still be produced", () => {
+  const input = state([]);
+  input.tracks[0].readySegmentIndices = [1];
+  const forecast = predictPlaybackReadiness(input);
+  assert.equal(forecast.reason, "minimum-safe-delay");
+  assert.ok(Number.isFinite(forecast.delaySeconds));
+});

package/test/segment-store.test.js

@@ -113,7 +113,7 @@ test("a piece still being written is not a piece, and its name says so", (t) =>
   assert.equal(store.pathOf(KEY, 1), null);
 
   // And closing it is one rename, after which it is servable.
-  assert.equal(store.publish(KEY, "making-0-00001.mp4", fmp4Format), "segment-00001.mp4");
+  assert.equal(store.publish(KEY, "making-0-00001.mp4", { ...fmp4Format, readMediaRanges: undefined }), "segment-00001.mp4");
   assert.equal(store.isClosed(KEY, 1), true);
 });