serverless-ircd 0.2.0 → 0.3.0

package/packages/cf-adapter/src/channel-registry-do.ts

@@ -0,0 +1,58 @@
+/**
+ * `ChannelRegistryDO` — Cloudflare Durable Object that tracks the set
+ * of all channel names.
+ *
+ * A single DO instance (keyed by the literal name `channels`) maintains
+ * the complete channel-name set so {@link CfRuntime.listChannels} can
+ * enumerate every channel without scanning each per-channel DO
+ * individually.
+ *
+ * Storage layout:
+ *   - One key per channel: `chan:<lower>` → `1`
+ *
+ * Per-channel keys keep storage proportional to the live channel count
+ * and let individual register/unregister calls stay O(1).
+ *
+ * RPC surface — implements {@link ChannelRegistryRpc}. The ChannelDO
+ * calls `register` / `unregister` whenever its membership transitions
+ * between empty and non-empty; CfRuntime calls `list` for LIST.
+ */
+
+import { DurableObject } from 'cloudflare:workers';
+import type { ChannelRegistryRpc } from './env.js';
+
+/** Storage key prefix for per-channel entries. */
+const CHAN_KEY_PREFIX = 'chan:';
+
+/** Returns the storage key for `nameLower`. */
+function chanKey(nameLower: string): string {
+  return `${CHAN_KEY_PREFIX}${nameLower}`;
+}
+
+/**
+ * Channel registry authority.
+ *
+ * The class is exported as a binding target in `wrangler.toml`; the
+ * Workers runtime instantiates it with `(ctx, env)`.
+ */
+export class ChannelRegistryDO extends DurableObject implements ChannelRegistryRpc {
+  /** Adds `name` to the registry (idempotent). */
+  async register(name: string): Promise<void> {
+    await this.ctx.storage.put(chanKey(name.toLowerCase()), 1);
+  }
+
+  /** Removes `name` from the registry (idempotent). */
+  async unregister(name: string): Promise<void> {
+    await this.ctx.storage.delete(chanKey(name.toLowerCase()));
+  }
+
+  /** Returns all registered channel names (lowercased). */
+  async list(): Promise<string[]> {
+    const entries = await this.ctx.storage.list({ prefix: CHAN_KEY_PREFIX });
+    const names: string[] = [];
+    for (const key of entries.keys()) {
+      names.push(key.slice(CHAN_KEY_PREFIX.length));
+    }
+    return names;
+  }
+}

package/packages/cf-adapter/src/config-loader.ts

@@ -34,6 +34,12 @@ export interface CfConfigEnv {
   TOPIC_LEN?: string;
   MAX_LIST_ENTRIES?: string;
   QUIT_MESSAGE?: string;
+  /**
+   * SASL PLAIN accounts. Newline-delimited `username:password` pairs.
+   * Parsed into the `saslAccounts` config field so the config-driven
+   * path (vs the connection-do's direct env read) stays consistent.
+   */
+  SASL_ACCOUNTS?: string;
 }
 
 /**
@@ -90,9 +96,32 @@ function buildConfigInput(env: CfConfigEnv): Record<string, unknown> {
   if (env.QUIT_MESSAGE !== undefined) {
     input.quitMessage = env.QUIT_MESSAGE;
   }
+  if (env.SASL_ACCOUNTS !== undefined && env.SASL_ACCOUNTS.length > 0) {
+    input.saslAccounts = parseSaslAccountsLines(env.SASL_ACCOUNTS);
+  }
   return input;
 }
 
+/**
+ * Parses a newline-delimited `username:password` string into the config's
+ * `saslAccounts` shape. Malformed entries are skipped so a trailing
+ * newline or partial edit does not break boot.
+ */
+function parseSaslAccountsLines(raw: string): Array<{ username: string; password: string }> {
+  const out: Array<{ username: string; password: string }> = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const sep = trimmed.indexOf(':');
+    if (sep <= 0) continue;
+    const username = trimmed.slice(0, sep);
+    const password = trimmed.slice(sep + 1);
+    if (username.length === 0 || password.length === 0) continue;
+    out.push({ username, password });
+  }
+  return out;
+}
+
 /**
  * Loads and validates the server config from a Cloudflare Workers env.
  *

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

@@ -29,6 +29,7 @@
 
 import { DurableObject } from 'cloudflare:workers';
 import {
+  type AccountStore,
   type ChanName,
   type ChannelState,
   type Clock,
@@ -36,12 +37,14 @@ import {
   type ConnectionState,
   ConsoleLogger,
   type IdFactory,
+  InMemoryAccountStore,
   InMemoryMessageStore,
   LogLevel,
   type Logger,
   type MessageStore,
   type MotdProvider,
   type RawLine,
+  type SaslAccountCredential,
   type ServerConfig,
   SystemClock,
   UuidIdFactory,
@@ -55,6 +58,7 @@ import { makeCfRuntime } from './cf-runtime.js';
 import type { CfConnectionHandlers } from './cf-runtime.js';
 import type { Env } from './env.js';
 import { PERSISTED_STATE_VERSION, STATE_STORAGE_KEY, deserialize, serialize } from './serialize.js';
+import type { PersistedConnectionState } from './serialize.js';
 
 /** Default PING cadence (ms) — tuned for typical IRC client behavior. */
 export const DEFAULT_PING_INTERVAL_MS = 60_000;
@@ -104,6 +108,13 @@ export class ConnectionDO extends DurableObject<Env> {
    * follow-up. Lazily constructed so the first frame seeds it.
    */
   private messages: MessageStore | undefined;
+  /**
+   * In-worker SASL account store seeded from the `SASL_ACCOUNTS` env var.
+   * Lazily constructed so the first frame that needs it parses the env once.
+   * A Durable-Object / D1-backed persistent variant is a documented
+   * follow-up; swapping it in means replacing {@link accountStore}.
+   */
+  private accounts: AccountStore | undefined;
   private readonly clock: Clock = SystemClock;
   private readonly ids: IdFactory = new UuidIdFactory();
   private readonly pingIntervalMs: number = DEFAULT_PING_INTERVAL_MS;
@@ -311,6 +322,7 @@ export class ConnectionDO extends DurableObject<Env> {
     // Bound `connectionId` so every record the actor emits is filterable
     // per-connection in the Workers dashboard.
     const logger: Logger = new ConsoleLogger({ connectionId: state.id }, undefined, LogLevel.Info);
+    const accounts = this.accountStore();
     return new ConnectionActor({
       state,
       runtime,
@@ -320,6 +332,7 @@ export class ConnectionDO extends DurableObject<Env> {
       ids: this.ids,
       motd,
       messages: this.messageStore(),
+      ...(accounts !== undefined ? { accounts } : {}),
       logger,
     });
   }
@@ -384,6 +397,21 @@ export class ConnectionDO extends DurableObject<Env> {
     return this.messages;
   }
 
+  /**
+   * Lazily constructs the in-worker SASL account store from the
+   * `SASL_ACCOUNTS` env var. Returns `undefined` when no accounts are
+   * configured so the actor's `ctx.accounts` stays unset (preserving the
+   * no-store behaviour: `AUTHENTICATE PLAIN` → `904`). A Durable-Object /
+   * D1-backed persistent variant is a documented follow-up.
+   */
+  private accountStore(): AccountStore | undefined {
+    if (this.accounts !== undefined) return this.accounts;
+    const creds = parseSaslAccountsEnv(this.env.SASL_ACCOUNTS);
+    if (creds.length === 0) return undefined;
+    this.accounts = new InMemoryAccountStore(creds);
+    return this.accounts;
+  }
+
   // -------------------------------------------------------------------------
   // Test hooks (only invoked from `runInDurableObject` in tests)
   // -------------------------------------------------------------------------
@@ -470,6 +498,38 @@ export class ConnectionDO extends DurableObject<Env> {
     const state = await this.loadState();
     return toSnapshot(state);
   }
+
+  /**
+   * Cross-connection RPC: returns the full connection state as a
+   * JSON-friendly DTO ({@link PersistedConnectionState}). Called by
+   * another connection's {@link CfRuntime} when a `GetConnection`
+   * lookup targets this connection (e.g. WHOIS). The DTO survives DO
+   * RPC because `Set`/`Map` fields are pre-flattened to arrays by
+   * {@link serialize}; the caller rehydrates via {@link deserialize}.
+   */
+  public async getConnState(): Promise<PersistedConnectionState | null> {
+    const state = await this.loadState();
+    return serialize(state);
+  }
+
+  /**
+   * Cross-connection RPC: tears down this connection. Reuses the same
+   * QUIT fan-out / nick-release / WebSocket-close path as the normal
+   * `webSocketClose` handler so KICK and operator-driven disconnect
+   * produce identical side effects. If no live socket is attached the
+   * no-socket teardown path still releases the nick.
+   */
+  public async disconnect(reason?: string): Promise<void> {
+    void reason;
+    const sockets = this.ctx.getWebSockets();
+    const ws = sockets[0];
+    if (ws === undefined) {
+      const state = await this.loadState();
+      await this.tearDownNoSocket(state);
+      return;
+    }
+    await this.tearDown(ws as WebSocket);
+  }
 }
 
 /** Default MOTD when no `MOTD_LINES` env is supplied. */
@@ -574,3 +634,28 @@ class PassthroughChannelAccess {
 // in production today. (Removed from the ConnectionDO path because the
 // authoritative delta application lives in the ChannelDO stub today.)
 export { applyChannelDelta, PERSISTED_STATE_VERSION };
+
+/**
+ * Parses the `SASL_ACCOUNTS` env var into credential entries.
+ *
+ * Format: newline-delimited `username:password` pairs (mirroring the
+ * `MOTD_LINES` convention). Blank lines and malformed entries (missing
+ * colon or empty username/password) are skipped so a trailing newline or a
+ * partial edit does not break boot. Exported so the parsing boundary is
+ * unit-testable in isolation.
+ */
+export function parseSaslAccountsEnv(raw: string | undefined): SaslAccountCredential[] {
+  if (raw === undefined || raw.length === 0) return [];
+  const out: SaslAccountCredential[] = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const sep = trimmed.indexOf(':');
+    if (sep <= 0) continue; // missing colon or empty username
+    const username = trimmed.slice(0, sep);
+    const password = trimmed.slice(sep + 1);
+    if (username.length === 0 || password.length === 0) continue;
+    out.push({ username, password });
+  }
+  return out;
+}

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

@@ -31,13 +31,28 @@ export interface Env {
   REGISTRY_DO: DurableObjectNamespace;
   /**
    * Channel authority, keyed by lowercased channel name. RPC: broadcast /
-   * applyChannelDelta / getChannelSnapshot. Stubbed now; real in 035.
+   * applyChannelDelta / getChannelSnapshot / listMembers. Stubbed now;
+   * real in 035.
    */
   CHANNEL_DO: DurableObjectNamespace;
+  /**
+   * Channel registry authority. A single DO instance tracks the set of
+   * all channel names so {@link CfRuntime.listChannels} can enumerate
+   * them without scanning every per-channel DO. RPC: register /
+   * unregister / list.
+   */
+  CHANNEL_REGISTRY_DO: DurableObjectNamespace;
   /** Server-level config knobs (name, MOTD lines, limits). */
   SERVER_NAME: string;
   NETWORK_NAME: string;
   MOTD_LINES: string;
+  /**
+   * 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. Empty/undefined disables SASL account verification.
+   */
+  SASL_ACCOUNTS?: string;
 }
 
 /**
@@ -64,4 +79,15 @@ export interface ChannelRpc {
   broadcast(lines: unknown[], except?: string): Promise<void>;
   applyChannelDelta(delta: unknown): Promise<void>;
   getChannelSnapshot(): Promise<unknown>;
+  listMembers(): Promise<string[]>;
+}
+
+/**
+ * RPC contract for the channel registry DO. Tracks the set of all
+ * channel names so {@link CfRuntime.listChannels} can enumerate them.
+ */
+export interface ChannelRegistryRpc {
+  register(name: string): Promise<void>;
+  unregister(name: string): Promise<void>;
+  list(): Promise<string[]>;
 }

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

@@ -19,6 +19,7 @@ export {
 } from './connection-do.js';
 export { RegistryDO } from './registry-do.js';
 export { ChannelDO } from './channel-do.js';
+export { ChannelRegistryDO } from './channel-registry-do.js';
 export type { DeliverResult, ConnectionDeliveryRpc } from './channel-do.js';
 export {
   DEFAULT_REGISTRY_SHARDS,
@@ -27,7 +28,7 @@ export {
 } from './sharding.js';
 export { makeCfRuntime } from './cf-runtime.js';
 export type { CfConnectionHandlers } from './cf-runtime.js';
-export type { ChannelRpc, Env, RegistryRpc } from './env.js';
+export type { ChannelRpc, ChannelRegistryRpc, Env, RegistryRpc } from './env.js';
 export {
   PERSISTED_STATE_VERSION,
   STATE_STORAGE_KEY,

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

@@ -44,6 +44,7 @@ declare global {
       CHANNEL_DO: DurableObjectNamespace;
       CHANNEL_DO_REAL: DurableObjectNamespace;
       CHANNEL_DO_STUB: DurableObjectNamespace;
+      CHANNEL_REGISTRY_DO: DurableObjectNamespace;
     }
   }
 }
@@ -62,6 +63,7 @@ function envWithRealDOs(): Env {
     CONNECTION_DO: env.CONNECTION_DO,
     REGISTRY_DO: env.REGISTRY_DO_REAL,
     CHANNEL_DO: env.CHANNEL_DO_REAL,
+    CHANNEL_REGISTRY_DO: env.CHANNEL_REGISTRY_DO,
     SERVER_NAME: 'irc.example.com',
     NETWORK_NAME: 'ExampleNet',
     MOTD_LINES: '',
@@ -78,6 +80,7 @@ function envWithChannelStub(): Env {
     CONNECTION_DO: env.CONNECTION_DO,
     REGISTRY_DO: env.REGISTRY_DO_REAL,
     CHANNEL_DO: env.CHANNEL_DO_STUB,
+    CHANNEL_REGISTRY_DO: env.CHANNEL_REGISTRY_DO,
     SERVER_NAME: 'irc.example.com',
     NETWORK_NAME: 'ExampleNet',
     MOTD_LINES: '',
@@ -484,6 +487,94 @@ describe('CfRuntime — cross-connection RPC via ConnectionDO', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// Tests — cross-connection getConnection / getChannelConnections / listChannels / disconnect
+// ---------------------------------------------------------------------------
+
+describe('CfRuntime — cross-connection lookups and disconnect', () => {
+  it('getConnection(remoteConnId) returns the remote connection state via RPC', async () => {
+    const targetName = 'conn-get-target';
+    const ws = await openConnection(targetName);
+    await new Promise<void>((r) => setTimeout(r, 20));
+    ws.send('NICK carol\r\n');
+    ws.send('USER carol 0 * :Carol\r\n');
+    await new Promise<void>((r) => setTimeout(r, 100));
+
+    const targetHexId = await getConnectionHexId(targetName);
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-get-caller', recordingHandlers());
+    const conn = await rt.getConnection(targetHexId);
+    expect(conn).not.toBeNull();
+    expect(conn?.nick).toBe('carol');
+    expect(conn?.id).toBe(targetHexId);
+
+    ws.close();
+  });
+
+  it('getChannelConnections(chan) returns the ConnectionStates of all members', async () => {
+    const memberName = 'conn-who-target';
+    const ws = await openConnection(memberName);
+    await new Promise<void>((r) => setTimeout(r, 20));
+    ws.send('NICK dave\r\n');
+    ws.send('USER dave 0 * :Dave\r\n');
+    await new Promise<void>((r) => setTimeout(r, 100));
+
+    const memberHexId = await getConnectionHexId(memberName);
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-who-caller', recordingHandlers());
+
+    await rt.applyChannelDelta('#whochan', {
+      memberships: [{ type: 'add' as const, conn: memberHexId, nick: 'dave' }],
+    });
+
+    const conns = await rt.getChannelConnections('#whochan');
+    expect(conns.size).toBe(1);
+    expect(conns.get(memberHexId)?.nick).toBe('dave');
+
+    ws.close();
+  });
+
+  it('listChannels returns channels registered in the registry', async () => {
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-list', recordingHandlers());
+
+    await rt.applyChannelDelta('#listchan', {
+      memberships: [{ type: 'add' as const, conn: 'conn-list', nick: 'eve' }],
+    });
+
+    const channels = await rt.listChannels();
+    expect(channels.length).toBeGreaterThan(0);
+    expect(channels.some((c) => c.nameLower === '#listchan')).toBe(true);
+  });
+
+  it('listChannels returns empty array when no channels exist', async () => {
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-list-empty', recordingHandlers());
+    const channels = await rt.listChannels();
+    expect(channels).toEqual([]);
+  });
+
+  it('disconnect(remoteConn) closes the target connection', async () => {
+    const targetName = 'conn-disc-target';
+    const ws = await openConnection(targetName);
+    await new Promise<void>((r) => setTimeout(r, 20));
+
+    const targetHexId = await getConnectionHexId(targetName);
+    const realEnv = envWithRealDOs();
+    const rt = new CfRuntime(realEnv, 'conn-disc-caller', recordingHandlers());
+
+    const closed = new Promise<void>((resolve) => {
+      ws.addEventListener('close', () => resolve());
+      setTimeout(resolve, 2000);
+    });
+
+    await rt.disconnect(targetHexId, 'Kicked');
+    await closed;
+
+    expect([WebSocket.CLOSING, WebSocket.CLOSED]).toContain(ws.readyState);
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Tests — implements IrcRuntime
 // ---------------------------------------------------------------------------

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

@@ -366,6 +366,46 @@ describe('ConnectionDO — chathistory end-to-end', () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// 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.2.0",
+  "version": "0.3.0",
   "private": true,
   "description": "Single-process reference implementation of the IrcRuntime port, backed by Maps",
   "license": "BSD-3-Clause",