@torrent-tv/proxy 2.105.11 → 2.105.13

package/package.json

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

package/services/transport/data-channel-handler.js

@@ -63,10 +63,10 @@ const loopbackDispatcher = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
  * @property {(message: string) => void} [onLog]
  *   Optional log sink.
  * @property {{ maybeCapture: (trigger: {
- *   sessionId: string, tag: string, label: string,
+ *   sessionId: string, tag: string, captureId: string, label: string,
  *   remote: { address: string, port: number } | null,
  *   queuedBytes: number, stuckForMs: number
- * }) => boolean }} [witness]
+ * }) => boolean, cancelCapture?: (captureId: string) => Promise<boolean> }} [witness]
  *   The packet witness (services/transport/packet-witness.js). When {@link wedgeIsCertain}
  *   says delivery has stopped, the watcher hands it the transport snapshot's
  *   remote endpoint: the ring's history is kept and a tail capture records what
@@ -182,7 +182,7 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
   // closing, delete the survivor's entry. `captureStarted` rides on the same
   // record: both channels of one wedged connection must ask the witness once,
   // not once per channel.
-  /** @type {Map<string, { channels: Map<DataChannel, string>, at: number, previous: object | null, unknown: number, captureStarted: boolean }>} */
+  /** @type {Map<string, { channels: Map<DataChannel, string>, at: number, previous: object | null, unknown: number, captureStarted: boolean, captureId: string | null, captureChannel: DataChannel | null, captureSequence: number }>} */
   const connections = new Map();
 
   /**
@@ -288,6 +288,9 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         previous: null,
         unknown: 0,
         captureStarted: false,
+        captureId: null,
+        captureChannel: null,
+        captureSequence: 0,
         // The accepted-byte counter and when it last moved, plus the rate it
         // was moving at. `wedgeIsCertain` divides the queue by that rate.
         rateAt: 0,
@@ -324,6 +327,14 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
       }
       stopped = true;
       witness?.releaseRing?.();
+      if (connection.captureChannel === channel) {
+        if (connection.captureId) {
+          void witness?.cancelCapture?.(connection.captureId);
+        }
+        connection.captureStarted = false;
+        connection.captureId = null;
+        connection.captureChannel = null;
+      }
       if (timer) {
         clearInterval(timer);
       }
@@ -454,7 +465,14 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         // The queue moved, so whatever was called a wedge has cleared. Let a
         // later one be recorded too: one mistaken call must not spend the
         // session's only capture.
-        connection.captureStarted = false;
+        if (connection.captureChannel === channel) {
+          if (connection.captureId) {
+            void witness?.cancelCapture?.(connection.captureId);
+          }
+          connection.captureStarted = false;
+          connection.captureId = null;
+          connection.captureChannel = null;
+        }
         return;
       }
       const now = Date.now();
@@ -535,14 +553,23 @@ function makeSendQueueWatcher({ log, getTransportSnapshot, witness, usrsctpState
         peerStillSending
       ) {
         connection.captureStarted = true;
-        witness.maybeCapture({
+        const captureId = `${sessionId}:send-queue:${++connection.captureSequence}`;
+        connection.captureId = captureId;
+        connection.captureChannel = channel;
+        const started = witness.maybeCapture({
           sessionId,
           tag,
+          captureId,
           label,
           remote: snapshot.remote ?? null,
           queuedBytes: queued,
           stuckForMs: now - stuckSince
         });
+        if (!started) {
+          connection.captureStarted = false;
+          connection.captureId = null;
+          connection.captureChannel = null;
+        }
       }
       if (usrsctpState && verdict.certain && peerStillSending) {
         // Its own single-flight and cooldown, independent of the witness's —

package/services/transport/delivery-probe.js

@@ -246,7 +246,9 @@ export function probeWedgeIsCertain({
  * @property {number | null} peerBytesAtTick - The same, as it stood at the previous tick.
  * @property {number | null} peerLoopLagMs - The far end's own event-loop delay, as last reported.
  * @property {string | null} peerVisibility - Whether the far end's tab is visible or hidden, as last reported.
- * @property {boolean} probeCaptureStarted - One evidence-gathering attempt per wedge; reset once `seen` advances again.
+ * @property {boolean} probeCaptureStarted - One evidence-gathering attempt per wedge; reset once the verdict clears.
+ * @property {number} probeCaptureSequence
+ * @property {string | null} probeCaptureId
  * @property {ReturnType<typeof setInterval> | null} timer
  */
 
@@ -409,7 +411,7 @@ export function readProbeState(state) {
  * @param {(sessionId: string) => object | null} [options.getTransportSnapshot]
  *   Needed only to hand the witness a remote endpoint when this probe is the
  *   one declaring a wedge.
- * @param {{ maybeCapture: (trigger: object) => boolean }} [options.witness]
+ * @param {{ maybeCapture: (trigger: object) => boolean, cancelCapture?: (captureId: string) => Promise<boolean> }} [options.witness]
  * @param {{ maybeRead: (reasonText: string) => boolean }} [options.usrsctpState]
  * @returns {{
  *   attach: (sessionId: string, tag: string, label: string, channel: import('node-datachannel').DataChannel) => void,
@@ -599,6 +601,8 @@ export function createDeliveryProbe({
       });
       if (isCertain && !connection.probeCaptureStarted) {
         connection.probeCaptureStarted = true;
+        const captureId = `${connection.id}:probe:${++connection.probeCaptureSequence}`;
+        connection.probeCaptureId = captureId;
         const reasonText =
           `probe seen-counter unmoved ${Math.round(stuckForMs / 1000)}s against the ` +
           `${(needMs / 1000).toFixed(1)}s this connection's own history says is legitimate`;
@@ -607,6 +611,7 @@ export function createDeliveryProbe({
           const started = witness.maybeCapture({
             sessionId: connection.id,
             tag: connection.tag,
+            captureId,
             label: "probe",
             remote: snapshot?.remote ?? null,
             queuedBytes: 0,
@@ -614,16 +619,27 @@ export function createDeliveryProbe({
           });
           if (!started) {
             connection.probeCaptureStarted = false;
+            connection.probeCaptureId = null;
           }
         }
         if (usrsctpState) {
           usrsctpState.maybeRead(reasonText);
         }
+      } else if (!isCertain) {
+        connection.probeCaptureStarted = false;
+        if (connection.probeCaptureId) {
+          void witness?.cancelCapture?.(connection.probeCaptureId);
+          connection.probeCaptureId = null;
+        }
       }
     } else {
       // Not association-stopped any more: whatever was flagged has cleared,
       // and a later wedge on the same connection deserves its own attempt.
       connection.probeCaptureStarted = false;
+      if (connection.probeCaptureId) {
+        void witness?.cancelCapture?.(connection.probeCaptureId);
+        connection.probeCaptureId = null;
+      }
     }
   }
 
@@ -672,6 +688,8 @@ export function createDeliveryProbe({
           longestHealthySeenGapMs: 0,
           sentAtBySeq: new Map(),
           probeCaptureStarted: false,
+          probeCaptureSequence: 0,
+          probeCaptureId: null,
           timer: null
         };
         connections.set(sessionId, connection);
@@ -701,6 +719,10 @@ export function createDeliveryProbe({
         if (connections.get(sessionId) === connection) {
           connections.delete(sessionId);
         }
+        if (connection.probeCaptureId) {
+          void witness?.cancelCapture?.(connection.probeCaptureId);
+          connection.probeCaptureId = null;
+        }
       }
     },
 
@@ -720,6 +742,10 @@ export function createDeliveryProbe({
       }
       connection.channels.clear();
       connections.delete(sessionId);
+      if (connection.probeCaptureId) {
+        void witness?.cancelCapture?.(connection.probeCaptureId);
+        connection.probeCaptureId = null;
+      }
     },
 
     noteEcho(sessionId, echo) {

package/services/transport/packet-witness.js

@@ -97,12 +97,26 @@ export const WITNESS_RING_BASENAME = "packet-witness-ring.pcap";
  * @typedef {Object} WitnessTrigger
  * @property {string} sessionId
  * @property {string} tag       - Session id, first 8 characters.
+ * @property {string} captureId - Identity of the diagnosis that owns this capture.
  * @property {string} label     - Data channel label ("proxy", "proxy-control").
  * @property {WitnessRemoteEndpoint | null} remote
  * @property {number} queuedBytes
  * @property {number} stuckForMs
  */
 
+/**
+ * @typedef {Object} PacketCapture
+ * @property {string} connection
+ * @property {Set<string>} incidents
+ * @property {boolean} cancelled
+ * @property {import("node:child_process").ChildProcess | null} child
+ * @property {NodeJS.Timeout | null} cancelKill
+ * @property {string} filePrefix
+ * @property {Set<string>} files
+ * @property {Promise<void>} finished
+ * @property {() => void} finish
+ */
+
 /**
  * Strip a zone suffix and keep only IPv4/IPv6 literals.
  *
@@ -356,6 +370,7 @@ let logLine = () => {};
  * @returns {{
  *   dir: string,
  *   maybeCapture: (trigger: WitnessTrigger) => boolean,
+ *   cancelCapture: (captureId: string) => Promise<boolean>,
  *   holdRing: () => void,
  *   releaseRing: () => void
  * }}
@@ -367,16 +382,11 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
   /** @type {{ running: boolean, lastStartedAt: number, availability: "unknown" | "yes" | "no" }} */
   const state = { running: false, lastStartedAt: 0, availability: "unknown" };
 
-  /**
-   * Connections already captured, so one wedge is recorded once.
-   *
-   * A capture of a connection already captured adds nothing: the wedge does not
-   * un-wedge, and the second recording of it is the same silence as the first.
-   * Field 2026-09-06: thirteen captures of ONE wedge over six hours, 74 MB, all
-   * saying what the first one said.
-   *
-   * @type {Set<string>}
-   */
+  /** @type {Map<string, PacketCapture>} */
+  const capturesByConnection = new Map();
+  /** @type {Map<string, PacketCapture>} */
+  const capturesByIncident = new Map();
+  /** @type {Set<string>} */
   const captured = new Set();
 
   /**
@@ -416,9 +426,10 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
    *
    * @param {WitnessTrigger} trigger
    * @param {number} stampSeconds - Shared with the tail, so the pair sorts together.
+   * @param {PacketCapture} capture
    * @returns {Promise<string[]>} Names of the copies that landed.
    */
-  const preserveRing = async (trigger, stampSeconds) => {
+  const preserveRing = async (trigger, stampSeconds, capture) => {
     /** @type {string[]} */
     const kept = [];
     ring.preserving = true;
@@ -431,11 +442,15 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
         return kept;
       }
       for (const name of names) {
+        if (capture.cancelled) {
+          break;
+        }
         const suffix = name.slice(WITNESS_RING_BASENAME.length) || "0";
         const target = `packet-witness.${trigger.tag}.${stampSeconds}.before${suffix}.pcap`;
         try {
           await copyFile(path.join(resolvedDir, name), path.join(resolvedDir, target));
           kept.push(target);
+          capture.files.add(target);
         } catch {
           // silent-ok: nothing to copy, or it vanished under us.
         }
@@ -458,9 +473,10 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
    * @param {WitnessTrigger} trigger
    * @param {string} address - Validated remote IP literal.
    * @param {number} stampSeconds
+   * @param {PacketCapture} capture
    * @returns {Promise<void>}
    */
-  const runCapture = async (trigger, address, stampSeconds) => {
+  const runCapture = async (trigger, address, stampSeconds, capture) => {
     const prefix = path.join(
       resolvedDir,
       `packet-witness.${trigger.tag}.${stampSeconds}.tail.pcap`
@@ -472,6 +488,7 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
       fileMegabytes: WITNESS_TAIL_FILE_MB,
       files: WITNESS_TAIL_FILES
     });
+    capture.filePrefix = path.basename(prefix);
     logLine(
       `packet witness: capturing ${WITNESS_TAIL_SECONDS}s of udp port ${port} ↔ ${address} ` +
       `(session ${trigger.tag}, "${trigger.label}" queue ${trigger.queuedBytes}B wedged ` +
@@ -492,6 +509,7 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
         resolve();
         return;
       }
+      capture.child = child;
       const finish = () => {
         if (killer) {
           clearTimeout(killer);
@@ -501,6 +519,13 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
           clearTimeout(hardKill);
           hardKill = null;
         }
+        if (capture.child === child) {
+          capture.child = null;
+        }
+        if (capture.cancelKill) {
+          clearTimeout(capture.cancelKill);
+          capture.cancelKill = null;
+        }
         resolve();
       };
       child.on("error", (error) => {
@@ -533,6 +558,7 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
         try {
           const info = await stat(path.join(resolvedDir, name));
           mine.push(`${name} ${(info.size / 1024).toFixed(1)} KB`);
+          capture.files.add(name);
         } catch { /* gone between listing and reading */ }
       }
       logLine(`packet witness: wrote ${mine.length} file(s): ${mine.join(", ") || "none"}`);
@@ -553,12 +579,20 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
     if (!address || !Number.isInteger(portNumber) || portNumber < 1 || portNumber > 65535) {
       return false;
     }
-    if (!shouldStartCapture(state)) {
-      return false;
-    }
     const connection = `${address}:${portNumber}`;
+    const captureId = typeof trigger?.captureId === "string" && trigger.captureId.length > 0
+      ? trigger.captureId
+      : `${trigger?.sessionId ?? trigger?.tag ?? connection}:${trigger?.label ?? "unknown"}`;
+    const existing = capturesByConnection.get(connection);
+    if (existing && !existing.cancelled) {
+      existing.incidents.add(captureId);
+      capturesByIncident.set(captureId, existing);
+      return true;
+    }
     if (captured.has(connection)) {
-      // Not evidence twice.
+      return false;
+    }
+    if (!shouldStartCapture(state)) {
       return false;
     }
     // The evidence takes room from the product, so it is asked for. Refused, it
@@ -567,7 +601,21 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
     if (typeof mayKeep === "function" && !mayKeep(expectedBytes)) {
       return false;
     }
-    captured.add(connection);
+    /** @type {PacketCapture} */
+    const capture = {
+      connection,
+      incidents: new Set([captureId]),
+      cancelled: false,
+      child: null,
+      cancelKill: null,
+      filePrefix: "",
+      files: new Set(),
+      finished: Promise.resolve(),
+      finish: () => {}
+    };
+    capture.finished = new Promise((resolve) => { capture.finish = resolve; });
+    capturesByConnection.set(connection, capture);
+    capturesByIncident.set(captureId, capture);
     state.running = true;
     state.lastStartedAt = Date.now();
     const startedAt = state.lastStartedAt;
@@ -576,6 +624,9 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
         if (state.availability === "unknown") {
           state.availability = (await probeAvailability()) ? "yes" : "no";
         }
+        if (capture.cancelled) {
+          return;
+        }
         if (state.availability === "no") {
           logLine(
             "packet witness: unavailable — no tcpdump on this host; " +
@@ -584,29 +635,111 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
           return;
         }
         const stampSeconds = Math.floor(Date.now() / 1000);
-        const before = await preserveRing(trigger, stampSeconds);
+        const before = await preserveRing(trigger, stampSeconds, capture);
+        if (capture.cancelled) {
+          return;
+        }
         logLine(
           before.length > 0
             ? `packet witness: kept ${before.length} ring file(s) from before the wedge: ${before.join(", ")}`
             : "packet witness: no ring history to keep — the ring was not running"
         );
-        await runCapture(trigger, address, stampSeconds);
+        await runCapture(trigger, address, stampSeconds, capture);
+        if (capture.cancelled) {
+          return;
+        }
         // The disk bound has to hold between restarts too: one episode writes
         // up to four ring copies and two tail files, and the cooldown allows
         // six episodes an hour. Pruning only at startup let that accumulate.
         await pruneWitnessCaptures(resolvedDir, chooseRemovals);
+        captured.add(connection);
       } finally {
+        if (capture.cancelled) {
+          await removeCaptureFiles(capture);
+        }
+        if (capturesByConnection.get(connection) === capture) {
+          capturesByConnection.delete(connection);
+        }
+        for (const incident of capture.incidents) {
+          if (capturesByIncident.get(incident) === capture) {
+            capturesByIncident.delete(incident);
+          }
+        }
         state.running = false;
         // Keep the requested spacing honest even when the capture ended early.
         const earliestNext = startedAt + WITNESS_COOLDOWN_MS;
         if (state.lastStartedAt < earliestNext) {
           state.lastStartedAt = earliestNext;
         }
+        capture.finish();
       }
     })();
     return true;
   };
 
+  /**
+   * Cancel one diagnosis's ownership of a capture. The evidence is removed only
+   * after every diagnosis that shared this connection's capture has cleared.
+   *
+   * @param {string} captureId
+   * @returns {Promise<boolean>} Whether this diagnosis owned a live capture.
+   */
+  const cancelCapture = async (captureId) => {
+    const capture = capturesByIncident.get(captureId);
+    if (!capture) {
+      return false;
+    }
+    capturesByIncident.delete(captureId);
+    capture.incidents.delete(captureId);
+    if (capture.incidents.size > 0) {
+      return true;
+    }
+    capture.cancelled = true;
+    captured.delete(capture.connection);
+    if (capture.child) {
+      capture.cancelKill = setTimeout(() => {
+        try {
+          capture.child?.kill("SIGKILL");
+        } catch {
+          // The child may have exited between the check and the signal.
+        }
+      }, WITNESS_KILL_GRACE_MS);
+      capture.cancelKill.unref?.();
+      try {
+        capture.child.kill("SIGTERM");
+      } catch {
+        // The child may have exited between the check and the signal.
+      }
+    }
+    await capture.finished;
+    return true;
+  };
+
+  /** @param {PacketCapture} capture */
+  const removeCaptureFiles = async (capture) => {
+    if (capture.filePrefix) {
+      try {
+        for (const name of await readdir(resolvedDir)) {
+          if (name.startsWith(capture.filePrefix) && isWitnessCapture(name)) {
+            capture.files.add(name);
+          }
+        }
+      } catch {
+        // No output directory or no files to remove.
+      }
+    }
+    for (const name of capture.files) {
+      try {
+        await rm(path.join(resolvedDir, name), { force: true });
+      } catch {
+        // Best effort; a later pruning pass handles files that could not be removed.
+      }
+    }
+    if (capture.files.size > 0) {
+      logLine(`packet witness: removed ${capture.files.size} capture file(s) after recovery`);
+    }
+  };
+
   /**
    * The rolling ring: one tcpdump, reference-counted by open data channels.
    *
@@ -803,6 +936,6 @@ export function createPacketWitness({ log, dir = "", port, spawnProcess = spawn,
     await clearRingFiles();
   };
 
-  return { dir: resolvedDir, maybeCapture, holdRing, releaseRing, dispose, ring };
+  return { dir: resolvedDir, maybeCapture, cancelCapture, holdRing, releaseRing, dispose, ring };
 
 }

package/services/viewer/playback-readiness.js

@@ -519,17 +519,27 @@ export function predictPlaybackReadiness(input = {}) {
       const ahead = secondsAhead(earliest(before, trackEnd), at);
       constrain(completion.at - ahead, "delivery", trackIndex, completion.segment.index, completion.at, ahead, false,
         completion.sourceArrivalAt, completion.sourcePlanned);
-      if (compare(after, before) <= 0 && completion.segment.ranges.some(({ start }) => compare(start, before) > 0)) {
+      const beyond = completion.segment.ranges.filter(({ start }) => compare(start, before) > 0);
+      if (compare(after, before) <= 0 && beyond.length > 0) {
         // A timestamp hole cannot be repaired by waiting longer. Keep it
         // distinct from an unavailable rate or a slow but finite service.
-        return result(false, null, buffered, reserve, null, 'media-continuity-unavailable', preparedSegments);
+        // Said with the track and both edges: the refusals of
+        // torrent-tv/meta#105 could not be told apart afterwards.
+        return { ...result(false, null, buffered, reserve, null, 'media-continuity-unavailable', preparedSegments),
+          discontinuity: { trackId: state.track.id ?? trackIndex, segmentIndex: completion.segment.index,
+            contiguousEndSeconds: toSeconds(before),
+            rangeStartSeconds: toSeconds(earliest(...beyond.map(({ start }) => start))) } };
       }
     }
     if (compare(after, trackEnd) < 0) {
       // Everything this track still needs has been delivered in the schedule
       // and its media still stops short of the end: a hole between ranges
       // already held, which no arrival crosses.
-      return result(false, null, buffered, reserve, null, 'media-continuity-unavailable', preparedSegments);
+      const next = delivered.find(({ start }) => compare(start, after) > 0);
+      return { ...result(false, null, buffered, reserve, null, 'media-continuity-unavailable', preparedSegments),
+        discontinuity: { trackId: state.track.id ?? trackIndex, segmentIndex: null,
+          contiguousEndSeconds: toSeconds(after), rangeStartSeconds: next ? toSeconds(next.start) : null,
+          trackEndSeconds: toSeconds(trackEnd) } };
     }
     for (const production of productions.filter((item) => item.trackIndex === trackIndex)) {
       const before = contiguousEnd(prepared, at);