serverless-ircd 0.7.0 → 0.9.0

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

@@ -528,3 +528,66 @@ describe('InMemoryMessageStore — query defensive branches', () => {
     ).toEqual([]);
   });
 });
+
+// ============================================================================
+// findAtOrBefore / getMsg — timestamp<->msgid translation for draft/read-marker
+// MARKREAD support. findAtOrBefore resolves a client-supplied server-time
+// timestamp to the most recent retained message at or before it; getMsg
+// resolves a stored marker msgid back to its message (for the echo + the
+// monotonicity check).
+// ============================================================================
+describe('InMemoryMessageStore — findAtOrBefore (timestamp -> message)', () => {
+  it('returns the message whose time equals the timestamp exactly', () => {
+    const store = seededStore(); // m1..m5 at 1_000..5_000
+    expect(store.findAtOrBefore('#foo', 3_000)?.msgid).toBe('m3');
+  });
+
+  it('returns the most recent message at or before an in-between timestamp', () => {
+    const store = seededStore();
+    // 3_500 is between m3 (3_000) and m4 (4_000); the marker resolves to m3.
+    expect(store.findAtOrBefore('#foo', 3_500)?.msgid).toBe('m3');
+  });
+
+  it('returns the newest message when the timestamp is at/after the last', () => {
+    const store = seededStore();
+    expect(store.findAtOrBefore('#foo', 9_999)?.msgid).toBe('m5');
+  });
+
+  it('returns undefined when the timestamp predates every retained message', () => {
+    const store = seededStore();
+    expect(store.findAtOrBefore('#foo', 500)).toBeUndefined();
+  });
+
+  it('returns undefined for a channel with no retained messages', () => {
+    const store = new InMemoryMessageStore();
+    expect(store.findAtOrBefore('#ghost', 1_000)).toBeUndefined();
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const store = seededStore();
+    expect(store.findAtOrBefore('#FOO', 2_000)?.msgid).toBe('m2');
+  });
+});
+
+describe('InMemoryMessageStore — getMsg (msgid -> message)', () => {
+  it('returns the message for a retained msgid', () => {
+    const store = seededStore();
+    expect(store.getMsg('#foo', 'm3')?.text).toBe('three');
+  });
+
+  it('returns undefined for an unknown msgid', () => {
+    const store = seededStore();
+    expect(store.getMsg('#foo', 'ghost')).toBeUndefined();
+  });
+
+  it('returns undefined for an evicted (no-longer-retained) msgid', () => {
+    const store = seededStore(3); // keeps m3..m5, evicts m1..m2
+    expect(store.getMsg('#foo', 'm1')).toBeUndefined();
+    expect(store.getMsg('#foo', 'm4')?.msgid).toBe('m4');
+  });
+
+  it('folds the channel name case-insensitively', () => {
+    const store = seededStore();
+    expect(store.getMsg('#FoO', 'm2')?.msgid).toBe('m2');
+  });
+});

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

@@ -0,0 +1,582 @@
+/**
+ * `PersistentServicesStore` — the shared write-behind base class used by the
+ * D1 (Cloudflare) and DynamoDB (AWS) backends.
+ *
+ * The services port is synchronous (reducers stay free of IO); persistent
+ * adapters pre-load a snapshot into the in-memory cache and enqueue
+ * write-behind ops on every mutation. This suite verifies the enqueue /
+ * flush contract and the snapshot hydration round-trip using a recording
+ * fake backend — no real database is touched.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { hashAccountCredential } from '../src/credential-hashing';
+import {
+  FakeClock,
+  InMemoryServicesStore,
+  type MemoInput,
+  PersistentServicesStore,
+  type ServicesNickRow,
+  type ServicesSnapshot,
+  type ServicesWrite,
+} from '../src/ports';
+
+const NOW = 1_700_000_000_000;
+
+/**
+ * Concrete recording subclass: collects every flushed batch in order so the
+ * tests can assert which ops each mutator produced.
+ */
+class RecordingStore extends PersistentServicesStore {
+  readonly batches: ServicesWrite[][] = [];
+  protected async applyWrites(writes: ServicesWrite[]): Promise<void> {
+    this.batches.push(writes);
+  }
+  /** Test-only exposure of the protected helper so its `undefined` branch is covered. */
+  peekStoredNick(nick: string): ServicesNickRow | undefined {
+    return this.getStoredNick(nick);
+  }
+}
+
+function recordingStore(): RecordingStore {
+  return new RecordingStore({ clock: new FakeClock(NOW) });
+}
+
+// ============================================================================
+// Snapshot hydration
+// ============================================================================
+
+describe('PersistentServicesStore — snapshot hydration', () => {
+  it('hydrates from an empty snapshot into an empty store', () => {
+    const s = new InMemoryServicesStore({ clock: new FakeClock(NOW), snapshot: emptySnapshot() });
+    expect(s.listAkills()).toEqual([]);
+    expect(s.listMemos('alice')).toEqual([]);
+  });
+
+  it('round-trips a full snapshot through a peer InMemoryServicesStore', () => {
+    const original = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    original.registerNick('alice', 'pw', 'a@example.com');
+    original.setNickEnforce('alice', 'ghost');
+    original.registerChannel('#chan', 'alice');
+    original.setChannelAccess('#chan', 'bob', 5);
+    original.setChannelLevel('#chan', 'AUTOOP', 10);
+    original.setVhost('alice', 'hidden.example');
+    original.requestVhost('bob', 'pending.example');
+    original.recordMemo({ from: 'bob', to: 'alice', body: 'hi', sentAt: NOW });
+    original.setLastReadMarker('alice', '#chan', 'msgid-1');
+    original.addAkill('*!*@bad.example', 'flooding');
+    original.addJupe('jupedNick', 'reason');
+
+    const snap = original.snapshot();
+    const reloaded = new InMemoryServicesStore({ clock: new FakeClock(NOW), snapshot: snap });
+
+    // NickServ
+    expect(reloaded.isRegisteredNick('Alice')).toBe(true);
+    expect(reloaded.getNickEnforce('alice')).toBe('ghost');
+    expect(reloaded.verifyNick('alice', 'pw')).toEqual({ ok: true, account: 'alice' });
+    // ChanServ
+    expect(reloaded.getChannelFounder('#chan')).toBe('alice');
+    expect(reloaded.getChannelAccess('#chan', 'bob')).toBe(5);
+    expect(reloaded.getChannelLevel('#chan', 'AUTOOP')).toBe(10);
+    // HostServ
+    expect(reloaded.getVhost('alice')).toBe('hidden.example');
+    expect(reloaded.getPendingVhost('bob')).toBe('pending.example');
+    // MemoServ — id preserved across reload
+    const memos = reloaded.listMemos('alice');
+    expect(memos).toHaveLength(1);
+    expect(memos[0]).toMatchObject({ id: 1, from: 'bob', body: 'hi' });
+    // Next memo id continues after the reloaded max.
+    expect(reloaded.recordMemo({ from: 'x', to: 'alice', body: 'y', sentAt: NOW })).toBe(2);
+    // Read marker
+    expect(reloaded.getLastReadMarker('alice', '#chan')).toBe('msgid-1');
+    // OperServ
+    expect(reloaded.matchAkill('user!~u@bad.example')?.reason).toBe('flooding');
+    expect(reloaded.isJuped('JupedNick')).toBe(true);
+  });
+
+  it('snapshot omits topic for a channel that never had KEEPTOPIC set', () => {
+    const s = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    s.registerChannel('#notopic', 'alice');
+    const snap = s.snapshot();
+    expect(snap.channels).toHaveLength(1);
+    expect(snap.channels[0]?.topic).toBeUndefined();
+    // Hydrating a no-topic channel round-trips (covers the hydrate false branch).
+    const reloaded = new InMemoryServicesStore({ clock: new FakeClock(NOW), snapshot: snap });
+    expect(reloaded.getChannel('#notopic')?.topic).toBeUndefined();
+    expect(reloaded.getChannelFounder('#notopic')).toBe('alice');
+  });
+
+  it('hydrate reuses existing maps for multi-entry groups + round-trips a topic', () => {
+    // A snapshot with multiple entries per channel / account exercises every
+    // "map already exists, reuse it" branch in hydrate (access, levels,
+    // memos, readMarkers) plus the topic-present branch in snapshot+hydrate.
+    const original = new InMemoryServicesStore({ clock: new FakeClock(NOW) });
+    original.registerChannel('#chan', 'alice');
+    original.setChannelKeepTopic('#chan', true);
+    original.setChannelTopic('#chan', { text: 't', setter: 'alice', setAt: NOW });
+    original.setChannelAccess('#chan', 'bob', 5);
+    original.setChannelAccess('#chan', 'carol', 3); // second entry → reuse map
+    original.setChannelLevel('#chan', 'AUTOOP', 10);
+    original.setChannelLevel('#chan', 'AUTOVOICE', 1); // second entry → reuse map
+    original.recordMemo({ from: 'x', to: 'alice', body: 'm1', sentAt: NOW });
+    original.recordMemo({ from: 'y', to: 'alice', body: 'm2', sentAt: NOW }); // second → reuse arr
+    original.setLastReadMarker('alice', '#chan', 'a');
+    original.setLastReadMarker('alice', '#other', 'b'); // second → reuse chanMap
+
+    const snap = original.snapshot();
+    const reloaded = new InMemoryServicesStore({ clock: new FakeClock(NOW), snapshot: snap });
+    expect(reloaded.getChannelTopic('#chan')?.text).toBe('t');
+    expect(reloaded.getChannelAccess('#chan', 'carol')).toBe(3);
+    expect(reloaded.getChannelLevel('#chan', 'AUTOVOICE')).toBe(1);
+    expect(reloaded.listMemos('alice')).toHaveLength(2);
+    expect(reloaded.getLastReadMarker('alice', '#other')).toBe('b');
+  });
+
+  it('hydrate handles non-monotonic memo ids (counter max is idempotent)', () => {
+    // A snapshot whose memos are out of order exercises the
+    // `memo.id > memoCounter === false` branch in hydrate.
+    const snap: ServicesSnapshot = {
+      nicks: [],
+      channels: [],
+      access: [],
+      levels: [],
+      vhosts: [],
+      pendingVhosts: [],
+      memos: [
+        { id: 5, from: 'x', to: 'alice', body: 'big', sentAt: NOW, read: false },
+        { id: 2, from: 'y', to: 'alice', body: 'small', sentAt: NOW, read: false },
+      ],
+      readMarkers: [],
+      akills: [],
+      jupes: [],
+    };
+    const s = new InMemoryServicesStore({ clock: new FakeClock(NOW), snapshot: snap });
+    expect(s.listMemos('alice')).toHaveLength(2);
+    // Counter resumes after the max id (5), not the last-seen.
+    expect(s.recordMemo({ from: 'z', to: 'alice', body: 'next', sentAt: NOW })).toBe(6);
+  });
+
+  it('getStoredNick returns undefined for an unregistered nick', () => {
+    const s = recordingStore();
+    expect(s.peekStoredNick('ghost')).toBeUndefined();
+    s.registerNick('alice', 'pw', 'a@x');
+    // The credential is hashed scrypt; the plaintext password is not stored.
+    const stored = s.peekStoredNick('alice');
+    expect(stored).toBeDefined();
+    expect(stored?.credential.algorithm).toBe('scrypt');
+    expect(stored?.credential.account).toBe('alice');
+    expect((stored as unknown as Record<string, unknown>).password).toBeUndefined();
+  });
+});
+
+// ============================================================================
+// Write-behind enqueue / flush
+// ============================================================================
+
+describe('PersistentServicesStore — enqueue + flush', () => {
+  it('flush is a no-op when no mutations occurred', async () => {
+    const s = recordingStore();
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('enqueues a single batch covering many mutations and drains it on flush', async () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'pw', 'a@example.com');
+    s.registerChannel('#chan', 'alice');
+    s.addAkill('*!*@bad', 'reason');
+    await s.flush();
+    expect(s.batches).toHaveLength(1);
+    const ops = s.batches[0]?.map((w) => w.kind) ?? [];
+    expect(ops).toContain('upsertNick');
+    expect(ops).toContain('upsertChannel');
+    expect(ops).toContain('upsertAkill');
+    // Queue is drained after flush.
+    await s.flush();
+    expect(s.batches).toHaveLength(1);
+  });
+
+  it('coalesces concurrent flush calls into a single applyWrites invocation', async () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'pw', 'a@x');
+    const [a, b] = await Promise.all([s.flush(), s.flush()]);
+    expect(a).toBe(b);
+    expect(s.batches).toHaveLength(1);
+  });
+});
+
+// ============================================================================
+// Per-mutator op coverage
+// ============================================================================
+
+describe('PersistentServicesStore — per-mutator ops', () => {
+  function ops(s: RecordingStore): ServicesWrite[] {
+    return s.batches.flat();
+  }
+
+  it('registerNick → upsertNick (with hashed credential + createdAt)', async () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'hunter2', 'a@x');
+    await s.flush();
+    const op = ops(s).find((w) => w.kind === 'upsertNick');
+    expect(op).toBeDefined();
+    if (op?.kind === 'upsertNick') {
+      expect(op.row).toMatchObject({ nick: 'alice', email: 'a@x' });
+      expect(op.row.createdAt).toBe(NOW);
+      // The credential is scrypt-hashed; the plaintext is not on the row.
+      expect(op.row.credential.algorithm).toBe('scrypt');
+      expect(op.row.credential.account).toBe('alice');
+      expect((op.row as unknown as Record<string, unknown>).password).toBeUndefined();
+      expect(JSON.stringify(op.row)).not.toContain('hunter2');
+    }
+  });
+
+  it('a duplicate registerNick enqueues nothing', async () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'pw', 'a@x');
+    s.registerNick('alice', 'pw', 'a@x'); // rejected
+    await s.flush();
+    expect(ops(s).filter((w) => w.kind === 'upsertNick')).toHaveLength(1);
+  });
+
+  it('dropNick → deleteNick only when something was removed', async () => {
+    const s = recordingStore();
+    s.dropNick('ghost'); // nothing to remove
+    s.registerNick('alice', 'pw', 'a@x');
+    s.dropNick('alice');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'deleteNick')).toBe(true);
+  });
+
+  it('setNickEnforce → upsertNick (full row re-persisted)', async () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'pw', 'a@x');
+    s.setNickEnforce('alice', 'kill');
+    await s.flush();
+    const upserts = ops(s).filter((w) => w.kind === 'upsertNick');
+    const last = upserts[upserts.length - 1];
+    if (last?.kind === 'upsertNick') expect(last.row.enforce).toBe('kill');
+  });
+
+  it('setNickEnforce on an unregistered nick enqueues nothing', async () => {
+    const s = recordingStore();
+    s.setNickEnforce('ghost', 'kill');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('ingestAccountCredential enqueues upsertNick when a new credential is adopted', async () => {
+    const s = recordingStore();
+    const cred = hashAccountCredential('alice', 'hunter2');
+    s.ingestAccountCredential(cred);
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertNick')).toBe(true);
+    const op = ops(s).find((w) => w.kind === 'upsertNick');
+    if (op?.kind === 'upsertNick') {
+      expect(op.row.account).toBe('alice');
+      expect(op.row.credential.algorithm).toBe('scrypt');
+    }
+  });
+
+  it('ingestAccountCredential enqueues nothing when the nick is already registered', async () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'pw', 'a@x');
+    const cred = hashAccountCredential('alice', 'otherpw');
+    s.ingestAccountCredential(cred);
+    await s.flush();
+    expect(ops(s).filter((w) => w.kind === 'upsertNick')).toHaveLength(1);
+  });
+
+  it('registerChannel → upsertChannel; duplicate enqueues once', async () => {
+    const s = recordingStore();
+    s.registerChannel('#chan', 'alice');
+    s.registerChannel('#chan', 'alice');
+    await s.flush();
+    expect(ops(s).filter((w) => w.kind === 'upsertChannel')).toHaveLength(1);
+  });
+
+  it('dropChannel → deleteChannel (clears access + levels remotely)', async () => {
+    const s = recordingStore();
+    s.registerChannel('#chan', 'alice');
+    s.setChannelAccess('#chan', 'bob', 5);
+    s.setChannelLevel('#chan', 'AUTOOP', 3);
+    s.dropChannel('#chan');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'deleteChannel')).toBe(true);
+  });
+
+  it('dropChannel on an unregistered channel enqueues nothing', async () => {
+    const s = recordingStore();
+    s.dropChannel('#ghost');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it.each([
+    'setChannelFounder',
+    'setChannelMlock',
+    'setChannelRestricted',
+    'setChannelKeepTopic',
+  ] as const)('%s → upsertChannel', async (method) => {
+    const s = recordingStore();
+    s.registerChannel('#chan', 'alice');
+    switch (method) {
+      case 'setChannelFounder':
+        s.setChannelFounder('#chan', 'bob');
+        break;
+      case 'setChannelMlock':
+        s.setChannelMlock('#chan', '+nrt');
+        break;
+      case 'setChannelRestricted':
+        s.setChannelRestricted('#chan', true);
+        break;
+      case 'setChannelKeepTopic':
+        s.setChannelKeepTopic('#chan', true);
+        break;
+    }
+    await s.flush();
+    const upserts = ops(s).filter((w) => w.kind === 'upsertChannel');
+    expect(upserts.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('setChannelAccess level>0 → upsertChannelAccess; level<=0 → deleteChannelAccess', async () => {
+    const s = recordingStore();
+    s.registerChannel('#chan', 'alice');
+    s.setChannelAccess('#chan', 'bob', 5);
+    s.setChannelAccess('#chan', 'bob', 0);
+    await s.flush();
+    const all = ops(s);
+    expect(all.some((w) => w.kind === 'upsertChannelAccess')).toBe(true);
+    expect(all.some((w) => w.kind === 'deleteChannelAccess')).toBe(true);
+  });
+
+  it('setChannelLevel → upsertChannelLevel; resetChannelLevels → resetChannelLevels', async () => {
+    const s = recordingStore();
+    s.registerChannel('#chan', 'alice');
+    s.setChannelLevel('#chan', 'AUTOOP', 7);
+    s.resetChannelLevels('#chan');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertChannelLevel')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'resetChannelLevels')).toBe(true);
+  });
+
+  it('setChannelTopic → upsertChannel (carrying the topic snapshot)', async () => {
+    const s = recordingStore();
+    s.registerChannel('#chan', 'alice');
+    s.setChannelKeepTopic('#chan', true);
+    s.setChannelTopic('#chan', { text: 'hello', setter: 'alice', setAt: NOW });
+    await s.flush();
+    const last = ops(s)
+      .filter((w) => w.kind === 'upsertChannel')
+      .pop();
+    if (last?.kind === 'upsertChannel') expect(last.row.topic?.text).toBe('hello');
+  });
+
+  it.each([
+    'setChannelFounder',
+    'setChannelMlock',
+    'setChannelRestricted',
+    'setChannelKeepTopic',
+    'setChannelTopic',
+  ] as const)('%s on an unregistered channel enqueues nothing', async (method) => {
+    const s = recordingStore();
+    switch (method) {
+      case 'setChannelFounder':
+        s.setChannelFounder('#ghost', 'bob');
+        break;
+      case 'setChannelMlock':
+        s.setChannelMlock('#ghost', '+nrt');
+        break;
+      case 'setChannelRestricted':
+        s.setChannelRestricted('#ghost', true);
+        break;
+      case 'setChannelKeepTopic':
+        s.setChannelKeepTopic('#ghost', true);
+        break;
+      case 'setChannelTopic':
+        s.setChannelTopic('#ghost', { text: 'x', setter: 'y', setAt: NOW });
+        break;
+    }
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('setChannelAccess level<=0 on a non-existent entry enqueues nothing', async () => {
+    const s = recordingStore();
+    s.setChannelAccess('#ghost', 'bob', 0);
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('setVhost non-empty → upsertVhost; empty → deleteVhost', async () => {
+    const s = recordingStore();
+    s.setVhost('alice', 'cloak.example');
+    s.setVhost('alice', '');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertVhost')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'deleteVhost')).toBe(true);
+  });
+
+  it('setVhost empty on an account with no prior vhost enqueues nothing', async () => {
+    const s = recordingStore();
+    s.setVhost('ghost', '');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('requestVhost → upsertPendingVhost', async () => {
+    const s = recordingStore();
+    s.requestVhost('alice', 'queued.example');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertPendingVhost')).toBe(true);
+    const op = ops(s).find((w) => w.kind === 'upsertPendingVhost');
+    if (op?.kind === 'upsertPendingVhost') {
+      expect(op.row).toEqual({ account: 'alice', vhost: 'queued.example' });
+    }
+  });
+
+  it('approveVhost → deletePendingVhost + upsertVhost (activation)', async () => {
+    const s = recordingStore();
+    s.requestVhost('alice', 'queued.example');
+    s.approveVhost('alice');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertPendingVhost')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'deletePendingVhost')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'upsertVhost')).toBe(true);
+    const upsert = ops(s)
+      .filter((w) => w.kind === 'upsertVhost')
+      .pop();
+    if (upsert?.kind === 'upsertVhost') {
+      expect(upsert.row).toEqual({ account: 'alice', vhost: 'queued.example' });
+    }
+  });
+
+  it('approveVhost on an unknown account enqueues nothing', async () => {
+    const s = recordingStore();
+    s.approveVhost('ghost');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('rejectVhost → deletePendingVhost only (no activation)', async () => {
+    const s = recordingStore();
+    s.requestVhost('alice', 'queued.example');
+    s.rejectVhost('alice');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertPendingVhost')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'deletePendingVhost')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'upsertVhost')).toBe(false);
+  });
+
+  it('rejectVhost on an unknown account enqueues nothing', async () => {
+    const s = recordingStore();
+    s.rejectVhost('ghost');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('snapshot round-trips pending vhost requests across a peer store', () => {
+    const s = recordingStore();
+    s.requestVhost('alice', 'one.example');
+    s.requestVhost('bob', 'two.example');
+    const snap = s.snapshot();
+    expect(snap.pendingVhosts).toContainEqual({ account: 'alice', vhost: 'one.example' });
+    expect(snap.pendingVhosts).toContainEqual({ account: 'bob', vhost: 'two.example' });
+    const reloaded = new InMemoryServicesStore({ clock: new FakeClock(NOW), snapshot: snap });
+    expect(reloaded.getPendingVhost('alice')).toBe('one.example');
+    expect(reloaded.getPendingVhost('bob')).toBe('two.example');
+    expect(reloaded.listPendingVhosts()).toHaveLength(2);
+  });
+
+  it('recordMemo → insertMemo with the assigned id', async () => {
+    const s = recordingStore();
+    const memo: MemoInput = { from: 'bob', to: 'alice', body: 'hi', sentAt: NOW };
+    const id = s.recordMemo(memo);
+    await s.flush();
+    const op = ops(s).find((w) => w.kind === 'insertMemo');
+    if (op?.kind === 'insertMemo') expect(op.row.id).toBe(id);
+  });
+
+  it('markMemoRead → updateMemoRead only when the memo existed', async () => {
+    const s = recordingStore();
+    s.markMemoRead('alice', 9); // no such memo
+    s.recordMemo({ from: 'bob', to: 'alice', body: 'hi', sentAt: NOW });
+    s.markMemoRead('alice', 1);
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'updateMemoRead')).toBe(true);
+  });
+
+  it('deleteMemo → deleteMemo only when something was deleted', async () => {
+    const s = recordingStore();
+    s.deleteMemo('alice', 9); // no such memo
+    s.recordMemo({ from: 'bob', to: 'alice', body: 'hi', sentAt: NOW });
+    s.deleteMemo('alice', 1);
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'deleteMemo')).toBe(true);
+  });
+
+  it('setLastReadMarker → upsertReadMarker', async () => {
+    const s = recordingStore();
+    s.setLastReadMarker('alice', '#chan', 'm1');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertReadMarker')).toBe(true);
+  });
+
+  it('addAkill → upsertAkill; removeAkill → deleteAkill', async () => {
+    const s = recordingStore();
+    s.addAkill('*!*@bad', 'reason');
+    s.removeAkill('*!*@bad');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertAkill')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'deleteAkill')).toBe(true);
+  });
+
+  it('removeAkill on an unknown mask enqueues nothing', async () => {
+    const s = recordingStore();
+    s.removeAkill('*!*@unknown');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('addJupe → upsertJupe; removeJupe → deleteJupe', async () => {
+    const s = recordingStore();
+    s.addJupe('bad', 'reason');
+    s.removeJupe('bad');
+    await s.flush();
+    expect(ops(s).some((w) => w.kind === 'upsertJupe')).toBe(true);
+    expect(ops(s).some((w) => w.kind === 'deleteJupe')).toBe(true);
+  });
+
+  it('removeJupe on an unknown name enqueues nothing', async () => {
+    const s = recordingStore();
+    s.removeJupe('unknown');
+    await s.flush();
+    expect(s.batches).toEqual([]);
+  });
+
+  it('mutated state is visible synchronously (before flush)', () => {
+    const s = recordingStore();
+    s.registerNick('alice', 'pw', 'a@x');
+    expect(s.isRegisteredNick('alice')).toBe(true);
+    expect(s.verifyNick('alice', 'pw')).toEqual({ ok: true, account: 'alice' });
+  });
+});
+
+// ============================================================================
+// helpers
+// ============================================================================
+
+function emptySnapshot(): ServicesSnapshot {
+  return {
+    nicks: [],
+    channels: [],
+    access: [],
+    levels: [],
+    vhosts: [],
+    pendingVhosts: [],
+    memos: [],
+    readMarkers: [],
+    akills: [],
+    jupes: [],
+  };
+}