serverless-ircd 0.1.0 → 0.2.0

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

@@ -0,0 +1,996 @@
+import { describe, expect, it } from 'vitest';
+import { chathistoryReducer } from '../../src/commands/chathistory';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryMessageStore,
+  type MessageStore,
+  SequentialIdFactory,
+  type StoredMessage,
+} from '../../src/ports';
+import { formatServerTime } from '../../src/protocol/outbound';
+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',
+};
+
+/** Caps the connection has negotiated; defaults to the chathistory cap set. */
+function makeConn(
+  id = 'c1',
+  nick = 'alice',
+  caps: string[] = ['draft/chathistory', 'server-time', 'message-tags', 'batch'],
+): 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';
+  for (const c of caps) s.caps.add(c);
+  return s;
+}
+
+function makeCtx(conn: ConnectionState, store: MessageStore, clock = new FakeClock(10_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    messages: store,
+    connection: conn,
+  });
+}
+
+function makeChan(name = '#foo'): ChannelState {
+  return createChannel({ name, nameLower: name.toLowerCase(), createdAt: 0 });
+}
+
+/** Records N chronological PRIVMSG messages into the store. */
+function seed(store: MessageStore, chan: string, count: number): StoredMessage[] {
+  const out: StoredMessage[] = [];
+  for (let i = 1; i <= count; i++) {
+    const m: StoredMessage = {
+      msgid: `m${i}`,
+      time: i * 1_000,
+      chan: chan.toLowerCase(),
+      command: 'PRIVMSG',
+      nick: 'bob',
+      user: 'bob',
+      host: 'ex.org',
+      text: `msg ${i}`,
+    };
+    store.record(m);
+    out.push(m);
+  }
+  return out;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+/** Expected replay line for a stored PRIVMSG. */
+function replayLine(m: StoredMessage, displayChan: string): RawLine {
+  const stamp = formatServerTime(m.time);
+  return {
+    text: `@time=${stamp};msgid=${m.msgid} :bob!bob@ex.org PRIVMSG ${displayChan} :${m.text}`,
+  };
+}
+
+/** Builds the expected BATCH frame for a list of stored messages. */
+function expectedBatch(body: RawLine[], batchId: string, displayChan: string): EffectType[] {
+  if (body.length === 0) return [];
+  const start = L(`BATCH +${batchId} chathistory ${displayChan}`);
+  const end = L(`BATCH -${batchId}`);
+  return [Effect.send('c1', [start, ...body, end])];
+}
+
+// ============================================================================
+// cap gating
+// ============================================================================
+
+describe('chathistoryReducer — cap gating', () => {
+  it('rejects with 421 ERR_UNKNOWNCOMMAND when the cap is not negotiated', () => {
+    const conn = makeConn('c1', 'alice', []); // no caps
+    const store = new InMemoryMessageStore();
+    const chan = makeChan();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '2'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 421 alice CHATHISTORY :Unknown command')]),
+    ]);
+  });
+
+  it('does not query the store when the cap is missing (no leak / no work)', () => {
+    let queried = false;
+    const spyStore: MessageStore = {
+      record(): void {
+        /* noop */
+      },
+      query(): StoredMessage[] {
+        queried = true;
+        return [];
+      },
+      recent(): StoredMessage[] {
+        queried = true;
+        return [];
+      },
+      hasMsgid(): boolean {
+        return true;
+      },
+      targets(): { chan: string; time: number }[] {
+        return [];
+      },
+    };
+    const conn = makeConn('c1', 'alice', []);
+    const chan = makeChan();
+    const ctx = makeCtx(conn, spyStore);
+
+    chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '2'], tags: {} },
+      ctx,
+    );
+
+    expect(queried).toBe(false);
+  });
+});
+
+// ============================================================================
+// LATEST
+// ============================================================================
+
+describe('chathistoryReducer — LATEST', () => {
+  it('returns the most recent N messages in a chathistory BATCH, oldest first, each tagged @time+msgid', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '2'], tags: {} },
+      ctx,
+    );
+
+    const body = [
+      replayLine(seeded[3] as StoredMessage, '#foo'),
+      replayLine(seeded[4] as StoredMessage, '#foo'),
+    ];
+    expect(out.effects).toEqual<EffectType[]>(expectedBatch(body, 'batch-0', '#foo'));
+  });
+
+  it('honors a known msgid pivot for LATEST (returns up to and including the pivot)', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      // Real msgid pivot (m3) exercises the pivotArg !== undefined branch.
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', 'm3', '5'], tags: {} },
+      ctx,
+    );
+
+    // Spec: LATEST with a known pivot returns the most recent N messages
+    // up to *and including* the pivot, oldest first.
+    const body = [
+      replayLine(seeded[0] as StoredMessage, '#foo'),
+      replayLine(seeded[1] as StoredMessage, '#foo'),
+      replayLine(seeded[2] as StoredMessage, '#foo'),
+    ];
+    expect(out.effects).toEqual<EffectType[]>(expectedBatch(body, 'batch-0', '#foo'));
+  });
+
+  it('uses the channel display name (original case) in replay lines and batch args', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#Foo', 1);
+    const conn = makeConn();
+    const chan = makeChan('#Foo');
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '5'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch([replayLine(seeded[0] as StoredMessage, '#Foo')], 'batch-0', '#Foo'),
+    );
+  });
+
+  it('returns fewer than the limit when history is shorter (no error)', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 2);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '50'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch(
+        [
+          replayLine(seeded[0] as StoredMessage, '#foo'),
+          replayLine(seeded[1] as StoredMessage, '#foo'),
+        ],
+        'batch-0',
+        '#foo',
+      ),
+    );
+  });
+
+  it('emits nothing when the channel has no history (empty batch elided)', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '50'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+});
+
+// ============================================================================
+// BEFORE / AFTER / AROUND / BETWEEN
+// ============================================================================
+
+describe('chathistoryReducer — BEFORE / AFTER / AROUND / BETWEEN', () => {
+  it('BEFORE returns the N messages preceding the pivot msgid', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BEFORE', '#foo', 'm4', '2'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch(
+        [
+          replayLine(seeded[1] as StoredMessage, '#foo'),
+          replayLine(seeded[2] as StoredMessage, '#foo'),
+        ],
+        'batch-0',
+        '#foo',
+      ),
+    );
+  });
+
+  it('AFTER returns the N messages following the pivot msgid', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['AFTER', '#foo', 'm2', '2'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch(
+        [
+          replayLine(seeded[2] as StoredMessage, '#foo'),
+          replayLine(seeded[3] as StoredMessage, '#foo'),
+        ],
+        'batch-0',
+        '#foo',
+      ),
+    );
+  });
+
+  it('AROUND returns messages spanning the pivot', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['AROUND', '#foo', 'm3', '3'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch(
+        [
+          replayLine(seeded[1] as StoredMessage, '#foo'),
+          replayLine(seeded[2] as StoredMessage, '#foo'),
+          replayLine(seeded[3] as StoredMessage, '#foo'),
+        ],
+        'batch-0',
+        '#foo',
+      ),
+    );
+  });
+
+  it('BETWEEN returns messages after m1 up to and including m2', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BETWEEN', '#foo', 'm1', 'm4'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch(
+        [
+          replayLine(seeded[1] as StoredMessage, '#foo'),
+          replayLine(seeded[2] as StoredMessage, '#foo'),
+          replayLine(seeded[3] as StoredMessage, '#foo'),
+        ],
+        'batch-0',
+        '#foo',
+      ),
+    );
+  });
+
+  it('bounds at the start/end return fewer than the limit with no error', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 5);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BEFORE', '#foo', 'm1', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]); // nothing before the first message
+    void seeded;
+  });
+});
+
+// ============================================================================
+// TARGETS
+// ============================================================================
+
+describe('chathistoryReducer — TARGETS', () => {
+  it('enumerates channels with recent activity for TARGETS * *', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 1); // time 1000
+    store.record({
+      msgid: 'bx',
+      time: 5_000,
+      chan: '#bar',
+      command: 'PRIVMSG',
+      nick: 'b',
+      text: 'x',
+    });
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store, new FakeClock(100_000));
+
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['TARGETS', '*', '*'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [
+        L('BATCH +batch-0 chathistory'),
+        L(`:irc.example.com CHATHISTORY TARGETS ${formatServerTime(5_000)} #bar`),
+        L(`:irc.example.com CHATHISTORY TARGETS ${formatServerTime(1_000)} #foo`),
+        L('BATCH -batch-0'),
+      ]),
+    ]);
+  });
+
+  it('honors an explicit ISO-timestamp window', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 1); // time 1000
+    store.record({
+      msgid: 'bx',
+      time: 9_000,
+      chan: '#bar',
+      command: 'PRIVMSG',
+      nick: 'b',
+      text: 'x',
+    });
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store, new FakeClock(100_000));
+
+    const sinceIso = formatServerTime(2_000);
+    const untilIso = formatServerTime(5_000);
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['TARGETS', sinceIso, untilIso], tags: {} },
+      ctx,
+    );
+
+    // Only #foo@1000 is outside [2000,5000]; #bar@9000 is outside too → empty.
+    expect(out.effects).toEqual([]);
+  });
+
+  it('emits nothing when no channel has activity', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['TARGETS', '*', '*'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+});
+
+/** Channel arg is unused for TARGETS; supply a throwaway. */
+function chan0(): ChannelState {
+  return makeChan('#0');
+}
+
+// ============================================================================
+// error paths
+// ============================================================================
+
+describe('chathistoryReducer — error paths', () => {
+  it('returns 403 ERR_NOSUCHCHANNEL for a non-existent channel', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      undefined,
+      { command: 'CHATHISTORY', params: ['LATEST', '#nope', '*', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 403 alice #nope :No such channel')]),
+    ]);
+  });
+
+  it('returns 461 ERR_NEEDMOREPARAMS for an unknown pivot msgid (BEFORE)', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BEFORE', '#foo', 'missing', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice CHATHISTORY :Invalid parameters')]),
+    ]);
+  });
+
+  it('returns 461 for an unknown msgid in AFTER', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['AFTER', '#foo', 'ghost', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 for an unknown msgid in BETWEEN (either bound)', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BETWEEN', '#foo', 'm1', 'ghost'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 ERR_NEEDMOREPARAMS when the subcommand is missing', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(chan0(), { command: 'CHATHISTORY', params: [], tags: {} }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 461 alice CHATHISTORY :Not enough parameters')]),
+    ]);
+  });
+
+  it('returns 461 when a channel subcommand is missing its target parameter', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['LATEST'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 for an unknown subcommand', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['BOGUS', '#foo', '*', '10'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 for an unparseable TARGETS timestamp', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['TARGETS', 'not-a-date', '*'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 when BETWEEN is missing one of its two msgid bounds', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BETWEEN', '#foo', 'm1'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 when BEFORE is missing its pivot msgid', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BEFORE', '#foo'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 when the limit argument is not a non-negative integer', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', 'abc'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 when LATEST is asked to pivot on an unknown msgid', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', 'ghost', '5'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+
+  it('returns 461 when TARGETS is missing its until-bound argument', () => {
+    const store = new InMemoryMessageStore();
+    const conn = makeConn();
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan0(),
+      { command: 'CHATHISTORY', params: ['TARGETS', '*'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+});
+
+// ============================================================================
+// secret / private leak prevention
+// ============================================================================
+
+describe('chathistoryReducer — +s/+p leak prevention', () => {
+  it('returns an empty result (no batch) when the requester is not on a +s channel', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.modes.secret = true;
+    // requester NOT a member
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('returns an empty result when the requester is not on a +p channel', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 3);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.modes.private = true;
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('serves history to a +s member normally', () => {
+    const store = new InMemoryMessageStore();
+    const seeded = seed(store, '#foo', 1);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.modes.secret = true;
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '10'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch([replayLine(seeded[0] as StoredMessage, '#foo')], 'batch-0', '#foo'),
+    );
+  });
+});
+
+// ============================================================================
+// TAGMSG replay formatting
+// ============================================================================
+
+describe('chathistoryReducer — TAGMSG replay', () => {
+  it('replays a stored TAGMSG without a trailing text parameter', () => {
+    const store = new InMemoryMessageStore();
+    const tagmsg: StoredMessage = {
+      msgid: 't1',
+      time: 1_000,
+      chan: '#foo',
+      command: 'TAGMSG',
+      nick: 'bob',
+      user: 'bob',
+      host: 'ex.org',
+      text: '',
+    };
+    store.record(tagmsg);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '5'], tags: {} },
+      ctx,
+    );
+
+    const stamp = formatServerTime(tagmsg.time);
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch([L(`@time=${stamp};msgid=t1 :bob!bob@ex.org TAGMSG #foo`)], 'batch-0', '#foo'),
+    );
+  });
+
+  it('replays a message whose stored hostmask has only a user (no host)', () => {
+    const store = new InMemoryMessageStore();
+    const userOnly: StoredMessage = {
+      msgid: 'u1',
+      time: 1_000,
+      chan: '#foo',
+      command: 'PRIVMSG',
+      nick: 'eve',
+      user: 'eve',
+      // host omitted → replay line source is `eve!eve`, not `eve!eve@...`
+      text: 'hi',
+    };
+    store.record(userOnly);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '5'], tags: {} },
+      ctx,
+    );
+
+    const stamp = formatServerTime(userOnly.time);
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch([L(`@time=${stamp};msgid=u1 :eve!eve PRIVMSG #foo :hi`)], 'batch-0', '#foo'),
+    );
+  });
+
+  it('replays a message whose stored source is a bare nick (no user, no host)', () => {
+    const store = new InMemoryMessageStore();
+    const bare: StoredMessage = {
+      msgid: 'b1',
+      time: 2_000,
+      chan: '#foo',
+      command: 'PRIVMSG',
+      nick: 'webchat',
+      // user + host both omitted → replay line source is just `webchat`
+      text: 'hello',
+    };
+    store.record(bare);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '5'], tags: {} },
+      ctx,
+    );
+
+    const stamp = formatServerTime(bare.time);
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch([L(`@time=${stamp};msgid=b1 :webchat PRIVMSG #foo :hello`)], 'batch-0', '#foo'),
+    );
+  });
+
+  it('replays a message whose stored source has a host but no user (cloaked webchat shape)', () => {
+    const store = new InMemoryMessageStore();
+    const hostOnly: StoredMessage = {
+      msgid: 'h1',
+      time: 3_000,
+      chan: '#foo',
+      command: 'PRIVMSG',
+      nick: 'guest',
+      // user omitted, host defined → exercises the else of `if (m.user !== undefined)`
+      host: 'gateway.example.com',
+      text: 'hi',
+    };
+    store.record(hostOnly);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '5'], tags: {} },
+      ctx,
+    );
+
+    const stamp = formatServerTime(hostOnly.time);
+    expect(out.effects).toEqual<EffectType[]>(
+      expectedBatch(
+        [L(`@time=${stamp};msgid=h1 :guest@gateway.example.com PRIVMSG #foo :hi`)],
+        'batch-0',
+        '#foo',
+      ),
+    );
+  });
+
+  it('LATEST without an explicit limit argument uses the default 50 cap', () => {
+    const store = new InMemoryMessageStore();
+    seed(store, '#foo', 2);
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtx(conn, store);
+
+    const out = chathistoryReducer(
+      chan,
+      // Three params only — exercises `parseLimit(undefined) → DEFAULT_QUERY_LIMIT`.
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    const send = out.effects[0] as { lines: RawLine[] };
+    // BATCH start + 2 replay lines + BATCH end = 4 lines.
+    expect(send.lines).toHaveLength(4);
+  });
+});
+
+// ============================================================================
+// No MessageStore bound (deployment disabled chathistory persistence)
+// ============================================================================
+
+describe('chathistoryReducer — no MessageStore bound', () => {
+  /** Builds a Ctx with no `messages` port, exercising the `?? fallback` branches. */
+  function makeCtxNoStore(conn: ConnectionState): Ctx {
+    return buildCtx({
+      serverConfig,
+      clock: new FakeClock(10_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: conn,
+    });
+  }
+
+  it('LATEST on an empty store elides the batch (no replay, no error)', () => {
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtxNoStore(conn);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['LATEST', '#foo', '*', '5'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('TARGETS on an empty store emits nothing', () => {
+    const conn = makeConn();
+    const ctx = makeCtxNoStore(conn);
+
+    const out = chathistoryReducer(
+      makeChan(),
+      { command: 'CHATHISTORY', params: ['TARGETS', '*', '*'], tags: {} },
+      ctx,
+    );
+
+    expect(out.effects).toEqual([]);
+  });
+
+  it('BEFORE on an unbound store returns invalid-params (storeHas fallback)', () => {
+    const conn = makeConn();
+    const chan = makeChan();
+    chan.members.set('c1', { conn: 'c1', nick: 'alice', op: false, voice: false });
+    const ctx = makeCtxNoStore(conn);
+
+    const out = chathistoryReducer(
+      chan,
+      { command: 'CHATHISTORY', params: ['BEFORE', '#foo', 'm1', '5'], tags: {} },
+      ctx,
+    );
+
+    // No store → storeHas returns false → invalid-params 461 line.
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toContain('461');
+  });
+});
+
+// ============================================================================
+// Unregistered connection (numericErr fallback to `*`)
+// ============================================================================
+
+describe('chathistoryReducer — unregistered connection', () => {
+  it('formats numeric errors with `*` when the connection has no nick', () => {
+    const store = new InMemoryMessageStore();
+    const conn = createConnection({ id: 'c1', connectedSince: 0 });
+    // Caps negotiated but no NICK yet — exercises numericErr's `?? '*'` branch.
+    conn.caps.add('draft/chathistory');
+    conn.caps.add('server-time');
+    conn.caps.add('message-tags');
+    conn.caps.add('batch');
+    const ctx = buildCtx({
+      serverConfig,
+      clock: new FakeClock(10_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      messages: store,
+      connection: conn,
+    });
+
+    const out = chathistoryReducer(
+      makeChan(),
+      { command: 'CHATHISTORY', params: ['LATEST'], tags: {} },
+      ctx,
+    );
+
+    expect((out.effects[0] as { lines: RawLine[] }).lines[0]?.text).toBe(
+      ':irc.example.com 461 * CHATHISTORY :Not enough parameters',
+    );
+  });
+});