test: stop guessing port numbers

Twenty test servers picked a port with `NNNN + Math.floor(Math.random() * 500)`
and hoped it was free. Several files guessed inside the *same* range —
sdk.test.ts and gates.test.ts both on 19500, three files on 22000, and
webrtc-integration.test.ts used 22000 twice within itself — so with test files
serving in parallel the collision was not unlikely, it was scheduled.

Found from the outside, in Nova, where Shade is vendored: across eight runs of
an unchanged tree, two had failures and six were clean. The visible error was

    Failed to start server. Is port 24287 in use?  EADDRINUSE

and then a second, louder one: `teardownRig` ran on a rig that setup had never
finished building and died on `rig.alice`, so the TypeError from cleanup is
what you read first and the real cause scrolled past above it.

`Bun.serve({ port: 0 })` lets the OS hand out a free port and `server.port`
reads it back. There is no range to collide inside.

teardownRig now tolerates a rig that was never built. Cleanup must never be the
loudest thing in a failing test.

A suite that fails a quarter of the time is worse than a suite that fails: it
teaches everyone to re-run it, and then a real regression looks like the flake.

Verified: 1198 pass / 0 fail here, and the same fix is going into Nova's
vendored copy so the next sync does not bring the guessing back.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014489bKUtUEY1Zgs9xN9mt7

packages/shade-sdk/tests/webrtc-failover.test.ts

@@ -103,8 +103,12 @@ async function startPrekeyServer(): Promise<{ url: string; stop: () => void }> {
     disableRateLimit: true,
     events,
   });
-  const port = 23000 + Math.floor(Math.random() * 500);
-  const handle = Bun.serve({ port, fetch: server.fetch });
+  // Port 0 lets the OS hand out a free one. This guessed inside a 500-wide
+  // range and hoped — and several files here guessed inside the SAME range,
+  // so with test files serving in parallel the collision arrived about a
+  // quarter of the time as EADDRINUSE.
+  const handle = Bun.serve({ port: 0, fetch: server.fetch });
+  const port = handle.port;
   return { url: `http://localhost:${port}`, stop: () => handle.stop() };
 }
 
@@ -127,13 +131,21 @@ async function setupRig(connectTimeoutMs: number): Promise<Rig> {
   bob.configureWebRTC({ factory: broken, connectTimeoutMs });
 
   const bobApp = await bob.transferRoute();
-  const bobPort = 23500 + Math.floor(Math.random() * 500);
-  const bobServer = Bun.serve({ port: bobPort, fetch: bobApp.fetch });
+  // Port 0 lets the OS hand out a free one. This guessed inside a 500-wide
+  // range and hoped — and several files here guessed inside the SAME range,
+  // so with test files serving in parallel the collision arrived about a
+  // quarter of the time as EADDRINUSE.
+  const bobServer = Bun.serve({ port: 0, fetch: bobApp.fetch });
+  const bobPort = bobServer.port;
   baseUrls.set('bob', `http://localhost:${bobPort}`);
 
   const aliceApp = await alice.transferRoute();
-  const alicePort = 24000 + Math.floor(Math.random() * 500);
-  const aliceServer = Bun.serve({ port: alicePort, fetch: aliceApp.fetch });
+  // Port 0 lets the OS hand out a free one. This guessed inside a 500-wide
+  // range and hoped — and several files here guessed inside the SAME range,
+  // so with test files serving in parallel the collision arrived about a
+  // quarter of the time as EADDRINUSE.
+  const aliceServer = Bun.serve({ port: 0, fetch: aliceApp.fetch });
+  const alicePort = aliceServer.port;
   baseUrls.set('alice', `http://localhost:${alicePort}`);
 
   return {
@@ -145,12 +157,18 @@ async function setupRig(connectTimeoutMs: number): Promise<Rig> {
   };
 }
 
-async function teardownRig(rig: Rig): Promise<void> {
-  await rig.alice.shutdown();
-  await rig.bob.shutdown();
-  rig.bobServerStop();
-  rig.aliceServerStop();
-  rig.prekeyStop();
+async function teardownRig(rig: Rig | undefined): Promise<void> {
+  // Tolerates a rig that never finished being built. When setupRig threw —
+  // EADDRINUSE, before ports stopped being guessed — this ran anyway and died
+  // on `rig.alice`, so one failure became two and the second one, a TypeError
+  // in teardown, is what you saw first. Cleanup must never be the loudest
+  // thing in a failing test.
+  if (!rig) return;
+  await rig.alice?.shutdown().catch(() => {});
+  await rig.bob?.shutdown().catch(() => {});
+  try { rig.bobServerStop?.(); } catch { /* already gone */ }
+  try { rig.aliceServerStop?.(); } catch { /* already gone */ }
+  try { rig.prekeyStop?.(); } catch { /* already gone */ }
 }
 
 function hex(b: Uint8Array): string {