serverless-ircd 0.1.0

package/packages/irc-core/tests/commands/invite-notify.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, it } from 'vitest';
+import { inviteReducer } from '../../src/commands/invite';
+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): void {
+  chan.members.set(connId, { conn: connId, nick, op, voice: false });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// inviteReducer — invite-notify cap fanout
+// ============================================================================
+
+describe('inviteReducer — invite-notify cap fanout', () => {
+  it('broadcasts the INVITE line to invite-notify cap-enabled channel members', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    addMember(chan, 'c3', 'carol');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['dave', '#foo'], tags: {} }, ctx);
+
+    // The 341 numeric and the SendToNick to the invitee come first; the
+    // invite-notify broadcast is the trailing effect.
+    const broadcast = out.effects.find(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    expect(broadcast).toBeDefined();
+    expect(broadcast?.cap).toBe('invite-notify');
+    expect(broadcast?.lines).toEqual<RawLine[]>([L(':alice!alice@example.com INVITE dave #foo')]);
+    expect(broadcast?.capLines).toBeUndefined();
+  });
+
+  it('emits exactly one INVITE to the invitee via SendToNick, regardless of invite-notify', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob'); // invite-notify peer on-channel
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['dave', '#foo'], tags: {} }, ctx);
+
+    const sendToNicks = out.effects.filter(
+      (e): e is Extract<EffectType, { tag: 'SendToNick' }> => e.tag === 'SendToNick',
+    );
+    expect(sendToNicks).toHaveLength(1);
+    expect(sendToNicks[0]?.nick).toBe('dave');
+    expect(sendToNicks[0]?.lines).toEqual<RawLine[]>([
+      L(':alice!alice@example.com INVITE dave #foo'),
+    ]);
+  });
+
+  it('places the invite-notify broadcast AFTER the SendToNick to the invitee', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['dave', '#foo'], tags: {} }, ctx);
+
+    const tags = out.effects.map((e) => e.tag);
+    const sendToNickIdx = tags.indexOf('SendToNick');
+    const broadcastIdx = tags.indexOf('Broadcast');
+    expect(sendToNickIdx).toBeGreaterThanOrEqual(0);
+    expect(broadcastIdx).toBeGreaterThan(sendToNickIdx);
+  });
+
+  it('does NOT emit an invite-notify broadcast when there are no other channel members', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    // No other members.
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['dave', '#foo'], tags: {} }, ctx);
+
+    const broadcasts = out.effects.filter(
+      (e): e is Extract<EffectType, { tag: 'Broadcast' }> => e.tag === 'Broadcast',
+    );
+    // The invite-notify broadcast is cap-only; with no peers to receive it
+    // the reducer still emits a (no-op) cap-only broadcast so dispatch can
+    // route per-recipient. The test asserts the cap is set correctly.
+    expect(broadcasts).toHaveLength(1);
+    expect(broadcasts[0]?.cap).toBe('invite-notify');
+  });
+
+  it('does not affect error paths (invitee already on channel)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    // 443 only; no SendToNick, no broadcast.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 443 alice bob #foo :is already on channel')]),
+    ]);
+  });
+
+  it('does not affect the +i non-op rejection path', () => {
+    const chan = makeChan('#foo');
+    chan.modes.inviteOnly = true;
+    addMember(chan, 'c1', 'alice', false);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['dave', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 482 alice #foo :You're not channel operator")]),
+    ]);
+  });
+});

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

@@ -0,0 +1,321 @@
+import { describe, expect, it } from 'vitest';
+import { inviteReducer } from '../../src/commands/invite';
+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): void {
+  chan.members.set(connId, { conn: connId, nick, op, voice: false });
+}
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// inviteReducer — success
+// ============================================================================
+
+describe('inviteReducer — success', () => {
+  it('emits 341 RPL_INVITING to the inviter and an INVITE notice to the invitee', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    // bob is offline (not on the channel) — the canonical invite case.
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 341 alice #foo bob')]),
+      Effect.sendToNick('bob', 'c1', [L(':alice!alice@example.com INVITE bob #foo')]),
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com INVITE bob #foo')],
+        undefined,
+        'invite-notify',
+      ),
+    ]);
+  });
+
+  it('records the pending invite in channel state so the invitee can bypass +i', () => {
+    const chan = makeChan('#foo');
+    chan.modes.inviteOnly = true;
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    expect(chan.pendingInvites.has('bob')).toBe(true);
+  });
+
+  it('allows inviting a nick that is not currently on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 341 alice #foo bob')]),
+      Effect.sendToNick('bob', 'c1', [L(':alice!alice@example.com INVITE bob #foo')]),
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com INVITE bob #foo')],
+        undefined,
+        'invite-notify',
+      ),
+    ]);
+  });
+
+  it('matches the invitee nick case-insensitively', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['BOB', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 341 alice #foo BOB')]),
+      Effect.sendToNick('BOB', 'c1', [L(':alice!alice@example.com INVITE BOB #foo')]),
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com INVITE BOB #foo')],
+        undefined,
+        'invite-notify',
+      ),
+    ]);
+    expect(chan.pendingInvites.has('bob')).toBe(true);
+  });
+
+  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(7_700);
+    const ctx = makeCtx(conn, clock);
+
+    inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    expect(conn.lastSeen).toBe(7_700);
+  });
+});
+
+// ============================================================================
+// inviteReducer — errors
+// ============================================================================
+
+describe('inviteReducer — errors', () => {
+  it('emits 461 ERR_NEEDMOREPARAMS when the channel argument is missing', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice INVITE :Not enough parameters')]),
+    ]);
+  });
+
+  it('emits 461 ERR_NEEDMOREPARAMS when both arguments are missing', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice INVITE :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 = inviteReducer(chan, { command: 'INVITE', params: ['bob', 'foo'], 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 = inviteReducer(chan, { command: 'INVITE', params: ['bob', ''], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice  :No such channel')]),
+    ]);
+  });
+
+  it('emits 442 ERR_NOTONCHANNEL when the inviter is not on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c2', 'bob', true);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(
+      chan,
+      { command: 'INVITE', params: ['carol', '#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 482 ERR_CHANOPRIVSNEEDED when a non-op invites to a +i channel', () => {
+    const chan = makeChan('#foo');
+    chan.modes.inviteOnly = true;
+    addMember(chan, 'c1', 'alice', false);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(
+      chan,
+      { command: 'INVITE', params: ['carol', '#foo'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(":irc.example.com 482 alice #foo :You're not channel operator")]),
+    ]);
+    expect(chan.pendingInvites.has('carol')).toBe(false);
+  });
+
+  it('allows a non-op to invite to a non-invite-only channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', false);
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 341 alice #foo bob')]),
+      Effect.sendToNick('bob', 'c1', [L(':alice!alice@example.com INVITE bob #foo')]),
+      Effect.broadcast(
+        '#foo',
+        [L(':alice!alice@example.com INVITE bob #foo')],
+        undefined,
+        'invite-notify',
+      ),
+    ]);
+  });
+
+  it('emits 443 ERR_USERONCHANNEL when the invitee is already on the channel', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    // Already a member → 443, no 341, no INVITE.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 443 alice bob #foo :is already on channel')]),
+    ]);
+    expect(chan.pendingInvites.has('bob')).toBe(false);
+  });
+
+  it('emits 443 ERR_USERONCHANNEL when checking by case-insensitive nick match', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    addMember(chan, 'c2', 'Bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['BOB', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 443 alice BOB #foo :is already on channel')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// inviteReducer — defensive paths
+// ============================================================================
+
+describe('inviteReducer — defensive', () => {
+  it('uses * in error replies when the connection has no nick', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice', true);
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(conn);
+
+    const out = inviteReducer(chan, { command: 'INVITE', params: ['bob'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 * INVITE :Not enough parameters')]),
+    ]);
+  });
+
+  it('uses ? fallback for the source hostmask 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 = inviteReducer(chan, { command: 'INVITE', params: ['bob', '#foo'], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 341 * #foo bob')]),
+      Effect.sendToNick('bob', 'c1', [L(':? INVITE bob #foo')]),
+      Effect.broadcast('#foo', [L(':? INVITE bob #foo')], undefined, 'invite-notify'),
+    ]);
+  });
+});

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

@@ -0,0 +1,209 @@
+import { describe, expect, it } from 'vitest';
+import { generateIsupport } from '../../src/commands/isupport';
+import type { ServerConfig } from '../../src/types';
+
+function makeConfig(overrides: Partial<ServerConfig> = {}): ServerConfig {
+  return {
+    serverName: 'irc.example.com',
+    networkName: 'ExampleNet',
+    maxChannelsPerUser: 30,
+    maxTargetsPerCommand: 10,
+    maxListEntries: 50,
+    nickLen: 30,
+    channelLen: 50,
+    topicLen: 390,
+    quitMessage: 'Client Quit',
+    ...overrides,
+  };
+}
+
+// ============================================================================
+// generateIsupport — token set
+// ============================================================================
+
+describe('generateIsupport — token set', () => {
+  it('includes the canonical RFC 2812/IRCv3 base tokens', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+
+    expect(all.some((t) => t.startsWith('CHANTYPES='))).toBe(true);
+    expect(all.some((t) => t.startsWith('CHANMODES='))).toBe(true);
+    expect(all.some((t) => t.startsWith('PREFIX='))).toBe(true);
+    expect(all.some((t) => t.startsWith('MODES='))).toBe(true);
+    expect(all.some((t) => t.startsWith('NICKLEN='))).toBe(true);
+    expect(all.some((t) => t.startsWith('CHANNELLEN='))).toBe(true);
+    expect(all.some((t) => t.startsWith('TOPICLEN='))).toBe(true);
+    expect(all.some((t) => t.startsWith('CASEMAPPING='))).toBe(true);
+    expect(all.some((t) => t.startsWith('NETWORK='))).toBe(true);
+    expect(all.some((t) => t.startsWith('MAXCHANNELS='))).toBe(true);
+    expect(all.some((t) => t.startsWith('MAXTARGETS='))).toBe(true);
+  });
+
+  it('ends the final line with the `:are supported by this server` trailer', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const last = lines.at(-1);
+    expect(last?.text.endsWith(':are supported by this server')).toBe(true);
+  });
+
+  it('produces at least one 005 line', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    expect(lines.length).toBeGreaterThanOrEqual(1);
+    expect(lines[0]?.text).toMatch(/ 005 /u);
+  });
+
+  it('derives token values from serverConfig rather than hard-coding', () => {
+    const cfg = makeConfig({ nickLen: 15, channelLen: 64, topicLen: 300, networkName: 'Zeta' });
+    const lines = generateIsupport(cfg, new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+
+    expect(all).toContain('NICKLEN=15');
+    expect(all).toContain('CHANNELLEN=64');
+    expect(all).toContain('TOPICLEN=300');
+    expect(all).toContain('NETWORK=Zeta');
+  });
+});
+
+// ============================================================================
+// generateIsupport — token values
+// ============================================================================
+
+describe('generateIsupport — token values', () => {
+  it('emits CHANTYPES=#', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('CHANTYPES=#');
+  });
+
+  it('emits PREFIX=(ov)@+', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('PREFIX=(ov)@+');
+  });
+
+  it('emits CASEMAPPING=rfc1459', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('CASEMAPPING=rfc1459');
+  });
+
+  it('emits CHANMODES with the four comma-separated mode classes', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    const cm = all.find((t) => t.startsWith('CHANMODES='));
+    expect(cm).toBeDefined();
+    // Class A (list), B (param-set), C (param-always), D (boolean).
+    expect(cm?.split('=').at(1)?.split(',').length).toBe(4);
+    // Our server supports: list=b, key=k, limit=l, bool=imnpst.
+    expect(cm).toContain('b');
+    expect(cm).toContain('k');
+    expect(cm).toContain('l');
+    expect(cm).toContain('i');
+    expect(cm).toContain('t');
+    expect(cm).toContain('n');
+    expect(cm).toContain('m');
+    expect(cm).toContain('s');
+    expect(cm).toContain('p');
+  });
+
+  it('emits MODES=4 (max mode changes per command)', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MODES=4');
+  });
+
+  it('emits MAXCHANNELS from serverConfig.maxChannelsPerUser', () => {
+    const lines = generateIsupport(makeConfig({ maxChannelsPerUser: 20 }), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MAXCHANNELS=20');
+  });
+
+  it('emits MAXTARGETS from serverConfig.maxTargetsPerCommand', () => {
+    const lines = generateIsupport(makeConfig({ maxTargetsPerCommand: 4 }), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('MAXTARGETS=4');
+  });
+
+  it('advertises the bare SAFELIST token (LIST is non-destructive)', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('SAFELIST');
+    // SAFELIST is a boolean token (no `=` value).
+    expect(all.some((t) => t.startsWith('SAFELIST='))).toBe(false);
+  });
+
+  it('advertises SAFELIST regardless of negotiated caps (ISUPPORT is global)', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>(['safelist']));
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all).toContain('SAFELIST');
+
+    const linesNoCap = generateIsupport(makeConfig(), new Set<string>());
+    const allNoCap = linesNoCap.flatMap((l) => l.text.split(' '));
+    expect(allNoCap).toContain('SAFELIST');
+  });
+});
+
+// ============================================================================
+// generateIsupport — line splitting
+// ============================================================================
+
+describe('generateIsupport — line splitting', () => {
+  it('splits tokens across multiple 005 lines when the total would exceed 510 bytes', () => {
+    // The realistic trigger is a long NETWORK name: NETWORK=<long> is one
+    // of the longer tokens, and packing it with the rest would exceed 510.
+    // We use a name that pushes the total past the ceiling but keeps every
+    // individual token short enough to fit on its own line.
+    const longName = `${'Z'.repeat(450)}`;
+    const lines = generateIsupport(makeConfig({ networkName: longName }), new Set<string>());
+
+    expect(lines.length).toBeGreaterThan(1);
+    for (const line of lines) {
+      // Each wire line is bounded by 510 bytes (incl. trailing \r\n).
+      expect(line.text.length).toBeLessThanOrEqual(510);
+    }
+    // Only the last line has the trailer.
+    const trailers = lines.filter((l) => l.text.endsWith(':are supported by this server'));
+    expect(trailers.length).toBe(1);
+  });
+
+  it('places all tokens before the trailing `:are supported by this server`', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const last = lines.at(-1)?.text ?? '';
+    // Strip the leading `:<server> 005 <nick> ` prefix, then check the
+    // token region (between prefix and trailer) contains no stray colons.
+    const withoutPrefix = last.replace(/^:\S+ 005 \S+ /u, '');
+    const beforeTrailer = withoutPrefix.split(':are supported by this server')[0];
+    expect(beforeTrailer).not.toContain(':');
+  });
+
+  it('labels every line with the 005 numeric and the connection nick', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>(), 'alice');
+    for (const line of lines) {
+      expect(line.text).toMatch(/ 005 alice /u);
+    }
+  });
+
+  it('uses * as the nick when no nick is provided', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    for (const line of lines) {
+      expect(line.text).toMatch(/ 005 \* /u);
+    }
+  });
+});
+
+// ============================================================================
+// generateIsupport — IRCv3 capability-aware tokens
+// ============================================================================
+
+describe('generateIsupport — capability-aware tokens', () => {
+  it('does not advertise BOT when the client lacks the bot-mode cap', () => {
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    const all = lines.flatMap((l) => l.text.split(' '));
+    expect(all.some((t) => t.startsWith('BOT='))).toBe(false);
+  });
+
+  it('returns an empty array when called with no config (defensive)', () => {
+    // Sanity: contract is "always returns at least one line for valid config".
+    const lines = generateIsupport(makeConfig(), new Set<string>());
+    expect(lines.length).toBeGreaterThan(0);
+  });
+});