serverless-ircd 0.7.0 → 0.9.0

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

@@ -6,8 +6,10 @@ import {
   EmptyMotdProvider,
   FakeClock,
   InMemoryMessageStore,
+  InMemoryServicesStore,
   type MessageStore,
   SequentialIdFactory,
+  type ServicesStore,
   type StoredMessage,
 } from '../../src/ports';
 import { type ChannelState, createChannel } from '../../src/state/channel';
@@ -30,6 +32,7 @@ function makeCtx(
   conn: ConnectionState,
   clock = new FakeClock(1_000),
   messages?: MessageStore,
+  services?: ServicesStore,
 ): Ctx {
   return buildCtx({
     serverConfig,
@@ -38,6 +41,7 @@ function makeCtx(
     motd: EmptyMotdProvider,
     connection: conn,
     ...(messages !== undefined ? { messages } : {}),
+    ...(services !== undefined ? { services } : {}),
   });
 }
 
@@ -126,7 +130,7 @@ describe('joinReducer — success', () => {
 
     expect(out.effects).toEqual<EffectType[]>([
       Effect.applyChannelDelta('#foo', {
-        memberships: [{ type: 'add', conn: 'c1', nick: 'alice', op: true }],
+        memberships: [{ type: 'add', conn: 'c1', nick: 'alice', op: true, voice: false }],
       }),
       Effect.broadcast(
         '#foo',
@@ -929,3 +933,570 @@ describe('joinReducer — chathistory auto-playback', () => {
     expect(conn.lastReadMarkers?.get('#foo')).toBe('m5');
   });
 });
+
+// ============================================================================
+// joinReducer — ChanServ +R (block unidentified join)
+// ============================================================================
+
+describe('joinReducer — +R (block unidentified join)', () => {
+  it('rejects an unidentified joiner with 519 ERR_ALLMUSTREGISTER', () => {
+    const chan = makeChan('#foo');
+    chan.modes.blockUnidentified = true;
+    const conn = makeConn('c1', 'guest');
+    // guest has no account set
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.members.has('c1')).toBe(false);
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(
+      ':irc.example.com 519 guest #foo :You must register with NickServ to join this channel',
+    );
+  });
+
+  it('admits an identified joiner (account set)', () => {
+    const chan = makeChan('#foo');
+    chan.modes.blockUnidentified = true;
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.members.has('c1')).toBe(true);
+  });
+});
+
+// ============================================================================
+// joinReducer — ChanServ KEEPTOPIC restore
+// ============================================================================
+
+describe('joinReducer — KEEPTOPIC restore from ServicesStore', () => {
+  it('restores the persisted topic on the first join after empty-recreate', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelKeepTopic('#foo', true);
+    services.setChannelTopic('#foo', {
+      text: 'remembered topic',
+      setter: 'bob!bob@example.org',
+      setAt: 1_000,
+    });
+    const chan = makeChan('#foo');
+    // First joiner: members is empty.
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.topic?.text).toBe('remembered topic');
+    expect(out.state.topic?.setter).toBe('bob!bob@example.org');
+    expect(out.state.topic?.setAt).toBe(1_000);
+    // The 332/333 numerics are emitted to the joiner.
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 332 alice #foo :remembered topic');
+    expect(
+      texts.some((t) => t.startsWith(':irc.example.com 333 alice #foo bob!bob@example.org 1000')),
+    ).toBe(true);
+  });
+
+  it('does not restore a topic when the channel has existing members', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelKeepTopic('#foo', true);
+    services.setChannelTopic('#foo', { text: 'stale', setter: 's', setAt: 0 });
+    const chan = makeChan('#foo');
+    // Pre-existing member.
+    chan.members.set('c0', { conn: 'c0', nick: 'bob', op: true, voice: false });
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.topic).toBeUndefined();
+  });
+
+  it('does not restore a topic when no services store is bound', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn('c1', 'alice');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.topic).toBeUndefined();
+  });
+
+  it('does not restore a topic when KEEPTOPIC is off', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    // keepTopic defaults to false; do not enable it.
+    services.setChannelTopic('#foo', { text: 'nope', setter: 's', setAt: 0 });
+    const chan = makeChan('#foo');
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.topic).toBeUndefined();
+  });
+
+  it('does not restore when KEEPTOPIC is on but no topic snapshot is stored', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelKeepTopic('#foo', true);
+    // No setChannelTopic call.
+    const chan = makeChan('#foo');
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    expect(out.state.topic).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// joinReducer — TOPIC numerics (332/333) on JOIN
+// ============================================================================
+//
+// RFC 2812 §3.2.1: after a successful JOIN the server sends 332 RPL_TOPIC
+// and 333 RPL_TOPICWHOTIME whenever a topic is set, regardless of how the
+// topic reached the authoritative ChannelState (KEEPTOPIC restore, a
+// deploy snapshot, or an earlier joiner). These tests pin the behaviour
+// that was previously missing for every non-KEEPTOPIC-restore code path.
+// ============================================================================
+
+describe('joinReducer — TOPIC numerics on JOIN', () => {
+  it('emits 332/333 to the joiner when state.topic is already set (deploy snapshot)', () => {
+    const chan = makeChan('#foo');
+    // Simulate a topic that survived a deploy in storage and was loaded
+    // onto the authoritative ChannelState before this JOIN (empty roster,
+    // no KEEPTOPIC restore path taken).
+    chan.topic = { text: 'persisted topic', setter: 'alice!alice@example.com', setAt: 5_000 };
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 332 bob #foo :persisted topic');
+    expect(
+      texts.some((t) => t.startsWith(':irc.example.com 333 bob #foo alice!alice@example.com 5000')),
+    ).toBe(true);
+  });
+
+  it('emits 332/333 to a second joiner when the topic was set by an earlier joiner', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c0', 'alice', true);
+    // Topic set by an earlier joiner on a non-empty channel.
+    chan.topic = { text: 'hello world', setter: 'alice!alice@example.com', setAt: 1_000 };
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts).toContain(':irc.example.com 332 bob #foo :hello world');
+    expect(
+      texts.some((t) => t.startsWith(':irc.example.com 333 bob #foo alice!alice@example.com 1000')),
+    ).toBe(true);
+  });
+
+  it('emits 332/333 after the 353/366 NAMES list (existing emission order)', () => {
+    const chan = makeChan('#foo');
+    chan.topic = { text: 't', setter: 's', setAt: 1 };
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const send = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    const idx353 = send.findIndex((t) => t.includes(' 353 '));
+    const idx366 = send.findIndex((t) => t.includes(' 366 '));
+    const idx332 = send.findIndex((t) => t.includes(' 332 '));
+    expect(idx353).toBeGreaterThanOrEqual(0);
+    expect(idx366).toBeGreaterThan(idx353);
+    expect(idx332).toBeGreaterThan(idx366);
+  });
+
+  it('does not emit 332/333 when no topic is set', () => {
+    const chan = makeChan('#foo');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const texts = out.effects.flatMap((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text) : []));
+    expect(texts.some((t) => t.includes(' 332 '))).toBe(false);
+    expect(texts.some((t) => t.includes(' 333 '))).toBe(false);
+  });
+});
+
+// ============================================================================
+// joinReducer — ChanServ ACCESS auto-op / auto-voice
+// ============================================================================
+
+describe('joinReducer — ChanServ ACCESS auto-prefix', () => {
+  it('AOP accounts are auto-opped on JOIN', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    // bob holds the AOP default level.
+    services.setChannelAccess('#foo', 'bob', 5);
+    const chan = makeChan('#foo');
+    // Pre-existing op so the founder-first-op path does not interfere.
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    // The authoritative roster reflects the auto-op.
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+    // ChanServ broadcasts `:ChanServ MODE #foo +o bob` so other clients update.
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(broadcasts.some((t) => t.includes('MODE #foo +o bob'))).toBe(true);
+    // The joiner's roster mirror also carries op.
+    const applyDeltas = out.effects.filter((e) => e.tag === 'ApplyChannelDelta');
+    expect(applyDeltas.length).toBeGreaterThan(0);
+    for (const e of applyDeltas) {
+      if (e.tag === 'ApplyChannelDelta') {
+        const added = (e.delta.memberships ?? []).find((m) => m.conn === 'c1');
+        expect(added?.op).toBe(true);
+      }
+    }
+  });
+
+  it('VOP accounts are auto-voiced on JOIN', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelAccess('#foo', 'bob', 3);
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(true);
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(broadcasts.some((t) => t.includes('MODE #foo +v bob'))).toBe(true);
+  });
+
+  it('AOP-level accounts are also voiced (op supersedes voice but the +v is not emitted)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelAccess('#foo', 'bob', 5);
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    // +o emitted; +v is not (op already grants voice speak rights).
+    expect(broadcasts.some((t) => t.includes('MODE #foo +o bob'))).toBe(true);
+    expect(broadcasts.some((t) => t.includes('+v'))).toBe(false);
+  });
+
+  it('accounts with no access entry get no auto prefix', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(broadcasts.some((t) => t.includes('MODE #foo'))).toBe(false);
+  });
+
+  it('unidentified joiners get no auto prefix even with an entry', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelAccess('#foo', 'bob', 5);
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    // No conn.account set.
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+  });
+
+  it('LEVELS SET AUTOOP raises the auto-op threshold', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    // bob holds AOP (5) but the founder raised AUTOOP to 7.
+    services.setChannelAccess('#foo', 'bob', 5);
+    services.setChannelLevel('#foo', 'AUTOOP', 7);
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(true);
+  });
+
+  it('LEVELS SET AUTOVOICE raises the auto-voice threshold', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    // bob holds level 3 but the founder raised AUTOVOICE to 5.
+    services.setChannelAccess('#foo', 'bob', 3);
+    services.setChannelLevel('#foo', 'AUTOVOICE', 5);
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+  });
+
+  it('the founder is auto-opped regardless of the access list', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'someone', op: true, voice: false });
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('the first joiner (channel empty) keeps the RFC 2812 founder-op and skips ChanServ MODE', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+    // The first-op path emits no ChanServ MODE broadcast.
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(broadcasts.some((t) => t.includes('ChanServ MODE'))).toBe(false);
+  });
+
+  it('does not auto-op the first joiner of an empty registered channel when off the access list', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(broadcasts.some((t) => t.includes('ChanServ MODE'))).toBe(false);
+    expect(broadcasts.some((t) => t.includes('+o bob'))).toBe(false);
+  });
+
+  it('auto-ops the first joiner of an empty registered channel when they hold AUTOOP-level access', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelAccess('#foo', 'bob', 5);
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('does not auto-op an unidentified first joiner of an empty registered channel', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+  });
+
+  it('still auto-ops the founder first-joining an empty registered channel', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerChannel('#foo', 'alice');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'alice');
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('auto-ops the first joiner of an empty channel when services are bound but the channel is unregistered', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('bob', 'pw', 'b@e');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('auto-ops the first joiner of an empty channel when no services store is bound', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('bob', 'pw', 'b@e');
+    const chan = makeChan('#foo');
+    expect(chan.members.size).toBe(0);
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, undefined);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(true);
+  });
+
+  it('does nothing when no services store is bound', () => {
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+  });
+
+  it('does nothing when the channel is not registered', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('bob', 'pw', 'b@e');
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const entry = out.state.members.get('c1');
+    expect(entry?.op).toBe(false);
+    expect(entry?.voice).toBe(false);
+  });
+
+  it('auto-op broadcasts use the ChanServ pseudo-client source', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(2_000) });
+    services.registerNick('alice', 'pw', 'a@e');
+    services.registerNick('bob', 'pw', 'b@e');
+    services.registerChannel('#foo', 'alice');
+    services.setChannelAccess('#foo', 'bob', 5);
+    const chan = makeChan('#foo');
+    chan.members.set('c0', { conn: 'c0', nick: 'alice', op: true, voice: false });
+    const conn = makeConn('c1', 'bob');
+    conn.account = 'bob';
+    const ctx = makeCtx(conn, new FakeClock(2_000), undefined, services);
+
+    const out = joinReducer(chan, { command: 'JOIN', params: ['#foo'], tags: {} }, ctx);
+
+    const broadcasts = out.effects.flatMap((e) =>
+      e.tag === 'Broadcast' && e.chan === '#foo' ? e.lines.map((l) => l.text) : [],
+    );
+    expect(
+      broadcasts.some((t) => t.startsWith(':ChanServ!ChanServ@services MODE #foo +o bob')),
+    ).toBe(true);
+  });
+});