@torrent-tv/proxy 2.97.0 → 2.97.2

package/package.json

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

package/services/encode/EncodeInputs.js

@@ -33,8 +33,13 @@ export class EncodeInputs {
   #wanted = new Map();
   /** Bytes per millisecond of recent original-input copies, read where the copy is made. */
   #copyRates = [];
-  /** Seconds an encoder took to open its original input, per output. */
-  #opens = new Map();
+  /**
+   * How long an encoder takes to open an output's original input: asked of
+   * the one owner of start readings (`RunCosts`, torrent-tv/meta#184).
+   *
+   * @type {(output: object) => { seconds: number, measured: boolean } | null}
+   */
+  #openOf;
   #resolve;
   #read;
   #heldRanges;
@@ -46,7 +51,9 @@ export class EncodeInputs {
   #log;
   #now;
 
-  constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true, log = () => {}, now = Date.now }) {
+  constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true,
+    openOf = () => null, log = () => {}, now = Date.now }) {
+    this.#openOf = openOf;
     this.#resolve = resolve;
     this.#read = readRanges;
     this.#heldRanges = heldRanges;
@@ -130,10 +137,26 @@ export class EncodeInputs {
     return null;
   }
 
-  retain(output, windows) {
+  /**
+   * Withdraw what this output no longer needs: a request no wanted window
+   * covers, and — when `starts` is given — a copy already held whose start is
+   * neither where a live run ends nor where one is being started. A next
+   * stretch is copied for the run working before it (torrent-tv/meta#158);
+   * once that run has gone and the plan starts elsewhere, after a seek, the
+   * copy held memory nobody would use (torrent-tv/meta#184).
+   *
+   * @param {object} output
+   * @param {{ from: number, to: number }[]} windows
+   * @param {Set<number> | null} [starts]
+   */
+  retain(output, windows, starts = null) {
     for (const [key, request] of this.#requests) {
-      if (request.output !== output || windows.some(window => request.from <= window.to && request.to >= window.from)) continue;
-      this.#note(request, "withdrawn: no wanted window covers it");
+      if (request.output !== output) continue;
+      const covered = windows.some(window => request.from <= window.to && request.to >= window.from);
+      const unused = starts !== null && request.result?.kind === "result" && !starts.has(request.from);
+      if (covered && !unused) continue;
+      this.#note(request, covered ? "withdrawn: no live run ends before it and no start is placed there"
+        : "withdrawn: no wanted window covers it");
       this.#requests.delete(key);
       this.#wanted.delete(key);
       request.result?.release?.();
@@ -154,16 +177,13 @@ export class EncodeInputs {
     let existing = this.#requests.get(key);
     if (existing && existing.to !== to) {
       // The plan's bound for this start moved. A copy already made beyond it
-      // would be a run over somebody else's stretch, so it is given back; one
-      // being made is checked when it is done, and one waiting for bytes or
-      // memory takes the new bound when its own event prepares it again.
+      // holds the shorter stretch whole, so the run is commanded over its
+      // prefix and the copy is kept until the run ends: copying it again cost
+      // as long as the first copy (torrent-tv/meta#184). One being made is
+      // narrowed when it is done, and one waiting for bytes or memory takes the
+      // new bound when its own event prepares it again.
       existing.to = to;
-      if (existing.result?.kind === "result" && existing.result.to > to) {
-        this.#requests.delete(key);
-        this.#wanted.delete(key);
-        existing.result.release();
-        existing = undefined;
-      }
+      if (existing.result?.kind === "result" && existing.result.to > to) existing.result.to = Math.max(existing.from, to);
     }
     if (existing?.result?.kind === "result") {
       this.#requests.delete(key);
@@ -200,44 +220,38 @@ export class EncodeInputs {
       this.#wanted.delete(key);
       request.result?.release?.();
     }
-    this.#opens.delete(addressOf(output));
   }
 
   /**
-   * How long an encoder took to open this output's original input: from its
-   * spawn to the name of its first closed piece, less what encoding that piece
-   * costs. Measured by whoever ran it, kept here where a stretch is sized.
+   * How many bytes a stretch may hold so that copying it takes no longer than
+   * opening the input it replaces: the recent copy rate times this output's
+   * recent open. Beyond it the open's share of each piece falls below the
+   * copy's, which is the same for every piece; a longer stretch buys less and
+   * delays the run's start more. Null until a copy rate is measured and an
+   * open is known, and the run then gets one piece. An output that has not
+   * opened yet is sized by the host's startup reading, which is said: at a
+   * cold start the second run was one piece too for want of it, and cost
+   * another open (6.34 s, torrent-tv/meta#166 run 12).
    *
    * @param {object} output
-   * @param {number} seconds
+   * @returns {{ bytes: number, openMeasured: boolean } | null}
    */
-  noteOpen(output, seconds) {
-    if (!Number.isFinite(seconds) || seconds < 0) return;
-    const readings = this.#opens.get(addressOf(output)) ?? [];
-    keep(readings, seconds);
-    this.#opens.set(addressOf(output), readings);
+  stretchFor(output) {
+    const rate = middleOf(this.#copyRates);
+    const open = this.#openOf(output);
+    return rate === null || !open ? null : { bytes: Math.floor(rate * open.seconds * 1000), openMeasured: open.measured };
   }
 
   /**
-   * How many bytes a stretch may hold so that copying it takes no longer than
-   * opening the input it replaces: the recent copy rate times this output's
-   * recent open. Beyond it the open's share of each piece falls below the
-   * copy's, which is the same for every piece; a longer stretch buys less and
-   * delays the run's start more. Null until both have been measured, and the
-   * run then gets one piece, as it did before either reading existed.
-   *
    * @param {object} output
    * @returns {number | null}
    */
   stretchBytesFor(output) {
-    const rate = middleOf(this.#copyRates);
-    const open = middleOf(this.#opens.get(addressOf(output)) ?? []);
-    return rate === null || open === null ? null : Math.floor(rate * open * 1000);
+    return this.stretchFor(output)?.bytes ?? null;
   }
 
   #prepare(request) {
     request.pending = true;
-    request.stale = false;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
     // Where the time from the request to its input goes, across every attempt:
@@ -260,13 +274,9 @@ export class EncodeInputs {
         if (result.kind === "result") Object.assign(result, { from: request.from, to: request.from });
       }
       if (this.#requests.get(request.key) !== request) { result.release?.(); return; }
-      if (result.kind === "result" && result.to > request.to) {
-        // The plan narrowed this start while the copy was being made.
-        result.release();
-        request.result = null;
-        request.stale = true;
-        return;
-      }
+      // The plan narrowed this start while the copy was being made: the run
+      // is commanded over its prefix.
+      if (result.kind === "result" && result.to > request.to) result.to = Math.max(request.from, request.to);
       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` : "")
@@ -281,8 +291,8 @@ export class EncodeInputs {
     }).finally(() => {
       request.pending = false;
       if (request.result?.kind !== "needs-memory") this.#wanted.delete(request.key);
-      const changed = request.stale || (request.result?.kind === "needs-memory"
-        ? request.memoryRevision !== this.#memoryRevision : request.revision !== this.#revision);
+      const changed = request.result?.kind === "needs-memory"
+        ? request.memoryRevision !== this.#memoryRevision : request.revision !== this.#revision;
       if (this.#requests.get(request.key) === request && changed &&
         request.result?.kind !== "result" && request.result?.kind !== "terminal") this.#prepare(request);
     });
@@ -360,7 +370,9 @@ export class EncodeInputs {
       }
       return good;
     };
-    const target = this.stretchBytesFor(output);
+    const sizing = this.stretchFor(output);
+    const target = sizing?.bytes ?? null;
+    if (sizing && !sizing.openMeasured) request.timing.openApproximate = true;
     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 });
@@ -429,7 +441,8 @@ function describeTiming(timing, now) {
   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`;
+    `held ranges ${timing.heldMs}ms, budget ${timing.budgetMs}ms` +
+    (timing.openApproximate ? "; sized by the host's startup open, this output has not opened yet" : "");
 }
 
 function addressOf(output) { return output.outputKey ?? output.id; }

package/services/encode/EncodeOrchestrator.js

@@ -145,6 +145,30 @@ export class EncodeOrchestrator {
     this.#costs.noteStartup(measured);
   }
 
+  /**
+   * One output's original-input open, and what sizes its stretch: the one
+   * owner of start readings is this class's `RunCosts` (torrent-tv/meta#184).
+   *
+   * @param {string} address
+   * @param {number} seconds
+   */
+  noteOpen(address, seconds) {
+    this.#costs.noteOpen(address, seconds);
+  }
+
+  /**
+   * @param {string} address
+   * @returns {{ seconds: number, measured: boolean } | null}
+   */
+  openOf(address) {
+    return this.#costs.openOf(address);
+  }
+
+  /** @param {string} address */
+  forgetOpens(address) {
+    this.#costs.forgetOpens(address);
+  }
+
   /**
    * What a stop and a start cost on this host, in seconds, as the plan reads
    * them — for anyone else pricing a fresh encoder by the same figures.
@@ -289,41 +313,6 @@ export class EncodeOrchestrator {
     return coverage;
   }
 
-  /**
-   * Where a run started here must stop: the free stretch in front of it.
-   *
-   * Asked of the one map, brought up to date first. It used to be worked out by
-   * the session manager, which reached into this layer for the map and into the
-   * store for what was on the disk and put the two together itself — one fact
-   * with two owners and a third party carrying it between them, which is how the
-   * two came to disagree.
-   *
-   * @param {object} params
-   * @param {string} params.address
-   * @param {number} params.from - Where the run will start.
-   * @param {object | null} [params.exceptRun] - The run being replaced, whose
-   *   own claim is not somebody else's material.
-   * @param {number} [params.segmentCount] - The output's length, when known.
-   * @returns {number} The last number to work through, or `-1` for the end of
-   *   the film.
-   */
-  freeStretchEnd({ address, from, exceptRun = null, segmentCount = 0 }) {
-    if (!address) {
-      return -1;
-    }
-    if (segmentCount > 0) {
-      this.coverageOf(address).setSegmentCount(segmentCount);
-    }
-    const coverage = this.#upToDateCoverage(address);
-    const start = Math.max(0, from);
-    const free = coverage.freeRunFrom(start, exceptRun);
-    if (!Number.isFinite(free)) {
-      return -1;
-    }
-    const end = start + Math.max(1, free) - 1;
-    return segmentCount > 0 && end >= segmentCount - 1 ? -1 : end;
-  }
-
   /**
    * @param {string} address
    * @returns {import("../encode/EncodeRun.js").EncodeRun[]}
@@ -974,9 +963,11 @@ export class EncodeOrchestrator {
     // were two steps, and two owners each performed the second one.
     //
     // A run whose input is one copied stretch can make nothing past it, so it
-    // claims that stretch and not the plan's longer bound: the rest stays free
-    // for the next run (torrent-tv/meta#158). Every other run claims as before.
-    const through = Number.isInteger(run.inputThrough) ? run.inputThrough : to;
+    // claims that stretch — its own `to` — and not the plan's longer bound:
+    // the rest stays free for the next run (torrent-tv/meta#158). A run whose
+    // input grows a segment at a time claims the plan's bound, as it may reach
+    // it (torrent-tv/meta#184).
+    const through = run.originalInput ? run.to : to;
     this.coverageOf(address).claim(run, from, endOfRun({ from, to: through }));
   }
 

package/services/encode/EncodeRun.js

@@ -64,8 +64,14 @@ const MICROSECONDS_PER_SECOND = 1_000_000;
  *   it finished none.
  * @property {number} livedMs
  * @property {number | null} [firstNamedMs] - Spawn to the moment the encoder
- *   named its first closed piece: the open of its input plus that one piece's
- *   encoding, without the wait for the following piece that publication adds.
+ *   named its first closed piece, less the time it was paused before then: the
+ *   open of its input plus that one piece's encoding, without the wait for the
+ *   following piece that publication adds.
+ * @property {number | null} [firstNamedWallMs] - The same on the wall clock,
+ *   pauses included: what the viewer waited.
+ * @property {number | null} [firstOutputWallMs] - Spawn to the first output on
+ *   the wall clock; `firstOutputMs` leaves the pauses out.
+ * @property {number} [stoppedMs] - How long the run was paused in all.
  * @property {boolean} normal - Whether this ending is the expected one.
  * @property {string} lastError - The last thing ffmpeg said on stderr.
  * @property {string | null} provenName - The last piece this run named while it
@@ -166,6 +172,10 @@ export class EncodeRun {
    */
   #firstNamedAt = 0;
 
+  /** How long the run had been paused when each of the two above was taken. */
+  #stoppedBeforeFirstOutput = 0;
+  #stoppedBeforeFirstNamed = 0;
+
   /** The film made and the run's own working time, as of the last progress report. */
   #workSample = null;
 
@@ -569,6 +579,7 @@ export class EncodeRun {
       this.#produced.add(index);
       if (this.#firstOutputAt === 0) {
         this.#firstOutputAt = this.now();
+        this.#stoppedBeforeFirstOutput = this.clock.stoppedMs(this.#firstOutputAt);
       }
       if (this.#state === ENCODE_RUN_STATE.STARTING) {
         this.#transition(ENCODE_RUN_EVENT.FIRST_SEGMENT);
@@ -607,7 +618,10 @@ export class EncodeRun {
       }
       if (this.#publicationError) break;
       const index = this.indexOfName(name);
-      if (this.#firstNamedAt === 0 && Number.isInteger(index) && index >= this.from) this.#firstNamedAt = this.now();
+      if (this.#firstNamedAt === 0 && Number.isInteger(index) && index >= this.from) {
+        this.#firstNamedAt = this.now();
+        this.#stoppedBeforeFirstNamed = this.clock.stoppedMs(this.#firstNamedAt);
+      }
       const endOfWork = Number.isFinite(endOfRun(this)) ? this.to : this.lastSegmentIndex();
       // A packet crossing the final cut can flush a following file. It may
       // complete its predecessor, but no unadmitted interval can be published.
@@ -920,11 +934,18 @@ export class EncodeRun {
       // Null where the run was never told to stop, or never produced anything:
       // an absent measurement says so rather than reading as zero.
       dyingMs: this.#stopOrderedAt > 0 ? this.now() - this.#stopOrderedAt : null,
+      // Without the time this run was paused before then: a pause is our own
+      // decision, not what starting cost (torrent-tv/meta#184). The wall-clock
+      // figures beside them are what the viewer waited.
       firstOutputMs:
         this.#firstOutputAt > 0 && this.#startedAt > 0
-          ? this.#firstOutputAt - this.#startedAt
+          ? this.#firstOutputAt - this.#startedAt - this.#stoppedBeforeFirstOutput
           : null,
-      firstNamedMs: this.#firstNamedAt > 0 && this.#startedAt > 0 ? this.#firstNamedAt - this.#startedAt : null,
+      firstOutputWallMs: this.#firstOutputAt > 0 && this.#startedAt > 0 ? this.#firstOutputAt - this.#startedAt : null,
+      firstNamedMs: this.#firstNamedAt > 0 && this.#startedAt > 0
+        ? this.#firstNamedAt - this.#startedAt - this.#stoppedBeforeFirstNamed : null,
+      firstNamedWallMs: this.#firstNamedAt > 0 && this.#startedAt > 0 ? this.#firstNamedAt - this.#startedAt : null,
+      stoppedMs: this.clock.stoppedMs(),
       normal: ending === ENCODE_EXIT.COMPLETE,
       lastError: this.lastError
     };

package/services/encode/EncodeRuns.js

@@ -582,6 +582,7 @@ export class EncodeRuns {
     this.#host.encodeInputs?.forget(output);
     if (this.#host.outputs.outputsOn(output.outputKey).length === 0) {
       this.#inputFailures.forget(output.outputKey);
+      this.#host.encodeOrchestrator.forgetOpens?.(output.outputKey);
       this.#host.encodeOrchestrator.forgetOutput(output.outputKey);
     }
   }
@@ -793,40 +794,6 @@ export class EncodeRuns {
     );
   }
 
-  /**
-   * How far a run starting here may work before it meets somebody else's
-   * material — read off the ONE coverage map, never worked out again here.
-   *
-   * This replaced `planRunInterval`, which was a second authority over the same
-   * question and answered it by different rules: it walked the whole track for
-   * the first free number, MOVED the start there itself, and counted every live
-   * run as claiming up to `head + look-ahead`. Measured in the field
-   * 2026-09-05: the plan commanded a start at #46, this moved it to #78 — the
-   * "run moved forward from #46 to #78" line — and the plan, seeing a run
-   * outside the window it had asked for, killed it as unwanted and commanded
-   * the same start again, 350-700ms per cycle, dozens of times, the viewer's
-   * picture stopped for 125 seconds.
-   *
-   * Where a run STARTS is the plan's decision and arrives here as an argument.
-   * All this answers is where it must stop, and the answer is a fact of the
-   * map: the free stretch from that number on. `-1` means the end of the track,
-   * which is what "no end" is written as everywhere here.
-   *
-   * @param {object} session
-   * @param {number} startIndex
-   * @param {object | null} exceptRun - The run being replaced, whose own claim
-   *   is not somebody else's material.
-   * @returns {number} The last number to work through, or `-1` for the end.
-   */
-  #runEndFrom(session, startIndex, exceptRun = null) {
-    return this.#host.encodeOrchestrator.freeStretchEnd({
-      address: session.outputKey ?? "",
-      from: startIndex,
-      exceptRun,
-      segmentCount: Number(session.timeline?.segmentCount) || 0
-    });
-  }
-
   // Returns the encoder it built, or nothing when there was nothing to build.
   // It waits for nothing: the one thing it used to wait for was the death of
   // the run it was replacing, and that killing is gone.
@@ -834,7 +801,10 @@ export class EncodeRuns {
     if (!this.isLive(session)) {
       return null;
     }
-    this.#host.encodeInputs?.retain(session, this.#host.encodeOrchestrator.wantedSegmentsOn(session.outputKey));
+    // A copy held for a start that no live run ends before and that is not
+    // being started now goes back (torrent-tv/meta#184).
+    this.#host.encodeInputs?.retain(session, this.#host.encodeOrchestrator.wantedSegmentsOn(session.outputKey),
+      new Set([startIndex, ...this.liveRunsOf(session).map((run) => run.to + 1)]));
     // THE LAST NUMBER THIS RUN MAY REACH is the plan's; how far its input
     // really reaches is the input's answer. An original input is one copied
     // stretch, and the run is given exactly that stretch (torrent-tv/meta#158).
@@ -847,13 +817,13 @@ export class EncodeRuns {
     // The stretch is part of an original input's identity: two stretches from
     // one start can hold the same padded bytes, and a stretch that failed is
     // refused only while it is the same stretch.
-    const inputParameters = admittedInput ? { outputKey: session.outputKey, encoder: this.#host.videoEncoder.name,
+    const inputParameters = { outputKey: session.outputKey, encoder: this.#host.videoEncoder.name,
       width: session.output.encodeWidth, height: session.output.encodeHeight, fps: session.output.outputFps,
       preset: session.output.softwarePreset, tonemap: session.output.applyTonemap,
       rateControl: session.spec.video?.encode?.rateControl ?? null,
-      ...(admittedInput.original ? { interval: [startIndex, inputEnd] } : {}) } : null;
-    const inputKey = admittedInput ? this.#inputFailures.key(admittedInput, inputParameters) : null;
-    if (inputKey && this.#inputFailures.failure(session.outputKey, startIndex, inputKey)) {
+      ...(admittedInput.original ? { interval: [startIndex, inputEnd] } : {}) };
+    const inputKey = this.#inputFailures.key(admittedInput, inputParameters);
+    if (this.#inputFailures.failure(session.outputKey, startIndex, inputKey)) {
       admittedInput.release();
       return null;
     }
@@ -879,9 +849,10 @@ export class EncodeRuns {
     // an argument. Reading it off the coverage map a second time was the last
     // remaining second answer to that question: the plan computed `to`, passed
     // it, and the parameter list did not name it.
-    const runEnd = admittedInput ? inputEnd : Number.isInteger(ordered?.to)
-      ? ordered.to
-      : this.#runEndFrom(session, startIndex, null);
+    // A run ends where its input does: an original input is one copied
+    // stretch, and a packet input grows one segment at a time from its first
+    // (`run.to` follows it below).
+    const runEnd = inputEnd;
     // The restart backs off a segment or two from what was asked for, so the
     // request that prompted it is recorded under a HIGHER index than the run
     // starts at. Looking it up by the start index alone found nothing and the
@@ -1056,7 +1027,7 @@ export class EncodeRuns {
             const since = (at) => at ? `${at - run.startedAt}ms` : "never";
             this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: ` +
               `${reads.count} read(s), ${reads.bytes} bytes, first at ${since(reads.firstAt)}, last at ${since(reads.lastAt)}, ` +
-              `ended at ${Date.now() - run.startedAt}ms` + describeTaken(reads.answers, run.startedAt, ended.firstNamedMs));
+              `ended at ${Date.now() - run.startedAt}ms` + describeTaken(reads.answers, run.startedAt, ended.firstNamedWallMs));
           }
           this.#noteOpen(session, run, ended);
           admittedInput.release();
@@ -1072,10 +1043,6 @@ export class EncodeRuns {
       // Every number of the stretch answers to its one key, so a failure
       // anywhere inside it is recorded against the stretch that was commanded.
       run.admittedInputKeys = new Map(Array.from({ length: inputEnd - safeIndex + 1 }, (_, offset) => [safeIndex + offset, inputKey]));
-      // What this run can make is what its input holds, and that is what it
-      // claims; the plan's longer bound would read as made by a run that
-      // cannot reach it.
-      run.inputThrough = inputEnd;
       run.process.stdin.end();
       // THE NEXT STRETCH IS PREPARED WHILE THIS ONE IS BEING MADE. Asked for
       // only when this run had ended, its copy fell between the two runs and
@@ -1159,7 +1126,7 @@ export class EncodeRuns {
     const speed = run.speedX > 0 ? run.speedX : this.#host.encodeOrchestrator.speedOn?.(session.outputKey) ?? 0;
     if (!Number.isFinite(ended.firstNamedMs) || !(pieceSeconds > 0) || !(speed > 0)) return;
     const openSeconds = Math.max(0, ended.firstNamedMs / 1000 - pieceSeconds / speed);
-    this.#host.encodeInputs?.noteOpen(session, openSeconds);
+    this.#host.encodeOrchestrator.noteOpen?.(session.outputKey ?? "", openSeconds);
     this.#host.logger.info(`encode input of run #${run.from}..#${run.to} on ${session.outputKey}: opened in ` +
       `${openSeconds.toFixed(2)}s (first piece named at ${ended.firstNamedMs}ms, ${pieceSeconds.toFixed(3)}s of film at ${speed.toFixed(2)}x)`);
   }

package/services/encode/RunClock.js

@@ -28,6 +28,15 @@ export class RunClock {
   #idleCauses = 0;
   #idleSince = 0;
   #idleMs = 0;
+  /**
+   * Stopped time alone, apart from input waits: a pause is a decision of
+   * ours, while a wait for input is part of what starting a run costs, so the
+   * readings of a start leave out the first and keep the second
+   * (torrent-tv/meta#184).
+   */
+  #stoppedSince = 0;
+  #stoppedMs = 0;
+  #isStopped = false;
 
   /**
    * @param {{ now?: () => number }} [options]
@@ -67,11 +76,29 @@ export class RunClock {
   /** The process is stopped. */
   stopped() {
     this.#idleBegins();
+    if (!this.#isStopped) {
+      this.#isStopped = true;
+      this.#stoppedSince = this.#now();
+    }
   }
 
   /** The process runs again. */
   continued() {
     this.#idleEnds();
+    if (this.#isStopped) {
+      this.#isStopped = false;
+      this.#stoppedMs += this.#now() - this.#stoppedSince;
+    }
+  }
+
+  /**
+   * Milliseconds the process has been stopped so far.
+   *
+   * @param {number} [at]
+   * @returns {number}
+   */
+  stoppedMs(at = this.#now()) {
+    return this.#stoppedMs + (this.#isStopped ? Math.max(0, at - this.#stoppedSince) : 0);
   }
 
   /**

package/services/encode/run-costs.js

@@ -100,8 +100,10 @@ export class RunCosts {
     // Without it the figure that prices a move could only ever be learned from
     // runs that survived, so the state in which moves are ruinous was exactly
     // the state in which their cost stayed unknown.
-    if (!Number.isFinite(ended?.firstOutputMs) && Number.isFinite(ended?.livedMs) && ended.livedMs > 0) {
-      RunCosts.#keep(this.#firstOutput, /** @type {number} */ (ended.livedMs));
+    // Its pauses are left out: a pause is our decision, not what a start costs.
+    const livedWorking = Number(ended?.livedMs) - Math.max(0, Number(ended?.stoppedMs) || 0);
+    if (!Number.isFinite(ended?.firstOutputMs) && Number.isFinite(livedWorking) && livedWorking > 0) {
+      RunCosts.#keep(this.#firstOutput, livedWorking);
     }
     if (Number.isFinite(ended?.dyingMs)) {
       RunCosts.#keep(this.#dying, /** @type {number} */ (ended.dyingMs));
@@ -111,6 +113,49 @@ export class RunCosts {
     }
   }
 
+  /**
+   * How long an encoder took to open one output's original input, in seconds:
+   * from its spawn to the name of its first closed piece, less that piece's
+   * encoding and any pause (torrent-tv/meta#184). Kept per output, beside the
+   * host's time to first output above and apart from it: the two are related
+   * and not the same quantity, and the stretch of an original input is sized
+   * from this one.
+   *
+   * @type {Map<string, number[]>}
+   */
+  #opens = new Map();
+
+  /**
+   * @param {string} address
+   * @param {number} seconds
+   */
+  noteOpen(address, seconds) {
+    if (!address || !Number.isFinite(seconds) || seconds < 0) return;
+    const readings = this.#opens.get(address) ?? [];
+    RunCosts.#keep(readings, seconds);
+    this.#opens.set(address, readings);
+  }
+
+  /**
+   * The open of this output: its own readings' median where it has any; else
+   * the host's startup reading of spawn to first piece, said to be an
+   * approximation — it opened a generated picture, not this file; else null.
+   *
+   * @param {string} address
+   * @returns {{ seconds: number, measured: boolean } | null}
+   */
+  openOf(address) {
+    const own = middleOf(this.#opens.get(address) ?? []);
+    if (own !== null) return { seconds: own, measured: true };
+    const startup = this.#atStartup?.firstByteWaitSec;
+    return Number.isFinite(startup) && startup > 0 ? { seconds: startup, measured: false } : null;
+  }
+
+  /** @param {string} address */
+  forgetOpens(address) {
+    this.#opens.delete(address);
+  }
+
   /**
    * @param {number[]} readings
    * @param {number} value

package/services/server/wire-outputs.js

@@ -975,6 +975,9 @@ export function wireOutputs({
     heldRanges: readEncodeHeldRanges,
     reviseBudget: () => parts.machineBudget.revise(),
     capacity: () => parts.machineBudget.capacityOf("memory"),
+    // How long this output's input takes to open, from the one owner of start
+    // readings (torrent-tv/meta#184).
+    openOf: (output) => parts.encodeOrchestrator?.openOf?.(output.outputKey ?? "") ?? null,
     urgent: (output, index) => parts.encodeOrchestrator.wantedSegmentsOn(output.outputKey).some(window =>
       index >= window.from && index <= window.to && window.urgent === true),
     log: line => logger.info(line),

package/services/storage/processor-report.js

@@ -16,7 +16,7 @@
  * process figure alone is said.
  */
 
-import { readFile, readdir } from "node:fs/promises";
+import { readFileSync, readdirSync } from "node:fs";
 
 /** Clock ticks per second of `/proc/<pid>/stat`, as in `encode/host-load.js`. */
 const CLOCK_TICKS_PER_SECOND = 100;
@@ -58,26 +58,46 @@ export function partOfThread(tid, name, pid) {
   return "other";
 }
 
+/**
+ * One `/proc` stat file, or null when it cannot be read.
+ *
+ * @param {string} file
+ * @returns {{ name: string, seconds: number } | null}
+ */
+function statOf(file) {
+  try {
+    return parseStat(readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
 /**
  * CPU seconds of this process's threads, by part, or null where `/proc` cannot
  * be read.
  *
+ * READ SYNCHRONOUSLY, with the clock read beside it: a reading is only a share
+ * when every counter in it and its time belong to one instant. Read as
+ * promises on the field host (2.97.0), the counters were taken while the main
+ * thread was busy and the time after, and a second read "process 1238 %" of a
+ * core (torrent-tv/meta#177). About a hundred small files a second, kernel
+ * memory, no disk.
+ *
  * @param {number} [pid]
- * @returns {Promise<{ main: number, worker: number, other: number } | null>}
+ * @returns {{ main: number, worker: number, other: number } | null}
  */
-export async function readThreadSeconds(pid = process.pid) {
+export function readThreadSeconds(pid = process.pid) {
   let tids;
   try {
-    tids = await readdir(`/proc/${pid}/task`);
+    tids = readdirSync(`/proc/${pid}/task`);
   } catch {
     return null;
   }
   const parts = { main: 0, worker: 0, other: 0 };
-  await Promise.all(tids.map(async (entry) => {
-    const tid = Number(entry);
-    const stat = await readFile(`/proc/${pid}/task/${entry}/stat`, "utf8").then(parseStat, () => null);
-    if (stat) parts[partOfThread(tid, stat.name, pid)] += stat.seconds;
-  }));
+  for (const entry of tids) {
+    const stat = statOf(`/proc/${pid}/task/${entry}/stat`);
+    if (stat) parts[partOfThread(Number(entry), stat.name, pid)] += stat.seconds;
+  }
   return parts;
 }
 
@@ -85,14 +105,14 @@ export async function readThreadSeconds(pid = process.pid) {
  * CPU seconds of each of these processes that can be read now.
  *
  * @param {number[]} pids
- * @returns {Promise<Map<number, number>>}
+ * @returns {Map<number, number>}
  */
-export async function readProcessesSeconds(pids) {
+export function readProcessesSeconds(pids) {
   const seconds = new Map();
-  await Promise.all(pids.map(async (pid) => {
-    const stat = await readFile(`/proc/${pid}/stat`, "utf8").then(parseStat, () => null);
+  for (const pid of pids) {
+    const stat = statOf(`/proc/${pid}/stat`);
     if (stat) seconds.set(pid, stat.seconds);
-  }));
+  }
   return seconds;
 }
 
@@ -158,29 +178,22 @@ export function startProcessorReport({ log, ffmpegPids, detailed = () => false,
   let previous = null;
   let series = [];
   let since = Date.now();
-  let reading = false;
-  const tick = async () => {
-    if (reading) return;
-    reading = true;
-    try {
-      const usage = process.cpuUsage();
-      const [threads, ffmpeg] = await Promise.all([readThreadSeconds(), readProcessesSeconds(ffmpegPids())]);
-      const now = { at: Date.now(), process: (usage.user + usage.system) / 1e6, threads, ffmpeg };
-      const shares = previous ? sharesBetween(previous, now) : null;
-      previous = now;
-      if (!shares) return;
-      series.push(shares);
-      if (detailed()) log(`processor: ${describeShares([shares])}`);
-      if (now.at - since >= sayEveryMs) {
-        log(`processor: ${describeShares(series)}`);
-        series = [];
-        since = now.at;
-      }
-    } finally {
-      reading = false;
+  const tick = () => {
+    const at = Date.now();
+    const usage = process.cpuUsage();
+    const now = { at, process: (usage.user + usage.system) / 1e6, threads: readThreadSeconds(), ffmpeg: readProcessesSeconds(ffmpegPids()) };
+    const shares = previous ? sharesBetween(previous, now) : null;
+    previous = now;
+    if (!shares) return;
+    series.push(shares);
+    if (detailed()) log(`processor: ${describeShares([shares])}`);
+    if (now.at - since >= sayEveryMs) {
+      log(`processor: ${describeShares(series)}`);
+      series = [];
+      since = now.at;
     }
   };
-  const timer = setInterval(() => { void tick(); }, everyMs);
+  const timer = setInterval(tick, everyMs);
   if (typeof timer.unref === "function") timer.unref();
   return { stop: () => clearInterval(timer) };
 }