serverless-ircd 0.4.0 → 0.5.0

package/packages/aws-adapter/tests/connect.test.ts

@@ -11,6 +11,7 @@ import { type DynamoDBDocumentClient, PutCommand, ScanCommand } from '@aws-sdk/l
 import { DEFAULT_SERVER_CONFIG } from '@serverless-ircd/irc-core';
 import { describe, expect, it } from 'vitest';
 import { handleConnect } from '../src/handlers/connect.js';
+import type { MarshalledConnection } from '../src/serialize.js';
 import type { TablesConfig } from '../src/tables.js';
 
 const TABLES: TablesConfig = {
@@ -24,12 +25,15 @@ const TABLES: TablesConfig = {
 interface Stub {
   dynamo: DynamoDBDocumentClient;
   puts: number;
+  /** Most recently PutCommand Item (undefined when no put happened). */
+  lastPutItem: Record<string, unknown> | undefined;
 }
 
 /** Builds a stub client that serves the supplied `Scan` pages in order. */
 function makeStub(pages: Array<Record<string, unknown>>): Stub {
   let scanIdx = 0;
   const calls = { puts: 0 };
+  let lastPutItem: Record<string, unknown> | undefined;
   const dynamo = {
     send: async (cmd: unknown) => {
       if (cmd instanceof ScanCommand) {
@@ -37,6 +41,7 @@ function makeStub(pages: Array<Record<string, unknown>>): Stub {
       }
       if (cmd instanceof PutCommand) {
         calls.puts++;
+        lastPutItem = cmd.input.Item as Record<string, unknown> | undefined;
         return {};
       }
       throw new Error('unexpected command');
@@ -47,6 +52,9 @@ function makeStub(pages: Array<Record<string, unknown>>): Stub {
     get puts() {
       return calls.puts;
     },
+    get lastPutItem() {
+      return lastPutItem;
+    },
   };
 }
 
@@ -60,7 +68,7 @@ describe('handleConnect admission plumbing', () => {
       now: 42,
       serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
     });
-    expect(outcome).toEqual({ admitted: true });
+    expect(outcome).toEqual({ admitted: true, subprotocol: null });
     expect(stub.puts).toBe(1);
   });
 
@@ -76,3 +84,91 @@ describe('handleConnect admission plumbing', () => {
     expect(stub.puts).toBe(0);
   });
 });
+
+describe('handleConnect — IRCv3 WebSocket subprotocol negotiation', () => {
+  it('selects binary.ircv3.net, echoes it, and persists a spec-binary mode row', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-binary',
+      now: 42,
+      secWebSocketProtocol: 'binary.ircv3.net',
+      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: 'binary.ircv3.net' });
+    expect(stub.puts).toBe(1);
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBe('spec-binary');
+  });
+
+  it('selects text.ircv3.net and persists a spec-text mode row', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-text',
+      now: 42,
+      secWebSocketProtocol: 'text.ircv3.net',
+      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: 'text.ircv3.net' });
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBe('spec-text');
+  });
+
+  it('honours client-preference order when both subprotocols are offered', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-pref',
+      now: 42,
+      secWebSocketProtocol: 'text.ircv3.net, binary.ircv3.net',
+      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: 'text.ircv3.net' });
+  });
+
+  it('falls back to legacy (null subprotocol, no mode column) when no offer is present', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-legacy',
+      now: 42,
+      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: null });
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBeUndefined();
+  });
+
+  it('falls back to legacy when only unsupported subprotocols are offered', async () => {
+    const stub = makeStub([{ Count: 0 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-unsupported',
+      now: 42,
+      secWebSocketProtocol: 'chat, superchat.v2',
+      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+    });
+    expect(outcome).toEqual({ admitted: true, subprotocol: null });
+    const item = stub.lastPutItem as MarshalledConnection | undefined;
+    expect(item?.wsMode).toBeUndefined();
+  });
+
+  it('does not negotiate a subprotocol when the admission gate rejects', async () => {
+    const stub = makeStub([{ Count: 5 }]);
+    const outcome = await handleConnect({
+      dynamo: stub.dynamo,
+      tables: TABLES,
+      connectionId: 'c-full',
+      secWebSocketProtocol: 'binary.ircv3.net',
+      serverConfig: { ...DEFAULT_SERVER_CONFIG, maxClients: 5 },
+    });
+    expect(outcome).toEqual({ admitted: false, statusCode: 429, reason: 'server full' });
+    expect(stub.puts).toBe(0);
+  });
+});

package/packages/aws-adapter/tests/handlers.test.ts

@@ -96,6 +96,9 @@ async function makeFixture(): Promise<Fixture> {
       motd: MOTD,
       messages: bindMessageStore(SERVER_CONFIG),
       managementApi: mgmt as never,
+      // Bind a REHASH reload source so the $default dispatch path exercises
+      // the configLoader wiring (and an oper's REHASH re-fetches config).
+      configLoader: async () => SERVER_CONFIG,
     },
     cleanup: async () => {
       for (const logical of Object.keys(TABLE_DEFS)) {
@@ -142,6 +145,27 @@ describe.skipIf(!available)('handlers', () => {
       expect(info?.registration).toBe('pre-registration');
     });
 
+    it('echoes the agreed Sec-WebSocket-Protocol header back on a spec-mode connect', async () => {
+      const res = await dispatch(
+        {
+          requestContext: { routeKey: '$connect', connectionId: 'c-sub' },
+          headers: { 'Sec-WebSocket-Protocol': 'text.ircv3.net' },
+        },
+        requireFx().deps,
+      );
+      expect(res.statusCode).toBe(200);
+      expect(res.headers?.['Sec-WebSocket-Protocol']).toBe('text.ircv3.net');
+    });
+
+    it('omits the Sec-WebSocket-Protocol header on a legacy connect', async () => {
+      const res = await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'c-nosub' } },
+        requireFx().deps,
+      );
+      expect(res.statusCode).toBe(200);
+      expect(res.headers?.['Sec-WebSocket-Protocol']).toBeUndefined();
+    });
+
     it('is idempotent on APIGW retry (same connectionId overwrites)', async () => {
       for (let i = 0; i < 2; i++) {
         await dispatch(
@@ -361,6 +385,95 @@ describe.skipIf(!available)('handlers', () => {
       expect(sink).toContain('PONG :tok');
     });
 
+    it('delivers each outbound line as its own postToConnection for a spec-mode connection', async () => {
+      await dispatch(
+        {
+          requestContext: { routeKey: '$connect', connectionId: 'spec1' },
+          headers: { 'Sec-WebSocket-Protocol': 'text.ircv3.net' },
+        },
+        requireFx().deps,
+      );
+      const calls: string[] = [];
+      requireFx().mgmt.register('spec1', (data) => {
+        calls.push(data);
+      });
+      // Spec clients send exactly one IRC message per WebSocket frame.
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec1' },
+          body: 'NICK bob\r\n',
+        },
+        requireFx().deps,
+      );
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec1' },
+          body: 'USER bob 0 * :Bob\r\n',
+        },
+        requireFx().deps,
+      );
+      // The welcome block is multiple IRC lines; the IRCv3 spec contract
+      // sends exactly one line per WebSocket message (no trailing CRLF).
+      expect(calls.length).toBeGreaterThan(1);
+      for (const data of calls) {
+        expect(data).not.toContain('\r\n');
+      }
+      expect(calls.some((d) => d.includes(' 001 '))).toBe(true);
+    });
+
+    it('delivers one postToConnection per line for a binary.ircv3.net connection', async () => {
+      await dispatch(
+        {
+          requestContext: { routeKey: '$connect', connectionId: 'spec2' },
+          headers: { 'Sec-WebSocket-Protocol': 'binary.ircv3.net' },
+        },
+        requireFx().deps,
+      );
+      const calls: string[] = [];
+      requireFx().mgmt.register('spec2', (data) => {
+        calls.push(data);
+      });
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec2' },
+          body: 'NICK binbob\r\n',
+        },
+        requireFx().deps,
+      );
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'spec2' },
+          body: 'USER binbob 0 * :BinBob\r\n',
+        },
+        requireFx().deps,
+      );
+      expect(calls.length).toBeGreaterThan(1);
+      for (const data of calls) {
+        expect(data).not.toContain('\r\n');
+      }
+    });
+
+    it('batches outbound lines into a single postToConnection for a legacy connection', async () => {
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'leg1' } },
+        requireFx().deps,
+      );
+      const calls: string[] = [];
+      requireFx().mgmt.register('leg1', (data) => {
+        calls.push(data);
+      });
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'leg1' },
+          body: 'NICK carol\r\nUSER carol 0 * :Carol\r\n',
+        },
+        requireFx().deps,
+      );
+      expect(calls.length).toBe(1);
+      expect(calls[0]).toContain('\r\n');
+      expect(calls[0]).toContain(' 001 ');
+    });
+
     it('persists joined channels across $default invocations', async () => {
       await dispatch(
         { requestContext: { routeKey: '$connect', connectionId: 'c1' } },
@@ -537,6 +650,41 @@ describe.skipIf(!available)('handlers', () => {
       // The 500-branch is covered indirectly by GoneException tests.
       expect(true).toBe(true);
     });
+
+    it('runs an oper REHASH through the bound configLoader and emits 382', async () => {
+      await dispatch(
+        { requestContext: { routeKey: '$connect', connectionId: 'rh1' } },
+        requireFx().deps,
+      );
+      const sink: string[] = [];
+      requireFx().mgmt.register('rh1', (data) => {
+        for (const line of data.split('\r\n')) {
+          if (line.length > 0) sink.push(line);
+        }
+      });
+      // Seed oper creds + a reload source so OPER then REHASH both succeed.
+      const depsWithOper: HandlerDeps = {
+        ...requireFx().deps,
+        serverConfig: { ...SERVER_CONFIG, operCreds: [{ user: 'alice', password: 's3cret' }] },
+        configLoader: async () => ({
+          ...SERVER_CONFIG,
+          operCreds: [{ user: 'alice', password: 'rotated' }],
+        }),
+      };
+      await dispatch(
+        {
+          requestContext: { routeKey: '$default', connectionId: 'rh1' },
+          body: 'NICK alice\r\nUSER alice 0 * :Alice\r\nOPER alice s3cret\r\nREHASH\r\n',
+        },
+        depsWithOper,
+      );
+
+      // 381 (oper) + 382 (rehashing from the Secrets Manager source) emitted.
+      expect(sink.some((l) => l.includes(' 381 '))).toBe(true);
+      expect(sink.some((l) => l.includes(' 382 ') && l.includes('Secrets Manager'))).toBe(true);
+      // Never a 421 for REHASH.
+      expect(sink.some((l) => l.includes(' 421 ') && l.includes('REHASH'))).toBe(false);
+    });
   });
 
   // -------------------------------------------------------------------------

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

@@ -151,6 +151,8 @@ describe.skipIf(!available)('NLB stream handler — byte framing', () => {
       motd: MOTD,
       messages: bindMessageStore(SERVER_CONFIG),
       managementApi: f.mgmt,
+      // Bind a reload source so the configLoader wiring is exercised.
+      configLoader: async () => SERVER_CONFIG,
     });
     expect(res.statusCode).toBe(200);
 

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

@@ -0,0 +1,317 @@
+import { CreateTableCommand, DeleteTableCommand } from '@aws-sdk/client-dynamodb';
+import type { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
+import { type Clock, createConnection } from '@serverless-ircd/irc-core';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { AwsRuntime } from '../src/aws-runtime.js';
+import type { AwsRuntimeHandlers } from '../src/aws-runtime.js';
+import { TABLE_DEFS } from '../src/cdk-table-defs.js';
+import { createDynamoDocumentClient } from '../src/dynamo.js';
+import { AwsStats } from '../src/stats.js';
+import type { TablesConfig } from '../src/tables.js';
+
+const available = process.env.DDB_AVAILABLE === '1';
+const endpoint = process.env.DYNAMO_ENDPOINT;
+
+interface Fixture {
+  tables: TablesConfig;
+  client: ReturnType<typeof createDynamoDocumentClient>;
+  cleanup: () => Promise<void>;
+}
+
+let fx: Fixture;
+
+async function makeFixture(): Promise<Fixture> {
+  if (endpoint === undefined) throw new Error('DYNAMO_ENDPOINT missing');
+  const prefix = `t${Date.now()}-${Math.floor(Math.random() * 1e6)}-`;
+  const tables = Object.fromEntries(
+    Object.keys(TABLE_DEFS).map((name) => [name, `${prefix}${name}`]),
+  ) as TablesConfig;
+  const client = createDynamoDocumentClient({ endpoint });
+  for (const [logical, props] of Object.entries(TABLE_DEFS)) {
+    const pkName = props.partitionKey?.name;
+    const skName = props.sortKey?.name;
+    if (pkName === undefined) throw new Error(`table ${logical} missing partitionKey`);
+    const attributeDefinitions: Array<{ AttributeName: string; AttributeType: 'S' }> = [
+      { AttributeName: pkName, AttributeType: 'S' },
+    ];
+    const keySchema: Array<{ AttributeName: string; KeyType: 'HASH' | 'RANGE' }> = [
+      { AttributeName: pkName, KeyType: 'HASH' },
+    ];
+    if (skName !== undefined) {
+      attributeDefinitions.push({ AttributeName: skName, AttributeType: 'S' });
+      keySchema.push({ AttributeName: skName, KeyType: 'RANGE' });
+    }
+    await client.send(
+      new CreateTableCommand({
+        TableName: `${prefix}${logical}`,
+        AttributeDefinitions: attributeDefinitions,
+        KeySchema: keySchema,
+        BillingMode: 'PAY_PER_REQUEST',
+      }),
+    );
+  }
+  return {
+    tables,
+    client,
+    cleanup: async () => {
+      for (const logical of Object.keys(TABLE_DEFS)) {
+        await client.send(new DeleteTableCommand({ TableName: `${prefix}${logical}` }));
+      }
+    },
+  };
+}
+
+function noopHandlers(): AwsRuntimeHandlers {
+  return {
+    send: () => {},
+    disconnect: () => {},
+    snapshot: () => undefined,
+  };
+}
+
+function makeRuntime(connId: string, clockFn: () => number = () => 1_000): AwsRuntime {
+  const clock: Clock = { now: clockFn };
+  return new AwsRuntime({
+    dynamo: fx.client,
+    tables: fx.tables,
+    connId,
+    handlers: noopHandlers(),
+    managementApi: null,
+    clock,
+  });
+}
+
+describe.skipIf(!available)('AwsStats', () => {
+  beforeEach(async () => {
+    fx = await makeFixture();
+  });
+  afterEach(async () => {
+    if (fx) await fx.cleanup();
+  });
+
+  it('returns zero counts for an empty deployment', async () => {
+    const stats = new AwsStats({
+      dynamo: fx.client,
+      tables: fx.tables,
+      uptimeStartedAt: 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 registered connections (visible, invisible, opers)', async () => {
+    const rt = makeRuntime('self');
+    const a = createConnection({ id: 'c1', connectedSince: 0 });
+    a.nick = 'alice';
+    a.registration = 'registered';
+    const b = createConnection({ id: 'c2', connectedSince: 0 });
+    b.nick = 'bob';
+    b.registration = 'registered';
+    b.userModes.invisible = true;
+    const c = createConnection({ id: 'c3', connectedSince: 0 });
+    c.nick = 'carol';
+    c.registration = 'registered';
+    c.userModes.oper = true;
+    const d = createConnection({ id: 'c4', connectedSince: 0 });
+    d.registration = 'pre-registration';
+    await rt.persistConnectionState(a);
+    await rt.persistConnectionState(b);
+    await rt.persistConnectionState(c);
+    await rt.persistConnectionState(d);
+
+    const stats = new AwsStats({
+      dynamo: fx.client,
+      tables: fx.tables,
+      uptimeStartedAt: 1_000,
+    });
+    const snap = await stats.getStats();
+    // 3 registered (2 visible + 1 invisible), 1 oper, 1 unknown, 4 total.
+    expect(snap.users).toBe(2);
+    expect(snap.invisible).toBe(1);
+    expect(snap.opers).toBe(1);
+    expect(snap.unknownConnections).toBe(1);
+    expect(snap.localConns).toBe(4);
+  });
+
+  it('counts channels via the ChannelMeta table', async () => {
+    const rt = makeRuntime('self');
+    await rt.applyChannelDelta('#a', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'Alice' }],
+    });
+    await rt.applyChannelDelta('#b', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'Alice' }],
+    });
+
+    const stats = new AwsStats({
+      dynamo: fx.client,
+      tables: fx.tables,
+      uptimeStartedAt: 1_000,
+    });
+    const snap = await stats.getStats();
+    expect(snap.channels).toBe(2);
+  });
+
+  it('echoes the supplied uptimeStartedAt', async () => {
+    const stats = new AwsStats({
+      dynamo: fx.client,
+      tables: fx.tables,
+      uptimeStartedAt: 7_777,
+    });
+    const snap = await stats.getStats();
+    expect(snap.uptimeStartedAt).toBe(7_777);
+  });
+
+  it('honours supplied maxLocalConns / maxGlobalConns overrides', async () => {
+    const rt = makeRuntime('self');
+    const a = createConnection({ id: 'c1', connectedSince: 0 });
+    a.nick = 'alice';
+    a.registration = 'registered';
+    await rt.persistConnectionState(a);
+
+    const stats = new AwsStats({
+      dynamo: fx.client,
+      tables: fx.tables,
+      uptimeStartedAt: 1_000,
+      maxLocalConns: 99,
+      maxGlobalConns: 88,
+    });
+    const snap = await stats.getStats();
+    expect(snap.maxLocalConns).toBe(99);
+    expect(snap.maxGlobalConns).toBe(88);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Mock-based unit tests — exercise the defensive Scan fallbacks without
+// requiring DynamoDB Local.
+// ---------------------------------------------------------------------------
+
+/**
+ * Builds a stub DocumentClient whose `send` returns canned Scan output.
+ * Exercises the `?? []` and `?? 0` fallbacks in {@link AwsStats.getStats}
+ * that the DynamoDB-Local integration suite cannot reach (the SDK always
+ * returns defined arrays / counts there).
+ *
+ * Pass `connectionsItems: undefined` to simulate the SDK omitting the
+ * `Items` field entirely (the `?? []` fallback path).
+ */
+function stubDynamo(
+  connectionsItems: unknown[] | undefined,
+  channelCount: number | undefined,
+): DynamoDBDocumentClient {
+  const calls: { TableName: string }[] = [];
+  const stub = {
+    send: async (cmd: {
+      input?: { TableName?: string; Select?: string };
+      TableName?: string;
+      Select?: string;
+    }) => {
+      // ScanCommand exposes its input via `.input`; both shapes are tolerated.
+      const input = (cmd as { input?: { TableName?: string; Select?: string } }).input ?? cmd;
+      const tableName = input.TableName ?? '';
+      const select = input.Select;
+      calls.push({ TableName: tableName });
+      void calls;
+      // Heuristic: the Connections scan omits `Select`, the ChannelMeta
+      // scan sets `Select: 'COUNT'`.
+      if (select === 'COUNT') {
+        return { Count: channelCount };
+      }
+      // Returning `{}` (no Items key) exercises the `?? []` fallback.
+      return connectionsItems === undefined ? {} : { Items: connectionsItems };
+    },
+  };
+  // Expose calls for any future assertions.
+  (stub as { _calls?: unknown })._calls = calls;
+  return stub as unknown as DynamoDBDocumentClient;
+}
+
+describe('AwsStats — defensive Scan fallbacks (mocked client)', () => {
+  // These tests do NOT require DynamoDB Local — they exercise the
+  // `?? []` / `?? 0` fallbacks by feeding a stub client.
+  it('returns empty arrays when the Connections Scan yields no Items field', async () => {
+    const tables: TablesConfig = {
+      Connections: 'Connections',
+      ChannelMeta: 'ChannelMeta',
+      ChannelMembers: 'ChannelMembers',
+      Nicks: 'Nicks',
+      Accounts: 'Accounts',
+    };
+    // Pass `undefined` so the stub returns `{}` — no Items key — to
+    // exercise the `?? []` fallback on the Connections scan, and
+    // `undefined` for Count to exercise the `?? 0` fallback.
+    const dynamo = stubDynamo(undefined, undefined);
+    const stats = new AwsStats({ dynamo, tables, uptimeStartedAt: 1_000 });
+    const snap = await stats.getStats();
+    expect(snap.users).toBe(0);
+    expect(snap.unknownConnections).toBe(0);
+    expect(snap.channels).toBe(0);
+    expect(snap.localConns).toBe(0);
+  });
+
+  it('honours maxLocalConns / maxGlobalConns overrides via the stub client', async () => {
+    const tables: TablesConfig = {
+      Connections: 'Connections',
+      ChannelMeta: 'ChannelMeta',
+      ChannelMembers: 'ChannelMembers',
+      Nicks: 'Nicks',
+      Accounts: 'Accounts',
+    };
+    const dynamo = stubDynamo([], 0);
+    const stats = new AwsStats({
+      dynamo,
+      tables,
+      uptimeStartedAt: 1_000,
+      maxLocalConns: 42,
+      maxGlobalConns: 43,
+    });
+    const snap = await stats.getStats();
+    expect(snap.maxLocalConns).toBe(42);
+    expect(snap.maxGlobalConns).toBe(43);
+  });
+
+  it('counts connections returned by the stub client', async () => {
+    const tables: TablesConfig = {
+      Connections: 'Connections',
+      ChannelMeta: 'ChannelMeta',
+      ChannelMembers: 'ChannelMembers',
+      Nicks: 'Nicks',
+      Accounts: 'Accounts',
+    };
+    // Two registered connection rows.
+    const items = [
+      {
+        connectionId: 'c1',
+        registration: 'registered',
+        capNegotiating: false,
+        caps: [],
+        userModes: { invisible: false, oper: false, wallops: false, serverNotices: false },
+        lastSeen: 0,
+        connectedSince: 0,
+        idleSince: 0,
+        version: 1,
+      },
+      {
+        connectionId: 'c2',
+        registration: 'registered',
+        capNegotiating: false,
+        caps: [],
+        userModes: { invisible: true, oper: false, wallops: false, serverNotices: false },
+        lastSeen: 0,
+        connectedSince: 0,
+        idleSince: 0,
+        version: 1,
+      },
+    ];
+    const dynamo = stubDynamo(items, 3);
+    const stats = new AwsStats({ dynamo, tables, uptimeStartedAt: 1_000 });
+    const snap = await stats.getStats();
+    expect(snap.users).toBe(1); // 2 registered − 1 invisible
+    expect(snap.invisible).toBe(1);
+    expect(snap.channels).toBe(3);
+    expect(snap.localConns).toBe(2);
+  });
+});

package/packages/cf-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/cf-adapter",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "private": true,
   "description": "Cloudflare Workers adapter: Durable Objects (ConnectionDO, RegistryDO, ChannelDO) and CfRuntime implementing IrcRuntime",
   "license": "BSD-3-Clause",
@@ -11,6 +11,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./accounts": {
+      "types": "./dist/d1-account-store.d.ts",
+      "import": "./dist/d1-account-store.js"
     }
   },
   "scripts": {