serverless-ircd 0.4.0 → 0.6.0

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

@@ -6,7 +6,9 @@ import {
   EmptyMotdProvider,
   FakeClock,
   InMemoryMessageStore,
+  InMemoryReadMarkerStore,
   type MessageStore,
+  type ReadMarkerStore,
   SequentialIdFactory,
   type StoredMessage,
 } from '../../src/ports';
@@ -30,6 +32,7 @@ function makeCtx(
   conn: ConnectionState,
   clock = new FakeClock(1_000),
   messages?: MessageStore,
+  readMarkers?: ReadMarkerStore,
 ): Ctx {
   return buildCtx({
     serverConfig,
@@ -38,6 +41,7 @@ function makeCtx(
     motd: EmptyMotdProvider,
     connection: conn,
     ...(messages !== undefined ? { messages } : {}),
+    ...(readMarkers !== undefined ? { readMarkers } : {}),
   });
 }
 
@@ -417,6 +421,328 @@ describe('tagmsgChannelReducer — echo-message', () => {
   });
 });
 
+// ============================================================================
+// tagmsgChannelReducer — draft/typing broadcast
+// ============================================================================
+//
+// IRCv3 draft/typing: a TAGMSG carrying `+draft/typing=<active|paused|done>`
+// fans out to channel members that negotiated `draft/typing` OR
+// `message-tags`. The `message-tags` path is the baseline (every TAGMSG goes
+// to message-tags peers); `draft/typing` adds the spec's client-tag
+// exception — peers that lack `message-tags` but negotiated `draft/typing`
+// still receive the typing TAGMSG. The reducer annotates the Broadcast
+// effect with `caps` (OR semantics) so dispatch routes per-recipient.
+// ============================================================================
+
+describe('tagmsgChannelReducer — draft/typing broadcast', () => {
+  it('emits a Broadcast with caps=[message-tags, draft/typing] for a +draft/typing TAGMSG', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [L('@+draft/typing=active :alice!alice@example.com TAGMSG #foo')],
+        except: 'c1',
+        caps: ['message-tags', 'draft/typing'],
+      },
+    ]);
+  });
+
+  it('still uses cap=message-tags (single cap) for a non-typing TAGMSG', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.broadcast(
+        '#foo',
+        [L('@+typing=active :alice!alice@example.com TAGMSG #foo')],
+        'c1',
+        'message-tags',
+      ),
+    ]);
+  });
+
+  it('treats a valueless +draft/typing tag as a typing TAGMSG', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': '' } },
+      ctx,
+    );
+
+    const broadcast = out.effects[0];
+    expect(broadcast?.tag).toBe('Broadcast');
+    expect((broadcast as Extract<EffectType, { tag: 'Broadcast' }>).caps).toEqual([
+      'message-tags',
+      'draft/typing',
+    ]);
+  });
+
+  it('excludes the sender unless echo-message is negotiated (typing TAGMSG)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).except).toBe('c1');
+  });
+
+  it('echoes the typing TAGMSG back to the sender when echo-message is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    const line = L('@+draft/typing=active :alice!alice@example.com TAGMSG #foo');
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [line],
+        except: 'c1',
+        caps: ['message-tags', 'draft/typing'],
+      },
+      Effect.send('c1', [line]),
+    ]);
+  });
+});
+
+// ============================================================================
+// tagmsgChannelReducer — draft/read-marker broadcast + persistence
+// ============================================================================
+//
+// IRCv3 draft/read-marker: a TAGMSG carrying `+draft/read-marker=<msgid>`
+// marks `<msgid>` as the last read message for the sender's account in the
+// target channel. The reducer (1) persists the marker via the bound
+// ReadMarkerStore keyed by (account, channel), (2) advances the connection's
+// in-memory lastReadMarkers, and (3) fans the TAGMSG out — carrying the
+// `+draft/read-marker` tag — to members that negotiated `draft/read-marker`
+// OR `message-tags` (OR-semantics, matching the draft/typing precedent).
+// ============================================================================
+
+describe('tagmsgChannelReducer — draft/read-marker broadcast + persistence', () => {
+  it('emits a Broadcast with caps=[message-tags, draft/read-marker] carrying the tag', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    addMember(chan, 'c2', 'bob');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm42' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [L('@+draft/read-marker=m42 :alice!alice@example.com TAGMSG #foo')],
+        except: 'c1',
+        caps: ['message-tags', 'draft/read-marker'],
+      },
+    ]);
+  });
+
+  it('persists the marker to the ReadMarkerStore keyed by (account, channel)', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm7' } },
+      ctx,
+    );
+
+    expect(store.get('alice', '#foo')).toBe('m7');
+  });
+
+  it('advances the connection in-memory lastReadMarkers', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn, undefined, undefined, new InMemoryReadMarkerStore());
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm7' } },
+      ctx,
+    );
+
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m7');
+  });
+
+  it('overwrites a previously stored marker when a newer msgid arrives', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm2' } },
+      ctx,
+    );
+
+    expect(store.get('alice', '#foo')).toBe('m2');
+  });
+
+  it('does NOT persist to the store when the connection has no account', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn(); // no account
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+
+    expect(store.forAccount('alice')).toEqual([]);
+    // The in-memory marker still advances for the session.
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+  });
+
+  it('does NOT persist when no ReadMarkerStore is bound but still fans out', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const ctx = makeCtx(conn); // no store
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).caps).toEqual([
+      'message-tags',
+      'draft/read-marker',
+    ]);
+    expect(conn.lastReadMarkers?.get('#foo')).toBe('m1');
+  });
+
+  it('excludes the sender unless echo-message is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm1' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).except).toBe('c1');
+  });
+
+  it('echoes the read-marker TAGMSG back to the sender when echo-message is negotiated', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.caps.add('echo-message');
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': 'm3' } },
+      ctx,
+    );
+
+    const line = L('@+draft/read-marker=m3 :alice!alice@example.com TAGMSG #foo');
+    expect(out.effects).toEqual<EffectType[]>([
+      {
+        tag: 'Broadcast',
+        chan: '#foo',
+        lines: [line],
+        except: 'c1',
+        caps: ['message-tags', 'draft/read-marker'],
+      },
+      Effect.send('c1', [line]),
+    ]);
+  });
+
+  it('fans out a valueless +draft/read-marker tag but persists no msgid', () => {
+    const chan = makeChan('#foo');
+    addMember(chan, 'c1', 'alice');
+    const conn = makeConn();
+    conn.account = 'alice';
+    const store = new InMemoryReadMarkerStore();
+    const ctx = makeCtx(conn, undefined, undefined, store);
+
+    const out = tagmsgChannelReducer(
+      chan,
+      { command: 'TAGMSG', params: ['#foo'], tags: { '+draft/read-marker': '' } },
+      ctx,
+    );
+
+    // Broadcast still widens to draft/read-marker peers (tag is present)...
+    expect((out.effects[0] as Extract<EffectType, { tag: 'Broadcast' }>).caps).toEqual([
+      'message-tags',
+      'draft/read-marker',
+    ]);
+    // ...but nothing is persisted (no msgid to store).
+    expect(store.forAccount('alice')).toEqual([]);
+    expect(conn.lastReadMarkers?.get('#foo')).toBeUndefined();
+  });
+});
+
 // ============================================================================
 // tagmsgChannelReducer — chathistory recording
 // ============================================================================
@@ -631,6 +957,37 @@ describe('tagmsgUserReducer', () => {
     ]);
   });
 
+  it('routes a +draft/typing TAGMSG to a single nick target', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.sendToNick('bob', 'c1', [
+        L('@+draft/typing=active :alice!alice@example.com TAGMSG bob'),
+      ]),
+    ]);
+  });
+
+  it('excludes the sender from the echo for a +draft/typing TAGMSG without echo-message', () => {
+    const conn = makeConn();
+    const ctx = makeCtx(conn);
+
+    const out = tagmsgUserReducer(
+      conn,
+      { command: 'TAGMSG', params: ['bob'], tags: { '+draft/typing': 'active' } },
+      ctx,
+    );
+
+    expect(out.effects).toHaveLength(1);
+    expect(out.effects[0]?.tag).toBe('SendToNick');
+  });
+
   it('updates lastSeen to ctx.clock.now()', () => {
     const conn = makeConn();
     const clock = new FakeClock(12_000);

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

@@ -0,0 +1,282 @@
+import { describe, expect, it } from 'vitest';
+import { traceReducer } from '../../src/commands/trace';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import { EmptyMotdProvider, FakeClock, SequentialIdFactory } from '../../src/ports';
+import { type ConnectionState, createConnection } from '../../src/state/connection';
+import { type Ctx, type ServerConfig, buildCtx } from '../../src/types';
+
+const serverConfig: ServerConfig = {
+  serverName: 'irc.example.com',
+  networkName: 'ExampleNet',
+  maxChannelsPerUser: 30,
+  maxTargetsPerCommand: 10,
+  maxListEntries: 50,
+  nickLen: 30,
+  channelLen: 50,
+  topicLen: 390,
+  quitMessage: 'Client Quit',
+};
+
+function makeCtx(conn: ConnectionState, clock = new FakeClock(5_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice', oper = false): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  s.userModes.oper = oper;
+  return s;
+}
+
+function makeTarget(
+  id: string,
+  nick: string,
+  opts: { oper?: boolean; invisible?: boolean } = {},
+): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Real Name';
+  s.registration = 'registered';
+  if (opts.oper !== undefined) s.userModes.oper = opts.oper;
+  if (opts.invisible !== undefined) s.userModes.invisible = opts.invisible;
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+const trace = (target?: string) =>
+  ({
+    command: 'TRACE',
+    params: target === undefined ? [] : [target],
+    tags: {},
+  }) as const;
+
+// ============================================================================
+// traceReducer — no target
+// ============================================================================
+
+describe('traceReducer — no target', () => {
+  it('emits the 262 terminator with no middle when there is no target', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice :End of TRACE')]),
+    ]);
+  });
+
+  it('omits any 200/204/205 detail line when there is no target', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace(), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 200 ');
+    expect(text).not.toContain(' 204 ');
+    expect(text).not.toContain(' 205 ');
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const requester = makeConn();
+    expect(requester.lastSeen).toBe(0);
+    const ctx = makeCtx(requester);
+
+    traceReducer(undefined, trace(), ctx);
+
+    expect(requester.lastSeen).toBe(5_000);
+  });
+
+  it('uses "*" as the nick when the requester has none', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace(), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 * :End of TRACE')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// traceReducer — non-oper detail suppression
+// ============================================================================
+
+describe('traceReducer — non-oper suppression', () => {
+  it('emits only the 262 terminator for a non-oper TRACE <nick> (no leak)', () => {
+    const requester = makeConn('c1', 'alice', false);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('does not emit a 205 detail line for a non-oper requester', () => {
+    const requester = makeConn('c1', 'alice', false);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    const text = out.effects
+      .map((e) => (e.tag === 'Send' ? e.lines.map((l) => l.text).join('|') : ''))
+      .join('|');
+    expect(text).not.toContain(' 205 ');
+    expect(text).not.toContain(' 204 ');
+  });
+});
+
+// ============================================================================
+// traceReducer — oper detail
+// ============================================================================
+
+describe('traceReducer — oper detail', () => {
+  it('emits a 205 RPL_TRACEUSER line for an oper tracing a normal user', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 205 alice User 0 bob bob example.com')]),
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('emits a 204 RPL_TRACEOPERATOR line for an oper tracing another oper', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { oper: true });
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 204 alice Oper 0 bob bob example.com')]),
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('uses "*" nick fallbacks in 204/205 lines for an oper without a nick', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    requester.userModes.oper = true;
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob');
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 205 * User 0 bob bob example.com')]),
+    );
+  });
+
+  it('uses "?" / "*" fallbacks in 205 line when target lacks user/host/nick', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = createConnection({ id: 'c2', connectedSince: 0 });
+    target.registration = 'registered';
+
+    const out = traceReducer(target, trace('ghost'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 205 alice User 0 * ? ?')]),
+    );
+  });
+});
+
+// ============================================================================
+// traceReducer — +i invisible filtering
+// ============================================================================
+
+describe('traceReducer — +i invisible filtering', () => {
+  it('omits detail for an invisible target a non-oper does not share a channel with', () => {
+    const requester = makeConn('c1', 'alice', false);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { invisible: true });
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice bob :End of TRACE')]),
+    ]);
+  });
+
+  it('shows a 205 line for an invisible target when the requester is an oper (oper bypasses +i)', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+    const target = makeTarget('c2', 'bob', { invisible: true });
+
+    const out = traceReducer(target, trace('bob'), ctx);
+
+    expect(out.effects[0]).toEqual<EffectType>(
+      Effect.send('c1', [L(':irc.example.com 205 alice User 0 bob bob example.com')]),
+    );
+  });
+});
+
+// ============================================================================
+// traceReducer — remote server target
+// ============================================================================
+
+describe('traceReducer — remote server target', () => {
+  it('emits 402 ERR_NOSUCHSERVER when the actor flags a non-local server target', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace('remote.example.org'), ctx, 'remote.example.org');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 402 alice remote.example.org :No such server')]),
+    ]);
+  });
+
+  it('uses "*" nick in 402 when the requester has none', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace('remote.example.org'), ctx, 'remote.example.org');
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 402 * remote.example.org :No such server')]),
+    ]);
+  });
+});
+
+// ============================================================================
+// traceReducer — unknown nick (actor could not resolve)
+// ============================================================================
+
+describe('traceReducer — unknown nick', () => {
+  it('emits 262 with the requested nick when target resolves to undefined', () => {
+    const requester = makeConn('c1', 'alice', true);
+    const ctx = makeCtx(requester);
+
+    const out = traceReducer(undefined, trace('ghost'), ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 262 alice ghost :End of TRACE')]),
+    ]);
+  });
+});