serverless-ircd 0.3.0 → 0.5.0

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

@@ -0,0 +1,184 @@
+/**
+ * CF adapter — IRCv3 WebSocket subprotocol negotiation + per-message framing.
+ *
+ * Drives the real `ConnectionDO` through `cloudflare:test` (miniflare) so
+ * the `Sec-WebSocket-Protocol` round-trip, hibernation tags, and frame
+ * framing behave exactly as in production. Each test gets its own
+ * isolated storage namespace.
+ */
+
+import { env } from 'cloudflare:test';
+import { describe, expect, it } from 'vitest';
+
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      CONNECTION_DO: DurableObjectNamespace;
+      REGISTRY_DO: DurableObjectNamespace;
+      CHANNEL_DO: DurableObjectNamespace;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers — WebSocket client that records raw WS messages (not split lines).
+// ---------------------------------------------------------------------------
+
+class SpecWsClient {
+  /** Raw WebSocket messages exactly as delivered (one entry per WS message). */
+  readonly messages: string[] = [];
+  /** Lines split out of `messages` (tolerant of legacy `\r\n` framing). */
+  readonly lines: string[] = [];
+  readonly ws: WebSocket;
+  closedCode: number | undefined;
+
+  constructor(ws: WebSocket) {
+    this.ws = ws;
+    ws.addEventListener('message', (ev: MessageEvent) => {
+      const data = typeof ev.data === 'string' ? ev.data : new TextDecoder().decode(ev.data);
+      this.messages.push(data);
+      for (const line of data.split('\r\n')) {
+        if (line.length > 0) this.lines.push(line);
+      }
+    });
+    ws.addEventListener('close', (ev: CloseEvent) => {
+      this.closedCode = ev.code;
+    });
+  }
+
+  send(line: string): void {
+    this.ws.send(`${line}\r\n`);
+  }
+
+  waitForLine(predicate: (line: string) => boolean, timeoutMs = 2000): Promise<string> {
+    return new Promise<string>((resolve, reject) => {
+      const start = Date.now();
+      const tick = (): void => {
+        const hit = this.lines.find(predicate);
+        if (hit !== undefined) {
+          resolve(hit);
+          return;
+        }
+        if (Date.now() - start > timeoutMs) {
+          reject(new Error(`timeout waiting for line; got: ${JSON.stringify(this.lines)}`));
+          return;
+        }
+        setTimeout(tick, 20);
+      };
+      tick();
+    });
+  }
+
+  waitForClose(timeoutMs = 2000): Promise<number | undefined> {
+    return new Promise<number | undefined>((resolve, reject) => {
+      if (this.closedCode !== undefined) {
+        resolve(this.closedCode);
+        return;
+      }
+      const start = Date.now();
+      const tick = (): void => {
+        if (this.closedCode !== undefined) {
+          resolve(this.closedCode);
+          return;
+        }
+        if (Date.now() - start > timeoutMs) {
+          reject(
+            new Error(`timeout waiting for close; messages: ${JSON.stringify(this.messages)}`),
+          );
+          return;
+        }
+        setTimeout(tick, 20);
+      };
+      tick();
+    });
+  }
+}
+
+/**
+ * Opens a WebSocket to a fresh ConnectionDO, optionally offering a
+ * `Sec-WebSocket-Protocol` list. Returns the upgrade Response so the
+ * caller can assert on the echoed header, plus a ready-to-use client.
+ */
+async function openUpgrade(
+  connId: string,
+  protocols?: string,
+): Promise<{ response: Response; client: SpecWsClient }> {
+  const stub = env.CONNECTION_DO.get(env.CONNECTION_DO.idFromName(connId));
+  const headers: Record<string, string> = { Upgrade: 'websocket' };
+  if (protocols !== undefined) {
+    headers['Sec-WebSocket-Protocol'] = protocols;
+  }
+  const response = await stub.fetch('https://do/upgrade', { headers });
+  const ws = response.webSocket;
+  if (ws === undefined || ws === null) {
+    throw new Error('ConnectionDO.fetch did not return a WebSocket');
+  }
+  ws.accept();
+  const client = await new Promise<SpecWsClient>((resolve) => {
+    setTimeout(() => resolve(new SpecWsClient(ws as WebSocket)), 0);
+  });
+  return { response, client };
+}
+
+async function register(client: SpecWsClient, nick: string): Promise<void> {
+  client.send(`NICK ${nick}`);
+  client.send(`USER ${nick} 0 * :${nick}`);
+  await client.waitForLine((l) => l.includes(' 001 '));
+}
+
+// ---------------------------------------------------------------------------
+// Acceptance criteria
+// ---------------------------------------------------------------------------
+
+describe('ConnectionDO — IRCv3 WebSocket subprotocol negotiation', () => {
+  it('echoes text.ircv3.net back in the 101 response Sec-WebSocket-Protocol header', async () => {
+    const { response, client } = await openUpgrade('conn-subproto-text', 'text.ircv3.net');
+    expect(response.status).toBe(101);
+    expect(response.headers.get('Sec-WebSocket-Protocol')).toBe('text.ircv3.net');
+    client.ws.close();
+  });
+
+  it('selects the first-listed supported protocol when both are offered', async () => {
+    const a = await openUpgrade('conn-subproto-order-a', 'text.ircv3.net, binary.ircv3.net');
+    expect(a.response.headers.get('Sec-WebSocket-Protocol')).toBe('text.ircv3.net');
+    a.client.ws.close();
+
+    const b = await openUpgrade('conn-subproto-order-b', 'binary.ircv3.net, text.ircv3.net');
+    expect(b.response.headers.get('Sec-WebSocket-Protocol')).toBe('binary.ircv3.net');
+    b.client.ws.close();
+  });
+
+  it('omits Sec-WebSocket-Protocol when the client offers no supported protocol', async () => {
+    const { response, client } = await openUpgrade('conn-subproto-unsupported', 'bogus.proto');
+    expect(response.status).toBe(101);
+    expect(response.headers.get('Sec-WebSocket-Protocol')).toBeNull();
+    client.ws.close();
+  });
+
+  it('connects without a subprotocol offer (legacy mode) and registers', async () => {
+    const { client } = await openUpgrade('conn-subproto-legacy');
+    await register(client, 'legacy-alice');
+    expect(client.lines.some((l) => l.includes(' 001 '))).toBe(true);
+    client.ws.close();
+  });
+
+  it('delivers registration replies as N separate WS messages with no trailing CRLF (spec-text)', async () => {
+    const { client } = await openUpgrade('conn-subproto-permsg', 'text.ircv3.net');
+    client.send('NICK spec-bob');
+    client.send('USER spec-bob 0 * :spec-bob');
+    await client.waitForLine((l) => l.includes(' 001 '));
+
+    expect(client.messages.length).toBeGreaterThan(1);
+    for (const msg of client.messages) {
+      expect(msg.endsWith('\r\n')).toBe(false);
+    }
+    client.ws.close();
+  });
+
+  it('closes with code 1003 when a binary frame arrives on a spec-text connection', async () => {
+    const { client } = await openUpgrade('conn-subproto-bin-on-text', 'text.ircv3.net');
+    client.ws.send(new Uint8Array([0x4e, 0x49, 0x43, 0x4b]).buffer);
+    const code = await client.waitForClose();
+    expect(code).toBe(1003);
+  });
+});

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/d1-account-store.test.ts

@@ -0,0 +1,226 @@
+/**
+ * D1-backed SASL account store + precedence resolver.
+ *
+ * Exercises the real D1 round-trip via miniflare: `putAccountCredential`
+ * writes a hashed row, `loadD1AccountStore` reads it back, and
+ * `resolveAccountStore` applies the table-then-config precedence.
+ */
+
+import { env } from 'cloudflare:test';
+import { hashAccountCredential } from '@serverless-ircd/irc-core';
+import { beforeEach, describe, expect, it } from 'vitest';
+import {
+  buildAccountPutStatement,
+  loadD1AccountStore,
+  putAccountCredential,
+  resolveAccountStore,
+} from '../src/d1-account-store';
+
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      ACCOUNTS_DB: D1Database;
+    }
+  }
+}
+
+const CREATE_TABLE =
+  'CREATE TABLE IF NOT EXISTS accounts (account TEXT PRIMARY KEY, algorithm TEXT NOT NULL, salt TEXT NOT NULL, hash TEXT NOT NULL)';
+
+async function resetDb(): Promise<void> {
+  await env.ACCOUNTS_DB.exec('DROP TABLE IF EXISTS accounts');
+  await env.ACCOUNTS_DB.exec(CREATE_TABLE);
+}
+
+describe('loadD1AccountStore', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('returns undefined when the table has no rows', async () => {
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store).toBeUndefined();
+  });
+
+  it('verifies an account after a row is written via putAccountCredential', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'alice', 's3cret');
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store).toBeDefined();
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 's3cret' }),
+    ).toEqual({ ok: true, account: 'alice' });
+  });
+
+  it('rejects a wrong password after round-trip', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'alice', 'right');
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store).toBeDefined();
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'wrong' }).ok).toBe(
+      false,
+    );
+  });
+
+  it('loads multiple distinct accounts', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'alice', 'a1');
+    await putAccountCredential(env.ACCOUNTS_DB, 'bob', 'b2');
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store?.size).toBe(2);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'a1' }).ok).toBe(
+      true,
+    );
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'bob', password: 'b2' }).ok).toBe(
+      true,
+    );
+  });
+
+  it('overwrites an existing account on re-seed', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'alice', 'old');
+    await putAccountCredential(env.ACCOUNTS_DB, 'alice', 'new');
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store?.size).toBe(1);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'old' }).ok).toBe(
+      false,
+    );
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'new' }).ok).toBe(
+      true,
+    );
+  });
+
+  it('skips rows missing required columns', async () => {
+    // Use a permissive table (no NOT NULL) to simulate a row with a missing
+    // salt — the production schema's NOT NULL prevents this, but the loader
+    // stays defensive against schema drift / manual edits.
+    await env.ACCOUNTS_DB.exec('DROP TABLE accounts');
+    await env.ACCOUNTS_DB.exec(
+      'CREATE TABLE accounts (account TEXT PRIMARY KEY, algorithm TEXT, salt TEXT, hash TEXT)',
+    );
+    await env.ACCOUNTS_DB.prepare(
+      "INSERT INTO accounts (account, algorithm, hash) VALUES ('bad', 'scrypt', 'bbbb')",
+    ).run();
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store).toBeUndefined();
+  });
+});
+
+describe('putAccountCredential', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('writes a hashed row that round-trips through the store', async () => {
+    const entry = await putAccountCredential(env.ACCOUNTS_DB, 'carol', 'p@ss');
+    expect(entry.account).toBe('carol');
+    expect(entry.algorithm).toBe('scrypt');
+
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'carol', password: 'p@ss' })).toEqual({
+      ok: true,
+      account: 'carol',
+    });
+  });
+
+  it('never writes the plaintext password to the row', async () => {
+    const entry = await putAccountCredential(env.ACCOUNTS_DB, 'alice', 'hunter2-secret');
+    expect(entry.account).not.toContain('hunter2');
+    expect(entry.salt).not.toContain('hunter2');
+    expect(entry.hash).not.toContain('hunter2');
+  });
+
+  it('matches a manually-hashed entry written via raw D1 insert', async () => {
+    const hashed = hashAccountCredential('dave', 'pw');
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO accounts (account, algorithm, salt, hash) VALUES (?, ?, ?, ?)',
+    )
+      .bind(hashed.account, hashed.algorithm, hashed.salt, hashed.hash)
+      .run();
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'dave', password: 'pw' }).ok).toBe(
+      true,
+    );
+  });
+});
+
+describe('buildAccountPutStatement (seed SQL builder)', () => {
+  it('produces an INSERT OR REPLACE statement with scrypt-hashed values', () => {
+    const { entry, sql } = buildAccountPutStatement('alice', 's3cret');
+    expect(entry.account).toBe('alice');
+    expect(entry.algorithm).toBe('scrypt');
+    expect(sql).toContain('INSERT OR REPLACE INTO accounts');
+    // Plaintext must never appear in the SQL.
+    expect(sql).not.toContain('s3cret');
+  });
+
+  it('the generated SQL round-trips through loadD1AccountStore', async () => {
+    await resetDb();
+    const { sql } = buildAccountPutStatement('carol', 'p@ss');
+    await env.ACCOUNTS_DB.exec(sql);
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'carol', password: 'p@ss' })).toEqual({
+      ok: true,
+      account: 'carol',
+    });
+  });
+
+  it('escapes single quotes in the username to avoid breaking the SQL', async () => {
+    await resetDb();
+    const { sql } = buildAccountPutStatement("o'brien", 'pw');
+    await env.ACCOUNTS_DB.exec(sql);
+    const store = await loadD1AccountStore(env.ACCOUNTS_DB);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: "o'brien", password: 'pw' }).ok).toBe(
+      true,
+    );
+  });
+
+  it('escapes single quotes in the base64 hash output', () => {
+    // The hash is base64 so it won't contain quotes, but the escaper is
+    // still exercised — verify the SQL is well-formed.
+    const { sql } = buildAccountPutStatement('alice', 'secret');
+    // A valid INSERT with four quoted values.
+    expect(sql.match(/'/g)?.length).toBe(8);
+  });
+});
+
+describe('resolveAccountStore precedence', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('returns the D1 store when the table has rows (table wins)', async () => {
+    await putAccountCredential(env.ACCOUNTS_DB, 'alice', 'table-secret');
+    const store = await resolveAccountStore(env.ACCOUNTS_DB, 'envuser:env-secret');
+    expect(store).toBeDefined();
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'table-secret' }).ok,
+    ).toBe(true);
+    // Config account does NOT verify (table is authoritative).
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'envuser', password: 'env-secret' }).ok,
+    ).toBe(false);
+  });
+
+  it('falls back to the SASL_ACCOUNTS seed when the table is empty', async () => {
+    const store = await resolveAccountStore(env.ACCOUNTS_DB, 'envuser:env-secret');
+    expect(store).toBeDefined();
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'envuser', password: 'env-secret' }).ok,
+    ).toBe(true);
+  });
+
+  it('returns undefined when the table is empty and no seed is set', async () => {
+    const store = await resolveAccountStore(env.ACCOUNTS_DB, undefined);
+    expect(store).toBeUndefined();
+  });
+
+  it('returns undefined when the table is empty and the seed is blank', async () => {
+    const store = await resolveAccountStore(env.ACCOUNTS_DB, '');
+    expect(store).toBeUndefined();
+  });
+
+  it('falls back to the seed when the D1 binding is undefined', async () => {
+    const store = await resolveAccountStore(undefined, 'envuser:env-secret');
+    expect(store).toBeDefined();
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'envuser', password: 'env-secret' }).ok,
+    ).toBe(true);
+  });
+});

package/packages/cf-adapter/tests/raw-modules.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Ambient declaration so `?raw` imports (Vite's built-in transform that
+ * inlines a file's text at bundle time) typecheck under the strict
+ * `tsconfig.test.json`. Used by source-level regression guards that
+ * assert dead code stays removed.
+ */
+declare module '*?raw' {
+  const content: string;
+  // eslint-disable-next-line import/no-default-export
+  export default content;
+}

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';
@@ -25,7 +25,14 @@ import { RegistryDO } from '../../src/registry-do';
 import { RecordingChannelDO } from './stubs/channel-stub';
 import { RecordingRegistryDO } from './stubs/registry-stub';
 
-export { ChannelDO, ChannelRegistryDO, ConnectionDO, RegistryDO, RecordingRegistryDO, RecordingChannelDO };
+export {
+  ChannelDO,
+  ChannelRegistryDO,
+  ConnectionDO,
+  RegistryDO,
+  RecordingRegistryDO,
+  RecordingChannelDO,
+};
 
 export default {
   async fetch(): Promise<Response> {

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