@torrent-tv/proxy 2.46.0 → 2.48.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 2.48.0
+
+- **Fix**: A copied picture now begins where it was asked to, so its cuts land on the times its playlist names. ffmpeg's own CLI moves an input seek back by `3*AV_TIME_BASE / 23` — **130.435 ms** — whenever the container does not declare `AVFMT_SEEK_TO_PTS` (Matroska does not) and a stream carries B-frames, which is sound in itself: such containers seek in decode order while the caller asks in presentation order. The consequence for a copy is that asking for a keyframe lands on the one BEFORE it, deterministically; and since `-segment_times` is measured from where the run really began while this code computed those offsets from the time it asked for, every cut of the run inherited one whole keyframe interval. Field 2026-08-20: 119 of 125 segments arriving a uniform 2.002 s early against the 0.5 s hls.js bridges, so every fragment was refused and re-fetched — on 2026-08-17 two of them 1908 times each. The request is now made that much later, bounded by half the distance to the next keyframe. Measured 2026-08-21 on Matroska with keyframes every 2 s: `-ss 10` produced a first segment starting at 8.000, `-ss 10.130435` one starting at 10.000; on MP4, where the heuristic does not fire, 10, 10.130435 and 10.2 all produced 10.000 — right in one case and harmless in the other. Not applied when the picture is re-encoded: a re-encode discards frames up to the requested time and already begins exactly there (`-ss 11` copied starts at 10.000, re-encoded at 11.000).
+- **New**: A run that did not begin where it was asked to says so. The first piece a run produces is the only statement of its real origin that exists, and nothing compared the two — which is why the fault above stayed silent through two releases that touched the same grid. Said once per run, and only past what a player bridges.
+- **Chore**: The tunnel-renewal test shuts its stand-in registry down deterministically. `WebSocketServer.close` waits for every connection to end and a renewal can leave one still closing, so a full suite run could hang for nine minutes on it.
+
+## 2.47.0
+
+- **Fix**: The tunnel is replaced before anything upstream ends it, so a viewer no longer arrives to find no proxy. Something between the proxy and the server closes the socket after exactly **100 min 15 s** — measured across a day of logs 2026-08-20, three intervals of 100:15 wherever a restart did not reset the clock, `code=1006` each time, and with the 30 s keepalive running throughout, so it is a lifetime cap and not an idle timeout. Reconnecting afterwards takes five seconds during which this proxy does not exist as far as the registry is concerned. The connection is now replaced at ninety minutes and the replacement takes over FIRST: the new socket registers itself, the server atomically supersedes the old one, and only then does the old one close — so there is no instant with nothing registered. A socket that finds itself superseded says so rather than reporting the tunnel as down, and an abrupt close nobody asked for still reconnects as before. Pinned by a test against a real WebSocket server.
+
 ## 2.46.0
 
 - **New**: The cost of DECODING is measured per codec family, not once on H.264. A video that has to be re-encoded is by definition one the browser could not play — HEVC, 10-bit — so the one model the host had was fitted on the codec it is least often asked about, and those decode dearer per pixel on the same box. There are now sets for HEVC 8-bit and HEVC Main 10 beside the H.264 one (`assets/calibration/`, four clips each: two sizes at two bitrates, the smallest grid that keeps the axes independent and still leaves a spare), the source's own codec and bit depth choose the constants, and a family with no set of its own is priced as H.264 — said in the log rather than left to be inferred. Measured on a desktop 2026-08-20, the same 1080p picture at ~5.8 Mbit/s: 7.7x as 8-bit HEVC against 6.3x as 10-bit, which is why ten bits is its own family and not a multiplier. AV1 has no set yet; the release survey of 2026-07-10 found it rare where HEVC was 18 %.

package/package.json

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

package/services/hls-session-manager.js

@@ -568,6 +568,36 @@ const SEGMENT_READ_HIGH_WATER_MARK = 4 * 1024 * 1024;
 // second is below any drift a viewer could notice, so anything above it is the
 // index being wrong about where a keyframe is rather than rounding.
 const SEGMENT_START_DISAGREEMENT_SEC = 0.25;
+/**
+ * What ffmpeg's own CLI subtracts from an input seek, and therefore what has to
+ * be added back to land where we asked.
+ *
+ * `fftools/ffmpeg_demux.c`, in `ifile_open`: when the container does not
+ * declare `AVFMT_SEEK_TO_PTS` — Matroska does not — and any stream carries
+ * B-frames, the seek target is moved back by `3*AV_TIME_BASE / 23` before
+ * `avformat_seek_file` is called. Its purpose is sound: such containers seek in
+ * decode order while the caller asks in presentation order, and with B-frames
+ * the two differ, so it backs off far enough to be sure of reaching the frame
+ * asked for.
+ *
+ * The consequence for a COPY is that asking for a keyframe lands on the one
+ * BEFORE it — deterministically, every time. Measured 2026-08-21 on a Matroska
+ * file with keyframes every 2 s: `-ss 10` produced a first segment starting at
+ * 8.000; `-ss 10.130435` produced one starting at 10.000. On MP4, where the
+ * heuristic does not fire, all of 10, 10.130435 and 10.2 produced 10.000 — so
+ * adding this is right in one case and harmless in the other.
+ *
+ * That landing is what `-segment_times` is measured from, while this code
+ * computes those offsets from the time it ASKED for. One keyframe interval
+ * apart, inherited by every cut of the run: 119 of 125 segments arriving a
+ * uniform 2.002 s early in the field, four times what a player bridges.
+ *
+ * Not applied when the picture is re-encoded: a re-encode decodes from the
+ * keyframe and discards frames up to the requested time, so its output already
+ * begins exactly where asked (measured the same day: `-ss 11` copied starts at
+ * 10.000, re-encoded at 11.000).
+ */
+const SEEK_LANDING_OFFSET_SEC = 3 / 23;
 
 /**
  * How far a fragment may land from where the playlist put it before the player
@@ -1146,6 +1176,34 @@ export function segmentCutTimesFrom(boundaries, startIndex) {
   return times;
 }
 
+/**
+ * How much later than a keyframe to ASK, so that ffmpeg lands on that keyframe.
+ *
+ * Bounded by half the distance to the next keyframe, which matters only where
+ * keyframes stand closer together than twice the offset. There no single value
+ * can satisfy both worlds — asking too little lands a keyframe early when the
+ * heuristic fires, asking too much lands a keyframe late when it does not — and
+ * the bound picks the smaller error, which is then under one keyframe interval
+ * and therefore under what a player bridges.
+ *
+ * @param {HlsSession} session
+ * @param {number} keyframe - A real keyframe time the run is to begin at.
+ * @returns {number} Seconds to add to the request.
+ */
+export function seekLandingOffsetFor(session, keyframe) {
+  // A re-encode trims to the requested time itself, so it needs no help and
+  // must not be pushed past what it was asked for.
+  if (session?.transcodeVideo === true) {
+    return 0;
+  }
+  const times = Array.isArray(session?.keyframeTimes) ? session.keyframeTimes : [];
+  const next = times.find((time) => time > keyframe + 0.001);
+  if (next === undefined) {
+    return SEEK_LANDING_OFFSET_SEC;
+  }
+  return Math.min(SEEK_LANDING_OFFSET_SEC, (next - keyframe) / 2);
+}
+
 /**
  * The largest keyframe time that does not exceed `target`, from a SORTED
  * (ascending) array of keyframe times such as {@link probeVideoKeyframeTimes}
@@ -3932,7 +3990,7 @@ export class HlsSessionManager {
     if (snappedKeyframe !== null) {
       const residualSeconds = Math.max(0, seekSeconds - snappedKeyframe);
       if (snappedKeyframe > 0) {
-        args.push("-ss", ffmpegSeconds(snappedKeyframe));
+        args.push("-ss", ffmpegSeconds(snappedKeyframe + seekLandingOffsetFor(session, snappedKeyframe)));
       }
       args.push("-i", session.inputUrl);
       if (residualSeconds > 0) {
@@ -5124,6 +5182,41 @@ export class HlsSessionManager {
    * @param {number} declaredStart - Seconds, from the playlist.
    * @returns {void}
    */
+  /**
+   * Where the run REALLY began, against where it was asked to begin.
+   *
+   * The first piece a run produces is the only statement of this that exists,
+   * and until now nothing compared the two. They disagree whenever the seek
+   * lands somewhere other than the time asked for — which, before the landing
+   * offset, was every run on a Matroska source with B-frames, by exactly one
+   * keyframe interval. Every cut of the run then inherits it, because
+   * `-segment_times` is measured from the landing.
+   *
+   * Said once per run, and only when it matters: within what a player bridges
+   * there is nothing to report.
+   *
+   * @param {HlsSession} session
+   * @param {number} index
+   * @param {number} trueStart
+   * @returns {void}
+   */
+  #noteRunLanding(session, index, trueStart) {
+    if (session.encodeStartIndex !== index || session.landingReportedForRun === index) {
+      return;
+    }
+    session.landingReportedForRun = index;
+    const asked = this.#segmentStartTime(session, index);
+    const drift = trueStart - asked;
+    if (!Number.isFinite(drift) || Math.abs(drift) <= PLAYER_BUFFER_HOLE_SEC) {
+      return;
+    }
+    logger.warn(
+      `transcode ${session.id} run began at ${trueStart.toFixed(3)}s but was asked for ` +
+      `${asked.toFixed(3)}s — ${drift > 0 ? "+" : ""}${drift.toFixed(3)}s, and every cut of this ` +
+      "run is measured from where it began, so the whole run is that far from its playlist"
+    );
+  }
+
   #noteIndexAccuracy(session, index, trueStart, declaredStart) {
     const deviation = Math.abs(trueStart - declaredStart);
     session.indexCheck ??= newIndexCheck();
@@ -7719,6 +7812,7 @@ export class HlsSessionManager {
           : null;
         const declaredStart = this.#segmentStartTime(session, index);
         if (trueStart !== null) {
+          this.#noteRunLanding(session, index, trueStart);
           this.#noteIndexAccuracy(session, index, trueStart, declaredStart);
         }
         // WHERE THE PLAYER WAS TOLD THIS SEGMENT BEGINS, which is the playlist

package/services/tunnel-client.js

@@ -80,6 +80,28 @@ import { WebSocket } from "ws";
 const RECONNECT_DELAY_MS = 5_000;
 /** Send a keepalive ping every 30 s to prevent Cloudflare's idle WebSocket timeout (~100 s). */
 const KEEPALIVE_INTERVAL_MS = 30_000;
+/**
+ * Replace the connection before anything upstream ends it for us.
+ *
+ * Something between this process and the server closes the socket after
+ * exactly **100 min 15 s**, whatever is flowing over it. It is not an idle
+ * timeout — the keepalive above has been running for months — it is a lifetime
+ * cap. Measured across one day of logs (2026-08-20): 01:54:12 → 03:34:27 →
+ * ... the same 100:15 apart wherever a restart did not reset the clock, and
+ * with `code=1006`, an abrupt close with no closing handshake, which is what an
+ * intermediary killing a connection looks like.
+ *
+ * Reconnecting after the fact costs 5 s during which this proxy does not exist
+ * as far as the registry is concerned, and a viewer arriving in that window is
+ * told there is no proxy. So the connection is replaced BEFORE the cap, and the
+ * replacement is seamless: the new socket registers itself with the server,
+ * which atomically supersedes the old one, and only then does the old one
+ * close. There is no moment with nothing registered.
+ *
+ * Ninety minutes leaves ten minutes of margin against a cap that has been
+ * exact, and makes the replacement a quiet event rather than a race.
+ */
+const CONNECTION_LIFETIME_MS = 90 * 60_000;
 
 /**
  * Create and manage the outbound WebSocket tunnel to the registry server.
@@ -87,15 +109,30 @@ const KEEPALIVE_INTERVAL_MS = 30_000;
  * @param {TunnelClientOptions} options
  * @returns {TunnelClient}
  */
-export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSignal, onConnect, onHealthRequest, onLog }) {
+export function createTunnelClient({
+  serverUrl,
+  proxyId,
+  token,
+  proxyPort,
+  onSignal,
+  onConnect,
+  onHealthRequest,
+  onLog,
+  connectionLifetimeMs = CONNECTION_LIFETIME_MS
+}) {
   const wsUrl = serverUrl.replace(/^http/, "ws").replace(/\/+$/, "") + "/ws/proxy-tunnel";
 
   /** @type {WebSocket | null} */
   let socket = null;
   /** @type {ReturnType<typeof setTimeout> | null} */
   let reconnectTimer = null;
-  /** @type {ReturnType<typeof setInterval> | null} */
-  let keepaliveTimer = null;
+  /**
+   * The renewal that will replace the live connection before the upstream cap
+   * ends it. Owned by the connection it belongs to, and cancelled with it.
+   *
+   * @type {ReturnType<typeof setTimeout> | null}
+   */
+  let renewalTimer = null;
   let stopped = false;
 
   /**
@@ -122,28 +159,46 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
     }
     log(`Connecting tunnel to ${wsUrl}`);
 
-    socket = new WebSocket(wsUrl, {
+    // The connection being opened, held separately from `socket` so that a
+    // socket which has been SUPERSEDED can still recognise itself. During a
+    // renewal two exist for a moment, and the old one's close must not be
+    // mistaken for the tunnel going down.
+    const connection = new WebSocket(wsUrl, {
       headers: {
         "x-proxy-id": proxyId,
         "x-proxy-token": token,
         "user-agent": "torrent-tv-proxy/1.0"
       }
     });
+    /** @type {ReturnType<typeof setInterval> | null} */
+    let keepaliveTimer = null;
+    socket = connection;
 
-    socket.addEventListener("open", () => {
+    connection.addEventListener("open", () => {
       log("Tunnel connected.");
       // Start keepalive pings to prevent Cloudflare's idle WebSocket timeout.
       keepaliveTimer = setInterval(() => {
-        if (socket && socket.readyState === WebSocket.OPEN) {
-          send({ type: "ping" });
+        if (connection.readyState === WebSocket.OPEN) {
+          send({ type: "ping" }, connection);
         }
       }, KEEPALIVE_INTERVAL_MS);
+      // And replace this connection before the upstream lifetime cap does.
+      if (renewalTimer !== null) {
+        clearTimeout(renewalTimer);
+      }
+      renewalTimer = setTimeout(() => {
+        if (stopped || socket !== connection) {
+          return;
+        }
+        log("Tunnel renewing before the upstream lifetime cap; the replacement takes over first.");
+        connect();
+      }, connectionLifetimeMs);
       if (typeof onConnect === "function") {
         onConnect();
       }
     });
 
-    socket.addEventListener("message", (event) => {
+    connection.addEventListener("message", (event) => {
       let message;
       try {
         message = JSON.parse(event.data);
@@ -174,19 +229,31 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
       }
     });
 
-    socket.addEventListener("close", (event) => {
-      log(`Tunnel disconnected (code=${event.code}). Reconnecting in ${RECONNECT_DELAY_MS}ms...`);
-      socket = null;
+    connection.addEventListener("close", (event) => {
       if (keepaliveTimer !== null) {
         clearInterval(keepaliveTimer);
         keepaliveTimer = null;
       }
+      // A connection this one replaced. The server closes it as soon as the
+      // replacement registers, which is the whole point of renewing early —
+      // there is nothing to report and nothing to reconnect, because the tunnel
+      // never went down.
+      if (socket !== connection) {
+        log(`Tunnel handed over (code=${event.code}); the replacement is already carrying it.`);
+        return;
+      }
+      log(`Tunnel disconnected (code=${event.code}). Reconnecting in ${RECONNECT_DELAY_MS}ms...`);
+      socket = null;
+      if (renewalTimer !== null) {
+        clearTimeout(renewalTimer);
+        renewalTimer = null;
+      }
       if (!stopped) {
         reconnectTimer = setTimeout(connect, RECONNECT_DELAY_MS);
       }
     });
 
-    socket.addEventListener("error", (event) => {
+    connection.addEventListener("error", (event) => {
       log(`Tunnel WebSocket error: ${event.message ?? "unknown"}`);
     });
   }
@@ -255,9 +322,14 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
    * @param {object} message
    * @returns {void}
    */
-  function send(message) {
-    if (socket && socket.readyState === WebSocket.OPEN) {
-      socket.send(JSON.stringify(message));
+  function send(message, over = null) {
+    // Everything the proxy has to say goes over the LIVE connection. `over` is
+    // for the one thing that belongs to a particular socket rather than to the
+    // tunnel — its own keepalive — which must not be sent over a replacement
+    // that has already taken over.
+    const target = over ?? socket;
+    if (target && target.readyState === WebSocket.OPEN) {
+      target.send(JSON.stringify(message));
     }
   }
 
@@ -291,9 +363,9 @@ export function createTunnelClient({ serverUrl, proxyId, token, proxyPort, onSig
      */
     disconnect() {
       stopped = true;
-      if (keepaliveTimer !== null) {
-        clearInterval(keepaliveTimer);
-        keepaliveTimer = null;
+      if (renewalTimer !== null) {
+        clearTimeout(renewalTimer);
+        renewalTimer = null;
       }
       if (reconnectTimer != null) {
         clearTimeout(reconnectTimer);

package/test/seek-landing.test.js

@@ -0,0 +1,50 @@
+/**
+ * @file Ask ffmpeg late enough that it lands where we meant.
+ *
+ * `fftools/ffmpeg_demux.c` moves an input seek back by `3*AV_TIME_BASE / 23` —
+ * 130.435 ms — whenever the container does not declare `AVFMT_SEEK_TO_PTS` and
+ * a stream carries B-frames. So asking for a keyframe lands on the one before
+ * it, and since `-segment_times` is measured from where the run really began,
+ * every cut of that run inherits the shift.
+ *
+ * Measured 2026-08-21 on Matroska with keyframes every 2 s: `-ss 10` produced a
+ * first segment starting at 8.000, `-ss 10.130435` one starting at 10.000. On
+ * MP4, where the heuristic does not fire, 10, 10.130435 and 10.2 all produced
+ * 10.000 — right in one case, harmless in the other.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { seekLandingOffsetFor } from "../services/hls-session-manager.js";
+
+const OFFSET = 3 / 23;
+
+test("a copied picture is asked for one heuristic later than the keyframe", () => {
+  const session = { transcodeVideo: false, keyframeTimes: [0, 2.002, 4.004, 6.006] };
+  assert.equal(seekLandingOffsetFor(session, 2.002), OFFSET);
+});
+
+test("a re-encode is asked for exactly what it should produce", () => {
+  // It decodes from the keyframe and discards frames up to the requested time,
+  // so pushing the request later would start its output late.
+  const session = { transcodeVideo: true, keyframeTimes: [0, 2.002, 4.004] };
+  assert.equal(seekLandingOffsetFor(session, 2.002), 0);
+});
+
+test("the offset never reaches the next keyframe", () => {
+  // Keyframes 0.1 s apart: half of that is the most that can be added without
+  // risking a landing on the NEXT one where the heuristic does not fire.
+  const session = { transcodeVideo: false, keyframeTimes: [0, 0.1, 0.2, 0.3] };
+  assert.equal(seekLandingOffsetFor(session, 0.1), 0.05);
+});
+
+test("the last keyframe has nothing after it to collide with", () => {
+  const session = { transcodeVideo: false, keyframeTimes: [0, 2.002, 4.004] };
+  assert.equal(seekLandingOffsetFor(session, 4.004), OFFSET);
+});
+
+test("no keyframe list is still answered", () => {
+  assert.equal(seekLandingOffsetFor({ transcodeVideo: false }, 5), OFFSET);
+  assert.equal(seekLandingOffsetFor(null, 5), OFFSET);
+});

package/test/tunnel-renewal.test.js

@@ -0,0 +1,138 @@
+/**
+ * @file The tunnel is replaced before anything upstream ends it, and the
+ * replacement takes over first.
+ *
+ * Something between the proxy and the server closes the socket after exactly
+ * 100 min 15 s whatever is flowing over it — measured across a day of logs on
+ * 2026-08-20, `code=1006` each time, with a 30 s keepalive running throughout,
+ * so it is a lifetime cap and not an idle timeout. Reconnecting afterwards
+ * costs five seconds in which the proxy does not exist as far as the registry
+ * is concerned, and a viewer arriving then is told there is no proxy.
+ *
+ * What is pinned here is the property that removes that window: at no instant
+ * is the server without a registered connection for this proxy.
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { WebSocketServer } from "ws";
+
+import { createTunnelClient } from "../services/tunnel-client.js";
+
+/**
+ * A stand-in for the registry's tunnel endpoint, with the one behaviour that
+ * matters here: a new connection for a proxy REPLACES the previous one, which
+ * is what `registerConnection` does in `server/services/proxy-tunnel-server.js`.
+ *
+ * @returns {Promise<{ url: string, close: () => Promise<void>, registered: () => number, opened: () => number, everEmpty: () => boolean }>}
+ */
+async function startRegistry() {
+  const server = new WebSocketServer({ port: 0 });
+  await new Promise((resolve) => { server.on("listening", resolve); });
+  /** @type {import("ws").WebSocket | null} */
+  let current = null;
+  let opened = 0;
+  let everEmpty = false;
+  /** Every socket ever accepted, so the server can be shut without waiting. */
+  const accepted = new Set();
+  server.on("connection", (socket) => {
+    opened += 1;
+    accepted.add(socket);
+    socket.on("close", () => { accepted.delete(socket); });
+    const previous = current;
+    current = socket;
+    // The replacement is registered BEFORE the old one is closed, so a reader
+    // of `current` never sees nothing.
+    if (previous && previous.readyState < 2) {
+      previous.close(1000, "replaced");
+    }
+    socket.on("close", () => {
+      if (current === socket) {
+        current = null;
+        everEmpty = true;
+      }
+    });
+  });
+  const { port } = server.address();
+  return {
+    url: `http://127.0.0.1:${port}`,
+    // `close` waits for every connection to end, and a renewal can leave one
+    // still closing, so they are ended here rather than waited on.
+    close: () => new Promise((resolve) => {
+      for (const socket of accepted) {
+        socket.terminate();
+      }
+      accepted.clear();
+      server.close(() => resolve());
+    }),
+    registered: () => (current && current.readyState === 1 ? 1 : 0),
+    killCurrent: () => { current?.terminate(); },
+    opened: () => opened,
+    everEmpty: () => everEmpty
+  };
+}
+
+test("the connection is replaced before its lifetime runs out, without a gap", async (t) => {
+  const registry = await startRegistry();
+  /** @type {string[]} */
+  const lines = [];
+  const client = createTunnelClient({
+    serverUrl: registry.url,
+    proxyId: "p1",
+    token: "t",
+    proxyPort: 9090,
+    onLog: (line) => lines.push(line),
+    // The real cap is 100 min 15 s and the real renewal is at 90 min; the
+    // ratio is what matters, not the magnitude.
+    connectionLifetimeMs: 150
+  });
+  t.after(async () => {
+    client.disconnect();
+    await registry.close();
+  });
+
+  client.connect();
+  // Long enough for several renewals at 150 ms each.
+  await new Promise((resolve) => { setTimeout(resolve, 700); });
+
+  assert.ok(registry.opened() >= 3, `expected several renewals, saw ${registry.opened()}`);
+  // The property this exists for: the registry was never left with nothing.
+  assert.equal(registry.everEmpty(), false, "the registry lost its connection at some point");
+  assert.equal(registry.registered(), 1);
+  // And the proxy knows the difference between a handover and going down. A
+  // "Reconnecting in" line here would mean it had treated its own renewal as a
+  // failure and waited five seconds before coming back.
+  assert.ok(lines.some((line) => line.includes("Tunnel renewing")), lines.join("\n"));
+  assert.ok(lines.some((line) => line.includes("Tunnel handed over")), lines.join("\n"));
+  assert.equal(lines.filter((line) => line.includes("Reconnecting in")).length, 0, lines.join("\n"));
+});
+
+test("a connection killed from outside is still reconnected", async (t) => {
+  const registry = await startRegistry();
+  /** @type {string[]} */
+  const lines = [];
+  const client = createTunnelClient({
+    serverUrl: registry.url,
+    proxyId: "p2",
+    token: "t",
+    proxyPort: 9090,
+    onLog: (line) => lines.push(line),
+    // Far longer than this test runs, so nothing renews and the only close is
+    // the one forced below — which is what the upstream cap looks like from
+    // here: an abrupt end nobody asked for.
+    connectionLifetimeMs: 60_000
+  });
+  t.after(async () => {
+    client.disconnect();
+    await registry.close();
+  });
+
+  client.connect();
+  await new Promise((resolve) => { setTimeout(resolve, 200); });
+  assert.equal(registry.opened(), 1);
+
+  registry.killCurrent();
+  await new Promise((resolve) => { setTimeout(resolve, 300); });
+  // The renewal must not have taken the ordinary reconnect away with it.
+  assert.ok(lines.some((line) => line.includes("Reconnecting in")), lines.join("\n"));
+});