@torrent-tv/proxy 2.98.0 → 2.98.1

package/package.json

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

package/services/encode/EncodePlan.js

@@ -991,47 +991,64 @@ function lastOf(windows) {
 
 function deadlineReaderFor(windows, segmentSeconds) {
   const perSegment = segmentSeconds > 0 ? segmentSeconds : 0;
-  return (index) => {
-    let soonest = Number.POSITIVE_INFINITY;
-    for (const span of windows) {
-      if (index < span.from || index > span.to) {
-        continue;
-      }
-      const stated = /** @type {{ withinSeconds?: number }} */ (span).withinSeconds;
-      // A stretch stated with no time is somebody waiting at its near edge: that
-      // is what stating one means. The rest of it grows with the distance, the
-      // same as a stated one — read as due all at once instead, a window as wide
-      // as a viewer's cushion demanded its far end instantly and bought an
-      // encoder to stand beside one already working.
-      // `null` IS A STATEMENT AND IT SAYS NOBODY IS COMING. `undefined` is the
-      // absence of one, and a caller that knows only a position is somebody
-      // waiting at it.
-      //
-      // Read through `Number()`, `null` becomes 0 — due NOW — so the film BEHIND
-      // the viewers, which the map marks with exactly that, was the most urgent
-      // material in the file. Everything followed from it: it bought encoders,
-      // it took the run standing in front of the viewer because that run was the
-      // nearest encoder to it, and it did so again on every pass. Field 2026-09-08:
-      // 39 moves in one session, 24 between three adjacent numbers, one viewer
-      // on three encoders, and the picture stood still for 116.7 s in three
-      // interruptions, the worst of them 91.8 s.
-      //
-      // The map has always said it plainly — `{"from":0,"to":57,"priority":1,
-      // "withinSeconds":null,"behind":true}` is in the log of every session — and
-      // this line turned it into its opposite. Fourth time in this repository
-      // that the input to a calculation was not what the calculation assumed.
-      const within = stated === undefined ? 0 : (stated === null ? Number.NaN : Number(stated));
-      if (!Number.isFinite(within)) {
-        // Stated as no time at all: nobody is coming here.
-        continue;
-      }
+  // A TABLE BY SEGMENT, filled once per plan. Read for every segment of every
+  // arrangement the plan weighs, a search of every window for each index was
+  // the plan's own walk times the windows (r26, torrent-tv/meta#178). Filled
+  // span by span with the same rule, the soonest of overlapping spans kept.
+  let last = -1;
+  for (const span of windows) {
+    if (Number.isFinite(span.to) && span.to > last) last = Math.floor(span.to);
+  }
+  const table = new Float64Array(last + 1).fill(Number.POSITIVE_INFINITY);
+  for (const span of windows) {
+    const within = withinOf(span);
+    if (!Number.isFinite(within)) {
+      // Stated as no time at all: nobody is coming here.
+      continue;
+    }
+    for (let index = Math.max(0, Math.ceil(span.from)); index <= span.to; index += 1) {
       const here = within + (index - span.from) * perSegment;
-      if (here < soonest) {
-        soonest = here;
+      if (here < table[index]) {
+        table[index] = here;
       }
     }
-    return soonest;
-  };
+  }
+  return (index) => (index >= 0 && index < table.length ? table[index] : Number.POSITIVE_INFINITY);
+}
+
+/**
+ * When a window is first needed, in seconds from now: NaN where it says nobody
+ * is coming.
+ *
+ * A stretch stated with no time is somebody waiting at its near edge: that
+ * is what stating one means. The rest of it grows with the distance, the
+ * same as a stated one — read as due all at once instead, a window as wide
+ * as a viewer's cushion demanded its far end instantly and bought an
+ * encoder to stand beside one already working.
+ * `null` IS A STATEMENT AND IT SAYS NOBODY IS COMING. `undefined` is the
+ * absence of one, and a caller that knows only a position is somebody
+ * waiting at it.
+ *
+ * Read through `Number()`, `null` becomes 0 — due NOW — so the film BEHIND
+ * the viewers, which the map marks with exactly that, was the most urgent
+ * material in the file. Everything followed from it: it bought encoders,
+ * it took the run standing in front of the viewer because that run was the
+ * nearest encoder to it, and it did so again on every pass. Field 2026-09-08:
+ * 39 moves in one session, 24 between three adjacent numbers, one viewer
+ * on three encoders, and the picture stood still for 116.7 s in three
+ * interruptions, the worst of them 91.8 s.
+ *
+ * The map has always said it plainly — `{"from":0,"to":57,"priority":1,
+ * "withinSeconds":null,"behind":true}` is in the log of every session — and
+ * that reading turned it into its opposite. Fourth time in this repository
+ * that the input to a calculation was not what the calculation assumed.
+ *
+ * @param {WantedSpan} span
+ * @returns {number}
+ */
+function withinOf(span) {
+  const stated = /** @type {{ withinSeconds?: number }} */ (span).withinSeconds;
+  return stated === undefined ? 0 : (stated === null ? Number.NaN : Number(stated));
 }
 
 /**

package/services/encode/output/Timeline.js

@@ -156,8 +156,8 @@ export class Timeline {
    * It lived in the session manager, which is a place, not a layer. Here it is
    * beside the table it converts against.
    *
-   * @param {import("../../viewer/PriorityMap.js").PriorityMap} map - One number
-   *   per second of film.
+   * @param {import("../../viewer/PriorityMap.js").PriorityMap} map - What every
+   *   viewer of this output wants, in seconds of film.
    * @param {number} segmentCount - How many pieces this output has.
    * @param {{ runsPastEnd?: boolean }} [shape] - `runsPastEnd`: the output's
    *   pieces copy a stream, which is cut where its packets end, so a piece
@@ -188,22 +188,10 @@ export class Timeline {
       const until = index + 1 < segmentCount
         ? Math.max(from + 1, runsPastEnd ? Math.floor(end) + 1 : Math.ceil(end))
         : map.durationSeconds;
-      let priority = 0;
-      let withinSeconds = Number.POSITIVE_INFINITY;
-      let behind = true;
-      let urgent = false;
-      for (let second = from; second < until && second < map.durationSeconds; second += 1) {
-        if (map.priority[second] > priority) {
-          priority = map.priority[second];
-        }
-        if (map.secondsUntilPlayed[second] < withinSeconds) {
-          withinSeconds = map.secondsUntilPlayed[second];
-        }
-        if (map.behind[second] === 0) {
-          behind = false;
-        }
-        if (map.urgent?.[second]) urgent = true;
-      }
+      // Asked of the map for the piece's seconds as a whole, not second by
+      // second: a walk of every second of the film for every output on every
+      // plan (torrent-tv/meta#178).
+      const { priority, withinSeconds, behind, urgent } = map.on(from, until);
       if (priority === 0) {
         continue;
       }

package/services/viewer/DownloadMaps.js

@@ -39,6 +39,7 @@ export class DownloadMaps {
     const now = Date.now();
     file.sourceZones = zones.map(zone => Number.isFinite(zone.deadlineAt) || !Number.isFinite(zone.withinSeconds)
       ? zone : { ...zone, deadlineAt: now + Math.max(0, zone.withinSeconds) * 1000 });
+    const sourceZones = zoneIndexOf(file);
     let changed = false;
     // Until the new zones are resolved to bytes, a resolved zone stays while
     // the film it covers is still wanted. A viewer moving on re-cuts every zone
@@ -49,9 +50,9 @@ export class DownloadMaps {
     // a seek away — is withdrawn at once.
     const retained = file.zones.flatMap(zone => {
       const interval = zone.downloadInterval ?? zone;
-      const current = file.sourceZones.find(candidate => candidate.from === interval.from && candidate.to === interval.to);
+      const current = sourceZones.exactly(interval);
       if (!current) {
-        const stillWanted = file.sourceZones.some(candidate => candidate.from < interval.to && interval.from < candidate.to);
+        const stillWanted = sourceZones.overlaps(interval);
         if (!stillWanted) changed = true;
         return stillWanted ? [zone] : [];
       }
@@ -76,7 +77,7 @@ export class DownloadMaps {
         changed = true;
       }
       else if (metadata.interval) {
-        const current = file.sourceZones.find(zone => zone.from === metadata.interval.from && zone.to === metadata.interval.to);
+        const current = sourceZones.exactly(metadata.interval);
         const deadlineAt = Number.isFinite(current.deadlineAt) ? current.deadlineAt - metadata.leadSeconds * 1000 : current.deadlineAt;
         if (metadata.priority !== current.priority || metadata.urgent !== current.urgent || metadata.deadlineAt !== deadlineAt) changed = true;
         metadata.priority = current.priority;
@@ -147,7 +148,8 @@ export class DownloadMaps {
   }
 
   wantsInterval(sourceKey, fileIndex, { from, to }) {
-    return this.#files.get(`${sourceKey}:${fileIndex}`)?.sourceZones.some(zone => zone.from === from && zone.to === to) ?? false;
+    const file = this.#files.get(`${sourceKey}:${fileIndex}`);
+    return Boolean(file && zoneIndexOf(file).exactly({ from, to }));
   }
 
   metadata({ sourceKey, fileIndex, statement, result, priority = 100, urgent = true, deadlineAt = 0, interval, leadSeconds = 0, scope = "playback", order = 0 }) {
@@ -155,7 +157,7 @@ export class DownloadMaps {
     const file = this.#file(sourceKey, fileIndex);
     if (result.kind === "needs-ranges") {
       if (interval && !this.wantsInterval(sourceKey, fileIndex, interval)) return Promise.resolve();
-      const current = interval && file.sourceZones.find(zone => zone.from === interval.from && zone.to === interval.to);
+      const current = interval && zoneIndexOf(file).exactly(interval);
       if (current) {
         priority = current.priority;
         urgent = current.urgent;
@@ -372,6 +374,60 @@ export class DownloadMaps {
   }
 }
 
+/**
+ * The map zones of one statement, looked up by interval.
+ *
+ * Every zone kept from the last pass asks which zone of the new map it belongs
+ * to, by its exact interval, and if none, whether any new zone still overlaps
+ * it — a search of every new zone for every kept one, thousands by tens on
+ * every statement over a film (r26, torrent-tv/meta#178). The exact match is
+ * a table, and the overlap a binary search over the zones, which a map states
+ * ascending and apart; zones in any other order are searched as before.
+ */
+class ZoneIndex {
+  /** The list indexed: replaced whole, never edited in place, so it says whether the index is current. */
+  zones;
+  #byInterval = new Map();
+  #ordered = true;
+
+  /** @param {Array<{ from: number, to: number }>} zones */
+  constructor(zones) {
+    this.zones = zones;
+    zones.forEach((zone, index) => {
+      const key = `${zone.from}:${zone.to}`;
+      // The first of equals, as a search from the start would find.
+      if (!this.#byInterval.has(key)) this.#byInterval.set(key, zone);
+      if (index > 0 && !(zone.from >= zones[index - 1].to)) this.#ordered = false;
+    });
+  }
+
+  /** The zone with exactly this interval. @param {{ from: number, to: number }} interval */
+  exactly({ from, to }) {
+    return this.#byInterval.get(`${from}:${to}`);
+  }
+
+  /** Whether any zone overlaps this interval. @param {{ from: number, to: number }} interval */
+  overlaps({ from, to }) {
+    const zones = this.zones;
+    if (!this.#ordered) return zones.some(zone => zone.from < to && from < zone.to);
+    // The first zone that ends after `from`; it overlaps if it begins before `to`.
+    let low = 0;
+    let high = zones.length;
+    while (low < high) {
+      const middle = (low + high) >> 1;
+      if (zones[middle].to <= from) low = middle + 1;
+      else high = middle;
+    }
+    return low < zones.length && zones[low].from < to;
+  }
+}
+
+/** The index of a file's map zones, made again when they have been replaced. */
+function zoneIndexOf(file) {
+  if (file.sourceIndex?.zones !== file.sourceZones) file.sourceIndex = new ZoneIndex(file.sourceZones);
+  return file.sourceIndex;
+}
+
 /**
  * Zones resolved so far, with the retained zones of every segment they do not
  * yet resolve again: a segment's bytes are stated once, by its newest reading.

package/services/viewer/NativeSourceMap.js

@@ -15,7 +15,7 @@ export async function nativeOriginalSourceMap({ container, viewers, durationSeco
     const input = await container.readMappedSourceRanges({ from: zone.from + startTimeSeconds,
       to: Math.min(durationSeconds, zone.to) + startTimeSeconds });
     if (input.kind !== "result") continue;
-    const links = viewers.filter((_viewer, index) => maps[index].priority[zone.from] === zone.priority)
+    const links = viewers.filter((_viewer, index) => maps[index].at(zone.from).priority === zone.priority)
       .map(viewer => viewer.linkReading()?.linkMbps).filter(rate => Number.isFinite(rate) && rate > 0);
     const bytes = input.ranges.reduce((sum, [start, end]) => sum + end - start + 1, 0);
     const deliverySeconds = links.length ? bytes * 8 / (Math.min(...links) * 1_000_000) : 0;
@@ -46,7 +46,7 @@ export function nativeSourceMap({ index, tracks, viewers, durationSeconds, start
       const input = index.inputFor({ trackId: track.trackNumber, from, to });
       if (input.kind === "needs-index") continue;
       if (input.kind !== "result") throw new Error(`Native source input refused: ${input.reason}`);
-      const links = viewers.filter((_viewer, viewerIndex) => maps[viewerIndex].priority[zone.from] === zone.priority)
+      const links = viewers.filter((_viewer, viewerIndex) => maps[viewerIndex].at(zone.from).priority === zone.priority)
         .map(viewer => viewer.linkReading()?.linkMbps).filter(rate => Number.isFinite(rate) && rate > 0);
       const bytes = input.ranges.reduce((sum, [start, end]) => sum + end - start + 1, 0);
       const deliverySeconds = links.length ? bytes * 8 / (Math.min(...links) * 1_000_000) : 0;

package/services/viewer/PriorityMap.js

@@ -44,34 +44,45 @@
  */
 
 /**
- * THE MAP ITSELF: one number per second of film.
- *
- * Literally an array as long as the film, where the value at second `x` says how
- * urgently that second is wanted. Stated by the user 2026-09-06, and it replaced
- * a list of stretches each carrying two numbers.
- *
- * Two arrays rather than one, because two different questions are asked of the
- * map and only one of them can be answered by a rank:
+ * THE MAP ITSELF: what each viewer wants, kept as the rules that say it, and
+ * answered for a second, for a stretch, or as the stretches of one value.
+ *
+ * The rules are the ones the map has had since 2026-09-06, when an array of one
+ * number per second of film replaced a list of stretches: a priority for every
+ * second, the time until a viewer plays it, and whether it lies behind every
+ * viewer, is wanted before playback can continue, or has been yielded by a
+ * viewer who stopped. What changed (torrent-tv/meta#178) is only how they are
+ * held. Every one of those values is a step function of the distance from a
+ * viewer, with steps the rules themselves place — where the viewer stands, the
+ * end of the urgent allowance, the doubling bands of priority — and the time is
+ * that distance. Built as arrays the length of the film, a map cost a pass over
+ * every second for every viewer and again for the merge, on every move of a
+ * viewer: on Home Assistant the main thread built them 21-61 times a minute
+ * over a two-hour film (r26). Held as rules, a question costs what the viewers
+ * and their steps cost, and nothing per second of film.
+ *
+ * Two different questions are asked of the map and only one of them can be
+ * answered by a rank:
  *
  * - `priority` orders the work. Only the ORDER between values is meaningful;
  *   the scale below says what the numbers separate;
- * - `secondsUntilPlayed` is a quantity, and it is what makes lateness
- *   computable at all: whoever fills the map compares "when is this needed"
- *   against "when would it arrive", and only the second half is theirs to work
- *   out. `Infinity` where nobody is on their way.
- *
- * @typedef {object} PriorityMap
- * @property {number} durationSeconds - The film's length, in whole seconds.
- * @property {Uint8Array} priority - One entry per second. Zero means nothing is
- *   wanted there, which happens only where nobody is watching at all.
- * @property {Float64Array} secondsUntilPlayed - One entry per second.
- * @property {Uint8Array} behind - One entry per second, 1 where the second lies
- *   behind EVERY viewer. Stated rather than worked out from the other two,
- *   because working it out means knowing this file's scale, and the consumers
- *   are in other layers. Inferred from the absence of a time, as it was, it was
- *   wrong for a stopped viewer: their whole film carries no time, so the film in
- *   front of them counted as behind them and the encoders wandered to the start
- *   of the file.
+ * - the time until a second is played is a quantity, and it is what makes
+ *   lateness computable at all: whoever fills the map compares "when is this
+ *   needed" against "when would it arrive", and only the second half is theirs
+ *   to work out. `Infinity` where nobody is on their way.
+ *
+ * The merge keeps what it always did: the highest priority and the soonest
+ * time, taken separately — two viewers can tie on the coarse priority while one
+ * is genuinely nearer; in front of ANYBODY is in front; a second is urgent if
+ * any viewer needs it before playback can continue; and it is deferred only if
+ * every viewer in front of it has yielded it.
+ *
+ * @typedef {object} MapPoint
+ * @property {number} priority - Zero where nobody wants it.
+ * @property {number} untilSeconds - Seconds until a viewer plays it.
+ * @property {boolean} behind - Behind every viewer.
+ * @property {boolean} urgent
+ * @property {boolean} deferred
  */
 
 /**
@@ -87,6 +98,7 @@
  * @property {boolean} behind - Whether this lies behind every viewer.
  */
 
+
 /**
  * Wanted seconds use priorities 1..100. Distance lowers priority relative to
  * the measured urgent allowance. Pause preserves the same priorities until
@@ -167,28 +179,27 @@ function stepsAway(distanceSeconds, allowanceSeconds) {
   return Math.floor(Math.log2(1 + distanceSeconds / allowanceSeconds));
 }
 
+/** Where nothing is wanted. */
+const NO_DEMAND = Object.freeze({ priority: NOTHING, untilSeconds: Number.POSITIVE_INFINITY, behind: true, urgent: false, deferred: false });
+
 /**
- * An empty map of the right length: nothing wanted anywhere.
+ * The first whole distance whose step is at least `step`, worked out by the
+ * same arithmetic the step is read with, so a boundary is exactly where the
+ * value changes.
  *
- * @param {number} durationSeconds
- * @returns {PriorityMap}
+ * @param {number} step
+ * @param {number} allowanceSeconds
+ * @returns {number}
  */
-export function emptyMap(durationSeconds) {
-  const seconds = Number.isFinite(durationSeconds) && durationSeconds > 0
-    ? Math.ceil(durationSeconds)
-    : 0;
-  return {
-    durationSeconds: seconds,
-    priority: new Uint8Array(seconds),
-    secondsUntilPlayed: new Float64Array(seconds).fill(Number.POSITIVE_INFINITY),
-    behind: new Uint8Array(seconds).fill(1),
-    urgent: new Uint8Array(seconds),
-    deferred: new Uint8Array(seconds)
-  };
+function firstDistanceOfStep(step, allowanceSeconds) {
+  let distance = Math.ceil(allowanceSeconds * (2 ** step - 1));
+  while (distance > 0 && stepsAway(distance - 1, allowanceSeconds) >= step) distance -= 1;
+  while (stepsAway(distance, allowanceSeconds) < step) distance += 1;
+  return distance;
 }
 
 /**
- * One viewer's map.
+ * One viewer's demand: the rules of their map, with where they stand.
  *
  * **The number is a reading of how soon they will be there.** A viewer watching
  * forward reaches second `x` after `x - p` seconds of film. That distance — not
@@ -198,195 +209,303 @@ export function emptyMap(durationSeconds) {
  * Pause retains urgent preparation first. Once that work is ready, the
  * allowance / (allowance + pauseSeconds) coefficient gradually reduces this
  * viewer's priorities if others consume the file. Resume restores them.
- *
- * **What must NOT be here**, and the boundary is the point: how fast this
- * machine encodes, how many encoders that takes, what a second weighs in bytes,
- * where a piece boundary falls, and what has already been made. Those are
- * answers the encoding and the downloading work out for themselves, from this
- * map and from what each knows about itself.
- *
- * @param {object} params
- * @param {number} params.atSeconds - Where they are watching from.
- * @param {number} params.durationSeconds - How long the film is.
- * @param {number} params.allowanceSeconds - The measured depth below which an
- *   interruption reaches this viewer. The width of the first step.
- * @param {boolean} [params.playing] - Whether the picture is moving.
- * @returns {PriorityMap}
  */
-export function pauseCoefficient({ playing, urgentReady, viewerCount, pauseSeconds, allowanceSeconds }) {
-  if (playing !== false || !urgentReady || viewerCount <= 1) return 1;
-  const allowance = Number.isFinite(allowanceSeconds) && allowanceSeconds > 0 ? allowanceSeconds : 1;
-  const elapsed = Number.isFinite(pauseSeconds) ? Math.max(0, pauseSeconds) : 0;
-  return allowance / (allowance + elapsed);
-}
+class ViewerDemand {
+  /**
+   * @param {{ atSeconds: number, durationSeconds: number, allowanceSeconds: number, playing?: boolean,
+   *   pauseSeconds?: number, urgentReady?: boolean, viewerCount?: number }} params
+   */
+  constructor({ atSeconds, durationSeconds, allowanceSeconds, playing = true, pauseSeconds = 0, urgentReady = false, viewerCount = 1 }) {
+    this.durationSeconds = Number.isFinite(durationSeconds) && durationSeconds > 0 ? Math.ceil(durationSeconds) : 0;
+    this.at = Number.isFinite(atSeconds) && atSeconds > 0 ? Math.floor(atSeconds) : 0;
+    this.allowance = Number.isFinite(allowanceSeconds) && allowanceSeconds > 0 ? allowanceSeconds : this.durationSeconds;
+    // The measured urgent span is the time scale. There is no chosen decay
+    // period: one span on pause halves the excess above minimum priority.
+    this.attenuate = playing === false && urgentReady && viewerCount > 1;
+    this.elapsed = Number.isFinite(pauseSeconds) ? Math.max(0, pauseSeconds) : 0;
+    this.coefficient = pauseCoefficient({ playing, urgentReady, viewerCount, pauseSeconds: this.elapsed, allowanceSeconds: this.allowance });
+  }
 
-export function mapForViewer({ atSeconds, durationSeconds, allowanceSeconds, playing = true,
-  pauseSeconds = 0, urgentReady = false, viewerCount = 1 }) {
-  const map = emptyMap(durationSeconds);
-  if (map.durationSeconds === 0) {
-    return map;
+  /** The priority at a whole distance in front of the viewer. @param {number} distance */
+  priorityAt(distance) {
+    const priority = Math.max(NOBODY_IS_COMING, AT_A_WATCHING_VIEWER - stepsAway(distance, this.allowance));
+    return Math.max(NOBODY_IS_COMING, 1 + Math.floor((priority - 1) * this.coefficient));
   }
-  const at = Number.isFinite(atSeconds) && atSeconds > 0 ? Math.floor(atSeconds) : 0;
-  const allowance = Number.isFinite(allowanceSeconds) && allowanceSeconds > 0
-    ? allowanceSeconds
-    : map.durationSeconds;
-  const watching = playing !== false;
-  // The measured urgent span is the time scale. There is no chosen decay
-  // period: one span on pause halves the excess above minimum priority.
-  const attenuate = !watching && urgentReady && viewerCount > 1;
-  const elapsed = Number.isFinite(pauseSeconds) ? Math.max(0, pauseSeconds) : 0;
-  const coefficient = pauseCoefficient({ playing, urgentReady, viewerCount, pauseSeconds: elapsed, allowanceSeconds: allowance });
-  for (let second = 0; second < map.durationSeconds; second += 1) {
-    if (second < at) {
-      map.priority[second] = NOBODY_IS_COMING;
-      continue;
+
+  /**
+   * @param {number} second
+   * @returns {MapPoint | null} Null where the film does not reach.
+   */
+  pointAt(second) {
+    if (!(second >= 0 && second < this.durationSeconds)) return null;
+    if (second < this.at) {
+      return { priority: NOBODY_IS_COMING, untilSeconds: Number.POSITIVE_INFINITY, behind: true, urgent: false, deferred: false };
     }
-    map.behind[second] = 0;
-    const distance = second - at;
-    const priority = Math.max(NOBODY_IS_COMING, AT_A_WATCHING_VIEWER - stepsAway(distance, allowance));
-    map.priority[second] = Math.max(NOBODY_IS_COMING, 1 + Math.floor((priority - 1) * coefficient));
-    map.urgent[second] = distance < allowance && !attenuate ? 1 : 0;
-    map.deferred[second] = attenuate ? 1 : 0;
+    const distance = second - this.at;
     // Urgent preparation keeps its deadline during pause. After completion,
     // pause duration defers this viewer's work without altering other viewers.
-    map.secondsUntilPlayed[second] = distance + (attenuate ? elapsed : 0);
+    return { priority: this.priorityAt(distance), untilSeconds: distance + (this.attenuate ? this.elapsed : 0), behind: false,
+      urgent: distance < this.allowance && !this.attenuate, deferred: this.attenuate };
+  }
+
+  /** Every second where one of this viewer's values may change, inside the film. @returns {number[]} */
+  breaks() {
+    const breaks = [this.at, this.durationSeconds, this.at + Math.ceil(this.allowance)];
+    for (let step = 1; step < AT_A_WATCHING_VIEWER - NOBODY_IS_COMING; step += 1) {
+      const second = this.at + firstDistanceOfStep(step, this.allowance);
+      if (second >= this.durationSeconds) break;
+      breaks.push(second);
+    }
+    return breaks.filter(second => second > 0 && second <= this.durationSeconds);
   }
-  return map;
 }
 
 /**
- * Where viewers stand, read off a map: every second whose priority rises above
- * the second before it.
- *
- * A viewer's own map is highest where they stand and falls away in front of
- * them, so in a merged map each viewer's position is a step UP — the one place
- * a value is higher than the value just behind it. A viewer standing inside the
- * stretch somebody else is walking towards adds nothing that map does not
- * already ask for, and is not a step; neither is somebody behind everybody.
- *
- * Read by whoever orders work by where people are and must not know what a
- * viewer is — the subtitle walk reads the clusters at these times first.
- *
- * @param {PriorityMap | null | undefined} map
- * @returns {number[]} Seconds, ascending.
+ * Every viewer's demand on one film, merged: the map.
  */
-export function viewerStartsOn(map) {
-  const starts = [];
-  if (!map || !(map.durationSeconds > 0)) {
-    return starts;
+export class PriorityMap {
+  /** @type {ViewerDemand[]} */
+  #viewers;
+  /** The film between the breaks, each stretch with its value at its start; worked out once. */
+  #pieces = null;
+
+  /** @param {ViewerDemand[]} [viewers] */
+  constructor(viewers = []) {
+    this.#viewers = viewers.filter(viewer => viewer.durationSeconds > 0);
+    /** The film's length, in whole seconds. */
+    this.durationSeconds = this.#viewers.reduce((longest, viewer) => Math.max(longest, viewer.durationSeconds), 0);
+  }
+
+  /** The viewers' demands, for a merge. */
+  get viewers() {
+    return this.#viewers;
+  }
+
+  /**
+   * What is wanted at one second.
+   *
+   * @param {number} second
+   * @returns {MapPoint}
+   */
+  at(second) {
+    let priority = NOTHING;
+    let untilSeconds = Number.POSITIVE_INFINITY;
+    let behind = true;
+    let urgent = false;
+    let yieldedByAll = true;
+    for (const viewer of this.#viewers) {
+      const point = viewer.pointAt(second);
+      if (!point) continue;
+      if (point.priority > priority) priority = point.priority;
+      if (point.untilSeconds < untilSeconds) untilSeconds = point.untilSeconds;
+      if (!point.behind) {
+        // In front of ANYBODY is in front: a stretch one viewer has passed is
+        // still the film another is walking towards.
+        behind = false;
+        // Deferred only if every viewer needing this second has yielded it.
+        if (!point.deferred) yieldedByAll = false;
+      }
+      if (point.urgent) urgent = true;
+    }
+    if (priority === NOTHING) return NO_DEMAND;
+    return { priority, untilSeconds, behind, urgent, deferred: !behind && yieldedByAll };
+  }
+
+  /**
+   * What a stretch of seconds wants as a whole, taken as a piece made or not
+   * made whole is wanted: as much as its strongest second, as soon as its
+   * soonest one, in front of somebody if any second of it is, urgent if any
+   * second of it is.
+   *
+   * A viewer's priority does not rise with distance and their time rises a
+   * second a second, so the second of the stretch nearest to them answers both.
+   *
+   * @param {number} from - First second, inclusive.
+   * @param {number} to - Last second, exclusive.
+   * @returns {{ priority: number, withinSeconds: number, behind: boolean, urgent: boolean }}
+   *   Priority zero where nobody wants any of it.
+   */
+  on(from, to) {
+    let priority = NOTHING;
+    let withinSeconds = Number.POSITIVE_INFINITY;
+    let behind = true;
+    let urgent = false;
+    const pieces = this.#piecesOfFilm();
+    // The first stretch that ends after `from`.
+    let low = 0;
+    let high = pieces.length;
+    while (low < high) {
+      const middle = (low + high) >> 1;
+      if (pieces[middle].to <= from) low = middle + 1;
+      else high = middle;
+    }
+    for (let index = low; index < pieces.length && pieces[index].from < to; index += 1) {
+      const { from: start, point } = pieces[index];
+      if (point.priority === NOTHING) continue;
+      if (point.priority > priority) priority = point.priority;
+      // Inside a stretch every viewer in front stays in front and their time
+      // rises a second a second, so the soonest time rises with it.
+      const until = point.untilSeconds + (Math.max(from, start) - start);
+      if (until < withinSeconds) withinSeconds = until;
+      if (!point.behind) behind = false;
+      if (point.urgent) urgent = true;
+    }
+    return { priority, withinSeconds, behind, urgent };
   }
-  for (let second = 0; second < map.durationSeconds; second += 1) {
-    const value = map.priority[second];
-    const before = second === 0 ? NOBODY_IS_COMING : map.priority[second - 1];
-    if (value > before && value > NOBODY_IS_COMING) {
-      starts.push(second);
+
+  /** @returns {Array<{ from: number, to: number, point: MapPoint }>} */
+  #piecesOfFilm() {
+    if (this.#pieces) return this.#pieces;
+    const breaks = this.#breaks();
+    const pieces = [];
+    for (let index = 0; index + 1 < breaks.length; index += 1) {
+      pieces.push({ from: breaks[index], to: breaks[index + 1], point: this.at(breaks[index]) });
     }
+    this.#pieces = pieces;
+    return pieces;
+  }
+
+  /** Every second where a merged value may change, with 0 and the end, ascending. */
+  #breaks() {
+    const breaks = new Set([0, this.durationSeconds]);
+    for (const viewer of this.#viewers) for (const second of viewer.breaks()) breaks.add(second);
+    return [...breaks].filter(second => second >= 0 && second <= this.durationSeconds).sort((left, right) => left - right);
+  }
+
+  /**
+   * The map as stretches: runs of seconds that agree on everything but the
+   * time, ascending, without gaps or overlaps. Seconds nobody wants are left
+   * out.
+   *
+   * THE TIME OF A STRETCH IS THE TIME OF ITS NEAR EDGE. A stretch is met at its
+   * beginning, so its beginning is when it must exist; whoever needs the time
+   * of a second inside it walks forward from there, at a second of film per
+   * second, which is the same arithmetic that put the number here. Merging on
+   * the exact time as well would merge nothing at all: the time is the
+   * distance, so it differs at every second.
+   *
+   * @returns {DemandZone[]}
+   */
+  runs() {
+    /** @type {DemandZone[]} */
+    const runs = [];
+    for (const { from, to, point } of this.#piecesOfFilm()) {
+      if (point.priority === NOTHING) continue;
+      const previous = runs[runs.length - 1];
+      if (previous && previous.to === from && previous.priority === point.priority && previous.behind === point.behind &&
+        previous.urgent === point.urgent && previous.deferred === point.deferred) {
+        previous.to = to;
+        continue;
+      }
+      runs.push({ from, to, priority: point.priority, withinSeconds: point.untilSeconds, behind: point.behind,
+        urgent: point.urgent, deferred: point.deferred });
+    }
+    return runs;
+  }
+
+  /**
+   * Where viewers stand, read off the map: every second whose priority rises
+   * above the second before it.
+   *
+   * A viewer's own map is highest where they stand and falls away in front of
+   * them, so in a merged map each viewer's position is a step UP — the one place
+   * a value is higher than the value just behind it. A viewer standing inside the
+   * stretch somebody else is walking towards adds nothing that map does not
+   * already ask for, and is not a step; neither is somebody behind everybody.
+   *
+   * Read by whoever orders work by where people are and must not know what a
+   * viewer is — the subtitle walk reads the clusters at these times first.
+   *
+   * @returns {number[]} Seconds, ascending.
+   */
+  viewerStarts() {
+    const starts = [];
+    for (const second of this.#breaks()) {
+      if (second >= this.durationSeconds) continue;
+      const value = this.at(second).priority;
+      const before = second === 0 ? NOBODY_IS_COMING : this.at(second - 1).priority;
+      if (value > before && value > NOBODY_IS_COMING) starts.push(second);
+    }
+    return starts;
   }
-  return starts;
 }
 
 /**
- * Every viewer's map as one.
+ * A map with nothing in it, which says the same as nobody watching.
  *
- * The highest priority per second wins, and the soonest time: film two people
- * want is as urgent as the more urgent of them, and making it once serves both.
- * The two are taken separately on purpose — the priority is coarse, so two
- * viewers can tie on it while one is genuinely nearer, and whoever schedules
- * against the time must be given the nearer one.
+ * @returns {PriorityMap}
+ */
+export function emptyMap() {
+  return new PriorityMap([]);
+}
+
+/**
+ * How far a viewer's priorities are lowered while they pause beside other
+ * viewers: allowance / (allowance + pauseSeconds), once their urgent work is
+ * ready; 1 otherwise.
+ *
+ * @param {{ playing?: boolean, urgentReady?: boolean, viewerCount: number, pauseSeconds?: number, allowanceSeconds?: number }} params
+ * @returns {number}
+ */
+export function pauseCoefficient({ playing, urgentReady, viewerCount, pauseSeconds, allowanceSeconds }) {
+  if (playing !== false || !urgentReady || viewerCount <= 1) return 1;
+  const allowance = Number.isFinite(allowanceSeconds) && allowanceSeconds > 0 ? allowanceSeconds : 1;
+  const elapsed = Number.isFinite(pauseSeconds) ? Math.max(0, pauseSeconds) : 0;
+  return allowance / (allowance + elapsed);
+}
+
+/**
+ * One viewer's map.
  *
- * In front of ANYBODY is in front, and the third array says so directly.
+ * **What must NOT be here**, and the boundary is the point: how fast this
+ * machine encodes, how many encoders that takes, what a second weighs in bytes,
+ * where a piece boundary falls, and what has already been made. Those are
+ * answers the encoding and the downloading work out for themselves, from this
+ * map and from what each knows about itself.
+ *
+ * @param {object} params
+ * @param {number} params.atSeconds - Where they are watching from.
+ * @param {number} params.durationSeconds - How long the film is.
+ * @param {number} params.allowanceSeconds - The measured depth below which an
+ *   interruption reaches this viewer. The width of the first step.
+ * @param {boolean} [params.playing] - Whether the picture is moving.
+ * @param {number} [params.pauseSeconds]
+ * @param {boolean} [params.urgentReady]
+ * @param {number} [params.viewerCount]
+ * @returns {PriorityMap}
+ */
+export function mapForViewer(params) {
+  return new PriorityMap([new ViewerDemand(params)]);
+}
+
+/**
+ * Every viewer's map as one.
  *
  * @param {PriorityMap[]} maps
  * @returns {PriorityMap}
  */
 export function mergeMaps(maps) {
-  const all = (maps ?? []).filter((map) => map && map.durationSeconds > 0);
-  if (all.length === 0) {
-    return emptyMap(0);
-  }
-  const merged = emptyMap(Math.max(...all.map((map) => map.durationSeconds)));
-  merged.deferred.fill(1);
-  for (const map of all) {
-    for (let second = 0; second < map.durationSeconds; second += 1) {
-      if (map.priority[second] > merged.priority[second]) {
-        merged.priority[second] = map.priority[second];
-      }
-      if (map.secondsUntilPlayed[second] < merged.secondsUntilPlayed[second]) {
-        merged.secondsUntilPlayed[second] = map.secondsUntilPlayed[second];
-      }
-      // In front of ANYBODY is in front: a stretch one viewer has passed is
-      // still the film another is walking towards.
-      if (map.behind[second] === 0) {
-        merged.behind[second] = 0;
-      }
-      if (map.urgent?.[second]) merged.urgent[second] = 1;
-      // Deferred only if every viewer needing this second has yielded it.
-      if (map.behind[second] === 0 && !map.deferred?.[second]) merged.deferred[second] = 0;
-    }
-  }
-  for (let second = 0; second < merged.durationSeconds; second += 1) {
-    if (merged.behind[second]) merged.deferred[second] = 0;
-  }
-  return merged;
+  return new PriorityMap((maps ?? []).filter(Boolean).flatMap(map => map.viewers));
 }
 
 /**
- * The map as stretches: runs of seconds that agree on both numbers.
- *
- * A VIEW of the map, never a second copy of it. Consumers that work in ranges —
- * the swarm is asked for byte ranges, an encoder is given a stretch of pieces —
- * would otherwise each write this walk for themselves.
+ * The map as stretches (`PriorityMap.runs`).
  *
- * @param {PriorityMap} map
- * @returns {DemandZone[]} Ascending, without gaps or overlaps. Seconds nobody
- *   wants are left out.
+ * @param {PriorityMap | null | undefined} map
+ * @returns {DemandZone[]}
  */
 export function runsOf(map) {
-  /** @type {DemandZone[]} */
-  const runs = [];
-  if (!map || !(map.durationSeconds > 0)) {
-    return runs;
-  }
-  for (let second = 0; second < map.durationSeconds; second += 1) {
-    const priority = map.priority[second];
-    if (priority === NOTHING) {
-      continue;
-    }
-    const behind = map.behind[second] === 1;
-    const urgent = map.urgent?.[second] === 1;
-    const deferred = map.deferred?.[second] === 1;
-    const previous = runs[runs.length - 1];
-    if (
-      previous
-      && previous.to === second
-      && previous.priority === priority
-      && previous.behind === behind
-      && previous.urgent === urgent
-      && previous.deferred === deferred
-    ) {
-      previous.to = second + 1;
-      continue;
-    }
-    // THE TIME OF A STRETCH IS THE TIME OF ITS NEAR EDGE. A stretch is met at
-    // its beginning, so its beginning is when it must exist; whoever needs the
-    // time of a second inside it walks forward from there, at a second of film
-    // per second, which is the same arithmetic that put the number here.
-    //
-    // Merging on the exact time as well would merge nothing at all: the time is
-    // the distance, so it differs at every second, and the map came back as one
-    // stretch per second of film.
-    const withinSeconds = map.secondsUntilPlayed[second];
-    runs.push({
-      from: second,
-      to: second + 1,
-      priority,
-      withinSeconds,
-      behind,
-      urgent,
-      deferred
-    });
-  }
-  return runs;
+  return map ? map.runs() : [];
+}
+
+/**
+ * Where viewers stand on a map (`PriorityMap.viewerStarts`).
+ *
+ * @param {PriorityMap | null | undefined} map
+ * @returns {number[]}
+ */
+export function viewerStartsOn(map) {
+  return map ? map.viewerStarts() : [];
 }
 
 /**

package/services/viewer/segment-demands.js

@@ -11,10 +11,27 @@ export function segmentDemands(output, fileIndex, zones) {
   const grid = output.timeline?.published ?? output.timeline?.boundaries;
   if (!Array.isArray(grid)) return [];
   const demands = [];
+  // THE ZONES ARE WALKED BESIDE THE SEGMENTS, not searched for each of them.
+  // A map's zones come ascending and apart (`PriorityMap.runs`) and the grid is
+  // ascending, so the zones a segment overlaps begin at or after those of the
+  // segment before it. Every zone filtered for every segment was thousands of
+  // segments by tens of zones on every pass over a film (r26,
+  // torrent-tv/meta#178). Zones in any other order are filtered as before.
+  const ordered = ascendingAndApart(zones);
+  let first = 0;
   for (let index = 0; index + 1 < grid.length; index++) {
     const from = grid[index], to = grid[index + 1];
     if (!Number.isFinite(from) || !Number.isFinite(to) || !(to > from)) throw new Error("An output segment needs a valid interval.");
-    const overlapping = zones.filter(zone => zone.priority > 0 && zone.from < to && zone.to > from);
+    let overlapping;
+    if (ordered) {
+      while (first < zones.length && zones[first].to <= from) first += 1;
+      overlapping = [];
+      for (let at = first; at < zones.length && zones[at].from < to; at += 1) {
+        if (zones[at].priority > 0) overlapping.push(zones[at]);
+      }
+    } else {
+      overlapping = zones.filter(zone => zone.priority > 0 && zone.from < to && zone.to > from);
+    }
     if (!overlapping.length) continue;
     // A zone states the deadline of its near edge. A later segment within it
     // is reached later, at one second of film per second of playback.
@@ -31,6 +48,14 @@ export function segmentDemands(output, fileIndex, zones) {
   return demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
 }
 
+/** Whether zones come ascending and without overlaps, as a map's runs do. */
+function ascendingAndApart(zones) {
+  for (let index = 1; index < zones.length; index += 1) {
+    if (!(zones[index].from >= zones[index - 1].to)) return false;
+  }
+  return true;
+}
+
 /** Source bytes must arrive before measured processing and delivery consume time. */
 export function sourceDeadline(demand, { encodeSpeed, outputBytes, linkMbps }) {
   const span = demand.to - demand.from;