@torrent-tv/proxy 2.96.0 → 2.96.2

package/bin/cli.js

@@ -617,9 +617,6 @@ try {
     onSignal(sessionId, signal) {
       webRtcManager?.handleSignal(sessionId, signal);
     },
-    // Asked by a server that still polls; the same description the proxy
-    // sends on its own when it changes.
-    onHealthRequest: () => describeSelf(),
     // Whether this host could sustain a file it has only been told about. The
     // same arithmetic the first offer uses, against this host's own startup
     // benchmarks — no torrent, no bytes, no ffmpeg — so the browser can ask

package/package.json

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

package/services/encode/EncodeRun.js

@@ -285,6 +285,15 @@ export class EncodeRun {
     this.indexOfName = typeof indexOfName === "function" ? indexOfName : () => null;
     /** The last thing ffmpeg said on stderr, which is what a failure is explained by. */
     this.lastError = "";
+    /**
+     * How far after the start it was asked for this run's segment muxer counts
+     * its cuts from, in seconds. The muxer measures every cut from its first
+     * reference packet, and a copied stream's first packet lies up to one frame
+     * after the requested start, so every piece of the run ends that much later
+     * than its cut. `null` until the run's first piece has closed
+     * (`piece-completeness.js`, `cutShiftOf`).
+     */
+    this.cutShiftSeconds = null;
     // EXISTING IS RUNNING. There is no moment at which a built run is not yet a
     // process, so there is no second act for two owners to perform.
     this.#begin(because);

package/services/encode/EncodeRuns.js

@@ -17,7 +17,7 @@ import { computeOutputDimensions } from "./args.js";
 import { buildAdmittedCommand } from "./admitted-command.js";
 import { buildOriginalCommand } from "./source-command.js";
 import { writeAdmittedInput } from "./AdmittedInput.js";
-import { cutOf, judgeNeighbors, judgePiece } from "./piece-completeness.js";
+import { cutOf, cutShiftOf, judgeNeighbors, judgePiece } from "./piece-completeness.js";
 import { presentationSegment } from "./segment-formats/presentation-segment.js";
 import { InputFailures, failedAdmittedInput } from "./InputFailures.js";
 
@@ -351,9 +351,13 @@ export class EncodeRuns {
    * @param {HlsSession} session
    * @param {string} name - The working name the encoder closed it under.
    * @param {number} index
+   * @param {object | false} [admitted] - The original input the run reads, when it reads one.
+   * @param {Buffer | null} [bytes]
+   * @param {EncodeRun | null} [run] - The run that closed it, which keeps where its muxer counts cuts from.
+   * @param {{ endMicros: bigint } | null} [timing] - The piece's end in the muxer's clock, from its segment list.
    * @returns {object | null | false}
    */
-  #wholeClosedPiece(session, name, index, admitted = false, bytes = null) {
+  #wholeClosedPiece(session, name, index, admitted = false, bytes = null, run = null, timing = null) {
 
     const format = session.segmentFormat;
     if (!format?.readMediaRanges || !Number.isInteger(index) || index < 0) {
@@ -371,6 +375,16 @@ export class EncodeRuns {
             .map(input => [input.track.type === "video" ? "vide" : "soun", input.sourceEndSeconds])) } : {}),
         requiredKinds: [session.spec.carries !== "audio-only" ? "vide" : null,
           session.spec.audio && !this.#host.servesAudioSeparately(session) ? "soun" : null].filter(Boolean) } : undefined;
+      if (run) {
+        // Where the muxer counts this run's cuts from is known once its first
+        // piece has closed, and holds for every piece after it. It is a fact
+        // of each piece the run makes, so it travels with the piece.
+        if (run.cutShiftSeconds === null && index === run.from) {
+          run.cutShiftSeconds = cutShiftOf(mediaRanges, grid?.[run.from], session.spec.carries !== "audio-only" ? "vide" : "soun",
+            timing?.endMicros ?? null);
+        }
+        if (mediaRanges && run.cutShiftSeconds !== null) mediaRanges.cutShiftSeconds = run.cutShiftSeconds;
+      }
       const { whole, throughSeconds, reason } = judgePiece(format, mediaRanges, cut, interval);
       if (!whole) {
         this.#host.logger.warn(
@@ -990,7 +1004,7 @@ 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, following) => {
+      onClosed: (name, following, timing) => {
 
         const index = session.segmentFormat.segmentIndexFromName(
           session.segmentFormat.servedNameOf?.(name) ?? name);
@@ -1012,7 +1026,7 @@ export class EncodeRuns {
             throw error;
           }
         }
-        const mediaRanges = this.#wholeClosedPiece(session, name, index, admittedInput, bytes);
+        const mediaRanges = this.#wholeClosedPiece(session, name, index, admittedInput, bytes, run, timing);
         if (mediaRanges === false) throw Object.assign(new Error(`Closed piece #${index} has incomplete media.`),
           { code: "ERR_INCOMPLETE_MEDIA" });
         const published = this.#host.segmentFiles.publish(session.outputKey ?? "", name, session.segmentFormat, { mediaRanges, bytes });

package/services/encode/piece-completeness.js

@@ -30,82 +30,81 @@ export function cutOf(timeline, index) {
 }
 
 /**
- * Track positions read from empty edits retain their movie-tick uncertainty.
- * Fresh closures also carry the muxer's packet end and its actual cut, so a
- * restarted run is judged on its own reference clock. Neither allowance is a
- * browser's frame-join rule.
+ * Whether a closed piece holds its stretch of film. With `interval` (a run
+ * reading the original file, which states the stretch each piece covers) the
+ * piece's tracks are compared with that stretch; otherwise with the cut.
+ *
+ * Both are compared on the clock the producing run's muxer cut by: moved by
+ * `ranges.cutShiftSeconds`, which the run states for every piece it closes
+ * ({@link cutShiftOf}) and which travels with the piece. A piece whose run is
+ * not known — one adopted from an earlier life of the process — has none, and
+ * is compared with the cut as published.
  *
  * @param {{ producedThroughSeconds?: (ranges: object) => number | null }} format
  * @param {object} ranges - The piece's media intervals, as the format read them.
  * @param {number | undefined} cutSeconds - From {@link cutOf}.
- * @returns {{ whole: boolean, throughSeconds: number | null }}
+ * @param {{ from: number, to: number, requiredKinds: string[], sourceEnds?: object }} [interval]
+ * @returns {{ whole: boolean, throughSeconds: number | null, reason?: string }}
  */
 export function judgePiece(format, ranges, cutSeconds, interval) {
   const throughSeconds = format.producedThroughSeconds?.(ranges) ?? null;
   if (throughSeconds === null) {
     return { whole: false, throughSeconds };
   }
+  const shift = Number.isFinite(ranges?.cutShiftSeconds) ? ranges.cutShiftSeconds : 0;
   if (interval) {
-    const reason = intervalFailure(ranges, interval);
+    const reason = intervalFailure(ranges, { ...interval, shift });
     return reason ? { whole: false, throughSeconds, reason } : { whole: true, throughSeconds };
   }
-  const cutMicros = ranges?.production?.cutMicros ??
-    (Number.isFinite(cutSeconds) ? BigInt(Math.round(cutSeconds * 1_000_000)) : null);
+  const cutMicros = Number.isFinite(cutSeconds) ? BigInt(Math.round((cutSeconds + shift) * 1_000_000)) : null;
   if (cutMicros !== null && ranges?.tracks?.length) {
-    const tracks = ranges.tracks;
-    const production = ranges.production;
-    const reference = production ? tracks.find(({ kind }) => kind === production.kind) : null;
-    const referenceEnd = reference?.ranges.at(-1)?.end;
-    const whole = tracks.every((track) => {
-      const { timescale, ranges: held, positionErrorTicks = 0n } = track;
+    const whole = ranges.tracks.every(({ timescale, ranges: held, positionErrorTicks = 0n }) => {
       const end = held.at(-1)?.end;
-      if (end === undefined) return false;
-      if (referenceEnd !== undefined) {
-        if (track === reference) return 2n * production.endMicros + 1n >= 2n * cutMicros;
-        // The segment muxer's CSV reports packet time before movenc truncates
-        // the empty edit. Compare on that clock, including another track's
-        // relative end and the precision of both written track positions.
-        const difference = (end + positionErrorTicks) * reference.timescale -
-          (referenceEnd - (reference.positionErrorTicks ?? 0n)) * timescale;
-        const denominator = timescale * reference.timescale;
-        return 2n * difference * 1_000_000n +
-          (2n * production.endMicros + 1n) * denominator >= 2n * cutMicros * denominator;
-      }
-      return (end + positionErrorTicks) * 1_000_000n >= cutMicros * timescale;
+      return end !== undefined && (end + positionErrorTicks) * 1_000_000n >= cutMicros * timescale;
     });
     return { whole, throughSeconds };
   }
   if (cutMicros !== null && throughSeconds < Number(cutMicros) / 1_000_000) {
-
     return { whole: false, throughSeconds };
   }
   return { whole: true, throughSeconds };
 }
 
-/** The muxer cuts relative to its first reference packet, not the requested seek. */
-export function productionOf(timing, cutTimes, relativeIndex, kind) {
-  if (!timing || timing.originMicros === null || !Number.isFinite(cutTimes?.[relativeIndex])) return null;
-  return {
-    kind,
-    endMicros: timing.endMicros,
-    cutMicros: timing.originMicros + BigInt(Math.round(cutTimes[relativeIndex] * 1_000_000)) -
-      BigInt(Math.round(SEGMENT_CUT_TIME_DELTA_SECONDS * 1_000_000))
-  };
-}
-
 /**
- * The first CSV entry has start_time = 0 even after a seek (segment.c).
- * Recover its reference packet's PTS from the reported end minus the exact
- * sample span. The edit-list offset cancels, including its lost precision.
+ * How far after its requested start a run's segment muxer counts its cuts
+ * from, read from the run's FIRST piece, or `null` when that piece does not
+ * start within one frame of the start.
+ *
+ * With `endMicros`, the end of the piece in the muxer's own clock as its
+ * segment list states it, the first packet is that end less the span of the
+ * piece's samples: exact, because the span is a sum of sample durations and
+ * the muxer's clock needs no track position. Without it, the first sample's
+ * position is read, which the piece states only to within its position error.
+ *
+ * The muxer measures every cut time from its first packet of the reference
+ * stream, not from the start it was asked for (measured on ffmpeg 8.1.2,
+ * 2026-10-09: AAC copied from Matroska, asked to start at 10.385 s with its
+ * first packet at 10.403 s and a cut at 10.386 s from the start, closed the
+ * piece at 20.805 s — the first packet at or after 10.403 + 10.386). A copied
+ * stream cannot start between its packets, so its first packet lies up to one
+ * frame after the requested start, and every cut of the run moves by as much.
+ *
+ * @param {object} ranges - The first piece's media intervals.
+ * @param {number} startSeconds - Where the run was asked to start.
+ * @param {string} kind - The reference track: `vide` when the output carries a picture, else `soun`.
+ * @returns {number | null}
  */
-export function originOf(ranges, endMicros, kind) {
-  const track = ranges?.tracks?.find(track => track.kind === kind);
-  if (track?.firstSampleStart === undefined || !track.ranges.length) return null;
-  const ticks = endMicros * track.timescale -
-    (track.ranges.at(-1).end - track.firstSampleStart) * 1_000_000n;
-  // CSV rounds to microseconds; rescale with the muxer's nearest rounding.
-  return ticks >= 0n ? (2n * ticks + track.timescale) / (2n * track.timescale) :
-    -((-2n * ticks + track.timescale) / (2n * track.timescale));
+export function cutShiftOf(ranges, startSeconds, kind, endMicros = null) {
+  const track = ranges?.tracks?.find((candidate) => candidate.kind === kind);
+  const first = track?.ranges?.[0];
+  if (!first || !(track.timescale > 0n) || !Number.isFinite(startSeconds)) return null;
+  const timescale = Number(track.timescale);
+  const firstSeconds = typeof endMicros === "bigint" && track.firstSampleStart !== undefined
+    ? Number(endMicros) / 1_000_000 - Number(track.ranges.at(-1).end - track.firstSampleStart) / timescale
+    : Number(first.start) / timescale;
+  const shift = firstSeconds - startSeconds;
+  const allowance = Number((track.productionFrame ?? first.frame) + (track.positionErrorTicks ?? 0n)) / timescale;
+  return Math.abs(shift) <= allowance ? shift : null;
 }
 
 /** Compare adjacent production ranges in their declared track clocks. */
@@ -129,15 +128,19 @@ export function judgeNeighbors(left, right) {
   return { whole: true };
 }
 
-/** Every required track must cover the interval with at most one-frame error. */
-function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {} }) {
+/**
+ * Every required track must cover the interval with at most one-frame error,
+ * on the clock the run's muxer cut by: the interval moved by `shift`
+ * ({@link cutShiftOf}). A track's own end in the file is not moved.
+ */
+function intervalFailure(coverage, { from, to, requiredKinds, sourceEnds = {}, shift = 0 }) {
   if (!Number.isFinite(from) || !Number.isFinite(to) || !(to > from) || !requiredKinds?.length) return "segment-interval-is-not-declared";
   for (const kind of requiredKinds) {
     const track = coverage?.tracks?.find(track => track.kind === kind);
     if (!track?.ranges?.length || !(track.timescale > 0n)) return `segment-missing-${kind}`;
-    const start = BigInt(Math.round(from * Number(track.timescale)));
-    const through = Number.isFinite(sourceEnds[kind]) ? Math.min(to, sourceEnds[kind]) : to;
-    if (!(through > from)) return `segment-interval-is-empty-${kind}`;
+    const start = BigInt(Math.round((from + shift) * Number(track.timescale)));
+    const through = Number.isFinite(sourceEnds[kind]) ? Math.min(to + shift, sourceEnds[kind]) : to + shift;
+    if (!(through > from + shift)) return `segment-interval-is-empty-${kind}`;
     const end = BigInt(Math.round(through * Number(track.timescale)));
     const first = track.ranges[0];
     const frame = track.productionFrame ?? first.frame;

package/services/transport/tunnel-client.js

@@ -20,7 +20,6 @@
 
 import { WebSocket } from "ws";
 
-/** @import { HealthMetrics } from './health-collector.js' */
 
 /**
  * Configuration for the tunnel client.
@@ -52,9 +51,6 @@ import { WebSocket } from "ws";
  *   Answered from this host's startup benchmarks alone: no torrent is added, no
  *   bytes are fetched and ffmpeg is not run, so it costs milliseconds and can
  *   be asked of every proxy in the pool at once.
- * @property {() => HealthMetrics} [onHealthRequest]
- *   Called when the server sends a `health-request` message.  The return value is
- *   sent back as `health-response` and used by the server to score this proxy.
  * @property {(message: string) => void} [onLog]
  *   Optional structured log sink.
  */
@@ -136,7 +132,6 @@ export function createTunnelClient({
   baseUrl = "",
   onSignal,
   onConnect,
-  onHealthRequest,
   onCanServeRequest,
   onLog,
   connectionLifetimeMs = CONNECTION_LIFETIME_MS
@@ -278,6 +273,14 @@ export function createTunnelClient({
         return;
       }
 
+      // The server's answer to this proxy's keepalive, echoed at once on the
+      // same connection: the server measures the tunnel round trip from it on
+      // its own clock, and chooses proxies partly by that.
+      if (message.type === "rtt-probe") {
+        send({ type: "rtt-echo", sentAt: message.sentAt }, connection);
+        return;
+      }
+
       // Could this host serve a file it is only told ABOUT? Asked when the
       // proxy a viewer landed on has refused the file, so the browser can be
       // sent somewhere that will work instead of being shown an error. The
@@ -297,29 +300,6 @@ export function createTunnelClient({
         send({ type: "can-serve-response", requestId: message.requestId, offer }, connection);
         return;
       }
-
-      // Health check: server requests current metrics for proxy scoring.
-      if (message.type === "health-request") {
-        // Awaited: the answer now carries which films this proxy holds, and the
-        // truthful list of those lives on the torrent thread.
-        void (async () => {
-          let answer = {};
-          try {
-            answer = typeof onHealthRequest === "function" ? await onHealthRequest() : {};
-          } catch {
-            // silent-ok: a proxy that cannot describe itself is scored on
-            // nothing rather than not answered at all, which would drop it out
-            // of every selection until the next poll.
-          }
-          send({
-            type: "health-response",
-            requestId: message.requestId,
-            metrics: answer?.metrics ?? answer ?? {},
-            holds: Array.isArray(answer?.holds) ? answer.holds : []
-          }, connection);
-        })();
-        return;
-      }
     });
 
     connection.addEventListener("close", (event) => {