@torrent-tv/proxy 2.89.6 → 2.89.8

package/services/encode/EncodeRun.js

@@ -106,6 +106,8 @@ export class EncodeRun {
   /** Half a name left over from the last chunk of the encoder's own channel. */
   #closedTail = "";
   #pendingClosed = null;
+  #closedTimings = new Map();
+  #publicationError = null;
   #inputTruncated = false;
   #stderrReadTail = "";
   #processExited = false;
@@ -550,16 +552,24 @@ export class EncodeRun {
     // The last piece of the chunk may be half a name; it waits for the rest.
     this.#closedTail = lines.pop() ?? "";
     for (const line of lines) {
-      const name = line.trim();
+      const entry = line.trim();
+      const csv = /^"?([^",]+)"?,(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)$/.exec(entry);
+      const name = csv ? csv[1] : entry;
       if (name.length === 0) {
         continue;
       }
-      if (this.#stopping) continue;
+      if (this.#stopping || this.#publicationError) continue;
+      if (csv) {
+        this.#closedTimings.set(name, {
+          endMicros: BigInt(Math.round(Number(csv[3]) * 1_000_000))
+        });
+      }
       // A subsequent closed file proves the previous one reached a cut.
       // The last file can instead have been flushed by an input failure.
       if (this.#pendingClosed !== null) {
         this.#publishClosed(this.#pendingClosed);
       }
+      if (this.#publicationError) break;
       this.#pendingClosed = name;
     }
   }
@@ -570,7 +580,20 @@ export class EncodeRun {
       // ffmpeg writes a piece under a working name and reports that; the piece
       // becomes servable by being renamed, and everything below works in the
       // name a request can actually ask for.
-      const served = this.onClosed(name);
+      let served;
+      try {
+        served = this.onClosed(name, this.#closedTimings.get(name) ?? null);
+      } catch (error) {
+        this.#publicationError = error instanceof Error ? error.message : String(error);
+        this.lastError = this.#publicationError;
+        // A refused closed piece must release this run's claim now, rather
+        // than keep its viewer waiting until the rest of the film is encoded.
+        this.#continue();
+        this.#signal("SIGTERM");
+        return false;
+      } finally {
+        this.#closedTimings.delete(name);
+      }
       if (!served) return false;
       if (!this.#stopping) {
         this.#provenName = served;
@@ -640,10 +663,37 @@ export class EncodeRun {
     // A suspended process does not act on SIGTERM until it is continued, so the
     // wait for its exit would never end. Let it run before asking it to stop.
     this.#continue();
+    this.#signal("SIGTERM");
+  }
+
+  /**
+   * Send a signal to this run's process, and only to it.
+   *
+   * ONLY A PROCESS THAT STARTED IS SIGNALLED. When the executable cannot be
+   * started, Node reports the failure on a later turn, and until then the child
+   * holds a handle whose process id is 0. Signalling it then is `kill(0, …)`,
+   * which reaches every process in our own process group: the proxy itself, and
+   * under `node --test` the test runner. Measured 2026-10-03: a run stopped in
+   * the same turn its `ffmpeg` failed to start ended the whole test run
+   * ("Interrupted while running") in 5 of 40 runs of one file.
+   *
+   * Sent through the child object rather than `process.kill(pid)`, so the
+   * signal goes to the process this run spawned and to nothing that happens to
+   * hold the same number.
+   *
+   * @param {NodeJS.Signals} signal
+   * @returns {boolean} Whether the signal was delivered.
+   */
+  #signal(signal) {
+    const child = this.#process;
+    if (!child || !(Number(child.pid) > 0)) {
+      return false;
+    }
     try {
-      this.#process.kill("SIGTERM");
+      return child.kill(signal) !== false;
     } catch {
       // Best effort: it may already be gone, and its exit will say so.
+      return false;
     }
   }
 
@@ -662,7 +712,9 @@ export class EncodeRun {
       return false;
     }
     try {
-      globalThis.process.kill(this.#process.pid, "SIGSTOP");
+      // A platform without the signal throws here (ENOSYS), which is what
+      // marks suspension unsupported below.
+      this.#process.kill("SIGSTOP");
     } catch (error) {
       this.#pauseUnsupported = true;
       this.logger.info(
@@ -708,15 +760,10 @@ export class EncodeRun {
     if (this.#state !== ENCODE_RUN_STATE.SUSPENDED || !this.#process?.pid) {
       return false;
     }
-    let continued = true;
-    try {
-      globalThis.process.kill(this.#process.pid, "SIGCONT");
-    } catch {
-      // The process is gone; its exit handler will deal with it. The state is
-      // moved either way — but nothing was resumed, and saying so is what stops
-      // a dead run being reported as producing again.
-      continued = false;
-    }
+    // The process may be gone; its exit handler will deal with it. The state
+    // is moved either way — but nothing was resumed, and saying so is what
+    // stops a dead run being reported as producing again.
+    const continued = this.#signal("SIGCONT");
     this.#transition(ENCODE_RUN_EVENT.RESUMED);
     this.clock.continued();
     return continued;
@@ -727,6 +774,10 @@ export class EncodeRun {
    * @param {string | null} signal
    */
   #onExit(code, signal) {
+    if (this.#publicationError) {
+      this.#finish(ENCODE_EXIT.PUBLICATION_FAILED, this.#publicationError, code, signal);
+      return;
+    }
     if (this.#stopping) {
       this.#finish(ENCODE_EXIT.STOPPED, this.#stopReason, code, signal);
       return;
@@ -749,7 +800,8 @@ export class EncodeRun {
     if (outcome === ENCODE_EXIT.COMPLETE) {
       if (this.#pendingClosed !== null && !this.#inputTruncated) {
         if (!this.#publishClosed(this.#pendingClosed)) {
-          this.#finish(ENCODE_EXIT.SHORT, "its final file could not be published", code, signal);
+          this.#finish(this.#publicationError ? ENCODE_EXIT.PUBLICATION_FAILED : ENCODE_EXIT.SHORT,
+            this.#publicationError ?? "its final file could not be published", code, signal);
           return;
         }
         this.#pendingClosed = null;

package/services/encode/EncodeRuns.js

@@ -15,7 +15,7 @@ import { ENCODE_EXIT } from "./encode-exit.js";
 import { EncodeRun } from "./EncodeRun.js";
 import { computeOutputDimensions } from "./args.js";
 import { buildRunCommand, trueStartOf } from "./run-command.js";
-import { cutOf, judgePiece } from "./piece-completeness.js";
+import { cutOf, judgePiece, originOf, productionOf } from "./piece-completeness.js";
 
 /**
  * @typedef {Object} SegmentFiles
@@ -346,7 +346,7 @@ export class EncodeRuns {
    * @param {number} index
    * @returns {object | null | false}
    */
-  #wholeClosedPiece(session, name, index) {
+  #wholeClosedPiece(session, name, index, production = null) {
     const format = session.segmentFormat;
     if (!format?.readMediaRanges || !Number.isInteger(index) || index < 0) {
       return null;
@@ -354,6 +354,7 @@ export class EncodeRuns {
     const address = session.outputKey ?? "";
     try {
       const mediaRanges = format.readMediaRanges(this.#host.segmentFiles.closedBytesOf(address, name));
+      if (mediaRanges && production) mediaRanges.production = production;
       const cut = cutOf(session.timeline, index);
       const { whole, throughSeconds } = judgePiece(format, mediaRanges, cut);
       if (!whole) {
@@ -851,7 +852,7 @@ export class EncodeRuns {
     this.#lastInputToken += 1;
     const inputToken = this.#lastInputToken;
     const inputs = this.#host.inputOf(session, inputToken);
-    const { args, safeIndex, startSeconds, cutTimes } = buildRunCommand({
+    const { args, safeIndex, inputIndex, startSeconds, cutTimes } = buildRunCommand({
       keyframes: session.keyframes,
       inputFile: inputs.inputFile,
       audioFile: inputs.audioFile,
@@ -897,6 +898,8 @@ export class EncodeRuns {
     // killed mid-piece leaving a partial file — is not a correctness problem
     // either, because the store serves a segment only once its closure is
     // proven, and it is cleared up when the run ends.
+    let originMicros = null;
+    const referenceKind = session.spec.video ? "vide" : "soun";
     const run = new EncodeRun({
       address: session.outputKey ?? session.id,
       encoder: this.#host.videoEncoder,
@@ -929,13 +932,22 @@ export class EncodeRuns {
       // Why this encoder exists, recorded with its argument list. It used to be
       // handed to a separate `start` call; there is no separate call now.
       because,
-      onClosed: (name) => {
+      onClosed: (name, timing) => {
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
+        if (timing && originMicros === null && session.segmentFormat.readMediaRanges) {
+          const ranges = session.segmentFormat.readMediaRanges(
+            this.#host.segmentFiles.closedBytesOf(session.outputKey ?? "", name));
+          originMicros = originOf(ranges, timing.endMicros, referenceKind);
+        }
         if (Number.isInteger(index) && index < safeIndex) return null;
-        const mediaRanges = this.#wholeClosedPiece(session, name, index);
-        if (mediaRanges === false) return null;
-        return this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat, { mediaRanges });
+        const production = productionOf(timing ? { ...timing, originMicros } : null,
+          cutTimes, index - inputIndex, referenceKind);
+        const mediaRanges = this.#wholeClosedPiece(session, name, index, production);
+        if (mediaRanges === false) throw new Error(`Closed piece #${index} could not be published: its media does not reach its muxer cut or is unreadable.`);
+        const published = this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat, { mediaRanges });
+        if (!published) throw new Error(`Closed piece #${index} could not be published to the segment store.`);
+        return published;
       },
       onSpeedMeasured: () => this.#host.noteRunSpeedMeasured?.(session, run),
       onEnded: (ended) => {