diff --git a/README.md b/README.md
index fdb9a09..45c64d4 100644
--- a/README.md
+++ b/README.md
@@ -75,6 +75,10 @@ npm run demo:browser
 
 See [`examples/browser-test/README.md`](examples/browser-test/README.md).
 
+## Latency benchmark
+
+[`examples/latency-bench`](examples/latency-bench/README.md) runs counting-echo turns against your own deployed agent and writes per-turn end-to-end latency in the node-webrtc-rust benchmark format.
+
 ## Ending a session
 
 | Action                | API                                                                               | Server `end_reason`   |
diff --git a/examples/latency-bench/README.md b/examples/latency-bench/README.md
new file mode 100644
index 0000000..65ccc1b
--- /dev/null
+++ b/examples/latency-bench/README.md
@@ -0,0 +1,124 @@
+# latency-bench
+
+Measures how long a VoiceThere voice agent takes to answer, from the client's side. It
+starts a session on your own project with `@voicethere/client/node`, speaks a counting phrase
+into the microphone track, waits for the agent to echo it, and records four timings per turn.
+The results use the same file format as the
+[node-webrtc-rust vendor benchmarks](https://github.com/akirilyuk/node-webrtc-rust/tree/main/benchmarks),
+so you can summarise and compare them with that project's tools.
+
+## What it measures
+
+A turn starts when the last audio frame of your clip has been written to the microphone track
+("speech end"). All four numbers are in milliseconds, taken on one monotonic clock on your
+machine, at the moment the voice-control message arrives.
+
+| Metric                         | Starts                                | Ends                                                                            |
+| ------------------------------ | ------------------------------------- | ------------------------------------------------------------------------------- |
+| `speech_end_to_final_ms`       | speech end                            | `user_speech_final` event with a non-empty text (the speech-to-text result)     |
+| `final_to_reply_start_ms`      | that `user_speech_final` event        | first `agent_speaking_start` event after it (the agent starts talking)          |
+| `speech_end_to_reply_start_ms` | speech end                            | the same `agent_speaking_start` event: the wait a caller feels                  |
+| `tts_first_audio_ms`           | agent called `speak()` (server clock) | first reply audio sent, as reported in `firstAudioMs` of `agent_speaking_start` |
+
+A metric is `null` when one of its events never arrived. The first turn of each conversation
+is recorded as `cold` (new session, new connections), the later ones as `warm`.
+
+VoiceThere's own end-to-end runs use the same events and the same start and end points. They
+differ in two ways: their load client produces its clip with text-to-speech, while this tool
+plays a recording you provide, and the load client stamps events with the wall clock instead
+of a monotonic one.
+
+The numbers include your network path to the VoiceThere region and the load on your machine.
+Close other heavy programs, note the region in `--region`, and use a machine that stays
+awake: if the host sleeps during a run, the tool prints `[host-suspended] result:
+inconclusive`, lists the gaps in `meta.json` and exits with code 3. Do not use such a run.
+
+## Prerequisites
+
+- A deployed VoiceThere project whose agent answers every final transcript with the same
+  words. A few lines with [`@voicethere/agent`](https://github.com/voicethere/agent) do it:
+
+  ```typescript
+  import { defineAgent, speak } from "@voicethere/agent";
+
+  defineAgent({
+    onUserSpeechFinal({ sessionId, text }) {
+      speak(sessionId, `echo: ${text}`);
+    },
+  });
+  ```
+
+  Keep the agent free of other work (no model calls, no greeting) so the numbers show the
+  platform and not your agent logic.
+
+- A **client** API key (`vthc_…`) for that project, in `VOICETHERE_CLIENT_API_KEY`. It is
+  never printed or written to the output files. See
+  [voicethere.io](https://voicethere.io) for how to create one.
+- The project id, in `VOICETHERE_PROJECT_ID` or `--project`.
+- A 16-bit PCM WAV file (mono or stereo, any sample rate) of someone saying a counting
+  phrase such as "one two three four five six seven eight nine ten", about 3 to 6 seconds.
+  The example ships no recording; record your own or generate one with a text-to-speech tool
+  whose licence you have. For example, on a machine with `espeak-ng` and `ffmpeg`:
+
+  ```bash
+  espeak-ng -v en -s 150 -w counting.wav "one two three four five six seven eight nine ten"
+  ```
+
+  The tool converts the clip to 48 kHz stereo and scales the loudest sample to -1 dBFS.
+
+- Node.js 22 or newer and `npm ci` in this repository.
+
+## Run
+
+```bash
+export VOICETHERE_CLIENT_API_KEY=vthc_...
+export VOICETHERE_PROJECT_ID=<your project id>
+
+npm run bench:latency -- \
+  --clip counting.wav \
+  --turns 10 \
+  --conversations 3 \
+  --region eu \
+  --out results/my-run
+```
+
+| Option                | Default                             | Meaning                                                                      |
+| --------------------- | ----------------------------------- | ---------------------------------------------------------------------------- |
+| `--clip <file>`       | required                            | WAV file to speak                                                            |
+| `--out <dir>`         | required                            | Output directory. The run refuses to start if it already holds a `raw.jsonl` |
+| `--turns <n>`         | `10`                                | Turns per conversation                                                       |
+| `--conversations <n>` | `1`                                 | Conversations, one after another (a new session each)                        |
+| `--region <label>`    | none                                | Free text stored in `environment.json`                                       |
+| `--project <id>`      | `VOICETHERE_PROJECT_ID`             | Project to call                                                              |
+| `--api-base <url>`    | `https://sessions.voicethere.io/v1` | Session API                                                                  |
+| `--model <label>`     | `default/default`                   | `stt/tts` label stored in each record                                        |
+| `--turn-timeout-ms`   | `30000`                             | Wait for a reply before the turn counts as failed                            |
+
+To use the example outside this repository, copy the folder and change the import in
+`src/run.ts` from `../../../src/node/index.js` to `@voicethere/client/node`.
+
+## Output
+
+- `raw.jsonl`: one record per answered turn, with `vendor: "voicethere"`, `leg: "e2e"`,
+  `transport: "webrtc"`, `phase`, `text: "counting-echo"`, `run` and the four `metrics`.
+- `meta.json`: schema version, turns and conversations, failed turns, start and end time, and
+  any host-suspend gaps.
+- `environment.json`: operating system, CPU, Node.js and client versions, region.
+
+No transcripts, session ids or keys are written.
+
+## Summarise and compare
+
+The summariser and compare tool live in the node-webrtc-rust repository:
+
+```bash
+git clone https://github.com/akirilyuk/node-webrtc-rust
+cd node-webrtc-rust
+node benchmarks/scripts/bench-vendors.mjs --summarize <your-out-dir>
+npm run bench:compare -- benchmarks/results/<published-dir>/<run> <your-out-dir>
+```
+
+How the library numbers are measured is described in
+[METHODOLOGY.md](https://github.com/akirilyuk/node-webrtc-rust/blob/main/benchmarks/METHODOLOGY.md).
+Those runs call the speech vendors directly, so they leave out WebRTC and the VoiceThere
+platform; this tool adds both.
diff --git a/examples/latency-bench/src/args.ts b/examples/latency-bench/src/args.ts
new file mode 100644
index 0000000..35661cc
--- /dev/null
+++ b/examples/latency-bench/src/args.ts
@@ -0,0 +1,64 @@
+import { parseArgs } from "node:util";
+
+export const DEFAULT_API_BASE = "https://sessions.voicethere.io/v1";
+
+export type BenchArgs = {
+  turns: number;
+  conversations: number;
+  out: string;
+  region: string | null;
+  projectId: string;
+  apiBase: string;
+  clip: string;
+  model: string;
+  turnTimeoutMs: number;
+};
+
+function positiveInt(name: string, raw: string): number {
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`--${name} must be a positive integer`);
+  }
+  return value;
+}
+
+/** Parses the command line. The API key is not an argument: it is read from the environment. */
+export function parseBenchArgs(
+  argv: string[],
+  env: Record<string, string | undefined> = process.env,
+): BenchArgs {
+  const { values } = parseArgs({
+    args: argv,
+    options: {
+      turns: { type: "string", default: "10" },
+      conversations: { type: "string", default: "1" },
+      out: { type: "string" },
+      region: { type: "string" },
+      project: { type: "string" },
+      "api-base": { type: "string" },
+      clip: { type: "string" },
+      model: { type: "string", default: "default/default" },
+      "turn-timeout-ms": { type: "string", default: "30000" },
+    },
+    strict: true,
+  });
+  if (!values.out) throw new Error("--out <dir> is required");
+  if (!values.clip) {
+    throw new Error("--clip <file.wav> is required (a spoken counting phrase)");
+  }
+  const projectId = values.project ?? env.VOICETHERE_PROJECT_ID;
+  if (!projectId) {
+    throw new Error("pass --project <id> or set VOICETHERE_PROJECT_ID");
+  }
+  return {
+    turns: positiveInt("turns", values.turns!),
+    conversations: positiveInt("conversations", values.conversations!),
+    out: values.out,
+    region: values.region ?? null,
+    projectId,
+    apiBase: values["api-base"] ?? DEFAULT_API_BASE,
+    clip: values.clip,
+    model: values.model!,
+    turnTimeoutMs: positiveInt("turn-timeout-ms", values["turn-timeout-ms"]!),
+  };
+}
diff --git a/examples/latency-bench/src/environment.ts b/examples/latency-bench/src/environment.ts
new file mode 100644
index 0000000..ea320f8
--- /dev/null
+++ b/examples/latency-bench/src/environment.ts
@@ -0,0 +1,30 @@
+import { readFileSync } from "node:fs";
+import os from "node:os";
+
+function clientVersion(): string {
+  try {
+    const raw = readFileSync(
+      new URL("../../../package.json", import.meta.url),
+      "utf8",
+    );
+    return (JSON.parse(raw) as { version?: string }).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+/** Where and on what the run happened. No hostnames, addresses or user names. */
+export function collectEnvironment(
+  region: string | null,
+): Record<string, unknown> {
+  const cpus = os.cpus();
+  return {
+    os: { platform: os.platform(), release: os.release(), arch: os.arch() },
+    cpu: { model: cpus[0]?.model ?? "unknown", count: cpus.length },
+    memory_total_mb: Math.round(os.totalmem() / 1024 / 1024),
+    load_avg_1m_at_start: Number(os.loadavg()[0]!.toFixed(2)),
+    node_version: process.version,
+    voicethere_client_version: clientVersion(),
+    region,
+  };
+}
diff --git a/examples/latency-bench/src/metrics.test.ts b/examples/latency-bench/src/metrics.test.ts
new file mode 100644
index 0000000..82823e1
--- /dev/null
+++ b/examples/latency-bench/src/metrics.test.ts
@@ -0,0 +1,95 @@
+import { describe, expect, it } from "vitest";
+
+import { computeTurnMetrics, parseSpeechEvent } from "./metrics.js";
+
+const ev = (
+  event: string,
+  atMs: number,
+  extra: { text?: string; payload?: Record<string, unknown> } = {},
+) => ({ event, atMs, ...extra });
+
+describe("computeTurnMetrics", () => {
+  it("measures the four metrics from a scripted turn", () => {
+    const metrics = computeTurnMetrics({
+      speechEndAtMs: 1000,
+      events: [
+        ev("user_speaking_start", 200),
+        ev("user_speech_final", 1400, { text: "one two three" }),
+        ev("agent_speaking_start", 1900, { payload: { firstAudioMs: 310 } }),
+        ev("agent_speaking_end", 4000),
+      ],
+    });
+    expect(metrics).toEqual({
+      speech_end_to_final_ms: 400,
+      final_to_reply_start_ms: 500,
+      speech_end_to_reply_start_ms: 900,
+      tts_first_audio_ms: 310,
+    });
+  });
+
+  it("reads first_audio_ms in snake case", () => {
+    const metrics = computeTurnMetrics({
+      speechEndAtMs: 0,
+      events: [
+        ev("user_speech_final", 10, { text: "x" }),
+        ev("agent_speaking_start", 20, { payload: { first_audio_ms: 5 } }),
+      ],
+    });
+    expect(metrics.tts_first_audio_ms).toBe(5);
+  });
+
+  it("returns null for every metric that needs a missing event", () => {
+    expect(computeTurnMetrics({ speechEndAtMs: 1000, events: [] })).toEqual({
+      speech_end_to_final_ms: null,
+      final_to_reply_start_ms: null,
+      speech_end_to_reply_start_ms: null,
+      tts_first_audio_ms: null,
+    });
+    const noReply = computeTurnMetrics({
+      speechEndAtMs: 1000,
+      events: [ev("user_speech_final", 1300, { text: "one" })],
+    });
+    expect(noReply.speech_end_to_final_ms).toBe(300);
+    expect(noReply.final_to_reply_start_ms).toBeNull();
+    expect(noReply.speech_end_to_reply_start_ms).toBeNull();
+    expect(noReply.tts_first_audio_ms).toBeNull();
+  });
+
+  it("ignores an empty final and a reply that started before the final", () => {
+    const metrics = computeTurnMetrics({
+      speechEndAtMs: 100,
+      events: [
+        ev("agent_speaking_start", 150),
+        ev("user_speech_final", 200, { text: "  " }),
+      ],
+    });
+    expect(metrics.speech_end_to_final_ms).toBeNull();
+    expect(metrics.speech_end_to_reply_start_ms).toBeNull();
+  });
+
+  it("drops a negative or non-finite firstAudioMs", () => {
+    const metrics = computeTurnMetrics({
+      speechEndAtMs: 0,
+      events: [
+        ev("user_speech_final", 10, { text: "x" }),
+        ev("agent_speaking_start", 20, { payload: { firstAudioMs: -1 } }),
+      ],
+    });
+    expect(metrics.tts_first_audio_ms).toBeNull();
+  });
+});
+
+describe("parseSpeechEvent", () => {
+  it("keeps non-envelope fields as payload and ignores other messages", () => {
+    const parsed = parseSpeechEvent(
+      { type: "speech_event", event: "agent_speaking_start", firstAudioMs: 12 },
+      5,
+    );
+    expect(parsed).toMatchObject({
+      event: "agent_speaking_start",
+      atMs: 5,
+      payload: { firstAudioMs: 12 },
+    });
+    expect(parseSpeechEvent({ type: "agent_speak", text: "x" }, 5)).toBeNull();
+  });
+});
diff --git a/examples/latency-bench/src/metrics.ts b/examples/latency-bench/src/metrics.ts
new file mode 100644
index 0000000..6cd6bdd
--- /dev/null
+++ b/examples/latency-bench/src/metrics.ts
@@ -0,0 +1,109 @@
+/**
+ * Turn timing from the events a customer's client sees on the voice-control data channel.
+ *
+ * All timestamps are milliseconds on one monotonic client clock (`performance.now()`), taken
+ * when the control message arrives, and `speechEndAtMs` is taken when the last frame of the
+ * spoken clip was written to the mic track.
+ */
+
+export type SpeechEventRecord = {
+  event: string;
+  atMs: number;
+  /** Present on `user_speech_final`. Only checked for being non-empty, never stored. */
+  text?: string;
+  /** Extra fields of the `speech_event` message (for example `firstAudioMs`). */
+  payload?: Record<string, unknown>;
+};
+
+export type TurnMetricValues = {
+  speech_end_to_final_ms: number | null;
+  final_to_reply_start_ms: number | null;
+  speech_end_to_reply_start_ms: number | null;
+  tts_first_audio_ms: number | null;
+};
+
+const ENVELOPE_KEYS = new Set(["type", "event", "ts", "text", "language"]);
+
+/**
+ * Turns a voice-control JSON message into an event record, or null when it is not a
+ * `speech_event`. Fields other than the envelope go to `payload`.
+ */
+export function parseSpeechEvent(
+  message: Record<string, unknown>,
+  atMs: number,
+): SpeechEventRecord | null {
+  if (message.type !== "speech_event") return null;
+  const event = String(message.event ?? "");
+  if (!event) return null;
+  const payloadEntries = Object.entries(message).filter(
+    ([key]) => !ENVELOPE_KEYS.has(key),
+  );
+  return {
+    event,
+    atMs,
+    text: typeof message.text === "string" ? message.text : undefined,
+    payload:
+      payloadEntries.length > 0
+        ? Object.fromEntries(payloadEntries)
+        : undefined,
+  };
+}
+
+function timingFromPayload(
+  payload: Record<string, unknown> | undefined,
+  camelKey: string,
+  snakeKey: string,
+): number | null {
+  for (const key of [camelKey, snakeKey]) {
+    const value = payload?.[key];
+    if (typeof value === "number" && Number.isFinite(value) && value >= 0) {
+      return value;
+    }
+  }
+  return null;
+}
+
+function isNonEmptyFinal(event: SpeechEventRecord): boolean {
+  return (
+    event.event === "user_speech_final" && (event.text?.trim().length ?? 0) > 0
+  );
+}
+
+/**
+ * The four metrics of one turn. Any metric whose start or end event is missing is null.
+ *
+ * - `final`: the last non-empty `user_speech_final` seen in the turn.
+ * - `reply start`: the first `agent_speaking_start` after that final.
+ * - `tts_first_audio_ms`: `firstAudioMs` carried by that `agent_speaking_start`.
+ *
+ * Pass only the events recorded since the clip started playing, so leftovers from the
+ * previous turn cannot be picked up.
+ */
+export function computeTurnMetrics(input: {
+  speechEndAtMs: number | null;
+  events: SpeechEventRecord[];
+}): TurnMetricValues {
+  const { speechEndAtMs, events } = input;
+  const final = events.filter(isNonEmptyFinal).at(-1);
+  const replyStart = final
+    ? events.find(
+        (e) =>
+          e.event === "agent_speaking_start" &&
+          events.indexOf(e) > events.indexOf(final),
+      )
+    : undefined;
+
+  const diff = (end: number | undefined, start: number | null | undefined) =>
+    end != null && start != null ? end - start : null;
+
+  return {
+    speech_end_to_final_ms: diff(final?.atMs, speechEndAtMs),
+    final_to_reply_start_ms: diff(replyStart?.atMs, final?.atMs),
+    speech_end_to_reply_start_ms: diff(replyStart?.atMs, speechEndAtMs),
+    tts_first_audio_ms: timingFromPayload(
+      replyStart?.payload,
+      "firstAudioMs",
+      "first_audio_ms",
+    ),
+  };
+}
diff --git a/examples/latency-bench/src/pacing.test.ts b/examples/latency-bench/src/pacing.test.ts
new file mode 100644
index 0000000..3407779
--- /dev/null
+++ b/examples/latency-bench/src/pacing.test.ts
@@ -0,0 +1,112 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  FRAME_BYTES,
+  FRAME_MS,
+  PacedMicPump,
+  nextFrameWait,
+  type PumpClock,
+} from "./pacing.js";
+
+/** Fake clock: sleeping advances time, a write can cost time or stall. */
+function harness(options: {
+  writeCostMs?: number;
+  stallOnWrite?: { index: number; ms: number };
+  stopAfterFrames: number;
+}) {
+  let t = 0;
+  const clock: PumpClock = {
+    now: () => t,
+    sleep: async (ms) => {
+      t += ms;
+    },
+  };
+  const writes: { at: number; bytes: number; ms: number; tag: number }[] = [];
+  let pump: PacedMicPump;
+  const track = {
+    async writeSample(data: Uint8Array, durationMs: number) {
+      writes.push({
+        at: t,
+        bytes: data.byteLength,
+        ms: durationMs,
+        tag: data[0] ?? 0,
+      });
+      if (options.stallOnWrite?.index === writes.length) {
+        t += options.stallOnWrite.ms;
+      } else {
+        t += options.writeCostMs ?? 0;
+      }
+      if (writes.length >= options.stopAfterFrames + 1) pump.requestStop();
+    },
+  };
+  pump = new PacedMicPump(track, clock);
+  return {
+    pump,
+    writes,
+    /** Runs the pump until `stopAfterFrames` frames were written. */
+    async run() {
+      pump.start();
+      await pump.finished();
+    },
+  };
+}
+
+describe("PacedMicPump", () => {
+  it("writes one 20 ms frame per 20 ms from an anchor without drift", async () => {
+    const h = harness({ writeCostMs: 1.5, stopAfterFrames: 100 });
+    await h.run();
+    const frames = h.writes.filter((w) => w.ms === FRAME_MS);
+    for (let i = 1; i < frames.length; i++) {
+      expect(frames[i]!.at - frames[0]!.at).toBeCloseTo(i * FRAME_MS, 5);
+    }
+    expect(h.pump.reanchors).toBe(0);
+  });
+
+  it("re-anchors after a stall and does not burst", async () => {
+    const h = harness({
+      stallOnWrite: { index: 11, ms: 400 },
+      stopAfterFrames: 40,
+    });
+    await h.run();
+    const frames = h.writes.filter((w) => w.ms === FRAME_MS);
+    const gaps = frames.slice(1).map((w, i) => w.at - frames[i]!.at);
+    // No two frames are ever written closer than one frame apart.
+    expect(Math.min(...gaps)).toBeGreaterThanOrEqual(FRAME_MS);
+    expect(h.pump.reanchors).toBe(1);
+  });
+
+  it("sends the clip frames in order, then resolves at the last write", async () => {
+    const h = harness({ stopAfterFrames: 30 });
+    const frames = [1, 2, 3].map((n) => new Uint8Array(FRAME_BYTES).fill(n));
+    h.pump.start();
+    const speechEnd = await h.pump.play(frames);
+    const played = h.writes.filter((w) => w.ms === FRAME_MS);
+    // The third clip frame was due 40 ms after the first; speech end is taken right after it.
+    expect(speechEnd).toBe(played[2]!.at);
+    await h.run();
+    const all = h.writes.filter((w) => w.ms === FRAME_MS);
+    expect(all.slice(0, 4).map((w) => w.tag)).toEqual([1, 2, 3, 0]);
+  });
+
+  it("refuses a second clip while one is playing", async () => {
+    const h = harness({ stopAfterFrames: 5 });
+    void h.pump.play([new Uint8Array(FRAME_BYTES)]);
+    expect(() => h.pump.play([new Uint8Array(FRAME_BYTES)])).toThrow();
+  });
+});
+
+describe("nextFrameWait", () => {
+  it("sleeps until the next due time, and re-anchors when over 100 ms behind", () => {
+    expect(nextFrameWait({ anchorMs: 0, sent: 1, nowMs: 5 })).toEqual({
+      reanchor: false,
+      waitMs: 15,
+    });
+    expect(nextFrameWait({ anchorMs: 0, sent: 1, nowMs: 60 })).toEqual({
+      reanchor: false,
+      waitMs: 0,
+    });
+    expect(nextFrameWait({ anchorMs: 0, sent: 1, nowMs: 200 }).reanchor).toBe(
+      true,
+    );
+  });
+});
diff --git a/examples/latency-bench/src/pacing.ts b/examples/latency-bench/src/pacing.ts
new file mode 100644
index 0000000..acaa2dc
--- /dev/null
+++ b/examples/latency-bench/src/pacing.ts
@@ -0,0 +1,137 @@
+/**
+ * One writer on the mic track, paced at real time.
+ *
+ * The Node WebRTC runtime sends every frame as soon as `writeSample` is called, so whatever
+ * is written is what goes on the wire. This pump is the only writer: it sends silence while
+ * idle and the clip frames while a turn plays. Frame n is due at `anchor + n x 20 ms`. After a
+ * stall of more than 100 ms it re-anchors instead of sending a burst to catch up.
+ */
+
+export const FRAME_MS = 20;
+/** 20 ms of 48 kHz stereo s16le. */
+export const FRAME_BYTES = 3840;
+/** Priming frame the runtime needs before RTP flows: 5 ms of 48 kHz stereo. */
+export const KICK_BYTES = 960;
+export const KICK_MS = 5;
+export const REANCHOR_BEHIND_MS = 5 * FRAME_MS;
+
+export type PumpTrack = {
+  writeSample(data: Uint8Array, durationMs: number): Promise<void>;
+};
+
+export type PumpClock = {
+  /** Monotonic ms. */
+  now(): number;
+  sleep(ms: number): Promise<void>;
+};
+
+export const realClock: PumpClock = {
+  now: () => performance.now(),
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+};
+
+/**
+ * What to do after frame number `sent` was written: sleep `waitMs`, or re-anchor when the
+ * schedule is more than {@link REANCHOR_BEHIND_MS} behind.
+ */
+export function nextFrameWait(input: {
+  anchorMs: number;
+  sent: number;
+  nowMs: number;
+}): { reanchor: boolean; waitMs: number } {
+  const waitMs = input.anchorMs + input.sent * FRAME_MS - input.nowMs;
+  if (waitMs < -REANCHOR_BEHIND_MS) return { reanchor: true, waitMs: 0 };
+  return { reanchor: false, waitMs: Math.max(0, waitMs) };
+}
+
+type PendingClip = {
+  frames: Uint8Array[];
+  next: number;
+  resolve: (speechEndAtMs: number) => void;
+  reject: (error: Error) => void;
+};
+
+export class PacedMicPump {
+  private readonly silence = new Uint8Array(FRAME_BYTES);
+  private pending: PendingClip | null = null;
+  private stopped = false;
+  private loop: Promise<void> | null = null;
+  /** Number of times the schedule was re-anchored after a stall. */
+  reanchors = 0;
+  /** Write error that ended the loop, if any. */
+  failure: Error | null = null;
+
+  constructor(
+    private readonly track: PumpTrack,
+    private readonly clock: PumpClock = realClock,
+  ) {}
+
+  start(): void {
+    if (this.loop) return;
+    this.loop = this.run();
+  }
+
+  /** Asks the loop to end after the frame being written. */
+  requestStop(): void {
+    this.stopped = true;
+  }
+
+  /** Resolves when the loop has ended. */
+  async finished(): Promise<void> {
+    await this.loop;
+  }
+
+  async stop(): Promise<void> {
+    this.requestStop();
+    await this.finished();
+  }
+
+  /**
+   * Plays `frames` (each {@link FRAME_BYTES} long) and resolves with the clock reading taken
+   * right after the last frame was written: the end of the caller's speech.
+   */
+  play(frames: Uint8Array[]): Promise<number> {
+    if (this.pending) throw new Error("a clip is already playing");
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise<number>((resolve, reject) => {
+      this.pending = { frames, next: 0, resolve, reject };
+    });
+  }
+
+  private async run(): Promise<void> {
+    try {
+      await this.track.writeSample(new Uint8Array(KICK_BYTES), KICK_MS);
+      let anchor = this.clock.now();
+      let sent = 0;
+      while (!this.stopped) {
+        const clip = this.pending;
+        const frame = clip ? clip.frames[clip.next] : undefined;
+        await this.track.writeSample(frame ?? this.silence, FRAME_MS);
+        if (clip && frame) {
+          clip.next += 1;
+          if (clip.next >= clip.frames.length) {
+            this.pending = null;
+            clip.resolve(this.clock.now());
+          }
+        }
+        sent += 1;
+        const step = nextFrameWait({
+          anchorMs: anchor,
+          sent,
+          nowMs: this.clock.now(),
+        });
+        if (step.reanchor) {
+          anchor = this.clock.now();
+          sent = 0;
+          this.reanchors += 1;
+        } else if (step.waitMs > 0) {
+          await this.clock.sleep(step.waitMs);
+        }
+      }
+    } catch (error) {
+      this.failure = error instanceof Error ? error : new Error(String(error));
+      this.pending?.reject(this.failure);
+      this.pending = null;
+    }
+  }
+}
diff --git a/examples/latency-bench/src/records.test.ts b/examples/latency-bench/src/records.test.ts
new file mode 100644
index 0000000..52fc16b
--- /dev/null
+++ b/examples/latency-bench/src/records.test.ts
@@ -0,0 +1,132 @@
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { computeTurnMetrics } from "./metrics.js";
+import {
+  RECORD_KEYS,
+  buildRecord,
+  phaseFor,
+  prepareOutDir,
+  writeResults,
+  type BenchMeta,
+} from "./records.js";
+import { collectEnvironment } from "./environment.js";
+import { parseBenchArgs } from "./args.js";
+
+const meta: BenchMeta = {
+  schema_version: 1,
+  source: "client-latency-bench",
+  concurrency: 1,
+  conversations: 1,
+  turns_per_conversation: 2,
+  failed_turns: 0,
+  started_at: "2026-10-20T10:00:00.000Z",
+  finished_at: "2026-10-20T10:01:00.000Z",
+  host_suspended: [],
+};
+
+describe("records", () => {
+  it("first turn of a conversation is cold, later turns are warm", () => {
+    expect([0, 1, 2].map(phaseFor)).toEqual(["cold", "warm", "warm"]);
+  });
+
+  it("record keys match the nwr BenchRecord field order", () => {
+    // Mirrors `BenchRecord` in node-webrtc-rust crates/vendor-live-support/src/bench.rs.
+    const record = buildRecord({
+      model: "default/default",
+      turnIndexInConversation: 0,
+      run: 1,
+      metrics: computeTurnMetrics({ speechEndAtMs: 0, events: [] }),
+    });
+    expect(Object.keys(record)).toEqual([...RECORD_KEYS]);
+    expect(RECORD_KEYS).toEqual([
+      "vendor",
+      "leg",
+      "transport",
+      "model",
+      "phase",
+      "text",
+      "run",
+      "http_version",
+      "metrics",
+    ]);
+    expect(Object.keys(record.metrics)).toEqual([
+      "speech_end_to_final_ms",
+      "final_to_reply_start_ms",
+      "speech_end_to_reply_start_ms",
+      "tts_first_audio_ms",
+    ]);
+  });
+
+  it("writes no transcript, session id or key into any output file", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "latency-bench-"));
+    const transcript = "one two three four";
+    const metrics = computeTurnMetrics({
+      speechEndAtMs: 0,
+      events: [
+        { event: "user_speech_final", atMs: 10, text: transcript },
+        {
+          event: "agent_speaking_start",
+          atMs: 30,
+          payload: { firstAudioMs: 7, sessionId: "sess-123" },
+        },
+      ],
+    });
+    await prepareOutDir(dir);
+    await writeResults(dir, {
+      records: [
+        buildRecord({
+          model: "default/default",
+          turnIndexInConversation: 0,
+          run: 1,
+          metrics,
+        }),
+      ],
+      meta,
+      environment: collectEnvironment("eu-test"),
+    });
+    for (const file of ["raw.jsonl", "meta.json", "environment.json"]) {
+      const text = await readFile(join(dir, file), "utf8");
+      expect(text).not.toContain("one two");
+      expect(text).not.toContain("sess-123");
+      expect(text).not.toMatch(/vthc_|Bearer/);
+    }
+    const line = JSON.parse(
+      (await readFile(join(dir, "raw.jsonl"), "utf8")).trim(),
+    );
+    expect(line.metrics.speech_end_to_reply_start_ms).toBe(30);
+  });
+
+  it("refuses to overwrite an existing raw.jsonl", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "latency-bench-"));
+    await writeFile(join(dir, "raw.jsonl"), "keep\n");
+    await expect(prepareOutDir(dir)).rejects.toThrow(/already exists/);
+    await expect(
+      writeResults(dir, { records: [], meta, environment: {} }),
+    ).rejects.toThrow();
+    expect(await readFile(join(dir, "raw.jsonl"), "utf8")).toBe("keep\n");
+  });
+});
+
+describe("parseBenchArgs", () => {
+  it("applies defaults and reads the project from the environment", () => {
+    const args = parseBenchArgs(["--out", "o", "--clip", "c.wav"], {
+      VOICETHERE_PROJECT_ID: "p",
+    });
+    expect(args).toMatchObject({ turns: 10, conversations: 1, projectId: "p" });
+  });
+
+  it("requires --out, --clip and a project", () => {
+    expect(() =>
+      parseBenchArgs(["--clip", "c"], { VOICETHERE_PROJECT_ID: "p" }),
+    ).toThrow(/--out/);
+    expect(() =>
+      parseBenchArgs(["--out", "o"], { VOICETHERE_PROJECT_ID: "p" }),
+    ).toThrow(/--clip/);
+    expect(() => parseBenchArgs(["--out", "o", "--clip", "c"], {})).toThrow(
+      /project/,
+    );
+  });
+});
diff --git a/examples/latency-bench/src/records.ts b/examples/latency-bench/src/records.ts
new file mode 100644
index 0000000..a0e2d50
--- /dev/null
+++ b/examples/latency-bench/src/records.ts
@@ -0,0 +1,105 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import type { TurnMetricValues } from "./metrics.js";
+
+/**
+ * Key order of one `raw.jsonl` line. Mirrors the `BenchRecord` struct in
+ * https://github.com/akirilyuk/node-webrtc-rust (`crates/vendor-live-support/src/bench.rs`),
+ * so the nwr summariser and compare tool read this file unchanged.
+ */
+export const RECORD_KEYS = [
+  "vendor",
+  "leg",
+  "transport",
+  "model",
+  "phase",
+  "text",
+  "run",
+  "http_version",
+  "metrics",
+] as const;
+
+export type BenchRecord = {
+  vendor: "voicethere";
+  leg: "e2e";
+  transport: "webrtc";
+  model: string;
+  phase: "cold" | "warm";
+  text: "counting-echo";
+  run: number;
+  http_version: null;
+  metrics: TurnMetricValues;
+};
+
+/** The first turn of a conversation is cold (new session, new connections); later turns are warm. */
+export function phaseFor(turnIndexInConversation: number): "cold" | "warm" {
+  return turnIndexInConversation === 0 ? "cold" : "warm";
+}
+
+export function buildRecord(input: {
+  model: string;
+  turnIndexInConversation: number;
+  run: number;
+  metrics: TurnMetricValues;
+}): BenchRecord {
+  return {
+    vendor: "voicethere",
+    leg: "e2e",
+    transport: "webrtc",
+    model: input.model,
+    phase: phaseFor(input.turnIndexInConversation),
+    text: "counting-echo",
+    run: input.run,
+    http_version: null,
+    metrics: input.metrics,
+  };
+}
+
+export type BenchMeta = {
+  schema_version: 1;
+  source: "client-latency-bench";
+  concurrency: 1;
+  conversations: number;
+  turns_per_conversation: number;
+  failed_turns: number;
+  started_at: string;
+  finished_at: string;
+  host_suspended: { at: string; gap_ms: number }[];
+};
+
+export const RAW_FILE = "raw.jsonl";
+
+/** Throws when `raw.jsonl` already exists in `dir`; creates `dir` otherwise. */
+export async function prepareOutDir(dir: string): Promise<void> {
+  if (existsSync(join(dir, RAW_FILE))) {
+    throw new Error(
+      `${join(dir, RAW_FILE)} already exists; choose a new --out directory`,
+    );
+  }
+  await mkdir(dir, { recursive: true });
+}
+
+export async function writeResults(
+  dir: string,
+  results: {
+    records: BenchRecord[];
+    meta: BenchMeta;
+    environment: Record<string, unknown>;
+  },
+): Promise<void> {
+  const lines = results.records.map((r) => JSON.stringify(r)).join("\n");
+  // "wx" fails if the file appeared since prepareOutDir: never overwrite a result.
+  await writeFile(join(dir, RAW_FILE), lines ? `${lines}\n` : "", {
+    flag: "wx",
+  });
+  await writeFile(
+    join(dir, "meta.json"),
+    `${JSON.stringify(results.meta, null, 2)}\n`,
+  );
+  await writeFile(
+    join(dir, "environment.json"),
+    `${JSON.stringify(results.environment, null, 2)}\n`,
+  );
+}
diff --git a/examples/latency-bench/src/run.ts b/examples/latency-bench/src/run.ts
new file mode 100644
index 0000000..9df3e4e
--- /dev/null
+++ b/examples/latency-bench/src/run.ts
@@ -0,0 +1,227 @@
+/**
+ * End-to-end turn latency against your own deployed VoiceThere agent.
+ *
+ *   VOICETHERE_CLIENT_API_KEY=vthc_… VOICETHERE_PROJECT_ID=<uuid> \
+ *     npx tsx examples/latency-bench/src/run.ts --clip counting.wav --out results/my-run
+ *
+ * See ../README.md. Output files: raw.jsonl, meta.json, environment.json.
+ */
+import { readFile } from "node:fs/promises";
+
+import {
+  connectBrowserVoiceSession,
+  createNodeWebRtcRuntime,
+  startSession,
+  type BrowserVoiceSession,
+} from "../../../src/node/index.js";
+import { parseBenchArgs, type BenchArgs } from "./args.js";
+import { collectEnvironment } from "./environment.js";
+import {
+  computeTurnMetrics,
+  parseSpeechEvent,
+  type SpeechEventRecord,
+} from "./metrics.js";
+import { PacedMicPump, type PumpTrack } from "./pacing.js";
+import {
+  buildRecord,
+  prepareOutDir,
+  writeResults,
+  type BenchMeta,
+  type BenchRecord,
+} from "./records.js";
+import { SuspendWatch } from "./suspend-watch.js";
+import { clipToFrames, decodeWav } from "./wav.js";
+
+/** Quiet time before a turn so the voice activity detector sees silence first. */
+const LEAD_SILENCE_MS = 1000;
+/** Quiet time after a reply before the next turn. */
+const TAIL_SILENCE_MS = 1500;
+const CONNECT_TIMEOUT_MS = 60_000;
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+const now = () => performance.now();
+
+async function waitFor(
+  predicate: () => boolean,
+  timeoutMs: number,
+): Promise<boolean> {
+  const deadline = now() + timeoutMs;
+  while (now() < deadline) {
+    if (predicate()) return true;
+    await sleep(25);
+  }
+  return predicate();
+}
+
+function micTrack(session: BrowserVoiceSession): PumpTrack {
+  const track = session.getMicStream()?.getAudioTracks()[0] as unknown as
+    PumpTrack | undefined;
+  if (!track || typeof track.writeSample !== "function") {
+    throw new Error(
+      "mic track has no writeSample (Node WebRTC runtime needed)",
+    );
+  }
+  return track;
+}
+
+async function runConversation(
+  args: BenchArgs,
+  apiKey: string,
+  frames: Uint8Array[],
+  firstRun: number,
+  records: BenchRecord[],
+): Promise<number> {
+  const events: SpeechEventRecord[] = [];
+  const provision = await startSession({
+    apiBase: args.apiBase,
+    projectId: args.projectId,
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!provision.ok) {
+    throw new Error(`could not start a session: ${provision.code}`);
+  }
+
+  const session = await connectBrowserVoiceSession({
+    credentials: provision.credentials,
+    runtime: createNodeWebRtcRuntime(),
+    requestMic: true,
+    // We own writeSample on the mic track: the pump below is the only writer.
+    micPump: "external",
+    onControlMessage: (message) => {
+      const event = parseSpeechEvent(message, now());
+      if (event) events.push(event);
+    },
+  });
+  const pump = new PacedMicPump(micTrack(session));
+  let failed = 0;
+  try {
+    // RTP must flow before the connection reaches "connected".
+    pump.start();
+    await session.waitForConnected(CONNECT_TIMEOUT_MS);
+    // Let a greeting from the agent finish before the first turn.
+    await sleep(2000);
+    await waitFor(() => !agentIsSpeaking(events), 15_000);
+
+    for (let turn = 0; turn < args.turns; turn++) {
+      await sleep(LEAD_SILENCE_MS);
+      const startIndex = events.length;
+      const speechEndAtMs = await pump.play(frames);
+      const answered = await waitFor(
+        () => replyStarted(events.slice(startIndex)),
+        args.turnTimeoutMs,
+      );
+      const metrics = computeTurnMetrics({
+        speechEndAtMs,
+        events: events.slice(startIndex),
+      });
+      if (!answered) failed += 1;
+      else {
+        records.push(
+          buildRecord({
+            model: args.model,
+            turnIndexInConversation: turn,
+            run: firstRun + turn,
+            metrics,
+          }),
+        );
+      }
+      console.log(
+        `turn ${turn + 1}/${args.turns}: ` +
+          (answered
+            ? `speech_end_to_reply_start_ms=${Math.round(metrics.speech_end_to_reply_start_ms ?? NaN)}`
+            : "no reply"),
+      );
+      // Wait for the reply to finish so it does not overlap the next turn.
+      await waitFor(() => !agentIsSpeaking(events), args.turnTimeoutMs);
+      await sleep(TAIL_SILENCE_MS);
+    }
+  } finally {
+    await pump.stop();
+    await session.disconnectAsync().catch(() => undefined);
+  }
+  return failed;
+}
+
+function replyStarted(events: SpeechEventRecord[]): boolean {
+  const metrics = computeTurnMetrics({ speechEndAtMs: null, events });
+  return metrics.final_to_reply_start_ms != null;
+}
+
+function agentIsSpeaking(events: SpeechEventRecord[]): boolean {
+  const last = events
+    .filter(
+      (e) =>
+        e.event === "agent_speaking_start" || e.event === "agent_speaking_end",
+    )
+    .at(-1);
+  return last?.event === "agent_speaking_start";
+}
+
+async function main(): Promise<void> {
+  const args = parseBenchArgs(process.argv.slice(2));
+  const apiKey = process.env.VOICETHERE_CLIENT_API_KEY;
+  if (!apiKey) throw new Error("set VOICETHERE_CLIENT_API_KEY (a vthc_ key)");
+
+  await prepareOutDir(args.out);
+  const frames = clipToFrames(
+    decodeWav(new Uint8Array(await readFile(args.clip))),
+  );
+  const watch = new SuspendWatch();
+  watch.start();
+
+  const records: BenchRecord[] = [];
+  const startedAt = new Date();
+  let failedTurns = 0;
+  for (let c = 0; c < args.conversations; c++) {
+    console.log(`conversation ${c + 1}/${args.conversations}`);
+    try {
+      failedTurns += await runConversation(
+        args,
+        apiKey,
+        frames,
+        c * args.turns + 1,
+        records,
+      );
+    } catch (error) {
+      failedTurns += args.turns;
+      console.error(
+        `conversation ${c + 1} failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+  watch.stop();
+
+  const meta: BenchMeta = {
+    schema_version: 1,
+    source: "client-latency-bench",
+    concurrency: 1,
+    conversations: args.conversations,
+    turns_per_conversation: args.turns,
+    failed_turns: failedTurns,
+    started_at: startedAt.toISOString(),
+    finished_at: new Date().toISOString(),
+    host_suspended: watch.gaps,
+  };
+  await writeResults(args.out, {
+    records,
+    meta,
+    environment: collectEnvironment(args.region),
+  });
+  console.log(
+    `wrote ${records.length} records to ${args.out} (${failedTurns} failed turns)`,
+  );
+  if (watch.suspended) {
+    console.log("[host-suspended] result: inconclusive");
+    process.exitCode = 3;
+  } else if (records.length === 0) {
+    process.exitCode = 1;
+  }
+}
+
+main().then(
+  () => process.exit(process.exitCode ?? 0),
+  (error: unknown) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  },
+);
diff --git a/examples/latency-bench/src/suspend-watch.test.ts b/examples/latency-bench/src/suspend-watch.test.ts
new file mode 100644
index 0000000..b486f6a
--- /dev/null
+++ b/examples/latency-bench/src/suspend-watch.test.ts
@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+
+import { SuspendWatch } from "./suspend-watch.js";
+
+describe("SuspendWatch", () => {
+  it("records a gap where the wall clock ran but the monotonic clock did not", () => {
+    let wall = 1_000_000;
+    let mono = 5_000;
+    const watch = new SuspendWatch(
+      () => wall,
+      () => mono,
+      5000,
+    );
+    wall += 1000;
+    mono += 1000;
+    watch.tick();
+    expect(watch.suspended).toBe(false);
+    wall += 60_000; // asleep for a minute
+    mono += 1000;
+    watch.tick();
+    expect(watch.gaps).toEqual([
+      { at: new Date(wall).toISOString(), gap_ms: 59_000 },
+    ]);
+    expect(watch.suspended).toBe(true);
+  });
+
+  it("does not flag a blocked event loop (both clocks advance)", () => {
+    let wall = 0;
+    let mono = 0;
+    const watch = new SuspendWatch(
+      () => wall,
+      () => mono,
+      5000,
+    );
+    wall += 20_000;
+    mono += 20_000;
+    watch.tick();
+    expect(watch.suspended).toBe(false);
+  });
+});
diff --git a/examples/latency-bench/src/suspend-watch.ts b/examples/latency-bench/src/suspend-watch.ts
new file mode 100644
index 0000000..452fe7e
--- /dev/null
+++ b/examples/latency-bench/src/suspend-watch.ts
@@ -0,0 +1,59 @@
+/**
+ * Notices that the machine was asleep during a run. A laptop that sleeps in the middle of a
+ * turn produces a huge "latency" that says nothing about the service.
+ *
+ * Once a second it compares the wall clock (keeps running while asleep) with the monotonic
+ * clock (stops while asleep on macOS and Linux). A blocked event loop moves both clocks
+ * alike, so only a real suspend shows up as a difference of more than `gapThresholdMs`.
+ */
+
+/** `at` is an ISO timestamp (the nwr summariser prints it); `gap_ms` the time asleep. */
+export type SuspendGap = { at: string; gap_ms: number };
+
+export class SuspendWatch {
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private lastWall: number;
+  private lastMono: number;
+  readonly gaps: SuspendGap[] = [];
+
+  constructor(
+    private readonly wall: () => number = Date.now,
+    private readonly mono: () => number = () => performance.now(),
+    private readonly gapThresholdMs = 5000,
+  ) {
+    this.lastWall = wall();
+    this.lastMono = mono();
+  }
+
+  /** One tick. Public so tests can drive it with fake clocks. */
+  tick(): void {
+    const wall = this.wall();
+    const mono = this.mono();
+    const gap = wall - this.lastWall - (mono - this.lastMono);
+    if (gap > this.gapThresholdMs) {
+      this.gaps.push({
+        at: new Date(wall).toISOString(),
+        gap_ms: Math.round(gap),
+      });
+    }
+    this.lastWall = wall;
+    this.lastMono = mono;
+  }
+
+  start(intervalMs = 1000): void {
+    if (this.timer) return;
+    this.lastWall = this.wall();
+    this.lastMono = this.mono();
+    this.timer = setInterval(() => this.tick(), intervalMs);
+    this.timer.unref();
+  }
+
+  stop(): void {
+    if (this.timer) clearInterval(this.timer);
+    this.timer = null;
+  }
+
+  get suspended(): boolean {
+    return this.gaps.length > 0;
+  }
+}
diff --git a/examples/latency-bench/src/wav.test.ts b/examples/latency-bench/src/wav.test.ts
new file mode 100644
index 0000000..f87cfa5
--- /dev/null
+++ b/examples/latency-bench/src/wav.test.ts
@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+
+import { FRAME_BYTES } from "./pacing.js";
+import { clipToFrames, decodeWav } from "./wav.js";
+
+function wav(rate: number, channels: number, samples: number[]): Uint8Array {
+  const data = new Uint8Array(samples.length * 2);
+  const dv = new DataView(data.buffer);
+  samples.forEach((s, i) => dv.setInt16(i * 2, s, true));
+  const out = new Uint8Array(44 + data.length);
+  const v = new DataView(out.buffer);
+  out.set(new TextEncoder().encode("RIFF"), 0);
+  v.setUint32(4, 36 + data.length, true);
+  out.set(new TextEncoder().encode("WAVEfmt "), 8);
+  v.setUint32(16, 16, true);
+  v.setUint16(20, 1, true);
+  v.setUint16(22, channels, true);
+  v.setUint32(24, rate, true);
+  v.setUint32(28, rate * channels * 2, true);
+  v.setUint16(32, channels * 2, true);
+  v.setUint16(34, 16, true);
+  out.set(new TextEncoder().encode("data"), 36);
+  v.setUint32(40, data.length, true);
+  out.set(data, 44);
+  return out;
+}
+
+describe("wav", () => {
+  it("turns 16 kHz mono into 20 ms 48 kHz stereo frames", () => {
+    const samples = Array.from({ length: 16_000 }, (_, i) =>
+      i % 2 ? 1000 : -1000,
+    );
+    const frames = clipToFrames(decodeWav(wav(16_000, 1, samples)));
+    expect(frames).toHaveLength(50); // 1 s / 20 ms
+    expect(frames.every((f) => f.byteLength === FRAME_BYTES)).toBe(true);
+  });
+
+  it("normalises the peak and writes both channels alike", () => {
+    const frames = clipToFrames(decodeWav(wav(48_000, 1, [0, 500, -500, 0])));
+    const dv = new DataView(frames[0]!.buffer);
+    expect(Math.abs(dv.getInt16(4, true))).toBeGreaterThan(29_000);
+    expect(dv.getInt16(4, true)).toBe(dv.getInt16(6, true));
+  });
+
+  it("rejects non-WAV and non-16-bit input", () => {
+    expect(() => decodeWav(new Uint8Array(20))).toThrow(/WAVE/);
+    const bad = wav(16_000, 1, [1, 2]);
+    new DataView(bad.buffer).setUint16(34, 8, true);
+    expect(() => decodeWav(bad)).toThrow(/16-bit/);
+  });
+});
diff --git a/examples/latency-bench/src/wav.ts b/examples/latency-bench/src/wav.ts
new file mode 100644
index 0000000..0df1d19
--- /dev/null
+++ b/examples/latency-bench/src/wav.ts
@@ -0,0 +1,106 @@
+import { FRAME_BYTES } from "./pacing.js";
+
+const TARGET_RATE = 48_000;
+/** -1 dBFS, like the nwr bench, so a quiet clip still passes the voice activity gate. */
+const TARGET_PEAK = Math.round(32767 * 0.891);
+
+export type DecodedWav = {
+  sampleRate: number;
+  channels: number;
+  /** Interleaved s16 samples. */
+  samples: Int16Array;
+};
+
+/** Reads a 16-bit PCM WAV (mono or stereo, any sample rate). Throws on anything else. */
+export function decodeWav(bytes: Uint8Array): DecodedWav {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tag = (offset: number) =>
+    String.fromCharCode(...bytes.subarray(offset, offset + 4));
+  if (bytes.byteLength < 12 || tag(0) !== "RIFF" || tag(8) !== "WAVE") {
+    throw new Error("clip is not a RIFF/WAVE file");
+  }
+  let format: {
+    code: number;
+    channels: number;
+    rate: number;
+    bits: number;
+  } | null = null;
+  let offset = 12;
+  while (offset + 8 <= bytes.byteLength) {
+    const id = tag(offset);
+    const size = view.getUint32(offset + 4, true);
+    const body = offset + 8;
+    if (id === "fmt ") {
+      format = {
+        code: view.getUint16(body, true),
+        channels: view.getUint16(body + 2, true),
+        rate: view.getUint32(body + 4, true),
+        bits: view.getUint16(body + 14, true),
+      };
+    } else if (id === "data") {
+      if (!format) throw new Error("WAV data chunk before fmt chunk");
+      const isPcm = format.code === 1 || format.code === 0xfffe;
+      if (!isPcm || format.bits !== 16) {
+        throw new Error("clip must be 16-bit PCM");
+      }
+      if (format.channels !== 1 && format.channels !== 2) {
+        throw new Error("clip must be mono or stereo");
+      }
+      const length = Math.min(size, bytes.byteLength - body);
+      const count = Math.floor(length / 2);
+      const samples = new Int16Array(count);
+      for (let i = 0; i < count; i++)
+        samples[i] = view.getInt16(body + i * 2, true);
+      return { sampleRate: format.rate, channels: format.channels, samples };
+    }
+    offset = body + size + (size % 2);
+  }
+  throw new Error("WAV has no data chunk");
+}
+
+/**
+ * Converts a decoded clip to 48 kHz interleaved stereo s16le (what the mic track takes),
+ * peak-normalised to -1 dBFS, cut into 20 ms frames. The last frame is padded with zeros.
+ */
+export function clipToFrames(wav: DecodedWav): Uint8Array[] {
+  const inFrames = Math.floor(wav.samples.length / wav.channels);
+  const mono = new Float64Array(inFrames);
+  for (let i = 0; i < inFrames; i++) {
+    let sum = 0;
+    for (let c = 0; c < wav.channels; c++)
+      sum += wav.samples[i * wav.channels + c]!;
+    mono[i] = sum / wav.channels;
+  }
+  const outFrames = Math.floor((inFrames * TARGET_RATE) / wav.sampleRate);
+  const resampled = new Float64Array(outFrames);
+  const step = wav.sampleRate / TARGET_RATE;
+  let peak = 0;
+  for (let i = 0; i < outFrames; i++) {
+    const pos = i * step;
+    const lo = Math.floor(pos);
+    const hi = Math.min(lo + 1, inFrames - 1);
+    const frac = pos - lo;
+    const value = mono[lo]! * (1 - frac) + mono[hi]! * frac;
+    resampled[i] = value;
+    peak = Math.max(peak, Math.abs(value));
+  }
+  const gain = peak > 0 ? TARGET_PEAK / peak : 1;
+
+  const bytesTotal = outFrames * 4;
+  const frameCount = Math.max(1, Math.ceil(bytesTotal / FRAME_BYTES));
+  const frames: Uint8Array[] = [];
+  for (let f = 0; f < frameCount; f++) {
+    const frame = new Uint8Array(FRAME_BYTES);
+    const view = new DataView(frame.buffer);
+    const samplesPerFrame = FRAME_BYTES / 4;
+    for (let i = 0; i < samplesPerFrame; i++) {
+      const value = resampled[f * samplesPerFrame + i];
+      if (value === undefined) break;
+      const s = Math.max(-32768, Math.min(32767, Math.round(value * gain)));
+      view.setInt16(i * 4, s, true);
+      view.setInt16(i * 4 + 2, s, true);
+    }
+    frames.push(frame);
+  }
+  return frames;
+}
diff --git a/package.json b/package.json
index 519c66b..05f84f3 100644
--- a/package.json
+++ b/package.json
@@ -35,6 +35,7 @@
     "test:ci": "npm run typecheck && npm run test && npm run build",
     "demo:local": "tsx examples/local-connect.ts",
     "demo:cloud": "tsx examples/cloud-connect.ts",
+    "bench:latency": "tsx examples/latency-bench/src/run.ts",
     "demo:browser": "vite --config examples/browser-test/vite.config.ts"
   },
   "repository": {