@torrent-tv/proxy 2.96.10 → 2.96.12

package/package.json

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

package/server.js

@@ -55,6 +55,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 { 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";
@@ -533,7 +534,9 @@ export async function startProxyServer({
         segmentSourceRanges.set(rangesKey, input.ranges);
         convert(input.ranges);
       }
-      return converted;
+      // 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).
+      return withoutRepeatedZones(converted);
     }
   });
   const mediaReads = new MediaReadRequests({

package/services/encode/EncodeOrchestrator.js

@@ -33,6 +33,24 @@ import { contentionPenalty } from "./contention.js";
 import { SegmentDemand } from "./SegmentDemand.js";
 import { runStateOf } from "./encode-run-state.js";
 
+/**
+ * Which of two bands of the map is wanted sooner: what is needed before
+ * playback can continue first, then the higher priority.
+ *
+ * Everything needed before playback can continue is ONE band, whatever its
+ * priority: two viewers each short of their own minimum share the machine, and
+ * neither is stopped for the other. Priority orders only what can wait.
+ *
+ * @param {{ urgent: boolean, priority: number }} left
+ * @param {{ urgent: boolean, priority: number }} right
+ * @returns {number} Negative when `left` is more urgent, zero when equal.
+ */
+export function compareUrgency(left, right) {
+  const urgent = Number(right.urgent === true) - Number(left.urgent === true);
+  if (urgent !== 0 || left.urgent === true) return urgent;
+  return right.priority - left.priority;
+}
+
 /**
  * @typedef {Object} SegmentCoverage
  * @property {(address: string) => number[]} provenNumbers
@@ -105,6 +123,14 @@ export class EncodeOrchestrator {
   /** The last state said out loud, so an unchanged state is not repeated. */
   #lastDescribed = "";
 
+  /**
+   * The most urgent band any live encoder stands in, over every output, as the
+   * pass that is deciding now found it. Null when no encoder is alive.
+   *
+   * @type {{ urgent: boolean, priority: number, address: string, index: number } | null}
+   */
+  #leading = null;
+
   /** What a stop and a start have cost on this host. */
   #costs = new RunCosts();
 
@@ -575,6 +601,9 @@ export class EncodeOrchestrator {
     for (const run of this.runsOn(address)) {
       run.noteProduced(index);
     }
+    // A closed piece moves its encoder forward, perhaps out of the band that
+    // led: who has the processor is decided again now, not at the next pass.
+    this.shareTheMachine();
   }
 
   /**
@@ -586,9 +615,11 @@ export class EncodeOrchestrator {
    */
   reconcile() {
     const addresses = new Set([...this.#demand.addresses(), ...this.#runs.keys()]);
+    this.#leading = this.#leadingBand();
     for (const address of addresses) {
       this.#reconcileOne(address);
     }
+    this.shareTheMachine();
     // WHAT THIS CLASS BELIEVES, said by this class. `describe()` was written
     // and called from nowhere, so on 2026-09-05 the question "why did the plan
     // not see the gap the viewer was stopped at" had to be answered by
@@ -604,6 +635,82 @@ export class EncodeOrchestrator {
     }
   }
 
+  /**
+   * How urgently the map wants one segment of one output: whether it is needed
+   * before playback can continue, and the map's priority for it. A number in
+   * nobody's zone is wanted least of all.
+   *
+   * The priority is a step of distance from a viewer on one scale for every
+   * output, so the picture and the soundtrack a viewer plays are compared on it
+   * directly.
+   *
+   * @param {string} address
+   * @param {number} index
+   * @returns {{ urgent: boolean, priority: number }}
+   */
+  #bandAt(address, index) {
+    let band = { urgent: false, priority: 0 };
+    for (const zone of this.#demand.mapOn(address)) {
+      if (index < zone.from || index > zone.to) continue;
+      const candidate = { urgent: zone.urgent === true, priority: Number(zone.priority) || 0 };
+      if (compareUrgency(candidate, band) < 0) band = candidate;
+    }
+    return band;
+  }
+
+  /**
+   * The most urgent band a live encoder stands in, over every output.
+   *
+   * @returns {{ urgent: boolean, priority: number, address: string, index: number } | null}
+   */
+  #leadingBand() {
+    let leading = null;
+    for (const [address, runs] of this.#runs) {
+      for (const run of runs) {
+        if (!run.isAlive || run.isStopping) continue;
+        const band = this.#bandAt(address, run.head);
+        if (!leading || compareUrgency(band, leading) < 0) leading = { ...band, address, index: run.head };
+      }
+    }
+    return leading;
+  }
+
+  /**
+   * WHO GETS THE PROCESSOR FIRST, over every output at once.
+   *
+   * Each output is planned on its own, and a file is encoded whole in the order
+   * its map gives (the rule of 2026-09-05), so an output that is cheap to make
+   * runs far ahead of one that is dear: field 2026-10-10, a copied soundtrack
+   * at 38 minutes while its picture, re-encoded at 0.65–1.31x, was at five and
+   * the viewer stalled. The machine is one, so the order is one: an encoder
+   * making something less urgent than what another encoder is making somewhere
+   * stands still where it is — paused, not stopped, so it keeps its place, its
+   * input and its claim — and goes on the moment nothing more urgent is being
+   * made. The encoder in the most urgent band is never paused, so something is
+   * always being made.
+   *
+   * Paused rather than lowered in priority: a lowered priority cannot be raised
+   * again without `CAP_SYS_NICE`, which the add-on's container does not have
+   * (Home Assistant 2026-10-10: `renice 0` after `renice 19` left 19).
+   */
+  shareTheMachine() {
+    const leading = this.#leadingBand();
+    this.#leading = leading;
+    if (!leading) return;
+    for (const [address, runs] of this.#runs) {
+      for (const run of runs) {
+        if (!run.isAlive || run.isStopping || typeof run.pause !== "function") continue;
+        const behind = compareUrgency(this.#bandAt(address, run.head), leading) > 0;
+        if (behind && run.isSuspended !== true) {
+          run.pause(`#${run.head} of ${address} is wanted less urgently than #${leading.index} of ${leading.address}, ` +
+            `which is being made`);
+        } else if (!behind && run.isSuspended === true) {
+          run.resume(`nothing more urgent than #${run.head} of ${address} is being made`);
+        }
+      }
+    }
+  }
+
   /**
    * @param {string} address
    */
@@ -739,7 +846,16 @@ export class EncodeOrchestrator {
         `live=${JSON.stringify(live.map((run) => ({ from: run.from, to: run.to, head: run.head, speedX: run.speedX })))}`
       );
     }
+    // A START BEHIND WHAT IS BEING MADE ELSEWHERE IS NOT MADE: the encoder would
+    // be paused the moment it exists (`shareTheMachine`), holding a process and
+    // its input for nothing. It is placed when nothing more urgent is in hand.
+    let heldBack = null;
     for (const action of actions) {
+      if (action.type === "start" && this.#leading &&
+          compareUrgency(this.#bandAt(address, action.from), this.#leading) > 0) {
+        heldBack = action;
+        continue;
+      }
       if (action.type === "stop") {
         this.#stop(action.run, action.because);
         continue;
@@ -795,6 +911,15 @@ export class EncodeOrchestrator {
     const stillRunning = this.runsOn(address).filter((run) => run.isAlive);
     if (wanting === null || stillRunning.length > 0) {
       this.#lastUnmet.delete(address);
+    } else if (heldBack) {
+      const said = `held:${heldBack.from}:${this.#leading?.address}:${this.#leading?.index}`;
+      if (this.#lastUnmet.get(address) !== said) {
+        this.#lastUnmet.set(address, said);
+        this.logger.info(
+          `encode: #${heldBack.from} of ${address} waits — #${this.#leading?.index} of ` +
+          `${this.#leading?.address} is wanted more urgently and is being made`
+        );
+      }
     } else if (this.#lastUnmet.get(address) !== wanting) {
       this.#lastUnmet.set(address, wanting);
       const held = this.#segmentCoverage ? this.#segmentCoverage.filesHeld(address) : -1;

package/services/encode/EncodeRun.js

@@ -216,6 +216,8 @@ export class EncodeRun {
    *   encoder itself names it on its own channel, and answers with the name that
    *   piece is served under — because making it servable is a rename, and only
    *   whoever owns the disk can perform one.
+   * @param {(index: number) => void} [params.onProduced] - Called with every
+   *   segment number this run has closed, as it closes it.
    * @param {(progress: object) => void} [params.onProgress] - Called with this
    *   run's progress on the source timeline after every `-progress` report.
    * @param {() => number | null} [params.lastSegmentIndex] - The film's last
@@ -251,6 +253,7 @@ export class EncodeRun {
     onSpeedMeasured,
     onClosed,
     onProgress,
+    onProduced,
     lastSegmentIndex,
     inputUnavailable,
     argsDescribed = "",
@@ -274,6 +277,7 @@ export class EncodeRun {
     this.clock = new RunClock({ now: this.now });
     this.onEnded = typeof onEnded === "function" ? onEnded : () => {};
     this.onProgress = typeof onProgress === "function" ? onProgress : () => {};
+    this.onProduced = typeof onProduced === "function" ? onProduced : () => {};
     this.onSpeedMeasured = typeof onSpeedMeasured === "function" ? onSpeedMeasured : () => {};
     // Told the NAME of every piece the encoder has closed. The name is the
     // proof it is whole; nothing else here can prove that.
@@ -569,6 +573,7 @@ export class EncodeRun {
       if (this.#state === ENCODE_RUN_STATE.STARTING) {
         this.#transition(ENCODE_RUN_EVENT.FIRST_SEGMENT);
       }
+      this.onProduced(index);
     }
   }
 

package/services/encode/EncodeRuns.js

@@ -999,6 +999,9 @@ export class EncodeRuns {
         run.to,
       inputUnavailable: (message) => isInputUnavailable(message),
       onProgress: (report) => this.#noteRunProgress(session, run, report),
+      // A closed piece moves this encoder forward, perhaps out of the band that
+      // led; who has the processor is decided again at once.
+      onProduced: () => this.#host.encodeOrchestrator?.shareTheMachine?.(),
       indexOfName: (name) => session.segmentFormat.segmentIndexFromName(
         session.segmentFormat.servedNameOf?.(name) ?? name),
       // Why this encoder exists, recorded with its argument list. It used to be

package/services/torrent/map-zones.js

@@ -0,0 +1,91 @@
+/**
+ * @file What one zone of the priority map tells the torrent: the level of
+ * urgency it is stated at, and the band the swarm ranks it by.
+ *
+ * Pure arithmetic over the zone's own fields, so the main thread can ask the
+ * same question before a map is sent and the torrent thread when it is applied.
+ */
+import { isAtAWatchingViewer, isBehindEverybody, isNobodyComingNow } from "../viewer/PriorityMap.js";
+import { Urgency } from "./demand/Urgency.js";
+import { compareBands } from "./download/bands.js";
+
+/**
+ * Which level of urgency one zone is stated at, from the map's own number
+ * and nothing else. The map's numbers are a scale as long as the film needs
+ * — ten bands on a fifty-minute film — while the register has five levels,
+ * and the fit is by meaning:
+ *
+ *  - the top of the scale is where a viewer is standing, so it is the
+ *    cushion being built: {@link Urgency.NEAR}. Never BLOCKED — that level
+ *    means a reader is stopped on those bytes right now, which only a read
+ *    can say;
+ *  - the bottom is what nobody is approaching: behind a viewer moving
+ *    forward, and the whole film of a viewer who has stopped the picture.
+ *    Wanted only if somebody seeks back, which is {@link Urgency.BEHIND};
+ *  - one above the bottom is the far tail — wanted for certain if the
+ *    viewer watches on, and not before: {@link Urgency.TAIL};
+ *  - everything between is the lead being built: {@link Urgency.AHEAD}.
+ *
+ * Read from the scale's own ends rather than from the highest and lowest
+ * number in THIS file's map. The two speculative levels are withheld across
+ * every torrent at once while anything urgent is missing anywhere, so a
+ * paused viewer's film has to compare as wanted-last against another film
+ * somebody is watching — and relative to itself alone it would compare as
+ * the most urgent thing there is.
+ *
+ * @param {{ priority?: number, behind?: boolean, deferred?: boolean, urgent?: boolean }} zone
+ * @returns {number}
+ */
+export function levelOfMapZone(zone) {
+  // Read through the map's own words rather than by comparing its numbers.
+  // The scale is that layer's, and the numbers inside a band mean nothing
+  // but their order.
+  const priority = zone.priority ?? 0;
+  if (zone.behind === true || (zone.behind === undefined && isBehindEverybody(priority))) {
+    return Urgency.BEHIND;
+  }
+  if (zone.deferred === true || (zone.deferred === undefined && isNobodyComingNow(priority))) {
+    // In front of somebody who has stopped the picture, and of nobody who is
+    // watching. Wanted, and wanted after everyone who is on their way.
+    return Urgency.TAIL;
+  }
+  return (zone.urgent === true || (zone.urgent === undefined && isAtAWatchingViewer(priority))) ? Urgency.NEAR : Urgency.AHEAD;
+}
+
+/** The priority a zone is stated at, within the register's scale. */
+export function priorityOfMapZone(zone) {
+  return Number.isFinite(zone.priority) ? Math.max(1, Math.min(100, zone.priority)) : 1;
+}
+
+/** When a zone's bytes are needed, as an instant; `now` reads `withinSeconds`. */
+export function deadlineOfMapZone(zone, now = Date.now()) {
+  return Number.isFinite(zone.deadlineAt) ? zone.deadlineAt :
+    Number.isFinite(zone.withinSeconds) ? now + Math.max(0, zone.withinSeconds) * 1000 : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * The zones with every repeat of the same bytes left out but the one the swarm
+ * would rank first.
+ *
+ * Each piece is fetched in the band of the best zone that holds it
+ * ({@link compareBands}), so a zone naming exactly the bytes of a better one
+ * changes nothing the swarm is told. The ranges an AVI's picture reads at open
+ * — its declarations and its indexes — are named again in the zone of every
+ * segment: field 2026-10-10 (torrent-tv/meta#166), maps of 9700 zones, for a
+ * film of 2035 segments, cost half a second each to deliver.
+ *
+ * @template {{ byteStart: number, byteEnd: number }} Zone
+ * @param {Zone[]} zones
+ * @param {number} [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 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) });
+  });
+  return zones.filter((zone, index) => best.get(`${zone.byteStart}:${zone.byteEnd}`).index === index);
+}

package/services/torrent/torrent-pool.js

@@ -20,7 +20,7 @@ import { demandProgress } from "./demand-progress.js";
 import { Urgency, urgencyName } from "./demand/index.js";
 import { demandFor, firstClassStatement, forgetTorrent, reconcileAll, hasUnmetDemand } from "./download/registry.js";
 import { withdrawClaim } from "./download/withdraw-claim.js";
-import { isAtAWatchingViewer, isBehindEverybody, isNobodyComingNow } from "../viewer/PriorityMap.js";
+import { deadlineOfMapZone, levelOfMapZone, priorityOfMapZone } from "./map-zones.js";
 import { deriveSourceKey } from "../../utils/torrent-source-key.js";
 import { noteTorrentDestroyed } from "./destroyed-torrents.js";
 
@@ -1290,48 +1290,9 @@ export class TorrentPool {
       .filter((zone) => Number.isSafeInteger(zone?.byteStart) && Number.isSafeInteger(zone?.byteEnd) &&
         zone.byteStart >= 0 && zone.byteEnd >= zone.byteStart && zone.byteStart < length)
       .sort((left, right) => (right.priority ?? 0) - (left.priority ?? 0));
-    /**
-     * Which level of urgency one zone is stated at, from the map's own number
-     * and nothing else. The map's numbers are a scale as long as the film needs
-     * — ten bands on a fifty-minute film — while the register has five levels,
-     * and the fit is by meaning:
-     *
-     *  - the top of the scale is where a viewer is standing, so it is the
-     *    cushion being built: {@link Urgency.NEAR}. Never BLOCKED — that level
-     *    means a reader is stopped on those bytes right now, which only a read
-     *    can say;
-     *  - the bottom is what nobody is approaching: behind a viewer moving
-     *    forward, and the whole film of a viewer who has stopped the picture.
-     *    Wanted only if somebody seeks back, which is {@link Urgency.BEHIND};
-     *  - one above the bottom is the far tail — wanted for certain if the
-     *    viewer watches on, and not before: {@link Urgency.TAIL};
-     *  - everything between is the lead being built: {@link Urgency.AHEAD}.
-     *
-     * Read from the scale's own ends rather than from the highest and lowest
-     * number in THIS file's map. The two speculative levels are withheld across
-     * every torrent at once while anything urgent is missing anywhere, so a
-     * paused viewer's film has to compare as wanted-last against another film
-     * somebody is watching — and relative to itself alone it would compare as
-     * the most urgent thing there is.
-     *
-     * @param {{ priority?: number }} zone
-     * @returns {number}
-     */
-    const levelOf = (zone) => {
-      // Read through the map's own words rather than by comparing its numbers.
-      // The scale is that layer's, and the numbers inside a band mean nothing
-      // but their order.
-      const priority = zone.priority ?? 0;
-      if (zone.behind === true || (zone.behind === undefined && isBehindEverybody(priority))) {
-        return Urgency.BEHIND;
-      }
-      if (zone.deferred === true || (zone.deferred === undefined && isNobodyComingNow(priority))) {
-        // In front of somebody who has stopped the picture, and of nobody who is
-        // watching. Wanted, and wanted after everyone who is on their way.
-        return Urgency.TAIL;
-      }
-      return (zone.urgent === true || (zone.urgent === undefined && isAtAWatchingViewer(priority))) ? Urgency.NEAR : Urgency.AHEAD;
-    };
+    // Which level each zone is stated at: `map-zones.js`, where the main thread
+    // reads the same rule before it sends a map.
+    const levelOf = levelOfMapZone;
     ordered.forEach((zone, index) => {
       // Only ranges declared by the container index or metadata read are wanted.
       const byteStart = zone.byteStart;
@@ -1345,10 +1306,9 @@ export class TorrentPool {
         byteStart,
         byteEnd,
         urgency: levelOf(zone),
-        priority: Number.isFinite(zone.priority) ? Math.max(1, Math.min(100, zone.priority)) : 1,
+        priority: priorityOfMapZone(zone),
         order: Number.isSafeInteger(zone.order) && zone.order >= 0 ? zone.order : 0,
-        deadlineAt: Number.isFinite(zone.deadlineAt) ? zone.deadlineAt :
-          Number.isFinite(zone.withinSeconds) ? Date.now() + Math.max(0, zone.withinSeconds) * 1000 : Number.POSITIVE_INFINITY,
+        deadlineAt: deadlineOfMapZone(zone),
         requestId: zone.requestId ?? `${torrent.infoHash}:${fileIndex}:map`
       });
     });