@torrent-tv/proxy 2.97.26 → 2.97.27

package/package.json

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

package/server.js

@@ -56,7 +56,7 @@ import { createPlaybackPlanner } from "./services/media/playback-planner.js";
 import { KeyframeTables } from "./services/media/KeyframeTables.js";
 import { contentsOf } from "./services/torrent/Contents.js";
 import { joinedWithinPieces } from "./services/torrent/demand/pieces.js";
-import { withoutRepeatedZones } from "./services/torrent/map-zones.js";
+import { coalescedZones, withoutRepeatedZones } from "./services/torrent/map-zones.js";
 import { SubtitleOrchestrator } from "./services/media/SubtitleOrchestrator.js";
 import { containerOrchestrator, CONTAINER_HEAD_BYTES, describeWorkTags } from "./services/media/ContainerOrchestrator.js";
 import { readPlaybackDeclarations } from "./services/media/read-playback-declarations.js";
@@ -436,10 +436,23 @@ export async function startProxyServer({
    * change; forgotten with the source.
    */
   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) => {
-    const choicesKey = zone.tracks.map(choice => `${choice.type}/${choice.index}/${choice.mode}`).join(",");
-    const key = `${map.sourceKey}:${map.fileIndex}:${zone.outputKey}:${zone.index}`;
-    const kept = segmentReadings.get(key);
+    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"
@@ -453,7 +466,7 @@ export async function startProxyServer({
         modes: Object.fromEntries(wanted.map(track => [track.trackNumber, modes.get(track)])) };
       reading = { wanted, modes, interval, rangesKey: `${map.sourceKey}:${map.fileIndex}:${JSON.stringify(interval)}` };
     }
-    segmentReadings.set(key, { trackList, shift, choicesKey, from: zone.sourceInterval.from, to: zone.sourceInterval.to, reading });
+    byIndex.set(zone.index, { trackList, shift, choicesKey, from: zone.sourceInterval.from, to: zone.sourceInterval.to, reading });
     return reading;
   };
   /** A segment's ranges joined at the precision the torrent fetches, once per kept list and piece length. */
@@ -474,6 +487,10 @@ export async function startProxyServer({
     // same bytes — lost them with 2.96.11, and the start forecast answered
     // "source-input-ranges-unavailable" for ever (Home Assistant 2026-10-11).
     publish: (map) => torrentPool.setPriorityMap({ ...map, zones: withoutRepeatedZones(map.zones) }),
+    // And what is sent is packed: a stretch of one level and priority is one
+    // window, not one zone per range of each of its segments
+    // (`coalescedZones`, torrent-tv/meta#178).
+    pack: (zones) => coalescedZones(zones),
     log: (line) => logger.info(line),
     resolvePlayback: async (map) => {
       if (map.zones.length === 0) return [];

package/services/encode/EncodePlan.js

@@ -720,6 +720,37 @@ export function planEncoders({
  * @returns {{ stall: number, ahead: number, whole: number }} Three counts of
  *   seconds, compared in that order by {@link cheaperThan}.
  */
+/** Each number's rank in the map, worked out once per map rather than per arrangement scored. */
+const ranksByMap = new WeakMap();
+
+/**
+ * The highest priority any span gives each number from `first` to `last`.
+ *
+ * Asked once per number of the film by every arrangement a plan scores, it
+ * walked every span each time: 19 s of the main thread in ten minutes of a cold
+ * AVI on Home Assistant (torrent-tv/meta#178). The map does not change between
+ * the arrangements of one plan, so the answer is kept with it.
+ *
+ * @param {WantedSpan[]} wanted
+ * @param {number} first
+ * @param {number} last
+ * @returns {(index: number) => number}
+ */
+function ranksOf(wanted, first, last) {
+  const kept = ranksByMap.get(wanted);
+  if (kept && kept.first === first && kept.last === last) return kept.rankAt;
+  const ranks = new Float64Array(Math.max(0, last - first + 1));
+  for (const span of wanted) {
+    const priority = Number(span.priority) || 0;
+    for (let index = Math.max(first, span.from); index <= Math.min(last, span.to); index += 1) {
+      if (priority > ranks[index - first]) ranks[index - first] = priority;
+    }
+  }
+  const rankAt = (index) => (index >= first && index <= last ? ranks[index - first] : 0);
+  ranksByMap.set(wanted, { first, last, rankAt });
+  return rankAt;
+}
+
 function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPerSegment, segmentSeconds) {
   const first = Math.min(...wanted.map((span) => span.from));
   const last = Math.max(...wanted.map((span) => span.to));
@@ -750,15 +781,7 @@ function latenessOf(encoders, coverage, wanted, untilNeeded, rate, refetchSecPer
   // that is 2024 s, which outvotes everything: field 2026-09-08, one viewer got
   // three encoders, two of them on film behind them, and the run serving them
   // was killed to make room for one.
-  const rankAt = (at) => {
-    let rank = 0;
-    for (const span of wanted) {
-      if (at >= span.from && at <= span.to) {
-        rank = Math.max(rank, Number(span.priority) || 0);
-      }
-    }
-    return rank;
-  };
+  const rankAt = ranksOf(wanted, first, last);
   // The ranks the map actually states, most urgent first. The comparison is over
   // these and nothing else, so a rank can never be outvoted by a lower one
   // however many seconds are at stake there.

package/services/torrent/download/FutureDownload.js

@@ -6,8 +6,8 @@ import { compareBands } from "./bands.js";
 const BLOCK_BYTES = 16 * 1024;
 
 /** Estimate completion from observed queues and the public selection bands.
- * The native picker decides the order within a band, so every unqueued piece
- * uses that band's completion time rather than an invented request order.
+ * The native picker takes a band's pieces from its first up (the `sequential`
+ * strategy), so an unqueued piece arrives after the band's pieces before it.
  * Pieces without a measured supplier remain unknown. No requests are changed.
  * Times are conditional on the measured rate and successful verification.
  */
@@ -97,21 +97,18 @@ export async function futureDownload(entries, { now = Date.now(), findStore = pi
     }
     forecasts.set(torrent, { measuredAt: now, arrivals });
   }
-  pending.sort(compareBands);
+  // WITHIN A BAND, IN THE ORDER THE PIECES COME. The picker walks each
+  // selection from its first piece up (WebTorrent 2.8.5's default `sequential`
+  // strategy, which this proxy keeps), so a piece of a band arrives once those
+  // before it have. Charged the whole band's end instead, a band of many
+  // segments — the map states one per stretch of a level since 2.97.27 — would
+  // put its nearest piece at its farthest piece's time (torrent-tv/meta#178).
+  pending.sort((left, right) => compareBands(left, right) || left.index - right.index);
   let finish = now;
-  for (let start = 0; start < pending.length;) {
-    let end = start;
-    const first = pending[start];
-    while (end < pending.length && compareBands(pending[end], first) === 0) {
-      const seconds = pending[end++].seconds;
-      finish = finish === null || seconds === null ? null : finish + seconds * 1000;
-    }
-    for (let i = start; i < end; i++) {
-      const { arrivals, index } = pending[i];
-      const queuedAt = arrivals.get(index);
-      if (finish !== null) arrivals.set(index, queuedAt === null ? finish : Math.min(queuedAt, finish));
-    }
-    start = end;
+  for (const { arrivals, index, seconds } of pending) {
+    finish = finish === null || seconds === null ? null : finish + seconds * 1000;
+    const queuedAt = arrivals.get(index);
+    if (finish !== null) arrivals.set(index, queuedAt === null ? finish : Math.min(queuedAt, finish));
   }
   return isCurrent() ? forecasts : new Map();
 }

package/services/torrent/map-zones.js

@@ -80,12 +80,70 @@ export function deadlineOfMapZone(zone, now = Date.now()) {
  * @returns {Zone[]} In their order, without the repeats.
  */
 export function withoutRepeatedZones(zones, now = Date.now()) {
-  const bandOf = zone => ({ urgency: levelOfMapZone(zone), priority: priorityOfMapZone(zone), deadlineAt: deadlineOfMapZone(zone, now) });
+  const keys = zones.map(zone => `${zone.byteStart}:${zone.byteEnd}`);
   const best = new Map();
   zones.forEach((zone, index) => {
-    const key = `${zone.byteStart}:${zone.byteEnd}`;
-    const kept = best.get(key);
-    if (!kept || compareBands(bandOf(zone), kept.band) < 0) best.set(key, { index, band: bandOf(zone) });
+    const kept = best.get(keys[index]);
+    const band = { urgency: levelOfMapZone(zone), priority: priorityOfMapZone(zone), deadlineAt: deadlineOfMapZone(zone, now) };
+    if (!kept || compareBands(band, kept.band) < 0) best.set(keys[index], { index, band });
   });
-  return zones.filter((zone, index) => best.get(`${zone.byteStart}:${zone.byteEnd}`).index === index);
+  return zones.filter((_zone, index) => best.get(keys[index]).index === index);
+}
+
+/**
+ * What the torrent is told, as few windows as say the same thing: every stretch
+ * of bytes once, in the best band that names it, and the stretches of one
+ * level and priority that touch or overlap joined into one window, wanted by
+ * the earliest deadline among them.
+ *
+ * A map names every range of every segment — three of an AVI's segment, two of
+ * them the header and index all its segments read — and a film is thousands of
+ * segments: 10 000 zones, built, compared, copied to the torrent thread and
+ * stated there every three seconds a viewer plays on, about 70 s of the main
+ * thread in ten minutes on Home Assistant (torrent-tv/meta#178). The swarm acts
+ * on the band of a piece and nothing else, and within one band the pieces of
+ * consecutive segments are consecutive bytes. A zone a metadata read states
+ * keeps its own request and order, and is left as it is.
+ *
+ * @template {{ byteStart: number, byteEnd: number }} Zone
+ * @param {Zone[]} zones
+ * @param {number} [now]
+ * @returns {object[]}
+ */
+export function coalescedZones(zones, now = Date.now()) {
+  const kept = [];
+  const groups = new Map();
+  for (const zone of withoutRepeatedZones(zones, now)) {
+    if (zone.requestId !== undefined || zone.downloadOnly || (Number.isSafeInteger(zone.order) && zone.order > 0)) {
+      kept.push(zone);
+      continue;
+    }
+    const urgency = levelOfMapZone(zone);
+    const priority = priorityOfMapZone(zone);
+    const key = `${urgency}:${priority}`;
+    let group = groups.get(key);
+    if (!group) groups.set(key, group = { urgency, priority, parts: [] });
+    group.parts.push({ start: zone.byteStart, end: zone.byteEnd, deadlineAt: deadlineOfMapZone(zone, now) });
+  }
+  for (const { urgency, priority, parts } of groups.values()) {
+    parts.sort((left, right) => left.start - right.start);
+    let window = null;
+    const close = () => {
+      if (!window) return;
+      kept.push({ byteStart: window.start, byteEnd: window.end, priority, urgent: urgency === Urgency.NEAR,
+        behind: urgency === Urgency.BEHIND, deferred: urgency === Urgency.TAIL,
+        ...(Number.isFinite(window.deadlineAt) ? { deadlineAt: window.deadlineAt } : {}) });
+    };
+    for (const part of parts) {
+      if (window && part.start <= window.end + 1) {
+        window.end = Math.max(window.end, part.end);
+        window.deadlineAt = Math.min(window.deadlineAt, part.deadlineAt);
+      } else {
+        close();
+        window = { ...part };
+      }
+    }
+    close();
+  }
+  return kept;
 }

package/services/viewer/DownloadMaps.js

@@ -18,12 +18,15 @@ export class DownloadMaps {
    * thread's receipt included (torrent-tv/meta#177).
    */
   #clock;
+  /** What the torrent is told of the playback zones: as many windows as say the same thing. */
+  #pack;
 
   constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now,
-    clock = () => performance.timeOrigin + performance.now() }) {
+    clock = () => performance.timeOrigin + performance.now(), pack = zones => zones }) {
     if (typeof publish !== "function") throw new TypeError("Download map publication is required.");
     this.#publish = publish;
     this.#resolvePlayback = resolvePlayback;
+    this.#pack = pack;
     this.#log = typeof log === "function" ? log : null;
     this.#now = now;
     this.#clock = clock;
@@ -74,7 +77,8 @@ export class DownloadMaps {
     }
     if (changed) await this.#emit(file);
     if (revision !== file.revision) return;
-    const isCurrent = () => this.#files.get(`${sourceKey}:${fileIndex}`) === file && revision === file.revision;
+    const fileKey = `${sourceKey}:${fileIndex}`;
+    const isCurrent = () => this.#files.get(fileKey) === file && revision === file.revision;
     // WHAT IS RESOLVED IS STATED WHILE THE REST IS STILL BEING RESOLVED. A pass
     // works the zones out in the order the swarm is to fetch them, and
     // published only at its end it kept the first bytes from the swarm for as
@@ -264,7 +268,9 @@ export class DownloadMaps {
   #emit(file) {
     file.dirty = false;
     const builtFrom = this.#clock();
-    const zones = [...file.zones, ...file.nativeZones];
+    // Compared and sent as the torrent is to act on it: the playback zones
+    // packed into as few windows as say the same (`coalescedZones`).
+    const zones = this.#pack([...file.zones, ...file.nativeZones]);
     for (const { ranges, requestId, priority, urgent, deadlineAt, order } of file.metadata.values()) {
       for (const [byteStart, byteEnd] of ranges) {
         zones.push({ byteStart, byteEnd, priority, urgent, downloadOnly: true, requestId, deadlineAt, ...(order ? { order } : {}) });