serverless-ircd 0.4.0 → 0.6.0

package/packages/irc-core/tests/labeled-response.test.ts

@@ -0,0 +1,181 @@
+import { describe, expect, it } from 'vitest';
+import { Effect } from '../src/effects';
+import type { Effect as EffectType, RawLine } from '../src/effects';
+import {
+  LABELED_RESPONSE_CAP_NAME,
+  LABEL_TAG,
+  applyLabelToEffects,
+  extractLabel,
+  wrapLabeledResponse,
+} from '../src/protocol/labeled-response';
+
+const L = (text: string): RawLine => ({ text });
+
+// ============================================================================
+// extractLabel — IRCv3 labeled-response client-tag reader
+// ============================================================================
+
+describe('extractLabel — +label client tag', () => {
+  it('returns the value when the +label tag is present', () => {
+    expect(extractLabel({ '+label': 'foo' })).toBe('foo');
+  });
+
+  it('returns undefined when the +label tag is absent', () => {
+    expect(extractLabel({})).toBeUndefined();
+  });
+
+  it('returns undefined when the +label tag is present but empty', () => {
+    expect(extractLabel({ '+label': '' })).toBeUndefined();
+  });
+
+  it('ignores unrelated tags', () => {
+    expect(extractLabel({ '+typing': 'active', server_time: 'x' })).toBeUndefined();
+  });
+
+  it('exposes the wire tag name as the +label constant', () => {
+    expect(LABEL_TAG).toBe('+label');
+  });
+});
+
+// ============================================================================
+// wrapLabeledResponse — the always-emit BATCH framing helper
+// ============================================================================
+
+describe('wrapLabeledResponse — batch framing', () => {
+  it('wraps a non-empty line list with BATCH +label labeled-response / -label', () => {
+    const out = wrapLabeledResponse('foo', [L(':srv PONG :tok'), L(':srv 001 alice :Welcome')]);
+    expect(out.map((l) => l.text)).toEqual([
+      'BATCH +foo labeled-response',
+      ':srv PONG :tok',
+      ':srv 001 alice :Welcome',
+      'BATCH -foo',
+    ]);
+  });
+
+  it('emits an empty batch (start + end only) when there are no inner lines', () => {
+    const out = wrapLabeledResponse('foo', []);
+    expect(out.map((l) => l.text)).toEqual(['BATCH +foo labeled-response', 'BATCH -foo']);
+  });
+
+  it('uses the labeled-response batch type token', () => {
+    const out = wrapLabeledResponse('x', [L('inner')]);
+    expect(out[0]?.text).toBe('BATCH +x labeled-response');
+  });
+
+  it('uses the supplied label verbatim in both markers', () => {
+    const out = wrapLabeledResponse('my-label-7', [L('inner')]);
+    expect(out[0]?.text).toBe('BATCH +my-label-7 labeled-response');
+    expect(out[out.length - 1]?.text).toBe('BATCH -my-label-7');
+  });
+
+  it('preserves the order of the inner lines', () => {
+    const out = wrapLabeledResponse('x', [L('one'), L('two'), L('three')]);
+    expect(out.map((l) => l.text)).toEqual([
+      'BATCH +x labeled-response',
+      'one',
+      'two',
+      'three',
+      'BATCH -x',
+    ]);
+  });
+
+  it('exposes the wire cap name as the labeled-response constant', () => {
+    expect(LABELED_RESPONSE_CAP_NAME).toBe('labeled-response');
+  });
+});
+
+// ============================================================================
+// applyLabelToEffects — pure Effect[] transform
+// ============================================================================
+
+describe('applyLabelToEffects — effect transform', () => {
+  it('returns the effects unchanged when no label is set', () => {
+    const effects: EffectType[] = [Effect.send('c1', [L('PONG :tok')])];
+    expect(applyLabelToEffects(effects, { label: undefined, connId: 'c1' })).toEqual(effects);
+  });
+
+  it('wraps a single Send-to-self effect in a labeled batch', () => {
+    const effects: EffectType[] = [Effect.send('c1', [L(':srv PONG :tok')])];
+
+    const out = applyLabelToEffects(effects, { label: 'foo', connId: 'c1' });
+
+    expect(out).toEqual<EffectType[]>([
+      Effect.send('c1', [L('BATCH +foo labeled-response'), L(':srv PONG :tok'), L('BATCH -foo')]),
+    ]);
+  });
+
+  it('accumulates multiple Send-to-self effects into a single labeled batch in order', () => {
+    const effects: EffectType[] = [
+      Effect.send('c1', [L('echo-a')]),
+      Effect.send('c1', [L('echo-b'), L('echo-c')]),
+    ];
+
+    const out = applyLabelToEffects(effects, { label: 'm', connId: 'c1' });
+
+    expect(out).toHaveLength(1);
+    expect(out[0]?.tag).toBe('Send');
+    const lines = (out[0] as Extract<EffectType, { tag: 'Send' }>).lines;
+    expect(lines.map((l) => l.text)).toEqual([
+      'BATCH +m labeled-response',
+      'echo-a',
+      'echo-b',
+      'echo-c',
+      'BATCH -m',
+    ]);
+  });
+
+  it('leaves a Send to a different connection untouched', () => {
+    const effects: EffectType[] = [Effect.send('c2', [L('to-other')])];
+
+    const out = applyLabelToEffects(effects, { label: 'foo', connId: 'c1' });
+
+    // No Send-to-self → an empty labeled batch is appended at the end, and the
+    // Send to c2 stays in place.
+    expect(out).toEqual<EffectType[]>([
+      Effect.send('c2', [L('to-other')]),
+      Effect.send('c1', [L('BATCH +foo labeled-response'), L('BATCH -foo')]),
+    ]);
+  });
+
+  it('emits an empty labeled batch when no Send-to-self effect exists', () => {
+    const effects: EffectType[] = [Effect.broadcast('#foo', [L(':a PRIVMSG #foo :hi')], 'c1')];
+
+    const out = applyLabelToEffects(effects, { label: 'foo', connId: 'c1' });
+
+    expect(out).toEqual<EffectType[]>([
+      Effect.broadcast('#foo', [L(':a PRIVMSG #foo :hi')], 'c1'),
+      Effect.send('c1', [L('BATCH +foo labeled-response'), L('BATCH -foo')]),
+    ]);
+  });
+
+  it('places the batch at the position of the first Send-to-self, preserving surrounding effects', () => {
+    const effects: EffectType[] = [
+      Effect.broadcast('#a', [L('to-a-peers')], 'c1'),
+      Effect.send('c1', [L('echo-a')]),
+      Effect.broadcast('#b', [L('to-b-peers')], 'c1'),
+      Effect.send('c1', [L('echo-b')]),
+    ];
+
+    const out = applyLabelToEffects(effects, { label: 'm', connId: 'c1' });
+
+    expect(out).toEqual<EffectType[]>([
+      Effect.broadcast('#a', [L('to-a-peers')], 'c1'),
+      Effect.send('c1', [L('BATCH +m labeled-response'), L('echo-a'), L('echo-b'), L('BATCH -m')]),
+      Effect.broadcast('#b', [L('to-b-peers')], 'c1'),
+    ]);
+  });
+
+  it('does not wrap effects addressed to self via non-Send tags (e.g. SendToNick from self)', () => {
+    const sendToNick = Effect.sendToNick('bob', 'c1', [L(':a PRIVMSG bob :hi')]);
+    const effects: EffectType[] = [sendToNick];
+
+    const out = applyLabelToEffects(effects, { label: 'foo', connId: 'c1' });
+
+    // SendToNick is not a Send-to-self; the requester sees no reply, so an
+    // empty labeled batch is appended and the SendToNick stays unchanged.
+    expect(out).toEqual<EffectType[]>([
+      sendToNick,
+      Effect.send('c1', [L('BATCH +foo labeled-response'), L('BATCH -foo')]),
+    ]);
+  });
+});

package/packages/irc-core/tests/message-tags.test.ts

@@ -78,6 +78,120 @@ describe('filterClientTags — cap gating', () => {
   });
 });
 
+// ============================================================================
+// filterClientTags — draft/typing client-tag whitelist
+//
+// IRCv3 `draft/typing` carves out an exception to the message-tags cap
+// requirement: a peer that announced `draft/typing` (but NOT message-tags)
+// still receives the `+draft/typing` client tag on TAGMSG/PRIVMSG lines.
+// Other client tags (`+foo`, `+typing` without the `draft/` prefix, …)
+// remain stripped for non-message-tags recipients.
+// ============================================================================
+
+describe('filterClientTags — draft/typing whitelist', () => {
+  it('preserves +draft/typing for a draft/typing-only recipient', () => {
+    const line = L('@+draft/typing=active :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing']));
+    expect(out.text).toBe('@+draft/typing=active :alice TAGMSG #foo');
+  });
+
+  it('preserves a valueless +draft/typing tag for a draft/typing-only recipient', () => {
+    const line = L('@+draft/typing :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing']));
+    expect(out.text).toBe('@+draft/typing :alice TAGMSG #foo');
+  });
+
+  it('strips a non-typing client tag even when draft/typing is negotiated', () => {
+    const line = L('@+typing=1;+draft/typing=active :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing']));
+    expect(out.text).toBe('@+draft/typing=active :alice TAGMSG #foo');
+  });
+
+  it('keeps +draft/typing alongside a server tag for a draft/typing-only recipient', () => {
+    const line = L('@msgid=abc;+draft/typing=active :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing']));
+    expect(out.text).toBe('@msgid=abc;+draft/typing=active :alice TAGMSG #foo');
+  });
+
+  it('drops every client tag (including +draft/typing) for a cap-less recipient', () => {
+    const line = L('@+draft/typing=active;+foo=bar :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>());
+    expect(out.text).toBe(':alice TAGMSG #foo');
+  });
+
+  it('preserves all client tags for a recipient with both message-tags and draft/typing', () => {
+    const line = L('@+draft/typing=active;+foo=bar :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['message-tags', 'draft/typing']));
+    expect(out.text).toBe('@+draft/typing=active;+foo=bar :alice TAGMSG #foo');
+  });
+
+  it('drops the leading @ when only a non-typing client tag was present', () => {
+    const line = L('@+foo=bar;+draft/typing=active :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing']));
+    expect(out.text).toBe('@+draft/typing=active :alice TAGMSG #foo');
+  });
+});
+
+// ============================================================================
+// filterClientTags — draft/read-marker client-tag whitelist
+//
+// IRCv3 `draft/read-marker` carves out the same exception `draft/typing`
+// does: a peer that announced `draft/read-marker` (but NOT message-tags)
+// still receives the `+draft/read-marker` client tag on TAGMSG lines so the
+// read-marker update reaches the user's other connections. Other client
+// tags remain stripped for non-message-tags recipients.
+// ============================================================================
+
+describe('filterClientTags — draft/read-marker whitelist', () => {
+  it('preserves +draft/read-marker for a draft/read-marker-only recipient', () => {
+    const line = L('@+draft/read-marker=m42 :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/read-marker']));
+    expect(out.text).toBe('@+draft/read-marker=m42 :alice TAGMSG #foo');
+  });
+
+  it('preserves a valueless +draft/read-marker tag for a draft/read-marker-only recipient', () => {
+    const line = L('@+draft/read-marker :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/read-marker']));
+    expect(out.text).toBe('@+draft/read-marker :alice TAGMSG #foo');
+  });
+
+  it('strips a non-read-marker client tag even when draft/read-marker is negotiated', () => {
+    const line = L('@+foo=bar;+draft/read-marker=m1 :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/read-marker']));
+    expect(out.text).toBe('@+draft/read-marker=m1 :alice TAGMSG #foo');
+  });
+
+  it('keeps both +draft/typing and +draft/read-marker for a recipient with both draft caps', () => {
+    const line = L('@+draft/typing=active;+draft/read-marker=m1 :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing', 'draft/read-marker']));
+    expect(out.text).toBe('@+draft/typing=active;+draft/read-marker=m1 :alice TAGMSG #foo');
+  });
+
+  it('keeps +draft/read-marker alongside a server tag for a draft/read-marker-only recipient', () => {
+    const line = L('@msgid=abc;+draft/read-marker=m1 :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/read-marker']));
+    expect(out.text).toBe('@msgid=abc;+draft/read-marker=m1 :alice TAGMSG #foo');
+  });
+
+  it('drops every client tag (including +draft/read-marker) for a cap-less recipient', () => {
+    const line = L('@+draft/read-marker=m1;+foo=bar :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>());
+    expect(out.text).toBe(':alice TAGMSG #foo');
+  });
+
+  it('drops +draft/read-marker for a draft/typing-only recipient', () => {
+    const line = L('@+draft/typing=active;+draft/read-marker=m1 :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['draft/typing']));
+    expect(out.text).toBe('@+draft/typing=active :alice TAGMSG #foo');
+  });
+
+  it('preserves all client tags for a recipient with message-tags', () => {
+    const line = L('@+draft/read-marker=m1;+foo=bar :alice TAGMSG #foo');
+    const out = filterClientTags(line, new Set<string>(['message-tags', 'draft/read-marker']));
+    expect(out.text).toBe('@+draft/read-marker=m1;+foo=bar :alice TAGMSG #foo');
+  });
+});
+
 // ============================================================================
 // filterClientTags + applyServerTime composition (dispatch-layer ordering)
 // ============================================================================

package/packages/irc-core/tests/monitor-store.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it } from 'vitest';
+import { InMemoryMonitorStore, type MonitorPush } from '../src/ports';
+
+describe('InMemoryMonitorStore — sync', () => {
+  it('is a no-op when before and after are both empty', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set());
+    // No public surface to assert directly; subsequent drainPushes shows
+    // no subscriptions were recorded (an onNickOnline push would land
+    // if any were tracked).
+    store.onNickOnline('bob');
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('is a no-op when before equals after (no delta)', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(['bob']), new Set(['bob']));
+    store.onNickOnline('bob');
+    // Already-monitored → no push because sync recorded nothing.
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('records added nicks in the reverse index', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob', 'carol']));
+    store.onNickOnline('bob');
+    store.onNickOnline('carol');
+
+    const pushes = store.drainPushes();
+    expect(pushes).toContainEqual({ connId: 'c1', display: 'bob', status: 'online' });
+    expect(pushes).toContainEqual({ connId: 'c1', display: 'carol', status: 'online' });
+  });
+
+  it('removes dropped nicks from the reverse index', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob', 'carol']));
+    store.sync('c1', new Set(['bob', 'carol']), new Set(['bob']));
+    store.onNickOnline('carol');
+    // carol was dropped → no push.
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('cleans up the watcher entry when its watchlist becomes empty', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.sync('c1', new Set(['bob']), new Set());
+    store.onNickOnline('bob');
+    // c1 is fully unsubscribed → no push.
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('records two watchers of the same nick independently', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.sync('c2', new Set(), new Set(['bob']));
+    store.onNickOnline('bob');
+
+    const pushes = store.drainPushes();
+    expect(pushes).toContainEqual({ connId: 'c1', display: 'bob', status: 'online' });
+    expect(pushes).toContainEqual({ connId: 'c2', display: 'bob', status: 'online' });
+  });
+
+  it('drops a watcher without disturbing the others', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.sync('c2', new Set(), new Set(['bob']));
+    store.sync('c1', new Set(['bob']), new Set());
+    store.onNickOnline('bob');
+
+    const pushes = store.drainPushes();
+    expect(pushes).toEqual<MonitorPush[]>([{ connId: 'c2', display: 'bob', status: 'online' }]);
+  });
+});
+
+describe('InMemoryMonitorStore — unsubscribe', () => {
+  it('is a no-op when the connection had no subscriptions', () => {
+    const store = new InMemoryMonitorStore();
+    store.unsubscribe('ghost');
+    store.onNickOnline('bob');
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('removes every subscription for a connection', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob', 'carol']));
+    store.unsubscribe('c1');
+    store.onNickOnline('bob');
+    store.onNickOnline('carol');
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('leaves the reverse entry intact when another watcher remains', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.sync('c2', new Set(), new Set(['bob']));
+    store.unsubscribe('c1');
+    store.onNickOnline('bob');
+
+    // c2 still subscribed → push goes to c2 only.
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([
+      { connId: 'c2', display: 'bob', status: 'online' },
+    ]);
+  });
+});
+
+describe('InMemoryMonitorStore — onNickOnline / onNickOffline', () => {
+  it('onNickOnline enqueues a push for every watcher of the nick', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.sync('c2', new Set(), new Set(['bob']));
+    store.onNickOnline('Bob');
+
+    const pushes = store.drainPushes();
+    expect(pushes).toHaveLength(2);
+    expect(pushes.every((p) => p.display === 'Bob' && p.status === 'online')).toBe(true);
+  });
+
+  it('onNickOnline is idempotent (second call enqueues nothing)', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.onNickOnline('bob');
+    store.onNickOnline('bob');
+
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([
+      { connId: 'c1', display: 'bob', status: 'online' },
+    ]);
+  });
+
+  it('onNickOnline without any watchers records the online state but no push', () => {
+    const store = new InMemoryMonitorStore();
+    store.onNickOnline('bob');
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+    expect(store.onlineNicks()).toEqual(['bob']);
+  });
+
+  it('onNickOffline enqueues a push only when the nick was previously online', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    // bob was never announced online → offline push is a no-op.
+    store.onNickOffline('bob');
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+
+    // After online, offline produces a push.
+    store.onNickOnline('bob');
+    store.drainPushes();
+    store.onNickOffline('bob');
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([
+      { connId: 'c1', display: 'bob', status: 'offline' },
+    ]);
+  });
+
+  it('onNickOffline is idempotent (second call enqueues nothing)', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.onNickOnline('bob');
+    store.drainPushes();
+    store.onNickOffline('bob');
+    store.onNickOffline('bob');
+
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([
+      { connId: 'c1', display: 'bob', status: 'offline' },
+    ]);
+  });
+
+  it('onNickOffline without any watchers clears the online state', () => {
+    const store = new InMemoryMonitorStore();
+    store.onNickOnline('bob');
+    store.onNickOffline('bob');
+    expect(store.onlineNicks()).toEqual([]);
+  });
+});
+
+describe('InMemoryMonitorStore — onlineNicks', () => {
+  it('returns the display spellings of every online nick', () => {
+    const store = new InMemoryMonitorStore();
+    store.onNickOnline('Bob');
+    store.onNickOnline('Carol');
+    expect(store.onlineNicks().sort()).toEqual(['Bob', 'Carol']);
+  });
+
+  it('returns an empty array when no nick is online', () => {
+    const store = new InMemoryMonitorStore();
+    expect(store.onlineNicks()).toEqual([]);
+  });
+});
+
+describe('InMemoryMonitorStore — drainPushes', () => {
+  it('returns the pending pushes and empties the queue', () => {
+    const store = new InMemoryMonitorStore();
+    store.sync('c1', new Set(), new Set(['bob']));
+    store.onNickOnline('bob');
+    expect(store.drainPushes()).toHaveLength(1);
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+
+  it('returns an empty array when nothing is pending', () => {
+    const store = new InMemoryMonitorStore();
+    expect(store.drainPushes()).toEqual<MonitorPush[]>([]);
+  });
+});

package/packages/irc-core/tests/numerics.test.ts

@@ -31,6 +31,68 @@ describe('Numerics registry', () => {
     expect(Numerics.RPL_ENDOFWHOWAS).toBe(369);
   });
 
+  it('maps RPL_TRACELINK to 200', () => {
+    expect(Numerics.RPL_TRACELINK).toBe(200);
+  });
+
+  it('maps RPL_TRACEOPERATOR to 204', () => {
+    expect(Numerics.RPL_TRACEOPERATOR).toBe(204);
+  });
+
+  it('maps RPL_TRACEUSER to 205', () => {
+    expect(Numerics.RPL_TRACEUSER).toBe(205);
+  });
+
+  it('maps RPL_TRACESERVER to 206', () => {
+    expect(Numerics.RPL_TRACESERVER).toBe(206);
+  });
+
+  it('maps RPL_ENDOFTRACE to 262', () => {
+    expect(Numerics.RPL_ENDOFTRACE).toBe(262);
+  });
+
+  // -- LUSERS (RFC 2812 §4.6.2) ----------------------------------------------
+  it('maps RPL_LUSERCLIENT to 251', () => {
+    expect(Numerics.RPL_LUSERCLIENT).toBe(251);
+  });
+
+  it('maps RPL_LUSEROP to 252', () => {
+    expect(Numerics.RPL_LUSEROP).toBe(252);
+  });
+
+  it('maps RPL_LUSERUNKNOWN to 253', () => {
+    expect(Numerics.RPL_LUSERUNKNOWN).toBe(253);
+  });
+
+  it('maps RPL_LUSERCHANNELS to 254', () => {
+    expect(Numerics.RPL_LUSERCHANNELS).toBe(254);
+  });
+
+  it('maps RPL_LUSERME to 255', () => {
+    expect(Numerics.RPL_LUSERME).toBe(255);
+  });
+
+  it('maps RPL_LOCALUSERS to 265', () => {
+    expect(Numerics.RPL_LOCALUSERS).toBe(265);
+  });
+
+  it('maps RPL_GLOBALUSERS to 266', () => {
+    expect(Numerics.RPL_GLOBALUSERS).toBe(266);
+  });
+
+  // -- STATS (RFC 2812 §4.6.3) -----------------------------------------------
+  it('maps RPL_STATSLINKINFO to 211', () => {
+    expect(Numerics.RPL_STATSLINKINFO).toBe(211);
+  });
+
+  it('maps RPL_ENDOFSTATS to 219', () => {
+    expect(Numerics.RPL_ENDOFSTATS).toBe(219);
+  });
+
+  it('maps RPL_STATSUPTIME to 242', () => {
+    expect(Numerics.RPL_STATSUPTIME).toBe(242);
+  });
+
   it('maps ERR_WASNOSUCHNICK to 406', () => {
     expect(Numerics.ERR_WASNOSUCHNICK).toBe(406);
   });
@@ -77,6 +139,26 @@ describe('numericToName', () => {
     expect(numericToName.get(1)).toBe('RPL_WELCOME');
   });
 
+  it('reverses RPL_LUSERCLIENT', () => {
+    expect(numericToName.get(251)).toBe('RPL_LUSERCLIENT');
+  });
+
+  it('reverses RPL_GLOBALUSERS', () => {
+    expect(numericToName.get(266)).toBe('RPL_GLOBALUSERS');
+  });
+
+  it('reverses RPL_STATSLINKINFO', () => {
+    expect(numericToName.get(211)).toBe('RPL_STATSLINKINFO');
+  });
+
+  it('reverses RPL_ENDOFSTATS', () => {
+    expect(numericToName.get(219)).toBe('RPL_ENDOFSTATS');
+  });
+
+  it('reverses RPL_STATSUPTIME', () => {
+    expect(numericToName.get(242)).toBe('RPL_STATSUPTIME');
+  });
+
   it('returns undefined for an unregistered code', () => {
     expect(numericToName.get(600)).toBeUndefined();
   });
@@ -107,4 +189,12 @@ describe('formatNumeric', () => {
   it('zero-pads RPL_ISUPPORT', () => {
     expect(formatNumeric('RPL_ISUPPORT')).toBe('005');
   });
+
+  it('formats RPL_LUSERCLIENT as 251', () => {
+    expect(formatNumeric('RPL_LUSERCLIENT')).toBe('251');
+  });
+
+  it('formats RPL_ENDOFSTATS as 219', () => {
+    expect(formatNumeric('RPL_ENDOFSTATS')).toBe('219');
+  });
 });

package/packages/irc-core/tests/outbound.test.ts

@@ -9,6 +9,7 @@ import {
 } from '../src/protocol/outbound';
 import { parse } from '../src/protocol/parser';
 import { serialize } from '../src/protocol/serializer';
+import { MAX_WS_MESSAGE_BYTES } from '../src/ws-framing';
 
 const L = (text: string): RawLine => ({ text });
 
@@ -192,6 +193,56 @@ describe('enforceLineLimit', () => {
   });
 });
 
+// ============================================================================
+// enforceLineLimit — budget-aware optional WsFrameMode parameter
+// ============================================================================
+
+describe('enforceLineLimit — WsFrameMode budget', () => {
+  // The optional `mode` parameter selects the byte budget. Spec modes cap at
+  // MAX_WS_MESSAGE_BYTES (510) directly — there is no trailing CRLF on a WS
+  // message. Legacy mode caps at MAX_LINE_BYTES - 2 (512 - 2 = 510). Both
+  // resolve to 510 today, but the API is mode-aware so a future change to
+  // either constant needs no call-site edits.
+  const SPEC_BUDGET = MAX_WS_MESSAGE_BYTES;
+
+  it('accepts an optional spec-text mode and caps at MAX_WS_MESSAGE_BYTES', () => {
+    const exact: RawLine = L('x'.repeat(SPEC_BUDGET));
+    expect(enforceLineLimit(exact, new Set<string>(), 'spec-text')).toBe(exact);
+
+    const tooLong: RawLine = L('x'.repeat(SPEC_BUDGET + 5));
+    const out = enforceLineLimit(tooLong, new Set<string>(), 'spec-text');
+    expect(out.text.length).toBe(SPEC_BUDGET);
+  });
+
+  it('accepts an optional spec-binary mode and caps at MAX_WS_MESSAGE_BYTES', () => {
+    const tooLong: RawLine = L('x'.repeat(SPEC_BUDGET + 5));
+    const out = enforceLineLimit(tooLong, new Set<string>(), 'spec-binary');
+    expect(out.text.length).toBe(SPEC_BUDGET);
+  });
+
+  it('uses the legacy budget when mode is explicitly "legacy"', () => {
+    const tooLong: RawLine = L('x'.repeat(SPEC_BUDGET + 5));
+    const out = enforceLineLimit(tooLong, new Set<string>(), 'legacy');
+    expect(out.text.length).toBe(SPEC_BUDGET);
+  });
+
+  it('omitting mode defaults to the legacy budget (backward compatible)', () => {
+    const tooLong: RawLine = L('x'.repeat(SPEC_BUDGET + 5));
+    const withDefault = enforceLineLimit(tooLong, new Set<string>());
+    const withLegacy = enforceLineLimit(tooLong, new Set<string>(), 'legacy');
+    expect(withDefault).toEqual(withLegacy);
+  });
+
+  it('preserves the tag section in spec-text mode just as in legacy mode', () => {
+    const tagPrefix = '@time=2024-01-15T12:34:56.789Z ';
+    const body = `:alice PRIVMSG #foo :${'x'.repeat(500)}`;
+    const line: RawLine = L(`${tagPrefix}${body}`);
+    const out = enforceLineLimit(line, new Set<string>(['message-tags']), 'spec-text');
+    expect(out.text.length).toBe(SPEC_BUDGET);
+    expect(out.text.startsWith(tagPrefix)).toBe(true);
+  });
+});
+
 // ============================================================================
 // Round-trip through serialize -> applyServerTime -> parse
 // ============================================================================