serverless-ircd 0.5.0 → 0.7.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

@@ -162,6 +162,19 @@ describe('numericToName', () => {
   it('returns undefined for an unregistered code', () => {
     expect(numericToName.get(600)).toBeUndefined();
   });
+
+  it('round-trips every entry in the Numerics registry (reverse-lookup parity)', () => {
+    // Pin the map-construction arrow function: every [name, code] pair in
+    // the forward table MUST appear inverted in numericToName. A mutated
+    // mapper (e.g. `() => undefined`) would leave the reverse table empty
+    // or fail to construct, which this exhaustive check catches.
+    const entries = Object.entries(Numerics) as ReadonlyArray<[NumericCode, number]>;
+    expect(entries.length).toBeGreaterThan(0);
+    for (const [name, code] of entries) {
+      expect(numericToName.get(code)).toBe(name);
+    }
+    expect(numericToName.size).toBe(entries.length);
+  });
 });
 
 describe('isNumericCommand', () => {

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

@@ -133,31 +133,58 @@ describe('parse — framing tolerance', () => {
   it('strips a lone trailing LF', () => {
     expect(parse('PING :tok\n').params).toEqual(['tok']);
   });
+
+  it('preserves CR/LF that appears inside the trailing param', () => {
+    // The CR/LF strip regex is anchored to the END of the line only; a CR/LF
+    // embedded in a trailing param must survive into the parsed value.
+    expect(parse('PRIVMSG #foo :a\rb').params[1]).toBe('a\rb');
+    expect(parse('PRIVMSG #foo :a\nb').params[1]).toBe('a\nb');
+  });
 });
 
 describe('parse — malformed input', () => {
+  // Each case asserts both the error class AND the diagnostic message text.
+  // The message assertion is what pins the failure to the *correct* guard:
+  // several guards fall through to a sibling throw of the same class, so a
+  // bare `toThrow(IrcParseError)` would miss removed/disabled guards.
+
   it('throws IrcParseError on empty input', () => {
     expect(() => parse('')).toThrow(IrcParseError);
+    expect(() => parse('')).toThrow('empty message');
   });
 
   it('throws IrcParseError on whitespace-only input', () => {
     expect(() => parse('   ')).toThrow(IrcParseError);
+    expect(() => parse('   ')).toThrow('invalid command token');
   });
 
   it('throws IrcParseError when only a source prefix is present', () => {
     expect(() => parse(':nick!user@host')).toThrow(IrcParseError);
+    expect(() => parse(':nick!user@host')).toThrow('source prefix with no command');
   });
 
   it('throws IrcParseError when a source is followed by no command', () => {
     expect(() => parse(':irc.example.com   ')).toThrow(IrcParseError);
+    expect(() => parse(':irc.example.com   ')).toThrow('missing command');
   });
 
   it('throws IrcParseError when a tag section has no body', () => {
     expect(() => parse('@time=now')).toThrow(IrcParseError);
+    expect(() => parse('@time=now')).toThrow('tag section with no message body');
   });
 
   it('throws IrcParseError on an invalid command token', () => {
     expect(() => parse('12 hi')).toThrow(IrcParseError);
+    expect(() => parse('12 hi')).toThrow('invalid command token');
+  });
+
+  it('sets the error `name` to "IrcParseError" for instanceof-equivalent checks', () => {
+    try {
+      parse('');
+      expect.fail('expected parse to throw');
+    } catch (err) {
+      expect((err as Error).name).toBe('IrcParseError');
+    }
   });
 });
 
@@ -203,3 +230,85 @@ describe('parse — RFC 1459 §2.3 input line-length cap', () => {
     }
   });
 });
+
+describe('parse — command token grammar (anchored regex)', () => {
+  // COMMAND_RE is anchored at both ends (^...$). A command token must be
+  // EITHER all letters OR exactly three digits — mixed alphanumerics are a
+  // protocol violation. These tests pin both anchors: removing ^ or $
+  // would let the partial-match mutations through.
+
+  it('rejects a command token with trailing digits (end anchor)', () => {
+    expect(() => parse('PRIVMSG123 #foo :hi')).toThrow(IrcParseError);
+  });
+
+  it('rejects a command token with leading digits (start anchor)', () => {
+    expect(() => parse('123PRIVMSG #foo :hi')).toThrow(IrcParseError);
+  });
+
+  it('rejects a two-digit numeric command (length pin)', () => {
+    expect(() => parse('12 #foo')).toThrow(IrcParseError);
+  });
+});
+
+describe('parse — source prefix shape (strict property presence)', () => {
+  // `user` and `host` must be ABSENT (not merely `undefined`) when the
+  // source has no `!user` / `@host` component. `toEqual` ignores
+  // undefined-valued properties, so these mutants would survive a normal
+  // equality check; `toStrictEqual` does not.
+
+  it('omits user AND host from a bare-servername source', () => {
+    expect(parse(':irc.example.com NOTICE * :hi').source).toStrictEqual({
+      name: 'irc.example.com',
+    });
+  });
+
+  it('omits host from a nick!user source (no @host)', () => {
+    expect(parse(':nick!user PRIVMSG #foo :hi').source).toStrictEqual({
+      name: 'nick',
+      user: 'user',
+    });
+  });
+
+  it('omits user from a nick@host source (no !user)', () => {
+    expect(parse(':nick@host PRIVMSG #foo :hi').source).toStrictEqual({
+      name: 'nick',
+      host: 'host',
+    });
+  });
+
+  it('does not set a source property on a source-less message', () => {
+    const msg = parse('PRIVMSG #foo :hi');
+    expect('source' in msg).toBe(false);
+  });
+});
+
+describe('parse — middle parameter whitespace collapsing', () => {
+  it('drops empty params produced by runs of spaces between middles', () => {
+    // The split-then-filter pipeline removes the empty strings that
+    // consecutive spaces generate. Removing the filter (or mutating the
+    // predicate to a tautology) would leak '' entries here.
+    expect(parse(':nick JOIN #a  #b').params).toEqual(['#a', '#b']);
+    expect(parse(':nick JOIN  #a   #b ').params).toEqual(['#a', '#b']);
+  });
+});
+
+describe('unescapeTagValue — boundary conditions', () => {
+  // Imported indirectly through parse() tag values; these pin the loop
+  // bounds so off-by-one mutations on the backslash lookahead can't survive.
+
+  it('keeps a lone trailing backslash verbatim', () => {
+    // `\` at the end with no following char must not read past the end of
+    // the string and must be emitted literally.
+    expect(parse('@a=foo\\ PRIVMSG #foo :hi').tags.a).toBe('foo\\');
+    expect(parse('@a=\\ PRIVMSG #foo :hi').tags.a).toBe('\\');
+  });
+
+  it('handles a tag value that is only a backslash', () => {
+    expect(parse('@a=\\ PRIVMSG #foo :hi').tags.a).toBe('\\');
+  });
+
+  it('decodes a trailing escape sequence with no following character partially', () => {
+    // A complete `\\` pair decodes to a single backslash.
+    expect(parse('@a=x\\\\ PRIVMSG #foo :hi').tags.a).toBe('x\\');
+  });
+});