serverless-ircd 0.5.0 → 0.7.0

package/packages/aws-adapter/tests/message-store.test.ts

@@ -7,7 +7,8 @@
  * store (record → query round-trip) without needing DynamoDB Local.
  */
 
-import { DEFAULT_SERVER_CONFIG, type StoredMessage } from '@serverless-ircd/irc-core';
+import type { StoredMessage } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { describe, expect, it } from 'vitest';
 import { bindMessageStore } from '../src/message-store.js';
 
@@ -26,7 +27,7 @@ function sampleMessage(chan: string, text: string): StoredMessage {
 
 describe('bindMessageStore', () => {
   it('returns a store that records and replays a message via LATEST', () => {
-    const store = bindMessageStore(DEFAULT_SERVER_CONFIG);
+    const store = bindMessageStore(makeTestServerConfig());
     store.record(sampleMessage('#aws', 'hello aws'));
 
     const result = store.query({ chan: '#aws', direction: 'latest', limit: 10 });
@@ -35,7 +36,7 @@ describe('bindMessageStore', () => {
   });
 
   it('returns a store scoped per channel (no cross-channel leak)', () => {
-    const store = bindMessageStore(DEFAULT_SERVER_CONFIG);
+    const store = bindMessageStore(makeTestServerConfig());
     store.record(sampleMessage('#a', 'in a'));
     store.record(sampleMessage('#b', 'in b'));
 
@@ -45,8 +46,8 @@ describe('bindMessageStore', () => {
   });
 
   it('returns an independent store instance per call', () => {
-    const a = bindMessageStore(DEFAULT_SERVER_CONFIG);
-    const b = bindMessageStore(DEFAULT_SERVER_CONFIG);
+    const a = bindMessageStore(makeTestServerConfig());
+    const b = bindMessageStore(makeTestServerConfig());
     a.record(sampleMessage('#aws', 'only in a'));
 
     expect(a.query({ chan: '#aws', direction: 'latest', limit: 10 })).toHaveLength(1);

package/packages/aws-adapter/tests/nlb-stream.test.ts

@@ -9,11 +9,8 @@
  */
 
 import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
-import {
-  DEFAULT_SERVER_CONFIG,
-  type ParsedServerConfig,
-  StaticMotdProvider,
-} from '@serverless-ircd/irc-core';
+import { type ParsedServerConfig, StaticMotdProvider } from '@serverless-ircd/irc-core';
+import { makeTestServerConfig } from '@serverless-ircd/irc-test-support';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { AwsRuntime } from '../src/aws-runtime.js';
 import type { PostToConnection } from '../src/aws-runtime.js';
@@ -30,12 +27,11 @@ import type { TablesConfig } from '../src/tables.js';
 const available = process.env.DDB_AVAILABLE === '1';
 const endpoint = process.env.DYNAMO_ENDPOINT;
 
-const SERVER_CONFIG: ParsedServerConfig = {
-  ...DEFAULT_SERVER_CONFIG,
+const SERVER_CONFIG: ParsedServerConfig = makeTestServerConfig({
   serverName: 'irc.example.com',
   networkName: 'ExampleNet',
   motdLines: ['Welcome to the test IRC server.'],
-};
+});
 
 const MOTD = new StaticMotdProvider(SERVER_CONFIG.motdLines);
 
@@ -461,6 +457,62 @@ describe.skipIf(!available)('NLB stream handler — streaming back', () => {
     });
     expect(bSink.some((l) => l.includes('PRIVMSG #room :hello from alice'))).toBe(true);
   });
+
+  it('refreshChannel tolerates an empty channel snapshot without throwing', async () => {
+    // After the last member PARTs, the channel meta row persists but
+    // queryMembers returns no rows → snap.members.size === 0. The next
+    // frame referencing the channel triggers refreshChannel on the
+    // empty-members + existing-cache path. This test ensures that path
+    // does not throw and the channel remains usable for a re-JOIN.
+    const f = requireFx();
+    const opts = () => ({
+      dynamo: f.client,
+      tables: f.tables,
+      serverConfig: SERVER_CONFIG,
+      motd: MOTD,
+      messages: bindMessageStore(SERVER_CONFIG),
+      managementApi: f.mgmt,
+    });
+    const a = deriveNlbConnectionId('10.0.0.40', '50040');
+    f.mgmt.register(a, () => {});
+    // Register + JOIN + PART → cache populated then snapshot empty.
+    await handleNlbStream(nlbEvent('10.0.0.40', '50040', ''), opts());
+    await handleNlbStream(
+      nlbEvent('10.0.0.40', '50040', 'NICK alice\r\nUSER alice 0 * :Alice\r\nJOIN #nlbempty\r\n'),
+      opts(),
+    );
+    await handleNlbStream(nlbEvent('10.0.0.40', '50040', 'PART #nlbempty\r\n'), opts());
+    // Re-JOIN hits refreshChannel on the empty-members path; must not throw.
+    const res = await handleNlbStream(nlbEvent('10.0.0.40', '50040', 'JOIN #nlbempty\r\n'), opts());
+    expect(res.statusCode).toBe(200);
+  });
+
+  it('falls back to "unknown"/"0" when NLB headers are absent', async () => {
+    // `readHeader` returns undefined when no header key matches. The
+    // caller's `?? 'unknown'` / `?? '0'` fallbacks must apply so the
+    // handler does not crash on a malformed event (defensive).
+    const f = requireFx();
+    const eventWithoutHeaders: NlbStreamEvent = {
+      requestContext: {
+        elb: { targetGroupArn: 'arn:aws:elasticloadbalancing:::targetgroup/test' },
+      },
+      version: '2.0',
+      body: Buffer.from('PING :tok\r\n', 'utf8').toString('base64'),
+      isBase64Encoded: true,
+      headers: { 'some-other-header': 'value' },
+    };
+    const res = await handleNlbStream(eventWithoutHeaders, {
+      dynamo: f.client,
+      tables: f.tables,
+      serverConfig: SERVER_CONFIG,
+      motd: MOTD,
+      messages: bindMessageStore(SERVER_CONFIG),
+      managementApi: f.mgmt,
+    });
+    expect(res.statusCode).toBe(200);
+    // The fallback id (nlb-unknown-0) still received a PONG.
+    expect(res.body).toBeDefined();
+  });
 });
 
 /**

package/packages/cf-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/cf-adapter",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "private": true,
   "description": "Cloudflare Workers adapter: Durable Objects (ConnectionDO, RegistryDO, ChannelDO) and CfRuntime implementing IrcRuntime",
   "license": "BSD-3-Clause",
@@ -35,6 +35,7 @@
     "@cloudflare/workers-types": "^5.20260714.1",
     "@serverless-ircd/in-memory-runtime": "workspace:*",
     "@serverless-ircd/irc-test-support": "workspace:*",
+    "@vitest/coverage-istanbul": "^4.1.0",
     "@vitest/coverage-v8": "^4.1.0",
     "rimraf": "^6.0.0",
     "typescript": "^5.6.0",

package/packages/cf-adapter/src/connection-do.ts

@@ -466,6 +466,9 @@ export class ConnectionDO extends DurableObject<Env> {
       // deployment-wide uptime, tracked as future work.
       stats: new CfStats(runtime, WORKER_STARTUP_AT),
       transport: makeWsFrameTransport(mode),
+      // Cloudflare terminates TLS at the edge before the WebSocket reaches
+      // the DO, so every WS connection is secure → user mode `S`.
+      secure: true,
       ...(accounts !== undefined ? { accounts } : {}),
       ...(mtlsIdentity !== undefined ? { mtlsIdentity } : {}),
       logger,

package/packages/cf-adapter/src/serialize.ts

@@ -34,6 +34,13 @@ export interface PersistedConnectionState {
   id: string;
   registration: RegistrationState;
   capNegotiating: boolean;
+  /**
+   * Transport TLS fact (user mode `S`). Optional on the persisted shape so
+   * records written before the field shipped (schema is otherwise
+   * unchanged) deserialize with a `false` default via the coalescing in
+   * {@link deserialize}. Always written by {@link serialize}.
+   */
+  secure?: boolean;
   caps: string[];
   joinedChannels: ChanName[];
   userModes: UserModes;
@@ -61,6 +68,7 @@ export function serialize(state: ConnectionState): PersistedConnectionState {
     id: state.id,
     registration: state.registration,
     capNegotiating: state.capNegotiating,
+    secure: state.secure,
     caps: [...state.caps],
     joinedChannels: [...state.joinedChannels],
     userModes: { ...state.userModes },
@@ -88,6 +96,9 @@ export function deserialize(record: unknown): ConnectionState {
     id: migrated.id,
     registration: migrated.registration,
     capNegotiating: migrated.capNegotiating,
+    // `secure` is absent on records persisted before user mode `S` shipped;
+    // `migrate` backfills it to false so the cast below is truthful.
+    secure: migrated.secure ?? false,
     caps: new Set<string>(migrated.caps),
     joinedChannels: new Set<ChanName>(migrated.joinedChannels),
     userModes: { ...migrated.userModes },
@@ -119,8 +130,19 @@ export function migrate(record: unknown): PersistedConnectionState {
   if (!isPlainObject(record)) {
     throw new Error('persisted connection state is not an object');
   }
+  // Backfill additive fields introduced by user mode `S` (TLS connected):
+  // `secure` and `userModes.tls`. Both default to false (plain transport),
+  // preserving the pre-feature behaviour for records persisted before the
+  // mode shipped. The schema version is unchanged because the additions are
+  // purely additive with safe defaults — no row transformation is needed
+  // beyond coalescing the missing keys.
+  if (record.secure === undefined) record.secure = false;
+  if (isPlainObject(record.userModes)) {
+    const um = record.userModes as Record<string, unknown>;
+    if (um.tls === undefined) um.tls = false;
+  }
   const version = typeof record.version === 'number' ? record.version : 0;
-  // No migrations yet — v1 is the initial schema. Future work adds steps:
+  // No versioned migrations yet — v1 is the initial schema. Future work:
   //   if (version < 2) record = migrate_v1_v2(record);
   //   if (version < 3) record = migrate_v2_v3(record);
   if (version > PERSISTED_STATE_VERSION) {
@@ -131,9 +153,8 @@ export function migrate(record: unknown): PersistedConnectionState {
   }
   // The cast below is safe: we accept any JSON shape the storage layer
   // returns; production code wrote it via `serialize`, tests wrote it
-  // through the same path. If a future field is missing, the
-  // `exactOptionalPropertyTypes` discipline in `serialize` keeps
-  // undefined keys out of the persisted record entirely.
+  // through the same path. Backfilling above keeps the additive
+  // `secure` / `userModes.tls` keys present even on pre-feature records.
   return record as unknown as PersistedConnectionState;
 }
 

package/packages/cf-adapter/tests/cf-harness.ts

@@ -119,7 +119,18 @@ class CfHarness implements IrcHarness {
     if (opts?.nick !== undefined) {
       await client.send(`NICK ${opts.nick}`);
       await client.send(`USER ${opts.nick} 0 * :${opts.nick}`);
-      await client.waitForNumeric('001', DEFAULT_TIMEOUT_MS);
+      // Wait for the FULL registration block, not just 001. Unlike the
+      // in-memory runtime (where the whole welcome fires synchronously
+      // inside `send`), CF delivers the 001..376 lines asynchronously
+      // through the WebSocket. Returning on 001 leaves 002..376 in flight,
+      // which can pollute `received` after a test calls `received.length = 0`
+      // and trip "no numeric" assertions on slow/loaded runners. The
+      // MOTD tailer (376 RPL_ENDOFMOTD, or 422 ERR_NOMOTD when no MOTD is
+      // configured) is the last frame of the registration burst.
+      await client.waitForLine(
+        (l) => numericEquals(l, '376') || numericEquals(l, '422'),
+        DEFAULT_TIMEOUT_MS,
+      );
       this.nicks.set(opts.nick.toLowerCase(), client);
     }
 

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

@@ -652,3 +652,272 @@ describe('CfRuntime — reloadConfig (REHASH)', () => {
     await expect(rt.reloadConfig()).rejects.toThrow(/networkName/u);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Tests — broadcastWallops (global +w fan-out across every registry shard)
+// ---------------------------------------------------------------------------
+
+/**
+ * Opens a ConnectionDO, registers it with the given nick, and optionally
+ * flips user mode `w` on via a direct state mutation (avoids driving the
+ * full MODE handshake through the actor). Returns the live WebSocket and
+ * the connection's canonical hex id.
+ */
+async function openWallopsCapableConn(
+  name: string,
+  opts: { wallops: boolean },
+): Promise<{ ws: WebSocket; hexId: string; received: string[] }> {
+  const ws = await openConnection(name);
+  await new Promise<void>((r) => setTimeout(r, 20));
+  ws.send(`NICK ${name}\r\n`);
+  ws.send(`USER ${name} 0 * :${name}\r\n`);
+  // Drain the registration numerics so they don't interfere with the
+  // assertions on wallops delivery below.
+  await new Promise<void>((r) => setTimeout(r, 100));
+
+  const hexId = await getConnectionHexId(name);
+  const received = drainSocket(ws);
+
+  if (opts.wallops) {
+    // Flip the +w mode directly on the live cached state. The DO is the
+    // authority for this state; broadcastWallops reads it back via
+    // getConnState() so what we mutate here is exactly what the fan-out
+    // will see.
+    const stub = env.CONNECTION_DO.get(env.CONNECTION_DO.idFromString(hexId));
+    await runInDurableObject(stub, async (instance: unknown) => {
+      const doi = instance as {
+        __peekState?: () => Promise<
+          import('@serverless-ircd/irc-core').ConnectionState | undefined
+        >;
+        __pokeState?: (s: import('@serverless-ircd/irc-core').ConnectionState) => void;
+      };
+      const state = await doi.__peekState?.();
+      if (state !== undefined) state.userModes.wallops = true;
+    });
+  }
+
+  // Reserve the nick in the REAL registry under its hex id so
+  // broadcastWallops' shard walk finds it.
+  await reserveNickInRealRegistry(name, hexId);
+
+  return { ws, hexId, received };
+}
+
+describe('CfRuntime — broadcastWallops', () => {
+  it('delivers to every +w connection enumerated across all registry shards', async () => {
+    const realEnv = envWithRealDOs();
+
+    const a = await openWallopsCapableConn('wallops-a', { wallops: true });
+    const b = await openWallopsCapableConn('wallops-b', { wallops: true });
+    // A connection without +w must not receive the wallops.
+    const plain = await openWallopsCapableConn('wallops-plain', { wallops: false });
+
+    const rt = new CfRuntime(realEnv, 'conn-wallops-sender', recordingHandlers());
+    await rt.broadcastWallops([{ text: ':oper!u@h WALLOPS :hi fleet' }]);
+
+    await new Promise<void>((resolve) => {
+      const deadline = Date.now() + 1500;
+      const tick = (): void => {
+        const aGot = a.received.some((l) => l.includes('hi fleet'));
+        const bGot = b.received.some((l) => l.includes('hi fleet'));
+        if (aGot && bGot && Date.now() > deadline - 1000) {
+          resolve();
+          return;
+        }
+        if (Date.now() > deadline) {
+          resolve();
+          return;
+        }
+        setTimeout(tick, 20);
+      };
+      tick();
+    });
+
+    expect(a.received.some((l) => l.includes('hi fleet'))).toBe(true);
+    expect(b.received.some((l) => l.includes('hi fleet'))).toBe(true);
+    expect(plain.received.some((l) => l.includes('hi fleet'))).toBe(false);
+
+    a.ws.close();
+    b.ws.close();
+    plain.ws.close();
+  });
+
+  it('skips the excepted originator', async () => {
+    const realEnv = envWithRealDOs();
+    const sender = await openWallopsCapableConn('wallops-except-sender', { wallops: true });
+    const other = await openWallopsCapableConn('wallops-except-other', { wallops: true });
+
+    const rt = new CfRuntime(realEnv, sender.hexId, recordingHandlers());
+    await rt.broadcastWallops([{ text: ':oper!u@h WALLOPS :except me' }], sender.hexId);
+
+    await new Promise<void>((resolve) => {
+      const deadline = Date.now() + 1000;
+      const tick = (): void => {
+        if (other.received.some((l) => l.includes('except me'))) {
+          resolve();
+          return;
+        }
+        if (Date.now() > deadline) {
+          resolve();
+          return;
+        }
+        setTimeout(tick, 20);
+      };
+      tick();
+    });
+
+    expect(other.received.some((l) => l.includes('except me'))).toBe(true);
+    expect(sender.received.some((l) => l.includes('except me'))).toBe(false);
+
+    sender.ws.close();
+    other.ws.close();
+  });
+
+  it('is a no-op when the registry has no entries', async () => {
+    const realEnv = envWithRealDOs();
+    const handlers = recordingHandlers();
+    const rt = new CfRuntime(realEnv, 'conn-wallops-empty', handlers);
+    // Fresh storage (afterEach reset); no nick reservations anywhere.
+    await expect(
+      rt.broadcastWallops([{ text: ':oper!u@h WALLOPS :nobody' }]),
+    ).resolves.toBeUndefined();
+    expect(handlers.sent).toEqual([]);
+  });
+
+  it('skips a connection whose persisted state is null without throwing', async () => {
+    // Reserve a nick pointing at a hex id whose ConnectionDO has no
+    // live state. `newUniqueId()` gives us a valid 64-hex DO id that
+    // is guaranteed not to collide with any connection we open here.
+    const realEnv = envWithRealDOs();
+    const ghostHex = env.CONNECTION_DO.newUniqueId().toString();
+    await reserveNickInRealRegistry('wallops-ghost', ghostHex);
+
+    const other = await openWallopsCapableConn('wallops-alongside-ghost', { wallops: true });
+
+    const rt = new CfRuntime(realEnv, 'conn-wallops-ghost-caller', recordingHandlers());
+    // Must not reject even though one enumerated conn reports null state.
+    await expect(
+      rt.broadcastWallops([{ text: ':oper!u@h WALLOPS :ghost friendly' }]),
+    ).resolves.toBeUndefined();
+
+    await new Promise<void>((resolve) => {
+      const deadline = Date.now() + 1000;
+      const tick = (): void => {
+        if (other.received.some((l) => l.includes('ghost friendly'))) {
+          resolve();
+          return;
+        }
+        if (Date.now() > deadline) {
+          resolve();
+          return;
+        }
+        setTimeout(tick, 20);
+      };
+      tick();
+    });
+    expect(other.received.some((l) => l.includes('ghost friendly'))).toBe(true);
+
+    other.ws.close();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — changeNick shard routing + failure paths
+// ---------------------------------------------------------------------------
+
+describe('CfRuntime — changeNick shard routing', () => {
+  it('uses the single-shard RegistryDO.changeNick when old and new hash to the same shard', async () => {
+    // Pin registryShards to 1 so every nick routes to shard 0 — the
+    // same-shard branch in CfRuntime.changeNick is taken.
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-sameshard', recordingHandlers(), {
+      registryShards: 1,
+    });
+    expect(await rt.reserveNick('sn-old', 'conn-sameshard')).toEqual({ ok: true });
+
+    const ok = await rt.changeNick('conn-sameshard', 'sn-old', 'sn-new');
+    expect(ok).toBe(true);
+
+    // Look up under the same shard count the runtime used (1).
+    const key = registryKeyForNick('sn-new', 1);
+    const newOwner = (
+      (await env.REGISTRY_DO_REAL.get(
+        env.REGISTRY_DO_REAL.idFromName(key),
+      )) as unknown as RegistryRpc
+    ).lookupNick('sn-new');
+    expect(await newOwner).toBe('conn-sameshard');
+    const oldKey = registryKeyForNick('sn-old', 1);
+    const oldOwner = (
+      (await env.REGISTRY_DO_REAL.get(
+        env.REGISTRY_DO_REAL.idFromName(oldKey),
+      )) as unknown as RegistryRpc
+    ).lookupNick('sn-old');
+    expect(await oldOwner).toBeNull();
+  });
+
+  it('two-phase path returns false when the new nick is already taken cross-shard', async () => {
+    // Default shard count (32). Reserve `wn-taken` by another conn first,
+    // then attempt to changeNick to it from a different conn.
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-newowner', recordingHandlers());
+    expect(await rt.reserveNick('wn-current', 'conn-newowner')).toEqual({ ok: true });
+    expect(await rt.reserveNick('wn-taken', 'conn-someoneelse')).toEqual({ ok: true });
+
+    const ok = await rt.changeNick('conn-newowner', 'wn-current', 'wn-taken');
+    expect(ok).toBe(false);
+    // Old nick untouched because the reserve-new phase failed.
+    expect(await registryForNick(realEnv, 'wn-current').lookupNick('wn-current')).toBe(
+      'conn-newowner',
+    );
+    expect(await registryForNick(realEnv, 'wn-taken').lookupNick('wn-taken')).toBe(
+      'conn-someoneelse',
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests — getConnection / getChannelConnections edge cases
+// ---------------------------------------------------------------------------
+
+describe('CfRuntime — getConnection and getChannelConnections branches', () => {
+  it('getConnection(this.connId) returns the live snapshot via handlers', async () => {
+    const stubEnv = envWithChannelStub();
+    const state = createConnection({ id: 'conn-getc-self', connectedSince: 0 });
+    state.nick = 'self';
+    const handlers: CfConnectionHandlers = {
+      send: (): void => {},
+      disconnect: (): void => {},
+      snapshot: () => state,
+    };
+    const rt = new CfRuntime(stubEnv, 'conn-getc-self', handlers);
+    const conn = await rt.getConnection('conn-getc-self');
+    expect(conn).not.toBeNull();
+    expect(conn?.nick).toBe('self');
+  });
+
+  it('getConnection(this.connId) returns null when handlers.snapshot is undefined', async () => {
+    const stubEnv = envWithChannelStub();
+    const rt = new CfRuntime(stubEnv, 'conn-getc-empty', recordingHandlers());
+    expect(await rt.getConnection('conn-getc-empty')).toBeNull();
+  });
+
+  it('getChannelConnections returns every member that reports a persisted state', async () => {
+    // A channel roster with one real member; the ConnectionDO is the
+    // authority for each member's state. getChannelConnections fans out
+    // one getConnState RPC per member and collects the results.
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-gcc-caller', recordingHandlers());
+
+    const member = await openWallopsCapableConn('gcc-real', { wallops: false });
+
+    await rt.applyChannelDelta('#gcc', {
+      memberships: [{ type: 'add' as const, conn: member.hexId, nick: 'gcc-real' }],
+    });
+
+    const conns = await rt.getChannelConnections('#gcc');
+    expect(conns.size).toBe(1);
+    expect(conns.get(member.hexId)?.nick).toBe('gcc-real');
+
+    member.ws.close();
+  });
+});

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

@@ -478,3 +478,120 @@ describe('ChannelDO — scale', () => {
     expect(snapAfter?.members.length).toBe(0);
   }, 15_000);
 });
+
+// ---------------------------------------------------------------------------
+// Edge cases — empty-lines broadcast, cache reload, test hooks
+// ---------------------------------------------------------------------------
+
+describe('ChannelDO — broadcast + cache edge cases', () => {
+  it('broadcast is a no-op for an empty lines array', async () => {
+    const chan = '#empty-bcast';
+    await channel(chan.toLowerCase()).applyChannelDelta({
+      memberships: [{ type: 'add' as const, conn: 'ghost', nick: 'g' }],
+    });
+    // Must not reject and must not prune members (no fan-out attempted).
+    await expect(channel(chan.toLowerCase()).broadcast([])).resolves.toBeUndefined();
+    const snap = await channel(chan.toLowerCase()).getChannelSnapshot();
+    expect(snap?.members.length).toBe(1);
+  });
+
+  it('reloads persisted state from storage after __resetCache (deserializeChannel)', async () => {
+    // Mutate the channel, drop the in-memory cache, then read again.
+    // The read must go through deserializeChannel to rebuild Map/Set
+    // fields from the JSON-friendly persisted shape.
+    const chan = '#cache-reload';
+    const lower = chan.toLowerCase();
+    await channel(lower).applyChannelDelta({
+      memberships: [{ type: 'add' as const, conn: 'c-1', nick: 'alice' }],
+      topic: { text: 'hello topic', setter: 'alice', setAt: 100 },
+    });
+
+    // Drop the cache so the next read forces a storage reload.
+    await runInDurableObject(channelStub(lower), (instance: unknown) => {
+      const doi = instance as { __resetCache?: () => void };
+      doi.__resetCache?.();
+    });
+
+    const snap = await channel(lower).getChannelSnapshot();
+    expect(snap?.members.length).toBe(1);
+    expect(snap?.members[0]?.nick).toBe('alice');
+    expect(snap?.topic?.text).toBe('hello topic');
+  });
+
+  it('__peekState returns the live cached state before any reload', async () => {
+    const lower = '#peek-state';
+    await channel(lower).applyChannelDelta({
+      memberships: [{ type: 'add' as const, conn: 'c-peek', nick: 'peeker' }],
+    });
+    const cached = await runInDurableObject(channelStub(lower), async (instance: unknown) => {
+      const doi = instance as { __peekState?: () => Promise<unknown> };
+      return doi.__peekState?.();
+    });
+    expect(cached).toBeDefined();
+    // The cached state's members Map carries the entry we just added.
+    const members = (cached as { members: Map<string, unknown> }).members;
+    expect(members.get('c-peek')).toBeDefined();
+  });
+
+  it('__resetCache clears the in-memory cache', async () => {
+    const lower = '#reset-cache';
+    await channel(lower).applyChannelDelta({
+      memberships: [{ type: 'add' as const, conn: 'c-reset', nick: 'resetter' }],
+    });
+
+    await runInDurableObject(channelStub(lower), (instance: unknown) => {
+      const doi = instance as { __resetCache?: () => void };
+      doi.__resetCache?.();
+    });
+
+    const cached = await runInDurableObject(channelStub(lower), async (instance: unknown) => {
+      const doi = instance as { __peekState?: () => Promise<unknown> };
+      return doi.__peekState?.();
+    });
+    expect(cached).toBeUndefined();
+  });
+
+  it('broadcast with all-live members does not prune the roster', async () => {
+    // When every member has an OPEN WebSocket, deliver returns > 0 for
+    // each and the `pruned.length > 0` else branch is taken (no prune
+    // delta applied).
+    const chan = '#no-prune';
+    const alice = await connectAndRegister('conn-noprune-alice', 'alice');
+    const bob = await connectAndRegister('conn-noprune-bob', 'bob');
+
+    await channel(chan.toLowerCase()).applyChannelDelta({
+      memberships: [
+        { type: 'add', conn: alice.id, nick: 'alice' },
+        { type: 'add', conn: bob.id, nick: 'bob' },
+      ],
+    });
+
+    await channel(chan.toLowerCase()).broadcast(['PRIVMSG #no-prune :hello']);
+    await alice.client.waitForMessage((l) => l.startsWith('PRIVMSG #no-prune'));
+    await bob.client.waitForMessage((l) => l.startsWith('PRIVMSG #no-prune'));
+
+    // Both members survive — no prune occurred.
+    const snap = await channel(chan.toLowerCase()).getChannelSnapshot();
+    expect(snap?.members.length).toBe(2);
+
+    await alice.client.close();
+    await bob.client.close();
+  });
+
+  it('sweep on a channel with all-live members prunes nobody', async () => {
+    const chan = '#sweep-clean';
+    const alice = await connectAndRegister('conn-sweep-uniq-001', 'sweepop');
+
+    await channel(chan.toLowerCase()).applyChannelDelta({
+      memberships: [{ type: 'add', conn: alice.id, nick: 'alice' }],
+    });
+
+    const pruned = await channel(chan.toLowerCase()).sweep();
+    expect(pruned).toBe(0);
+
+    const snap = await channel(chan.toLowerCase()).getChannelSnapshot();
+    expect(snap?.members.length).toBe(1);
+
+    await alice.client.close();
+  });
+});