serverless-ircd 0.8.0 → 0.9.0

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

@@ -577,12 +577,15 @@ describe('passReducer', () => {
     expect(out.effects).toEqual([]);
   });
 
-  it('overwrites a previous passAttempt on repeated PASS', () => {
+  it('emits 462 when PASS is sent twice before registration completes', () => {
     const state = makeState();
     state.passAttempt = 'first';
     const ctx = makeCtx(state);
     const out = passReducer(state, { command: 'PASS', params: ['second'], tags: {} }, ctx);
-    expect(out.state.passAttempt).toBe('second');
+    expect(out.effects).toEqual<EffectType[]>([
+      Effect.send('c1', [L(':irc.example.com 462 * :You may not reregister')]),
+    ]);
+    expect(out.state.passAttempt).toBe('first');
   });
 
   it('emits 461 when no password is supplied', () => {
@@ -595,14 +598,119 @@ describe('passReducer', () => {
     expect(out.state.passAttempt).toBeUndefined();
   });
 
-  it('emits 462 when already registered', () => {
+  it('emits 461 when no password is supplied even after registration', () => {
     const state = registeredState();
     const ctx = makeCtx(state);
-    const out = passReducer(state, { command: 'PASS', params: ['secret'], tags: {} }, ctx);
+    const out = passReducer(state, { command: 'PASS', params: [], tags: {} }, ctx);
     expect(out.effects).toEqual<EffectType[]>([
-      Effect.send('c1', [L(':irc.example.com 462 alice :You may not reregister')]),
+      Effect.send('c1', [L(':irc.example.com 461 alice PASS :Not enough parameters')]),
     ]);
-    expect(out.state.passAttempt).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// passReducer — post-registration PASS (late account login)
+// ============================================================================
+
+describe('passReducer — post-registration PASS <nick>:<password>', () => {
+  it('logs in when PASS <nick>:<password> matches an account after registration', () => {
+    const state = registeredState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    const out = passReducer(state, { command: 'PASS', params: ['alice:hunter2'], tags: {} }, ctx);
+
+    expect(out.state.account).toBe('alice');
+    expect(out.state.userModes.registered).toBe(true);
+    const texts = sentTexts(out.effects);
+    expect(texts).toContain(
+      `:${SV} 900 alice alice!alice@example.com alice :You are now logged in as alice`,
+    );
+    expect(texts).toContain(`:${SV} 903 alice :SASL authentication successful`);
+    expect(texts.some((t) => t.includes(' 462 '))).toBe(false);
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+
+  it('does not log in or disconnect when the password is wrong', () => {
+    const state = registeredState();
+    const accounts = new FakeAccountStore({ ok: false, reason: 'invalid credentials' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    const out = passReducer(state, { command: 'PASS', params: ['alice:wrong'], tags: {} }, ctx);
+
+    expect(out.state.account).toBeUndefined();
+    expect(out.state.userModes.registered).toBe(false);
+    expect(out.effects).toEqual([]);
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+
+  it('is indistinguishable from an unknown nick (no auth numerics, no disconnect)', () => {
+    const state = registeredState();
+    state.nick = 'nobody';
+    const accounts = new FakeAccountStore({ ok: false, reason: 'invalid credentials' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    const out = passReducer(state, { command: 'PASS', params: ['nobody:wrong'], tags: {} }, ctx);
+
+    expect(out.state.account).toBeUndefined();
+    expect(out.effects).toEqual([]);
+  });
+
+  it('equalises timing with an extra dummy verify on failure', () => {
+    const state = registeredState();
+    const accounts = new FakeAccountStore({ ok: false, reason: 'invalid credentials' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    passReducer(state, { command: 'PASS', params: ['alice:wrong'], tags: {} }, ctx);
+
+    expect(accounts.calls).toHaveLength(2);
+    expect(accounts.calls[0]?.payload).toEqual({
+      kind: 'PLAIN',
+      username: 'alice',
+      password: 'wrong',
+    });
+    expect(accounts.calls[1]?.payload.kind).toBe('PLAIN');
+  });
+
+  it('does not log in when the payload nick does not match state.nick', () => {
+    const state = registeredState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'bob' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    const out = passReducer(state, { command: 'PASS', params: ['bob:hunter2'], tags: {} }, ctx);
+
+    expect(out.state.account).toBeUndefined();
+    expect(accounts.calls).toHaveLength(0);
+    expect(out.effects).toEqual([]);
+  });
+
+  it('ignores a bare PASS value (no colon) after registration — no 462, no disconnect', () => {
+    const state = registeredState();
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    const out = passReducer(state, { command: 'PASS', params: ['serverpw'], tags: {} }, ctx);
+
+    expect(out.state.account).toBeUndefined();
+    expect(out.effects).toEqual([]);
+    expect(accounts.calls).toHaveLength(0);
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+
+  it('ignores a late PASS when the connection is already identified', () => {
+    const state = registeredState();
+    state.account = 'alice';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const ctx = makeCtxWithAccounts(state, accounts);
+    const out = passReducer(state, { command: 'PASS', params: ['alice:hunter2'], tags: {} }, ctx);
+
+    expect(accounts.calls).toHaveLength(0);
+    expect(out.effects).toEqual([]);
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
+  });
+
+  it('ignores a late PASS <nick>:<password> when no AccountStore is bound', () => {
+    const state = registeredState();
+    const ctx = makeCtx(state);
+    const out = passReducer(state, { command: 'PASS', params: ['alice:hunter2'], tags: {} }, ctx);
+
+    expect(out.state.account).toBeUndefined();
+    expect(out.effects).toEqual([]);
+    expect(out.effects.some((e) => e.tag === 'Disconnect')).toBe(false);
   });
 });
 
@@ -1668,6 +1776,76 @@ describe('emitWelcomeIfReady — PASS-based account auth (account-effects parity
     expect(sentTexts(effects).some((t) => t.includes('[Memo #') && t.includes('hi'))).toBe(true);
   });
 
+  it('applies the assigned HostServ vhost on PASS-auth success so 001 carries the vhost', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'real.example.net';
+    state.passAttempt = 'alice:hunter2';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.setVhost('alice', 'cool.example.net');
+    const ctx = makeCtxPassAuth(state, { accounts, services });
+
+    const effects = emitWelcomeIfReady(state, ctx);
+
+    expect(state.account).toBe('alice');
+    expect(state.vhostActive).toBe(true);
+    expect(state.host).toBe('cool.example.net');
+    expect(state.preVhostHost).toBe('real.example.net');
+    const welcome = sentTexts(effects).find((t) => t.startsWith(`:${SV} 001 `));
+    expect(welcome).toBeDefined();
+    expect(welcome).toContain('cool.example.net');
+  });
+
+  it('does not apply a vhost on PASS-auth success when none is assigned', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = 'real.example.net';
+    state.passAttempt = 'alice:hunter2';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    const ctx = makeCtxPassAuth(state, { accounts, services });
+
+    emitWelcomeIfReady(state, ctx);
+
+    expect(state.vhostActive).toBeUndefined();
+    expect(state.host).toBe('real.example.net');
+  });
+
+  it('does not cloak over an active vhost applied during PASS-auth (vhost wins)', () => {
+    const state = makeState();
+    state.nick = 'alice';
+    state.user = 'alice';
+    state.host = '203.0.113.5';
+    state.passAttempt = 'alice:hunter2';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.setVhost('alice', 'cool.example.net');
+    const ctx: Ctx = buildCtx({
+      serverConfig: { ...serverConfig, cloaking: { enabled: true, secret: 's3cret' } },
+      clock: new FakeClock(1_000),
+      ids: new SequentialIdFactory(),
+      motd: EmptyMotdProvider,
+      connection: state,
+      accounts,
+      services,
+    });
+
+    const effects = emitWelcomeIfReady(state, ctx);
+
+    // The vhost was applied by the PASS-auth success chain; cloaking must not
+    // clobber it, and the 001 welcome must carry the vhost, not the cloak.
+    expect(state.vhostActive).toBe(true);
+    expect(state.host).toBe('cool.example.net');
+    const welcome = sentTexts(effects).find((t) => t.startsWith(`:${SV} 001 `));
+    expect(welcome).toContain('cool.example.net');
+    expect(welcome).not.toContain(
+      cloakHost('203.0.113.5', { enabled: true, secret: 's3cret' }, 'ExampleNet'),
+    );
+  });
+
   it('records the payload nick as the canonical account name', () => {
     const state = makeState();
     state.nick = 'alice';
@@ -1940,3 +2118,46 @@ describe('applyAccountSuccess — shared account-login helper', () => {
     expect(texts).toContain(`:${SV} 903 alice :SASL authentication successful`);
   });
 });
+
+// ============================================================================
+// applyAccountSuccess — HostServ vhost auto-apply (SASL + PASS-auth share it)
+// ============================================================================
+
+describe('applyAccountSuccess — HostServ vhost auto-apply', () => {
+  it('applies an assigned vhost to state.host and sets vhostActive when services hold a vhost for the account', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.setVhost('alice', 'cool.example.net');
+    const state = registeredState();
+    state.host = 'real.example.net';
+    const ctx = makeCtxWithServices(state, services);
+
+    applyAccountSuccess(state, ctx, 'alice');
+
+    expect(state.vhostActive).toBe(true);
+    expect(state.host).toBe('cool.example.net');
+    expect(state.preVhostHost).toBe('real.example.net');
+  });
+
+  it('leaves state.host unchanged when no vhost is assigned to the account', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    const state = registeredState();
+    state.host = 'real.example.net';
+    const ctx = makeCtxWithServices(state, services);
+
+    applyAccountSuccess(state, ctx, 'alice');
+
+    expect(state.vhostActive).toBeUndefined();
+    expect(state.host).toBe('real.example.net');
+  });
+
+  it('does not emit a CHGHOST broadcast when no channels are joined (pre-JOIN identify)', () => {
+    const services = new InMemoryServicesStore({ clock: new FakeClock(1_000) });
+    services.setVhost('alice', 'cool.example.net');
+    const state = registeredState();
+    const ctx = makeCtxWithServices(state, services);
+
+    const effects = applyAccountSuccess(state, ctx, 'alice');
+
+    expect(effects.filter((e) => e.tag === 'Broadcast')).toEqual<EffectType[]>([]);
+  });
+});

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

@@ -302,6 +302,50 @@ describe('authenticateReducer — PLAIN success', () => {
     expect(texts.some((l) => l.text.includes('[Memo #1'))).toBe(false);
   });
 
+  it('applies the assigned HostServ vhost on SASL PLAIN success', () => {
+    const state = saslReadyState();
+    state.host = 'real.example.net';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const services = new InMemoryServicesStore();
+    services.setVhost('alice', 'cool.example.net');
+    const ctx = makeCtx(state, accounts, undefined, services);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.vhostActive).toBe(true);
+    expect(state.host).toBe('cool.example.net');
+    expect(state.preVhostHost).toBe('real.example.net');
+  });
+
+  it('does not emit a CHGHOST broadcast on SASL success (pre-registration, no peers)', () => {
+    const state = saslReadyState();
+    state.host = 'real.example.net';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const services = new InMemoryServicesStore();
+    services.setVhost('alice', 'cool.example.net');
+    const ctx = makeCtx(state, accounts, undefined, services);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    const out = authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(out.effects.filter((e) => e.tag === 'Broadcast')).toEqual<EffectType[]>([]);
+  });
+
+  it('leaves host unchanged on SASL success when no vhost is assigned', () => {
+    const state = saslReadyState();
+    state.host = 'real.example.net';
+    const accounts = new FakeAccountStore({ ok: true, account: 'alice' });
+    const services = new InMemoryServicesStore();
+    const ctx = makeCtx(state, accounts, undefined, services);
+
+    authenticateReducer(state, authenticate('PLAIN'), ctx);
+    authenticateReducer(state, authenticate(plainPayload('alice', 'secret')), ctx);
+
+    expect(state.vhostActive).toBeUndefined();
+    expect(state.host).toBe('real.example.net');
+  });
+
   it('delivers nothing on a SASL login when the account has no memos', () => {
     const state = saslReadyState();
     const accounts = new FakeAccountStore({ ok: true, account: 'alice' });

package/packages/irc-core/tests/commands/service-aliases.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+import { CHANSERV_NICK } from '../../src/commands/chanserv';
+import { HOSTSERV_NICK } from '../../src/commands/hostserv';
+import { MEMOSERV_NICK } from '../../src/commands/memoserv';
+import { NICKSERV_NICK } from '../../src/commands/nickserv';
+import { OPERSERV_NICK } from '../../src/commands/operserv';
+import { SERVICE_NICKS, SHORTCUT_TO_SERVICE } from '../../src/commands/service-aliases';
+
+describe('service-aliases — single source of truth for shortcut verbs', () => {
+  it('maps every Atheme/Anope shortcut verb to its canonical service nick', () => {
+    const expected: ReadonlyArray<[string, string]> = [
+      ['NICKSERV', NICKSERV_NICK],
+      ['NS', NICKSERV_NICK],
+      ['CHANSERV', CHANSERV_NICK],
+      ['CS', CHANSERV_NICK],
+      ['HOSTSERV', HOSTSERV_NICK],
+      ['HS', HOSTSERV_NICK],
+      ['MEMOSERV', MEMOSERV_NICK],
+      ['MS', MEMOSERV_NICK],
+      ['OPERSERV', OPERSERV_NICK],
+      ['OS', OPERSERV_NICK],
+    ];
+    expect(SHORTCUT_TO_SERVICE.size).toBe(10);
+    for (const [alias, nick] of expected) {
+      expect(SHORTCUT_TO_SERVICE.get(alias)).toBe(nick);
+    }
+  });
+
+  it('keys every alias uppercased so the dispatcher can do a case-insensitive lookup', () => {
+    for (const alias of SHORTCUT_TO_SERVICE.keys()) {
+      expect(alias).toBe(alias.toUpperCase());
+    }
+  });
+
+  it('SERVICE_NICKS is the de-duplicated set of service nicks from the map values', () => {
+    const expected = Array.from(new Set(SHORTCUT_TO_SERVICE.values())).sort();
+    expect([...SERVICE_NICKS].sort()).toEqual(expected);
+  });
+
+  it('every value in SHORTCUT_TO_SERVICE is one of the canonical *_NICK constants', () => {
+    const canonical = new Set<string>([
+      NICKSERV_NICK,
+      CHANSERV_NICK,
+      HOSTSERV_NICK,
+      MEMOSERV_NICK,
+      OPERSERV_NICK,
+    ]);
+    for (const nick of SHORTCUT_TO_SERVICE.values()) {
+      expect(canonical.has(nick)).toBe(true);
+    }
+  });
+});

package/packages/irc-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-server",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "private": true,
   "description": "Orchestration layer: IrcRuntime port, dispatch interpreter, ConnectionActor",
   "license": "BSD-3-Clause",

package/packages/irc-server/src/actor.ts

@@ -56,6 +56,8 @@ import {
   Numerics,
   OPERSERV_NICK,
   type RawLine,
+  type Reducer,
+  SHORTCUT_TO_SERVICE,
   type ServerConfig,
   type ServerStats,
   type ServicesStore,
@@ -527,6 +529,28 @@ export class ConnectionActor {
       return this.accumulateMultilineLine(msg);
     }
 
+    // Service shortcut commands (Atheme/Anope convention): rewrite verbs
+    // like `NICKSERV IDENTIFY pw` / `NS INFO` / `CS REGISTER #home` to the
+    // canonical `PRIVMSG <ServiceNick> :<joined args>` and delegate to the
+    // existing service-routing path (`routeMessageTarget` →
+    // `serviceReducerFor`). `SHORTCUT_TO_SERVICE` is the single source of
+    // truth for the alias → service nick mapping; the service reducers run
+    // unchanged against the rewritten `params=[serviceNick, body]` shape.
+    const serviceShortcutTarget = SHORTCUT_TO_SERVICE.get(msg.command.toUpperCase());
+    if (serviceShortcutTarget !== undefined) {
+      const rewritten: IrcMessage = {
+        ...msg,
+        command: 'PRIVMSG',
+        params: [serviceShortcutTarget, msg.params.join(' ')],
+      };
+      return this.routeMessageTarget(
+        rewritten,
+        this.reducers.privmsgChannel,
+        this.reducers.privmsgUser,
+        ctx,
+      );
+    }
+
     switch (msg.command) {
       // -------- Connection-authority commands --------
       case 'PING':
@@ -1348,39 +1372,22 @@ export class ConnectionActor {
     }
     for (const target of targets) {
       const singleParamMsg: IrcMessage = { ...msg, params: [target, ...tail] };
+      const serviceReducer = this.serviceReducerFor(target, msg.command);
       if (isChannelTarget(target)) {
         const chan = this.channels.getOrCreateChannel(target);
         effects.push(...channelReducer(chan, singleParamMsg, ctx).effects);
-      } else if (
-        msg.command === 'PRIVMSG' &&
-        this.services !== undefined &&
-        caseFold('rfc1459', target) === caseFold('rfc1459', NICKSERV_NICK)
-      ) {
-        effects.push(...this.reducers.nickserv(this.state, singleParamMsg, ctx).effects);
-      } else if (
-        msg.command === 'PRIVMSG' &&
-        this.services !== undefined &&
-        caseFold('rfc1459', target) === caseFold('rfc1459', CHANSERV_NICK)
-      ) {
-        effects.push(...this.reducers.chanserv(this.state, singleParamMsg, ctx).effects);
-      } else if (
-        msg.command === 'PRIVMSG' &&
-        this.services !== undefined &&
-        caseFold('rfc1459', target) === caseFold('rfc1459', HOSTSERV_NICK)
-      ) {
-        effects.push(...this.reducers.hostserv(this.state, singleParamMsg, ctx).effects);
-      } else if (
-        msg.command === 'PRIVMSG' &&
-        this.services !== undefined &&
-        caseFold('rfc1459', target) === caseFold('rfc1459', MEMOSERV_NICK)
-      ) {
-        effects.push(...this.reducers.memoserv(this.state, singleParamMsg, ctx).effects);
-      } else if (
-        msg.command === 'PRIVMSG' &&
-        this.services !== undefined &&
-        caseFold('rfc1459', target) === caseFold('rfc1459', OPERSERV_NICK)
-      ) {
-        effects.push(...this.reducers.operserv(this.state, singleParamMsg, ctx).effects);
+      } else if (serviceReducer !== undefined) {
+        // Echo the sender's own PRIVMSG back BEFORE the service reducer's NOTICE
+        // reply — matching how every other PRIVMSG renders (your outgoing line
+        // first, then any reply). Without this ordering a client sees the
+        // service's response above its own message, which reads as a bug.
+        if (ctx.connection.caps.has('echo-message')) {
+          const hostmask = hostmaskOf(this.state) ?? this.state.nick ?? '?';
+          const text = singleParamMsg.params[1] ?? '';
+          const echoLine: RawLine = { text: `:${hostmask} PRIVMSG ${target} :${text}` };
+          effects.push(Effect.send(ctx.connId, [echoLine]));
+        }
+        effects.push(...serviceReducer(this.state, singleParamMsg, ctx).effects);
       } else {
         effects.push(...userReducer(this.state, singleParamMsg, ctx).effects);
       }
@@ -1388,6 +1395,26 @@ export class ConnectionActor {
     return effects;
   }
 
+  /**
+   * Resolves the service pseudo-client reducer for a nick target, or
+   * `undefined` when the target is not a service nick / the command is not
+   * `PRIVMSG` / no services store is bound. Centralised so the
+   * `echo-message` echo (and any future service-routing concern) lives in a
+   * single place rather than being duplicated across five near-identical
+   * branches. `NOTICE` / `TAGMSG` to a service nick intentionally return
+   * `undefined` so they fall through to the normal user-target reducer.
+   *
+   * The membership test is a table lookup against {@link SERVICE_REDUCER_KEYS}
+   * (built from the same `*_NICK` constants that back
+   * {@link SHORTCUT_TO_SERVICE}), so the service-nick list has one source of
+   * truth rather than a per-service `if`-chain here.
+   */
+  private serviceReducerFor(target: string, command: string): Reducer<ConnectionState> | undefined {
+    if (command !== 'PRIVMSG' || this.services === undefined) return undefined;
+    const key = SERVICE_REDUCER_KEYS.get(caseFold('rfc1459', target));
+    return key === undefined ? undefined : this.reducers[key];
+  }
+
   private unknownCommandEffect(command: string): EffectType {
     const nick = this.state.nick ?? '*';
     const code = Numerics.ERR_UNKNOWNCOMMAND.toString().padStart(3, '0');
@@ -1416,6 +1443,29 @@ function splitCsv(param: string): string[] {
   return param.split(',').filter((p) => p.length > 0);
 }
 
+/**
+ * Service reducer keys on {@link RoutedReducers}. Narrower than
+ * `keyof RoutedReducers` so the table lookup resolves to a
+ * `Reducer<ConnectionState>` without a widening cast.
+ */
+type ServiceReducerKey = 'nickserv' | 'chanserv' | 'hostserv' | 'memoserv' | 'operserv';
+
+/**
+ * rfc1459 case-folded service nick → reducer key. The single source of
+ * truth for "which targets are service nicks" — built from the canonical
+ * `*_NICK` constants that also back {@link SHORTCUT_TO_SERVICE}, so the
+ * dispatcher's shortcut rewrite and `serviceReducerFor`'s routing consult
+ * one set of service nicks rather than each maintaining its own
+ * hand-written `if`-chain.
+ */
+const SERVICE_REDUCER_KEYS: ReadonlyMap<string, ServiceReducerKey> = new Map([
+  [caseFold('rfc1459', NICKSERV_NICK), 'nickserv'],
+  [caseFold('rfc1459', CHANSERV_NICK), 'chanserv'],
+  [caseFold('rfc1459', HOSTSERV_NICK), 'hostserv'],
+  [caseFold('rfc1459', MEMOSERV_NICK), 'memoserv'],
+  [caseFold('rfc1459', OPERSERV_NICK), 'operserv'],
+]);
+
 /**
  * Resolves the `<server>` parameter shared by `LUSERS` / `STATS` (and any
  * future single-server-aware query verb). Returns `undefined` when the