serverless-ircd 0.4.0 → 0.5.0

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

@@ -1,7 +1,7 @@
 /**
- * 033 — `ConnectionDO` (hibernatable WS), state migration, alarms.
+ * `ConnectionDO` (hibernatable WS), state migration, alarms.
  *
- * TDD outline (from tickets.md):
+ * TDD outline:
  *   "Red via `@cloudflare/vitest-pool-workers` on 'hibernate then wake
  *    preserves nick'; green; then alarm-driven PING."
  *
@@ -406,6 +406,31 @@ describe('ConnectionDO — SASL PLAIN end-to-end', () => {
   });
 });
 
+describe('ConnectionDO — OPER command (env-thread operCreds)', () => {
+  it('grants oper with 381 RPL_YOUREOPER for matching OPER_USER/OPER_PASSWORD', async () => {
+    const client = await connect('conn-oper-ok');
+    await register(client, 'alice');
+
+    client.send('OPER cf-oper oper-secret\r\n');
+    const reply = await client.waitForMessage((l) => / 381 | 491 | 464 | 461 /.test(l));
+
+    expect(reply).toContain(' 381 ');
+    expect(reply).toContain('You are now an IRC operator');
+    client.ws.close();
+  });
+
+  it('rejects oper with 464 ERR_PASSWDMISMATCH for a wrong password', async () => {
+    const client = await connect('conn-oper-bad');
+    await register(client, 'bob');
+
+    client.send('OPER cf-oper wrong\r\n');
+    const reply = await client.waitForMessage((l) => / 381 | 491 | 464 | 461 /.test(l));
+
+    expect(reply).toContain(' 464 ');
+    client.ws.close();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // End of file
 // ---------------------------------------------------------------------------

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);

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/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.5.0",
   "private": true,
   "description": "Single-process reference implementation of the IrcRuntime port, backed by Maps",
   "license": "BSD-3-Clause",

package/packages/in-memory-runtime/src/in-memory-runtime.ts

@@ -26,6 +26,7 @@ import {
   type ConnectionState,
   type Nick,
   type RawLine,
+  type ServerConfig,
   applyChannelDelta as applyDelta,
   caseFold,
   createChannel,
@@ -64,6 +65,15 @@ export interface InMemoryRuntimeOptions {
    * deployment's `ServerConfig`.
    */
   readonly admission?: AdmissionConfig;
+  /**
+   * Config-reload source for `REHASH`. When bound, the runtime re-invokes
+   * it on every {@link InMemoryRuntime.reloadConfig} call and returns the
+   * fresh {@link ServerConfig}; the local-cli binds the loader that
+   * re-derives config from its original options. When omitted
+   * `reloadConfig` rejects so the actor's graceful failure path applies a
+   * consistent error-suffixed `382`.
+   */
+  readonly configLoader?: () => Promise<ServerConfig>;
 }
 
 export class InMemoryRuntime implements IrcRuntime {
@@ -73,9 +83,11 @@ export class InMemoryRuntime implements IrcRuntime {
   private readonly nicks = new Map<string, ConnId>();
   private readonly admissionStats: AdmissionStats | undefined;
   private readonly admissionConfig: AdmissionConfig | undefined;
+  private readonly configLoader: (() => Promise<ServerConfig>) | undefined;
 
   constructor(opts: InMemoryRuntimeOptions) {
     this.clock = opts.clock;
+    this.configLoader = opts.configLoader;
     if (opts.admission !== undefined) {
       this.admissionConfig = opts.admission;
       this.admissionStats = new AdmissionStats(this.clock);
@@ -242,6 +254,22 @@ export class InMemoryRuntime implements IrcRuntime {
     }
   }
 
+  /**
+   * Global cross-connection fanout for `WALLOPS`. Scans the connection map
+   * and delivers `lines` to every live connection whose `+w` user mode is
+   * set, skipping `except` (the originator). Unlike {@link broadcast} this
+   * is NOT channel-scoped — it reaches connections with no shared channel
+   * membership. This is the reference implementation the CF and AWS
+   * adapters mirror against their own enumeration primitives.
+   */
+  async broadcastWallops(lines: RawLine[], except?: ConnId): Promise<void> {
+    for (const [connId, tracked] of this.connections) {
+      if (connId === except) continue;
+      if (!tracked.state.userModes.wallops) continue;
+      tracked.handlers.send(lines);
+    }
+  }
+
   // ------------------------------------------------------------------
   // IrcRuntime — nick registry
   // ------------------------------------------------------------------
@@ -333,4 +361,15 @@ export class InMemoryRuntime implements IrcRuntime {
   async listChannels(): Promise<ChanSnapshot[]> {
     return Array.from(this.channels.values(), (c) => toChannelSnapshot(c));
   }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — config reload (REHASH)
+  // ------------------------------------------------------------------
+
+  async reloadConfig(): Promise<ServerConfig> {
+    if (this.configLoader === undefined) {
+      throw new Error('no config loader bound to InMemoryRuntime');
+    }
+    return this.configLoader();
+  }
 }

package/packages/in-memory-runtime/tests/in-memory-runtime.test.ts

@@ -5,6 +5,7 @@ import {
   type ConnectionState,
   FakeClock,
   type RawLine,
+  type ServerConfig,
   createConnection,
 } from '@serverless-ircd/irc-core';
 import { describe, expect, it } from 'vitest';
@@ -124,6 +125,26 @@ describe('InMemoryRuntime — changeNick', () => {
     expect(await rt.lookupNick('alice')).toBe('c1');
     expect(await rt.lookupNick('bob')).toBe('c2');
   });
+
+  it('does not clobber a third party that grabbed the old nick via re-reserve (stale-release guard)', async () => {
+    // Covers the defensive branch on the old-mapping clear: c1 held
+    // `alice`, released it, c2 re-reserved it, then c1 reports a nick
+    // change FROM `alice` (stale state). The guard must NOT delete the
+    // alice mapping that now belongs to c2.
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    rt.registerConnection(makeConn('c1'), { send: () => {}, disconnect: () => {} });
+    rt.registerConnection(makeConn('c2'), { send: () => {}, disconnect: () => {} });
+
+    await rt.reserveNick('alice', 'c1');
+    await rt.releaseNick('alice'); // nicks[alice] deleted (still pointed at c1)
+    await rt.reserveNick('alice', 'c2'); // nicks[alice] = c2
+
+    const ok = await rt.changeNick('c1', 'alice', 'bob');
+    expect(ok).toBe(true);
+    // c1 got `bob`, c2 still holds `alice` (the stale clear was skipped).
+    expect(await rt.lookupNick('alice')).toBe('c2');
+    expect(await rt.lookupNick('bob')).toBe('c1');
+  });
 });
 
 describe('InMemoryRuntime — releaseNick', () => {
@@ -255,6 +276,100 @@ describe('InMemoryRuntime — applyChannelDelta / getChannelSnapshot', () => {
   });
 });
 
+describe('InMemoryRuntime — getChannel (peek-only)', () => {
+  it('returns the authoritative ChannelState when the channel exists', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    await rt.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+
+    const chan = rt.getChannel('#foo');
+    expect(chan).toBeDefined();
+    expect(chan?.name).toBe('#foo');
+    expect(chan?.members.has('c1')).toBe(true);
+  });
+
+  it('returns undefined for an unknown channel (does not create it)', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    expect(rt.getChannel('#nope')).toBeUndefined();
+    // Peek-only: the channel map is still empty.
+    expect(await rt.listChannels()).toEqual([]);
+  });
+
+  it('folds the channel name with rfc1459 case-mapping on lookup', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    await rt.applyChannelDelta('#Foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    expect(rt.getChannel('#foo')).toBeDefined();
+    expect(rt.getChannel('#FOO')).toBeDefined();
+  });
+});
+
+describe('InMemoryRuntime — getChannelConnections', () => {
+  it('returns the live ConnectionState for each registered member', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    rt.registerConnection(makeConn('c1', 'alice'), { send: () => {}, disconnect: () => {} });
+    rt.registerConnection(makeConn('c2', 'bob'), { send: () => {}, disconnect: () => {} });
+    await rt.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
+    });
+
+    const conns = await rt.getChannelConnections('#foo');
+    expect(conns.size).toBe(2);
+    expect(conns.get('c1')?.nick).toBe('alice');
+    expect(conns.get('c2')?.nick).toBe('bob');
+  });
+
+  it('returns an empty map for an unknown channel', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    expect(await rt.getChannelConnections('#nope')).toEqual(new Map());
+  });
+
+  it('skips members whose connection is no longer tracked', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    rt.registerConnection(makeConn('c1', 'alice'), { send: () => {}, disconnect: () => {} });
+    // c2 is referenced by a membership but was never registered (and c1's
+    // registration is dropped mid-test to exercise the filter branch).
+    await rt.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
+    });
+
+    const conns = await rt.getChannelConnections('#foo');
+    expect(conns.size).toBe(1);
+    expect(conns.get('c1')?.nick).toBe('alice');
+    expect(conns.has('c2')).toBe(false);
+  });
+});
+
+describe('InMemoryRuntime — listChannels', () => {
+  it('returns an empty array when no channels exist', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    expect(await rt.listChannels()).toEqual([]);
+  });
+
+  it('returns a snapshot per channel, preserving original casing', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    await rt.applyChannelDelta('#Foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    await rt.applyChannelDelta('#bar', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+
+    const list = await rt.listChannels();
+    expect(list).toHaveLength(2);
+    const names = list.map((c) => c.name).sort();
+    expect(names).toEqual(['#Foo', '#bar']);
+  });
+});
+
 describe('InMemoryRuntime — send', () => {
   it('delivers lines to the target connection send handler', async () => {
     const sent: RawLine[][] = [];
@@ -430,6 +545,28 @@ describe('InMemoryRuntime — sendToNick', () => {
     const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
     await expect(rt.sendToNick('ghost', 'c1', [L('hi')], [L('401')])).resolves.toBeUndefined();
   });
+
+  it('falls through to notFoundLines when the owner nick is registered but its connection is gone', async () => {
+    // Covers the stale-nick defensive branch in sendToNick: `this.nicks`
+    // still maps the nick to a connId, but that conn is no longer tracked
+    // (unregisterConnection deletes the conn without releasing its nick —
+    // the comment on unregisterConnection documents this split).
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const senderOut: RawLine[][] = [];
+    rt.registerConnection(makeConn('c1', 'alice'), { send: () => {}, disconnect: () => {} });
+    rt.registerConnection(makeConn('c2', 'bob'), {
+      send: (lines) => {
+        senderOut.push(lines);
+      },
+      disconnect: () => {},
+    });
+    await rt.reserveNick('alice', 'c1');
+    // Remove c1 from the connection map while leaving the nick mapping intact.
+    rt.unregisterConnection('c1');
+
+    await rt.sendToNick('alice', 'c2', [L('hi')], [L('401 bob alice :No such nick')]);
+    expect(senderOut).toEqual([[{ text: '401 bob alice :No such nick' }]]);
+  });
 });
 
 describe('InMemoryRuntime — disconnect', () => {
@@ -634,3 +771,125 @@ describe('InMemoryRuntime — admission gate', () => {
     }
   });
 });
+
+describe('InMemoryRuntime — reloadConfig (REHASH)', () => {
+  const baseConfig: ServerConfig = {
+    serverName: 'irc.example.com',
+    networkName: 'ExampleNet',
+    maxChannelsPerUser: 30,
+    maxTargetsPerCommand: 10,
+    maxListEntries: 50,
+    nickLen: 30,
+    channelLen: 50,
+    topicLen: 390,
+    quitMessage: 'Client Quit',
+  };
+
+  it('re-invokes the bound loader and returns the fresh config', async () => {
+    let version = 1;
+    const rt = new InMemoryRuntime({
+      clock: new FakeClock(0),
+      configLoader: async () => ({ ...baseConfig, serverName: `v${version}.example.com` }),
+    });
+
+    const first = await rt.reloadConfig();
+    expect(first.serverName).toBe('v1.example.com');
+    version = 2;
+    const second = await rt.reloadConfig();
+    expect(second.serverName).toBe('v2.example.com');
+  });
+
+  it('propagates a loader rejection so the actor can apply the graceful failure path', async () => {
+    const rt = new InMemoryRuntime({
+      clock: new FakeClock(0),
+      configLoader: async () => {
+        throw new Error('store unreachable');
+      },
+    });
+
+    await expect(rt.reloadConfig()).rejects.toThrow('store unreachable');
+  });
+
+  it('rejects when no loader was bound at construction', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+
+    await expect(rt.reloadConfig()).rejects.toThrow('no config loader bound');
+  });
+});
+
+describe('InMemoryRuntime — broadcastWallops', () => {
+  it('delivers lines to every connection with the +w user mode set', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const received: Record<string, RawLine[][]> = { c1: [], c2: [], c3: [] };
+    const push = (id: string) => (lines: RawLine[]) => received[id]?.push(lines);
+    // c1 has NO +w; c2 and c3 do.
+    rt.registerConnection(makeConn('c1', 'alice'), { send: push('c1'), disconnect: () => {} });
+    const c2 = makeConn('c2', 'bob');
+    c2.userModes.wallops = true;
+    rt.registerConnection(c2, { send: push('c2'), disconnect: () => {} });
+    const c3 = makeConn('c3', 'carol');
+    c3.userModes.wallops = true;
+    rt.registerConnection(c3, { send: push('c3'), disconnect: () => {} });
+
+    await rt.broadcastWallops([L(':alice WALLOPS :reboot')]);
+
+    // c1 has no +w → no delivery.
+    expect(received.c1).toHaveLength(0);
+    expect(received.c2).toHaveLength(1);
+    expect(received.c3).toHaveLength(1);
+  });
+
+  it('skips the except connection even when it has +w', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const received: Record<string, RawLine[][]> = { c1: [], c2: [] };
+    const push = (id: string) => (lines: RawLine[]) => received[id]?.push(lines);
+    const oper = makeConn('c1', 'alice');
+    oper.userModes.wallops = true;
+    oper.userModes.oper = true;
+    rt.registerConnection(oper, { send: push('c1'), disconnect: () => {} });
+    const listener = makeConn('c2', 'bob');
+    listener.userModes.wallops = true;
+    rt.registerConnection(listener, { send: push('c2'), disconnect: () => {} });
+
+    await rt.broadcastWallops([L(':alice WALLOPS :hi')], 'c1');
+
+    // The oper (except) never receives their own wallops; the +w peer does.
+    expect(received.c1).toHaveLength(0);
+    expect(received.c2).toHaveLength(1);
+  });
+
+  it('does not deliver to +w connections that have unregistered', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    let c2Received = 0;
+    rt.registerConnection(makeConn('c1', 'alice'), {
+      send: () => {},
+      disconnect: () => {},
+    });
+    const c2 = makeConn('c2', 'bob');
+    c2.userModes.wallops = true;
+    rt.registerConnection(c2, {
+      send: () => {
+        c2Received++;
+      },
+      disconnect: () => {},
+    });
+
+    rt.unregisterConnection('c2');
+    await rt.broadcastWallops([L(':alice WALLOPS :hi')]);
+    expect(c2Received).toBe(0);
+  });
+
+  it('is a no-op when no connection has +w', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    let c1Received = 0;
+    rt.registerConnection(makeConn('c1', 'alice'), {
+      send: () => {
+        c1Received++;
+      },
+      disconnect: () => {},
+    });
+
+    await rt.broadcastWallops([L(':a WALLOPS :hi')]);
+    expect(c1Received).toBe(0);
+  });
+});

package/packages/irc-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-core",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "private": true,
   "description": "Platform-agnostic IRC protocol core: parser, serializer, command reducers, state shapes",
   "license": "BSD-3-Clause",