@torrent-tv/proxy 2.105.8 → 2.105.10

package/package.json

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

package/services/encode/AdmittedInput.js

@@ -109,11 +109,12 @@ export async function admitInput({ sources, reserve, readRanges }) {
  * the download a second time through it (Home Assistant 2026-10-12,
  * torrent-tv/meta#178).
  */
-export async function writeAdmittedInput(input, stdin, { next = null, waiting = null } = {}) {
+export async function writeAdmittedInput(input, stdin, { next = null, waiting = null, onFirstInputBytes = null } = {}) {
   if (input?.kind !== "result") throw new TypeError("Only complete input may be written to an encoder.");
   const originSeconds = input.originSeconds;
   const declarations = JSON.stringify(input.tracks.map(input => matroskaTrackIdentity(input.track)));
   const seen = new Map();
+  let firstInputBytesNoted = false;
   let current = input, includeHeader = true;
   try {
     while (current) {
@@ -132,6 +133,10 @@ export async function writeAdmittedInput(input, stdin, { next = null, waiting =
         batch = Buffer.allocUnsafe(INPUT_WRITE_BATCH_BYTES);
         used = 0;
         await writeChunk(stdin, chunk);
+        if (!firstInputBytesNoted) {
+          firstInputBytesNoted = true;
+          onFirstInputBytes?.(chunk.length);
+        }
       };
       for await (const chunk of current.stream({ originSeconds, includeHeader, seen })) {
         if (!Buffer.isBuffer(chunk)) throw new TypeError("Admitted input stream yielded a non-buffer chunk.");

package/services/encode/EncodeRuns.js

@@ -291,8 +291,9 @@ export class EncodeRuns {
     const endedAt = performance.now();
     run.firstWaitTraceInputAt = endedAt;
     const { sourceKey, process } = run.waitTraceInput ?? {};
+    const startedAt = run.waitTraceInput?.startedAt;
     this.#host.observeWait?.(sourceKey, "process", { process, phase: "end", runToken, fileIndex, bytes,
-      startedAt: run.startedAt, endedAt, durationMs: endedAt - run.startedAt });
+      startedAt, endedAt, durationMs: Number.isFinite(startedAt) ? endedAt - startedAt : null });
     const f2Process = process === "F1.a" ? "F2.a" : "F2.v";
     run.waitTraceInput.f2Process = f2Process;
     run.waitTraceInput.f2StartedAt = endedAt;
@@ -1290,9 +1291,10 @@ export class EncodeRuns {
       }
     });
     const f1Process = session.spec.carries === "audio-only" ? "F1.a" : "F1.v";
-    run.waitTraceInput = { sourceKey: session.file.sourceKey, process: f1Process };
+    const f1StartedAt = performance.now();
+    run.waitTraceInput = { sourceKey: session.file.sourceKey, process: f1Process, startedAt: f1StartedAt };
     this.#host.observeWait?.(session.file.sourceKey, "process", { process: f1Process,
-      phase: "begin", runToken: inputToken, startedAt: run.startedAt, output: session.outputKey,
+      phase: "begin", runToken: inputToken, startedAt: f1StartedAt, output: session.outputKey,
       from: run.from, to: run.to });
     if (admittedInput.original) {
       run.originalInput = admittedInput;
@@ -1339,11 +1341,14 @@ export class EncodeRuns {
       // begun at once (`next-packet-input.js`).
       const following = nextPacketInputs({ take: index => this.#host.encodeInputs.take(session, index, index),
         canAppend, first: nextIndex, last: ordered?.to ?? startIndex });
-      void writeAdmittedInput(admittedInput, run.process.stdin, { next: async () => {
-        const next = following.next(index => { run.to = index; });
-        if (next) run.admittedInputKeys.set(run.to, this.#inputFailures.key(next, inputParameters));
-        return next;
-      } }).catch(error => {
+      void writeAdmittedInput(admittedInput, run.process.stdin, {
+        onFirstInputBytes: bytes => this.noteFirstInputBytes(inputToken, session.file.fileIndex, bytes),
+        next: async () => {
+          const next = following.next(index => { run.to = index; });
+          if (next) run.admittedInputKeys.set(run.to, this.#inputFailures.key(next, inputParameters));
+          return next;
+        }
+      }).catch(error => {
         this.#host.logger.warn(`encode input output=${session.outputKey} segment=${safeIndex} write failed: ${error.message}`);
         run.process?.stdin?.destroy();
       }).finally(() => following.release());