@torrent-tv/proxy 2.98.0 → 2.98.2

package/package.json

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

package/server.js

@@ -437,44 +437,55 @@ export async function startProxyServer({
   /** Source byte ranges of one segment interval, by file and interval; forgotten with the source. */
   const segmentSourceRanges = new Map();
   /**
-   * What one segment of an output reads — its tracks, its interval and the key
-   * its bytes are kept under — by output and segment, until the tracks, the
-   * file's start time, the segment's interval or the choices of the output
-   * change; forgotten with the source.
+   * WHAT ONE SEGMENT OF AN OUTPUT IS, kept from pass to pass: where it lies in
+   * the source, what it reads — its tracks and the key its bytes are kept under
+   * — and, once known, those bytes joined at the precision the torrent fetches,
+   * by output and segment. Worked out again only when the output's timeline,
+   * the tracks, the file's start time or the output's choices change; forgotten
+   * with the source. None of it depends on where a viewer stands, and a pass is
+   * made every time one moves: looked up, made and joined again for each of a
+   * film's 3500 segments on every pass, they were 6 s of the 40 s the passes
+   * cost the main thread in fifteen minutes on Home Assistant (r30,
+   * torrent-tv/meta#178).
    */
   const segmentReadings = new Map();
-  // Per output, then per segment: every segment of an output of one pass shares
-  // its list of track choices, so the output's key and the choices' key are
-  // worked out once for it. Built for each of a pass's segments, the two
-  // strings cost the main thread 13 s in ten minutes of a cold AVI on Home
-  // Assistant (torrent-tv/meta#178).
-  const readingsByChoices = new WeakMap();
-  const segmentReadingOf = (zone, trackList, shift, map) => {
-    let output = readingsByChoices.get(zone.tracks);
-    if (!output) {
-      const outputKey = `${map.sourceKey}:${map.fileIndex}:${zone.outputKey}`;
-      let byIndex = segmentReadings.get(outputKey);
-      if (!byIndex) segmentReadings.set(outputKey, byIndex = new Map());
-      output = { byIndex, choicesKey: zone.tracks.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(",") };
-      readingsByChoices.set(zone.tracks, output);
-    }
-    const { byIndex, choicesKey } = output;
-    const kept = byIndex.get(zone.index);
-    if (kept && kept.trackList === trackList && kept.shift === shift && kept.choicesKey === choicesKey &&
-      kept.from === zone.sourceInterval.from && kept.to === zone.sourceInterval.to) return kept.reading;
-    const selected = zone.tracks.map(choice => ({ choice, track: choice.type === "video"
+  /** One output's segments, by index. */
+  const segmentRecordsOf = (map, output) => {
+    const key = `${map.sourceKey}:${map.fileIndex}:${output.outputKey}`;
+    let records = segmentReadings.get(key);
+    if (!records) segmentReadings.set(key, records = new Map());
+    return records;
+  };
+  /** The choices of one output's tracks as a key, worked out once for the list of them a pass shares. */
+  const choicesKeys = new WeakMap();
+  const choicesKeyOf = (choices) => {
+    let key = choicesKeys.get(choices);
+    if (key === undefined) choicesKeys.set(choices, key = choices.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(","));
+    return key;
+  };
+  const segmentRecordOf = (records, demand, { timeline, trackList, shift, map }) => {
+    const choicesKey = choicesKeyOf(demand.tracks);
+    const kept = records.get(demand.index);
+    if (kept && kept.timeline === timeline && kept.trackList === trackList && kept.shift === shift && kept.choicesKey === choicesKey) return kept;
+    const sourceInterval = timeline.sourceInterval(demand.index, demand.index, shift);
+    const selected = demand.tracks.map(choice => ({ choice, track: choice.type === "video"
       ? ContainerTrack.firstUsable(trackList, "video")
       : trackList.filter(track => track.type === choice.type)[choice.index] }));
     let reading = null;
     if (!selected.some(({ track }) => !track)) {
       const wanted = selected.map(({ track }) => track);
       const modes = new Map(selected.map(({ choice, track }) => [track, choice.mode]));
-      const interval = { ...zone.sourceInterval, trackIds: wanted.map(track => track.trackNumber),
+      const interval = { ...sourceInterval, trackIds: wanted.map(track => track.trackNumber),
         modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
       reading = { wanted, modes, interval, rangesKey: `${map.sourceKey}:${map.fileIndex}:${JSON.stringify(interval)}` };
     }
-    byIndex.set(zone.index, { trackList, shift, choicesKey, from: zone.sourceInterval.from, to: zone.sourceInterval.to, reading });
-    return reading;
+    // `joined` is the segment's ranges as the torrent is told them, made from
+    // the list `ranges` at `pieceLength`; `registered` is the list the input
+    // table was last given.
+    const record = { timeline, trackList, shift, choicesKey, sourceInterval, reading,
+      ranges: null, pieceLength: Number.NaN, joined: null, registered: null };
+    records.set(demand.index, record);
+    return record;
   };
   /**
    * The last complete pass over each file, by file: what it was worked out
@@ -508,15 +519,6 @@ export async function startProxyServer({
       `${passCosts.built} zone list(s) built for the map in ${Math.round(passCosts.buildMs)}ms`);
     Object.assign(passCosts, { since: now, reused: 0, worked: 0, incomplete: 0, segments: 0, ranges: 0, zones: 0, built: 0, buildMs: 0, ms: 0, maxMs: 0 });
   };
-  /** A segment's ranges joined at the precision the torrent fetches, once per kept list and piece length. */
-  const joinedRanges = new WeakMap();
-  const joinedRangesOf = (ranges, pieceLength) => {
-    const kept = joinedRanges.get(ranges);
-    if (kept && kept.pieceLength === pieceLength) return kept.joined;
-    const joined = joinedWithinPieces(ranges, pieceLength);
-    if (ranges !== null && typeof ranges === "object") joinedRanges.set(ranges, { pieceLength, joined });
-    return joined;
-  };
   const downloadMaps = new DownloadMaps({
     // The ranges a picture reads at open are named again by every segment;
     // only the zone the swarm would rank first is sent (torrent-tv/meta#166).
@@ -574,14 +576,22 @@ export async function startProxyServer({
         const links = consumers.map(viewer => viewer.linkReading()?.linkMbps)
           .filter(value => Number.isFinite(value) && value > 0);
         const encodeSpeed = outputParts.encodeCost.latestSpeedReadingOf(output)?.speed;
+        const linkMbps = links.length ? Math.min(...links) : null;
+        const records = segmentRecordsOf(map, output);
+        const facts = { timeline: output.timeline, trackList: tracks.value, shift, map };
+        // Each demand is this pass's own object (`segmentDemands`), so it is
+        // completed in place rather than copied.
         for (const demand of segmentDemands(output, map.fileIndex, map.zones)) {
           if (inventory.has(demand.index)) continue;
           const deadlineAt = sourceDeadline(demand, { encodeSpeed,
-            outputBytes: seconds > 0 ? bytes / seconds * (demand.to - demand.from) : null,
-            linkMbps: links.length ? Math.min(...links) : null });
-          const leadSeconds = Number.isFinite(demand.deadlineAt) ? Math.max(0, (demand.deadlineAt - deadlineAt) / 1000) : 0;
-          demands.push({ ...demand, deadlineAt, leadSeconds, outputKey: output.outputKey,
-            sourceInterval: output.timeline.sourceInterval(demand.index, demand.index, shift) });
+            outputBytes: seconds > 0 ? bytes / seconds * (demand.to - demand.from) : null, linkMbps });
+          const record = segmentRecordOf(records, demand, facts);
+          demand.leadSeconds = Number.isFinite(demand.deadlineAt) ? Math.max(0, (demand.deadlineAt - deadlineAt) / 1000) : 0;
+          demand.deadlineAt = deadlineAt;
+          demand.outputKey = output.outputKey;
+          demand.sourceInterval = record.sourceInterval;
+          demand.record = record;
+          demands.push(demand);
         }
       }
       demands.sort((left, right) => left.deadlineAt - right.deadlineAt || right.priority - left.priority || left.index - right.index);
@@ -618,24 +628,37 @@ export async function startProxyServer({
       // two-hour AVI (torrent-tv/meta#178).
       const waiting = new Set();
       const turn = takeTurns();
+      /** One download interval per map zone, shared by the segments it owns: read, never changed. */
+      const downloadIntervals = new Map();
+      const downloadIntervalOf = (owner) => {
+        let interval = downloadIntervals.get(owner);
+        if (!interval) downloadIntervals.set(owner, interval = { from: owner.from, to: owner.to });
+        return interval;
+      };
       for (const zone of demands) {
         if (!map.isCurrent()) return [];
-        // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication: its
-        // tracks, its interval and the key its bytes are kept under depend on
-        // the output, the segment and the file's start time, none of which a
-        // new map changes. Rebuilt for every segment of the film on every map,
-        // this pass held the main thread up to 1.5 s at a time on Home
+        // WHAT A SEGMENT READS IS WORKED OUT ONCE, not on every publication
+        // (`segmentRecordOf`). Rebuilt for every segment of the film on every
+        // map, this pass held the main thread up to 1.5 s at a time on Home
         // Assistant (torrent-tv/meta#178).
-        const reading = segmentReadingOf(zone, tracks.value, shift, map);
+        const { record } = zone;
+        const reading = record.reading;
         if (!reading) continue;
         const { wanted, modes, interval, rangesKey } = reading;
-        const { tracks: _choices, owner: _owner, sourceInterval: _sourceInterval, ...demand } = zone;
         const convert = ranges => {
-          const joined = joinedRangesOf(ranges, pieceLength);
+          if (record.ranges !== ranges || record.pieceLength !== pieceLength) {
+            record.ranges = ranges;
+            record.pieceLength = pieceLength;
+            record.joined = joinedWithinPieces(ranges, pieceLength);
+          }
+          const joined = record.joined;
           rangeCount += joined.length;
           // What the segment reads is kept for the forecast in a table of its
           // own, whatever form the torrent is told it in.
-          segmentInputs.set(map.sourceKey, map.fileIndex, zone.outputKey, zone.index, joined);
+          if (record.registered !== joined) {
+            segmentInputs.set(map.sourceKey, map.fileIndex, zone.outputKey, zone.index, joined);
+            record.registered = joined;
+          }
           // ONE ZONE FOR THE SEGMENT, its demand stated once for all the
           // ranges it reads. The demand — level, priority, deadline, the map
           // zone it belongs to — is this pass's; the ranges are the list kept
@@ -643,14 +666,16 @@ export async function startProxyServer({
           // range copied the demand into every one: ten thousand objects a
           // pass over a two-hour AVI, made again 21-61 times a minute on Home
           // Assistant (r26, torrent-tv/meta#178).
-          converted.push({ ...demand, downloadInterval: { from: zone.owner.from, to: zone.owner.to }, ranges: joined });
+          converted.push({ index: zone.index, from: zone.from, to: zone.to, priority: zone.priority, urgent: zone.urgent,
+            behind: zone.behind, deferred: zone.deferred, deadlineAt: zone.deadlineAt, leadSeconds: zone.leadSeconds,
+            outputKey: zone.outputKey, downloadInterval: downloadIntervalOf(zone.owner), ranges: joined });
         };
         // The bytes one segment needs are a fact of the file and the output, so
         // they are worked out once. A whole film is thousands of segments and
         // the map changes every few seconds; worked out afresh on every change,
         // a pass over a two-hour AVI never finished and the next segment's bytes
         // were never asked for (Home Assistant 2026-10-08, torrent-tv/meta#151).
-        const known = segmentSourceRanges.get(rangesKey);
+        const known = record.ranges ?? segmentSourceRanges.get(rangesKey);
         if (known) { convert(known); continue; }
         if (waiting.has(zone.outputKey)) { complete = false; continue; }
         // What is resolved so far is stated before a lower zone is worked out

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/playback-pass.js

@@ -22,18 +22,30 @@
  *   behind?: boolean, deferred?: boolean, from: number, to: number,
  *   sourceInterval?: { from: number, to: number } }>} params.demands - In the
  *   order of their deadlines.
- * @returns {{ outputs: string[], inputs: number[] }}
+ * @returns {{ outputs: string[], inputs: Float64Array }}
  */
 export function passInputs({ pieceLength, shift, targets, demands }) {
   const outputs = [...targets.keys()];
-  const inputs = [pieceLength, shift];
-  for (const target of targets.values()) inputs.push(target ?? -1);
+  const position = new Map(outputs.map((outputKey, at) => [outputKey, at]));
+  // Numbers in a list made to its length: grown a value at a time, eight for
+  // each of a film's 3500 segments, it was most of what comparing a pass cost
+  // (r30, torrent-tv/meta#178).
+  const inputs = new Float64Array(2 + targets.size + demands.length * 8);
+  let at = 0;
+  inputs[at++] = pieceLength;
+  inputs[at++] = shift;
+  for (const target of targets.values()) inputs[at++] = target ?? -1;
   for (const demand of demands) {
     // The segment's own interval too: a cut grid read again can give one
     // number other bytes.
-    inputs.push(outputs.indexOf(demand.outputKey), demand.index, demand.priority,
-      (demand.urgent ? 1 : 0) + (demand.behind ? 2 : 0) + (demand.deferred ? 4 : 0),
-      demand.from, demand.to, demand.sourceInterval?.from ?? -1, demand.sourceInterval?.to ?? -1);
+    inputs[at++] = position.get(demand.outputKey) ?? -1;
+    inputs[at++] = demand.index;
+    inputs[at++] = demand.priority;
+    inputs[at++] = (demand.urgent ? 1 : 0) + (demand.behind ? 2 : 0) + (demand.deferred ? 4 : 0);
+    inputs[at++] = demand.from;
+    inputs[at++] = demand.to;
+    inputs[at++] = demand.sourceInterval?.from ?? -1;
+    inputs[at++] = demand.sourceInterval?.to ?? -1;
   }
   return { outputs, inputs };
 }
@@ -41,8 +53,8 @@ export function passInputs({ pieceLength, shift, targets, demands }) {
 /**
  * Whether a pass is worked out from what an earlier one was.
  *
- * @param {{ tracks: unknown, outputs: string[], inputs: number[] } | undefined} last
- * @param {{ tracks: unknown, outputs: string[], inputs: number[] }} next
+ * @param {{ tracks: unknown, outputs: string[], inputs: ArrayLike<number> } | undefined} last
+ * @param {{ tracks: unknown, outputs: string[], inputs: ArrayLike<number> }} next
  * @returns {boolean}
  */
 export function samePass(last, next) {

package/services/viewer/segment-demands.js

@@ -11,26 +11,50 @@ 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);
-    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.
-    const deadlineOf = zone => Number.isFinite(zone.deadlineAt)
-      ? zone.deadlineAt + Math.max(0, from - zone.from) * 1000 : Infinity;
-    const owner = overlapping.reduce((first, zone) => deadlineOf(zone) < deadlineOf(first) ? zone : first);
-    demands.push({ index, from, to, tracks, owner,
-      priority: Math.max(...overlapping.map(zone => zone.priority)),
-      urgent: overlapping.some(zone => zone.urgent),
-      behind: overlapping.every(zone => zone.behind),
-      deferred: overlapping.every(zone => zone.deferred),
-      deadlineAt: Math.min(...overlapping.map(deadlineOf)) });
+    if (ordered) while (first < zones.length && zones[first].to <= from) first += 1;
+    // The zones a segment overlaps are folded as they are met, into numbers:
+    // a list of them, and the lists made of it for each field, were five
+    // arrays for every segment of a film on every pass (r30,
+    // torrent-tv/meta#178).
+    let owner = null, ownerDeadline = Infinity, priority = 0, urgent = false, behind = true, deferred = true;
+    for (let at = ordered ? first : 0; at < zones.length; at += 1) {
+      const zone = zones[at];
+      if (ordered && !(zone.from < to)) break;
+      if (!(zone.priority > 0) || !(zone.from < to && zone.to > from)) 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.
+      const deadline = Number.isFinite(zone.deadlineAt) ? zone.deadlineAt + Math.max(0, from - zone.from) * 1000 : Infinity;
+      if (owner === null || deadline < ownerDeadline) { owner = zone; ownerDeadline = deadline; }
+      if (zone.priority > priority) priority = zone.priority;
+      if (zone.urgent) urgent = true;
+      if (!zone.behind) behind = false;
+      if (!zone.deferred) deferred = false;
+    }
+    if (owner === null) continue;
+    demands.push({ index, from, to, tracks, owner, priority, urgent, behind, deferred, deadlineAt: ownerDeadline });
   }
   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;