serverless-ircd 0.1.0

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

@@ -0,0 +1,1048 @@
+import { describe, expect, it } from 'vitest';
+import { channelModeReducer, userModeReducer } from '../../src/commands/mode';
+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, clock = new FakeClock(1_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    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,
+  op = false,
+  voice = false,
+): void {
+  chan.members.set(connId, { conn: connId, nick, op, voice });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// channelModeReducer — boolean modes
+// ============================================================================
+
+describe('channelModeReducer — boolean modes', () => {
+  it('sets +t when caller is op and broadcasts MODE +t to the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+t'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.topicLock).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'topicLock', set: true }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +t')]),
+    ]);
+  });
+
+  it('clears -t when caller is op', () => {
+    const chan = makeChan('#foo');
+    chan.modes.topicLock = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-t'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.topicLock).toBe(false);
+    expect(out.effects).toContainEqual<EffectType>(
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -t')]),
+    );
+  });
+
+  const booleanModes: Array<[string, keyof ChannelState['modes']]> = [
+    ['i', 'inviteOnly'],
+    ['t', 'topicLock'],
+    ['n', 'noExternal'],
+    ['m', 'moderated'],
+    ['s', 'secret'],
+    ['p', 'private'],
+  ];
+  for (const [letter, field] of booleanModes) {
+    it(`sets +${letter} (${field}) and clears -${letter}`, () => {
+      const chan = makeChan('#foo');
+      addMember(chan, 'c1', 'alice', true);
+      const conn = makeConn();
+      const ctx = makeCtx(conn);
+
+      channelModeReducer(chan, { command: 'MODE', params: ['#foo', `+${letter}`], tags: {} }, ctx);
+      expect(chan.modes[field]).toBe(true);
+
+      channelModeReducer(chan, { command: 'MODE', params: ['#foo', `-${letter}`], tags: {} }, ctx);
+      expect(chan.modes[field]).toBe(false);
+    });
+  }
+
+  it('combines multiple boolean mode changes into one broadcast', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+tn'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.topicLock).toBe(true);
+    expect(chan.modes.noExternal).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        modeChanges: [
+          { mode: 'topicLock', set: true },
+          { mode: 'noExternal', set: true },
+        ],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +tn')]),
+    ]);
+  });
+
+  it('toggles mixed sign changes preserving sign boundaries', () => {
+    const chan = makeChan('#foo');
+    chan.modes.topicLock = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-t+n'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.topicLock).toBe(false);
+    expect(chan.modes.noExternal).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        modeChanges: [
+          { mode: 'topicLock', set: false },
+          { mode: 'noExternal', set: true },
+        ],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -t+n')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// channelModeReducer — prefix modes (o, v)
+// ============================================================================
+
+describe('channelModeReducer — prefix modes', () => {
+  it('+o <nick> grants op to the named member and broadcasts MODE +o nick', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+o', 'bob'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.members.get('c2')?.op).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        memberships: [{ type: 'add', conn: 'c2', nick: 'bob', op: true, voice: false }],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +o bob')]),
+    ]);
+  });
+
+  it('-o <nick> removes op from the named member', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-o', 'bob'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.members.get('c2')?.op).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        memberships: [{ type: 'add', conn: 'c2', nick: 'bob', op: false, voice: false }],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -o bob')]),
+    ]);
+  });
+
+  it('+v <nick> grants voice', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+v', 'bob'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.members.get('c2')?.voice).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        memberships: [{ type: 'add', conn: 'c2', nick: 'bob', op: false, voice: true }],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +v bob')]),
+    ]);
+  });
+
+  it('-v <nick> removes voice', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob', false, true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-v', 'bob'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.members.get('c2')?.voice).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        memberships: [{ type: 'add', conn: 'c2', nick: 'bob', op: false, voice: false }],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -v bob')]),
+    ]);
+  });
+
+  it('matches nicks case-insensitively for +o', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'Bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    channelModeReducer(chan, { command: 'MODE', params: ['#foo', '+o', 'BOB'], tags: {} }, ctx);
+
+    expect(chan.members.get('c2')?.op).toBe(true);
+  });
+
+  it('emits 441 ERR_USERNOTINCHANNEL when +o target is not on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+o', 'carol'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 441 alice carol #foo :They are not on that channel')]),
+    ]);
+    expect(chan.members.size).toBe(1);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when +o has no nick argument', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+o'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice o :Not enough parameters')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// channelModeReducer — key (k)
+// ============================================================================
+
+describe('channelModeReducer — key (k)', () => {
+  it('+k <key> sets the channel key and broadcasts MODE +k key', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+k', 'secret'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.key).toBe('secret');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', {
+        modeChanges: [{ mode: 'key', set: true, arg: 'secret' }],
+      }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +k secret')]),
+    ]);
+  });
+
+  it('-k clears the channel key without requiring an argument', () => {
+    const chan = makeChan('#foo');
+    chan.modes.key = 'secret';
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-k'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.key).toBeUndefined();
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'key', set: false }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -k')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when +k has no argument', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+k'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice k :Not enough parameters')]),
+    ]);
+    expect(chan.modes.key).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// channelModeReducer — limit (l)
+// ============================================================================
+
+describe('channelModeReducer — limit (l)', () => {
+  it('+l <N> sets the channel limit and broadcasts MODE +l N', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+l', '30'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.limit).toBe(30);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'limit', set: true, arg: 30 }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +l 30')]),
+    ]);
+  });
+
+  it('-l clears the channel limit without requiring an argument', () => {
+    const chan = makeChan('#foo');
+    chan.modes.limit = 30;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-l'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.limit).toBeUndefined();
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'limit', set: false }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -l')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when +l has no argument', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+l'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice l :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when +l argument is non-numeric', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+l', 'big'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice l :Not enough parameters')]),
+    ]);
+    expect(chan.modes.limit).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// channelModeReducer — ban masks (b)
+// ============================================================================
+
+describe('channelModeReducer — ban masks', () => {
+  it('+b <mask> adds to the ban list and broadcasts MODE +b mask', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+b', 'bob!*@*'], tags: {} },
+      ctx,
+    );
+
+    expect([...chan.banMasks]).toEqual(['bob!*@*']);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { banMaskChanges: [{ type: 'add', mask: 'bob!*@*' }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +b bob!*@*')]),
+    ]);
+  });
+
+  it('-b <mask> removes from the ban list', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('bob!*@*');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '-b', 'bob!*@*'], tags: {} },
+      ctx,
+    );
+
+    expect([...chan.banMasks]).toEqual([]);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { banMaskChanges: [{ type: 'remove', mask: 'bob!*@*' }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo -b bob!*@*')]),
+    ]);
+  });
+
+  it('emits 367 RPL_BANLIST for each ban mask then 368 ENDOFBANLIST when querying with +b alone', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('bob!*@*');
+    chan.banMasks.add('carol!*@*');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+b'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 367 alice #foo bob!*@*')]),
+      Effect.send('c1', [L(':irc.example.com 367 alice #foo carol!*@*')]),
+      Effect.send('c1', [L(':irc.example.com 368 alice #foo :End of Channel Ban List')]),
+    ]);
+  });
+
+  it('uses * in 367/368 replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('bob!*@*');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo', 'b'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 367 * #foo bob!*@*')]),
+      Effect.send('c1', [L(':irc.example.com 368 * #foo :End of Channel Ban List')]),
+    ]);
+  });
+
+  it('emits only 368 ENDOFBANLIST when there are no bans', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo', 'b'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 368 alice #foo :End of Channel Ban List')]),
+    ]);
+  });
+
+  it('queries the ban list inline when +b appears in a combined modestring without an arg', () => {
+    const chan = makeChan('#foo');
+    chan.banMasks.add('bob!*@*');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+tb'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.topicLock).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 367 alice #foo bob!*@*')]),
+      Effect.send('c1', [L(':irc.example.com 368 alice #foo :End of Channel Ban List')]),
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'topicLock', set: true }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +t')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when +b has no argument and the list is queried empty (still emits 368)', () => {
+    // Per modern ircd behavior, +b alone queries the list. So no 461 here.
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+b'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 368 alice #foo :End of Channel Ban List')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// channelModeReducer — read form
+// ============================================================================
+
+describe('channelModeReducer — read', () => {
+  it('emits 324 RPL_CHANNELMODEIS with the current boolean modes', () => {
+    const chan = makeChan('#foo');
+    chan.modes.topicLock = true;
+    chan.modes.noExternal = true;
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 324 alice #foo +tn')]),
+    ]);
+  });
+
+  it('includes k and l parameters in 324 when set', () => {
+    const chan = makeChan('#foo');
+    chan.modes.topicLock = true;
+    chan.modes.key = 'secret';
+    chan.modes.limit = 50;
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 324 alice #foo +tkl secret 50')]),
+    ]);
+  });
+
+  it('emits 324 with bare + when no modes are set', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 324 alice #foo +')]),
+    ]);
+  });
+
+  it('uses * in 324 reply when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.topicLock = true;
+    addMember(chan, 'c1', 'alice');
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 324 * #foo +t')]),
+    ]);
+  });
+
+  it('allows non-member to read modes of a public channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.topicLock = true;
+    addMember(chan, 'c2', 'bob', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 324 alice #foo +t')]),
+    ]);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when a non-member queries a +s channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.secret = true;
+    addMember(chan, 'c2', 'bob', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 alice #foo :You're not on that channel")]),
+    ]);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when a non-member attempts to change modes on a +s channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.secret = true;
+    addMember(chan, 'c2', 'bob', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+t'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 alice #foo :You're not on that channel")]),
+    ]);
+    expect(chan.modes.topicLock).toBe(false);
+  });
+});
+
+// ============================================================================
+// channelModeReducer — authorization & errors
+// ============================================================================
+
+describe('channelModeReducer — authorization & errors', () => {
+  it('emits 482 ERR_CHANOPRIVSNEEDED when a non-op attempts a mode change', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+t'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 482 alice #foo :You're not channel operator")]),
+    ]);
+    expect(chan.modes.topicLock).toBe(false);
+  });
+
+  it('emits 482 when a non-op attempts +o on someone', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', false);
+    addMember(chan, 'c2', 'bob', false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+o', 'bob'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 482 alice #foo :You're not channel operator")]),
+    ]);
+    expect(chan.members.get('c2')?.op).toBe(false);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when a non-member attempts a mode change', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+t'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 442 alice #foo :You're not on that channel")]),
+    ]);
+  });
+
+  it('emits 472 ERR_UNKNOWNMODE for an unknown mode char and continues processing the rest', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+xz'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 472 alice x :is unknown mode char to me')]),
+      Effect.send('c1', [L(':irc.example.com 472 alice z :is unknown mode char to me')]),
+    ]);
+    expect(chan.modes.topicLock).toBe(false);
+  });
+
+  it('applies valid mode chars and reports unknown ones in the same modestring', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+tz'], tags: {} },
+      ctx,
+    );
+
+    expect(chan.modes.topicLock).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 472 alice z :is unknown mode char to me')]),
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'topicLock', set: true }] }),
+      Effect.broadcast('#foo', [L(':alice!alice@example.com MODE #foo +t')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when no channel argument is supplied', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice MODE :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for an invalid channel name', () => {
+    const chan = makeChan('foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['foo', '+t'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice foo :No such channel')]),
+    ]);
+  });
+
+  it('emits 403 ERR_NOSUCHCHANNEL for an empty channel name', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: ['', '+t'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice  :No such channel')]),
+    ]);
+  });
+
+  it('uses * in error replies when the connection has no nick (defensive)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(chan, { command: 'MODE', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * MODE :Not enough parameters')]),
+    ]);
+  });
+
+  it('broadcasts MODE with the bare hostmask (? fallback) when nick is undefined', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = channelModeReducer(
+      chan,
+      { command: 'MODE', params: ['#foo', '+t'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.applyChannelDelta('#foo', { modeChanges: [{ mode: 'topicLock', set: true }] }),
+      Effect.broadcast('#foo', [L(':? MODE #foo +t')]),
+    ]);
+  });
+
+  it('updates the connection lastSeen to ctx.clock.now()', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const clock = new FakeClock(9_000);
+    const ctx = makeCtx(conn, clock);
+
+    channelModeReducer(chan, { command: 'MODE', params: ['#foo', '+t'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(9_000);
+  });
+});
+
+// ============================================================================
+// userModeReducer
+// ============================================================================
+
+describe('userModeReducer — read', () => {
+  it('emits 221 RPL_UMODEIS with the current user modes', () => {
+    const conn = makeConn();
+    conn.userModes.invisible = true;
+    conn.userModes.wallops = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +iw')]),
+    ]);
+  });
+
+  it('emits 221 with bare + when no user modes are set', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 221 alice +')]),
+    ]);
+  });
+});
+
+describe('userModeReducer — write', () => {
+  it('sets +i (invisible) and broadcasts no echo (local-only state change)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+i'], tags: {} }, ctx);
+
+    expect(conn.userModes.invisible).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':alice!alice@example.com MODE alice +i')]),
+    ]);
+  });
+
+  it('clears -i', () => {
+    const conn = makeConn();
+    conn.userModes.invisible = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '-i'], tags: {} }, ctx);
+
+    expect(conn.userModes.invisible).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':alice!alice@example.com MODE alice -i')]),
+    ]);
+  });
+
+  it('toggles +w / -w (wallops)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    userModeReducer(conn, { command: 'MODE', params: ['alice', '+w'], tags: {} }, ctx);
+    expect(conn.userModes.wallops).toBe(true);
+
+    userModeReducer(conn, { command: 'MODE', params: ['alice', '-w'], tags: {} }, ctx);
+    expect(conn.userModes.wallops).toBe(false);
+  });
+
+  it('toggles +s / -s (server notices)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    userModeReducer(conn, { command: 'MODE', params: ['alice', '+s'], tags: {} }, ctx);
+    expect(conn.userModes.serverNotices).toBe(true);
+
+    userModeReducer(conn, { command: 'MODE', params: ['alice', '-s'], tags: {} }, ctx);
+    expect(conn.userModes.serverNotices).toBe(false);
+  });
+
+  it('rejects +o via MODE with 481 ERR_NOPRIVILEGES (oper is granted via OPER only)', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+o'], tags: {} }, ctx);
+
+    expect(conn.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L(":irc.example.com 481 alice :Permission Denied - You're not an IRC operator"),
+      ]),
+    ]);
+  });
+
+  it('allows an existing oper to drop +o via -o', () => {
+    const conn = makeConn();
+    conn.userModes.oper = true;
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '-o'], tags: {} }, ctx);
+
+    expect(conn.userModes.oper).toBe(false);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':alice!alice@example.com MODE alice -o')]),
+    ]);
+  });
+
+  it('combines multiple user mode changes into one echo', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+iw'], tags: {} }, ctx);
+
+    expect(conn.userModes.invisible).toBe(true);
+    expect(conn.userModes.wallops).toBe(true);
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':alice!alice@example.com MODE alice +iw')]),
+    ]);
+  });
+
+  it('emits 501 ERR_UMODEUNKNOWNFLAG for an unknown user mode char', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['alice', '+z'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 501 alice :Unknown MODE flag')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when no nick argument is supplied', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice MODE :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 502 ERR_USERSDONTMATCH when the target nick is not the connection', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = userModeReducer(conn, { command: 'MODE', params: ['bob', '+i'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 502 alice :Cannot change mode for other users')]),
+    ]);
+  });
+
+  it('updates lastSeen to ctx.clock.now()', () => {
+    const conn = makeConn();
+    const clock = new FakeClock(11_000);
+    const ctx = makeCtx(conn, clock);
+
+    userModeReducer(conn, { command: 'MODE', params: ['alice', '+i'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(11_000);
+  });
+});