@torrent-tv/proxy 2.96.4 → 2.96.6

package/package.json

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

package/server.js

@@ -422,6 +422,7 @@ export async function startProxyServer({
   const segmentSourceRanges = new Map();
   const downloadMaps = new DownloadMaps({
     publish: (map) => torrentPool.setPriorityMap(map),
+    log: (line) => logger.info(line),
     resolvePlayback: async (map) => {
       if (map.zones.length === 0) return [];
       const params = await containerOver(map);
@@ -630,7 +631,9 @@ export async function startProxyServer({
       error.canRetry = true;
       throw error;
     },
-    resolveEncodeInput: async (output, fromIndex, toIndex) => {
+    // `timing`, when given, is told how long each read of a file waited behind
+    // the reads asked before it and how long it took (torrent-tv/meta#166).
+    resolveEncodeInput: async (output, fromIndex, toIndex, timing = null) => {
       const grid = output.timeline?.published ?? output.timeline?.boundaries;
       const from = grid?.[fromIndex], to = grid?.[toIndex + 1];
       if (!Number.isFinite(from) || !(to > from)) return { kind: "terminal", reason: "output-interval-not-declared" };
@@ -650,6 +653,13 @@ export async function startProxyServer({
       for (const [fileIndex, choices] of selected) {
         const params = await containerOver({ sourceKey: output.file.sourceKey, fileIndex });
         if (!params) return { kind: "needs-source" };
+        if (timing) {
+          params.onTimed = (_statement, waitedMs, readMs) => {
+            timing.reads += 1;
+            timing.queuedMs += waitedMs;
+            timing.readMs += readMs;
+          };
+        }
         const tracks = await containerOrchestrator.inspect(params, "tracks");
         if (tracks.kind !== "result") return tracks;
         const container = containerOrchestrator.known(params.sourceKey, fileIndex);

package/services/encode/EncodeInputs.js

@@ -59,12 +59,36 @@ export class EncodeInputs {
     this.#now = now;
   }
 
-  /** One line when a request's state changes, so a wait that never ends names what it waits for. */
-  #note(request, state) {
+  /**
+   * One line when a request's state changes, so a wait that never ends names
+   * what it waits for. `detail` is said with it and does not count as a change.
+   */
+  #note(request, state, detail = "") {
     if (request.noted === state) return;
     request.noted = state;
     this.#log(`encode input #${request.from}..#${request.to} of ${request.output.outputKey ?? request.output.id}: ${state}` +
-      ` (held ${this.#held} of ${this.#allowed} allowed)`);
+      ` (held ${this.#held} of ${this.#allowed} allowed)${detail}`);
+  }
+
+  /** The container's statement of an interval, its time added to the request's account. */
+  async #resolveTimed(timing, output, from, to) {
+    const startedAt = this.#now();
+    try {
+      return await this.#resolve(output, from, to, timing);
+    } finally {
+      timing.resolutions += 1;
+      timing.resolveMs += this.#now() - startedAt;
+    }
+  }
+
+  /** `work`'s time added to one field of the request's account. */
+  async #spent(timing, field, work) {
+    const startedAt = this.#now();
+    try {
+      return await work();
+    } finally {
+      timing[field] += this.#now() - startedAt;
+    }
   }
 
   held() { return this.#held; }
@@ -216,8 +240,14 @@ export class EncodeInputs {
     request.stale = false;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
+    // Where the time from the request to its input goes, across every attempt:
+    // field 2026-10-10, a picture's request took 38 s before its copy began and
+    // nothing said on what (torrent-tv/meta#166).
+    request.timing ??= { askedAt: this.#now(), attempts: 0, resolutions: 0, resolveMs: 0,
+      reads: 0, queuedMs: 0, readMs: 0, heldMs: 0, budgetMs: 0 };
+    request.timing.attempts += 1;
     request.promise = (async () => {
-      const resolved = await this.#resolve(request.output, request.from, request.from);
+      const resolved = await this.#resolveTimed(request.timing, request.output, request.from, request.from);
       if (this.#requests.get(request.key) !== request) return;
       let result;
       if (resolved.kind !== "result") {
@@ -240,7 +270,8 @@ export class EncodeInputs {
       request.result = result;
       this.#note(request, result.kind === "result" ? `ready #${result.from}..#${result.to}, ${result.bytes ?? "?"} bytes` +
         (Number.isFinite(result.copyMs) ? `, copied in ${result.copyMs}ms` : "")
-        : `${result.kind}${result.reason ? ` ${result.reason}` : ""}${Number.isFinite(result.bytes) ? ` ${result.bytes} bytes` : ""}`);
+        : `${result.kind}${result.reason ? ` ${result.reason}` : ""}${Number.isFinite(result.bytes) ? ` ${result.bytes} bytes` : ""}`,
+      describeTiming(request.timing, this.#now()));
       if (result.kind === "result" || result.kind === "terminal") this.#changed(request.output, result);
     })().catch(error => {
       if (this.#requests.get(request.key) === request) {
@@ -261,7 +292,7 @@ export class EncodeInputs {
   #reserveFor(request) {
     return async bytes => {
       this.#wanted.set(request.key, { wanted: bytes, required: bytes });
-      await this.#revise();
+      await this.#spent(request.timing, "budgetMs", () => this.#revise());
       const capacity = this.#capacity();
       if (capacity !== null && bytes > capacity && this.#urgent(request.output, request.from)) return {
         kind: "terminal", reason: "source-input-exceeds-memory-capacity", bytes, capacity
@@ -303,7 +334,7 @@ export class EncodeInputs {
       if (!stretches.has(end)) {
         // A longer stretch that cannot be stated is not one to copy; the
         // shorter one already stated still runs.
-        const resolved = await this.#resolve(output, from, end).catch(() => null);
+        const resolved = await this.#resolveTimed(request.timing, output, from, end).catch(() => null);
         stretches.set(end, resolved?.kind === "result" && resolved.sources?.every(source => source.input.original === true)
           ? { sources: resolved.sources, bytes: originalInputBytes(resolved.sources) } : null);
       }
@@ -311,7 +342,7 @@ export class EncodeInputs {
     };
     const fits = async (end, maxBytes) => {
       const stretch = await at(end);
-      return Boolean(stretch) && stretch.bytes <= maxBytes && await this.#present(stretch.sources, held);
+      return Boolean(stretch) && stretch.bytes <= maxBytes && await this.#present(stretch.sources, held, request.timing);
     };
     // Grows by doubling and then halves back: a handful of resolutions find
     // the end whether it is a piece away or the rest of the film.
@@ -333,7 +364,7 @@ export class EncodeInputs {
     let end = target === null || this.#heldRanges === null ? from : await longest(target);
     if (this.#requests.get(request.key) !== request) return undefined;
     this.#wanted.set(request.key, { wanted: stretches.get(end).bytes, required: minimum });
-    await this.#revise();
+    await this.#spent(request.timing, "budgetMs", () => this.#revise());
     if (this.#requests.get(request.key) !== request) return undefined;
     const capacity = this.#capacity();
     if (capacity !== null && minimum > capacity && this.#urgent(output, from)) {
@@ -371,10 +402,10 @@ export class EncodeInputs {
   }
 
   /** Whether every range of these sources is downloaded whole now. */
-  async #present(sources, held) {
+  async #present(sources, held, timing) {
     for (const source of sources) {
       const name = `${source.sourceKey}:${source.fileIndex}`;
-      if (!held.has(name)) held.set(name, await Promise.resolve().then(() => this.#heldRanges(source)).catch(() => null) ?? []);
+      if (!held.has(name)) held.set(name, await this.#spent(timing, "heldMs", () => Promise.resolve().then(() => this.#heldRanges(source)).catch(() => null)) ?? []);
       const ranges = held.get(name);
       if (!source.input.ranges.every(([start, end]) => ranges.some(([first, last]) => first <= start && last >= end))) return false;
     }
@@ -382,5 +413,24 @@ export class EncodeInputs {
   }
 }
 
+/**
+ * Where a request has spent its time since it was asked, as one clause of its
+ * log line. The resolutions include the reads of the file they made, and those
+ * reads are split into the time spent behind earlier reads of the same file and
+ * the time of the read itself; what is left of the total is the copy and the
+ * waits between attempts for bytes or memory.
+ *
+ * @param {object | undefined} timing
+ * @param {number} now
+ * @returns {string}
+ */
+function describeTiming(timing, now) {
+  if (!timing) return "";
+  return `; asked ${Math.max(0, now - timing.askedAt)}ms ago over ${timing.attempts} attempt(s): ` +
+    `${timing.resolutions} resolution(s) ${timing.resolveMs}ms ` +
+    `(${timing.reads} file read(s): queued ${timing.queuedMs}ms, reading ${timing.readMs}ms), ` +
+    `held ranges ${timing.heldMs}ms, budget ${timing.budgetMs}ms`;
+}
+
 function addressOf(output) { return output.outputKey ?? output.id; }
 function keyOf(output, from) { return `${addressOf(output)}:${from}`; }

package/services/media/ContainerOrchestrator.js

@@ -137,10 +137,16 @@ export class ContainerOrchestrator {
     if (!lifetime) this.#lifetimes.set(key, lifetime = {});
     const isCurrent = () => this.#lifetimes.get(key) === lifetime && params.isCurrent?.() !== false;
     const previous = this.#reads.get(key) ?? Promise.resolve();
+    // Reads of one file run one after another, so an answer can wait for every
+    // read asked before it. Told to whoever asked, apart from the read itself,
+    // because the two call for different remedies (torrent-tv/meta#166).
+    const askedAt = Date.now();
     const reading = previous.catch(() => undefined).then(async () => {
       if (!isCurrent()) return { result: { kind: "terminal", reason: "request-obsolete", requestId: params.requestId } };
+      const startedAt = Date.now();
       const revision = params.onReadStart?.(statement);
       const result = await this.#inspectRead({ ...params, isCurrent }, statement);
+      params.onTimed?.(statement, startedAt - askedAt, Date.now() - startedAt);
       return { result, revision };
     });
     this.#reads.set(key, reading);

package/services/torrent/worker/client.js

@@ -476,7 +476,7 @@ export class TorrentWorkerClient {
    * @returns {Promise<void>}
    */
   async setPriorityMap({ sourceKey, fileIndex, zones, durationSeconds }) {
-    await this.#caller.call(Command.PRIORITY_MAP, {
+    return this.#caller.call(Command.PRIORITY_MAP, {
       sourceKey,
       fileIndex,
       zones,

package/services/torrent/worker/pool-adapter.js

@@ -168,7 +168,7 @@ export class WorkerTorrentPool {
     if (!sourceKey) {
       return;
     }
-    await this.#client.setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones });
+    return this.#client.setPriorityMap({ sourceKey, fileIndex, durationSeconds, zones });
   }
 
   /**

package/services/torrent/worker/worker.js

@@ -459,12 +459,17 @@ async function runCommand(command, params, id) {
       const zones = Array.isArray(params.zones) ? params.zones : [];
       // Nor may one for a file held whole, which has nothing left to fetch.
       const torrent = await knownTorrent(params.sourceKey);
-      if (torrent) {
-        ensureArrivalsWired(params.sourceKey, torrent);
-        pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
-        torrent.emit("priority-map-changed", params.fileIndex);
+      if (!torrent) {
+        return { appliedMs: null };
       }
-      return true;
+      // What applying a map costs this thread, told to whoever sent it: every
+      // zone becomes a window of the register and the swarm is told again
+      // (torrent-tv/meta#166).
+      const startedAt = performance.now();
+      ensureArrivalsWired(params.sourceKey, torrent);
+      pool.applyPriorityMap(torrent, params.fileIndex, zones, params.durationSeconds);
+      torrent.emit("priority-map-changed", params.fileIndex);
+      return { appliedMs: performance.now() - startedAt };
     }
 
     case Command.READ_RANGE: {

package/services/viewer/DownloadMaps.js

@@ -1,14 +1,24 @@
+/**
+ * How often what the publications of one file cost is said, at most: the
+ * cadence of the proxy's other once-a-minute readings.
+ */
+const REPORT_EVERY_MS = 60_000;
+
 /** One published download map per file, including download-only metadata reads. */
 export class DownloadMaps {
   #files = new Map();
   #publish;
   #resolvePlayback;
   #nextEpoch = 0;
+  #log;
+  #now;
 
-  constructor({ publish, resolvePlayback = async map => map.zones }) {
+  constructor({ publish, resolvePlayback = async map => map.zones, log = null, now = Date.now }) {
     if (typeof publish !== "function") throw new TypeError("Download map publication is required.");
     this.#publish = publish;
     this.#resolvePlayback = resolvePlayback;
+    this.#log = typeof log === "function" ? log : null;
+    this.#now = now;
   }
 
   async playback({ sourceKey, fileIndex, durationSeconds, zones }) {
@@ -197,11 +207,130 @@ export class DownloadMaps {
       }
     }
     const publication = { sourceKey: file.sourceKey, fileIndex: file.fileIndex, durationSeconds: file.durationSeconds, zones };
+    // SENT ONLY WHEN THE TORRENT WOULD ACT ON IT DIFFERENTLY: other bytes,
+    // another level or order of claim, or deadlines in another order. A map was
+    // sent after every read of the file's statements, changed or not, and the
+    // read waited for it: field 2026-10-10, 48-64 such reads per stretch of a
+    // two-hour AVI, 28-54 s before its copy began, with 5-12 thousand zones in
+    // each map (torrent-tv/meta#166). A deadline worked out again on a later
+    // clock moves every zone of a viewer playing on by the same amount and
+    // orders nothing differently, so the deadlines' order is compared and not
+    // their values.
+    const shape = shapeOf(publication);
+    if (file.shape && sameShape(file.shape, shape)) {
+      this.#statsOf(file).unchanged += 1;
+      this.#report(file);
+      return Promise.resolve();
+    }
+    file.shape = shape;
     const pending = file.pending.then(() => {
-      if (this.#files.get(`${file.sourceKey}:${file.fileIndex}`) === file) return this.#publish(publication);
+      if (this.#files.get(`${file.sourceKey}:${file.fileIndex}`) !== file) return undefined;
+      const sentAt = this.#now();
+      return Promise.resolve(this.#publish(publication)).then(reply => {
+        // A torrent not yet in the thread applies nothing, so this map was not
+        // delivered and the next one, however alike, has to be.
+        if (reply?.appliedMs === null && file.shape === shape) file.shape = null;
+        // The window open now, which a report since this map was asked for may have started.
+        const stats = this.#statsOf(file);
+        stats.sent += 1;
+        stats.zones.push(zones.length);
+        stats.deliveredMs.push(this.#now() - sentAt);
+        if (Number.isFinite(reply?.appliedMs)) stats.appliedMs.push(reply.appliedMs);
+        this.#report(file);
+        return reply;
+      });
+    });
+    // A failed publication must not prevent the next state change from being
+    // sent, and leaves nothing to compare the next one against.
+    file.pending = pending.catch(() => {
+      if (file.shape === shape) file.shape = null;
     });
-    // A failed publication must not prevent the next state change from being sent.
-    file.pending = pending.catch(() => undefined);
     return pending;
   }
+
+  #statsOf(file) {
+    file.stats ??= { since: this.#now(), sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [] };
+    return file.stats;
+  }
+
+  /** What this file's publications cost, said once a minute at most and only when one was asked for. */
+  #report(file) {
+    const stats = file.stats;
+    const now = this.#now();
+    if (!this.#log || !stats || now - stats.since < REPORT_EVERY_MS) return;
+    const total = values => Math.round(values.reduce((sum, value) => sum + value, 0));
+    this.#log(`download map ${file.sourceKey.slice(0, 48)}:${file.fileIndex}: ${stats.sent} sent and ` +
+      `${stats.unchanged} unchanged not sent in ${((now - stats.since) / 1000).toFixed(1)}s; ` +
+      `zones median ${middle(stats.zones)} max ${largest(stats.zones)}; ` +
+      `delivered median ${middle(stats.deliveredMs)}ms max ${largest(stats.deliveredMs)}ms (${total(stats.deliveredMs)}ms in all), ` +
+      `applied in the torrent thread median ${middle(stats.appliedMs)}ms max ${largest(stats.appliedMs)}ms ` +
+      `(${total(stats.appliedMs)}ms in all)`);
+    file.stats = { since: now, sent: 0, unchanged: 0, zones: [], deliveredMs: [], appliedMs: [] };
+  }
+}
+
+/** How many numbers describe one zone's part in what the torrent does. */
+const ZONE_FIELDS = 7;
+
+/** @param {boolean | undefined} value */
+function flag(value) {
+  return value === true ? 2 : value === false ? 1 : 0;
+}
+
+/** @param {{ deadlineAt?: number }} zone */
+function deadlineOf(zone) {
+  return Number.isFinite(zone.deadlineAt) ? zone.deadlineAt : Number.POSITIVE_INFINITY;
+}
+
+/**
+ * What the torrent acts on in a publication, packed for comparison: each
+ * zone's bytes, priority, words of level, order of claim, and the RANK of its
+ * deadline among the map's zones rather than the deadline itself. A zone with
+ * no deadline carries the time it is wanted within, which the torrent turns
+ * into a deadline on its own clock when the map is applied.
+ *
+ * @param {{ durationSeconds: number, zones: object[] }} publication
+ * @returns {{ durationSeconds: number, fields: Float64Array }}
+ */
+function shapeOf({ durationSeconds, zones }) {
+  const byDeadline = zones.map((_zone, index) => index).sort((left, right) => {
+    const first = deadlineOf(zones[left]);
+    const second = deadlineOf(zones[right]);
+    return first === second ? left - right : first < second ? -1 : 1;
+  });
+  const fields = new Float64Array(zones.length * ZONE_FIELDS);
+  byDeadline.forEach((index, rank) => {
+    fields[index * ZONE_FIELDS + 5] = rank;
+  });
+  zones.forEach((zone, index) => {
+    const at = index * ZONE_FIELDS;
+    fields[at] = Number.isFinite(zone.byteStart) ? zone.byteStart : -1;
+    fields[at + 1] = Number.isFinite(zone.byteEnd) ? zone.byteEnd : -1;
+    fields[at + 2] = Number.isFinite(zone.priority) ? zone.priority : -1;
+    fields[at + 3] = flag(zone.urgent) * 27 + flag(zone.deferred) * 9 + flag(zone.behind) * 3 + flag(zone.downloadOnly);
+    fields[at + 4] = Number.isSafeInteger(zone.order) ? zone.order : 0;
+    fields[at + 6] = Number.isFinite(zone.deadlineAt) ? -2 : Number.isFinite(zone.withinSeconds) ? zone.withinSeconds : -1;
+  });
+  return { durationSeconds: Number.isFinite(durationSeconds) ? durationSeconds : -1, fields };
+}
+
+/** @param {{ durationSeconds: number, fields: Float64Array }} left @param {{ durationSeconds: number, fields: Float64Array }} right */
+function sameShape(left, right) {
+  if (left.durationSeconds !== right.durationSeconds || left.fields.length !== right.fields.length) return false;
+  for (let index = 0; index < left.fields.length; index++) {
+    if (left.fields[index] !== right.fields[index]) return false;
+  }
+  return true;
+}
+
+/** @param {number[]} values */
+function middle(values) {
+  if (values.length === 0) return "n/a";
+  const sorted = [...values].sort((left, right) => left - right);
+  return Math.round(sorted[Math.floor(sorted.length / 2)]);
+}
+
+/** @param {number[]} values */
+function largest(values) {
+  return values.length === 0 ? "n/a" : Math.round(Math.max(...values));
 }