serverless-ircd 0.1.0

package/packages/irc-core/tests/commands/batch.test.ts

@@ -0,0 +1,178 @@
+import { describe, expect, it } from 'vitest';
+import { joinReducer } from '../../src/commands/join';
+import { namesReducer } from '../../src/commands/names';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ChannelState, createChannel } from '../../src/state/channel';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const serverConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(conn: ConnectionState, ids = new SequentialIdFactory()): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock: new FakeClock(1_000),
+    ids,
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = nick.charAt(0).toUpperCase() + nick.slice(1);
+  s.registration = 'registered';
+  return s;
+}
+
+function makeChan(name = '#foo'): ChannelState {
+  return createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+}
+
+function addMember(chan: ChannelState, connId: string, nick: string): void {
+  chan.members.set(connId, { conn: connId, nick, op: false, voice: false });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// namesReducer — IRCv3 batch wrapping
+// ============================================================================
+
+describe('namesReducer — IRCv3 batch', () => {
+  it('wraps the 353 + 366 reply in a BATCH frame when the requester has the batch cap', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('batch');
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L('BATCH +batch-0 names'),
+        L(':irc.example.com 353 alice = #foo :alice'),
+        L(':irc.example.com 366 alice #foo :End of /NAMES list.'),
+        L('BATCH -batch-0'),
+      ]),
+    ]);
+  });
+
+  it('leaves the reply unwrapped when the requester lacks the batch cap', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(':irc.example.com 353 alice = #foo :alice'),
+        L(':irc.example.com 366 alice #foo :End of /NAMES list.'),
+      ]),
+    ]);
+  });
+
+  it('does NOT wrap the 403 error path in a batch', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('batch');
+    const ctx = makeCtx(conn);
+
+    const out = namesReducer(chan, { command: 'NAMES', params: ['badname'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice badname :No such channel')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// joinReducer — IRCv3 batch wrapping of the joiner's NAMES reply
+// ============================================================================
+
+describe('joinReducer — IRCv3 batch', () => {
+  it('wraps the joiner-only 353 + 366 reply in a BATCH when the joiner has the batch cap', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    conn.caps.add('batch');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    // The Send effect to the joiner (c1) carries the wrapped NAMES reply.
+    // The Broadcast JOIN effect goes to the channel and is unaffected.
+    const sendToJoiner = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Send' }> =>
+        e.tag === 'Send' && e.to === 'c1' && e.lines.length === 4,
+    );
+    expect(sendToJoiner).toBeDefined();
+    expect(sendToJoiner?.lines[0]?.text.startsWith('BATCH +batch-')).toBe(true);
+    expect(sendToJoiner?.lines[0]?.text.endsWith(' join')).toBe(true);
+    expect(sendToJoiner?.lines[1]?.text).toBe(':irc.example.com 353 alice = #foo :bob alice');
+    expect(sendToJoiner?.lines[2]?.text).toBe(
+      ':irc.example.com 366 alice #foo :End of /NAMES list.',
+    );
+    expect(sendToJoiner?.lines[3]?.text).toMatch(/^BATCH -batch-\d+$/);
+  });
+
+  it('leaves the joiner NAMES reply unwrapped without the batch cap', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const sendToJoiner = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Send' }> =>
+        e.tag === 'Send' && e.to === 'c1' && e.lines.length === 2,
+    );
+    expect(sendToJoiner).toBeDefined();
+    expect(sendToJoiner?.lines[0]?.text).toBe(':irc.example.com 353 alice = #foo :bob alice');
+    expect(sendToJoiner?.lines[1]?.text).toBe(
+      ':irc.example.com 366 alice #foo :End of /NAMES list.',
+    );
+  });
+
+  it('still wraps the 353+366 in a batch even when the broadcast is cap-split', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    conn.caps.add('batch');
+    conn.caps.add('extended-join');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    // Broadcast (with extended-join cap-split) and Send-to-joiner (batched).
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast?.cap).toBe('extended-join');
+    const send = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Send' }> =>
+        e.tag === 'Send' && e.to === 'c1' && e.lines.length === 4,
+    );
+    expect(send?.lines[0]?.text.startsWith('BATCH +')).toBe(true);
+  });
+});

package/packages/irc-core/tests/commands/cap.test.ts

@@ -0,0 +1,499 @@
+import { describe, expect, it } from 'vitest';
+import { getLsString } from '../../src/caps/capabilities';
+import { capReducer } from '../../src/commands/cap';
+import { userReducer } from '../../src/commands/registration';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const serverConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(state: ConnectionState, cfg: ServerConfig = serverConfig): Ctx {
+  return buildCtx({
+    serverConfig: cfg,
+    clock: new FakeClock(1_000),
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: state,
+  });
+}
+
+function makeState(): ConnectionState {
+  return createConnection({ id: 'c1', connectedSince: 0 });
+}
+
+/** Convenience state with nick+user set, still pre-welcome, not yet CAP-gated. */
+function readyState(): ConnectionState {
+  const s = makeState();
+  s.nick = 'alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registering';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+/** Expected CAP LS body (single-line form, bare list of caps). */
+const EXPECTED_LS = getLsString();
+
+// ============================================================================
+// capReducer — LS
+// ============================================================================
+
+describe('capReducer — LS', () => {
+  it('responds with `CAP * LS :<caps>` for an unregistered client', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LS'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(`:irc.example.com CAP * LS :${EXPECTED_LS}`)]),
+    ]);
+  });
+
+  it('uses the connection nick as the target once registered', () => {
+    const state = readyState();
+    state.registration = 'registered';
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LS'], tags: {} }, ctx);
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toContain('CAP alice LS :');
+    }
+  });
+
+  it('accepts a client-advertised CAP LS version number', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LS', '302'], tags: {} }, ctx);
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toContain('CAP * LS :');
+    }
+  });
+
+  it('accepts a lowercase subcommand token', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['ls'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(`:irc.example.com CAP * LS :${EXPECTED_LS}`)]),
+    ]);
+  });
+
+  it('advertises safelist as a supported capability', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LS'], tags: {} }, ctx);
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      const body = send.lines[0]?.text ?? '';
+      expect(body).toContain('safelist');
+      // safelist has no value — must not appear in `name=value` form.
+      expect(body).not.toContain('safelist=');
+    }
+  });
+
+  it('marks the connection as in CAP negotiation so the welcome is deferred', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LS'], tags: {} }, ctx);
+    expect(out.state.capNegotiating).toBe(true);
+  });
+
+  it('refreshes lastSeen', () => {
+    const state = makeState();
+    const clock = new FakeClock(5_000);
+    const ctx = buildCtx({
+      serverConfig,
+      clock,
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: state,
+    });
+    const out = capReducer(state, { command: 'CAP', params: ['LS'], tags: {} }, ctx);
+    expect(out.state.lastSeen).toBe(5_000);
+  });
+
+  it('emits multiple CAP LS lines with the multiline `*` marker when the payload overflows one line', () => {
+    const longName = `s${'x'.repeat(460)}`;
+    const cfg: ServerConfig = { ...serverConfig, serverName: longName };
+    const state = makeState();
+    const ctx = makeCtx(state, cfg);
+    const out = capReducer(state, { command: 'CAP', params: ['LS'], tags: {} }, ctx);
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      expect(send.lines.length).toBeGreaterThan(1);
+      for (let i = 0; i < send.lines.length - 1; i++) {
+        const line = send.lines[i]?.text ?? '';
+        expect(line).toContain(' LS * :');
+      }
+      const last = send.lines[send.lines.length - 1]?.text ?? '';
+      expect(last).toContain(' LS :');
+      expect(last).not.toContain(' LS * :');
+    }
+  });
+});
+
+// ============================================================================
+// capReducer — LIST
+// ============================================================================
+
+describe('capReducer — LIST', () => {
+  it('returns an empty list when no caps are negotiated', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LIST'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP * LIST :')]),
+    ]);
+  });
+
+  it('returns the currently negotiated caps for a registered client', () => {
+    const state = readyState();
+    state.registration = 'registered';
+    state.caps.add('server-time');
+    state.caps.add('multi-prefix');
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LIST'], tags: {} }, ctx);
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      const body = send.lines[0]?.text ?? '';
+      expect(body).toContain('CAP alice LIST :');
+      expect(body).toContain('server-time');
+      expect(body).toContain('multi-prefix');
+    }
+  });
+
+  it('does not mutate caps or start CAP negotiation', () => {
+    const state = makeState();
+    state.caps.add('echo-message');
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['LIST'], tags: {} }, ctx);
+    expect(out.state.caps).toEqual(new Set(['echo-message']));
+    expect(out.state.capNegotiating).toBe(false);
+  });
+
+  it('emits multiple CAP LIST lines with the `*` marker when negotiated caps overflow one line', () => {
+    const longName = `s${'x'.repeat(460)}`;
+    const cfg: ServerConfig = { ...serverConfig, serverName: longName };
+    const state = makeState();
+    state.caps.add('server-time');
+    state.caps.add('multi-prefix');
+    state.caps.add('echo-message');
+    const ctx = makeCtx(state, cfg);
+    const out = capReducer(state, { command: 'CAP', params: ['LIST'], tags: {} }, ctx);
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      expect(send.lines.length).toBeGreaterThan(1);
+      for (let i = 0; i < send.lines.length - 1; i++) {
+        expect(send.lines[i]?.text).toContain(' LIST * :');
+      }
+      expect(send.lines[send.lines.length - 1]?.text).toContain(' LIST :');
+    }
+  });
+});
+
+// ============================================================================
+// capReducer — REQ
+// ============================================================================
+
+describe('capReducer — REQ', () => {
+  it('ACKs a single known cap and records it on the connection', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(
+      state,
+      { command: 'CAP', params: ['REQ', 'server-time'], tags: {} },
+      ctx,
+    );
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP alice ACK :server-time')]),
+    ]);
+    expect(out.state.caps.has('server-time')).toBe(true);
+  });
+
+  it('ACKs the safelist cap and records it on the connection', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['REQ', 'safelist'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP alice ACK :safelist')]),
+    ]);
+    expect(out.state.caps.has('safelist')).toBe(true);
+  });
+
+  it('NAKs a single unknown cap', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['REQ', 'nope'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP alice NAK :nope')]),
+    ]);
+    expect(out.state.caps.has('nope')).toBe(false);
+  });
+
+  it('ACKs multiple known caps requested in one REQ', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(
+      state,
+      { command: 'CAP', params: ['REQ', 'server-time multi-prefix'], tags: {} },
+      ctx,
+    );
+    const send = out.effects[0];
+    expect(send).toBeDefined();
+    if (send?.tag === 'Send') {
+      const body = send.lines[0]?.text ?? '';
+      expect(body).toContain('ACK');
+      expect(body).toContain('server-time');
+      expect(body).toContain('multi-prefix');
+    }
+    expect(out.state.caps.has('server-time')).toBe(true);
+    expect(out.state.caps.has('multi-prefix')).toBe(true);
+  });
+
+  it('NAKs the entire REQ when any requested cap is unknown (all-or-nothing)', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(
+      state,
+      { command: 'CAP', params: ['REQ', 'server-time nope'], tags: {} },
+      ctx,
+    );
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP alice NAK :server-time nope')]),
+    ]);
+    expect(out.state.caps.has('server-time')).toBe(false);
+    expect(out.state.caps.has('nope')).toBe(false);
+  });
+
+  it('echoes the disable marker (`-`) in the ACK and removes the cap', () => {
+    const state = readyState();
+    state.caps.add('server-time');
+    const ctx = makeCtx(state);
+    const out = capReducer(
+      state,
+      { command: 'CAP', params: ['REQ', '-server-time'], tags: {} },
+      ctx,
+    );
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP alice ACK :-server-time')]),
+    ]);
+    expect(out.state.caps.has('server-time')).toBe(false);
+  });
+
+  it('marks the connection as in CAP negotiation so the welcome is deferred', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    capReducer(state, { command: 'CAP', params: ['REQ', 'server-time'], tags: {} }, ctx);
+    expect(state.capNegotiating).toBe(true);
+  });
+
+  it('emits 461 when no caps parameter is supplied', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['REQ'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice CAP :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 461 when the caps parameter is an empty trailing string', () => {
+    const state = readyState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['REQ', ''], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice CAP :Not enough parameters')]),
+    ]);
+  });
+
+  it('targets `*` in ACK when the client has no nick yet', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(
+      state,
+      { command: 'CAP', params: ['REQ', 'server-time'], tags: {} },
+      ctx,
+    );
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com CAP * ACK :server-time')]),
+    ]);
+  });
+
+  it('targets `*` in the 461 reply when the client has no nick yet', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['REQ'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * CAP :Not enough parameters')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// capReducer — END
+// ============================================================================
+
+describe('capReducer — END', () => {
+  it('triggers the welcome sequence when registration is otherwise complete', () => {
+    const state = readyState();
+    state.capNegotiating = true;
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['END'], tags: {} }, ctx);
+    expect(out.state.registration).toBe('registered');
+    expect(out.state.capNegotiating).toBe(false);
+    const welcome = out.effects[0];
+    expect(welcome).toBeDefined();
+    if (welcome?.tag === 'Send') {
+      expect(welcome.lines[0]?.text).toContain('001 alice');
+    }
+  });
+
+  it('does not emit a welcome when nick is not yet set', () => {
+    const state = makeState();
+    state.user = 'alice';
+    state.realname = 'Alice';
+    state.capNegotiating = true;
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['END'], tags: {} }, ctx);
+    expect(out.state.registration).not.toBe('registered');
+    expect(out.effects).toEqual([]);
+    expect(out.state.capNegotiating).toBe(false);
+  });
+
+  it('does not emit a welcome when user is not yet set', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.capNegotiating = true;
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['END'], tags: {} }, ctx);
+    expect(out.state.registration).not.toBe('registered');
+    expect(out.effects).toEqual([]);
+  });
+
+  it('clears capNegotiating even when registration is incomplete', () => {
+    const state = makeState();
+    state.capNegotiating = true;
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['END'], tags: {} }, ctx);
+    expect(out.state.capNegotiating).toBe(false);
+  });
+
+  it('is a no-op when the connection is already registered', () => {
+    const state = readyState();
+    state.registration = 'registered';
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['END'], tags: {} }, ctx);
+    expect(out.effects).toEqual([]);
+    expect(out.state.registration).toBe('registered');
+  });
+});
+
+// ============================================================================
+// capReducer — deferred welcome integration with NICK/USER
+// ============================================================================
+
+describe('capReducer — deferred welcome', () => {
+  it('does not fire the welcome on USER while CAP negotiation is in progress', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.capNegotiating = true;
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    const out = userReducer(
+      state,
+      { command: 'USER', params: ['alice', '0', '*', 'Alice'], tags: {} },
+      ctx,
+    );
+    expect(out.state.registration).toBe('registering');
+    expect(out.effects).toEqual([]);
+  });
+
+  it('fires the welcome on CAP END after USER was deferred', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.capNegotiating = true;
+    state.registration = 'registering';
+    const ctx = makeCtx(state);
+    userReducer(state, { command: 'USER', params: ['alice', '0', '*', 'Alice'], tags: {} }, ctx);
+    const out = capReducer(state, { command: 'CAP', params: ['END'], tags: {} }, ctx);
+    expect(out.state.registration).toBe('registered');
+    const welcome = out.effects[0];
+    expect(welcome).toBeDefined();
+    if (welcome?.tag === 'Send') {
+      expect(welcome.lines[0]?.text).toContain('001 alice');
+    }
+  });
+});
+
+// ============================================================================
+// capReducer — unknown / invalid subcommands
+// ============================================================================
+
+describe('capReducer — unknown subcommands', () => {
+  it('emits 410 ERR_INVALIDCAPCMD for an unknown subcommand', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['BOGUS'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 410 * BOGUS :Invalid CAP command')]),
+    ]);
+  });
+
+  it('emits 410 for CAP NEW sent from a client (server-to-client only)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['NEW'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 410 * NEW :Invalid CAP command')]),
+    ]);
+  });
+
+  it('emits 410 for CAP DEL sent from a client (server-to-client only)', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['DEL'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 410 * DEL :Invalid CAP command')]),
+    ]);
+  });
+
+  it('emits 410 when the subcommand is missing entirely', () => {
+    const state = makeState();
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: [], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 410 * :Invalid CAP command')]),
+    ]);
+  });
+
+  it('uses the connection nick in the 410 reply when registered', () => {
+    const state = readyState();
+    state.registration = 'registered';
+    const ctx = makeCtx(state);
+    const out = capReducer(state, { command: 'CAP', params: ['BOGUS'], tags: {} }, ctx);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 410 alice BOGUS :Invalid CAP command')]),
+    ]);
+  });
+});