@torrent-tv/proxy 2.95.30 → 2.95.31

package/package.json

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

package/server.js

@@ -690,6 +690,13 @@ export async function startProxyServer({
       const torrent = torrentPool.knownTorrent(source.sourceKey);
       return torrent ? torrentPool.readHeldRangesOf(torrent, source.fileIndex, ranges, maxBytes) : null;
     },
+    // Which bytes of a file are downloaded whole now — what an original
+    // input's stretch may extend over. A snapshot: the copy that follows
+    // holds the pieces it reads, and refuses where one has gone since.
+    readEncodeHeldRanges: async (source) => {
+      const torrent = torrentPool.knownTorrent(source.sourceKey);
+      return torrent ? torrentPool.heldRangesOf(torrent, source.fileIndex) : [];
+    },
     enabled: transcodeAudio,
     keyframeTables,
     ffmpegBin,

package/services/encode/EncodeInputs.js

@@ -1,5 +1,26 @@
 import { admitInput } from "./AdmittedInput.js";
-import { admitOriginalInput } from "./OriginalInput.js";
+import { admitOriginalInput, originalInputBytes } from "./OriginalInput.js";
+
+/**
+ * How many recent readings a learned figure here is taken from: long enough
+ * that one reading does not move the answer, short enough that the answer
+ * still follows the host. The same count as `run-costs.js`.
+ */
+const RECENT_READINGS = 20;
+
+/** @param {number[]} values @returns {number | null} */
+function middleOf(values) {
+  if (values.length === 0) return null;
+  const sorted = [...values].sort((left, right) => left - right);
+  const middle = Math.floor(sorted.length / 2);
+  return sorted.length % 2 === 0 ? (sorted[middle - 1] + sorted[middle]) / 2 : sorted[middle];
+}
+
+/** @param {number[]} readings @param {number} value */
+function keep(readings, value) {
+  readings.push(value);
+  while (readings.length > RECENT_READINGS) readings.shift();
+}
 
 /** Event-driven preparation; a synchronous run request can take only ready input. */
 export class EncodeInputs {
@@ -8,25 +29,34 @@ export class EncodeInputs {
   #memoryRevision = 0;
   #held = 0;
   #allowed = 0;
+  /** What each preparing request asks of memory: all it would use, and the least it can run with. */
   #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();
   #resolve;
   #read;
+  #heldRanges;
   #revise;
   #changed;
   #failed;
   #capacity;
   #urgent;
   #log;
+  #now;
 
-  constructor({ resolve, readRanges, reviseBudget, changed, failed, capacity = () => null, urgent = () => true, log = () => {} }) {
+  constructor({ resolve, readRanges, heldRanges = null, reviseBudget, changed, failed, capacity = () => null, urgent = () => true, log = () => {}, now = Date.now }) {
     this.#resolve = resolve;
     this.#read = readRanges;
+    this.#heldRanges = heldRanges;
     this.#revise = reviseBudget;
     this.#changed = changed;
     this.#failed = failed;
     this.#capacity = capacity;
     this.#urgent = urgent;
     this.#log = log;
+    this.#now = now;
   }
 
   /** One line when a request's state changes, so a wait that never ends names what it waits for. */
@@ -38,16 +68,16 @@ export class EncodeInputs {
   }
 
   held() { return this.#held; }
-  wanted() { return this.#held + [...this.#wanted.values()].reduce((sum, bytes) => sum + bytes, 0); }
+  wanted() { return this.#held + [...this.#wanted.values()].reduce((sum, asked) => sum + asked.wanted, 0); }
   required() {
     let bytes = this.#held;
-    for (const [key, wanted] of this.#wanted) {
-      const request = this.#requests.get(key);
-      // The encode plan already chose this finite input. It must fit before
-      // production can advance, even when playback has not reached it yet.
-      // Sharing against speculative whole-file demand can otherwise deny it
-      // forever, so urgency must not decide its minimum allocation again.
-      if (request) bytes += wanted;
+    for (const [key, asked] of this.#wanted) {
+      // The encode plan already chose this finite input. Its least runnable
+      // part must fit before production can advance, even when playback has
+      // not reached it yet. Sharing against speculative whole-file demand can
+      // otherwise deny it forever, so urgency must not decide that minimum
+      // again. What a stretch asks beyond it is shared like any other want.
+      if (this.#requests.has(key)) bytes += asked.required;
     }
     return bytes;
   }
@@ -87,9 +117,30 @@ export class EncodeInputs {
     this.#retryMemory();
   }
 
+  /**
+   * The input of a run starting at `from`, once it is prepared.
+   *
+   * `to` is the last number the run may reach. A packet input is prepared for
+   * `from` alone; an original input for the longest stretch from `from` that
+   * is present, fits memory and copies no longer than an open of that input.
+   * The answer carries the stretch it holds as `from` and `to`.
+   */
   take(output, from, to) {
-    const key = `${output.outputKey ?? output.id}:${from}:${to}`;
-    const existing = this.#requests.get(key);
+    const key = keyOf(output, from);
+    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.
+      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") {
       this.#requests.delete(key);
       return existing.result;
@@ -102,7 +153,7 @@ export class EncodeInputs {
   }
 
   async acquire(output, from, to) {
-    const key = `${output.outputKey ?? output.id}:${from}:${to}`;
+    const key = keyOf(output, from);
     const ready = this.take(output, from, to);
     if (ready) return ready;
     await this.#requests.get(key)?.promise;
@@ -125,41 +176,70 @@ 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.
+   *
+   * @param {object} output
+   * @param {number} seconds
+   */
+  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);
+  }
+
+  /**
+   * 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);
   }
 
   #prepare(request) {
     request.pending = true;
+    request.stale = false;
     request.revision = this.#revision;
     request.memoryRevision = this.#memoryRevision;
     request.promise = (async () => {
-      const resolved = await this.#resolve(request.output, request.from, request.to);
+      const resolved = await this.#resolve(request.output, request.from, request.from);
       if (this.#requests.get(request.key) !== request) return;
-      const admit = resolved.sources?.every(source => source.input.original === true) ? admitOriginalInput : admitInput;
-      const result = resolved.kind === "result" ? await admit({
-        sources: resolved.sources,
-        readRanges: this.#read,
-        reserve: async bytes => {
-          this.#wanted.set(request.key, bytes);
-          await 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
-          };
-          if (this.#requests.get(request.key) !== request || this.#allowed - this.#held < bytes) return null;
-          this.#wanted.delete(request.key);
-          this.#held += bytes;
-          let released = false;
-          return () => {
-            if (!released) {
-              released = true; this.#held -= bytes;
-              queueMicrotask(() => this.memoryChanged());
-            }
-          };
-        }
-      }) : resolved;
+      let result;
+      if (resolved.kind !== "result") {
+        result = resolved;
+      } else if (resolved.sources?.every(source => source.input.original === true)) {
+        result = await this.#admitStretch(request, resolved.sources);
+        if (!result) return;
+      } else {
+        result = await admitInput({ sources: resolved.sources, readRanges: this.#read, reserve: this.#reserveFor(request) });
+        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;
+      }
       request.result = result;
-      this.#note(request, result.kind === "result" ? `ready, ${result.bytes ?? "?"} bytes`
+      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` : ""}`);
       if (result.kind === "result" || result.kind === "terminal") this.#changed(request.output, result);
     })().catch(error => {
@@ -170,10 +250,137 @@ export class EncodeInputs {
     }).finally(() => {
       request.pending = false;
       if (request.result?.kind !== "needs-memory") this.#wanted.delete(request.key);
-      const changed = request.result?.kind === "needs-memory"
-        ? request.memoryRevision !== this.#memoryRevision : request.revision !== this.#revision;
+      const changed = request.stale || (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);
     });
   }
+
+  /** The reservation a packet input makes: all of it, or nothing. */
+  #reserveFor(request) {
+    return async bytes => {
+      this.#wanted.set(request.key, { wanted: bytes, required: bytes });
+      await 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
+      };
+      return this.#hold(request, bytes);
+    };
+  }
+
+  /** Take `bytes` of the allowance for this request now, or answer null. */
+  #hold(request, bytes) {
+    if (this.#requests.get(request.key) !== request || this.#allowed - this.#held < bytes) return null;
+    this.#wanted.delete(request.key);
+    this.#held += bytes;
+    let released = false;
+    return () => {
+      if (!released) {
+        released = true; this.#held -= bytes;
+        queueMicrotask(() => this.memoryChanged());
+      }
+    };
+  }
+
+  /**
+   * Choose and copy one finite stretch of an original input, starting at the
+   * request's `from` and ending at the largest `e <= to` such that every byte
+   * of `from … e` is present now, the stretch copies no longer than an open,
+   * and it fits the memory the budget allows. One piece is the least it runs
+   * with; only that least is required of the budget, and only that least being
+   * larger than the policy's whole capacity is terminal.
+   *
+   * @returns {Promise<object | undefined>} Undefined when the request was withdrawn.
+   */
+  async #admitStretch(request, firstSources) {
+    const { output, from } = request;
+    const minimum = originalInputBytes(firstSources);
+    const stretches = new Map([[from, { sources: firstSources, bytes: minimum }]]);
+    const held = new Map();
+    const at = async end => {
+      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);
+        stretches.set(end, resolved?.kind === "result" && resolved.sources?.every(source => source.input.original === true)
+          ? { sources: resolved.sources, bytes: originalInputBytes(resolved.sources) } : null);
+      }
+      return stretches.get(end);
+    };
+    const fits = async (end, maxBytes) => {
+      const stretch = await at(end);
+      return Boolean(stretch) && stretch.bytes <= maxBytes && await this.#present(stretch.sources, held);
+    };
+    // 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.
+    const longest = async maxBytes => {
+      let good = from, bad = null, step = 1;
+      while (bad === null) {
+        const end = good + step;
+        if (end > request.to) bad = request.to + 1;
+        else if (await fits(end, maxBytes)) { good = end; step *= 2; }
+        else bad = end;
+      }
+      while (bad - good > 1) {
+        const middle = Math.floor((good + bad) / 2);
+        if (await fits(middle, maxBytes)) good = middle; else bad = middle;
+      }
+      return good;
+    };
+    const target = this.stretchBytesFor(output);
+    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();
+    if (this.#requests.get(request.key) !== request) return undefined;
+    const capacity = this.#capacity();
+    if (capacity !== null && minimum > capacity && this.#urgent(output, from)) {
+      return { kind: "terminal", reason: "source-input-exceeds-memory-capacity", bytes: minimum, capacity };
+    }
+    const roomNow = () => Math.min(capacity ?? Number.POSITIVE_INFINITY, this.#allowed - this.#held);
+    let room = roomNow();
+    let result;
+    for (;;) {
+      if (minimum > room) {
+        // Wait for memory with the least it can run with, not the larger stretch.
+        this.#wanted.set(request.key, { wanted: minimum, required: minimum });
+        return { kind: "needs-memory", bytes: minimum };
+      }
+      if (stretches.get(end).bytes > room) {
+        end = await longest(Math.min(target ?? minimum, room));
+        if (this.#requests.get(request.key) !== request) return undefined;
+      }
+      const chosen = stretches.get(end);
+      this.#wanted.set(request.key, { wanted: chosen.bytes, required: chosen.bytes });
+      result = await admitOriginalInput({ sources: chosen.sources, readRanges: this.#read, now: this.#now,
+        reserve: async bytes => this.#hold(request, bytes) });
+      // Another output's copy can take the room this one was sized for while
+      // it was being chosen. A shorter stretch is tried at once rather than
+      // waiting for a memory change that may never come.
+      if (result.kind !== "needs-memory" || this.#requests.get(request.key) !== request || roomNow() >= room) break;
+      room = roomNow();
+    }
+    if (result.kind === "needs-memory") this.#wanted.set(request.key, { wanted: minimum, required: minimum });
+    if (result.kind === "result") {
+      Object.assign(result, { from, to: end });
+      if (result.copyMs > 0) keep(this.#copyRates, result.bytes / result.copyMs);
+    }
+    return result;
+  }
+
+  /** Whether every range of these sources is downloaded whole now. */
+  async #present(sources, held) {
+    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) ?? []);
+      const ranges = held.get(name);
+      if (!source.input.ranges.every(([start, end]) => ranges.some(([first, last]) => first <= start && last >= end))) return false;
+    }
+    return true;
+  }
 }
+
+function addressOf(output) { return output.outputKey ?? output.id; }
+function keyOf(output, from) { return `${addressOf(output)}:${from}`; }

package/services/encode/EncodeOrchestrator.js

@@ -847,7 +847,24 @@ export class EncodeOrchestrator {
     // between is synchronous, and a process cannot say a word before the next
     // tick. What it removes is the second act — building a run and starting it
     // were two steps, and two owners each performed the second one.
-    this.coverageOf(address).claim(run, from, endOfRun({ from, to }));
+    //
+    // 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;
+    this.coverageOf(address).claim(run, from, endOfRun({ from, to: through }));
+  }
+
+  /**
+   * The speed one encoder on this output is taken to run at: the fastest live
+   * run's measurement, else what this output last measured or the startup
+   * figures predict. Zero where none exists.
+   *
+   * @param {string} address
+   * @returns {number}
+   */
+  speedOn(address) {
+    return this.#speedOn(address, this.runsOn(address).filter((run) => run.isAlive));
   }
 
   /**

package/services/encode/EncodeRun.js

@@ -63,6 +63,9 @@ const MICROSECONDS_PER_SECOND = 1_000_000;
  * @property {number} reached - The last number it finished, or `from - 1` when
  *   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.
  * @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
@@ -156,6 +159,13 @@ export class EncodeRun {
    */
   #firstOutputAt = 0;
 
+  /**
+   * When the encoder first NAMED a closed piece of its own stretch. A piece is
+   * published only once the next one is named, so the first output above holds
+   * two pieces' encoding; this holds one, and is what an open is read from.
+   */
+  #firstNamedAt = 0;
+
   /** The film made and the run's own working time, as of the last progress report. */
   #workSample = null;
 
@@ -583,6 +593,7 @@ 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();
       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.
@@ -899,6 +910,7 @@ export class EncodeRun {
         this.#firstOutputAt > 0 && this.#startedAt > 0
           ? this.#firstOutputAt - this.#startedAt
           : null,
+      firstNamedMs: this.#firstNamedAt > 0 && this.#startedAt > 0 ? this.#firstNamedAt - this.#startedAt : null,
       normal: ending === ENCODE_EXIT.COMPLETE,
       lastError: this.lastError
     };

package/services/encode/EncodeRuns.js

@@ -809,12 +809,23 @@ export class EncodeRuns {
       return null;
     }
     this.#host.encodeInputs?.retain(session, this.#host.encodeOrchestrator.wantedSegmentsOn(session.outputKey));
-    const admittedInput = this.#host.encodeInputs?.take(session, startIndex, startIndex) ?? null;
+    // 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).
+    const segmentCount = Number(session.timeline?.segmentCount) || 0;
+    const mayReach = Number.isInteger(ordered?.to) && ordered.to >= startIndex ? ordered.to
+      : segmentCount > startIndex ? segmentCount - 1 : startIndex;
+    const admittedInput = this.#host.encodeInputs?.take(session, startIndex, mayReach) ?? null;
     if (!admittedInput) return null;
+    const inputEnd = admittedInput.original ? admittedInput.to : startIndex;
+    // 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,
       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 } : null;
+      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.release();
@@ -842,7 +853,7 @@ 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 ? startIndex : Number.isInteger(ordered?.to)
+    const runEnd = admittedInput ? inputEnd : Number.isInteger(ordered?.to)
       ? ordered.to
       : this.#runEndFrom(session, startIndex, null);
     // The restart backs off a segment or two from what was asked for, so the
@@ -914,7 +925,8 @@ export class EncodeRuns {
       audioSourceTrackIndex: session.spec.audioSourceTrackIndex,
       rateControl: session.spec.video?.encode?.rateControl ?? null,
       startIndex,
-      endIndex: Number.isInteger(ordered?.to) ? ordered.to : runEnd >= startIndex ? runEnd : session.timeline.segmentCount - 1,
+      endIndex: admittedInput.original ? inputEnd
+        : Number.isInteger(ordered?.to) ? ordered.to : runEnd >= startIndex ? runEnd : session.timeline.segmentCount - 1,
       videoEncoder: this.#host.videoEncoder,
       segmentDurationSec: this.#host.segmentDurationSec
     });
@@ -1017,6 +1029,7 @@ export class EncodeRuns {
               `${reads.count} read(s), ${reads.bytes} bytes, first at ${since(reads.firstAt)}, last at ${since(reads.lastAt)}, ` +
               `ended at ${Date.now() - run.startedAt}ms`);
           }
+          this.#noteOpen(session, run, ended);
           admittedInput.release();
         }
         this.noteRunEnded(session, run, ended);
@@ -1025,7 +1038,13 @@ export class EncodeRuns {
     if (admittedInput.original) {
       run.originalInput = admittedInput;
       run.inputFingerprint = admittedInput.fingerprint;
-      run.admittedInputKeys = new Map([[safeIndex, inputKey]]);
+      // 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();
     } else if (admittedInput) {
       run.inputFingerprint = admittedInput.fingerprint;
@@ -1084,6 +1103,28 @@ export class EncodeRuns {
     }
   }
 
+  /**
+   * How long this run took to open its original input, for sizing the next
+   * stretch: from its spawn to the name of its first closed piece, less what
+   * encoding that piece costs at the run's speed — its own where it measured
+   * one, else the output's. Nothing is noted where either is unknown.
+   *
+   * @param {object} session
+   * @param {import("./EncodeRun.js").EncodeRun} run
+   * @param {import("./EncodeRun.js").RunEnded} ended
+   * @returns {void}
+   */
+  #noteOpen(session, run, ended) {
+    const grid = session.timeline?.published ?? session.timeline?.boundaries;
+    const pieceSeconds = Number(grid?.[run.from + 1]) - Number(grid?.[run.from]);
+    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.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)`);
+  }
+
   /**
    * Log a report from a run that still belongs to this output. The run owns the
    * clock and has already placed its relative ffmpeg time on the source

package/services/encode/OriginalInput.js

@@ -4,18 +4,22 @@ import { createHash } from "node:crypto";
  * The available-only reader acquires complete pieces atomically before copying;
  * owned buffers then outlive torrent eviction without keeping duplicate pins.
  */
-export async function admitOriginalInput({ sources, reserve, readRanges }) {
-  const bytes = sources.reduce((total, source) => total + source.input.ranges
-    .reduce((sum, [start, end]) => sum + end - start + 1, 0), 0);
+export async function admitOriginalInput({ sources, reserve, readRanges, now = Date.now }) {
+  const bytes = originalInputBytes(sources);
   if (!Number.isSafeInteger(bytes) || bytes <= 0) throw new TypeError("Original input requires complete finite byte ranges.");
   const releaseBudget = await reserve(bytes);
   if (typeof releaseBudget !== "function") return releaseBudget?.kind === "terminal" ? releaseBudget : { kind: "needs-memory", bytes };
   const held = new Map();
   const hash = createHash("sha256");
   let retained = false;
+  // How long the copy itself took, apart from any wait for memory or bytes
+  // before it: the figure a run's stretch is sized from, read where the copy is.
+  let copyMs = 0;
   try {
     for (const source of sources) {
+      const startedAt = now();
       const buffers = await readRanges(source, source.input.ranges, bytes);
+      copyMs += Math.max(0, now() - startedAt);
       if (buffers === null) return { kind: "needs-bytes", sourceKey: source.sourceKey, fileIndex: source.fileIndex, ranges: source.input.ranges };
       if (!Array.isArray(buffers) || buffers.length !== source.input.ranges.length || buffers.some((buffer, index) =>
         !Buffer.isBuffer(buffer) || buffer.length !== source.input.ranges[index][1] - source.input.ranges[index][0] + 1)) {
@@ -32,7 +36,7 @@ export async function admitOriginalInput({ sources, reserve, readRanges }) {
     // 1.6 s from a file, and nothing said whether it was waiting on its input.
     const reads = { count: 0, bytes: 0, firstAt: 0, lastAt: 0 };
     return {
-      kind: "result", original: true, sources, bytes, fingerprint: hash.digest("hex"),
+      kind: "result", original: true, sources, bytes, copyMs, fingerprint: hash.digest("hex"),
       tracks: sources.flatMap(source => (source.input.selections ?? []).map(selection => ({ track: selection.track,
         ...(Number.isFinite(source.input.sourceEnds?.[selection.track.trackNumber]) ? {
           sourceEndSeconds: source.input.sourceEnds[selection.track.trackNumber] - source.timeShiftSeconds
@@ -67,3 +71,9 @@ export async function admitOriginalInput({ sources, reserve, readRanges }) {
     if (!retained) releaseBudget();
   }
 }
+
+/** The bytes an original input of these sources holds once copied. */
+export function originalInputBytes(sources) {
+  return sources.reduce((total, source) => total + source.input.ranges
+    .reduce((sum, [start, end]) => sum + end - start + 1, 0), 0);
+}

package/services/encode/source-command.js

@@ -233,20 +233,34 @@ export function buildRunCommand({
 
 }
 
-/** One finite original-source run, preserving the published interval and track choice. */
+/**
+ * One finite original-source run over the stretch its input holds, `startIndex`
+ * through `endIndex`, preserving the published intervals and track choice.
+ *
+ * The command works on a local timeline holding the stretch's own boundaries
+ * plus one beyond its end, so every published boundary inside it, the end
+ * included, is a cut, and what the muxer flushes after the end is a piece
+ * nobody publishes. Numbering continues from `startIndex`.
+ */
 export function buildOriginalCommand(params) {
   const { admittedInput, timeline, startIndex, inputToken, baseUrl, audioOnly } = params;
+  const endIndex = Number.isInteger(params.endIndex) && params.endIndex >= startIndex ? params.endIndex : startIndex;
   const grid = publishedGridFor(timeline);
-  const from = grid[startIndex], to = grid[startIndex + 1];
-  if (!(to > from)) throw new Error("Original-source encoding requires a finite published interval.");
+  const stretch = grid.slice(startIndex, endIndex + 2);
+  const from = stretch[0], to = stretch.at(-1);
+  if (stretch.length !== endIndex - startIndex + 2 || !stretch.every((at, index) => index === 0 || at > stretch[index - 1])) {
+    throw new Error("Original-source encoding requires a finite published interval.");
+  }
+  const last = stretch.at(-2);
   const sourceFor = kind => admittedInput.sources.find(source => source.input.selections.some(selection => selection.track.type === kind));
   const primary = sourceFor(audioOnly ? "audio" : "video");
   const audio = sourceFor("audio") ?? primary;
   if (!primary) throw new Error("The selected source track is absent from original input.");
   const url = source => new URL(`/encode-input/${inputToken}/${source.fileIndex}`, baseUrl).href;
-  const localTimeline = { ...timeline, published: [from, to, to + (to - from)],
-    boundaries: [from, to, to + (to - from)], sourceStartOf: () => primary.input.from ?? from + primary.timeShiftSeconds };
-  const command = buildRunCommand({ ...params, startIndex: 0, endIndex: 0, timeline: localTimeline,
+  const local = [...stretch, to + (to - last)];
+  const localTimeline = { ...timeline, published: local,
+    boundaries: local, sourceStartOf: () => primary.input.from ?? from + primary.timeShiftSeconds };
+  const command = buildRunCommand({ ...params, startIndex: 0, endIndex: endIndex - startIndex, timeline: localTimeline,
     videoSourceTrackIndex: primary.input.selections.find(selection => selection.track.type === "video")?.index ?? 0,
     reorderDepth: primary.input.selections.find(selection => selection.track.type === "video")?.track.reorderDepth ?? 0,
     inputFile: { startTime: primary.timeShiftSeconds }, audioFile: { startTime: audio.timeShiftSeconds },

package/services/server/wire-outputs.js

@@ -218,6 +218,7 @@ export function wireOutputs({
     readMetadataActivity = null,
     sourceInputsFor = null,
     readEncodeRanges = null,
+    readEncodeHeldRanges = null,
     encodeInputs = null,
     indexMemory = null,
     budgetPolicy = null,
@@ -964,6 +965,7 @@ export function wireOutputs({
   parts.encodeInputs = encodeInputs ?? (typeof resolveEncodeInput === "function" ? new EncodeInputs({
     resolve: resolveEncodeInput,
     readRanges: readEncodeRanges,
+    heldRanges: readEncodeHeldRanges,
     reviseBudget: () => parts.machineBudget.revise(),
     capacity: () => parts.machineBudget.capacityOf("memory"),
     urgent: (output, index) => parts.encodeOrchestrator.wantedSegmentsOn(output.outputKey).some(window =>