@torrent-tv/proxy 2.105.12 → 2.106.0

package/package.json

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

package/routes/api/playback-plan/post.js

@@ -24,7 +24,7 @@ function getPayload(body) {
   return {};
 }
 
-export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers }) {
+export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, sourceRegistry, torrentPool, ffmpegBin, localBaseUrl, viewers, observeWait }) {
   const payload = getPayload(req.body);
   const sourceKey = typeof payload.sourceKey === "string" ? payload.sourceKey.trim() : "";
   const fileIndex = Number(payload.fileIndex);
@@ -38,10 +38,13 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, s
   if (typeof payload.positionSeconds === "number" && Number.isFinite(payload.positionSeconds) && payload.positionSeconds >= 0) selection.positionSeconds = payload.positionSeconds;
   if (typeof payload.wantsToPlay === "boolean") selection.wantsToPlay = payload.wantsToPlay;
   if (consumerId) viewers?.selectsFile(consumerId, sourceKey, fileIndex, Date.now(), selection);
+  const startedAt = performance.now();
 
   // Interface delegates to PlaybackController (orchestrator + domain). Keeps route thin.
   const { PlaybackController } = await import("../../../services/server/controllers/PlaybackController.js");
   const controller = new PlaybackController({ torrentPool, sourceRegistry, ffmpegBin, localBaseUrl, playbackPlanner });
+  const waitFields = { process: "P3", sourceKey, fileIndex };
+  observeWait?.(sourceKey, "process", { ...waitFields, phase: "begin", at: startedAt });
   const cancellation = new AbortController();
   const aborted = () => cancellation.abort();
   const closed = () => { if (!reply.raw?.writableEnded) aborted(); };
@@ -52,8 +55,14 @@ export async function handleApiPlaybackPlanPost(req, reply, { playbackPlanner, s
     const params = { sourceKey, fileIndex, userAgent };
     const plan = payload.waitForReady === true
       ? await controller.getReadyPlan(params, { signal: cancellation.signal }) : await controller.getPlan(params);
+    const endedAt = performance.now();
+    observeWait?.(sourceKey, "process", { ...waitFields, phase: "end", at: endedAt, startedAt,
+      endedAt, durationMs: endedAt - startedAt, outcome: "plan-ready" });
     return reply.send(plan);
   } catch (error) {
+    const endedAt = performance.now();
+    observeWait?.(sourceKey, "process", { ...waitFields, phase: "end", at: endedAt, startedAt,
+      endedAt, durationMs: endedAt - startedAt, outcome: cancellation.signal.aborted ? "cancelled" : "error" });
     if (cancellation.signal.aborted) return;
     if (error instanceof Error && error.code === "SOURCE_NOT_FOUND") {
       return reply.code(404).send({ error: error.message });

package/server.js

@@ -1614,7 +1614,8 @@ export async function startProxyServer({
     handleApiClientLogsPost(req, reply, { clientLogs, viewerRequests: outputParts.viewerRequests })
   );
   app.post("/api/playback-plan", async (req, reply) =>
-    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers })
+    handleApiPlaybackPlanPost(req, reply, { playbackPlanner, viewers: outputParts.viewers,
+      observeWait: (sourceKey, event, fields) => waitTrace.source(sourceKey, event, fields) })
   );
   app.post("/api/playback-plan/audio-tracks", async (req, reply) =>
     handleApiPlaybackPlanAudioTracksPost(req, reply, { playbackPlanner })

package/services/encode/EncodeRuns.js

@@ -1234,7 +1234,21 @@ export class EncodeRuns {
         if (mediaRanges === false && tentative) return null;
         if (mediaRanges === false) throw Object.assign(new Error(`Closed piece #${index} has incomplete media.`),
           { code: "ERR_INCOMPLETE_MEDIA" });
-        const published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
+        const publishStartedAt = performance.now();
+        const publishProcess = session.spec?.carries === "audio-only" ? "P11.a" : "P11.v";
+        this.#host.observeWait?.(session.file.sourceKey, "process", { process: publishProcess, phase: "begin",
+          output: address, segment: index, at: publishStartedAt });
+        let published;
+        let publishOutcome = "error";
+        try {
+          published = this.#host.segmentFiles.publish(address, name, session.segmentFormat, { mediaRanges, bytes });
+          publishOutcome = published ? "published" : "not-published";
+        } finally {
+          const publishEndedAt = performance.now();
+          this.#host.observeWait?.(session.file.sourceKey, "process", { process: publishProcess, phase: "end",
+            output: address, segment: index, at: publishEndedAt, startedAt: publishStartedAt, endedAt: publishEndedAt,
+            durationMs: publishEndedAt - publishStartedAt, outcome: publishOutcome });
+        }
         if (!published) throw new Error(`Closed piece #${index} could not be stored.`);
         if (index === safeIndex) this.#host.observeWait?.(session.file.sourceKey, "first-piece-published", {
           output: address, segment: index, startedAt: observedStart, endedAt: performance.now(),

package/services/server/ViewerRequests.js

@@ -865,6 +865,11 @@ export class ViewerRequests {
   }
 
   async #playbackReadinessFor(session, consumerId, progress, outputMbps) {
+    const waitStartedAt = performance.now();
+    const waitFields = { process: "P14", sessionId: session.id, consumerId };
+    this.#host.observeWait?.(session.file.sourceKey, "process", { ...waitFields, phase: "begin", at: waitStartedAt });
+    let waitOutcome = "error";
+    try {
     const now = Date.now();
     // WHERE AN ANSWER'S TIME GOES, said with each answer. On Home Assistant a
     // held viewer's answer took 11.2 s while its forecast took 0.1-0.4 s and
@@ -1116,7 +1121,14 @@ export class ViewerRequests {
     this.#host.noteViewerWaiting?.(consumerId || session.id,
       holding?.kind === "production" ? { address: holding.track, index: holding.segment } : null);
     delete forecast.firstRequiredStages;
+    waitOutcome = "forecast-ready";
     return forecast;
+    } finally {
+      const waitEndedAt = performance.now();
+      this.#host.observeWait?.(session.file.sourceKey, "process", { ...waitFields, phase: "end", at: waitEndedAt,
+        startedAt: waitStartedAt, endedAt: waitEndedAt, durationMs: waitEndedAt - waitStartedAt,
+        outcome: waitOutcome });
+    }
   }
 
   /**

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/utils/wait-trace.js

@@ -53,8 +53,9 @@ export class SourceWaitTrace {
         !Number.isSafeInteger(attempt) || attempt < 0) return;
       const context = { wait, attempt, operation, startedAt: this.now() };
       this.requests.set(req, context);
-      const process = typeof statedProcess === "string" && /^[A-Z][0-9]+(?:\.(?:[0-9]+[a-z]?|[va]))?$/.test(statedProcess)
-        ? statedProcess : processForRequest(req.url);
+      const endpointProcess = processForRequest(req.url);
+      const process = endpointProcess ?? (typeof statedProcess === "string" &&
+        /^[A-Z][0-9]+(?:\.(?:[0-9]+[a-z]?|[va]))?$/.test(statedProcess) ? statedProcess : null);
       this.write(context, "http-start", { process, phase: "begin", method: req.method, path: req.url,
         requestId: req.headers["x-ttv-forwarded-request-id"] ?? req.id });
       let finished = false;
@@ -92,11 +93,11 @@ export class SourceWaitTrace {
 }
 
 function processForRequest(path) {
+  if (/^\/api\/transcode-sessions\/[^/?]+\/progress(?:\?|$)/.test(path)) return "P14";
   if (path.startsWith("/api/transcode-sessions")) return "P6.v";
   if (path.startsWith("/api/playback-plan")) return "P3";
   if (/\/transcode\/.*\.m3u8(?:\?|$)/.test(path)) return "P12";
   if (/\/transcode\/.*(?:init|\.mp4)(?:\?|$)/.test(path)) return "P12";
   if (/\/transcode\/.*(?:\.m4s|\.ts)(?:\?|$)/.test(path)) return "P12";
-  if (path.startsWith("/api/session-progress")) return "P14";
   return null;
 }