serverless-ircd 0.4.0 → 0.6.0

package/packages/cf-adapter/tests/registry-do.test.ts

@@ -1,7 +1,7 @@
 /**
- * 034 — `RegistryDO` with sharding plan.
+ * `RegistryDO` with sharding plan.
  *
- * TDD outline (from tickets.md):
+ * TDD outline:
  *   "Red on concurrent reserve from two stub ConnectionDOs; green."
  *
  * Tests run inside real `workerd` via miniflare so DO storage
@@ -12,7 +12,7 @@
  * The binding `REGISTRY_DO_REAL` (declared in `wrangler.test.toml`)
  * points at the real {@link RegistryDO} class. Tests address a
  * specific shard by name (the same `registryKeyForNick` result the
- * CfRuntime will compute in 036), so a single DO instance
+ * CfRuntime will compute), so a single DO instance
  * stands in for one shard of the production fleet.
  */
 
@@ -34,7 +34,7 @@ declare global {
 
 /**
  * Returns a stub for the registry shard that owns `nick` under the
- * default shard count. Mirrors what CfRuntime will do in 036.
+ * default shard count. Mirrors what CfRuntime will do.
  */
 function shardForNick(nick: string, shards = DEFAULT_REGISTRY_SHARDS): DurableObjectStub {
   const key = registryKeyForNick(nick, shards);
@@ -53,6 +53,7 @@ interface RegistryRpc {
   changeNick(conn: string, oldNick: string, newNick: string): Promise<boolean>;
   releaseNick(nick: string): Promise<void>;
   lookupNick(nick: string): Promise<string | null>;
+  listEntries(): Promise<Array<[nickLower: string, connId: string]>>;
 }
 
 function rpc(stub: DurableObjectStub): RegistryRpc {
@@ -333,3 +334,106 @@ describe('RegistryDO — shard isolation', () => {
     expect(await rpc(i).lookupNick('in-shard-31')).toBeNull();
   });
 });
+
+// ---------------------------------------------------------------------------
+// changeNick — direct contract tests (sharding is a CfRuntime concern; the
+// DO method itself operates on whatever keys it is given, so we address a
+// single DO instance directly to exercise every branch without depending on
+// the FNV-1a hash landing two nicks in the same shard).
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — changeNick branch coverage (direct on one shard)', () => {
+  // Pin every test to a single, stable shard instance. The DO method is
+  // agnostic to which shard it lives on; what matters is the storage
+  // state we put in place before the call.
+  const shard = () => shardByIndex(1);
+
+  it('returns false when the new nick is held by a different conn', async () => {
+    const s = shard();
+    // Seed storage so both `taken` and `current` are owned by different
+    // conns on this same DO.
+    expect(await rpc(s).reserveNick('taken-new', 'conn-owner')).toEqual({ ok: true });
+    expect(await rpc(s).reserveNick('current-old', 'conn-changer')).toEqual({ ok: true });
+
+    const ok = await rpc(s).changeNick('conn-changer', 'current-old', 'taken-new');
+    expect(ok).toBe(false);
+    // State untouched: owners stay as they were.
+    expect(await rpc(s).lookupNick('taken-new')).toBe('conn-owner');
+    expect(await rpc(s).lookupNick('current-old')).toBe('conn-changer');
+  });
+
+  it('clears the old nick when it still points at the caller', async () => {
+    const s = shard();
+    expect(await rpc(s).reserveNick('cn-clear-old', 'conn-self')).toEqual({ ok: true });
+
+    const ok = await rpc(s).changeNick('conn-self', 'cn-clear-old', 'cn-clear-new');
+    expect(ok).toBe(true);
+    expect(await rpc(s).lookupNick('cn-clear-old')).toBeNull();
+    expect(await rpc(s).lookupNick('cn-clear-new')).toBe('conn-self');
+  });
+
+  it('leaves a stale old nick alone when it no longer points at the caller', async () => {
+    // Crash-recovery / race defence: another conn grabbed `old` between
+    // our reserve and our changeNick. The conditional delete must not
+    // clobber that third party.
+    const s = shard();
+    // `old` is currently held by `conn-other`, not by `conn-caller`.
+    expect(await rpc(s).reserveNick('cn-stale-old', 'conn-other')).toEqual({ ok: true });
+
+    const ok = await rpc(s).changeNick('conn-caller', 'cn-stale-old', 'cn-stale-new');
+    expect(ok).toBe(true);
+    // New nick reserved for the caller...
+    expect(await rpc(s).lookupNick('cn-stale-new')).toBe('conn-caller');
+    // ...but `old` is untouched because it never pointed at the caller.
+    expect(await rpc(s).lookupNick('cn-stale-old')).toBe('conn-other');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listEntries — backs the global WALLOPS fan-out (CfRuntime.broadcastWallops
+// walks every shard via this method).
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — listEntries', () => {
+  it('returns an empty array for a fresh shard', async () => {
+    expect(await rpc(shardByIndex(2)).listEntries()).toEqual([]);
+  });
+
+  it('enumerates every (nickLower, connId) pair in this shard', async () => {
+    const s = shardByIndex(3);
+    await rpc(s).reserveNick('Alice', 'conn-a');
+    await rpc(s).reserveNick('Bob', 'conn-b');
+    await rpc(s).reserveNick('Carol', 'conn-c');
+
+    const entries = await rpc(s).listEntries();
+    // Keys are lowercased in storage; the strip recovers the lowercased
+    // nick (matches what CfRuntime expects when deduping conn ids).
+    const sorted = [...entries].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    expect(sorted).toEqual([
+      ['alice', 'conn-a'],
+      ['bob', 'conn-b'],
+      ['carol', 'conn-c'],
+    ]);
+  });
+
+  it('reflects releases: a freed nick drops out of the listing', async () => {
+    const s = shardByIndex(4);
+    await rpc(s).reserveNick('keep', 'conn-k');
+    await rpc(s).reserveNick('drop', 'conn-d');
+    await rpc(s).releaseNick('drop');
+
+    const entries = await rpc(s).listEntries();
+    expect(entries).toEqual([['keep', 'conn-k']]);
+  });
+
+  it('strips the storage prefix so callers see a bare nickLower', async () => {
+    const s = shardByIndex(5);
+    await rpc(s).reserveNick('prefixed', 'conn-p');
+    const entries = await rpc(s).listEntries();
+    const nickLower = entries[0]?.[0];
+    // The internal key is `nick:prefixed`; the public API must not leak
+    // that implementation detail.
+    expect(nickLower).toBe('prefixed');
+    expect(nickLower?.startsWith('nick:')).toBe(false);
+  });
+});

package/packages/cf-adapter/tests/serialize.test.ts

@@ -0,0 +1,308 @@
+/**
+ * `serialize` / `deserialize` / `migrate`.
+ *
+ * These helpers bridge {@link ConnectionState} (which carries `Set` and
+ * `Map` fields that degrade under `JSON.stringify`) and the JSON-safe
+ * {@link PersistedConnectionState} shape stored in DO transactional KV.
+ *
+ * Coverage focus: every optional-field branch in both directions, the
+ * `secure` / `userModes.tls` backfill paths in `migrate`, and the
+ * rejection paths (non-object record, too-new version).
+ */
+
+import { type ConnectionState, createConnection } from '@serverless-ircd/irc-core';
+import { describe, expect, it } from 'vitest';
+import { PERSISTED_STATE_VERSION, deserialize, migrate, serialize } from '../src/serialize';
+
+/** Builds a fully-populated connection state for round-trip assertions. */
+function fullState(): ConnectionState {
+  const s = createConnection({ id: 'conn-1', connectedSince: 100 });
+  s.registration = 'registered';
+  s.capNegotiating = false;
+  s.secure = true;
+  s.nick = 'Alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice Example';
+  s.passAttempt = 'hunter2';
+  s.account = 'alice-account';
+  s.away = 'brb';
+  s.caps = new Set(['server-time', 'message-tags']);
+  s.joinedChannels = new Set(['#one', '#two']);
+  s.userModes = {
+    invisible: true,
+    oper: false,
+    wallops: true,
+    serverNotices: false,
+    tls: true,
+  };
+  s.lastSeen = 200;
+  return s;
+}
+
+describe('serialize — round trip', () => {
+  it('survives serialize → deserialize for a fully-populated state', () => {
+    const original = fullState();
+    const round = deserialize(serialize(original));
+    // Sets are rebuilt with the same members.
+    expect(round.caps).toEqual(new Set(['server-time', 'message-tags']));
+    expect(round.joinedChannels).toEqual(new Set(['#one', '#two']));
+    // Optional fields preserved.
+    expect(round.nick).toBe('Alice');
+    expect(round.user).toBe('alice');
+    expect(round.host).toBe('example.com');
+    expect(round.realname).toBe('Alice Example');
+    expect(round.passAttempt).toBe('hunter2');
+    expect(round.account).toBe('alice-account');
+    expect(round.away).toBe('brb');
+    // userModes cloned (mutating the round trip must not leak back).
+    expect(round.userModes).toEqual(original.userModes);
+    expect(round.userModes).not.toBe(original.userModes);
+    expect(round.secure).toBe(true);
+  });
+
+  it('is JSON-stable: serialize → JSON.stringify → JSON.parse → deserialize', () => {
+    // This is the actual production path through DO storage: the runtime
+    // structured-clones the value, but the persisted shape must also be
+    // JSON-tolerant for older storage rows and snapshots written to R2.
+    const original = fullState();
+    const json = JSON.stringify(serialize(original));
+    const round = deserialize(JSON.parse(json));
+    expect(round.caps).toEqual(original.caps);
+    expect(round.nick).toBe(original.nick);
+    expect(round.away).toBe(original.away);
+  });
+
+  it('stamps the current persisted schema version', () => {
+    expect(serialize(fullState()).version).toBe(PERSISTED_STATE_VERSION);
+  });
+});
+
+describe('serialize — optional-field branches', () => {
+  it('omits host when undefined', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.nick = 'n';
+    expect(serialize(s).host).toBeUndefined();
+  });
+
+  it('omits passAttempt when undefined', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    expect(serialize(s).passAttempt).toBeUndefined();
+  });
+
+  it('omits away when undefined', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    expect(serialize(s).away).toBeUndefined();
+  });
+
+  it('clones caps and joinedChannels arrays away from the live Set', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.caps = new Set(['a']);
+    s.joinedChannels = new Set(['#x']);
+    const out = serialize(s);
+    expect(out.caps).toEqual(['a']);
+    expect(out.joinedChannels).toEqual(['#x']);
+  });
+});
+
+describe('deserialize — optional-field branches', () => {
+  it('populates host when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.host = 'host.example';
+    expect(deserialize(serialize(s)).host).toBe('host.example');
+  });
+
+  it('populates passAttempt when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.passAttempt = 'pw';
+    expect(deserialize(serialize(s)).passAttempt).toBe('pw');
+  });
+
+  it('populates account when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.account = 'acc';
+    expect(deserialize(serialize(s)).account).toBe('acc');
+  });
+
+  it('populates away when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.away = 'afk';
+    expect(deserialize(serialize(s)).away).toBe('afk');
+  });
+
+  it('leaves optional fields absent on a minimal pre-registration state', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    const round = deserialize(serialize(s));
+    expect(round.nick).toBeUndefined();
+    expect(round.host).toBeUndefined();
+    expect(round.away).toBeUndefined();
+    expect(round.account).toBeUndefined();
+    expect(round.passAttempt).toBeUndefined();
+  });
+});
+
+describe('migrate — backfills additive fields', () => {
+  it('defaults `secure` to false when the field is absent', () => {
+    // Pre-feature record: no `secure` key at all.
+    const legacy = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    const migrated = migrate(legacy);
+    expect(migrated.secure).toBe(false);
+    // The mutation landed on the original object reference (defensive
+    // backfill writes through to the record).
+    expect((legacy as Record<string, unknown>).secure).toBe(false);
+  });
+
+  it('defaults `userModes.tls` to false when the field is absent', () => {
+    const legacy = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    const migrated = migrate(legacy);
+    expect(migrated.userModes.tls).toBe(false);
+  });
+
+  it('leaves an explicit `secure: true` untouched', () => {
+    const rec = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      secure: true,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+        tls: true,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(migrate(rec).secure).toBe(true);
+    expect(migrate(rec).userModes.tls).toBe(true);
+  });
+
+  it('tolerates a missing `userModes` object without throwing', () => {
+    // A record corrupted in storage (or hand-built by an older code
+    // path) might not carry userModes at all. Migrate must not crash.
+    const rec = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(() => migrate(rec)).not.toThrow();
+  });
+});
+
+describe('migrate — rejection paths', () => {
+  it('rejects a non-object record', () => {
+    for (const bad of [null, 'string', 42, true, undefined]) {
+      expect(() => migrate(bad)).toThrow(/not an object/u);
+    }
+  });
+
+  it('rejects an array record (arrays are not plain objects)', () => {
+    expect(() => migrate([])).toThrow(/not an object/u);
+  });
+
+  it('rejects a record persisted with a newer schema version', () => {
+    const future = {
+      version: PERSISTED_STATE_VERSION + 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+        tls: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(() => migrate(future)).toThrow(/newer than/u);
+  });
+
+  it('treats a missing version as the legacy default (0)', () => {
+    // No `version` field — old shape. Migrate must accept it rather
+    // than fail the boot path; the backfill covers the additive keys.
+    const legacy = {
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(() => migrate(legacy)).not.toThrow();
+  });
+});
+
+describe('deserialize — migrate integration', () => {
+  it('backfills `secure` and `userModes.tls` on a legacy record, then materializes', () => {
+    const legacy = {
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: ['server-time'],
+      joinedChannels: ['#x'],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: true,
+        serverNotices: false,
+      },
+      lastSeen: 5,
+      connectedSince: 1,
+    };
+    const state = deserialize(legacy);
+    expect(state.secure).toBe(false);
+    expect(state.userModes.tls).toBe(false);
+    expect(state.userModes.wallops).toBe(true);
+    expect(state.caps).toEqual(new Set(['server-time']));
+  });
+});

package/packages/cf-adapter/tests/sharding.test.ts

@@ -1,5 +1,5 @@
 /**
- * 034 — Sharding function for `RegistryDO`.
+ * Sharding function for `RegistryDO`.
  *
  * PLAN §6.1 / §4 — the registry is sharded by `hash(nick) % N` so no
  * single Durable Object becomes a hot spot for nick registrations. Each

package/packages/cf-adapter/tests/stats.test.ts

@@ -0,0 +1,120 @@
+import { type ConnId, type ConnectionState, createConnection } from '@serverless-ircd/irc-core';
+import { describe, expect, it } from 'vitest';
+import { CfStats } from '../src/stats.js';
+
+/**
+ * Minimal stub satisfying the structural interface CfStats needs (just
+ * `listChannels` + `getChannelConnections`). Keeps the unit test free of
+ * the workerd/miniflare harness the full CfRuntime integration suite uses.
+ */
+interface StatsRuntimeShape {
+  listChannels(): Promise<{ nameLower: string }[]>;
+  getChannelConnections(name: string): Promise<ReadonlyMap<ConnId, ConnectionState>>;
+}
+
+class StubRuntime implements StatsRuntimeShape {
+  constructor(
+    private readonly channels: ReadonlyMap<string, ReadonlyMap<ConnId, ConnectionState>>,
+  ) {}
+  async listChannels(): Promise<{ nameLower: string }[]> {
+    return Array.from(this.channels.keys(), (nameLower) => ({ nameLower }));
+  }
+  async getChannelConnections(name: string): Promise<ReadonlyMap<ConnId, ConnectionState>> {
+    return this.channels.get(name) ?? new Map();
+  }
+}
+
+function makeConn(
+  id: ConnId,
+  opts: { oper?: boolean; invisible?: boolean; registered?: boolean } = {},
+): ConnectionState {
+  const s = createConnection({ id, connectedSince: 0 });
+  s.nick = id;
+  s.registration = opts.registered === false ? 'pre-registration' : 'registered';
+  if (opts.oper !== undefined) s.userModes.oper = opts.oper;
+  if (opts.invisible !== undefined) s.userModes.invisible = opts.invisible;
+  return s;
+}
+
+describe('CfStats', () => {
+  it('returns zero counts for an empty deployment', async () => {
+    const rt = new StubRuntime(new Map());
+    const stats = new CfStats(rt, 1_000);
+    const snap = await stats.getStats();
+    expect(snap.users).toBe(0);
+    expect(snap.channels).toBe(0);
+    expect(snap.servers).toBe(1);
+    expect(snap.localConns).toBe(0);
+  });
+
+  it('counts channels and their members (cross-channel dedup)', async () => {
+    const alice = makeConn('c1');
+    const bob = makeConn('c2', { invisible: true });
+    const carol = makeConn('c3', { oper: true });
+    // Alice and Bob share #a; Carol is alone in #b. Alice is also in #b
+    // (dup across channels) — must be counted once.
+    const channels = new Map<string, ReadonlyMap<ConnId, ConnectionState>>([
+      [
+        '#a',
+        new Map<ConnId, ConnectionState>([
+          ['c1', alice],
+          ['c2', bob],
+        ]),
+      ],
+      [
+        '#b',
+        new Map<ConnId, ConnectionState>([
+          ['c1', alice],
+          ['c3', carol],
+        ]),
+      ],
+    ]);
+    const rt = new StubRuntime(channels);
+
+    const stats = new CfStats(rt, 1_000);
+    const snap = await stats.getStats();
+
+    expect(snap.channels).toBe(2);
+    // 3 unique connections (alice, bob, carol).
+    expect(snap.localConns).toBe(3);
+    // 3 registered, 1 invisible → 2 visible.
+    expect(snap.users).toBe(2);
+    expect(snap.invisible).toBe(1);
+    expect(snap.opers).toBe(1);
+  });
+
+  it('counts a pre-registration member as an unknown connection', async () => {
+    const a = makeConn('c1');
+    const b = makeConn('c2', { registered: false });
+    const channels = new Map<string, ReadonlyMap<ConnId, ConnectionState>>([
+      [
+        '#a',
+        new Map<ConnId, ConnectionState>([
+          ['c1', a],
+          ['c2', b],
+        ]),
+      ],
+    ]);
+    const rt = new StubRuntime(channels);
+
+    const stats = new CfStats(rt, 1_000);
+    const snap = await stats.getStats();
+    expect(snap.users).toBe(1);
+    expect(snap.unknownConnections).toBe(1);
+    expect(snap.localConns).toBe(2);
+  });
+
+  it('echoes the supplied uptimeStartedAt', async () => {
+    const rt = new StubRuntime(new Map());
+    const stats = new CfStats(rt, 9_999);
+    const snap = await stats.getStats();
+    expect(snap.uptimeStartedAt).toBe(9_999);
+  });
+
+  it('returns servers=1 (single-server deployment)', async () => {
+    const rt = new StubRuntime(new Map());
+    const stats = new CfStats(rt, 0);
+    const snap = await stats.getStats();
+    expect(snap.servers).toBe(1);
+  });
+});

package/packages/cf-adapter/tests/worker/main.ts

@@ -7,15 +7,15 @@
  * and assert cross-DO interactions.
  *
  * Bindings:
- *   - `CONNECTION_DO` → `ConnectionDO` (real, 033).
+ *   - `CONNECTION_DO` → `ConnectionDO` (real).
  *   - `REGISTRY_DO` → `RecordingRegistryDO` stub used by the
- *     ConnectionDO tests (033). The stub records every RPC call
+ *     ConnectionDO tests. The stub records every RPC call
  *     into a per-instance log exposed via `runInDurableObject`.
- *   - `REGISTRY_DO_REAL` → `RegistryDO` (real, 034). Used by
- *     the RegistryDO unit tests. 036 will swap `REGISTRY_DO`
- *     over to this class once the full CfRuntime lands.
- *   - `CHANNEL_DO` → `RecordingChannelDO` stub (real impl lands in
- *     035).
+ *   - `REGISTRY_DO_REAL` → `RegistryDO` (real). Used by
+ *     the RegistryDO unit tests. The CfRuntime swaps `REGISTRY_DO`
+ *     over to this class once it lands.
+ *   - `CHANNEL_DO` → `RecordingChannelDO` stub (real impl in
+ *     `ChannelDO`).
  */
 
 import { ChannelDO } from '../../src/channel-do';

package/packages/cf-adapter/tests/worker/stubs/channel-stub.ts

@@ -1,7 +1,7 @@
 /**
  * Test-only {@link DurableObject} that records every cross-DO call from
- * {@link ConnectionDO}. The real ChannelDO ships in 035; for
- * 033 we only need to verify that ConnectionDO fan-outs (broadcast,
+ * {@link ConnectionDO}. The real ChannelDO ships in `channel-do.ts`;
+ * we only need to verify that ConnectionDO fan-outs (broadcast,
  * applyChannelDelta) reach it.
  *
  * Each instance is keyed by lowercased channel name (the convention the

package/packages/cf-adapter/tests/worker/stubs/registry-stub.ts

@@ -3,7 +3,7 @@
  * {@link ConnectionDO} into its `state.storage`. Tests inspect the call
  * log via `runInDurableObject` after exercising the connection.
  *
- * PLAN §2.1 — the real RegistryDO ships in 034. For 033 we
+ * PLAN §2.1 — the real RegistryDO ships separately. We
  * only need enough surface area to assert that ConnectionDO closes
  * release the nick and fan out QUIT correctly. The stub records the
  * requested operations verbatim; it does not enforce uniqueness.
@@ -12,7 +12,7 @@
 import { DurableObject } from 'cloudflare:workers';
 
 export interface RecordedRegistryCall {
-  method: 'reserveNick' | 'changeNick' | 'releaseNick' | 'lookupNick';
+  method: 'reserveNick' | 'changeNick' | 'releaseNick' | 'lookupNick' | 'listEntries';
   args: unknown[];
 }
 
@@ -21,6 +21,7 @@ interface RegistryRpc {
   changeNick(conn: string, oldNick: string, newNick: string): Promise<boolean>;
   releaseNick(nick: string): Promise<void>;
   lookupNick(nick: string): Promise<string | null>;
+  listEntries(): Promise<Array<[nickLower: string, connId: string]>>;
 }
 
 const LOG_KEY = 'registry-call-log';
@@ -54,4 +55,9 @@ export class RecordingRegistryDO extends DurableObject implements RegistryRpc {
     await this.append({ method: 'lookupNick', args: [nick] });
     return null;
   }
+
+  async listEntries(): Promise<Array<[nickLower: string, connId: string]>> {
+    await this.append({ method: 'listEntries', args: [] });
+    return [];
+  }
 }

package/packages/cf-adapter/vitest.config.ts

@@ -5,7 +5,7 @@ export default defineConfig({
   test: {
     include: ['tests/**/*.test.ts'],
     coverage: {
-      provider: 'v8',
+      provider: 'istanbul',
       all: false,
       include: ['src/**/*.ts'],
       exclude: ['src/**/index.ts'],

package/packages/cf-adapter/wrangler.test.toml

@@ -8,11 +8,18 @@ compatibility_flags = ["nodejs_compat"]
 # integration-test harness so scenario 18 (MOTD) asserts against the same
 # body text in every runtime factory.
 [vars]
+SERVER_NAME = "irc.example.com"
+NETWORK_NAME = "ServerlessIRCd"
 MOTD_LINES = "Welcome to the ServerlessIRCd integration-test harness.\nAll scenarios run parametrized over the IrcRuntime factory matrix."
 # SASL PLAIN accounts seeded into the in-worker AccountStore. Newline-
 # delimited `username:password` pairs; the connection-do parses these into
 # an InMemoryAccountStore so AUTHENTICATE PLAIN works end-to-end in tests.
 SASL_ACCOUNTS = "cf-sasl:s3cret"
+# IRC operator credentials consulted by the OPER reducer. The DO must
+# thread these from env into the reducer-facing ServerConfig so
+# `OPER <user> <pass>` returns 381 rather than 491 ERR_NOOPERHOST.
+OPER_USER = "cf-oper"
+OPER_PASSWORD = "oper-secret"
 
 # D1 database backing persistent SASL accounts. The D1 account-store suite
 # creates the `accounts` table in a beforeEach and exercises the real

package/packages/in-memory-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/in-memory-runtime",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "private": true,
   "description": "Single-process reference implementation of the IrcRuntime port, backed by Maps",
   "license": "BSD-3-Clause",