serverless-ircd 0.7.0 → 0.8.0

package/packages/irc-server/tests/dispatch.test.ts

@@ -1,7 +1,7 @@
 import { Effect } from '@serverless-ircd/irc-core';
 import { CapturingLogger, LogLevel } from '@serverless-ircd/irc-core';
 import type { ChannelDelta, ConnId, RawLine } from '@serverless-ircd/irc-core';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { dispatch } from '../src/dispatch';
 import type { IrcRuntime } from '../src/runtime';
 
@@ -251,6 +251,12 @@ describe('dispatch', () => {
 
 interface MemberInfo {
   caps: ReadonlySet<string>;
+  /**
+   * Optional SASL/NickServ account the member is identified as. When set,
+   * the fake runtime's `getConnectionInfo` surfaces it so account-scoped
+   * broadcast filtering (draft/read-marker privacy) can be exercised.
+   */
+  account?: string;
 }
 
 /**
@@ -300,9 +306,11 @@ function capAwareRuntime(members: ReadonlyMap<ConnId, MemberInfo>): {
           wallops: false,
           serverNotices: false,
           tls: false,
+          registered: false,
         },
         lastSeen: 0,
         connectedSince: 0,
+        ...(info.account !== undefined ? { account: info.account } : {}),
       };
     },
     async getConnection() {
@@ -323,6 +331,9 @@ function capAwareRuntime(members: ReadonlyMap<ConnId, MemberInfo>): {
           moderated: false,
           secret: false,
           private: false,
+          registered: false,
+          blockUnidentified: false,
+          moderatedIdent: false,
         },
         banMasks: new Set<string>(),
         members: roster,
@@ -491,6 +502,7 @@ describe('dispatch — Broadcast cap / capLines', () => {
               wallops: false,
               serverNotices: false,
               tls: false,
+              registered: false,
             },
             lastSeen: 0,
             connectedSince: 0,
@@ -516,6 +528,9 @@ describe('dispatch — Broadcast cap / capLines', () => {
             moderated: false,
             secret: false,
             private: false,
+            registered: false,
+            blockUnidentified: false,
+            moderatedIdent: false,
           },
           banMasks: new Set<string>(),
           members: roster,
@@ -690,7 +705,183 @@ describe('dispatch — Broadcast caps (OR semantics)', () => {
 });
 
 // ===========================================================================
-// dispatch — Broadcast client-tag gating (message-tags)
+// dispatch — Broadcast account-scoped recipient filter (draft/read-marker)
+//
+// IRCv3 `draft/read-marker` privacy: a read marker is private to the
+// originator's account and MUST NOT be disclosed to other users. The reducer
+// annotates the mark TAGMSG Broadcast with `account`; dispatch restricts the
+// recipient set to channel members authenticated as that account (case-
+// insensitive), still honouring `except` and the OR-semantics `caps` filter.
+// Unidentified peers (no account) never receive a mark bound to an account.
+// ===========================================================================
+
+describe('dispatch — Broadcast account-scoped filter (draft/read-marker)', () => {
+  it('delivers ONLY to same-account members; cross-account members are excluded', async () => {
+    const members = memberMap([
+      ['c1', { caps: new Set(['message-tags']), account: 'alice' }], // originator (except)
+      ['c2', { caps: new Set(['message-tags']), account: 'alice' }], // same account
+      ['c3', { caps: new Set(['message-tags']), account: 'bob' }], // different account
+    ]);
+    const { runtime, sends, broadcasts } = capAwareRuntime(members);
+
+    await dispatch(
+      [
+        Effect.broadcast(
+          '#foo',
+          [L('@+draft/read-marker=m1 :a!u@h TAGMSG #foo')],
+          'c1',
+          undefined,
+          undefined,
+          ['message-tags', 'draft/read-marker'],
+          'alice',
+        ),
+      ],
+      runtime,
+    );
+
+    // No fast-path bulk broadcast: dispatch routes per-recipient.
+    expect(broadcasts).toHaveLength(0);
+    // Only c2 (same account) receives; c3 (different account) is excluded.
+    expect(sends.map((s) => s.to).sort()).toEqual(['c2']);
+  });
+
+  it('excludes unidentified members (no account) from an account-scoped mark', async () => {
+    const members = memberMap([
+      ['c1', { caps: new Set(['message-tags']), account: 'alice' }], // originator (except)
+      ['c2', { caps: new Set(['message-tags']) }], // unidentified
+    ]);
+    const { runtime, sends } = capAwareRuntime(members);
+
+    await dispatch(
+      [
+        Effect.broadcast(
+          '#foo',
+          [L('@+draft/read-marker=m1 :a!u@h TAGMSG #foo')],
+          'c1',
+          undefined,
+          undefined,
+          ['message-tags', 'draft/read-marker'],
+          'alice',
+        ),
+      ],
+      runtime,
+    );
+
+    expect(sends).toHaveLength(0);
+  });
+
+  it('matches the account case-insensitively (Alice vs alice)', async () => {
+    const members = memberMap([
+      ['c1', { caps: new Set(['message-tags']), account: 'alice' }], // originator (except)
+      ['c2', { caps: new Set(['message-tags']), account: 'ALICE' }], // same account, diff case
+    ]);
+    const { runtime, sends } = capAwareRuntime(members);
+
+    await dispatch(
+      [
+        Effect.broadcast(
+          '#foo',
+          [L('@+draft/read-marker=m1 :a!u@h TAGMSG #foo')],
+          'c1',
+          undefined,
+          undefined,
+          ['message-tags', 'draft/read-marker'],
+          'alice',
+        ),
+      ],
+      runtime,
+    );
+
+    expect(sends.map((s) => s.to)).toEqual(['c2']);
+  });
+
+  it('still applies the OR-caps filter alongside the account filter', async () => {
+    const members = memberMap([
+      ['c1', { caps: new Set(['message-tags']), account: 'alice' }], // originator (except)
+      // same account but no relevant cap — excluded by caps filter:
+      ['c2', { caps: new Set<string>(), account: 'alice' }],
+      // same account, draft/read-marker cap — delivered:
+      ['c3', { caps: new Set(['draft/read-marker']), account: 'alice' }],
+    ]);
+    const { runtime, sends } = capAwareRuntime(members);
+
+    await dispatch(
+      [
+        Effect.broadcast(
+          '#foo',
+          [L('@+draft/read-marker=m1 :a!u@h TAGMSG #foo')],
+          'c1',
+          undefined,
+          undefined,
+          ['message-tags', 'draft/read-marker'],
+          'alice',
+        ),
+      ],
+      runtime,
+    );
+
+    expect(sends.map((s) => s.to)).toEqual(['c3']);
+  });
+
+  it('ignores the account filter when account is unset (channel-wide broadcast)', async () => {
+    const members = memberMap([
+      ['c1', { caps: new Set(['message-tags']), account: 'alice' }],
+      ['c2', { caps: new Set(['message-tags']), account: 'bob' }],
+      ['c3', { caps: new Set(['message-tags']), account: 'carol' }],
+    ]);
+    const { runtime, sends } = capAwareRuntime(members);
+
+    await dispatch(
+      [
+        Effect.broadcast(
+          '#foo',
+          [L('@+draft/typing=active :a!u@h TAGMSG #foo')],
+          'c1',
+          undefined,
+          undefined,
+          ['message-tags', 'draft/typing'],
+        ),
+      ],
+      runtime,
+    );
+
+    // No account filter → every other member receives regardless of account.
+    expect(sends.map((s) => s.to).sort()).toEqual(['c2', 'c3']);
+  });
+
+  it('delivers to every same-account member regardless of caps when only account is set', async () => {
+    // account-only broadcast (no cap / caps): the recipient set is purely
+    // account-scoped, so caps play no role — every same-account member
+    // receives the line, even with an empty cap set.
+    const members = memberMap([
+      ['c1', { caps: new Set<string>(), account: 'alice' }], // originator (except)
+      ['c2', { caps: new Set<string>(), account: 'alice' }], // same account, no caps
+      ['c3', { caps: new Set<string>(), account: 'bob' }], // different account
+    ]);
+    const { runtime, sends, broadcasts } = capAwareRuntime(members);
+
+    await dispatch(
+      [
+        Effect.broadcast(
+          '#foo',
+          [L(':a!u@h TAGMSG #foo')],
+          'c1',
+          undefined,
+          undefined,
+          undefined,
+          'alice',
+        ),
+      ],
+      runtime,
+    );
+
+    // No fast-path bulk broadcast: dispatch routes per-recipient.
+    expect(broadcasts).toHaveLength(0);
+    // c2 (same account, no caps) receives; c3 (different account) is excluded.
+    expect(sends.map((s) => s.to)).toEqual(['c2']);
+  });
+});
+
 //
 // Recipients that did NOT negotiate `message-tags` must never receive a line
 // beginning with `@+<client-tag>`. The dispatch broadcast per-recipient path
@@ -875,3 +1066,80 @@ describe('dispatch — observability', () => {
     expect(errs[0]?.fields?.err).toBe('string-error');
   });
 });
+
+describe('dispatch — EnforceNick', () => {
+  it('disconnects immediately for the kill policy', async () => {
+    const calls: RecordedCall[] = [];
+    await dispatch([Effect.enforceNick('c2', 'alice', 'kill', 0)], fakeRuntime(calls));
+    expect(calls).toEqual([{ method: 'disconnect', args: ['c2', 'Nick enforced by NickServ'] }]);
+  });
+
+  it('is a no-op for the none policy (no runtime calls)', async () => {
+    const calls: RecordedCall[] = [];
+    await dispatch([Effect.enforceNick('c2', 'alice', 'none', 0)], fakeRuntime(calls));
+    expect(calls).toEqual([]);
+  });
+
+  it('schedules the disconnect after graceMs for ghost via the injected scheduler', async () => {
+    const calls: RecordedCall[] = [];
+    const scheduled: { ms: number }[] = [];
+    let scheduledCallback: (() => void) | undefined;
+    const scheduler = (cb: () => void, ms: number): void => {
+      scheduled.push({ ms });
+      scheduledCallback = cb;
+    };
+
+    await dispatch([Effect.enforceNick('c2', 'alice', 'ghost', 30_000)], fakeRuntime(calls), {
+      scheduler,
+    });
+
+    // Disconnect must NOT have fired yet (still within the grace window).
+    expect(calls).toEqual([]);
+    expect(scheduled).toEqual([{ ms: 30_000 }]);
+    expect(scheduledCallback).toBeTypeOf('function');
+
+    // Flush the grace timer → disconnect fires with the canonical reason.
+    scheduledCallback?.();
+    await Promise.resolve();
+
+    expect(calls).toEqual([{ method: 'disconnect', args: ['c2', 'Nick enforced by NickServ'] }]);
+  });
+
+  it('disconnects immediately for ghost when graceMs is 0', async () => {
+    const calls: RecordedCall[] = [];
+    const scheduler = (): void => {
+      // Should never be called when graceMs is 0.
+      throw new Error('scheduler must not be invoked for graceMs=0');
+    };
+
+    await dispatch([Effect.enforceNick('c2', 'alice', 'ghost', 0)], fakeRuntime(calls), {
+      scheduler,
+    });
+
+    expect(calls).toEqual([{ method: 'disconnect', args: ['c2', 'Nick enforced by NickServ'] }]);
+  });
+
+  it('still disconnects for ghost when no scheduler is supplied (setTimeout fallback)', async () => {
+    // graceMs=0 takes the immediate path, so the missing scheduler is fine.
+    const calls: RecordedCall[] = [];
+    await dispatch([Effect.enforceNick('c2', 'alice', 'ghost', 0)], fakeRuntime(calls));
+    expect(calls).toEqual([{ method: 'disconnect', args: ['c2', 'Nick enforced by NickServ'] }]);
+  });
+
+  it('uses the default setTimeout scheduler when no scheduler is injected (ghost with grace)', async () => {
+    vi.useFakeTimers();
+    try {
+      const calls: RecordedCall[] = [];
+      // dispatch resolves once the timer is scheduled; the disconnect is deferred.
+      await dispatch([Effect.enforceNick('c2', 'alice', 'ghost', 30_000)], fakeRuntime(calls));
+      expect(calls).toEqual([]);
+
+      // Flushing the fake timer fires the scheduled disconnect.
+      await vi.advanceTimersByTimeAsync(30_000);
+
+      expect(calls).toEqual([{ method: 'disconnect', args: ['c2', 'Nick enforced by NickServ'] }]);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

package/packages/irc-server/tests/routing.test.ts

@@ -114,16 +114,22 @@ describe('buildRoutedReducers', () => {
         'away',
         'cap',
         'channelMode',
+        'chanserv',
+        'hostserv',
         'info',
         'invite',
         'join',
         'kick',
+        'markreadChannel',
         'motd',
         'names',
         'nick',
+        'nickserv',
+        'memoserv',
         'noticeChannel',
         'noticeUser',
         'oper',
+        'operserv',
         'part',
         'pass',
         'ping',

package/packages/irc-test-support/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-test-support",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Shared IRC scenario runner + harness seam used by every adapter's integration suite",
   "license": "BSD-3-Clause",

package/packages/irc-test-support/src/in-memory-harness.ts

@@ -21,6 +21,7 @@ import {
   FakeClock,
   type RawLine,
   SequentialIdFactory,
+  type ServerConfig,
   StaticMotdProvider,
   createConnection,
 } from '@serverless-ircd/irc-core';
@@ -44,7 +45,14 @@ const POLL_MS = 10;
 /** Default timeout for waitFor* implementations (ms). */
 const DEFAULT_TIMEOUT_MS = 1000;
 
-/** Shared server config used by the harness. Hard-coded — tests assert on it. */
+/**
+ * Shared server config used by the harness. Hard-coded — tests assert on it.
+ *
+ * `serverPassword` is intentionally NOT set here so the default harness
+ * leaves the registration gate disabled and every existing scenario
+ * registers without `PASS`. Construct the harness with
+ * `{ serverPassword: '...' }` to opt a scenario into the gated path.
+ */
 export const HARNESS_SERVER_CONFIG = {
   serverName: 'irc.example.com',
   networkName: 'ExampleNet',
@@ -57,6 +65,17 @@ export const HARNESS_SERVER_CONFIG = {
   quitMessage: 'Client Quit',
 } as const;
 
+/**
+ * Optional harness configuration. `serverPassword` opts a scenario into
+ * the server-password gate: when set, every spawned client must supply
+ * the matching `PASS <value>` (or SASL-identify) before `001
+ * RPL_WELCOME`. Default unset → gate disabled (existing scenarios
+ * unchanged).
+ */
+export interface InMemoryHarnessOptions {
+  serverPassword?: string;
+}
+
 /**
  * Default MOTD lines exposed to every spawned client. The registration
  * welcome block renders these lines as `375`/`372`×N/`376` numerics, and
@@ -120,6 +139,7 @@ export class InMemoryHarness implements IrcHarness {
   private readonly motd = new StaticMotdProvider(HARNESS_MOTD_LINES);
   private readonly clients = new Map<ConnId, TrackedClient>();
   private readonly transportKind: TransportKind;
+  private readonly serverConfig: ServerConfig;
   private nextId = 0;
   private closed = false;
 
@@ -130,9 +150,15 @@ export class InMemoryHarness implements IrcHarness {
    *   {@link TcpByteStreamTransport} so chunk-boundary scenarios exercise
    *   real byte-stream framing. One transport instance per client (TCP
    *   transports own a per-connection partial-line buffer).
+   * @param opts Optional harness-wide config. `serverPassword` opts a
+   *   scenario into the registration gate (default off).
    */
-  constructor(transportKind: TransportKind = 'ws') {
+  constructor(transportKind: TransportKind = 'ws', opts: InMemoryHarnessOptions = {}) {
     this.transportKind = transportKind;
+    this.serverConfig =
+      opts.serverPassword === undefined
+        ? HARNESS_SERVER_CONFIG
+        : { ...HARNESS_SERVER_CONFIG, serverPassword: opts.serverPassword };
   }
 
   async spawnClient(opts?: SpawnClientOptions): Promise<ClientHarness> {
@@ -162,7 +188,7 @@ export class InMemoryHarness implements IrcHarness {
       state,
       runtime: this.runtime,
       channels: this.runtime,
-      serverConfig: HARNESS_SERVER_CONFIG,
+      serverConfig: this.serverConfig,
       clock: this.clock,
       ids: this.ids,
       motd: this.motd,

package/packages/irc-test-support/src/index.ts

@@ -20,6 +20,7 @@ export {
   HARNESS_MOTD_LINES,
   HARNESS_SERVER_CONFIG,
   InMemoryHarness,
+  type InMemoryHarnessOptions,
   inMemoryHarnessFactory,
   inMemoryTcpHarnessFactory,
   inMemoryWsHarnessFactory,

package/packages/irc-test-support/tests/in-memory-harness.test.ts

@@ -228,3 +228,35 @@ describe('InMemoryClientHarness.close', () => {
     await h.close();
   });
 });
+
+describe('InMemoryHarness — server-password gate opt-in', () => {
+  it('rejects registration with 464 + disconnect when serverPassword is set and no PASS is sent', async () => {
+    const h = new InMemoryHarness('ws', { serverPassword: 's3cret' });
+    const c = await h.spawnClient();
+    await c.send('NICK alice');
+    await c.send('USER alice 0 * :alice');
+    // No PASS → gate fires: 464 then the connection is torn down.
+    const line464 = await c.waitForNumeric('464');
+    expect(line464).toMatch(/464 alice :Password mismatch/u);
+    await h.close();
+  });
+
+  it('completes registration when PASS matches the configured serverPassword', async () => {
+    const h = new InMemoryHarness('ws', { serverPassword: 's3cret' });
+    const c = await h.spawnClient();
+    await c.send('PASS s3cret');
+    await c.send('NICK bob');
+    await c.send('USER bob 0 * :bob');
+    await c.waitForNumeric('001');
+    await h.close();
+  });
+
+  it('leaves the gate disabled by default (no serverPassword option)', async () => {
+    const h = new InMemoryHarness();
+    const c = await h.spawnClient();
+    await c.send('NICK carol');
+    await c.send('USER carol 0 * :carol');
+    await c.waitForNumeric('001');
+    await h.close();
+  });
+});

package/tools/ci-hardening/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/ci-hardening",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "CI hardening helpers: coverage-gate config validator + mutation-testing driver for irc-core",
   "license": "BSD-3-Clause",

package/tools/load-test/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/load-test",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Synthetic WebSocket IRC client farm for load testing ServerlessIRCd (concurrency, latency p50/p95/p99, drop rate)",
   "license": "BSD-3-Clause",

package/tools/tcp-ws-forwarder/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/tcp-ws-forwarder",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Local TCP to ws/wss forwarder so standard IRC clients can reach the WebSocket-only ServerlessIRCd transport",
   "license": "BSD-3-Clause",

package/tools/tcp-ws-forwarder/tests/forwarder.test.ts

@@ -367,8 +367,8 @@ describe('forwarder — TCP→WS framing', () => {
     await client.opened();
     client.sendRaw('PING :bare\n');
 
-    await target.waitForConnection();
-    await new Promise<void>((res) => setTimeout(res, 25));
+    const ws = await target.waitForConnection();
+    await new Promise<void>((res) => ws.once('message', () => res()));
     expect(target.frames).toEqual(['PING :bare']);
   });
 

package/apps/cf-worker/tests/fixtures/web-dist/app/index.html

@@ -1,18 +0,0 @@
-<!doctype html>
-<!--
-  Test-only fixture mirroring the real `apps/web/dist/app/index.html` produced
-  by the Kiwi SPA build (`pnpm --filter web build`). The cf-worker smoke suite
-  points its `[assets]` binding here so the worker's fall-through routing
-  (WS → ConnectionDO, /health → plaintext, else → ASSETS) is exercised without
-  depending on the (slow, submodule-heavy) Kiwi build. Production points at
-  `apps/web/dist`; this fixture only stands in for the test run.
--->
-<html lang="en">
-  <head>
-    <meta charset="utf-8" />
-    <title>KiwiIRC</title>
-  </head>
-  <body>
-    <div id="app"></div>
-  </body>
-</html>

package/packages/irc-core/tests/read-marker-store.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { InMemoryReadMarkerStore, type ReadMarkerStore } from '../src/ports';
-
-describe('InMemoryReadMarkerStore — port conformance', () => {
-  it('implements the ReadMarkerStore port', () => {
-    const store: ReadMarkerStore = new InMemoryReadMarkerStore();
-    expect(store).toBeDefined();
-  });
-});
-
-describe('InMemoryReadMarkerStore — set + get', () => {
-  it('returns undefined for an unknown (account, channel) pair', () => {
-    const store = new InMemoryReadMarkerStore();
-    expect(store.get('alice', '#foo')).toBeUndefined();
-  });
-
-  it('stores and returns the msgid for a known (account, channel) pair', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    expect(store.get('alice', '#foo')).toBe('m1');
-  });
-
-  it('overwrites the marker on a subsequent set for the same pair', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    store.set('alice', '#foo', 'm2');
-    expect(store.get('alice', '#foo')).toBe('m2');
-  });
-
-  it('keys channels case-insensitively (rfc1459 fold)', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#Foo', 'm1');
-    expect(store.get('alice', '#foo')).toBe('m1');
-    expect(store.get('alice', '#FOO')).toBe('m1');
-  });
-
-  it('keys accounts case-insensitively (rfc1459 fold)', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('Alice', '#foo', 'm1');
-    expect(store.get('alice', '#foo')).toBe('m1');
-    expect(store.get('ALICE', '#foo')).toBe('m1');
-  });
-
-  it('keeps markers for distinct accounts on the same channel separate', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    store.set('bob', '#foo', 'm9');
-    expect(store.get('alice', '#foo')).toBe('m1');
-    expect(store.get('bob', '#foo')).toBe('m9');
-  });
-
-  it('keeps markers for distinct channels on the same account separate', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    store.set('alice', '#bar', 'm2');
-    expect(store.get('alice', '#foo')).toBe('m1');
-    expect(store.get('alice', '#bar')).toBe('m2');
-  });
-});
-
-describe('InMemoryReadMarkerStore — forAccount', () => {
-  it('returns an empty array for an account with no markers', () => {
-    const store = new InMemoryReadMarkerStore();
-    expect(store.forAccount('alice')).toEqual([]);
-  });
-
-  it('returns every (channel, msgid) pair recorded for the account', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    store.set('alice', '#bar', 'm2');
-
-    const entries = store.forAccount('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 store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    const entries = store.forAccount('alice');
-    expect(entries[0]?.account).toBe('alice');
-  });
-
-  it('reflects the most recent set when a pair is overwritten', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    store.set('alice', '#foo', 'm2');
-    const entries = store.forAccount('alice');
-    expect(entries).toHaveLength(1);
-    expect(entries[0]?.msgid).toBe('m2');
-  });
-
-  it('does not leak markers belonging to a different account', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('alice', '#foo', 'm1');
-    store.set('bob', '#bar', 'm2');
-    expect(store.forAccount('alice')).toHaveLength(1);
-    expect(store.forAccount('bob')).toHaveLength(1);
-  });
-
-  it('folds the account name case-insensitively on lookup', () => {
-    const store = new InMemoryReadMarkerStore();
-    store.set('Alice', '#foo', 'm1');
-    expect(store.forAccount('ALICE')).toHaveLength(1);
-  });
-});