diff --git a/.gitignore b/.gitignore
index 9db812842d..79159e264b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,6 +22,7 @@ src/assets/
 *debug*.txt
 eslint_out.txt
 tests/perf/output/
+tests/load/results/
 
 # Locally built Go binary (gen-maps uses `go run .`)
 map-generator/map-generator
diff --git a/eslint.config.js b/eslint.config.js
index 3ac29c3e3a..d0e3f8090f 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -33,6 +33,7 @@ export default [
             "__mocks__/fileMock.js",
             "eslint.config.js",
             "scripts/sync-assets.mjs",
+            "tests/load/*.mjs",
             "tests/matchmaking/*.mjs",
           ],
         },
diff --git a/package.json b/package.json
index d33064e650..3f35a9cf7b 100644
--- a/package.json
+++ b/package.json
@@ -5,7 +5,10 @@
     "build-prod": "concurrently --kill-others-on-fail \"tsc --noEmit\" \"vite build\"",
     "start:client": "vite",
     "start:server": "tsx src/server/Server.ts",
+    "start:server:bun": "bun src/server/Server.ts",
     "start:server-dev": "cross-env GAME_ENV=dev NUM_WORKERS=2 TURNSTILE_SITE_KEY=1x00000000000000000000AA API_KEY=WARNING_DEV_API_KEY_DO_NOT_USE_IN_PRODUCTION ADMIN_BOT_API_KEY=WARNING_DEV_ADMIN_BOT_KEY_DO_NOT_USE_IN_PRODUCTION DOMAIN=localhost GIT_COMMIT=DEV tsx src/server/Server.ts",
+    "start:server-dev:bun": "cross-env GAME_ENV=dev NUM_WORKERS=2 TURNSTILE_SITE_KEY=1x00000000000000000000AA API_KEY=WARNING_DEV_API_KEY_DO_NOT_USE_IN_PRODUCTION ADMIN_BOT_API_KEY=WARNING_DEV_ADMIN_BOT_KEY_DO_NOT_USE_IN_PRODUCTION DOMAIN=localhost GIT_COMMIT=DEV bun src/server/Server.ts",
+    "dev:bun": "cross-env GAME_ENV=dev concurrently \"npm run start:client\" \"npm run start:server-dev:bun\"",
     "dev": "cross-env GAME_ENV=dev concurrently \"npm run start:client\" \"npm run start:server-dev\"",
     "dev:host": "cross-env GAME_ENV=dev VITE_HOST=lan concurrently \"npm run start:client\" \"npm run start:server-dev\"",
     "dev:staging": "cross-env GAME_ENV=dev API_DOMAIN=api.openfront.dev concurrently \"npm run start:client\" \"npm run start:server-dev\"",
@@ -13,6 +16,9 @@
     "docs:map-generator": "cd map-generator && go doc -cmd -u -all",
     "tunnel": "npm run build-prod && npm run start:server",
     "test": "vitest run && vitest run tests/server",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:e2e:bun": "cross-env E2E_RUNTIME=bun vitest run --config vitest.e2e.config.ts",
+    "perf:server": "node tests/load/loadtest.mjs",
     "test:matchmaking": "node tests/matchmaking/contained.mjs",
     "test:matchmaking:e2e": "node tests/matchmaking/e2e.mjs",
     "test:matchmaking:cancel": "node tests/matchmaking/e2e-cancel.mjs",
diff --git a/src/server/Worker.ts b/src/server/Worker.ts
index aa17d86230..576fc443e4 100644
--- a/src/server/Worker.ts
+++ b/src/server/Worker.ts
@@ -47,6 +47,16 @@ const playlist = new MapPlaylist();
 export async function startWorker() {
   log.info(`Worker starting...`);
 
+  // Exit when the IPC channel to the master closes. Node's cluster workers
+  // already die with the master; Bun's do not — an orphaned worker would
+  // keep its port bound (SO_REUSEPORT) and serve stale state next to the
+  // restarted server's workers. Explicit exit makes the lifecycle identical
+  // on both runtimes.
+  process.on("disconnect", () => {
+    log.info("IPC channel to master closed, shutting down worker");
+    process.exit(0);
+  });
+
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = path.dirname(__filename);
 
diff --git a/src/server/WorkerLobbyService.ts b/src/server/WorkerLobbyService.ts
index 01e34572dd..ebbd69cd7f 100644
--- a/src/server/WorkerLobbyService.ts
+++ b/src/server/WorkerLobbyService.ts
@@ -127,7 +127,13 @@ export class WorkerLobbyService {
   }
 
   private sendToMaster(msg: WorkerReady | WorkerLobbyList) {
-    process.send?.(msg);
+    // On Node a closed IPC channel makes process.send return false; on Bun
+    // it throws instead. Treat both as "master is gone, drop the message".
+    try {
+      process.send?.(msg);
+    } catch (error) {
+      this.log.warn(`Failed to send IPC message to master: ${error}`);
+    }
   }
 
   private sendMyLobbiesToMaster() {
diff --git a/tests/e2e/GameFlow.test.ts b/tests/e2e/GameFlow.test.ts
new file mode 100644
index 0000000000..0664285a4b
--- /dev/null
+++ b/tests/e2e/GameFlow.test.ts
@@ -0,0 +1,238 @@
+// End-to-end test of the game server over real HTTP + WebSocket: boots the
+// actual master + cluster workers (Node via tsx, or Bun with
+// E2E_RUNTIME=bun) and drives the full lobby -> start -> turn-relay ->
+// rejoin -> kick flow that production clients exercise.
+
+import { randomUUID } from "crypto";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import {
+  createGame,
+  gameInfo,
+  RUNTIME,
+  sleep,
+  TestClient,
+  TestServer,
+  waitFor,
+} from "./util";
+
+describe(`game server e2e (runtime: ${RUNTIME})`, () => {
+  const server = new TestServer();
+  const creatorToken = randomUUID();
+  let game: { gameID: string; workerIndex: number; port: number };
+  let creator: TestClient;
+  let playerB: TestClient;
+  let playerC: TestClient;
+
+  beforeAll(async () => {
+    await server.start();
+    game = await createGame(creatorToken);
+    creator = new TestClient(game.port, game.gameID, "creator", creatorToken);
+    playerB = new TestClient(game.port, game.gameID, "playerB");
+    playerC = new TestClient(game.port, game.gameID, "playerC");
+  });
+
+  afterAll(async () => {
+    for (const c of [creator, playerB, playerC]) c?.close();
+    await server.stop();
+  });
+
+  test("health endpoint reports ok once workers are ready", async () => {
+    const res = await fetch("http://127.0.0.1:3000/api/health");
+    expect(res.ok).toBe(true);
+    expect(await res.json()).toEqual({ status: "ok" });
+  });
+
+  test("create_game requires an auth token", async () => {
+    const res = await fetch(`http://127.0.0.1:${game.port}/api/create_game`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+    });
+    expect(res.status).toBe(400);
+  });
+
+  test("created game is queryable on its worker", async () => {
+    const info = await gameInfo(game.port, game.gameID);
+    expect(info).not.toBeNull();
+    expect(info.gameID).toBe(game.gameID);
+    expect(info.gameConfig.gameType).toBe("Private");
+  });
+
+  test("clients join over WebSocket and get server-assigned clientIDs", async () => {
+    await creator.join();
+    await playerB.join();
+    await playerC.join();
+    expect(creator.clientID).toBeTruthy();
+    expect(playerB.clientID).toBeTruthy();
+    expect(playerC.clientID).toBeTruthy();
+    // All three ids are distinct.
+    expect(
+      new Set([creator.clientID, playerB.clientID, playerC.clientID]).size,
+    ).toBe(3);
+
+    // Lobby info converges to 3 clients for everyone.
+    await waitFor(
+      async () => {
+        const info = await gameInfo(game.port, game.gameID);
+        return info?.clients?.length === 3;
+      },
+      10_000,
+      "lobby to report 3 clients",
+    );
+  });
+
+  test("lobby identifies the creator", async () => {
+    const info = await gameInfo(game.port, game.gameID);
+    expect(info.lobbyCreatorClientID).toBe(creator.clientID);
+  });
+
+  test("non-creator cannot start the game", async () => {
+    playerB.sendIntent({ type: "toggle_game_start_timer" });
+    await sleep(1500);
+    const info = await gameInfo(game.port, game.gameID);
+    expect(info.startsAt ?? undefined).toBeUndefined();
+  });
+
+  test("creator starts the game; every client receives prestart and start", async () => {
+    creator.sendIntent({ type: "toggle_game_start_timer" });
+    for (const c of [creator, playerB, playerC]) {
+      await c.waitForMessage((m) => m.type === "prestart", 15_000);
+      const start = (await c.waitForMessage(
+        (m) => m.type === "start",
+        15_000,
+      )) as any;
+      expect(start.gameStartInfo.gameID).toBe(game.gameID);
+      expect(start.gameStartInfo.players).toHaveLength(3);
+      expect(start.myClientID).toBe(c.clientID);
+      const usernames = start.gameStartInfo.players.map((p: any) => p.username);
+      expect(usernames).toEqual(
+        expect.arrayContaining(["creator", "playerB", "playerC"]),
+      );
+    }
+  });
+
+  test("server broadcasts turns at the 100ms tick", async () => {
+    const before = creator.turns().length;
+    await sleep(1200);
+    const after = creator.turns().length;
+    const gained = after - before;
+    // ~12 expected; allow generous slack for CI jitter.
+    expect(gained).toBeGreaterThanOrEqual(8);
+    expect(gained).toBeLessThanOrEqual(16);
+    // Turn numbers are consecutive.
+    const numbers = creator.turns().map((t) => t.turn.turnNumber);
+    for (let i = 1; i < numbers.length; i++) {
+      expect(numbers[i]).toBe(numbers[i - 1] + 1);
+    }
+  });
+
+  test("an intent is relayed to every client, stamped with the sender's clientID", async () => {
+    const marker = 987654321; // distinctive troops value to find the intent
+    playerB.sendIntent({ type: "attack", targetID: null, troops: marker });
+    for (const c of [creator, playerB, playerC]) {
+      const turnMsg = (await c.waitForMessage(
+        (m) =>
+          m.type === "turn" &&
+          (m as any).turn.intents.some((i: any) => i.troops === marker),
+        5_000,
+      )) as any;
+      const intent = turnMsg.turn.intents.find((i: any) => i.troops === marker);
+      // The clientID comes from the authenticated connection, not the payload.
+      expect(intent.clientID).toBe(playerB.clientID);
+    }
+  });
+
+  test("a client that vanishes can rejoin and receives the missed turns", async () => {
+    // Hard-drop C's socket (no close frame ≈ network loss).
+    playerC.ws!.terminate();
+    await sleep(600);
+    const lastTurn =
+      playerC.turns().length === 0
+        ? 0
+        : playerC.turns()[playerC.turns().length - 1].turn.turnNumber + 1;
+
+    const rejoined = new TestClient(
+      game.port,
+      game.gameID,
+      "playerC",
+      playerC.token,
+    );
+    await rejoined.connect();
+    rejoined.send({
+      type: "rejoin",
+      gameID: game.gameID,
+      lastTurn,
+      token: playerC.token,
+    });
+    const start = (await rejoined.waitForMessage(
+      (m) => m.type === "start",
+      10_000,
+    )) as any;
+    // The catch-up slice starts exactly where the client left off.
+    expect(start.gameStartInfo.gameID).toBe(game.gameID);
+    if (start.turns.length > 0) {
+      expect(start.turns[0].turnNumber).toBe(lastTurn);
+    }
+    // Same identity as before the drop.
+    expect(start.myClientID).toBe(playerC.clientID);
+    playerC = rejoined;
+    playerC.clientID = start.myClientID;
+  });
+
+  test("a client sending garbage is kicked with a reason", async () => {
+    const victim = new TestClient(game.port, game.gameID, "victim");
+    await victim.join();
+    victim.ws!.send("this is not json");
+    await victim.waitForMessage(
+      (m) => m.type === "error" && (m as any).error.includes("invalid_message"),
+      5_000,
+    );
+    await waitFor(
+      () => victim.closeCode !== null,
+      5_000,
+      "victim socket to close",
+    );
+    expect(victim.closeCode).toBe(1000);
+
+    // Kicked identity cannot rejoin.
+    const comeback = new TestClient(
+      game.port,
+      game.gameID,
+      "victim",
+      victim.token,
+    );
+    await comeback.connect();
+    comeback.send({
+      type: "join",
+      token: comeback.token,
+      gameID: game.gameID,
+      username: "victim",
+      clanTag: null,
+      turnstileToken: null,
+    });
+    await waitFor(
+      () => comeback.closeCode !== null,
+      5_000,
+      "kicked rejoin to be rejected",
+    );
+    expect(comeback.closeCode).toBe(1002);
+  });
+
+  test("games on the wrong worker are rejected", async () => {
+    // Join a game that lives on worker A via worker B's port: the message
+    // is dropped (no lobby_info ever arrives).
+    const wrongPort = game.port === 3001 ? 3002 : 3001;
+    const lost = new TestClient(wrongPort, game.gameID, "lostsoul");
+    await lost.connect();
+    lost.send({
+      type: "join",
+      token: lost.token,
+      gameID: game.gameID,
+      username: "lostsoul",
+      clanTag: null,
+      turnstileToken: null,
+    });
+    await sleep(1500);
+    expect(lost.messages.find((m) => m.type === "lobby_info")).toBeUndefined();
+    lost.close();
+  });
+});
diff --git a/tests/e2e/WorkerLifecycle.test.ts b/tests/e2e/WorkerLifecycle.test.ts
new file mode 100644
index 0000000000..5f31a31f2c
--- /dev/null
+++ b/tests/e2e/WorkerLifecycle.test.ts
@@ -0,0 +1,50 @@
+// Regression test for the cluster worker lifecycle: when the master dies,
+// every worker must exit too. Node's cluster does this implicitly; Bun's
+// does not, which orphaned workers that kept their ports bound (via
+// SO_REUSEPORT) and served stale state next to a restarted server. Worker.ts
+// now exits explicitly on IPC disconnect — this test pins that behavior on
+// both runtimes.
+
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { RUNTIME, TestServer, waitFor } from "./util";
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+describe(`worker lifecycle (runtime: ${RUNTIME})`, () => {
+  const server = new TestServer();
+
+  beforeAll(async () => {
+    await server.start();
+  });
+
+  afterAll(async () => {
+    await server.stop();
+  });
+
+  test("workers exit when the master is killed", async () => {
+    const workerPids = server.workerPids();
+    expect(workerPids.length).toBeGreaterThanOrEqual(2);
+    for (const pid of workerPids) {
+      expect(pidAlive(pid)).toBe(true);
+    }
+
+    const masterPid = server.masterPid();
+    expect(masterPid).not.toBeNull();
+    // SIGKILL: the harshest case — no signal handler can run, only the IPC
+    // channel closing tells the workers their master is gone.
+    process.kill(masterPid!, "SIGKILL");
+
+    await waitFor(
+      () => workerPids.every((pid) => !pidAlive(pid)),
+      10_000,
+      `workers ${workerPids.join(",")} to exit after master SIGKILL`,
+    );
+  });
+});
diff --git a/tests/e2e/util.ts b/tests/e2e/util.ts
new file mode 100644
index 0000000000..de656710fc
--- /dev/null
+++ b/tests/e2e/util.ts
@@ -0,0 +1,281 @@
+// Helpers for e2e tests that boot the real game server (master + cluster
+// workers) as a child process and drive it over HTTP + WebSocket.
+//
+// The server runtime is selectable via E2E_RUNTIME=node|bun (default node),
+// so the same suite verifies both the tsx/Node deployment and the Bun one.
+
+import { ChildProcess, spawn } from "child_process";
+import { randomUUID } from "crypto";
+import path from "path";
+import WebSocket from "ws";
+import type { ServerMessage } from "../../src/core/Schemas";
+
+export const MASTER_PORT = 3000;
+export const NUM_WORKERS = 2;
+export const RUNTIME = process.env.E2E_RUNTIME === "bun" ? "bun" : "node";
+
+const repoRoot = path.resolve(__dirname, "../..");
+
+export const workerPort = (i: number) => 3001 + i;
+
+const serverEnv = {
+  ...process.env,
+  GAME_ENV: "dev",
+  NUM_WORKERS: String(NUM_WORKERS),
+  TURNSTILE_SITE_KEY: "1x00000000000000000000AA",
+  API_KEY: "WARNING_DEV_API_KEY_DO_NOT_USE_IN_PRODUCTION",
+  ADMIN_BOT_API_KEY: "WARNING_DEV_ADMIN_BOT_KEY_DO_NOT_USE_IN_PRODUCTION",
+  DOMAIN: "localhost",
+  GIT_COMMIT: "DEV",
+};
+
+function serverCommand(): [string, string[]] {
+  if (RUNTIME === "bun") {
+    return ["bun", ["src/server/Server.ts"]];
+  }
+  return ["npx", ["tsx", "src/server/Server.ts"]];
+}
+
+export const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+export async function waitFor(
+  fn: () => boolean | Promise<boolean>,
+  timeoutMs: number,
+  label: string,
+): Promise<void> {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    if (await fn()) return;
+    if (Date.now() > deadline) {
+      throw new Error(`Timed out after ${timeoutMs}ms waiting for: ${label}`);
+    }
+    await sleep(200);
+  }
+}
+
+async function portServesHttp(port: number): Promise<boolean> {
+  try {
+    await fetch(`http://127.0.0.1:${port}/`, {
+      signal: AbortSignal.timeout(1000),
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export class TestServer {
+  proc: ChildProcess | null = null;
+  logs: string[] = [];
+
+  async start(): Promise<void> {
+    // Fail fast if a stray server is already bound to our ports — under
+    // Bun's cluster (SO_REUSEPORT) a stray would silently absorb traffic.
+    for (let p = MASTER_PORT; p <= workerPort(NUM_WORKERS - 1); p++) {
+      if (await portServesHttp(p)) {
+        throw new Error(`port ${p} already serving HTTP; kill strays first`);
+      }
+    }
+    const [cmd, args] = serverCommand();
+    this.proc = spawn(cmd, args, {
+      cwd: repoRoot,
+      env: serverEnv,
+      detached: true, // own process group so stop() can kill the whole tree
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    this.proc.stdout!.on("data", (d) => this.logs.push(String(d)));
+    this.proc.stderr!.on("data", (d) => this.logs.push(String(d)));
+
+    await waitFor(
+      async () => {
+        try {
+          const res = await fetch(
+            `http://127.0.0.1:${MASTER_PORT}/api/health`,
+            { signal: AbortSignal.timeout(1000) },
+          );
+          return res.ok;
+        } catch {
+          return false;
+        }
+      },
+      60_000,
+      "server health",
+    );
+  }
+
+  // PIDs (from the server's own logs) of the cluster worker processes.
+  workerPids(): number[] {
+    const pids: number[] = [];
+    for (const line of this.logs) {
+      for (const m of line.matchAll(/Started worker \d+ \(PID: (\d+)\)/g)) {
+        pids.push(Number(m[1]));
+      }
+    }
+    return pids;
+  }
+
+  masterPid(): number | null {
+    for (const line of this.logs) {
+      const m = line.match(/Primary (\d+) is running/);
+      if (m) return Number(m[1]);
+    }
+    return null;
+  }
+
+  async stop(): Promise<void> {
+    if (this.proc?.pid) {
+      try {
+        process.kill(-this.proc.pid, "SIGTERM");
+      } catch {
+        // already dead
+      }
+    }
+    // Wait until every port is released so the next suite can bind.
+    await waitFor(
+      async () => {
+        for (let p = MASTER_PORT; p <= workerPort(NUM_WORKERS - 1); p++) {
+          if (await portServesHttp(p)) return false;
+        }
+        return true;
+      },
+      15_000,
+      "server ports released",
+    ).catch(() => {
+      // Last resort: SIGKILL the group.
+      if (this.proc?.pid) {
+        try {
+          process.kill(-this.proc.pid, "SIGKILL");
+        } catch {
+          // group already gone
+        }
+      }
+    });
+    this.proc = null;
+  }
+}
+
+export async function createGame(
+  creatorToken: string,
+  config: object = {},
+  onWorker = 0,
+): Promise<{ gameID: string; workerIndex: number; port: number }> {
+  const res = await fetch(
+    `http://127.0.0.1:${workerPort(onWorker)}/api/create_game`,
+    {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${creatorToken}`,
+      },
+      body: JSON.stringify(config),
+    },
+  );
+  if (!res.ok) {
+    throw new Error(`create_game failed: ${res.status} ${await res.text()}`);
+  }
+  const info = await res.json();
+  return {
+    gameID: info.gameID,
+    workerIndex: info.workerIndex,
+    port: workerPort(info.workerIndex),
+  };
+}
+
+export async function gameInfo(port: number, gameID: string): Promise<any> {
+  const res = await fetch(`http://127.0.0.1:${port}/api/game/${gameID}`);
+  if (!res.ok) return null;
+  return res.json();
+}
+
+// A WebSocket game client that records every server message and exposes
+// promise-based waits, so tests read as: join → waitFor("start") → assert.
+export class TestClient {
+  token: string;
+  ws: WebSocket | null = null;
+  messages: ServerMessage[] = [];
+  clientID: string | null = null;
+  closeCode: number | null = null;
+  closeReason = "";
+
+  constructor(
+    public port: number,
+    public gameID: string,
+    public username: string,
+    token?: string,
+  ) {
+    this.token = token ?? randomUUID();
+  }
+
+  async join(): Promise<void> {
+    await this.connect();
+    this.send({
+      type: "join",
+      token: this.token,
+      gameID: this.gameID,
+      username: this.username,
+      clanTag: null,
+      turnstileToken: null,
+    });
+    // The server-assigned clientID arrives in lobby_info (pre-start joins)
+    // or in the start message (late joins into a running game).
+    const msg = await this.waitForMessage(
+      (m) => m.type === "lobby_info" || m.type === "start",
+      10_000,
+    );
+    this.clientID = (msg as any).myClientID;
+  }
+
+  connect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${this.port}/`);
+      this.ws = ws;
+      ws.on("open", () => resolve());
+      ws.on("error", (err) => reject(err));
+      ws.on("message", (data) => {
+        try {
+          this.messages.push(JSON.parse(data.toString()));
+        } catch {
+          // not JSON; ignore
+        }
+      });
+      ws.on("close", (code, reason) => {
+        this.closeCode = code;
+        this.closeReason = reason.toString();
+      });
+    });
+  }
+
+  send(obj: unknown): void {
+    this.ws!.send(JSON.stringify(obj));
+  }
+
+  sendIntent(intent: object): void {
+    this.send({ type: "intent", intent });
+  }
+
+  async waitForMessage(
+    pred: (m: ServerMessage) => boolean,
+    timeoutMs = 10_000,
+  ): Promise<ServerMessage> {
+    let found: ServerMessage | undefined;
+    await waitFor(
+      () => {
+        found = this.messages.find(pred);
+        return found !== undefined;
+      },
+      timeoutMs,
+      `message matching predicate (got ${this.messages.length} messages)`,
+    );
+    return found!;
+  }
+
+  turns(): any[] {
+    return this.messages.filter((m) => m.type === "turn");
+  }
+
+  close(): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.close(1000);
+    }
+  }
+}
diff --git a/tests/load/README.md b/tests/load/README.md
new file mode 100644
index 0000000000..507de8b010
--- /dev/null
+++ b/tests/load/README.md
@@ -0,0 +1,80 @@
+# Server WebSocket load test
+
+Measures the game server's hot path — WebSocket intent ingestion and the
+100ms turn broadcast — against the **real** server (master + cluster
+workers), with a selectable server runtime.
+
+```bash
+npm run perf:server                        # Node (tsx) server, default profile
+npm run perf:server -- --runtime bun       # same profile, Bun server
+npm run perf:server -- --games 10 --clients 40 --duration 60 --intent-rate 2
+npm run perf:server -- --attach --workers 1   # drive an already-running server
+```
+
+The load generator always runs under plain Node so the measuring instrument
+stays constant across server runtimes. Results are printed and written to
+`tests/load/results/<label>.json` (gitignored).
+
+## How it works
+
+1. Spawns the dev server (`GAME_ENV=dev`, 2 workers by default) and waits
+   for `/api/health`.
+2. Creates `--games` private games via `POST /api/create_game` (round-robin
+   across workers), connects `--clients` WebSocket clients to each, and has
+   the creator start the game.
+3. Each client sends schema-valid `attack` intents at `--intent-rate`/s
+   (server limit: 10/s burst, 2.5/s sustained) with `Date.now()` embedded in
+   the `troops` field. The server relays intents verbatim inside turn
+   broadcasts, so every receiving client computes true intent→broadcast RTT
+   with zero server instrumentation. Clients ping every ~5s (the server
+   drops silent connections after 60s).
+4. Samples the spawned server's whole process tree (`/proc`) once per
+   second for CPU and RSS.
+
+Reported: intent→turn RTT percentiles (floor is ~50ms mean — an intent
+waits for the next 100ms tick), turn-interval jitter (target 100ms), join
+latency (dominated by the 1s `lobby_info` broadcast interval), client/server
+throughput, server CPU (% of one core, whole tree) and peak RSS.
+
+## Recorded results (2026-08-11, Linux x64, 20 cores, Node 26.5 / Bun 1.3.14)
+
+Medium = 8 games × 25 clients, 1 intent/s/client, 60s.
+Heavy = 10 games × 40 clients, 2 intents/s/client, 60s (~4,400 msgs/s out).
+
+| Metric               | Node medium | Bun medium | Node heavy | Bun heavy |
+| -------------------- | ----------- | ---------- | ---------- | --------- |
+| RTT p50 (ms)         | 50          | 51         | 50         | 54        |
+| RTT p99 (ms)         | 100         | 102        | 100        | 103       |
+| Turn jitter p99 (ms) | 101         | 105        | 104        | 106       |
+| Server avg CPU       | 6.3%        | 62.3%      | 11.6%      | 70.1%     |
+| Server peak RSS      | 641 MB      | 373 MB     | 661 MB     | 384 MB    |
+
+Single standalone worker (no cluster), 100 clients, 2 intents/s, 30s:
+Node 8.0% CPU vs Bun 33.6% CPU at identical latency.
+
+Interpretation: latency is tick-dominated and equivalent on both runtimes,
+but Bun spends ~4–6× the CPU for the same relay workload. Transport
+microbenchmarks (minimal broadcast server, 100 clients, 5,000 sends/s)
+rule out the obvious suspects:
+
+| Transport (same workload)         | CPU  |
+| --------------------------------- | ---- |
+| Node + `ws`                       | 2.2% |
+| Bun + `ws` (Bun's builtin shim)   | 3.8% |
+| Bun + native `Bun.serve()` ws     | 4.1% |
+| Node + `ws`, tick-driven fan-out  | 4.0% |
+| Bun + `ws`, tick-driven fan-out   | 7.0% |
+
+So a `Bun.serve()`-native transport rewrite would buy nothing — the shim is
+already native-backed and no slower. The per-op JS work (JSON.parse + Zod +
+stringify) is _faster_ on Bun in isolation. The real server's gap is
+diffuse runtime overhead that only shows up in situ: sends from timer
+context, event-emitter dispatch, GC pressure (JSC HeapHelper threads), and
+a ~5%/process idle floor from Bun's timers/fetch bookkeeping (Node:
+~0.3%). CPU profiling (`bun --cpu-prof`) shows ~38% of worker CPU inside
+the native websocket `send` called from `endTurn`'s broadcast loop at
+~1,000 sends/s — ~10× the per-send cost the same shim achieves in the
+minimal benchmark.
+
+Node's memory advantage reverses at the process level: Bun uses ~40% less
+RSS.
diff --git a/tests/load/loadtest.mjs b/tests/load/loadtest.mjs
new file mode 100644
index 0000000000..4de07a70c6
--- /dev/null
+++ b/tests/load/loadtest.mjs
@@ -0,0 +1,681 @@
+// WebSocket load test for the OpenFront game server.
+//
+// The game server's hot path is WebSocket messaging: clients send `intent`
+// messages, the server queues them, and every turn tick (100ms) it broadcasts
+// a `turn` message containing the queued intents to every client in the game.
+// This harness measures that path end to end against the REAL server.
+//
+// The load generator always runs under plain Node so the measuring instrument
+// stays constant; only the server runtime varies (--runtime node|bun).
+//
+// How RTT is measured with zero server changes: the `attack` intent's
+// `troops` field is any nonnegative number, and the server relays intents
+// verbatim. Each generated intent stores Date.now() in `troops`; every client
+// that receives the turn computes RTT = now - troops. Same machine, same
+// clock, no skew.
+//
+// Usage:
+//   node tests/load/loadtest.mjs [--runtime node|bun] [--games 8]
+//     [--clients 25] [--duration 60] [--intent-rate 1] [--workers 2]
+//     [--label baseline] [--attach]   (--attach: use an already-running server)
+//
+// Results: human summary on stdout + JSON in tests/load/results/<label>.json
+
+import { spawn } from "child_process";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import WebSocket from "ws";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, "../..");
+
+// ---------------------------------------------------------------- args
+
+function arg(name, def) {
+  const i = process.argv.indexOf(`--${name}`);
+  if (i === -1) return def;
+  const v = process.argv[i + 1];
+  return v === undefined || v.startsWith("--") ? true : v;
+}
+
+const RUNTIME = String(arg("runtime", "node")); // node | bun
+const GAMES = Number(arg("games", 8));
+const CLIENTS_PER_GAME = Number(arg("clients", 25));
+const DURATION_S = Number(arg("duration", 60));
+const INTENT_RATE = Number(arg("intent-rate", 1)); // intents/sec/client (<=2.5 to stay under server limits)
+const NUM_WORKERS = Number(arg("workers", 2));
+const LABEL = String(arg("label", RUNTIME));
+const ATTACH = arg("attach", false) === true;
+
+const MASTER_PORT = 3000;
+const workerPort = (i) => 3001 + i;
+
+// ---------------------------------------------------------------- helpers
+
+function percentile(sorted, p) {
+  if (sorted.length === 0) return NaN;
+  const idx = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.ceil((p / 100) * sorted.length) - 1),
+  );
+  return sorted[idx];
+}
+
+function stats(samples) {
+  const sorted = [...samples].sort((a, b) => a - b);
+  const sum = sorted.reduce((a, b) => a + b, 0);
+  return {
+    count: sorted.length,
+    mean: sorted.length ? sum / sorted.length : NaN,
+    p50: percentile(sorted, 50),
+    p95: percentile(sorted, 95),
+    p99: percentile(sorted, 99),
+    max: sorted.length ? sorted[sorted.length - 1] : NaN,
+  };
+}
+
+function fmt(ms) {
+  return Number.isFinite(ms) ? ms.toFixed(1) : "n/a";
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+async function waitFor(fn, timeoutMs, label) {
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const v = await fn();
+    if (v) return v;
+    if (Date.now() > deadline) {
+      throw new Error(`Timed out after ${timeoutMs}ms waiting for: ${label}`);
+    }
+    await sleep(250);
+  }
+}
+
+// UUID v4 for dev tokens (dev servers accept a raw persistent id as token).
+const uuid = () => crypto.randomUUID();
+
+// ---------------------------------------------------------------- server process management
+
+const serverEnv = {
+  ...process.env,
+  GAME_ENV: "dev",
+  NUM_WORKERS: String(NUM_WORKERS),
+  TURNSTILE_SITE_KEY: "1x00000000000000000000AA",
+  API_KEY: "WARNING_DEV_API_KEY_DO_NOT_USE_IN_PRODUCTION",
+  ADMIN_BOT_API_KEY: "WARNING_DEV_ADMIN_BOT_KEY_DO_NOT_USE_IN_PRODUCTION",
+  DOMAIN: "localhost",
+  GIT_COMMIT: "DEV",
+};
+
+function serverCommand() {
+  if (RUNTIME === "bun") {
+    return ["bun", ["src/server/Server.ts"]];
+  }
+  // The production Node path runs through tsx (see package.json start:server),
+  // so measuring tsx-launched Node is measuring the real deployment.
+  return ["npx", ["tsx", "src/server/Server.ts"]];
+}
+
+let serverProc = null;
+const resultsDir = path.join(__dirname, "results");
+fs.mkdirSync(resultsDir, { recursive: true });
+const serverLogPath = path.join(resultsDir, `${LABEL}-server.log`);
+
+function startServer() {
+  const [cmd, args] = serverCommand();
+  const logFd = fs.openSync(serverLogPath, "w");
+  serverProc = spawn(cmd, args, {
+    cwd: repoRoot,
+    env: serverEnv,
+    detached: true, // own process group so we can kill the whole tree
+    stdio: ["ignore", logFd, logFd],
+  });
+  serverProc.on("exit", (code, signal) => {
+    if (!shuttingDown) {
+      console.error(`server exited early (code=${code} signal=${signal})`);
+      console.error(`see ${serverLogPath}`);
+      process.exit(1);
+    }
+  });
+}
+
+let shuttingDown = false;
+function stopServer() {
+  shuttingDown = true;
+  if (serverProc && serverProc.pid) {
+    try {
+      process.kill(-serverProc.pid, "SIGTERM");
+    } catch {
+      // group already gone
+    }
+  }
+}
+
+process.on("SIGINT", () => {
+  stopServer();
+  process.exit(130);
+});
+
+// ---------------------------------------------------------------- /proc CPU + RSS sampling
+
+function readProcTable() {
+  // pid -> { ppid, utime, stime, rssPages, comm }
+  const table = new Map();
+  let pids;
+  try {
+    pids = fs.readdirSync("/proc").filter((d) => /^\d+$/.test(d));
+  } catch {
+    return table;
+  }
+  for (const pid of pids) {
+    try {
+      const stat = fs.readFileSync(`/proc/${pid}/stat`, "utf8");
+      // comm can contain spaces/parens; it is wrapped in the last ')'
+      const close = stat.lastIndexOf(")");
+      const comm = stat.slice(stat.indexOf("(") + 1, close);
+      const rest = stat.slice(close + 2).split(" ");
+      // rest[0]=state, rest[1]=ppid, rest[11]=utime, rest[12]=stime, rest[21]=rss(pages)
+      table.set(Number(pid), {
+        ppid: Number(rest[1]),
+        utime: Number(rest[11]),
+        stime: Number(rest[12]),
+        rssPages: Number(rest[21]),
+        comm,
+      });
+    } catch {
+      // process vanished between readdir and read
+    }
+  }
+  return table;
+}
+
+function descendantsOf(rootPid, table) {
+  const children = new Map();
+  for (const [pid, info] of table) {
+    if (!children.has(info.ppid)) children.set(info.ppid, []);
+    children.get(info.ppid).push(pid);
+  }
+  const out = [];
+  const stack = [rootPid];
+  while (stack.length) {
+    const pid = stack.pop();
+    if (!table.has(pid)) continue;
+    out.push(pid);
+    for (const c of children.get(pid) ?? []) stack.push(c);
+  }
+  return out;
+}
+
+const HZ = 100; // Linux USER_HZ
+const PAGE_SIZE = 4096;
+
+class ProcSampler {
+  constructor(rootPid) {
+    this.rootPid = rootPid;
+    this.samples = []; // { t, cpuTicks, rssBytes, nprocs }
+    this.timer = null;
+  }
+  start() {
+    this.timer = setInterval(() => this.sample(), 1000);
+    this.sample();
+  }
+  sample() {
+    const table = readProcTable();
+    const pids = descendantsOf(this.rootPid, table);
+    let cpuTicks = 0;
+    let rssBytes = 0;
+    for (const pid of pids) {
+      const info = table.get(pid);
+      cpuTicks += info.utime + info.stime;
+      rssBytes += info.rssPages * PAGE_SIZE;
+    }
+    this.samples.push({
+      t: Date.now(),
+      cpuTicks,
+      rssBytes,
+      nprocs: pids.length,
+    });
+  }
+  stop() {
+    if (this.timer) clearInterval(this.timer);
+  }
+  // CPU% (of one core) averaged over the window, and peak RSS.
+  report(windowStartMs) {
+    const inWindow = this.samples.filter((s) => s.t >= windowStartMs);
+    if (inWindow.length < 2) return { avgCpuPct: NaN, peakRssMb: NaN };
+    const first = inWindow[0];
+    const last = inWindow[inWindow.length - 1];
+    const cpuSec = (last.cpuTicks - first.cpuTicks) / HZ;
+    const wallSec = (last.t - first.t) / 1000;
+    const peakRss = Math.max(...inWindow.map((s) => s.rssBytes));
+    return {
+      avgCpuPct: (cpuSec / wallSec) * 100,
+      peakRssMb: peakRss / (1024 * 1024),
+      procCount: last.nprocs,
+    };
+  }
+}
+
+// ---------------------------------------------------------------- load client
+
+class LoadClient {
+  constructor(game, index, isCreator, token) {
+    this.game = game;
+    this.index = index;
+    this.isCreator = isCreator;
+    this.token = token;
+    this.clientID = null;
+    this.ws = null;
+    this.started = false;
+    this.joinSentAt = 0;
+    this.joinLatencyMs = null;
+    this.lastTurnAt = 0;
+    this.errors = [];
+    this.closed = false;
+    this.msgsReceived = 0;
+    this.bytesReceived = 0;
+    this.intentsSent = 0;
+    this.timers = [];
+  }
+
+  connect() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${this.game.port}/`);
+      this.ws = ws;
+      const joinTimeout = setTimeout(
+        () =>
+          reject(new Error(`join timeout g=${this.game.id} c=${this.index}`)),
+        20000,
+      );
+      ws.on("open", () => {
+        this.joinSentAt = performance.now();
+        ws.send(
+          JSON.stringify({
+            type: "join",
+            token: this.token,
+            gameID: this.game.id,
+            username: `load_${this.game.index}_${this.index}`,
+            clanTag: null,
+            turnstileToken: null,
+          }),
+        );
+      });
+      ws.on("message", (data) => {
+        this.msgsReceived++;
+        this.bytesReceived += data.length;
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          return;
+        }
+        this.onMessage(msg);
+        if (this.clientID !== null && joinTimeout) {
+          clearTimeout(joinTimeout);
+          resolve();
+        }
+      });
+      ws.on("error", (err) => {
+        this.errors.push(String(err));
+      });
+      ws.on("close", (code, reason) => {
+        this.closed = true;
+        if (!metrics.done && code !== 1000) {
+          this.errors.push(`closed ${code} ${reason}`);
+        }
+      });
+    });
+  }
+
+  onMessage(msg) {
+    const now = Date.now();
+    switch (msg.type) {
+      case "lobby_info":
+        if (this.clientID === null) {
+          this.clientID = msg.myClientID;
+          this.joinLatencyMs = performance.now() - this.joinSentAt;
+          metrics.joinLatencies.push(this.joinLatencyMs);
+        }
+        break;
+      case "start":
+        this.started = true;
+        this.game.onClientStarted();
+        break;
+      case "turn": {
+        // Turn-interval jitter, measured per client past the first turn.
+        if (this.lastTurnAt !== 0 && metrics.measuring) {
+          metrics.turnGaps.push(now - this.lastTurnAt);
+        }
+        this.lastTurnAt = now;
+        if (metrics.measuring) metrics.turnsReceived++;
+        for (const intent of msg.turn.intents) {
+          if (
+            intent.type === "attack" &&
+            typeof intent.troops === "number" &&
+            intent.troops > metrics.epoch
+          ) {
+            if (metrics.measuring) metrics.rtts.push(now - intent.troops);
+          }
+        }
+        break;
+      }
+      case "error":
+        this.errors.push(JSON.stringify(msg));
+        break;
+    }
+  }
+
+  startTraffic() {
+    // Keepalive pings (server drops clients silent for 60s).
+    this.timers.push(
+      setInterval(
+        () => this.send({ type: "ping" }),
+        5000 + Math.random() * 1000,
+      ),
+    );
+    // Intent traffic at INTENT_RATE per second, jittered start so clients
+    // don't phase-lock.
+    const intervalMs = 1000 / INTENT_RATE;
+    setTimeout(() => {
+      this.timers.push(
+        setInterval(() => {
+          this.send({
+            type: "intent",
+            intent: { type: "attack", targetID: null, troops: Date.now() },
+          });
+          this.intentsSent++;
+        }, intervalMs),
+      );
+    }, Math.random() * intervalMs);
+  }
+
+  send(obj) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(obj));
+    }
+  }
+
+  stop() {
+    for (const t of this.timers) clearInterval(t);
+    this.timers = [];
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) this.ws.close(1000);
+  }
+}
+
+class LoadGame {
+  constructor(index) {
+    this.index = index;
+    this.id = null;
+    this.port = null;
+    this.creatorToken = uuid();
+    this.clients = [];
+    this.startedClients = 0;
+    this.allStarted = null;
+    this.allStartedResolve = null;
+  }
+
+  async create() {
+    // Round-robin creation across workers; each worker mints an id routed to
+    // itself.
+    const port = workerPort(this.index % NUM_WORKERS);
+    const res = await fetch(`http://127.0.0.1:${port}/api/create_game`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.creatorToken}`,
+      },
+      body: JSON.stringify({}),
+    });
+    if (!res.ok) {
+      throw new Error(`create_game failed: ${res.status} ${await res.text()}`);
+    }
+    const info = await res.json();
+    this.id = info.gameID;
+    this.port = workerPort(info.workerIndex);
+  }
+
+  async join() {
+    this.allStarted = new Promise((r) => (this.allStartedResolve = r));
+    for (let i = 0; i < CLIENTS_PER_GAME; i++) {
+      const isCreator = i === 0;
+      const token = isCreator ? this.creatorToken : uuid();
+      this.clients.push(new LoadClient(this, i, isCreator, token));
+    }
+    // Batch connects to avoid a thundering herd on the accept queue.
+    const BATCH = 10;
+    for (let i = 0; i < this.clients.length; i += BATCH) {
+      await Promise.all(
+        this.clients.slice(i, i + BATCH).map((c) => c.connect()),
+      );
+    }
+  }
+
+  begin() {
+    // Creator flips the start timer; server prestarts on its next manager
+    // tick and starts ~2s later.
+    const creator = this.clients[0];
+    creator.send({
+      type: "intent",
+      intent: { type: "toggle_game_start_timer" },
+    });
+  }
+
+  onClientStarted() {
+    this.startedClients++;
+    if (this.startedClients === this.clients.length) {
+      this.allStartedResolve();
+    }
+  }
+}
+
+// ---------------------------------------------------------------- metrics
+
+const metrics = {
+  epoch: Date.now() - 60_000, // troops values above this are our timestamps
+  measuring: false,
+  done: false,
+  rtts: [],
+  turnGaps: [],
+  joinLatencies: [],
+  turnsReceived: 0,
+};
+
+// ---------------------------------------------------------------- main
+
+async function main() {
+  console.log(
+    `load test: runtime=${RUNTIME} games=${GAMES} clients/game=${CLIENTS_PER_GAME} ` +
+      `total clients=${GAMES * CLIENTS_PER_GAME} duration=${DURATION_S}s ` +
+      `intent rate=${INTENT_RATE}/s/client workers=${NUM_WORKERS}`,
+  );
+
+  if (!ATTACH) {
+    // Preflight: a leftover server on our ports would silently absorb the
+    // health check and half the traffic (workers bind with SO_REUSEPORT
+    // under Bun's cluster), poisoning results. Refuse to run.
+    for (let p = MASTER_PORT; p <= workerPort(NUM_WORKERS - 1); p++) {
+      const occupied = await fetch(`http://127.0.0.1:${p}/`, {
+        signal: AbortSignal.timeout(1000),
+      }).then(
+        () => true,
+        () => false,
+      );
+      if (occupied) {
+        throw new Error(
+          `port ${p} is already serving HTTP — kill the stray server first ` +
+            `(or pass --attach to test against it)`,
+        );
+      }
+    }
+    console.log(`starting server (${serverCommand().flat().join(" ")})...`);
+    startServer();
+  }
+
+  // In --attach mode the target may be a standalone worker (no master), so
+  // the master health check only runs for servers we spawned ourselves.
+  if (!ATTACH) {
+    await waitFor(
+      async () => {
+        try {
+          const res = await fetch(
+            `http://127.0.0.1:${MASTER_PORT}/api/health`,
+            { signal: AbortSignal.timeout(1500) },
+          );
+          return res.ok;
+        } catch {
+          return false;
+        }
+      },
+      60_000,
+      "server health",
+    );
+  }
+  // Health means workers signaled ready over IPC; verify their HTTP ports too.
+  for (let i = 0; i < NUM_WORKERS; i++) {
+    await waitFor(
+      async () => {
+        try {
+          await fetch(`http://127.0.0.1:${workerPort(i)}/api/env`, {
+            signal: AbortSignal.timeout(1500),
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      30_000,
+      `worker ${i} http`,
+    );
+  }
+  console.log("server healthy");
+
+  const sampler = serverProc ? new ProcSampler(serverProc.pid) : null;
+  sampler?.start();
+
+  // Create games (staggered to stay under the 20 req/s/IP limiter).
+  const games = [];
+  for (let i = 0; i < GAMES; i++) {
+    const g = new LoadGame(i);
+    await g.create();
+    games.push(g);
+    await sleep(60);
+  }
+  console.log(`created ${games.length} games`);
+
+  await Promise.all(games.map((g) => g.join()));
+  const joined = games.reduce((a, g) => a + g.clients.length, 0);
+  console.log(`joined ${joined} clients`);
+
+  for (const g of games) g.begin();
+  await Promise.all(
+    games.map((g) =>
+      waitFor(
+        () => g.startedClients === g.clients.length,
+        30_000,
+        `game ${g.id} start`,
+      ),
+    ),
+  );
+  console.log("all games started; warming up 5s...");
+
+  for (const g of games) for (const c of g.clients) c.startTraffic();
+  await sleep(5000); // warmup: JIT, connection settling
+
+  console.log(`measuring for ${DURATION_S}s...`);
+  const windowStart = Date.now();
+  metrics.measuring = true;
+  await sleep(DURATION_S * 1000);
+  metrics.measuring = false;
+  metrics.done = true;
+
+  // Teardown clients.
+  for (const g of games) for (const c of g.clients) c.stop();
+  sampler?.stop();
+
+  // ---------------- report
+  const rtt = stats(metrics.rtts);
+  const gaps = stats(metrics.turnGaps);
+  const joins = stats(metrics.joinLatencies);
+  const proc = sampler ? sampler.report(windowStart) : null;
+
+  const allClients = games.flatMap((g) => g.clients);
+  const totalMsgs = allClients.reduce((a, c) => a + c.msgsReceived, 0);
+  const totalBytes = allClients.reduce((a, c) => a + c.bytesReceived, 0);
+  const totalIntents = allClients.reduce((a, c) => a + c.intentsSent, 0);
+  const errored = allClients.filter((c) => c.errors.length > 0);
+  const closedEarly = allClients.filter((c) => c.closed);
+
+  const result = {
+    label: LABEL,
+    runtime: RUNTIME,
+    timestamp: new Date().toISOString(),
+    config: {
+      games: GAMES,
+      clientsPerGame: CLIENTS_PER_GAME,
+      totalClients: GAMES * CLIENTS_PER_GAME,
+      durationS: DURATION_S,
+      intentRatePerClient: INTENT_RATE,
+      numWorkers: NUM_WORKERS,
+      turnIntervalMs: 100,
+    },
+    intentToTurnBroadcastRttMs: rtt,
+    turnIntervalMs: gaps,
+    joinLatencyMs: joins,
+    throughput: {
+      turnsReceivedTotal: metrics.turnsReceived,
+      clientMsgsReceivedTotal: totalMsgs,
+      clientBytesReceivedTotal: totalBytes,
+      intentsSentTotal: totalIntents,
+    },
+    server: proc,
+    clientErrors: errored.length,
+    clientsClosedEarly: closedEarly.length,
+  };
+
+  const outPath = path.join(resultsDir, `${LABEL}.json`);
+  fs.writeFileSync(outPath, JSON.stringify(result, null, 2));
+
+  console.log(`\n===== RESULTS (${LABEL}) =====`);
+  console.log(
+    `intent -> turn-broadcast RTT ms (n=${rtt.count}): ` +
+      `mean=${fmt(rtt.mean)} p50=${fmt(rtt.p50)} p95=${fmt(rtt.p95)} p99=${fmt(rtt.p99)} max=${fmt(rtt.max)}`,
+  );
+  console.log(
+    `  (includes avg ~${100 / 2}ms inherent wait for the next 100ms turn tick)`,
+  );
+  console.log(
+    `turn interval ms (target 100, n=${gaps.count}): ` +
+      `mean=${fmt(gaps.mean)} p50=${fmt(gaps.p50)} p95=${fmt(gaps.p95)} p99=${fmt(gaps.p99)} max=${fmt(gaps.max)}`,
+  );
+  console.log(
+    `join latency ms (n=${joins.count}): mean=${fmt(joins.mean)} p50=${fmt(joins.p50)} p95=${fmt(joins.p95)} max=${fmt(joins.max)}`,
+  );
+  console.log(
+    `throughput: ${(totalMsgs / DURATION_S).toFixed(0)} msgs/s to clients, ` +
+      `${(totalBytes / DURATION_S / 1024).toFixed(0)} KiB/s, ` +
+      `${(totalIntents / DURATION_S).toFixed(0)} intents/s from clients`,
+  );
+  if (proc) {
+    console.log(
+      `server: avg CPU ${proc.avgCpuPct.toFixed(1)}% (of one core, whole tree), ` +
+        `peak RSS ${proc.peakRssMb.toFixed(0)} MB, ${proc.procCount} procs`,
+    );
+  }
+  console.log(
+    `client errors: ${errored.length}, closed early: ${closedEarly.length}`,
+  );
+  console.log(`json: ${outPath}`);
+
+  stopServer();
+  // Give the process group a moment to die, then force-exit (timers linger).
+  await sleep(500);
+  process.exit(errored.length > 0 ? 1 : 0);
+}
+
+main().catch((err) => {
+  console.error(err);
+  stopServer();
+  process.exit(1);
+});
diff --git a/tsconfig.json b/tsconfig.json
index 911dbbc48f..1aa3053566 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -29,7 +29,8 @@
     "generated/**/*",
     "tests/**/*",
     "src/scripts",
-    "vite.config.ts"
+    "vite.config.ts",
+    "vitest.e2e.config.ts"
   ],
   "exclude": ["node_modules"]
 }
diff --git a/vite.config.ts b/vite.config.ts
index b8a118e323..0ebe8118cc 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -253,6 +253,9 @@ export default defineConfig(({ mode }) => {
       globals: true,
       environment: "jsdom",
       setupFiles: "./tests/setup.ts",
+      // E2E tests boot the real server on fixed ports and have their own
+      // config (vitest.e2e.config.ts); run them via `npm run test:e2e`.
+      exclude: ["**/node_modules/**", "**/dist/**", "tests/e2e/**"],
     },
     root: "./",
     base: "/",
diff --git a/vitest.e2e.config.ts b/vitest.e2e.config.ts
new file mode 100644
index 0000000000..dd705cc281
--- /dev/null
+++ b/vitest.e2e.config.ts
@@ -0,0 +1,18 @@
+import { defineConfig } from "vitest/config";
+
+// E2E tests boot the real server (master + cluster workers) and talk to it
+// over HTTP + WebSocket on ports 3000-3002, so they run sequentially in a
+// plain node environment, separate from the unit-test config in
+// vite.config.ts. Run with `npm run test:e2e` (Node) or
+// `npm run test:e2e:bun` (Bun runtime for the server under test).
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/e2e/**/*.test.ts"],
+    // One server at a time: the suites share fixed ports.
+    fileParallelism: false,
+    testTimeout: 30_000,
+    hookTimeout: 90_000,
+  },
+});