serverless-ircd 0.1.0 → 0.3.0

package/packages/cf-adapter/tests/config-loader.test.ts

@@ -0,0 +1,149 @@
+/**
+ * Config loading for the cf-adapter.
+ *
+ * Verifies the shared `ServerConfigSchema` (from `irc-core`) is consumed
+ * by the Cloudflare adapter — both adapters (CF + AWS) build the same
+ * shape from their platform-native sources.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { loadServerConfigFromCfEnv } from '../src/config-loader';
+
+interface CfEnvLike {
+  SERVER_NAME?: string;
+  NETWORK_NAME?: string;
+  MOTD_LINES?: string;
+  MAX_CLIENTS?: string;
+  CHANNEL_PREFIXES?: string;
+  OPER_USER?: string;
+  OPER_PASSWORD?: string;
+  MAX_CHANNELS_PER_USER?: string;
+  MAX_TARGETS_PER_COMMAND?: string;
+  NICK_LEN?: string;
+  CHANNEL_LEN?: string;
+  TOPIC_LEN?: string;
+  MAX_LIST_ENTRIES?: string;
+  QUIT_MESSAGE?: string;
+}
+
+function baseEnv(): CfEnvLike {
+  return { SERVER_NAME: 'irc.cf.example.com', NETWORK_NAME: 'CfNet' };
+}
+
+describe('loadServerConfigFromCfEnv — valid env', () => {
+  it('returns a parsed config derived from the minimal required vars', () => {
+    const cfg = loadServerConfigFromCfEnv(baseEnv());
+    expect(cfg.serverName).toBe('irc.cf.example.com');
+    expect(cfg.networkName).toBe('CfNet');
+    // Defaults still apply.
+    expect(cfg.channelPrefixes.length).toBeGreaterThan(0);
+    expect(cfg.maxClients).toBeGreaterThan(0);
+    expect(cfg.operCreds).toEqual([]);
+  });
+
+  it('splits MOTD_LINES on newlines into motdLines', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      MOTD_LINES: 'line 1\nline 2\nline 3',
+    });
+    expect(cfg.motdLines).toEqual(['line 1', 'line 2', 'line 3']);
+  });
+
+  it('treats an undefined MOTD_LINES as the default empty MOTD', () => {
+    const cfg = loadServerConfigFromCfEnv(baseEnv());
+    expect(cfg.motdLines).toEqual([]);
+  });
+
+  it('parses MAX_CLIENTS as an integer', () => {
+    const cfg = loadServerConfigFromCfEnv({ ...baseEnv(), MAX_CLIENTS: '4242' });
+    expect(cfg.maxClients).toBe(4242);
+  });
+
+  it('parses CHANNEL_PREFIXES verbatim', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      CHANNEL_PREFIXES: '#&+',
+    });
+    expect(cfg.channelPrefixes).toBe('#&+');
+  });
+
+  it('builds operCreds from OPER_USER + OPER_PASSWORD when both set', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      OPER_USER: 'admin',
+      OPER_PASSWORD: 'hunter2',
+    });
+    expect(cfg.operCreds).toEqual([{ user: 'admin', password: 'hunter2' }]);
+  });
+
+  it('parses numeric limit overrides from string env vars', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      MAX_CHANNELS_PER_USER: '12',
+      MAX_TARGETS_PER_COMMAND: '3',
+      NICK_LEN: '20',
+      CHANNEL_LEN: '40',
+      TOPIC_LEN: '300',
+      MAX_LIST_ENTRIES: '7',
+    });
+    expect(cfg.maxChannelsPerUser).toBe(12);
+    expect(cfg.maxTargetsPerCommand).toBe(3);
+    expect(cfg.nickLen).toBe(20);
+    expect(cfg.channelLen).toBe(40);
+    expect(cfg.topicLen).toBe(300);
+    expect(cfg.maxListEntries).toBe(7);
+  });
+
+  it('honours a custom QUIT_MESSAGE', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      QUIT_MESSAGE: 'Bye from CF',
+    });
+    expect(cfg.quitMessage).toBe('Bye from CF');
+  });
+});
+
+describe('loadServerConfigFromCfEnv — failure modes', () => {
+  it('throws when SERVER_NAME is missing', () => {
+    expect(() => loadServerConfigFromCfEnv({ NETWORK_NAME: 'CfNet' })).toThrowError(/serverName/u);
+  });
+
+  it('throws when NETWORK_NAME is missing', () => {
+    expect(() => loadServerConfigFromCfEnv({ SERVER_NAME: 's' })).toThrowError(/networkName/u);
+  });
+
+  it('throws when MAX_CLIENTS is non-numeric', () => {
+    expect(() => loadServerConfigFromCfEnv({ ...baseEnv(), MAX_CLIENTS: 'lots' })).toThrowError(
+      /maxClients/u,
+    );
+  });
+
+  it('throws when OPER_USER is set but OPER_PASSWORD is missing', () => {
+    expect(() => loadServerConfigFromCfEnv({ ...baseEnv(), OPER_USER: 'admin' })).toThrowError(
+      /password/u,
+    );
+  });
+
+  it('throws when OPER_PASSWORD is set but OPER_USER is missing', () => {
+    expect(() => loadServerConfigFromCfEnv({ ...baseEnv(), OPER_PASSWORD: 'p' })).toThrowError(
+      /user/u,
+    );
+  });
+
+  it('aggregates multiple errors into a single readable Error', () => {
+    try {
+      loadServerConfigFromCfEnv({
+        MAX_CLIENTS: 'oops',
+        OPER_USER: 'admin',
+      });
+      expect.fail('expected throw');
+    } catch (err) {
+      expect(err).toBeInstanceOf(Error);
+      const msg = (err as Error).message;
+      expect(msg).toMatch(/invalid server config/iu);
+      // Both bad fields are surfaced.
+      expect(msg).toMatch(/serverName/u);
+      expect(msg).toMatch(/maxClients/u);
+    }
+  });
+});

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

@@ -123,6 +123,23 @@ async function register(client: IrcWsClient, nick: string): Promise<void> {
   await client.waitForMessage((l) => l.includes(' 001 '));
 }
 
+/**
+ * Negotiates the chathistory cap set then registers. Mirrors the
+ * pre-registration `CAP REQ` → `NICK`/`USER` → `CAP END` flow a real
+ * client uses.
+ */
+async function registerWithChathistory(client: IrcWsClient, nick: string): Promise<void> {
+  // `echo-message` is included so tests can deterministically wait for a
+  // PRIVMSG to be recorded before issuing a follow-up CHATHISTORY query
+  // (otherwise the two async webSocketMessage handlers race).
+  client.send('CAP REQ :draft/chathistory server-time message-tags batch echo-message\r\n');
+  await client.waitForMessage((l) => / CAP \S+ ACK :/.test(l));
+  client.send(`NICK ${nick}\r\n`);
+  client.send(`USER ${nick} 0 * :${nick}\r\n`);
+  client.send('CAP END\r\n');
+  await client.waitForMessage((l) => l.includes(' 001 '));
+}
+
 /**
  * Forces the ConnectionDO to drop its in-memory cache of the
  * {@link ConnectionState}, simulating wake-from-hibernation. The next
@@ -324,6 +341,71 @@ describe('ConnectionDO — alarms', () => {
   });
 });
 
+describe('ConnectionDO — chathistory end-to-end', () => {
+  it('records a PRIVMSG and replays it via CHATHISTORY LATEST in a BATCH', async () => {
+    const client = await connect('conn-chathist-1');
+    await registerWithChathistory(client, 'cf-alice');
+
+    client.send('JOIN #cf-chathist\r\n');
+    await client.waitForMessage((l) => l.includes(' 366 ') && l.includes('#cf-chathist'));
+
+    client.send('PRIVMSG #cf-chathist :recorded via cf\r\n');
+    // Wait for the echo (echo-message cap) so the PRIVMSG is recorded
+    // before the CHATHISTORY query arrives as a separate frame.
+    await client.waitForMessage((l) => l.includes('PRIVMSG #cf-chathist :recorded via cf'));
+
+    client.send('CHATHISTORY LATEST #cf-chathist * 10\r\n');
+    const batchOpen = await client.waitForMessage((l) =>
+      /^BATCH \+\S+ chathistory #cf-chathist/.test(l),
+    );
+    expect(batchOpen).toMatch(/^BATCH \+\S+ chathistory #cf-chathist/);
+
+    await client.waitForMessage((l) => l.includes('PRIVMSG #cf-chathist :recorded via cf'));
+
+    client.ws.close();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// SASL PLAIN end-to-end (AccountStore plumbing)
+// ---------------------------------------------------------------------------
+
+describe('ConnectionDO — SASL PLAIN end-to-end', () => {
+  /** base64(`\0authcid\0password`) — the PLAIN payload format. */
+  function plainB64(authcid: string, password: string): string {
+    // workerd has no `Buffer`; use btoa on a Latin1-encoded string.
+    const raw = `\0${authcid}\0${password}`;
+    let latin1 = '';
+    for (let i = 0; i < raw.length; i++) latin1 += String.fromCharCode(raw.charCodeAt(i));
+    return (globalThis as unknown as { btoa: (s: string) => string }).btoa(latin1);
+  }
+
+  it('completes SASL PLAIN with 900/903 for valid seeded creds', async () => {
+    const client = await connect('conn-sasl-1');
+    client.send('CAP REQ :sasl\r\n');
+    await client.waitForMessage((l) => / CAP \S+ ACK :sasl/.test(l));
+    client.send('AUTHENTICATE PLAIN\r\n');
+    await client.waitForMessage((l) => l === 'AUTHENTICATE +');
+    client.send(`AUTHENTICATE ${plainB64('cf-sasl', 's3cret')}\r\n`);
+    await client.waitForMessage((l) => l.includes(' 900 '));
+    const success = await client.waitForMessage((l) => l.includes(' 903 '));
+    expect(success).toContain(' 903 ');
+    client.ws.close();
+  });
+
+  it('rejects SASL PLAIN with 904 for invalid creds', async () => {
+    const client = await connect('conn-sasl-2');
+    client.send('CAP REQ :sasl\r\n');
+    await client.waitForMessage((l) => / CAP \S+ ACK :sasl/.test(l));
+    client.send('AUTHENTICATE PLAIN\r\n');
+    await client.waitForMessage((l) => l === 'AUTHENTICATE +');
+    client.send(`AUTHENTICATE ${plainB64('cf-sasl', 'wrong')}\r\n`);
+    const fail = await client.waitForMessage((l) => l.includes(' 904 '));
+    expect(fail).toContain(' 904 ');
+    client.ws.close();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // End of file
 // ---------------------------------------------------------------------------

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

@@ -19,12 +19,13 @@
  */
 
 import { ChannelDO } from '../../src/channel-do';
+import { ChannelRegistryDO } from '../../src/channel-registry-do';
 import { ConnectionDO } from '../../src/connection-do';
 import { RegistryDO } from '../../src/registry-do';
 import { RecordingChannelDO } from './stubs/channel-stub';
 import { RecordingRegistryDO } from './stubs/registry-stub';
 
-export { ChannelDO, 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

@@ -12,7 +12,7 @@
 import { DurableObject } from 'cloudflare:workers';
 
 export interface RecordedChannelCall {
-  method: 'broadcast' | 'applyChannelDelta' | 'getChannelSnapshot';
+  method: 'broadcast' | 'applyChannelDelta' | 'getChannelSnapshot' | 'listMembers';
   args: unknown[];
 }
 
@@ -20,6 +20,7 @@ interface ChannelRpc {
   broadcast(lines: unknown[], except?: string): Promise<void>;
   applyChannelDelta(delta: unknown): Promise<void>;
   getChannelSnapshot(): Promise<unknown>;
+  listMembers(): Promise<string[]>;
 }
 
 const LOG_KEY = 'channel-call-log';
@@ -47,4 +48,9 @@ export class RecordingChannelDO extends DurableObject implements ChannelRpc {
     await this.append({ method: 'getChannelSnapshot', args: [] });
     return null;
   }
+
+  async listMembers(): Promise<string[]> {
+    await this.append({ method: 'listMembers', args: [] });
+    return [];
+  }
 }

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

@@ -9,6 +9,10 @@ compatibility_flags = ["nodejs_compat"]
 # body text in every runtime factory.
 [vars]
 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"
 
 # Production bindings: REGISTRY_DO and CHANNEL_DO point at the real DO
 # classes so CfRuntime, ConnectionDO, and the integration suite all
@@ -25,6 +29,11 @@ class_name = "RegistryDO"
 name = "CHANNEL_DO"
 class_name = "ChannelDO"
 
+# Channel registry — single DO tracking all channel names for LIST.
+[[durable_objects.bindings]]
+name = "CHANNEL_REGISTRY_DO"
+class_name = "ChannelRegistryDO"
+
 # Recording stubs (kept under separate names for any test that wants to
 # assert "this exact RPC was emitted" rather than the end-to-end effect).
 [[durable_objects.bindings]]
@@ -47,4 +56,4 @@ class_name = "ChannelDO"
 
 [[migrations]]
 tag = "v1"
-new_classes = ["ConnectionDO", "RegistryDO", "ChannelDO", "RecordingRegistryDO", "RecordingChannelDO"]
+new_classes = ["ConnectionDO", "RegistryDO", "ChannelDO", "ChannelRegistryDO", "RecordingRegistryDO", "RecordingChannelDO"]

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

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/in-memory-runtime",
-  "version": "0.1.0",
+  "version": "0.3.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

@@ -13,6 +13,9 @@
  */
 
 import {
+  type AdmissionConfig,
+  type AdmissionDecision,
+  AdmissionStats,
   type ChanName,
   type ChanSnapshot,
   type ChannelDelta,
@@ -24,7 +27,9 @@ import {
   type Nick,
   type RawLine,
   applyChannelDelta as applyDelta,
+  caseFold,
   createChannel,
+  decideAdmission,
   toChannelSnapshot,
   toSnapshot as toConnSnapshot,
 } from '@serverless-ircd/irc-core';
@@ -41,10 +46,24 @@ export interface ConnectionHandlers {
 interface TrackedConnection {
   state: ConnectionState;
   handlers: ConnectionHandlers;
+  /**
+   * Optional admission record id paired with this connection at register
+   * time. When set, {@link InMemoryRuntime.unregisterConnection} releases
+   * it so per-IP / per-user connection counters stay accurate.
+   */
+  admissionRecordId?: string;
 }
 
-function lower(s: string): string {
-  return s.toLowerCase();
+export interface InMemoryRuntimeOptions {
+  clock: Clock;
+  /**
+   * Connection-admission policy. When omitted the admission gate is
+   * disabled — every {@link InMemoryRuntime.admitConnection} call returns
+   * an admit decision. Adapters that want to enforce per-IP / per-user /
+   * rate limits pass the same {@link AdmissionConfig} derived from the
+   * deployment's `ServerConfig`.
+   */
+  readonly admission?: AdmissionConfig;
 }
 
 export class InMemoryRuntime implements IrcRuntime {
@@ -52,9 +71,53 @@ export class InMemoryRuntime implements IrcRuntime {
   private readonly connections = new Map<ConnId, TrackedConnection>();
   private readonly channels = new Map<string, ChannelState>();
   private readonly nicks = new Map<string, ConnId>();
+  private readonly admissionStats: AdmissionStats | undefined;
+  private readonly admissionConfig: AdmissionConfig | undefined;
 
-  constructor(opts: { clock: Clock }) {
+  constructor(opts: InMemoryRuntimeOptions) {
     this.clock = opts.clock;
+    if (opts.admission !== undefined) {
+      this.admissionConfig = opts.admission;
+      this.admissionStats = new AdmissionStats(this.clock);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // Admission gate (NOT part of the IrcRuntime port — adapter only)
+  // ------------------------------------------------------------------
+
+  /**
+   * Decides whether a new connection should be admitted under the
+   * configured {@link AdmissionConfig}. Returns `{ ok: true, recordId }`
+   * when the connection may proceed; the caller MUST then call
+   * {@link commitAdmission} exactly once with the returned recordId.
+   *
+   * Returns `{ ok: false, reason }` when the connection must be refused.
+   *
+   * When no admission policy was supplied at construction, this method
+   * unconditionally admits (the gate is disabled).
+   */
+  admitConnection(ip: string, user: string | undefined): AdmissionDecision {
+    if (this.admissionConfig === undefined || this.admissionStats === undefined) {
+      return { ok: true, recordId: '' };
+    }
+    return decideAdmission(ip, user, this.admissionStats, this.admissionConfig);
+  }
+
+  /**
+   * Records an accepted admission. MUST be called exactly once per
+   * successful {@link admitConnection}. No-op when admission is disabled.
+   */
+  commitAdmission(ip: string, user: string | undefined, recordId: string): void {
+    this.admissionStats?.recordAdmission(ip, user, recordId);
+  }
+
+  /**
+   * Releases a previously-committed admission record. Safe to call with
+   * an unknown id. No-op when admission is disabled.
+   */
+  releaseAdmission(recordId: string): void {
+    this.admissionStats?.release(recordId);
   }
 
   // ------------------------------------------------------------------
@@ -65,13 +128,31 @@ export class InMemoryRuntime implements IrcRuntime {
    * Tracks a connection and its transport handlers. The runtime keeps a
    * reference to `state`; the actor may continue mutating it in place and
    * the runtime will observe the changes via {@link getConnectionInfo}.
+   *
+   * @param admissionRecordId Optional record id returned by
+   *   {@link admitConnection} + {@link commitAdmission}. When supplied,
+   *   {@link unregisterConnection} releases it automatically so the
+   *   per-IP / per-user connection counters stay accurate without the
+   *   adapter remembering to call {@link releaseAdmission} itself.
    */
-  registerConnection(state: ConnectionState, handlers: ConnectionHandlers): void {
-    this.connections.set(state.id, { state, handlers });
+  registerConnection(
+    state: ConnectionState,
+    handlers: ConnectionHandlers,
+    admissionRecordId?: string,
+  ): void {
+    const tracked: TrackedConnection =
+      admissionRecordId !== undefined
+        ? { state, handlers, admissionRecordId }
+        : { state, handlers };
+    this.connections.set(state.id, tracked);
   }
 
   /** Stops tracking a connection. Idempotent. Does NOT release its nick. */
   unregisterConnection(conn: ConnId): void {
+    const tracked = this.connections.get(conn);
+    if (tracked !== undefined && tracked.admissionRecordId !== undefined) {
+      this.releaseAdmission(tracked.admissionRecordId);
+    }
     this.connections.delete(conn);
   }
 
@@ -90,7 +171,7 @@ export class InMemoryRuntime implements IrcRuntime {
    * return the same object.
    */
   getOrCreateChannel(name: ChanName): ChannelState {
-    const key = lower(name);
+    const key = caseFold('rfc1459', name);
     const existing = this.channels.get(key);
     if (existing !== undefined) return existing;
     const created = createChannel({
@@ -102,6 +183,16 @@ export class InMemoryRuntime implements IrcRuntime {
     return created;
   }
 
+  /**
+   * Peek-only channel lookup that does NOT create the channel. Returns the
+   * authoritative {@link ChannelState} when it exists, or `undefined`.
+   * Used by query-only commands (CHATHISTORY) that must distinguish a
+   * missing channel from an empty one.
+   */
+  getChannel(name: ChanName): ChannelState | undefined {
+    return this.channels.get(caseFold('rfc1459', name));
+  }
+
   // ------------------------------------------------------------------
   // IrcRuntime — transport
   // ------------------------------------------------------------------
@@ -113,7 +204,7 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async broadcast(chan: ChanName, lines: RawLine[], except?: ConnId): Promise<void> {
-    const channel = this.channels.get(lower(chan));
+    const channel = this.channels.get(caseFold('rfc1459', chan));
     if (channel === undefined) return;
     for (const member of channel.members.keys()) {
       if (member === except) continue;
@@ -135,7 +226,7 @@ export class InMemoryRuntime implements IrcRuntime {
     lines: RawLine[],
     notFoundLines?: RawLine[],
   ): Promise<void> {
-    const owner = this.nicks.get(lower(nick));
+    const owner = this.nicks.get(caseFold('rfc1459', nick));
     if (owner !== undefined) {
       const conn = this.connections.get(owner);
       if (conn !== undefined) {
@@ -156,7 +247,7 @@ export class InMemoryRuntime implements IrcRuntime {
   // ------------------------------------------------------------------
 
   async reserveNick(nick: Nick, conn: ConnId): Promise<{ ok: true } | { ok: false }> {
-    const key = lower(nick);
+    const key = caseFold('rfc1459', nick);
     const existing = this.nicks.get(key);
     if (existing !== undefined && existing !== conn) {
       return { ok: false };
@@ -166,8 +257,8 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async changeNick(conn: ConnId, oldNick: Nick, newNick: Nick): Promise<boolean> {
-    const newKey = lower(newNick);
-    const oldKey = lower(oldNick);
+    const newKey = caseFold('rfc1459', newNick);
+    const oldKey = caseFold('rfc1459', oldNick);
     const owner = this.nicks.get(newKey);
     if (owner !== undefined && owner !== conn) {
       return false;
@@ -182,7 +273,7 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async releaseNick(nick: Nick): Promise<void> {
-    this.nicks.delete(lower(nick));
+    this.nicks.delete(caseFold('rfc1459', nick));
   }
 
   // ------------------------------------------------------------------
@@ -195,7 +286,7 @@ export class InMemoryRuntime implements IrcRuntime {
     // replace the stored object so subsequent snapshots see the new data
     // while any outstanding references to the prior state stay coherent.
     const next = applyDelta(channel, delta);
-    this.channels.set(lower(chan), next);
+    this.channels.set(caseFold('rfc1459', chan), next);
   }
 
   // ------------------------------------------------------------------
@@ -203,7 +294,7 @@ export class InMemoryRuntime implements IrcRuntime {
   // ------------------------------------------------------------------
 
   async lookupNick(nick: Nick): Promise<ConnId | null> {
-    return this.nicks.get(lower(nick)) ?? null;
+    return this.nicks.get(caseFold('rfc1459', nick)) ?? null;
   }
 
   async getConnectionInfo(conn: ConnId): Promise<ConnSnapshot | null> {
@@ -223,13 +314,13 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async getChannelSnapshot(chan: ChanName): Promise<ChanSnapshot | null> {
-    const channel = this.channels.get(lower(chan));
+    const channel = this.channels.get(caseFold('rfc1459', chan));
     if (channel === undefined) return null;
     return toChannelSnapshot(channel);
   }
 
   async getChannelConnections(chan: ChanName): Promise<ReadonlyMap<ConnId, ConnectionState>> {
-    const channel = this.channels.get(lower(chan));
+    const channel = this.channels.get(caseFold('rfc1459', chan));
     const out = new Map<ConnId, ConnectionState>();
     if (channel === undefined) return out;
     for (const connId of channel.members.keys()) {

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

@@ -6,4 +6,4 @@
  * and AWS runtimes.
  */
 export { InMemoryRuntime } from './in-memory-runtime.js';
-export type { ConnectionHandlers } from './in-memory-runtime.js';
+export type { ConnectionHandlers, InMemoryRuntimeOptions } from './in-memory-runtime.js';