@torrent-tv/proxy 2.87.14 → 2.87.16

package/services/server/playback-readiness.js

@@ -6,14 +6,15 @@
  * measurements and physical limits: source bytes and download rate, encoded
  * media and encoder rate, segment sizes and client-link rate, the existing
  * browser buffer, its capacity, the proxy look-ahead, and the measured reserve
- * for interruptions. Rates are extrapolated from their measured linear trend;
- * there are no fitted weights or rate multipliers.
+ * for interruptions. A measured rate relaxes toward the lower of its latest
+ * value and its observed mean over the measurement span. Its integral remains
+ * unbounded for a positive measured rate; an old slope cannot invent a permanent
+ * cessation of service. There are no fitted weights or rate multipliers.
  */
 
 /**
- * The mean rate predicted over a horizon by the trend in all supplied
- * measurements. With no trend this is the measured rate. The regression treats
- * every measurement equally.
+ * The mean rate predicted over a horizon by the integral of the measured rate.
+ * Every supplied measurement contributes equally to the observed mean.
  *
  * @param {Array<{ at: number, value: number }>} readings
  * @param {number} now
@@ -30,48 +31,36 @@ export function forecastRate(readings, now = Date.now(), horizonSeconds = 0) {
 }
 
 /**
- * Constant-space measurements for one rate trend. Linear regression can be
- * evaluated from these sums without retaining every poll for the life of a
- * film.
+ * Measurements over the output's existing look-ahead horizon. The oldest
+ * boundary sample is retained until another sample replaces it, so a repeated
+ * report never changes the history or invents a new measurement.
  */
 export class RateTrend {
-  #originAt = null;
-  #lastAt = null;
-  #count = 0;
-  #sumTime = 0;
-  #sumTimeSquared = 0;
-  #sumValue = 0;
-  #sumTimeValue = 0;
+  #readings = [];
+  #horizonMs;
+
+  constructor(horizonSeconds = Number.POSITIVE_INFINITY) {
+    this.#horizonMs = Math.max(0, horizonSeconds) * 1000;
+  }
 
   add(at, value) {
     if (!Number.isFinite(at) || !Number.isFinite(value) || value < 0 ||
-      (this.#lastAt !== null && at <= this.#lastAt)) {
+      at <= (this.#readings.at(-1)?.at ?? Number.NEGATIVE_INFINITY)) {
       return false;
     }
-    this.#originAt ??= at;
-    const elapsed = (at - this.#originAt) / 1000;
-    this.#count += 1;
-    this.#sumTime += elapsed;
-    this.#sumTimeSquared += elapsed ** 2;
-    this.#sumValue += value;
-    this.#sumTimeValue += elapsed * value;
-    this.#lastAt = at;
+    this.#readings.push({ at, value });
+    const cutoff = at - this.#horizonMs;
+    while (this.#readings.length > 1 && this.#readings[1].at <= cutoff) {
+      this.#readings.shift();
+    }
     return true;
   }
 
   snapshot() {
-    if (this.#count === 0) {
+    if (this.#readings.length === 0) {
       return null;
     }
-    return {
-      count: this.#count,
-      originAt: this.#originAt,
-      lastAt: this.#lastAt,
-      sumTime: this.#sumTime,
-      sumTimeSquared: this.#sumTimeSquared,
-      sumValue: this.#sumValue,
-      sumTimeValue: this.#sumTimeValue
-    };
+    return summarizeRate(this.#readings);
   }
 }
 
@@ -96,14 +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 capacity = finiteNonNegative(input.bufferLimitSeconds);
+  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),
+    ...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]));
@@ -123,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,
@@ -166,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;
@@ -179,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";
@@ -237,32 +240,6 @@ export function predictPlaybackReadiness(input = {}) {
     }
   }
 
-  const rateRecoveryDelays = [];
-  const sourceDemandByService = new Map();
-  for (const sourceId of new Set(jobs.flatMap(({ sourceIntervals }) => [...sourceIntervals.keys()]))) {
-    const source = sourceState.get(sourceId);
-    const demand = sourceDemandByService.get(source.serviceId) ?? new Map();
-    demand.set(sourceId, Number(source.source.bytesPerMediaSecond));
-    sourceDemandByService.set(source.serviceId, demand);
-  }
-  for (const [serviceId, demandBySource] of sourceDemandByService) {
-    const demand = [...demandBySource.values()].reduce((sum, value) => sum + value, 0);
-    rateRecoveryDelays.push(downloadServices.get(serviceId).curve.timeAtLeast(demand));
-  }
-  for (const { track, curve } of trackState) {
-    if (jobs.some((job) => job.track === track && !job.produced)) {
-      rateRecoveryDelays.push(curve.timeAtLeast(1));
-    }
-  }
-  const linkDemand = trackState.reduce((sum, { track, bitsPerMediaSecond }) =>
-    sum + (jobs.some((job) => job.track === track) ? bitsPerMediaSecond : 0), 0);
-  if (linkDemand > 0) {
-    rateRecoveryDelays.push(link.timeAtLeast(linkDemand));
-  }
-  const rateRecoveryDelay = rateRecoveryDelays
-    .filter(Number.isFinite)
-    .reduce((latest, delay) => Math.max(latest, delay), 0);
-
   jobs.sort((left, right) => left.segment.startSeconds - right.segment.startSeconds ||
     left.segment.endSeconds - right.segment.endSeconds || left.trackIndex - right.trackIndex);
 
@@ -353,6 +330,7 @@ export function predictPlaybackReadiness(input = {}) {
     return { safe: safety.safe,
       bufferedAtStart: safety.bufferedAtStart,
       neededSeconds: safety.neededSeconds,
+      completionTimes: usefulCompletions.map(({ at }) => at),
       finishAt: usefulCompletions.reduce((latest, item) => Math.max(latest, item.at), 0) };
   };
 
@@ -366,7 +344,7 @@ export function predictPlaybackReadiness(input = {}) {
   if (immediate.safe) {
     return result(true, 0, buffered, reserve, 0, "trajectory-safe-now", preparedSegments);
   }
-  const searchLimit = Math.max(maximumUsefulDelay, rateRecoveryDelay);
+  const searchLimit = maximumUsefulDelay;
   if (!(searchLimit > 0)) {
     return result(false, null, buffered, reserve, null, "no-safe-start-found", preparedSegments);
   }
@@ -376,7 +354,7 @@ export function predictPlaybackReadiness(input = {}) {
   const breakpoints = [...new Set([
     maximumUsefulDelay,
     searchLimit,
-    ...rateRecoveryDelays.filter(Number.isFinite)
+    ...prefillSchedule.completionTimes
   ])]
     .filter((delay) => delay > 0 && delay <= searchLimit)
     .sort((left, right) => left - right);
@@ -412,17 +390,9 @@ export function predictPlaybackReadiness(input = {}) {
 
 function rateCurve(readings, now) {
   if (readings && Number.isFinite(readings.count) && readings.count > 0 &&
-    Number.isFinite(readings.originAt) && Number.isFinite(readings.lastAt) &&
-    Number.isFinite(readings.sumTime) && Number.isFinite(readings.sumTimeSquared) &&
-    Number.isFinite(readings.sumValue) && Number.isFinite(readings.sumTimeValue)) {
-    const { count, originAt, sumTime, sumTimeSquared, sumValue, sumTimeValue } = readings;
-    const meanAt = sumTime / count;
-    const meanValue = sumValue / count;
-    const denominator = sumTimeSquared - count * meanAt ** 2;
-    const numerator = sumTimeValue - count * meanAt * meanValue;
-    const slope = denominator > 0 ? numerator / denominator : 0;
-    const current = Math.max(0, meanValue + slope * ((now - originAt) / 1000 - meanAt));
-    return rateCurveFrom(current, slope);
+    Number.isFinite(readings.lastAt) && Number.isFinite(readings.lastValue) &&
+    Number.isFinite(readings.meanValue) && Number.isFinite(readings.spanSeconds)) {
+    return rateCurveFrom(readings, now);
   }
   const ordered = (Array.isArray(readings) ? readings : [])
     .filter((reading) => Number.isFinite(reading?.at) && Number.isFinite(reading?.value) && reading.value >= 0)
@@ -433,71 +403,70 @@ function rateCurve(readings, now) {
     return null;
   }
 
-  const points = ordered.map((reading) => ({
-    at: (reading.at - now) / 1000,
-    value: reading.value
-  }));
-  const meanAt = points.reduce((sum, point) => sum + point.at, 0) / points.length;
-  const meanValue = points.reduce((sum, point) => sum + point.value, 0) / points.length;
-  const numerator = points.reduce((sum, point) =>
-    sum + (point.at - meanAt) * (point.value - meanValue), 0);
-  const denominator = points.reduce((sum, point) =>
-    sum + (point.at - meanAt) ** 2, 0);
-  const slope = denominator > 0 ? numerator / denominator : 0;
-  const current = Math.max(0, meanValue - slope * meanAt);
-  return rateCurveFrom(current, slope);
+  return rateCurveFrom(summarizeRate(ordered), now);
 }
 
-function rateCurveFrom(current, slope) {
-  const zeroAt = slope < 0 ? -current / slope : Number.POSITIVE_INFINITY;
-
-  const workBy = (seconds) => {
-    const span = Math.min(Math.max(0, seconds), zeroAt);
-    return Math.max(0, current * span + (slope * span ** 2) / 2);
-  };
-  const timeFor = (work) => {
-    if (!(work > 0)) {
-      return 0;
-    }
-    if (!(current > 0) && !(slope > 0)) {
-      return Number.POSITIVE_INFINITY;
-    }
-    const discriminant = current ** 2 + 2 * slope * work;
-    if (discriminant < 0) {
-      return Number.POSITIVE_INFINITY;
-    }
-    if (slope < 0 && work > workBy(zeroAt)) {
-      return Number.POSITIVE_INFINITY;
-    }
-    if (slope === 0) {
-      return current > 0 ? work / current : Number.POSITIVE_INFINITY;
-    }
-    const root = Math.sqrt(discriminant);
-    const denominator = current + root;
-    return denominator > 0 ? (2 * work) / denominator : Number.POSITIVE_INFINITY;
+function summarizeRate(readings) {
+  const latest = readings.at(-1);
+  return {
+    count: readings.length,
+    lastAt: latest.at,
+    lastValue: latest.value,
+    meanValue: readings.reduce((sum, reading) => sum + reading.value, 0) / readings.length,
+    spanSeconds: (latest.at - readings[0].at) / 1000
   };
+}
+
+function rateCurveFrom({ lastAt, lastValue, meanValue, spanSeconds }, now) {
+  const baseline = Math.max(0, Math.min(lastValue, meanValue));
+  const span = Math.max(Number.EPSILON, spanSeconds);
+  const age = Math.max(0, (now - lastAt) / 1000);
+  const excess = Math.max(0, lastValue - baseline) * Math.exp(-age / span);
+  // r(t) = baseline + excess * exp(-t/span).
+  // W(t) = integral(0..t, r(u)du). Positive measured service has no finite
+  // total-work ceiling merely because an old sample was faster.
+  const workBy = (seconds) => rateIntegral(Math.max(0, seconds), baseline, excess, span);
   return {
-    timeAtLeast: (target) => {
-      if (!Number.isFinite(target) || target < 0) {
-        return Number.POSITIVE_INFINITY;
-      }
-      if (current >= target) {
-        return 0;
-      }
-      return slope > 0 ? (target - current) / slope : Number.POSITIVE_INFINITY;
-    },
-    rateAt: (seconds) => Math.max(0, current + slope * Math.min(Math.max(0, seconds), zeroAt)),
+    rateAt: (seconds) => baseline + excess * Math.exp(-Math.max(0, seconds) / span),
     workBy,
     finish: (work, startAt) => {
-      if (!(work > 0)) {
-        return Math.max(0, startAt);
-      }
       const start = Math.max(0, startAt);
-      return start + (timeFor(work + workBy(start)) - start);
+      return start + invertRateIntegral(Math.max(0, work), baseline,
+        excess * Math.exp(-start / span), span);
     }
   };
 }
 
+function rateIntegral(seconds, baseline, excess, span) {
+  return baseline * seconds - excess * span * Math.expm1(-seconds / span);
+}
+
+/** Invert the strictly increasing service integral, with no playback rule. */
+function invertRateIntegral(work, baseline, excess, span) {
+  if (work === 0) {
+    return 0;
+  }
+  if (!(baseline > 0) || !Number.isFinite(work)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  let low = 0;
+  let high = work / baseline;
+  if (excess === 0) {
+    return high;
+  }
+  while (true) {
+    const middle = (low + high) / 2;
+    if (middle === low || middle === high) {
+      return high;
+    }
+    if (rateIntegral(middle, baseline, excess, span) >= work) {
+      high = middle;
+    } else {
+      low = middle;
+    }
+  }
+}
+
 function averageBitsPerMediaSecond(track, segments, ready) {
   let bits = 0;
   let mediaSeconds = 0;
@@ -522,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);
@@ -545,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;
     }
   };
@@ -560,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);
@@ -590,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);
@@ -641,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);
   }
 }