@hisoka-io/anon-rpc-worker 0.4.0 → 0.4.1

package/dist/anon-rpc-worker.js.keccak256

@@ -1 +1 @@
-0xd8bef626ec8511d7a468bca5137880680ca2da20d2ea4d9c981a2a3d0c86ba1e  anon-rpc-worker.js
+0xd9fa04b080a33062680a27cad828196bfb04615a0ebc76bcbffedb6dcbe838d4  anon-rpc-worker.js

package/dist/anon-rpc-worker.provenance.json

@@ -3,7 +3,7 @@
     "arch": "x64",
     "os": "linux"
   },
-  "gitCommit": "fee8d69861a112c65f0cbb0b848a7726ec12f01a",
+  "gitCommit": "66bce4af274b4be457ef11336ba9cb6d9200efd1",
   "gitTreeClean": true,
   "inputs": {
     "bootstrapKeccak": "0x6567e3ad5e1b1ac81529391c890d2652695d3ec139d56625170384794085fb74",
@@ -12,13 +12,13 @@
     "snapshotKeccak": "0x1090f071896b6ef41ddfd40d4ebcd20fae85a66468f82497e19a635488014681",
     "tlsWasmKeccak": "0x60b29cd4fca7ee2f31fbcff2dca25e64939e4b71a4629ffcfea1b89546f501ce",
     "tlsWasmSha256": "f74e8cfbed7be33ef1a9158b7b66e454b4ca0849bcb8956487fd13da47e4f4d2",
-    "wasmKeccak": "0x6ff418a78fc022d34dff00a867e173269413fb6887c9d6bf8e6505d4dcfffe2d",
-    "wasmSha256": "5171416972ea4499fd4b4ea8bcadf002f4c10f10ed42cafb0d5a426121da9c4f"
+    "wasmKeccak": "0x91060e59264ba44c3f16181caff1adcf16193a1e57d6ba4dd3531b192ac42de4",
+    "wasmSha256": "6db306a34ef50e9198f4ad6f31c6ffd9feafe459c24b8a29895824c7138241c8"
   },
   "output": {
-    "bytes": 1820668,
-    "keccak256": "0xd8bef626ec8511d7a468bca5137880680ca2da20d2ea4d9c981a2a3d0c86ba1e",
-    "sha256": "4b7b69cd6f45c364cd87ff75f5f8cacdebea2cd852d5384c47215bb88d56f35a"
+    "bytes": 1831246,
+    "keccak256": "0xd9fa04b080a33062680a27cad828196bfb04615a0ebc76bcbffedb6dcbe838d4",
+    "sha256": "9544fb10390eb135d4f6b9a32de674ea859e4977514afed4772cb4642d62ed19"
   },
   "package": "@hisoka-io/anon-rpc-worker",
   "tls": {
@@ -55,5 +55,5 @@
     "wasmPack": "0.13.1",
     "wasmPinsChecked": true
   },
-  "version": "0.4.0"
+  "version": "0.4.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hisoka-io/anon-rpc-worker",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Nox mixnet worker for the anon-rpc standard, built as one reproducible classic-script bundle with a pinned NoxRegistry snapshot",
   "license": "Apache-2.0",
   "repository": {
@@ -25,8 +25,8 @@
     "ethers": "6.16.0",
     "typescript": "5.9.3",
     "vitest": "1.6.1",
-    "@hisoka-io/nox-client": "0.8.0",
-    "@hisoka-io/nox-wasm": "0.2.0"
+    "@hisoka-io/nox-client": "0.9.0",
+    "@hisoka-io/nox-wasm": "0.3.0"
   },
   "publishConfig": {
     "access": "public"

package/src/config.ts

@@ -111,8 +111,12 @@ export const CONFIG_DEFAULTS: NoxWorkerConfig = Object.freeze({
   // Founder decisions D1/D2 (E2E TLS design §8): the most private settings until decided.
   tls: "required",
   tlsSession: "per-call",
-  tlsSpares: 1,
-  tlsSpareTtlMs: 20_000,
+  // Spare policy measured from India on 2026-10-15: the upstream RPC hosts close an idle TLS connection 15.0 s
+  // after the handshake, and spares used 14.2 s or more after their handshake had been closed (one wasted exchange,
+  // then a retry on a new session). A 12 s TTL kept every spare live (0 retries in 70 calls); a second spare per
+  // host raised spare use at a 1 s gap from 16/30 to 23/30 calls.
+  tlsSpares: 2,
+  tlsSpareTtlMs: 12_000,
   tlsKeepAliveMs: 30_000,
   tlsMaxCallsPerSession: 100,
   tlsOpenTimeoutMs: 5_000,

package/src/tls/pool.ts

@@ -12,8 +12,17 @@
  * - Per-call spares: after a call to a host (once the first wallet call has
  *   settled), a replacement spare opens on a random exit after an
  *   exponential delay with mean `SPARE_DELAY_MEAN_MS`, up to `tlsSpares` per
- *   host. A spare serves one call; unused, it is torn down after
- *   `tlsSpareTtlMs` and not replaced. Hosts live in memory only.
+ *   host. A spare serves one call; unused, it is torn down `tlsSpareTtlMs`
+ *   after its handshake. While the host was called within
+ *   `SPARE_REFILL_WINDOW_MS`, a replacement opens at once
+ *   `SPARE_REFILL_LEAD_MS` plus up to `SPARE_REFILL_JITTER_MS` before that
+ *   teardown (one replacement per host at a time, so a host holds at most
+ *   `tlsSpares` spares plus the one being replaced); after the window an
+ *   expired spare is not replaced. Hosts live in memory only.
+ * - A call that finds no spare while a spare's open for its host has run for
+ *   at least half the handshake median (and at most its p95) waits for that
+ *   open instead of starting another, and opens its own session when that
+ *   open fails.
  * - Keep-alive: up to `MAX_KEEP_ALIVE_SESSIONS` sessions per host, each
  *   reused for `tlsKeepAliveMs` from its open or `tlsMaxCallsPerSession`
  *   calls; a call beyond that runs on a session of its own.
@@ -39,6 +48,20 @@ export const SPARE_DELAY_MEAN_MS = 2_000;
 export const MAX_KEEP_ALIVE_SESSIONS = 4;
 /** Hosts with spares kept at once; the least recently used host loses its spares. */
 export const MAX_SPARE_HOSTS = 8;
+/**
+ * A spare is refreshed before its TTL only while its host was called within
+ * this long. Bounds how far apart the refresh chain can link a wallet's calls
+ * to one host at low traffic.
+ */
+export const SPARE_REFILL_WINDOW_MS = 60_000;
+/**
+ * How long before a spare's TTL its replacement opens: about the handshake
+ * p95 measured from India on 2026-10-15 (1.45 s), so the replacement is ready
+ * before the old spare goes.
+ */
+export const SPARE_REFILL_LEAD_MS = 1_500;
+/** Uniform jitter added to `SPARE_REFILL_LEAD_MS`, so refreshes do not tick at a fixed period. */
+export const SPARE_REFILL_JITTER_MS = 500;
 /** Exits tried for one open. */
 export const MAX_OPEN_ATTEMPTS = 3;
 /** Handshake times kept for the copy timer's p95. */
@@ -74,7 +97,35 @@ export class NoTunnelExitError extends Error {
 
 interface Spare {
   readonly channel: TlsChannel;
-  readonly timer: ReturnType<typeof setTimeout>;
+  /** When the handshake finished: the TTL and the logged age count from here. */
+  readonly readyAt: number;
+  readonly timers: ReturnType<typeof setTimeout>[];
+  /** A replacement is opening; this spare still serves a call until its TTL. */
+  superseded: boolean;
+  /** The TTL leaves room for a refresh (longer than LEAD plus jitter). */
+  refreshable: boolean;
+}
+
+/** A background spare open in flight, which a call may wait for. */
+interface PendingOpen {
+  readonly startedAt: number;
+  /** A call waits for this open: it is handed to the call, not kept as a spare. */
+  claimed: boolean;
+  /** Set once the open succeeded. */
+  channel: TlsChannel | undefined;
+  readyAt: number;
+  readonly promise: Promise<TlsChannel>;
+}
+
+/** How `acquire` obtained a session, for the `tls.call` log line. */
+export type AcquirePath = "spare" | "inline" | "waited" | "reused";
+
+export interface AcquireInfo {
+  readonly path: AcquirePath;
+  /** Time `acquire` spent waiting for a handshake (0 for a spare or a reused session). */
+  readonly openMs: number;
+  /** Age of the spare since its handshake, for `path: "spare"`. */
+  readonly spareAgeMs: number | undefined;
 }
 
 interface Pooled {
@@ -86,7 +137,13 @@ export class TlsPool {
   readonly policy: CopyPolicy;
   private readonly skipped = new Map<string, number>();
   private readonly spares = new Map<string, Spare[]>();
+  /** Spare opens per host, scheduled or in flight. */
   private readonly opening = new Map<string, number>();
+  /** Spare opens per host that have started their handshake. */
+  private readonly pending = new Map<string, PendingOpen[]>();
+  /** When each host was last called (per-call mode), least recent first. */
+  private readonly lastCallAt = new Map<string, number>();
+  private readonly acquired = new WeakMap<TlsChannel, AcquireInfo>();
   private readonly sessions = new Map<string, Pooled[]>();
   private readonly timers = new Set<ReturnType<typeof setTimeout>>();
   private readonly samples: number[] = [];
@@ -127,9 +184,23 @@ export class TlsPool {
 
   /** A session ready for a request to `host`: a spare, an idle shared session, or a new one. */
   async acquire(host: string, timing: Omit<ExchangeTiming, "background">): Promise<TlsChannel> {
+    const startedAt = this.deps.now();
     if (this.settings.tlsSession === "per-call") {
+      this.noteCall(host, startedAt);
       const spare = this.takeSpare(host);
-      const channel = spare ?? (await this.open(host, { ...timing, background: false }));
+      if (spare !== undefined) {
+        this.acquired.set(spare.channel, { path: "spare", openMs: 0, spareAgeMs: startedAt - spare.readyAt });
+        this.replenish(host);
+        return spare.channel;
+      }
+      const inFlight = this.waitableOpen(host, startedAt);
+      const waited = inFlight === undefined ? undefined : await this.waitFor(host, inFlight, timing);
+      const channel = waited ?? (await this.open(host, { ...timing, background: false }));
+      this.acquired.set(channel, {
+        path: waited === undefined ? "inline" : "waited",
+        openMs: this.deps.now() - startedAt,
+        spareAgeMs: undefined,
+      });
       this.replenish(host);
       return channel;
     }
@@ -138,9 +209,11 @@ export class TlsPool {
     const ready = pooled.find((entry) => entry.idle && this.keepAliveUsable(entry.channel, now));
     if (ready !== undefined) {
       ready.idle = false;
+      this.acquired.set(ready.channel, { path: "reused", openMs: 0, spareAgeMs: undefined });
       return ready.channel;
     }
     const channel = await this.open(host, { ...timing, background: false });
+    this.acquired.set(channel, { path: "inline", openMs: this.deps.now() - startedAt, spareAgeMs: undefined });
     const live = this.sessions.get(host) ?? [];
     if (live.length < MAX_KEEP_ALIVE_SESSIONS) {
       live.push({ channel, idle: false });
@@ -172,6 +245,11 @@ export class TlsPool {
     this.retire(channel);
   }
 
+  /** How the last `acquire` that returned `channel` obtained it. */
+  acquireInfo(channel: TlsChannel): AcquireInfo | undefined {
+    return this.acquired.get(channel);
+  }
+
   /** Drop every session; spares and shared sessions are torn down. */
   close(): void {
     this.closed = true;
@@ -264,16 +342,61 @@ export class TlsPool {
     this.deps.log.info("tls.exit.skipped", { reason, minutes: EXIT_SKIP_MS / 60_000 });
   }
 
-  private takeSpare(host: string): TlsChannel | undefined {
+  private takeSpare(host: string): Spare | undefined {
     const list = this.spares.get(host);
     const spare = list?.shift();
     if (spare === undefined) return undefined;
-    clearTimeout(spare.timer);
-    this.timers.delete(spare.timer);
+    this.clearSpareTimers(spare);
     // Most recently used host last (see MAX_SPARE_HOSTS).
     this.spares.delete(host);
     this.spares.set(host, list ?? []);
-    return spare.channel;
+    return spare;
+  }
+
+  private noteCall(host: string, at: number): void {
+    this.lastCallAt.delete(host);
+    this.lastCallAt.set(host, at);
+    while (this.lastCallAt.size > MAX_SPARE_HOSTS) {
+      const oldest = this.lastCallAt.keys().next().value as string;
+      this.lastCallAt.delete(oldest);
+    }
+  }
+
+  /** `host` was called within `SPARE_REFILL_WINDOW_MS`. */
+  private recentlyCalled(host: string): boolean {
+    const at = this.lastCallAt.get(host);
+    return at !== undefined && this.deps.now() - at < SPARE_REFILL_WINDOW_MS;
+  }
+
+  /**
+   * The oldest unclaimed spare open for `host` that started at least half the
+   * handshake median ago and no longer ago than the handshake p95 (once there
+   * are `LATENCY_MIN_SAMPLES`): an open past the p95 is likely stuck on a slow
+   * exit, so the call opens its own and that open stays a spare if it lands.
+   */
+  private waitableOpen(host: string, now: number): PendingOpen | undefined {
+    const minAgeMs = percentile(this.samples, 0.5, 1) / 2;
+    const maxAgeMs = percentile95(this.samples) || Number.POSITIVE_INFINITY;
+    return this.pending.get(host)?.find((entry) => {
+      const ageMs = now - entry.startedAt;
+      return !entry.claimed && ageMs >= minAgeMs && ageMs <= maxAgeMs;
+    });
+  }
+
+  /**
+   * Wait for the spare open `entry` and take its session. Undefined when that
+   * open fails or the call's deadline passes first (the call then opens its
+   * own); the call's abort rejects. A session the call gave up on stays a spare.
+   */
+  private async waitFor(host: string, entry: PendingOpen, timing: Omit<ExchangeTiming, "background">): Promise<TlsChannel | undefined> {
+    entry.claimed = true;
+    const outcome = await settleFirst(entry.promise, timing.signal, timing.deadlineAt - this.deps.now());
+    if (outcome.kind === "opened") return outcome.channel;
+    if (outcome.kind === "failed") return undefined;
+    entry.claimed = false;
+    if (entry.channel !== undefined) this.keepSpare(host, entry.channel, entry.readyAt);
+    if (outcome.kind === "aborted") throw outcome.reason;
+    return undefined;
   }
 
   /** Per-call mode: open a replacement spare for `host` after an exponential delay. */
@@ -283,51 +406,117 @@ export class TlsPool {
       if (this.deferredHosts.size < MAX_SPARE_HOSTS) this.deferredHosts.add(host);
       return;
     }
-    const have = (this.spares.get(host)?.length ?? 0) + (this.opening.get(host) ?? 0);
-    if (have >= this.settings.tlsSpares) return;
+    if (this.spareCount(host) >= this.settings.tlsSpares) return;
+    this.openSpare(host, Math.round(-Math.log(1 - this.deps.random()) * SPARE_DELAY_MEAN_MS));
+  }
+
+  /** Spares of `host` that count against `tlsSpares`: those not being replaced, and opens scheduled or in flight. */
+  private spareCount(host: string): number {
+    const live = (this.spares.get(host) ?? []).filter((spare) => !spare.superseded).length;
+    return live + (this.opening.get(host) ?? 0);
+  }
+
+  /** Open a spare for `host` after `delayMs` (at once for 0); it becomes a spare unless a call claims it first. */
+  private openSpare(host: string, delayMs: number): void {
     this.opening.set(host, (this.opening.get(host) ?? 0) + 1);
-    const delayMs = Math.round(-Math.log(1 - this.deps.random()) * SPARE_DELAY_MEAN_MS);
-    this.later(delayMs, () => {
-      const deadlineAt = this.deps.now() + this.settings.tlsOpenTimeoutMs * MAX_OPEN_ATTEMPTS;
-      this.open(host, { deadlineAt, background: true }).then(
-        (channel) => this.keepSpare(host, channel),
-        (error: unknown) => this.deps.log.debug("tls.spare.failed", { reason: error instanceof Error ? error.name : "error" }),
-      ).finally(() => {
+    const start = (): void => {
+      const settled = (entry: PendingOpen): void => {
         const left = (this.opening.get(host) ?? 1) - 1;
         if (left <= 0) this.opening.delete(host);
         else this.opening.set(host, left);
-      });
-    });
+        const rest = (this.pending.get(host) ?? []).filter((candidate) => candidate !== entry);
+        if (rest.length === 0) this.pending.delete(host);
+        else this.pending.set(host, rest);
+      };
+      const startedAt = this.deps.now();
+      const deadlineAt = startedAt + this.settings.tlsOpenTimeoutMs * MAX_OPEN_ATTEMPTS;
+      // The handlers run after `entry` below is assigned: `open` settles asynchronously.
+      const promise: Promise<TlsChannel> = this.open(host, { deadlineAt, background: true }).then(
+        (channel) => {
+          settled(entry);
+          entry.channel = channel;
+          entry.readyAt = this.deps.now();
+          if (!entry.claimed) this.keepSpare(host, channel, entry.readyAt);
+          return channel;
+        },
+        (error: unknown) => {
+          settled(entry);
+          this.deps.log.debug("tls.spare.failed", { reason: error instanceof Error ? error.name : "error" });
+          throw error;
+        },
+      );
+      promise.catch(() => undefined);
+      const entry: PendingOpen = { startedAt, claimed: false, channel: undefined, readyAt: 0, promise };
+      const list = this.pending.get(host) ?? [];
+      list.push(entry);
+      this.pending.set(host, list);
+    };
+    if (delayMs <= 0) start();
+    else this.later(delayMs, start);
   }
 
-  private keepSpare(host: string, channel: TlsChannel): void {
+  private keepSpare(host: string, channel: TlsChannel, readyAt: number): void {
     if (this.closed) {
       this.teardown(channel);
       return;
     }
     const list = this.spares.get(host) ?? [];
-    const timer = this.later(this.settings.tlsSpareTtlMs, () => {
-      const current = this.spares.get(host);
-      const index = current?.findIndex((spare) => spare.channel === channel) ?? -1;
-      if (current === undefined || index < 0) return;
-      current.splice(index, 1);
-      if (current.length === 0) this.spares.delete(host);
-      this.teardown(channel);
-    });
-    list.push({ channel, timer });
+    const spare: Spare = { channel, readyAt, timers: [], superseded: false, refreshable: false };
+    const ttlMs = this.settings.tlsSpareTtlMs;
+    const ageMs = this.deps.now() - readyAt;
+    spare.timers.push(this.later(ttlMs - ageMs, () => this.expire(host, spare)));
+    const refreshMs = ttlMs - SPARE_REFILL_LEAD_MS - this.deps.random() * SPARE_REFILL_JITTER_MS - ageMs;
+    if (refreshMs > 0) {
+      spare.refreshable = true;
+      spare.timers.push(this.later(refreshMs, () => this.refresh(host, spare)));
+    }
+    list.push(spare);
     this.spares.delete(host);
     this.spares.set(host, list);
     while (this.spares.size > MAX_SPARE_HOSTS) {
       const [oldest, spares] = this.spares.entries().next().value as [string, Spare[]];
       this.spares.delete(oldest);
-      for (const spare of spares) {
-        clearTimeout(spare.timer);
-        this.timers.delete(spare.timer);
-        this.teardown(spare.channel);
+      for (const evicted of spares) {
+        this.clearSpareTimers(evicted);
+        this.teardown(evicted.channel);
       }
     }
   }
 
+  /** Before a spare's TTL: open its replacement at once while the host is recent. */
+  private refresh(host: string, spare: Spare): void {
+    if (this.closed || !this.background || !this.recentlyCalled(host)) return;
+    const list = this.spares.get(host);
+    if (list === undefined || !list.includes(spare)) return;
+    if (list.some((other) => other.superseded)) return;
+    spare.superseded = true;
+    this.openSpare(host, 0);
+  }
+
+  /**
+   * A spare's TTL: tear it down. A spare whose refresh could not run (another
+   * spare of the host was being replaced, or the replacement failed) is
+   * replaced at once while the host is recent, up to `tlsSpares`.
+   */
+  private expire(host: string, spare: Spare): void {
+    const current = this.spares.get(host);
+    const index = current?.indexOf(spare) ?? -1;
+    if (current === undefined || index < 0) return;
+    current.splice(index, 1);
+    if (current.length === 0) this.spares.delete(host);
+    this.clearSpareTimers(spare);
+    this.teardown(spare.channel);
+    if (!spare.refreshable || this.closed || !this.background || !this.recentlyCalled(host)) return;
+    if (this.spareCount(host) < this.settings.tlsSpares) this.openSpare(host, 0);
+  }
+
+  private clearSpareTimers(spare: Spare): void {
+    for (const timer of spare.timers) {
+      clearTimeout(timer);
+      this.timers.delete(timer);
+    }
+  }
+
   private teardown(channel: TlsChannel): void {
     const deadlineAt = this.deps.now() + this.settings.tlsOpenTimeoutMs;
     channel.teardown(deadlineAt).catch((error: unknown) =>
@@ -352,7 +541,41 @@ export class TlsPool {
 
 /** p95 of `samples`, or 0 below `LATENCY_MIN_SAMPLES`. */
 function percentile95(samples: readonly number[]): number {
-  if (samples.length < LATENCY_MIN_SAMPLES) return 0;
+  return percentile(samples, 0.95, LATENCY_MIN_SAMPLES);
+}
+
+/** The `q` quantile (nearest rank) of `samples`, or 0 below `minSamples`. */
+function percentile(samples: readonly number[], q: number, minSamples: number): number {
+  if (samples.length < Math.max(1, minSamples)) return 0;
   const sorted = [...samples].sort((left, right) => left - right);
-  return sorted[Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1)] ?? 0;
+  return sorted[Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * q) - 1))] ?? 0;
+}
+
+type Settled =
+  | { readonly kind: "opened"; readonly channel: TlsChannel }
+  | { readonly kind: "failed" }
+  | { readonly kind: "aborted"; readonly reason: unknown }
+  | { readonly kind: "deadline" };
+
+/** Whichever comes first: `open` settling, `signal` aborting, or `withinMs` passing. */
+function settleFirst(open: Promise<TlsChannel>, signal: AbortSignal | undefined, withinMs: number): Promise<Settled> {
+  return new Promise<Settled>((resolve) => {
+    if (signal?.aborted === true) {
+      resolve({ kind: "aborted", reason: signal.reason });
+      return;
+    }
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const onAbort = (): void => finish({ kind: "aborted", reason: signal?.reason });
+    const finish = (outcome: Settled): void => {
+      if (timer !== undefined) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(outcome);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timer = setTimeout(() => finish({ kind: "deadline" }), Math.max(0, withinMs));
+    open.then(
+      (channel) => finish({ kind: "opened", channel }),
+      () => finish({ kind: "failed" }),
+    );
+  });
 }

package/src/tls/transport.ts

@@ -18,7 +18,7 @@ import {
   type TunnelHop,
 } from "../fetch-map.js";
 import { describeError, type WorkerLogger } from "../log.js";
-import { TLS_PORT } from "./channel.js";
+import { TLS_PORT, type TlsChannel } from "./channel.js";
 import { tlsErrorCode, type NoxTlsBindings } from "./module.js";
 import { NoTunnelExitError, type TlsPool } from "./pool.js";
 import {
@@ -184,6 +184,7 @@ export class TlsTransport implements TunnelHop {
         if (budget.signal.aborted) throw budget.signal.reason;
         throw mapTlsError(error);
       }
+      const sentAt = this.now();
       try {
         const reply = await channel.request({
           http,
@@ -196,6 +197,7 @@ export class TlsTransport implements TunnelHop {
           background: false,
         });
         this.pool.release(channel, true);
+        this.logCall(channel, attempt, sentAt, true);
         return {
           status: reply.status,
           headers: reply.headers.filter(([name]) => !CONNECTION_HEADERS.has(name.toLowerCase())),
@@ -205,12 +207,32 @@ export class TlsTransport implements TunnelHop {
       } catch (error) {
         this.pool.release(channel, false);
         if (budget.signal.aborted) throw budget.signal.reason;
-        if (attempt > 0 || budget.remainingMs() <= 0 || !retriable(error, resendable)) throw mapTlsError(error);
+        if (attempt > 0 || budget.remainingMs() <= 0 || !retriable(error, resendable)) {
+          this.logCall(channel, attempt, sentAt, false);
+          throw mapTlsError(error);
+        }
         this.log.info("tls.retry", { reason: error instanceof Error ? error.name : "error" });
       }
     }
   }
 
+  /**
+   * `tls.call`: how the last attempt of a tunnel hop got its session (`path`,
+   * `"retry"` after a retry), the handshake wait, the spare's age, and the
+   * request exchange time.
+   */
+  private logCall(channel: TlsChannel, retries: number, sentAt: number, ok: boolean): void {
+    const info = this.pool.acquireInfo(channel);
+    this.log.info("tls.call", {
+      path: retries > 0 ? "retry" : info?.path ?? "inline",
+      openMs: info?.openMs ?? 0,
+      ...(info?.spareAgeMs === undefined ? {} : { spareAgeMs: info.spareAgeMs }),
+      exchangeMs: this.now() - sentAt,
+      retries,
+      ok,
+    });
+  }
+
   private encode(request: PreparedRequest, target: TunnelTarget): Uint8Array {
     const headers: string[] = [];
     let hasAuthorization = false;