serverless-ircd 0.3.0 → 0.5.0

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

@@ -0,0 +1,312 @@
+import { describe, expect, it } from 'vitest';
+import { whowasReducer } from '../../src/commands/whowas';
+import { Effect } from '../../src/effects';
+import type { Effect as EffectType, RawLine } from '../../src/effects';
+import {
+  EmptyMotdProvider,
+  FakeClock,
+  InMemoryNickHistoryStore,
+  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(10_000)): Ctx {
+  return buildCtx({
+    serverConfig,
+    clock,
+    ids: new SequentialIdFactory(),
+    motd: EmptyMotdProvider,
+    connection: conn,
+  });
+}
+
+function makeConn(id = 'c1', nick = 'alice'): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = nick;
+  s.user = nick;
+  s.host = 'example.com';
+  s.realname = 'Alice';
+  s.registration = 'registered';
+  return s;
+}
+
+const L = (text: string): RawLine => ({ text });
+
+describe('whowasReducer — single nick with history', () => {
+  it('emits 314 RPL_WHOWASUSER then 369 RPL_ENDOFWHOWAS for a recorded nick', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'target.example.net',
+      realname: 'Bob',
+      signoffTime: 5_000,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 314 alice bob bob target.example.net * :Bob')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice bob :End of WHOWAS')]),
+    ]);
+  });
+
+  it('updates the requester lastSeen to ctx.clock.now()', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(7_700);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({ nick: 'bob', connId: 'c2', signoffTime: 1_000 });
+
+    whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    expect(requester.lastSeen).toBe(7_700);
+  });
+
+  it('uses ? fallbacks when the entry has no user/host and nick as realname', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({ nick: 'bob', connId: 'c2', signoffTime: 1_000 });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toBe(':irc.example.com 314 alice bob ? ? * :bob');
+    }
+  });
+});
+
+describe('whowasReducer — no match', () => {
+  it('emits 406 ERR_WASNOSUCHNICK then 369 for an unknown nick', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const history = new InMemoryNickHistoryStore(new FakeClock(10_000));
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 406 alice ghost :There was no such nickname')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice ghost :End of WHOWAS')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — multiple comma-separated nicks', () => {
+  it('emits a 314+369 (or 406+369) block per queried nick in order', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'h',
+      realname: 'Bob',
+      signoffTime: 1_000,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob,ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 314 alice bob bob h * :Bob')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice bob :End of WHOWAS')]),
+      Effect.send('c1', [L(':irc.example.com 406 alice ghost :There was no such nickname')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice ghost :End of WHOWAS')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — count cap', () => {
+  it('caps the number of 314 lines at the requested count', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c1',
+      username: 'u1',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_000,
+    });
+    clock.advance(100);
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'u2',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_100,
+    });
+    clock.advance(100);
+    history.record({
+      nick: 'bob',
+      connId: 'c3',
+      username: 'u3',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_200,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob', '1'] }, ctx);
+
+    // Only the most-recent entry (c3) is emitted, then the single 369.
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 314 alice bob u3 h * :R')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice bob :End of WHOWAS')]),
+    ]);
+  });
+
+  it('emits all matches when count exceeds the available history', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c1',
+      username: 'u1',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_000,
+    });
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'u2',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_100,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob', '50'] }, ctx);
+
+    const lines314 = out.effects.filter((e) => {
+      if (e.tag !== 'Send') return false;
+      return e.lines.some((l) => l.text.includes(' 314 '));
+    });
+    expect(lines314).toHaveLength(2);
+  });
+
+  it('treats a non-positive or malformed count as unlimited', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'bob',
+      connId: 'c1',
+      username: 'u1',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_000,
+    });
+    history.record({
+      nick: 'bob',
+      connId: 'c2',
+      username: 'u2',
+      hostname: 'h',
+      realname: 'R',
+      signoffTime: 1_100,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob', '0'] }, ctx);
+
+    const count314 = out.effects.filter((e) => {
+      if (e.tag !== 'Send') return false;
+      return e.lines.some((l) => l.text.includes(' 314 '));
+    });
+    expect(count314).toHaveLength(2);
+  });
+});
+
+describe('whowasReducer — no arg / 431', () => {
+  it('emits 431 ERR_NONICKNAMEGIVEN when no nick argument is supplied', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+    const history = new InMemoryNickHistoryStore(new FakeClock(10_000));
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: [] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 431 alice :No nickname given')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — case-insensitive lookup', () => {
+  it('matches the recorded nick regardless of case', () => {
+    const requester = makeConn();
+    const clock = new FakeClock(10_000);
+    const ctx = makeCtx(requester, clock);
+    const history = new InMemoryNickHistoryStore(clock);
+    history.record({
+      nick: 'Bob',
+      connId: 'c2',
+      username: 'bob',
+      hostname: 'h',
+      realname: 'Bob',
+      signoffTime: 1_000,
+    });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['BOB'] }, ctx);
+
+    expect(out.effects[0]?.tag).toBe('Send');
+    const send = out.effects[0];
+    if (send?.tag === 'Send') {
+      expect(send.lines[0]?.text).toContain(' 314 alice Bob ');
+    }
+  });
+});
+
+describe('whowasReducer — no store bound', () => {
+  it('treats undefined history as no matches (406 + 369, no crash)', () => {
+    const requester = makeConn();
+    const ctx = makeCtx(requester);
+
+    const out = whowasReducer(undefined, { command: 'WHOWAS', params: ['ghost'] }, ctx);
+
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 406 alice ghost :There was no such nickname')]),
+      Effect.send('c1', [L(':irc.example.com 369 alice ghost :End of WHOWAS')]),
+    ]);
+  });
+});
+
+describe('whowasReducer — requester without nick', () => {
+  it('uses * as the requester nick in replies', () => {
+    const requester = createConnection({ id: 'c1', connectedSince: 0 });
+    const ctx = makeCtx(requester);
+    const history = new InMemoryNickHistoryStore(new FakeClock(10_000));
+    history.record({ nick: 'bob', connId: 'c2', signoffTime: 1_000 });
+
+    const out = whowasReducer(history, { command: 'WHOWAS', params: ['bob'] }, ctx);
+
+    const end = out.effects.at(-1);
+    if (end?.tag === 'Send') {
+      expect(end.lines[0]?.text).toBe(':irc.example.com 369 * bob :End of WHOWAS');
+    }
+  });
+});

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

@@ -1,5 +1,13 @@
 import { describe, expect, it } from 'vitest';
-import { DEFAULT_SERVER_CONFIG, ServerConfigSchema, parseServerConfig } from '../src/config';
+import {
+  DEFAULT_CREATED_TEXT,
+  DEFAULT_SERVER_CONFIG,
+  DEFAULT_SERVER_VERSION,
+  ServerConfigSchema,
+  formatCreatedAt,
+  parseServerConfig,
+  resolveServerVersion,
+} from '../src/config';
 
 // ============================================================================
 // ServerConfigSchema — valid inputs
@@ -213,6 +221,92 @@ describe('ServerConfigSchema — maxClients', () => {
   });
 });
 
+// ============================================================================
+// ServerConfigSchema — serverVersion / createdAt
+// ============================================================================
+
+describe('ServerConfigSchema — serverVersion', () => {
+  it('accepts an explicit non-empty version', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n', serverVersion: '9.9.9' });
+    expect(cfg.serverVersion).toBe('9.9.9');
+  });
+
+  it('defaults to DEFAULT_SERVER_VERSION when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.serverVersion).toBe(DEFAULT_SERVER_VERSION);
+  });
+
+  it('rejects an empty version string', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', serverVersion: '' }),
+    ).toThrowError(/serverVersion/u);
+  });
+
+  it('rejects a non-string version', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', serverVersion: 42 }),
+    ).toThrowError(/serverVersion/u);
+  });
+});
+
+describe('ServerConfigSchema — createdAt', () => {
+  it('accepts a non-empty string verbatim', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n', createdAt: '2024-06-01' });
+    expect(cfg.createdAt).toBe('2024-06-01');
+  });
+
+  it('accepts an epoch-ms number', () => {
+    const cfg = parseServerConfig({
+      serverName: 's',
+      networkName: 'n',
+      createdAt: 1_700_000_000_000,
+    });
+    expect(cfg.createdAt).toBe(1_700_000_000_000);
+  });
+
+  it('defaults to DEFAULT_CREATED_TEXT when omitted', () => {
+    const cfg = parseServerConfig({ serverName: 's', networkName: 'n' });
+    expect(cfg.createdAt).toBe(DEFAULT_CREATED_TEXT);
+  });
+
+  it('rejects an empty string', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', createdAt: '' }),
+    ).toThrowError(/createdAt/u);
+  });
+
+  it('rejects a non-string/non-number value', () => {
+    expect(() =>
+      parseServerConfig({ serverName: 's', networkName: 'n', createdAt: true }),
+    ).toThrowError(/createdAt/u);
+  });
+});
+
+// ============================================================================
+// resolveServerVersion / formatCreatedAt helpers
+// ============================================================================
+
+describe('resolveServerVersion', () => {
+  it('returns the configured value when present', () => {
+    expect(resolveServerVersion({ serverVersion: '1.2.3' })).toBe('1.2.3');
+  });
+  it('falls back to DEFAULT_SERVER_VERSION when undefined', () => {
+    expect(resolveServerVersion({})).toBe(DEFAULT_SERVER_VERSION);
+  });
+});
+
+describe('formatCreatedAt', () => {
+  it('returns a string verbatim', () => {
+    expect(formatCreatedAt('2024-06-01')).toBe('2024-06-01');
+  });
+  it('formats an epoch-ms number as a UTC timestamp', () => {
+    expect(formatCreatedAt(1_700_000_000_000)).toBe(new Date(1_700_000_000_000).toUTCString());
+  });
+  it('falls back to DEFAULT_CREATED_TEXT when undefined', () => {
+    expect(formatCreatedAt(undefined)).toBe(DEFAULT_CREATED_TEXT);
+  });
+});
+
 // ============================================================================
 // ServerConfigSchema — operCreds
 // ============================================================================

package/packages/irc-core/tests/credential-hashing.test.ts

@@ -0,0 +1,170 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type HashedAccountCredential,
+  HashedAccountStore,
+  hashAccountCredential,
+  verifyHashedPassword,
+} from '../src/credential-hashing';
+import type { AccountStore, SaslPayload } from '../src/ports';
+
+describe('hashAccountCredential', () => {
+  it('produces an entry keyed by the username with scrypt', () => {
+    const entry = hashAccountCredential('alice', 'secret');
+    expect(entry.account).toBe('alice');
+    expect(entry.algorithm).toBe('scrypt');
+    expect(entry.salt.length).toBeGreaterThan(0);
+    expect(entry.hash.length).toBeGreaterThan(0);
+  });
+
+  it('never stores the plaintext password in any field', () => {
+    const entry = hashAccountCredential('alice', 'hunter2-secret');
+    expect(entry.account).not.toContain('hunter2');
+    expect(entry.salt).not.toContain('hunter2');
+    expect(entry.hash).not.toContain('hunter2');
+  });
+
+  it('produces different hashes for the same password under different salts', () => {
+    const a = hashAccountCredential('alice', 'secret', { salt: new Uint8Array(16).fill(0x61) });
+    const b = hashAccountCredential('alice', 'secret', { salt: new Uint8Array(16).fill(0x62) });
+    expect(a.hash).not.toBe(b.hash);
+  });
+
+  it('is deterministic for a fixed salt', () => {
+    const salt = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
+    const a = hashAccountCredential('alice', 'secret', { salt });
+    const b = hashAccountCredential('alice', 'secret', { salt });
+    expect(a.hash).toBe(b.hash);
+  });
+
+  it('honours a custom key length', () => {
+    const entry = hashAccountCredential('alice', 'secret', { keyLen: 32 });
+    // base64 of 32 bytes → ~44 chars; decode to verify length.
+    const decoded = Buffer.from(entry.hash, 'base64');
+    expect(decoded.length).toBe(32);
+  });
+
+  it('generates a fresh random salt when none is supplied', () => {
+    const a = hashAccountCredential('alice', 'secret');
+    const b = hashAccountCredential('alice', 'secret');
+    expect(a.salt).not.toBe(b.salt);
+    expect(a.hash).not.toBe(b.hash);
+  });
+});
+
+describe('verifyHashedPassword', () => {
+  it('round-trips a hashed credential: correct password verifies', () => {
+    const entry = hashAccountCredential('alice', 's3cret');
+    expect(verifyHashedPassword('s3cret', entry)).toBe(true);
+  });
+
+  it('rejects a wrong password', () => {
+    const entry = hashAccountCredential('alice', 's3cret');
+    expect(verifyHashedPassword('wrong', entry)).toBe(false);
+  });
+
+  it('rejects a non-scrypt algorithm entry', () => {
+    const entry: HashedAccountCredential = {
+      account: 'alice',
+      algorithm: 'argon2' as 'scrypt',
+      salt: 'aaaa',
+      hash: 'bbbb',
+    };
+    expect(verifyHashedPassword('s3cret', entry)).toBe(false);
+  });
+
+  it('rejects a malformed base64 salt without throwing', () => {
+    const entry: HashedAccountCredential = {
+      account: 'alice',
+      algorithm: 'scrypt',
+      salt: 'not!!valid*b64',
+      hash: 'bbbb',
+    };
+    expect(verifyHashedPassword('s3cret', entry)).toBe(false);
+  });
+
+  it('rejects an entry whose decoded hash is empty', () => {
+    const entry: HashedAccountCredential = {
+      account: 'alice',
+      algorithm: 'scrypt',
+      salt: 'AAAA',
+      hash: '',
+    };
+    expect(verifyHashedPassword('s3cret', entry)).toBe(false);
+  });
+});
+
+describe('HashedAccountStore', () => {
+  function plain(username: string, password: string): SaslPayload {
+    return { kind: 'PLAIN', username, password };
+  }
+
+  it('implements the AccountStore port', () => {
+    const store: AccountStore = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store).toBeDefined();
+  });
+
+  it('accepts valid PLAIN credentials and returns the account name', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', plain('alice', 's3cret'))).toEqual({
+      ok: true,
+      account: 'alice',
+    });
+  });
+
+  it('rejects a wrong password', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', plain('alice', 'wrong')).ok).toBe(false);
+  });
+
+  it('rejects an unknown username', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', plain('bob', 's3cret')).ok).toBe(false);
+  });
+
+  it('rejects a non-PLAIN mechanism', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('EXTERNAL', plain('alice', 's3cret')).ok).toBe(false);
+  });
+
+  it('rejects a RAW payload', () => {
+    const store = new HashedAccountStore([hashAccountCredential('alice', 's3cret')]);
+    expect(store.verify('PLAIN', { kind: 'RAW', data: 'whatever' }).ok).toBe(false);
+  });
+
+  it('handles multiple loaded accounts', () => {
+    const store = new HashedAccountStore([
+      hashAccountCredential('alice', 'a-secret'),
+      hashAccountCredential('bob', 'b-secret'),
+    ]);
+    expect(store.verify('PLAIN', plain('alice', 'a-secret'))).toEqual({
+      ok: true,
+      account: 'alice',
+    });
+    expect(store.verify('PLAIN', plain('bob', 'b-secret'))).toEqual({
+      ok: true,
+      account: 'bob',
+    });
+  });
+
+  it('fails every verify when constructed with no entries', () => {
+    const store = new HashedAccountStore([]);
+    expect(store.verify('PLAIN', plain('alice', 's3cret')).ok).toBe(false);
+  });
+
+  it('reports the number of loaded entries via size', () => {
+    const store = new HashedAccountStore([
+      hashAccountCredential('alice', 'a'),
+      hashAccountCredential('bob', 'b'),
+    ]);
+    expect(store.size).toBe(2);
+  });
+
+  it('round-trips an externally-constructed HashedAccountCredential', () => {
+    const row: HashedAccountCredential = hashAccountCredential('carol', 'p@ss');
+    const store = new HashedAccountStore([row]);
+    expect(store.verify('PLAIN', plain('carol', 'p@ss'))).toEqual({
+      ok: true,
+      account: 'carol',
+    });
+  });
+});

package/packages/irc-core/tests/dropped-s2s-and-obsolete-verbs.test.ts

@@ -0,0 +1,90 @@
+/**
+ * Regression guards for the formally-dropped S2S and obsolete RFC 2812 verbs.
+ *
+ * - S2S drop: `CONNECT` / `SQUIT` / `LINKS` are server-to-server commands.
+ *   S2S is an explicit PLAN non-goal (`PLAN.md` §1), so the three verbs are
+ *   formally dropped (they still return `421 ERR_UNKNOWNCOMMAND` — that is
+ *   the correct response for an unimplemented command). Their reserved
+ *   numerics (`RPL_LINKS`, `RPL_ENDOFLINKS`, `ERR_CANTKILLSERVER`) are removed
+ *   here.
+ *
+ * - Obsolete-verb drop: `SERVICE` / `SUMMON` / `USERS` are RFC 2812 verbs
+ *   that were never widely implemented and are effectively dead. They are
+ *   formally dropped (also still `421`). Their reserved numerics
+ *   (`RPL_YOURESERVICE`, `ERR_NOSUCHSERVICE`, `ERR_SUMMONDISABLED`,
+ *   `ERR_USERSDISABLED`) are removed here.
+ *
+ * Because the drop is "remove the numeric, keep the 421", there is no runtime
+ * behaviour to assert — these are source-level / registry-level regression
+ * guards that prevent the numerics (and the "deferred verb" framing) from
+ * creeping back in.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { Numerics, numericToName } from '../src/protocol/numerics';
+import numericsSource from '../src/protocol/numerics.ts?raw';
+
+describe('dropped S2S verbs (CONNECT / SQUIT / LINKS)', () => {
+  // S2S is a PLAN non-goal; the three verbs are formally dropped. Their
+  // reserved numerics are removed from the registry.
+  const droppedS2SNumerics = ['RPL_LINKS', 'RPL_ENDOFLINKS', 'ERR_CANTKILLSERVER'] as const;
+
+  it.each(droppedS2SNumerics)('numerics.ts source no longer defines %s', (name) => {
+    expect(numericsSource).not.toContain(`${name}:`);
+  });
+
+  it.each(droppedS2SNumerics)('Numerics runtime object has no %s key', (name) => {
+    expect((Numerics as Record<string, unknown>)[name]).toBeUndefined();
+  });
+
+  it('numericToName no longer resolves the dropped S2S codes (364, 365, 483)', () => {
+    expect(numericToName.get(364)).toBeUndefined();
+    expect(numericToName.get(365)).toBeUndefined();
+    expect(numericToName.get(483)).toBeUndefined();
+  });
+
+  it('numerics.ts source documents the S2S drop', () => {
+    // The drop must be explained where the numerics used to live, so the
+    // absence is not mistaken for a gap.
+    expect(numericsSource).toMatch(/S2S/);
+    expect(numericsSource).toMatch(/PLAN non-goal/);
+  });
+
+  it('ERR_NOSUCHSERVER (402) is retained (used by LUSERS/STATS/TRACE)', () => {
+    // 402 stays because the implemented query verbs use it for remote-server
+    // gating.
+    expect(Numerics.ERR_NOSUCHSERVER).toBe(402);
+    expect(numericToName.get(402)).toBe('ERR_NOSUCHSERVER');
+  });
+});
+
+describe('dropped obsolete RFC 2812 verbs (SERVICE / SUMMON / USERS)', () => {
+  // RFC 2812 obsolete verbs, never widely implemented. Formally dropped;
+  // their reserved numerics are removed from the registry.
+  const droppedObsoleteNumerics = [
+    'RPL_YOURESERVICE',
+    'ERR_NOSUCHSERVICE',
+    'ERR_SUMMONDISABLED',
+    'ERR_USERSDISABLED',
+  ] as const;
+
+  it.each(droppedObsoleteNumerics)('numerics.ts source no longer defines %s', (name) => {
+    expect(numericsSource).not.toContain(`${name}:`);
+  });
+
+  it.each(droppedObsoleteNumerics)('Numerics runtime object has no %s key', (name) => {
+    expect((Numerics as Record<string, unknown>)[name]).toBeUndefined();
+  });
+
+  it('numericToName no longer resolves the dropped obsolete codes (383, 408, 445, 446)', () => {
+    expect(numericToName.get(383)).toBeUndefined();
+    expect(numericToName.get(408)).toBeUndefined();
+    expect(numericToName.get(445)).toBeUndefined();
+    expect(numericToName.get(446)).toBeUndefined();
+  });
+
+  it('numerics.ts source documents the obsolete-verb drop', () => {
+    expect(numericsSource).toMatch(/RFC 2812/);
+    expect(numericsSource).toMatch(/obsolete/);
+  });
+});