serverless-ircd 0.7.0 → 0.9.0

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

@@ -0,0 +1,1289 @@
+import { describe, expect, it } from 'vitest';
+import {
+  type ChannelLevelOp,
+  type ChannelRegisterResult,
+  FakeClock,
+  InMemoryServicesStore,
+  type JupeEntry,
+  type MemoEntry,
+  type MemoInput,
+  type NickEnforcePolicy,
+  type ReadMarkerEntry,
+  type RegisteredNick,
+  type ServicesAuthResult,
+  type ServicesStore,
+} from '../src/ports';
+
+const NOW = 1_700_000_000_000;
+
+function store(): InMemoryServicesStore {
+  return new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+}
+
+describe('InMemoryServicesStore — port conformance', () => {
+  it('implements the ServicesStore port', () => {
+    const s: ServicesStore = new InMemoryServicesStore();
+    expect(s).toBeDefined();
+  });
+});
+
+// ============================================================================
+// NickServ
+// ============================================================================
+
+describe('InMemoryServicesStore — NickServ REGISTER (registerNick)', () => {
+  it('registers a fresh nick and returns ok with the account name', () => {
+    const s = store();
+    const out = s.registerNick('alice', 'hunter2', 'alice@example.com');
+    expect(out).toEqual<ServicesAuthResult>({ ok: true, account: 'alice' });
+  });
+
+  it('rejects a duplicate nick (case-insensitive) with a readable reason', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    const out = s.registerNick('Alice', 'other', 'alice2@example.com');
+    expect(out.ok).toBe(false);
+    if (out.ok) return;
+    expect(out.reason.length).toBeGreaterThan(0);
+  });
+
+  it('stores the email and a createdAt timestamp on the record', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    const rec = s.getNick('alice');
+    expect(rec).toBeDefined();
+    if (rec === undefined) return;
+    expect(rec.email).toBe('alice@example.com');
+    expect(rec.createdAt).toBe(NOW);
+  });
+
+  it('defaults the enforce policy to "none" on a fresh registration', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    expect(s.getNickEnforce('alice')).toBe<NickEnforcePolicy>('none');
+  });
+
+  it('is markable as registered via isRegisteredNick', () => {
+    const s = store();
+    expect(s.isRegisteredNick('alice')).toBe(false);
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    expect(s.isRegisteredNick('alice')).toBe(true);
+  });
+
+  it('matches isRegisteredNick case-insensitively', () => {
+    const s = store();
+    s.registerNick('Alice', 'hunter2', 'alice@example.com');
+    expect(s.isRegisteredNick('alice')).toBe(true);
+    expect(s.isRegisteredNick('ALICE')).toBe(true);
+  });
+});
+
+describe('InMemoryServicesStore — NickServ IDENTIFY (verifyNick)', () => {
+  it('returns ok with the account name for a correct password', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    expect(s.verifyNick('alice', 'hunter2')).toEqual<ServicesAuthResult>({
+      ok: true,
+      account: 'alice',
+    });
+  });
+
+  it('rejects a wrong password', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    expect(s.verifyNick('alice', 'wrong').ok).toBe(false);
+  });
+
+  it('rejects an unknown nick', () => {
+    const s = store();
+    expect(s.verifyNick('ghost', 'hunter2').ok).toBe(false);
+  });
+
+  it('matches the nick case-insensitively', () => {
+    const s = store();
+    s.registerNick('Alice', 'hunter2', 'alice@example.com');
+    expect(s.verifyNick('alice', 'hunter2')).toEqual<ServicesAuthResult>({
+      ok: true,
+      account: 'Alice',
+    });
+  });
+
+  it('returns a human-readable reason on failure', () => {
+    const s = store();
+    const out = s.verifyNick('alice', 'wrong');
+    if (out.ok) throw new Error('expected failure');
+    expect(out.reason.length).toBeGreaterThan(0);
+  });
+});
+
+describe('InMemoryServicesStore — NickServ DROP (dropNick)', () => {
+  it('returns true and removes the registration for a known nick', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    expect(s.dropNick('alice')).toBe(true);
+    expect(s.isRegisteredNick('alice')).toBe(false);
+    expect(s.getNick('alice')).toBeUndefined();
+  });
+
+  it('returns false for an unknown nick', () => {
+    const s = store();
+    expect(s.dropNick('ghost')).toBe(false);
+  });
+
+  it('folds the nick case-insensitively', () => {
+    const s = store();
+    s.registerNick('Alice', 'hunter2', 'alice@example.com');
+    expect(s.dropNick('ALICE')).toBe(true);
+    expect(s.isRegisteredNick('alice')).toBe(false);
+  });
+
+  it('clears the enforce policy on drop', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.setNickEnforce('alice', 'kill');
+    s.dropNick('alice');
+    expect(s.getNickEnforce('alice')).toBe<NickEnforcePolicy>('none');
+  });
+});
+
+describe('InMemoryServicesStore — NickServ SET ENFORCE (setNickEnforce)', () => {
+  it('updates the policy observable via getNickEnforce', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.setNickEnforce('alice', 'ghost');
+    expect(s.getNickEnforce('alice')).toBe<NickEnforcePolicy>('ghost');
+    s.setNickEnforce('alice', 'kill');
+    expect(s.getNickEnforce('alice')).toBe<NickEnforcePolicy>('kill');
+  });
+
+  it('folds the nick case-insensitively', () => {
+    const s = store();
+    s.registerNick('Alice', 'hunter2', 'alice@example.com');
+    s.setNickEnforce('alice', 'kill');
+    expect(s.getNickEnforce('ALICE')).toBe<NickEnforcePolicy>('kill');
+  });
+
+  it('is a no-op on an unregistered nick (policy stays "none")', () => {
+    const s = store();
+    s.setNickEnforce('ghost', 'kill');
+    expect(s.getNickEnforce('ghost')).toBe<NickEnforcePolicy>('none');
+  });
+
+  it('defaults to "none" for an unregistered nick', () => {
+    const s = store();
+    expect(s.getNickEnforce('ghost')).toBe<NickEnforcePolicy>('none');
+  });
+});
+
+describe('InMemoryServicesStore — NickServ INFO (getNick)', () => {
+  it('returns the full record for a registered nick', () => {
+    const s = store();
+    s.registerNick('Alice', 'hunter2', 'alice@example.com');
+    const rec = s.getNick('alice');
+    expect(rec).toEqual<RegisteredNick>({
+      nick: 'Alice',
+      account: 'Alice',
+      email: 'alice@example.com',
+      createdAt: NOW,
+      enforce: 'none',
+    });
+  });
+
+  it('returns undefined for an unknown nick', () => {
+    const s = store();
+    expect(s.getNick('ghost')).toBeUndefined();
+  });
+
+  it('reflects subsequent enforce-policy changes on the returned record', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.setNickEnforce('alice', 'kill');
+    const rec = s.getNick('alice');
+    expect(rec?.enforce).toBe<NickEnforcePolicy>('kill');
+  });
+});
+
+// ============================================================================
+// ChanServ
+// ============================================================================
+
+describe('InMemoryServicesStore — ChanServ REGISTER (registerChannel)', () => {
+  it('registers a fresh channel and returns ok with the founder', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    const out = s.registerChannel('#home', 'alice');
+    expect(out).toEqual<ChannelRegisterResult>({ ok: true, founder: 'alice' });
+  });
+
+  it('rejects a duplicate channel (case-insensitive)', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    const out = s.registerChannel('#Home', 'bob');
+    expect(out.ok).toBe(false);
+    if (out.ok) return;
+    expect(out.reason.length).toBeGreaterThan(0);
+  });
+
+  it('stores the founder and a createdAt timestamp', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    expect(s.getChannelFounder('#home')).toBe('alice');
+  });
+
+  it('initializes the new record with empty mlock / restricted=false / keepTopic=false', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    const rec = s.getChannel('#home');
+    expect(rec?.mlock).toBe('');
+    expect(rec?.restricted).toBe(false);
+    expect(rec?.keepTopic).toBe(false);
+    expect(rec?.topic).toBeUndefined();
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ DROP (dropChannel)', () => {
+  it('returns true and clears the founder for a known channel', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    expect(s.dropChannel('#home')).toBe(true);
+    expect(s.getChannelFounder('#home')).toBeUndefined();
+  });
+
+  it('returns false for an unknown channel', () => {
+    const s = store();
+    expect(s.dropChannel('#ghost')).toBe(false);
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#Home', 'alice');
+    expect(s.dropChannel('#home')).toBe(true);
+    expect(s.getChannelFounder('#home')).toBeUndefined();
+  });
+
+  it('clears the access list on drop', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerNick('bob', 'pw', 'bob@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelAccess('#home', 'bob', 5);
+    s.dropChannel('#home');
+    expect(s.getChannelAccess('#home', 'bob')).toBe(0);
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ founder lookup (getChannelFounder)', () => {
+  it('returns undefined for an unknown channel', () => {
+    const s = store();
+    expect(s.getChannelFounder('#ghost')).toBeUndefined();
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#Home', 'alice');
+    expect(s.getChannelFounder('#home')).toBe('alice');
+    expect(s.getChannelFounder('#HOME')).toBe('alice');
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ ACCESS (setChannelAccess / getChannelAccess)', () => {
+  it('returns 0 (no access) for an unknown (channel, account) pair', () => {
+    const s = store();
+    expect(s.getChannelAccess('#home', 'alice')).toBe(0);
+  });
+
+  it('sets and returns the level for a known pair', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 5);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(5);
+  });
+
+  it('overwrites the level on a subsequent set for the same pair', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 3);
+    s.setChannelAccess('#home', 'alice', 10);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(10);
+  });
+
+  it('folds channel and account case-insensitively', () => {
+    const s = store();
+    s.setChannelAccess('#Home', 'Alice', 5);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(5);
+    expect(s.getChannelAccess('#HOME', 'ALICE')).toBe(5);
+  });
+
+  it('keeps access for distinct accounts on the same channel separate', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 5);
+    s.setChannelAccess('#home', 'bob', 3);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(5);
+    expect(s.getChannelAccess('#home', 'bob')).toBe(3);
+  });
+
+  it('keeps access for the same account across distinct channels separate', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 5);
+    s.setChannelAccess('#other', 'alice', 3);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(5);
+    expect(s.getChannelAccess('#other', 'alice')).toBe(3);
+  });
+
+  it('removes the entry when the level is set to 0', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 5);
+    s.setChannelAccess('#home', 'alice', 0);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(0);
+  });
+
+  it('removes the entry when the level is set to a negative value', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 5);
+    s.setChannelAccess('#home', 'alice', -1);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(0);
+  });
+
+  it('leaves sibling entries intact when removing one entry from a multi-entry map', () => {
+    const s = store();
+    s.setChannelAccess('#home', 'alice', 5);
+    s.setChannelAccess('#home', 'bob', 3);
+    s.setChannelAccess('#home', 'alice', 0);
+    expect(s.getChannelAccess('#home', 'alice')).toBe(0);
+    expect(s.getChannelAccess('#home', 'bob')).toBe(3);
+  });
+
+  it('re-adds an entry after the per-channel map was emptied out', () => {
+    const s = store();
+    // Fill, then drain: the per-channel map is allocated then dropped.
+    s.setChannelAccess('#home', 'alice', 5);
+    s.setChannelAccess('#home', 'alice', 0);
+    // Re-adding must allocate a fresh per-channel map.
+    s.setChannelAccess('#home', 'bob', 3);
+    expect(s.getChannelAccess('#home', 'bob')).toBe(3);
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ LEVELS (getChannelLevel / setChannelLevel / listChannelLevels / resetChannelLevels)', () => {
+  it('returns undefined for an op with no override stored', () => {
+    const s = store();
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBeUndefined();
+  });
+
+  it('stores and returns an override for a single op', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBe(7);
+  });
+
+  it('overwrites the override on a subsequent set for the same op', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    s.setChannelLevel('#home', 'AUTOOP', 9);
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBe(9);
+  });
+
+  it('reuses the existing per-channel map on a second setChannelLevel for the same channel', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    s.setChannelLevel('#home', 'AUTOVOICE', 2);
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBe(7);
+    expect(s.getChannelLevel('#home', 'AUTOVOICE')).toBe(2);
+  });
+
+  it('folds the channel case-insensitively', () => {
+    const s = store();
+    s.setChannelLevel('#Home', 'AUTOOP', 7);
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBe(7);
+    expect(s.getChannelLevel('#HOME', 'AUTOOP')).toBe(7);
+  });
+
+  it('keeps overrides for distinct channels separate', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    s.setChannelLevel('#other', 'AUTOOP', 4);
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBe(7);
+    expect(s.getChannelLevel('#other', 'AUTOOP')).toBe(4);
+  });
+
+  it('listChannelLevels returns empty for a channel with no overrides', () => {
+    const s = store();
+    expect(s.listChannelLevels('#home')).toEqual([]);
+  });
+
+  it('listChannelLevels enumerates every override on the channel', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    s.setChannelLevel('#home', 'AUTOVOICE', 2);
+    const listed = s.listChannelLevels('#home');
+    expect(listed).toContainEqual({ op: 'AUTOOP', level: 7 });
+    expect(listed).toContainEqual({ op: 'AUTOVOICE', level: 2 });
+  });
+
+  it('resetChannelLevels drops every override for the channel', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    s.resetChannelLevels('#home');
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBeUndefined();
+    expect(s.listChannelLevels('#home')).toEqual([]);
+  });
+
+  it('resetChannelLevels is a no-op when no overrides are set', () => {
+    const s = store();
+    s.resetChannelLevels('#home');
+    expect(s.listChannelLevels('#home')).toEqual([]);
+  });
+
+  it('dropChannel also drops the channel levels map', () => {
+    const s = store();
+    s.setChannelLevel('#home', 'AUTOOP', 7);
+    s.registerChannel('#home', 'alice');
+    s.dropChannel('#home');
+    expect(s.getChannelLevel('#home', 'AUTOOP')).toBeUndefined();
+  });
+
+  it('LEVELS methods are reachable via the ServicesStore surface type', () => {
+    const s: ServicesStore = store();
+    const op: ChannelLevelOp = 'AUTOOP';
+    s.setChannelLevel('#home', op, 7);
+    expect(s.getChannelLevel('#home', op)).toBe(7);
+    expect(s.listChannelLevels('#home').length).toBe(1);
+    s.resetChannelLevels('#home');
+    expect(s.getChannelLevel('#home', op)).toBeUndefined();
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ record lookup (getChannel)', () => {
+  it('returns undefined for an unknown channel', () => {
+    const s = store();
+    expect(s.getChannel('#home')).toBeUndefined();
+  });
+
+  it('returns a defensive copy (mutating the returned record does not mutate the store)', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    const rec = s.getChannel('#home');
+    if (rec === undefined) {
+      expect.fail('expected a record');
+      return;
+    }
+    rec.founder = 'mallory';
+    rec.mlock = '+nt';
+    expect(s.getChannel('#home')?.founder).toBe('alice');
+    expect(s.getChannel('#home')?.mlock).toBe('');
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#Home', 'alice');
+    expect(s.getChannel('#HOME')?.founder).toBe('alice');
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ SET FOUNDER (setChannelFounder)', () => {
+  it('transfers the founder of a registered channel', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerNick('bob', 'pw', 'bob@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelFounder('#home', 'bob');
+    expect(s.getChannelFounder('#home')).toBe('bob');
+  });
+
+  it('is a no-op on an unregistered channel', () => {
+    const s = store();
+    s.setChannelFounder('#ghost', 'bob');
+    expect(s.getChannelFounder('#ghost')).toBeUndefined();
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ SET MLOCK (setChannelMlock / getChannelMlock)', () => {
+  it('stores and returns the modestring', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelMlock('#home', '+nt');
+    expect(s.getChannelMlock('#home')).toBe('+nt');
+  });
+
+  it('overwrites a previous value on a subsequent set', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelMlock('#home', '+nt');
+    s.setChannelMlock('#home', '+n');
+    expect(s.getChannelMlock('#home')).toBe('+n');
+  });
+
+  it('returns an empty string for an unregistered channel', () => {
+    const s = store();
+    expect(s.getChannelMlock('#ghost')).toBe('');
+  });
+
+  it('is a no-op on an unregistered channel (does not throw)', () => {
+    const s = store();
+    s.setChannelMlock('#ghost', '+nt');
+    expect(s.getChannelMlock('#ghost')).toBe('');
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#Home', 'alice');
+    s.setChannelMlock('#HOME', '+nt');
+    expect(s.getChannelMlock('#home')).toBe('+nt');
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ SET RESTRICTED (setChannelRestricted)', () => {
+  it('toggles the restricted flag on', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelRestricted('#home', true);
+    expect(s.getChannel('#home')?.restricted).toBe(true);
+  });
+
+  it('toggles the restricted flag off', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelRestricted('#home', true);
+    s.setChannelRestricted('#home', false);
+    expect(s.getChannel('#home')?.restricted).toBe(false);
+  });
+
+  it('is a no-op on an unregistered channel', () => {
+    const s = store();
+    s.setChannelRestricted('#ghost', true);
+    expect(s.getChannel('#ghost')).toBeUndefined();
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ SET KEEPTOPIC (setChannelKeepTopic)', () => {
+  it('toggles the keepTopic flag on', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelKeepTopic('#home', true);
+    expect(s.getChannel('#home')?.keepTopic).toBe(true);
+  });
+
+  it('drops the persisted topic snapshot when toggled off', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelKeepTopic('#home', true);
+    s.setChannelTopic('#home', { text: 't', setter: 's', setAt: 0 });
+    s.setChannelKeepTopic('#home', false);
+    expect(s.getChannel('#home')?.keepTopic).toBe(false);
+    expect(s.getChannel('#home')?.topic).toBeUndefined();
+  });
+
+  it('is a no-op on an unregistered channel', () => {
+    const s = store();
+    s.setChannelKeepTopic('#ghost', true);
+    expect(s.getChannel('#ghost')).toBeUndefined();
+  });
+});
+
+describe('InMemoryServicesStore — ChanServ topic persistence (setChannelTopic / getChannelTopic)', () => {
+  it('stores and returns the topic snapshot', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelTopic('#home', { text: 'hello', setter: 'alice!alice@e', setAt: 1 });
+    expect(s.getChannelTopic('#home')).toEqual({
+      text: 'hello',
+      setter: 'alice!alice@e',
+      setAt: 1,
+    });
+  });
+
+  it('returns a defensive copy (mutating the returned snapshot does not mutate the store)', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelTopic('#home', { text: 'hello', setter: 's', setAt: 1 });
+    const snap = s.getChannelTopic('#home');
+    if (snap === undefined) {
+      expect.fail('expected a snapshot');
+      return;
+    }
+    snap.text = 'tampered';
+    expect(s.getChannelTopic('#home')?.text).toBe('hello');
+  });
+
+  it('clears the snapshot when passed undefined', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#home', 'alice');
+    s.setChannelTopic('#home', { text: 'hello', setter: 's', setAt: 1 });
+    s.setChannelTopic('#home', undefined);
+    expect(s.getChannelTopic('#home')).toBeUndefined();
+  });
+
+  it('returns undefined for an unregistered channel', () => {
+    const s = store();
+    expect(s.getChannelTopic('#ghost')).toBeUndefined();
+    // setChannelTopic on an unregistered channel is a no-op (not a throw).
+    s.setChannelTopic('#ghost', { text: 'x', setter: 's', setAt: 0 });
+    expect(s.getChannelTopic('#ghost')).toBeUndefined();
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const s = store();
+    s.registerNick('alice', 'hunter2', 'alice@example.com');
+    s.registerChannel('#Home', 'alice');
+    s.setChannelTopic('#home', { text: 'hello', setter: 's', setAt: 1 });
+    expect(s.getChannelTopic('#HOME')?.text).toBe('hello');
+  });
+});
+
+// ============================================================================
+// HostServ
+// ============================================================================
+
+describe('InMemoryServicesStore — HostServ (setVhost / getVhost)', () => {
+  it('returns undefined for an unknown account', () => {
+    const s = store();
+    expect(s.getVhost('alice')).toBeUndefined();
+  });
+
+  it('sets and returns the vhost for a known account', () => {
+    const s = store();
+    s.setVhost('alice', 'cool.example.net');
+    expect(s.getVhost('alice')).toBe('cool.example.net');
+  });
+
+  it('overwrites the vhost on a subsequent set for the same account', () => {
+    const s = store();
+    s.setVhost('alice', 'one.example.net');
+    s.setVhost('alice', 'two.example.net');
+    expect(s.getVhost('alice')).toBe('two.example.net');
+  });
+
+  it('folds the account name case-insensitively', () => {
+    const s = store();
+    s.setVhost('Alice', 'one.example.net');
+    expect(s.getVhost('alice')).toBe('one.example.net');
+    expect(s.getVhost('ALICE')).toBe('one.example.net');
+  });
+
+  it('keeps vhosts for distinct accounts separate', () => {
+    const s = store();
+    s.setVhost('alice', 'a.example.net');
+    s.setVhost('bob', 'b.example.net');
+    expect(s.getVhost('alice')).toBe('a.example.net');
+    expect(s.getVhost('bob')).toBe('b.example.net');
+  });
+
+  it('clears the vhost when set to an empty string', () => {
+    const s = store();
+    s.setVhost('alice', 'cool.example.net');
+    s.setVhost('alice', '');
+    expect(s.getVhost('alice')).toBeUndefined();
+  });
+
+  it('is a no-op to clear an account that has no vhost', () => {
+    const s = store();
+    s.setVhost('alice', '');
+    expect(s.getVhost('alice')).toBeUndefined();
+  });
+});
+
+describe('InMemoryServicesStore — HostServ pending vhost queue', () => {
+  it('returns undefined for a pending vhost when no request has been recorded', () => {
+    const s = store();
+    expect(s.getPendingVhost('alice')).toBeUndefined();
+  });
+
+  it('records a pending vhost request and exposes it via getPendingVhost', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    expect(s.getPendingVhost('alice')).toBe('cool.example.net');
+  });
+
+  it('does NOT activate the vhost on requestVhost (queue mode)', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    expect(s.getVhost('alice')).toBeUndefined();
+  });
+
+  it('overwrites a previously pending vhost on a subsequent request', () => {
+    const s = store();
+    s.requestVhost('alice', 'one.example.net');
+    s.requestVhost('alice', 'two.example.net');
+    expect(s.getPendingVhost('alice')).toBe('two.example.net');
+  });
+
+  it('folds the account name case-insensitively on request and lookup', () => {
+    const s = store();
+    s.requestVhost('Alice', 'one.example.net');
+    expect(s.getPendingVhost('alice')).toBe('one.example.net');
+    expect(s.getPendingVhost('ALICE')).toBe('one.example.net');
+  });
+
+  it('listPendingVhosts returns an empty array when no requests are queued', () => {
+    const s = store();
+    expect(s.listPendingVhosts()).toEqual([]);
+  });
+
+  it('listPendingVhosts enumerates every queued request', () => {
+    const s = store();
+    s.requestVhost('alice', 'a.example.net');
+    s.requestVhost('bob', 'b.example.net');
+    const list = s.listPendingVhosts();
+    expect(list).toHaveLength(2);
+    expect(list).toContainEqual({ account: 'alice', vhost: 'a.example.net' });
+    expect(list).toContainEqual({ account: 'bob', vhost: 'b.example.net' });
+  });
+
+  it('approveVhost returns undefined when no pending request exists', () => {
+    const s = store();
+    expect(s.approveVhost('alice')).toBeUndefined();
+  });
+
+  it('approveVhost activates the pending vhost and returns the activated value', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    expect(s.approveVhost('alice')).toBe('cool.example.net');
+    expect(s.getVhost('alice')).toBe('cool.example.net');
+  });
+
+  it('approveVhost removes the pending request after activation', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    s.approveVhost('alice');
+    expect(s.getPendingVhost('alice')).toBeUndefined();
+    expect(s.listPendingVhosts()).toEqual([]);
+  });
+
+  it('rejectVhost returns undefined when no pending request exists', () => {
+    const s = store();
+    expect(s.rejectVhost('alice')).toBeUndefined();
+  });
+
+  it('rejectVhost drops the pending request and returns the rejected value', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    expect(s.rejectVhost('alice')).toBe('cool.example.net');
+    expect(s.getPendingVhost('alice')).toBeUndefined();
+  });
+
+  it('rejectVhost does NOT activate the vhost', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    s.rejectVhost('alice');
+    expect(s.getVhost('alice')).toBeUndefined();
+  });
+
+  it('rejectVhost removes the pending request', () => {
+    const s = store();
+    s.requestVhost('alice', 'cool.example.net');
+    s.rejectVhost('alice');
+    expect(s.listPendingVhosts()).toEqual([]);
+  });
+
+  it('folds the account name case-insensitively on approve', () => {
+    const s = store();
+    s.requestVhost('Alice', 'cool.example.net');
+    expect(s.approveVhost('ALICE')).toBe('cool.example.net');
+    expect(s.getVhost('alice')).toBe('cool.example.net');
+  });
+
+  it('folds the account name case-insensitively on reject', () => {
+    const s = store();
+    s.requestVhost('Alice', 'cool.example.net');
+    expect(s.rejectVhost('ALICE')).toBe('cool.example.net');
+    expect(s.getPendingVhost('alice')).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// MemoServ
+// ============================================================================
+
+const MEMO: MemoInput = {
+  from: 'bob',
+  to: 'alice',
+  body: 'Hi there',
+  sentAt: NOW,
+};
+
+describe('InMemoryServicesStore — MemoServ SEND (recordMemo)', () => {
+  it('returns a fresh monotonic id for each recorded memo', () => {
+    const s = store();
+    const id1 = s.recordMemo(MEMO);
+    const id2 = s.recordMemo({ ...MEMO, body: 'second' });
+    expect(id2).toBeGreaterThan(id1);
+  });
+
+  it('starts the id counter at 1', () => {
+    const s = store();
+    expect(s.recordMemo(MEMO)).toBe(1);
+  });
+
+  it('stores the memo with read:false observable via listMemos', () => {
+    const s = store();
+    s.recordMemo(MEMO);
+    const list = s.listMemos('alice');
+    expect(list).toHaveLength(1);
+    expect(list[0]).toEqual<MemoEntry>({
+      id: 1,
+      from: 'bob',
+      to: 'alice',
+      body: 'Hi there',
+      sentAt: NOW,
+      read: false,
+    });
+  });
+});
+
+describe('InMemoryServicesStore — MemoServ LIST (listMemos)', () => {
+  it('returns an empty array for an unknown recipient', () => {
+    const s = store();
+    expect(s.listMemos('alice')).toEqual([]);
+  });
+
+  it('returns only the memos addressed to the given recipient account', () => {
+    const s = store();
+    s.recordMemo({ from: 'bob', to: 'alice', body: 'for alice', sentAt: NOW });
+    s.recordMemo({ from: 'carol', to: 'dave', body: 'for dave', sentAt: NOW });
+    s.recordMemo({ from: 'eve', to: 'alice', body: 'also for alice', sentAt: NOW });
+    const list = s.listMemos('alice');
+    expect(list).toHaveLength(2);
+    expect(list.map((m) => m.body)).toEqual(['for alice', 'also for alice']);
+  });
+
+  it('folds the recipient account case-insensitively', () => {
+    const s = store();
+    s.recordMemo({ from: 'bob', to: 'Alice', body: 'x', sentAt: NOW });
+    expect(s.listMemos('alice')).toHaveLength(1);
+    expect(s.listMemos('ALICE')).toHaveLength(1);
+  });
+
+  it('returns a snapshot that does not mutate when the store updates', () => {
+    const s = store();
+    s.recordMemo(MEMO);
+    const snapshot = s.listMemos('alice');
+    s.recordMemo({ ...MEMO, body: 'second' });
+    expect(snapshot).toHaveLength(1);
+  });
+});
+
+describe('InMemoryServicesStore — MemoServ READ (markMemoRead)', () => {
+  it('returns true and marks the memo read for a known (recipient, id)', () => {
+    const s = store();
+    const id = s.recordMemo(MEMO);
+    expect(s.markMemoRead('alice', id)).toBe(true);
+    expect(s.listMemos('alice')[0]?.read).toBe(true);
+  });
+
+  it('returns false for an unknown memo id', () => {
+    const s = store();
+    s.recordMemo(MEMO);
+    expect(s.markMemoRead('alice', 999)).toBe(false);
+  });
+
+  it('returns false when the memo exists but belongs to another recipient', () => {
+    const s = store();
+    const id = s.recordMemo({ from: 'bob', to: 'alice', body: 'x', sentAt: NOW });
+    expect(s.markMemoRead('dave', id)).toBe(false);
+    expect(s.listMemos('alice')[0]?.read).toBe(false);
+  });
+
+  it('folds the recipient case-insensitively on a hit', () => {
+    const s = store();
+    const id = s.recordMemo({ from: 'bob', to: 'Alice', body: 'x', sentAt: NOW });
+    expect(s.markMemoRead('alice', id)).toBe(true);
+  });
+
+  it('is idempotent: re-marking a read memo returns true', () => {
+    const s = store();
+    const id = s.recordMemo(MEMO);
+    s.markMemoRead('alice', id);
+    expect(s.markMemoRead('alice', id)).toBe(true);
+  });
+});
+
+describe('InMemoryServicesStore — MemoServ DEL (deleteMemo)', () => {
+  it('returns true and removes the memo for a known (recipient, id)', () => {
+    const s = store();
+    const id = s.recordMemo(MEMO);
+    expect(s.deleteMemo('alice', id)).toBe(true);
+    expect(s.listMemos('alice')).toEqual([]);
+  });
+
+  it('returns false for an unknown memo id', () => {
+    const s = store();
+    s.recordMemo(MEMO);
+    expect(s.deleteMemo('alice', 999)).toBe(false);
+  });
+
+  it('returns false when the memo exists but belongs to another recipient', () => {
+    const s = store();
+    const id = s.recordMemo({ from: 'bob', to: 'alice', body: 'x', sentAt: NOW });
+    expect(s.deleteMemo('dave', id)).toBe(false);
+    expect(s.listMemos('alice')).toHaveLength(1);
+  });
+
+  it('only removes the targeted memo, leaving the rest intact', () => {
+    const s = store();
+    const id1 = s.recordMemo({ from: 'bob', to: 'alice', body: 'one', sentAt: NOW });
+    const id2 = s.recordMemo({ from: 'bob', to: 'alice', body: 'two', sentAt: NOW });
+    expect(s.deleteMemo('alice', id1)).toBe(true);
+    const remaining = s.listMemos('alice');
+    expect(remaining).toHaveLength(1);
+    expect(remaining[0]?.id).toBe(id2);
+  });
+
+  it('folds the recipient case-insensitively on a hit', () => {
+    const s = store();
+    const id = s.recordMemo({ from: 'bob', to: 'Alice', body: 'x', sentAt: NOW });
+    expect(s.deleteMemo('alice', id)).toBe(true);
+    expect(s.listMemos('alice')).toEqual([]);
+  });
+
+  it('is safe to call on an account with no memos', () => {
+    const s = store();
+    expect(s.deleteMemo('alice', 1)).toBe(false);
+  });
+});
+
+// ============================================================================
+// Read-marker persistence (draft/read-marker)
+// ============================================================================
+
+describe('InMemoryServicesStore — read-marker setLastReadMarker + getLastReadMarker', () => {
+  it('returns undefined for an unknown (account, channel) pair', () => {
+    const s = store();
+    expect(s.getLastReadMarker('alice', '#foo')).toBeUndefined();
+  });
+
+  it('stores and returns the msgid for a known (account, channel) pair', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    expect(s.getLastReadMarker('alice', '#foo')).toBe('m1');
+  });
+
+  it('overwrites the marker on a subsequent set for the same pair', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    s.setLastReadMarker('alice', '#foo', 'm2');
+    expect(s.getLastReadMarker('alice', '#foo')).toBe('m2');
+  });
+
+  it('keys channels case-insensitively (rfc1459 fold)', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#Foo', 'm1');
+    expect(s.getLastReadMarker('alice', '#foo')).toBe('m1');
+    expect(s.getLastReadMarker('alice', '#FOO')).toBe('m1');
+  });
+
+  it('keys accounts case-insensitively (rfc1459 fold)', () => {
+    const s = store();
+    s.setLastReadMarker('Alice', '#foo', 'm1');
+    expect(s.getLastReadMarker('alice', '#foo')).toBe('m1');
+    expect(s.getLastReadMarker('ALICE', '#foo')).toBe('m1');
+  });
+
+  it('keeps markers for distinct accounts on the same channel separate', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    s.setLastReadMarker('bob', '#foo', 'm9');
+    expect(s.getLastReadMarker('alice', '#foo')).toBe('m1');
+    expect(s.getLastReadMarker('bob', '#foo')).toBe('m9');
+  });
+
+  it('keeps markers for distinct channels on the same account separate', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    s.setLastReadMarker('alice', '#bar', 'm2');
+    expect(s.getLastReadMarker('alice', '#foo')).toBe('m1');
+    expect(s.getLastReadMarker('alice', '#bar')).toBe('m2');
+  });
+});
+
+describe('InMemoryServicesStore — read-marker listReadMarkers', () => {
+  it('returns an empty array for an account with no markers', () => {
+    const s = store();
+    expect(s.listReadMarkers('alice')).toEqual([]);
+  });
+
+  it('returns every (channel, msgid) pair recorded for the account', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    s.setLastReadMarker('alice', '#bar', 'm2');
+
+    const entries = s.listReadMarkers('alice');
+    expect(entries).toHaveLength(2);
+    const byChan = Object.fromEntries(entries.map((e) => [e.channel, e.msgid]));
+    expect(byChan['#foo']).toBe('m1');
+    expect(byChan['#bar']).toBe('m2');
+  });
+
+  it('reports the account name on each entry', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    const entries = s.listReadMarkers('alice');
+    expect(entries[0]?.account).toBe('alice');
+  });
+
+  it('reflects the most recent set when a pair is overwritten', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    s.setLastReadMarker('alice', '#foo', 'm2');
+    const entries = s.listReadMarkers('alice');
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.msgid).toBe('m2');
+  });
+
+  it('does not leak markers belonging to a different account', () => {
+    const s = store();
+    s.setLastReadMarker('alice', '#foo', 'm1');
+    s.setLastReadMarker('bob', '#bar', 'm2');
+    expect(s.listReadMarkers('alice')).toHaveLength(1);
+    expect(s.listReadMarkers('bob')).toHaveLength(1);
+  });
+
+  it('folds the account name case-insensitively on lookup', () => {
+    const s = store();
+    s.setLastReadMarker('Alice', '#foo', 'm1');
+    const entries = s.listReadMarkers('ALICE') as ReadonlyArray<ReadMarkerEntry>;
+    expect(entries).toHaveLength(1);
+  });
+});
+
+// ============================================================================
+// OperServ — AKILL (network-wide ban)
+// ============================================================================
+
+describe('InMemoryServicesStore — OperServ AKILL addAkill + listAkills', () => {
+  it('returns an empty list before any AKILL is added', () => {
+    const s = store();
+    expect(s.listAkills()).toEqual([]);
+  });
+
+  it('records an AKILL with the supplied mask and reason', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    const entries = s.listAkills();
+    expect(entries).toHaveLength(1);
+    expect(entries[0]).toMatchObject({ mask: '*!*@bad.example.net', reason: 'flooding' });
+  });
+
+  it('stamps a createdAt timestamp from the injected clock', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    expect(s.listAkills()[0]?.createdAt).toBe(NOW);
+  });
+
+  it('replaces the reason when the same mask is added twice', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    s.addAkill('*!*@bad.example.net', 'worse flooding');
+    const entries = s.listAkills();
+    expect(entries).toHaveLength(1);
+    expect(entries[0]?.reason).toBe('worse flooding');
+  });
+
+  it('preserves insertion order across multiple distinct masks', () => {
+    const s = store();
+    s.addAkill('*!*@a.example', 'one');
+    s.addAkill('*!*@b.example', 'two');
+    s.addAkill('*!*@c.example', 'three');
+    const masks = s.listAkills().map((e) => e.mask);
+    expect(masks).toEqual(['*!*@a.example', '*!*@b.example', '*!*@c.example']);
+  });
+
+  it('accepts an empty reason (verifies the no-default-reason contract)', () => {
+    const s = store();
+    s.addAkill('*!*@quiet.example', '');
+    expect(s.listAkills()[0]?.reason).toBe('');
+  });
+});
+
+describe('InMemoryServicesStore — OperServ AKILL removeAkill', () => {
+  it('returns true and drops the entry on a known mask', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    expect(s.removeAkill('*!*@bad.example.net')).toBe(true);
+    expect(s.listAkills()).toEqual([]);
+  });
+
+  it('matches the mask case-insensitively (rfc1459 fold)', () => {
+    const s = store();
+    s.addAkill('*!*@Bad.Example.Net', 'flooding');
+    expect(s.removeAkill('*!*@bad.example.net')).toBe(true);
+  });
+
+  it('returns false for an unknown mask without mutating state', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    expect(s.removeAkill('*!*@other.example.net')).toBe(false);
+    expect(s.listAkills()).toHaveLength(1);
+  });
+
+  it('returns false on an empty store', () => {
+    const s = store();
+    expect(s.removeAkill('*!*@anywhere.example')).toBe(false);
+  });
+});
+
+describe('InMemoryServicesStore — OperServ AKILL matchAkill', () => {
+  it('returns undefined when no AKILL is recorded', () => {
+    const s = store();
+    expect(s.matchAkill('evil!spammer@bad.example.net')).toBeUndefined();
+  });
+
+  it('returns the first matching entry for a hostmask that fits the mask', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    const hit = s.matchAkill('evil!spammer@bad.example.net');
+    expect(hit).toBeDefined();
+    expect(hit?.mask).toBe('*!*@bad.example.net');
+    expect(hit?.reason).toBe('flooding');
+  });
+
+  it('returns undefined when no mask matches the hostmask', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    expect(s.matchAkill('alice!alice@good.example.net')).toBeUndefined();
+  });
+
+  it('returns the first matching entry in insertion order', () => {
+    const s = store();
+    s.addAkill('*!*@a.example', 'first');
+    s.addAkill('*!*@b.example', 'second');
+    const hit = s.matchAkill('evil!spam@a.example');
+    expect(hit?.reason).toBe('first');
+  });
+
+  it('honours wildcards in the nick fragment of the mask', () => {
+    const s = store();
+    s.addAkill('bot*!*@*', 'bot flood');
+    expect(s.matchAkill('botnet!x@y.example')?.reason).toBe('bot flood');
+    expect(s.matchAkill('alice!x@y.example')).toBeUndefined();
+  });
+
+  it('honours ? wildcard as a single-char matcher', () => {
+    const s = store();
+    s.addAkill('a?c!*@*', 'mid match');
+    expect(s.matchAkill('abc!x@y.example')?.reason).toBe('mid match');
+  });
+
+  it('returns a defensive copy so callers cannot mutate the stored record', () => {
+    const s = store();
+    s.addAkill('*!*@bad.example.net', 'flooding');
+    const hit = s.matchAkill('evil!spammer@bad.example.net');
+    if (hit === undefined) return;
+    hit.reason = 'mutated';
+    expect(s.listAkills()[0]?.reason).toBe('flooding');
+  });
+});
+
+// ============================================================================
+// OperServ — JUPE (blocked nick/server)
+// ============================================================================
+
+describe('InMemoryServicesStore — OperServ JUPE addJupe + isJuped', () => {
+  it('reports not-juped on a fresh store', () => {
+    const s = store();
+    expect(s.isJuped('moo')).toBe(false);
+  });
+
+  it('records a jupe and reports it as juped', () => {
+    const s = store();
+    s.addJupe('moo', 'blocked');
+    expect(s.isJuped('moo')).toBe(true);
+  });
+
+  it('matches the juped name case-insensitively (rfc1459 fold)', () => {
+    const s = store();
+    s.addJupe('Moo', 'blocked');
+    expect(s.isJuped('moo')).toBe(true);
+    expect(s.isJuped('MOO')).toBe(true);
+  });
+
+  it('accepts an undefined reason (records an empty string)', () => {
+    const s = store();
+    s.addJupe('moo');
+    expect(s.getJupe('moo')?.reason).toBe('');
+  });
+
+  it('clears the reason when an existing jupe is re-added without a reason', () => {
+    const s = store();
+    s.addJupe('moo', 'blocked');
+    s.addJupe('moo');
+    expect(s.getJupe('moo')?.reason).toBe('');
+  });
+});
+
+describe('InMemoryServicesStore — OperServ JUPE removeJupe', () => {
+  it('returns true and clears the jupe on a known name', () => {
+    const s = store();
+    s.addJupe('moo', 'blocked');
+    expect(s.removeJupe('moo')).toBe(true);
+    expect(s.isJuped('moo')).toBe(false);
+  });
+
+  it('matches the name case-insensitively (rfc1459 fold)', () => {
+    const s = store();
+    s.addJupe('Moo', 'blocked');
+    expect(s.removeJupe('moo')).toBe(true);
+  });
+
+  it('returns false for an unknown name without mutating state', () => {
+    const s = store();
+    s.addJupe('moo', 'blocked');
+    expect(s.removeJupe('other')).toBe(false);
+    expect(s.isJuped('moo')).toBe(true);
+  });
+});
+
+describe('InMemoryServicesStore — OperServ JUPE getJupe', () => {
+  it('returns undefined for a name with no jupe', () => {
+    const s = store();
+    expect(s.getJupe('moo')).toBeUndefined();
+  });
+
+  it('returns the recorded reason and createdAt timestamp', () => {
+    const s = store();
+    s.addJupe('moo', 'blocked');
+    const entry = s.getJupe('moo');
+    expect(entry).toBeDefined();
+    expect(entry?.reason).toBe('blocked');
+    expect(entry?.createdAt).toBe(NOW);
+  });
+
+  it('returns a defensive copy so callers cannot mutate the stored record', () => {
+    const s = store();
+    s.addJupe('moo', 'blocked');
+    const entry = s.getJupe('moo');
+    if (entry === undefined) return;
+    entry.reason = 'mutated';
+    expect(s.getJupe('moo')?.reason).toBe('blocked');
+  });
+});
+
+describe('InMemoryServicesStore — OperServ JUPE listJupes', () => {
+  it('returns an empty array on a fresh store', () => {
+    const s = store();
+    expect(s.listJupes()).toEqual([]);
+  });
+
+  it('enumerates every recorded jupe in insertion order', () => {
+    const s = store();
+    s.addJupe('moo', 'one');
+    s.addJupe('bar', 'two');
+    const names = (s.listJupes() as ReadonlyArray<JupeEntry>).map((e) => e.name);
+    expect(names).toEqual(['moo', 'bar']);
+  });
+});