@torrent-tv/proxy 2.98.2 → 2.98.4

package/services/viewer/DownloadMaps.js

@@ -49,6 +49,10 @@ export class DownloadMaps {
     // Assistant 2026-10-07, torrent-tv/meta#95). A zone no new zone overlaps —
     // a seek away — is withdrawn at once.
     const retained = file.zones.flatMap(zone => {
+      // A window its resolver keeps current itself — the projection of the
+      // file's segments, brought to this map by the pass below — stands as it
+      // is until the pass states it (`PlaybackProjection`, torrent-tv/meta#178).
+      if (zone.standing === true) return [zone];
       const interval = zone.downloadInterval ?? zone;
       const current = sourceZones.exactly(interval);
       if (!current) {
@@ -343,7 +347,10 @@ export class DownloadMaps {
     const kept = file.packed;
     if (kept && kept.zones === file.zones && kept.nativeZones === file.nativeZones) return kept.result;
     const input = [...file.zones, ...file.nativeZones];
-    const result = this.#pack(input);
+    // Windows already packed by their resolver are not packed again unless
+    // something else is to be packed with them.
+    const result = file.nativeZones.length === 0 && file.zones.length > 0 && file.zones.every(zone => zone.standing === true)
+      ? file.zones : this.#pack(input);
     const relative = input.some(zone => !Number.isFinite(zone.deadlineAt) && Number.isFinite(zone.withinSeconds));
     file.packed = relative ? null : { zones: file.zones, nativeZones: file.nativeZones, result };
     return result;
@@ -435,7 +442,11 @@ function zoneIndexOf(file) {
 function withRetained(resolved, retained) {
   const keyOf = zone => typeof zone.outputKey === "string" && Number.isSafeInteger(zone.index) ? `${zone.outputKey}:${zone.index}` : null;
   const resolvedKeys = new Set(resolved.map(keyOf).filter(key => key !== null));
+  // Windows a resolver keeps current are all of what it states: the ones it
+  // stated before are what it states now.
+  const standing = resolved.some(zone => zone.standing === true);
   return [...resolved, ...retained.filter(zone => {
+    if (standing && zone.standing === true) return false;
     const key = keyOf(zone);
     return key === null || !resolvedKeys.has(key);
   })];

package/services/viewer/Viewer.js

@@ -388,6 +388,9 @@ export class Viewer {
    *   picture is in picture-in-picture. Absent means on screen.
    * @param {boolean} [report.inPictureInPicture] - Whether the picture has been
    *   pulled out of the page, which is watching it with the tab hidden.
+   * @param {number} [report.generation] - Which of this viewer's viewings the
+   *   page made the report in (`Assignments`). Absent from a page one release
+   *   behind; then the report is taken as current.
    * @param {number} [now]
    */
   report(
@@ -406,11 +409,18 @@ export class Viewer {
       onScreen,
       inPictureInPicture,
       qualityMode,
-      visiblePicture
+      visiblePicture,
+      generation
     },
     now = Date.now()
   ) {
     this.noteVisiblePicture(visiblePicture);
+    // A REPORT MADE BEFORE THE VIEWER'S LAST SEEK says where they were, not
+    // where they are: sent just before the seek and answered after it, it
+    // would place them back in the viewing they left, and the deadlines worked
+    // out from their position would follow it (torrent-tv/meta#178 review).
+    // What it measured of the link is still a measurement of the link.
+    const stale = this.isOfAnEarlierViewing(generation);
     // Whether the size on their screen was picked by hand or is the automatic
     // choice. Kept only when stated: a page one release behind says nothing,
     // and is taken as picking, which is what every page was before.
@@ -428,6 +438,7 @@ export class Viewer {
     const linkMeasuredAt = hasLinkMeasurement ? now : this.netReport?.linkMeasuredAt ?? null;
     const sampleMbps = Number(linkSampleMbps);
     const sampleAt = Number(linkSampleAt);
+    const previous = this.netReport;
     const hasPlaybackSample = Number.isFinite(sampleMbps) && sampleMbps > 0 &&
       Number.isFinite(sampleAt) && sampleAt > 0;
     const newerPlaybackSample = hasPlaybackSample && sampleAt > (this.netReport?.linkSampleAt ?? 0);
@@ -458,6 +469,13 @@ export class Viewer {
     };
     // Where the picture is now. A report states a place the viewer has played
     // to, not a place they moved to: their buffer's history stands.
+    if (stale) {
+      this.netReport = { ...this.netReport, positionSeconds: previous?.positionSeconds ?? null,
+        bufferedAheadSec: previous?.bufferedAheadSec ?? 0, bufferedRanges: previous?.bufferedRanges ?? null,
+        timestampOffsets: previous?.timestampOffsets ?? {}, at: previous?.at ?? now };
+      this.seen(now);
+      return;
+    }
     if (Number.isFinite(positionSeconds) && positionSeconds >= 0) {
       this.#place(/** @type {number} */ (positionSeconds), now);
     }
@@ -491,6 +509,18 @@ export class Viewer {
     this.seen(now);
   }
 
+  /**
+   * Whether something the page stated in viewing `generation` was stated
+   * before this viewer's last seek. A page that names no viewing is taken as
+   * current, as every page was before it could name one.
+   *
+   * @param {number | undefined} generation
+   * @returns {boolean}
+   */
+  isOfAnEarlierViewing(generation) {
+    return Number.isInteger(generation) && generation < this.assignments.generation;
+  }
+
   /**
    * Whether this viewer is here.
    *

package/services/viewer/segment-demands.js

@@ -1,5 +1,5 @@
-/** Translate map demand to complete output intervals and selected source tracks. */
-export function segmentDemands(output, fileIndex, zones) {
+/** The tracks of this file an output reads, and how: copied or encoded again. */
+export function trackChoicesOf(output, fileIndex) {
   const tracks = [];
   for (const type of ["video", "audio"]) {
     const spec = output.spec?.[type];
@@ -7,59 +7,5 @@ export function segmentDemands(output, fileIndex, zones) {
     tracks.push({ type, index: type === "video" ? 0 : spec.trackIndex,
       mode: type === "video" ? spec.encode ? "transcode" : "copy" : spec.transcode ? "transcode" : "copy" });
   }
-  if (!tracks.length) return [];
-  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.");
-    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;
-  const processing = Number.isFinite(encodeSpeed) && encodeSpeed > 0 ? span / encodeSpeed : 0;
-  const delivery = Number.isFinite(outputBytes) && outputBytes > 0 && Number.isFinite(linkMbps) && linkMbps > 0
-    ? outputBytes * 8 / (linkMbps * 1_000_000) : 0;
-  return Number.isFinite(demand.deadlineAt) ? demand.deadlineAt - (processing + delivery) * 1000 : demand.deadlineAt;
+  return tracks;
 }

package/services/viewer/playback-pass.js

@@ -1,70 +0,0 @@
-/**
- * @file What one pass that turns a file's playback map into bytes is worked out
- * from, so a pass whose inputs have not changed hands back what the last one
- * resolved (torrent-tv/meta#178).
- *
- * The viewer's map moves a second at a time while segments are seconds long,
- * so most passes give the zones the pass before gave: on Home Assistant 30–110
- * of 50–120 download maps a minute came out unchanged, and working them out
- * took 72 s of the main thread in fifteen minutes (r22). The deadlines are left
- * out of what is compared and their order is kept in it: a segment's deadline
- * is when the viewer reaches it, which moves only when they stop or seek, and
- * what is sent to the torrent is compared by the deadlines' order alone
- * (`DownloadMaps` `shapeOf`).
- */
-
-/**
- * @param {object} params
- * @param {number} params.pieceLength - The precision the torrent fetches at.
- * @param {number} params.shift - Where the file's own clock starts.
- * @param {Map<string, number | null>} params.targets - Each output's next input, by output.
- * @param {Array<{ outputKey: string, index: number, priority: number, urgent?: boolean,
- *   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: Float64Array }}
- */
-export function passInputs({ pieceLength, shift, targets, demands }) {
-  const outputs = [...targets.keys()];
-  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[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 };
-}
-
-/**
- * Whether a pass is worked out from what an earlier one was.
- *
- * @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) {
-  return Boolean(last) && last.tracks === next.tracks &&
-    sameValues(last.outputs, next.outputs) && sameValues(last.inputs, next.inputs);
-}
-
-/** Whether two lists hold the same values in the same order. */
-function sameValues(left, right) {
-  if (left.length !== right.length) return false;
-  for (let index = 0; index < left.length; index++) if (!Object.is(left[index], right[index])) return false;
-  return true;
-}

package/services/viewer/target-input-expansion.js

@@ -1,174 +0,0 @@
-/**
- * @file The next run's whole input, asked of the swarm as one group.
- *
- * While anything urgent is missing, the swarm is told only the first class
- * (`torrent/download/SwarmSelection.js`), and at a cold start the map's first
- * class is one segment's input. A peer holding none of its pieces then has
- * nothing to send, and a run is admitted only as far as its input has arrived
- * (`encode/EncodeInputs.js`), so it opens again a few seconds of film later.
- *
- * WebTorrent 2.8.5 keeps no order between several non-zero selections — it
- * rotates them (`shufflePriority`) — so the run's input is not stated as a
- * second group behind the first: the segments it covers take the first
- * segment's place in the map, and the swarm is told them as one group. How
- * far that reaches is what `EncodeInputs` would copy for the run, from its
- * copy rate, its open and the memory allowed; it is not worked out again here.
- * A read stopped on its bytes is stated at a level of its own above any of
- * this, and a seek, which moves the map's first segment, moves this with it
- * (torrent-tv/meta#178).
- */
-
-/**
- * The bytes a run's input holds, each counted once: the declarations and
- * indexes every segment of an original file names are held once by the run
- * that reads them. Kept merged and in order, so a segment's ranges are
- * counted against it by search rather than by sorting everything held again —
- * a soundtrack's segments add a few bytes each, and its stretch is walked far.
- */
-class HeldBytes {
-  /** Inclusive [start, end], merged, ascending. @type {Array<[number, number]>} */
-  #ranges = [];
-  total = 0;
-
-  /** @param {Array<[number, number]>} ranges */
-  constructor(ranges = []) {
-    this.add(ranges);
-  }
-
-  /** The first held range that ends at or after `at`. */
-  #from(at) {
-    let low = 0;
-    let high = this.#ranges.length;
-    while (low < high) {
-      const middle = (low + high) >> 1;
-      if (this.#ranges[middle][1] < at) low = middle + 1;
-      else high = middle;
-    }
-    return low;
-  }
-
-  /**
-   * What these ranges would add, without adding them.
-   *
-   * @param {Array<[number, number]>} ranges
-   * @returns {number}
-   */
-  adds(ranges) {
-    let added = 0;
-    for (const [start, end] of merged(ranges)) {
-      let at = start;
-      for (let index = this.#from(start); at <= end && index < this.#ranges.length && this.#ranges[index][0] <= end; index++) {
-        const [heldStart, heldEnd] = this.#ranges[index];
-        if (heldStart > at) added += heldStart - at;
-        at = Math.max(at, heldEnd + 1);
-      }
-      if (at <= end) added += end - at + 1;
-    }
-    return added;
-  }
-
-  /** @param {Array<[number, number]>} ranges */
-  add(ranges) {
-    for (const [start, end] of merged(ranges)) {
-      this.total += this.adds([[start, end]]);
-      // Joined with every held range it touches or overlaps.
-      const first = this.#from(start - 1);
-      let last = first;
-      let joinedStart = start;
-      let joinedEnd = end;
-      while (last < this.#ranges.length && this.#ranges[last][0] <= end + 1) {
-        joinedStart = Math.min(joinedStart, this.#ranges[last][0]);
-        joinedEnd = Math.max(joinedEnd, this.#ranges[last][1]);
-        last++;
-      }
-      this.#ranges.splice(first, last - first, [joinedStart, joinedEnd]);
-    }
-  }
-}
-
-/** Inclusive ranges merged where they overlap or touch, ascending. @param {Array<[number, number]>} ranges */
-function merged(ranges) {
-  const sorted = [...ranges].sort((left, right) => left[0] - right[0]);
-  const out = [];
-  for (const [start, end] of sorted) {
-    const previous = out.at(-1);
-    if (previous && start <= previous[1] + 1) previous[1] = Math.max(previous[1], end);
-    else out.push([start, end]);
-  }
-  return out;
-}
-
-/**
- * The map's byte zones with each output's next run input raised to its first
- * segment's place.
- *
- * @template {{ outputKey: string, index: number, priority: number, urgent?: boolean, behind?: boolean, deferred?: boolean,
- *   ranges?: Array<[number, number]>, byteStart?: number, byteEnd?: number }} Zone
- * @param {Zone[]} zones - One or more per segment, as the map's pass made
- *   them: a segment's zone names all its ranges (`ranges`), any other one
- *   range (`byteStart`-`byteEnd`).
- * @param {(outputKey: string) => number | null} targetBytesOf - What the
- *   output's next run would be given to copy; nothing is raised without it.
- * @returns {Zone[]} In their order; raised zones are copies.
- */
-export function expandToTargetInputs(zones, targetBytesOf) {
-  // ONE WALK FOR EACH OUTPUT'S FIRST SEGMENT, and the segments after it only
-  // as far as the run's input reaches. The map names every segment of a film,
-  // and each pass used to group all of them and work out each one's highest
-  // priority before looking at the few the run copies: 26 s of the main thread
-  // in fifteen minutes of a two-hour AVI on Home Assistant (r24,
-  // torrent-tv/meta#178).
-  /** @type {Map<string, { index: number, priority: number, zone: Zone }>} */
-  const first = new Map();
-  for (const zone of zones) {
-    const best = first.get(zone.outputKey);
-    if (!best || zone.priority > best.priority || (zone.priority === best.priority && zone.index < best.index)) {
-      first.set(zone.outputKey, { index: zone.index, priority: zone.priority, zone });
-    }
-  }
-  /** @type {Map<string, { first: { index: number, priority: number, zone: Zone }, target: number, after: Map<number, Zone[]> }>} */
-  const runs = new Map();
-  for (const [outputKey, best] of first) {
-    const target = targetBytesOf(outputKey);
-    if (target > 0) runs.set(outputKey, { first: best, target, after: new Map() });
-  }
-  if (runs.size === 0) return zones;
-  /** @type {Map<string, Array<[number, number]>>} */
-  const held = new Map();
-  for (const zone of zones) {
-    const run = runs.get(zone.outputKey);
-    if (!run) continue;
-    if (zone.index === run.first.index) {
-      let ranges = held.get(zone.outputKey);
-      if (!ranges) held.set(zone.outputKey, ranges = []);
-      ranges.push(...rangesOf(zone));
-    } else if (zone.index > run.first.index) {
-      const list = run.after.get(zone.index);
-      if (list) list.push(zone);
-      else run.after.set(zone.index, [zone]);
-    }
-  }
-  /** @type {Map<Zone, Zone>} */
-  const raised = new Map();
-  for (const [outputKey, run] of runs) {
-    const holding = new HeldBytes(held.get(outputKey) ?? []);
-    // The run's input is a stretch of consecutive segments: one already made,
-    // or not yet worked out, ends it.
-    for (let index = run.first.index + 1; run.after.has(index); index++) {
-      const list = run.after.get(index);
-      const ranges = list.flatMap(rangesOf);
-      if (holding.total + holding.adds(ranges) > run.target) break;
-      holding.add(ranges);
-      for (const zone of list) {
-        raised.set(zone, { ...zone, priority: run.first.priority, urgent: run.first.zone.urgent,
-          behind: run.first.zone.behind, deferred: run.first.zone.deferred });
-      }
-    }
-  }
-  return raised.size === 0 ? zones : zones.map(zone => raised.get(zone) ?? zone);
-}
-
-/** The ranges a zone names, inclusive. */
-function rangesOf(zone) {
-  return Array.isArray(zone.ranges) ? zone.ranges : [[zone.byteStart, zone.byteEnd]];
-}