serverless-ircd 0.3.0 → 0.5.0

package/packages/cf-adapter/tests/connection-do-channel-registration.test.ts

@@ -0,0 +1,37 @@
+/**
+ * CF `webSocketMessage` channel-registration: wire ChannelDO
+ * registration OR remove the dead loop.
+ *
+ * Spike conclusion: the dead loop that
+ * iterated `state.joinedChannels` to "register" the ConnectionDO with
+ * each ChannelDO is redundant. Channel membership — and therefore
+ * broadcast fan-out registration — is driven solely by the
+ * `ApplyChannelDelta` effect the joinReducer emits. The CfRuntime
+ * forwards that effect to the authoritative ChannelDO
+ * (`cf-runtime.ts` → `channel-do.ts#applyChannelDelta`), whose roster
+ * is the single source of truth used by `ChannelDO.broadcast`. The
+ * `connection-do.test.ts` "QUIT fanout to each joined channel" test
+ * proves this end-to-end (alice JOINs, closes, and bob observes the
+ * QUIT that only the ChannelDO roster could have routed).
+ *
+ * Because the removed loop was a no-op (`void chan;`), there is no
+ * behaviour to assert — these are source-level regression guards that
+ * prevent the redundant registration loop from creeping back in.
+ */
+
+import { describe, expect, it } from 'vitest';
+import connectionDoSource from '../src/connection-do.ts?raw';
+
+describe('ConnectionDO — no redundant channel-registration loop', () => {
+  it('webSocketMessage contains no dead `void chan` no-op registration body', () => {
+    // The joinReducer's `ApplyChannelDelta` effect is the sole channel
+    // registration path; a per-ConnectionDO loop here is dead code.
+    expect(connectionDoSource).not.toContain('void chan');
+  });
+
+  it('documents that no explicit per-ConnectionDO registration step is needed', () => {
+    // The absence of the loop must be explained so it is not mistaken
+    // for a missing feature.
+    expect(connectionDoSource).toContain('No per-ConnectionDO channel-registration step is needed');
+  });
+});

package/packages/cf-adapter/tests/connection-do-no-batching-reservation.test.ts

@@ -0,0 +1,52 @@
+/**
+ * CF outbound batching: implement OR drop the reserved optimization.
+ *
+ * Spike conclusion: the speculative per-microtask
+ * outbound drain that was reserved as a commented-out field in
+ * `ConnectionDO` is dropped. Per-call batching is already implemented —
+ * `ConnectionDO.deliver()` joins every line of a ChannelDO broadcast into
+ * a single `WebSocket.send()`, and the actor `send` handler
+ * (`buildActor`) joins every line of one frame's response the same way.
+ * What the reservation speculated about was *cross-call* coalescing —
+ * queueing lines emitted by independent `deliver` / `send` invocations
+ * within the same microtask and flushing them in one write. That adds a
+ * drain queue, a `queueMicrotask` scheduler, and ordering hazards between
+ * independent fan-out calls, in exchange for no measured benefit: nothing
+ * in the load-test report or the ChannelDO fan-out path shows WS
+ * round-trips as a bottleneck. The AWS adapter batches at a
+ * different layer (per-invocation `outbound: string[]` accumulated then
+ * posted once), so there is no shared abstraction worth extracting.
+ *
+ * Because the removed reservation was a comment with no runtime
+ * behaviour, these are source-level regression guards (mirroring the
+ * pattern used for other dropped reservations) that prevent the
+ * speculative field from creeping back in and keep the deferral
+ * documented at the point a reader would otherwise expect the batching
+ * hook.
+ */
+
+import { describe, expect, it } from 'vitest';
+import connectionDoSource from '../src/connection-do.ts?raw';
+
+describe('ConnectionDO — no reserved outbound-batching field', () => {
+  it('does not contain the deferred "Reserved for a future batching optimization" comment', () => {
+    // The reservation is dropped; per-call batching in `deliver()` and
+    // the actor `send` handler is the implemented strategy.
+    expect(connectionDoSource).not.toContain('Reserved for a future batching optimization');
+  });
+
+  it('does not reintroduce a speculative outbound-drain field declaration', () => {
+    // Guards against any variant of the commented-out reservation. The
+    // implemented batching is per-call (join lines then `send` once);
+    // there is no instance-level drain queue.
+    expect(connectionDoSource).not.toContain('Outstanding outbound lines');
+    expect(connectionDoSource).not.toContain('drop the reservation');
+  });
+
+  it('documents the deferral decision at the point the reservation used to live', () => {
+    // The absence of the field must be explained so it is not mistaken
+    // for a missing feature, and a reader is pointed at the perf ADR.
+    expect(connectionDoSource).toContain('batched per call');
+    expect(connectionDoSource).toContain('ADR-003');
+  });
+});

package/packages/cf-adapter/tests/connection-do-sasl-d1.test.ts

@@ -0,0 +1,166 @@
+/**
+ * End-to-end SASL PLAIN through ConnectionDO with D1-backed accounts.
+ *
+ * Verifies the full precedence matrix:
+ *   - D1 has rows → table is authoritative (900/903 for seeded account,
+ *     904 for the env-seed account which the table shadows).
+ *   - D1 empty → the `SASL_ACCOUNTS` env-var seed still works (fallback).
+ *
+ * Each test file gets its own isolated D1 database from miniflare, so the
+ * table state set up here does not leak into `connection-do.test.ts`.
+ */
+
+import { env } from 'cloudflare:test';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { CREATE_ACCOUNTS_TABLE_SQL, putAccountCredential } from '../src/d1-account-store';
+
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      CONNECTION_DO: DurableObjectNamespace;
+      REGISTRY_DO: DurableObjectNamespace;
+      CHANNEL_DO: DurableObjectNamespace;
+      ACCOUNTS_DB: D1Database;
+    }
+  }
+}
+
+class IrcWsClient {
+  readonly received: string[] = [];
+  readonly ws: WebSocket;
+
+  constructor(ws: WebSocket) {
+    this.ws = ws;
+    ws.addEventListener('message', (ev: MessageEvent) => {
+      const d = ev.data as string;
+      for (const line of d.split('\r\n')) {
+        if (line.length > 0) this.received.push(line);
+      }
+    });
+  }
+
+  send(line: string): void {
+    this.ws.send(line);
+  }
+
+  waitForMessage(predicate: (line: string) => boolean, timeoutMs = 2000): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      const start = Date.now();
+      const tick = (): void => {
+        const hit = this.received.find(predicate);
+        if (hit !== undefined) {
+          resolve(hit);
+          return;
+        }
+        if (Date.now() - start > timeoutMs) {
+          reject(new Error(`timeout waiting for message; got: ${JSON.stringify(this.received)}`));
+          return;
+        }
+        setTimeout(tick, 20);
+      };
+      tick();
+    });
+  }
+
+  close(): Promise<void> {
+    return new Promise<void>((resolve) => {
+      this.ws.addEventListener('close', () => resolve());
+      this.ws.close();
+    });
+  }
+}
+
+async function connect(connId: string): Promise<IrcWsClient> {
+  const doId = env.CONNECTION_DO.idFromName(connId);
+  const stub = env.CONNECTION_DO.get(doId);
+  const response = await stub.fetch('https://do/upgrade', {
+    headers: { Upgrade: 'websocket' },
+  });
+  const ws = response.webSocket;
+  if (ws === undefined || ws === null) {
+    throw new Error('ConnectionDO.fetch did not return a WebSocket');
+  }
+  ws.accept();
+  return new Promise<IrcWsClient>((resolve) => {
+    setTimeout(() => resolve(new IrcWsClient(ws as WebSocket)), 0);
+  });
+}
+
+/** base64(`\0authcid\0password`) — the PLAIN payload format. */
+function plainB64(authcid: string, password: string): string {
+  const raw = `\0${authcid}\0${password}`;
+  let latin1 = '';
+  for (let i = 0; i < raw.length; i++) latin1 += String.fromCharCode(raw.charCodeAt(i));
+  return (globalThis as unknown as { btoa: (s: string) => string }).btoa(latin1);
+}
+
+/** Negotiates `CAP sasl` and sends an AUTHENTICATE PLAIN payload. */
+async function authenticatePlain(
+  client: IrcWsClient,
+  authcid: string,
+  password: string,
+): Promise<void> {
+  client.send('CAP REQ :sasl\r\n');
+  await client.waitForMessage((l) => / CAP \S+ ACK :sasl/.test(l));
+  client.send('AUTHENTICATE PLAIN\r\n');
+  await client.waitForMessage((l) => l === 'AUTHENTICATE +');
+  client.send(`AUTHENTICATE ${plainB64(authcid, password)}\r\n`);
+}
+
+describe('ConnectionDO — SASL PLAIN with D1-backed accounts', () => {
+  beforeEach(async () => {
+    await env.ACCOUNTS_DB.exec(CREATE_ACCOUNTS_TABLE_SQL);
+  });
+  afterEach(async () => {
+    await env.ACCOUNTS_DB.exec('DROP TABLE IF EXISTS accounts');
+  });
+
+  it('completes SASL PLAIN with 900/903 for a D1-seeded account', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'd1-alice', 'd1-s3cret');
+    const client = await connect('conn-d1-sasl-1');
+    await authenticatePlain(client, 'd1-alice', 'd1-s3cret');
+    await client.waitForMessage((l) => l.includes(' 900 '));
+    const success = await client.waitForMessage((l) => l.includes(' 903 '));
+    expect(success).toContain(' 903 ');
+    await client.close();
+  });
+
+  it('rejects SASL PLAIN with 904 for a wrong password (D1 account)', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'd1-alice', 'd1-s3cret');
+    const client = await connect('conn-d1-sasl-2');
+    await authenticatePlain(client, 'd1-alice', 'wrong');
+    const fail = await client.waitForMessage((l) => l.includes(' 904 '));
+    expect(fail).toContain(' 904 ');
+    await client.close();
+  });
+
+  it('table shadows the env-seed account (table wins)', async () => {
+    // SASL_ACCOUNTS env seeds "cf-sasl:s3cret" but D1 has no such row.
+    await putAccountCredential(env.ACCOUNTS_DB, 'd1-alice', 'd1-s3cret');
+    const client = await connect('conn-d1-sasl-3');
+    // env-seed account does NOT verify (table is authoritative).
+    await authenticatePlain(client, 'cf-sasl', 's3cret');
+    const fail = await client.waitForMessage((l) => l.includes(' 904 '));
+    expect(fail).toContain(' 904 ');
+    await client.close();
+  });
+});
+
+describe('ConnectionDO — SASL PLAIN in-memory fallback (D1 empty)', () => {
+  // The table exists but has zero rows → resolver falls back to SASL_ACCOUNTS.
+  beforeEach(async () => {
+    await env.ACCOUNTS_DB.exec(CREATE_ACCOUNTS_TABLE_SQL);
+  });
+  afterEach(async () => {
+    await env.ACCOUNTS_DB.exec('DROP TABLE IF EXISTS accounts');
+  });
+
+  it('falls back to SASL_ACCOUNTS seed when D1 is empty', async () => {
+    const client = await connect('conn-d1-sasl-fallback');
+    await authenticatePlain(client, 'cf-sasl', 's3cret');
+    await client.waitForMessage((l) => l.includes(' 900 '));
+    const success = await client.waitForMessage((l) => l.includes(' 903 '));
+    expect(success).toContain(' 903 ');
+    await client.close();
+  });
+});

package/packages/cf-adapter/tests/connection-do-ws-spec-contract.test.ts

@@ -0,0 +1,289 @@
+/**
+ * CF adapter — IRCv3 WebSocket spec-compliance (end-to-end contract).
+ *
+ * A single integration suite driving the real `ConnectionDO`
+ * through `cloudflare:test` (miniflare) that asserts the FULL IRCv3
+ * WebSocket spec contract end-to-end against a negotiated `text.ircv3.net`
+ * connection (with a legacy fallback for the differential cases):
+ *
+ *   - `Sec-WebSocket-Protocol` echo (`text.ircv3.net` / `binary.ircv3.net`)
+ *   - one IRC message per WebSocket message, BOTH directions:
+ *       outbound registration replies arrive as N separate WS messages
+ *       with no trailing CR-LF; bare inbound frames (no trailing CR-LF)
+ *       are accepted; an embedded CR-LF is NOT split into two commands.
+ *   - the 510-byte message budget: a 511-byte message is rejected with
+ *     RFC 6455 close code 1009 (Message Too Big); a 510-byte message is
+ *     accepted.
+ *   - legacy fallback: a connection offering no subprotocol still
+ *     registers and still splits `\r\n`-joined frames.
+ *
+ * Hermetic against Miniflare; runs in the normal `pnpm test` suite (no
+ * `--e2e` flag). The per-connection negotiation cases live in
+ * `connection-do-ws-subprotocol.test.ts`; this file is the
+ * consolidated end-to-end contract.
+ */
+
+import { env } from 'cloudflare:test';
+import { MAX_WS_MESSAGE_BYTES } from '@serverless-ircd/irc-core';
+import { describe, expect, it } from 'vitest';
+
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      CONNECTION_DO: DurableObjectNamespace;
+      REGISTRY_DO: DurableObjectNamespace;
+      CHANNEL_DO: DurableObjectNamespace;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers — a WebSocket client that records raw WS messages (not pre-split).
+// ---------------------------------------------------------------------------
+
+/** Poll interval (ms) for the waitFor* helpers. */
+const POLL_MS = 10;
+/** Default timeout (ms) for the waitFor* helpers. */
+const DEFAULT_TIMEOUT_MS = 2000;
+
+class SpecWsClient {
+  /** Raw WebSocket messages exactly as delivered (one entry per WS message). */
+  readonly messages: string[] = [];
+  /** Lines split out of `messages` (tolerant of legacy `\r\n` framing). */
+  readonly lines: string[] = [];
+  readonly ws: WebSocket;
+  closedCode: number | undefined;
+
+  constructor(ws: WebSocket) {
+    this.ws = ws;
+    ws.addEventListener('message', (ev: MessageEvent) => {
+      const data = typeof ev.data === 'string' ? ev.data : new TextDecoder().decode(ev.data);
+      this.messages.push(data);
+      for (const line of data.split('\r\n')) {
+        if (line.length > 0) this.lines.push(line);
+      }
+    });
+    ws.addEventListener('close', (ev: CloseEvent) => {
+      this.closedCode = ev.code;
+    });
+  }
+
+  /** Sends one IRC line as a single WS message WITH a trailing CR-LF. */
+  send(line: string): void {
+    this.ws.send(`${line}\r\n`);
+  }
+
+  /**
+   * Sends `frame` verbatim as a single WS message — no trailing CR-LF is
+   * appended. This is how an IRCv3 spec-compliant client sends each IRC
+   * message (one per WS message, no terminator on the wire).
+   */
+  sendRaw(frame: string): void {
+    this.ws.send(frame);
+  }
+
+  async waitForLine(
+    predicate: (line: string) => boolean,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  ): Promise<string> {
+    const deadline = Date.now() + timeoutMs;
+    for (const l of this.lines) if (predicate(l)) return l;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, POLL_MS));
+      for (const l of this.lines) if (predicate(l)) return l;
+    }
+    throw new Error(`waitForLine timed out; lines: ${JSON.stringify(this.lines)}`);
+  }
+
+  async waitForClose(timeoutMs = DEFAULT_TIMEOUT_MS): Promise<number | undefined> {
+    if (this.closedCode !== undefined) return this.closedCode;
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, POLL_MS));
+      if (this.closedCode !== undefined) return this.closedCode;
+    }
+    throw new Error(`waitForClose timed out; messages: ${JSON.stringify(this.messages)}`);
+  }
+
+  /** Waits until at least `n` raw WS messages satisfy `predicate`. */
+  async waitForMessages(
+    predicate: (msg: string) => boolean,
+    n: number,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+  ): Promise<string[]> {
+    const deadline = Date.now() + timeoutMs;
+    const matching = (): string[] => this.messages.filter(predicate);
+    let hit = matching();
+    if (hit.length >= n) return hit;
+    while (Date.now() < deadline) {
+      await new Promise((r) => setTimeout(r, POLL_MS));
+      hit = matching();
+      if (hit.length >= n) return hit;
+    }
+    throw new Error(
+      `waitForMessages(n=${n}) timed out; matching ${hit.length}: ${JSON.stringify(hit)}`,
+    );
+  }
+}
+
+/** Counts raw WS messages whose command token is `cmd` (e.g. 'PONG'). */
+function countCommand(messages: readonly string[], cmd: string): number {
+  const upper = cmd.toUpperCase();
+  let n = 0;
+  for (const msg of messages) {
+    const parts = msg.split(' ');
+    const start = parts[0]?.startsWith(':') ? 1 : 0;
+    if (parts[start]?.toUpperCase() === upper) n++;
+  }
+  return n;
+}
+
+/**
+ * Opens a WebSocket to a fresh ConnectionDO, optionally offering a
+ * `Sec-WebSocket-Protocol` list. Returns the upgrade Response (so the
+ * caller can assert on the echoed header) plus a ready-to-use client.
+ */
+async function openUpgrade(
+  connId: string,
+  protocols?: string,
+): Promise<{ response: Response; client: SpecWsClient }> {
+  const stub = env.CONNECTION_DO.get(env.CONNECTION_DO.idFromName(connId));
+  const headers: Record<string, string> = { Upgrade: 'websocket' };
+  if (protocols !== undefined) {
+    headers['Sec-WebSocket-Protocol'] = protocols;
+  }
+  const response = await stub.fetch('https://do/upgrade', { headers });
+  const ws = response.webSocket;
+  if (ws === undefined || ws === null) {
+    throw new Error('ConnectionDO.fetch did not return a WebSocket');
+  }
+  ws.accept();
+  const client = await new Promise<SpecWsClient>((resolve) => {
+    setTimeout(() => resolve(new SpecWsClient(ws as WebSocket)), 0);
+  });
+  return { response, client };
+}
+
+/** Registers a client using bare spec-style frames (no trailing CR-LF). */
+async function registerBare(client: SpecWsClient, nick: string): Promise<void> {
+  client.sendRaw(`NICK ${nick}`);
+  client.sendRaw(`USER ${nick} 0 * :${nick}`);
+  await client.waitForLine((l) => l.includes(' 001 '));
+}
+
+// ---------------------------------------------------------------------------
+// Spec contract
+// ---------------------------------------------------------------------------
+
+describe('ConnectionDO — IRCv3 WebSocket spec contract (end-to-end)', () => {
+  // --- Sec-WebSocket-Protocol echo ----------------------------------------
+
+  it('echoes text.ircv3.net and binary.ircv3.net back in the 101 response', async () => {
+    const text = await openUpgrade('conn-contract-echo-text', 'text.ircv3.net');
+    expect(text.response.status).toBe(101);
+    expect(text.response.headers.get('Sec-WebSocket-Protocol')).toBe('text.ircv3.net');
+    text.client.ws.close();
+
+    const bin = await openUpgrade('conn-contract-echo-bin', 'binary.ircv3.net');
+    expect(bin.response.status).toBe(101);
+    expect(bin.response.headers.get('Sec-WebSocket-Protocol')).toBe('binary.ircv3.net');
+    bin.client.ws.close();
+  });
+
+  // --- Outbound: one IRC line per WS message, no trailing CR-LF -----------
+
+  it('delivers each outbound IRC line as its own WS message with no trailing CR-LF (spec-text)', async () => {
+    const { client } = await openUpgrade('conn-contract-outbound', 'text.ircv3.net');
+    client.sendRaw('NICK out-bob');
+    client.sendRaw('USER out-bob 0 * :out-bob');
+    await client.waitForLine((l) => l.includes(' 001 '));
+
+    // A successful registration emits several numerics (001..005, MOTD).
+    expect(client.messages.length).toBeGreaterThan(1);
+    for (const msg of client.messages) {
+      expect(msg.endsWith('\r\n')).toBe(false);
+    }
+    client.ws.close();
+  });
+
+  // --- Inbound: one IRC message per WS message ----------------------------
+
+  it('accepts bare single-line inbound frames (no trailing CR-LF) and completes registration (spec-text)', async () => {
+    const { client } = await openUpgrade('conn-contract-inbound-bare', 'text.ircv3.net');
+    // Each command is its own WS message with NO trailing CR-LF — the
+    // spec-mandated client shape. Registration must still complete.
+    await registerBare(client, 'bare-alice');
+    expect(client.lines.some((l) => l.includes(' 001 '))).toBe(true);
+    client.ws.close();
+  });
+
+  it('treats one WS message as exactly one IRC command (embedded CR-LF is not split) in spec-text mode', async () => {
+    const { client } = await openUpgrade('conn-contract-nosplit', 'text.ircv3.net');
+    await registerBare(client, 'nosplit-alice');
+    client.messages.length = 0;
+
+    // One WS message that LOOKS like two PING lines. In spec mode the frame
+    // is a single IRC message, so exactly ONE PONG is emitted.
+    client.sendRaw('PING one\r\nPING two');
+    await client.waitForMessages((m) => countCommand([m], 'PONG') === 1, 1);
+    // Give a grace window for a (incorrect) second PONG to arrive.
+    await new Promise((r) => setTimeout(r, 100));
+    expect(countCommand(client.messages, 'PONG')).toBe(1);
+    client.ws.close();
+  });
+
+  it('splits a joined CR-LF frame into multiple commands in legacy mode', async () => {
+    const { client } = await openUpgrade('conn-contract-legacy-split');
+    await registerBare(client, 'legsplit-bob');
+    client.messages.length = 0;
+
+    // Same joined frame, but legacy framing splits on CR-LF → TWO PONGs.
+    client.sendRaw('PING one\r\nPING two');
+    await client.waitForMessages((m) => countCommand([m], 'PONG') === 1, 2);
+    expect(countCommand(client.messages, 'PONG')).toBe(2);
+    client.ws.close();
+  });
+
+  // --- 510-byte message budget -------------------------------------------
+
+  it(`accepts a ${MAX_WS_MESSAGE_BYTES}-byte message and rejects a ${MAX_WS_MESSAGE_BYTES + 1}-byte message with close 1009 (spec-text)`, async () => {
+    // Accepted: exactly the budget. A PING whose token pads the frame to
+    // MAX_WS_MESSAGE_BYTES bytes parses and is answered with a PONG.
+    const okFrame = `PING :${'a'.repeat(MAX_WS_MESSAGE_BYTES - 'PING :'.length)}`;
+    expect(okFrame.length).toBe(MAX_WS_MESSAGE_BYTES);
+    const ok = await openUpgrade('conn-contract-budget-ok', 'text.ircv3.net');
+    ok.client.sendRaw(okFrame);
+    await ok.client.waitForLine((l) => l.startsWith('PONG') || l.includes(' PONG '));
+    expect(ok.client.closedCode).toBeUndefined();
+    ok.client.ws.close();
+
+    // Rejected: one byte over the budget → RFC 6455 1009 (Message Too Big).
+    const bigFrame = `PING :${'a'.repeat(MAX_WS_MESSAGE_BYTES + 1 - 'PING :'.length)}`;
+    expect(bigFrame.length).toBe(MAX_WS_MESSAGE_BYTES + 1);
+    const big = await openUpgrade('conn-contract-budget-big', 'text.ircv3.net');
+    big.client.sendRaw(bigFrame);
+    const code = await big.client.waitForClose();
+    expect(code).toBe(1009);
+
+    // The same budget applies on a binary.ircv3.net connection (sent as a
+    // binary frame): oversize → close 1009.
+    const bin = await openUpgrade('conn-contract-budget-bin', 'binary.ircv3.net');
+    bin.client.ws.send(new TextEncoder().encode(bigFrame));
+    const binCode = await bin.client.waitForClose();
+    expect(binCode).toBe(1009);
+  });
+
+  // --- Legacy fallback ----------------------------------------------------
+
+  it('still serves a legacy (no subprotocol offer) connection end-to-end', async () => {
+    const { response, client } = await openUpgrade('conn-contract-legacy');
+    expect(response.headers.get('Sec-WebSocket-Protocol')).toBeNull();
+    // Legacy clients join several commands into one CR-LF frame; the server
+    // splits and processes both → registration completes.
+    client.send('NICK legacy-carol');
+    client.send('USER legacy-carol 0 * :legacy-carol');
+    await client.waitForLine((l) => l.includes(' 001 '));
+    expect(client.lines.some((l) => l.includes(' 001 '))).toBe(true);
+    client.ws.close();
+  });
+});