serverless-ircd 0.1.0

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

@@ -0,0 +1,335 @@
+/**
+ * 034 — `RegistryDO` with sharding plan.
+ *
+ * TDD outline (from tickets.md):
+ *   "Red on concurrent reserve from two stub ConnectionDOs; green."
+ *
+ * Tests run inside real `workerd` via miniflare so DO storage
+ * transactions behave as in production. Each test gets its own
+ * isolated storage namespace (`isolatedStorage: true` in
+ * `vitest.config.ts`).
+ *
+ * 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
+ * stands in for one shard of the production fleet.
+ */
+
+import { env, runInDurableObject } from 'cloudflare:test';
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_REGISTRY_SHARDS, registryKeyForNick, shardNick } from '../src/sharding';
+
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      REGISTRY_DO_REAL: DurableObjectNamespace;
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns a stub for the registry shard that owns `nick` under the
+ * default shard count. Mirrors what CfRuntime will do in 036.
+ */
+function shardForNick(nick: string, shards = DEFAULT_REGISTRY_SHARDS): DurableObjectStub {
+  const key = registryKeyForNick(nick, shards);
+  return env.REGISTRY_DO_REAL.get(env.REGISTRY_DO_REAL.idFromName(key));
+}
+
+/** Convenience: addresses a shard directly by its numeric index. */
+function shardByIndex(index: number, shards = DEFAULT_REGISTRY_SHARDS): DurableObjectStub {
+  return env.REGISTRY_DO_REAL.get(
+    env.REGISTRY_DO_REAL.idFromName(registryKeyForNick(`__shard${index}`, shards)),
+  );
+}
+
+interface RegistryRpc {
+  reserveNick(nick: string, conn: string): Promise<{ ok: true } | { ok: false }>;
+  changeNick(conn: string, oldNick: string, newNick: string): Promise<boolean>;
+  releaseNick(nick: string): Promise<void>;
+  lookupNick(nick: string): Promise<string | null>;
+}
+
+function rpc(stub: DurableObjectStub): RegistryRpc {
+  return stub as unknown as RegistryRpc;
+}
+
+// ---------------------------------------------------------------------------
+// reserveNick
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — reserveNick', () => {
+  it('succeeds for a fresh nick', async () => {
+    const stub = shardForNick('alice');
+    const result = await rpc(stub).reserveNick('alice', 'conn-1');
+    expect(result).toEqual({ ok: true });
+  });
+
+  it('stores the owner so a subsequent lookup resolves the conn', async () => {
+    const stub = shardForNick('bob');
+    expect(await rpc(stub).reserveNick('bob', 'conn-2')).toEqual({ ok: true });
+    expect(await rpc(stub).lookupNick('bob')).toBe('conn-2');
+  });
+
+  it('rejects a second reservation by a different conn', async () => {
+    const stub = shardForNick('carol');
+    expect(await rpc(stub).reserveNick('carol', 'conn-3')).toEqual({ ok: true });
+    expect(await rpc(stub).reserveNick('carol', 'conn-4')).toEqual({ ok: false });
+  });
+
+  it('is idempotent for re-reserve by the SAME conn', async () => {
+    // The same client re-sending NICK during registration must not
+    // fail its own reservation.
+    const stub = shardForNick('dave');
+    expect(await rpc(stub).reserveNick('dave', 'conn-5')).toEqual({ ok: true });
+    expect(await rpc(stub).reserveNick('dave', 'conn-5')).toEqual({ ok: true });
+  });
+
+  it('is case-insensitive — Alice and alice collide', async () => {
+    // RFC 1459: nicks are case-insensitive. Both forms MUST map to the
+    // same registry entry. The sharding function already case-folds;
+    // the DO's storage key must too (defence in depth).
+    const stub = shardForNick('eve');
+    expect(await rpc(stub).reserveNick('Eve', 'conn-6')).toEqual({ ok: true });
+    expect(await rpc(stub).reserveNick('eve', 'conn-7')).toEqual({ ok: false });
+    expect(await rpc(stub).lookupNick('EVE')).toBe('conn-6');
+  });
+
+  it('isolates nicks across different shards', async () => {
+    // Pick two nicks guaranteed to live in different shards.
+    const a = 'a';
+    let b = 'b';
+    while (shardNick(a) === shardNick(b)) b += 'z';
+
+    expect(await rpc(shardForNick(a)).reserveNick(a, 'conn-a')).toEqual({ ok: true });
+    // `b` is a different nick in a different shard; reserving it must
+    // succeed regardless of what `a` did.
+    expect(await rpc(shardForNick(b)).reserveNick(b, 'conn-b')).toEqual({ ok: true });
+    expect(await rpc(shardForNick(a)).lookupNick(a)).toBe('conn-a');
+    expect(await rpc(shardForNick(b)).lookupNick(b)).toBe('conn-b');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// The killer property: concurrent reservations from two ConnectionDOs.
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — concurrent reservations for the same nick', () => {
+  it('exactly one of two concurrent reservations wins', async () => {
+    // Two ConnectionDOs race on the same nick. Both calls hit the same
+    // shard (that's the whole point of sharding by nick). The DO's
+    // storage transaction serializes them; exactly one returns ok:true.
+    const stub = shardForNick('race');
+    const [r1, r2] = await Promise.all([
+      rpc(stub).reserveNick('race', 'conn-x'),
+      rpc(stub).reserveNick('race', 'conn-y'),
+    ]);
+    const results = [r1, r2];
+    const winners = results.filter((r) => r.ok === true);
+    const losers = results.filter((r) => r.ok === false);
+    expect(winners.length).toBe(1);
+    expect(losers.length).toBe(1);
+  });
+
+  it('exactly one of three concurrent reservations wins', async () => {
+    const stub = shardForNick('triple');
+    const [r1, r2, r3] = await Promise.all([
+      rpc(stub).reserveNick('triple', 'c1'),
+      rpc(stub).reserveNick('triple', 'c2'),
+      rpc(stub).reserveNick('triple', 'c3'),
+    ]);
+    const results = [r1, r2, r3];
+    expect(results.filter((r) => r.ok === true).length).toBe(1);
+    expect(results.filter((r) => r.ok === false).length).toBe(2);
+  });
+
+  it('after the winner releases, a later reservation succeeds', async () => {
+    const stub = shardForNick('recycle');
+    expect(await rpc(stub).reserveNick('recycle', 'first')).toEqual({ ok: true });
+    expect(await rpc(stub).reserveNick('recycle', 'second')).toEqual({ ok: false });
+    await rpc(stub).releaseNick('recycle');
+    expect(await rpc(stub).reserveNick('recycle', 'second')).toEqual({ ok: true });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// changeNick
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — changeNick (same shard)', () => {
+  it('atomically swaps old → new when both nicks are in this shard', async () => {
+    // Find two nicks that hash to the same shard under the default count.
+    const old = 'm0';
+    let next = `${old}-z`;
+    let guard = 0;
+    while (shardNick(old) !== shardNick(next) && guard < 1000) {
+      next += 'q';
+      guard++;
+    }
+    // Skip the test gracefully if we couldn't find a same-shard pair
+    // (extremely unlikely with 32 shards, but keeps the test honest).
+    if (shardNick(old) !== shardNick(next)) return;
+
+    const stub = shardForNick(old);
+    expect(await rpc(stub).reserveNick(old, 'conn-cn-1')).toEqual({ ok: true });
+
+    const ok = await rpc(stub).changeNick('conn-cn-1', old, next);
+    expect(ok).toBe(true);
+
+    // Old nick is gone; new nick points at the same conn.
+    expect(await rpc(stub).lookupNick(old)).toBeNull();
+    expect(await rpc(stub).lookupNick(next)).toBe('conn-cn-1');
+  });
+
+  it('refuses the change when the new nick is taken by another conn', async () => {
+    // Reserve both nicks by different conns, then attempt changeNick.
+    const a = 'cn-a';
+    let b = 'cn-b';
+    let guard = 0;
+    while (shardNick(a) !== shardNick(b) && guard < 1000) {
+      b += 'z';
+      guard++;
+    }
+    if (shardNick(a) !== shardNick(b)) return;
+
+    const stub = shardForNick(a);
+    expect(await rpc(stub).reserveNick(a, 'conn-1')).toEqual({ ok: true });
+    expect(await rpc(stub).reserveNick(b, 'conn-2')).toEqual({ ok: true });
+
+    const ok = await rpc(stub).changeNick('conn-1', a, b);
+    expect(ok).toBe(false);
+    // State unchanged.
+    expect(await rpc(stub).lookupNick(a)).toBe('conn-1');
+    expect(await rpc(stub).lookupNick(b)).toBe('conn-2');
+  });
+
+  it('allows changeNick to a free nick even if old was never reserved', async () => {
+    // Defensive: if old isn't held, changeNick should still reserve new
+    // (mirrors the in-memory-runtime semantics). Useful for crash recovery.
+    const a = 'cn-recover-a';
+    let b = 'cn-recover-b';
+    let guard = 0;
+    while (shardNick(a) !== shardNick(b) && guard < 1000) {
+      b += 'z';
+      guard++;
+    }
+    if (shardNick(a) !== shardNick(b)) return;
+
+    const stub = shardForNick(a);
+    const ok = await rpc(stub).changeNick('conn-1', a, b);
+    expect(ok).toBe(true);
+    expect(await rpc(stub).lookupNick(b)).toBe('conn-1');
+  });
+
+  it('clears the old nick only when it still points at the caller', async () => {
+    // If another conn stole `old` between reserve and changeNick, the
+    // changeNick caller must not clobber that mapping.
+    const a = 'cn-stale-a';
+    let b = 'cn-stale-b';
+    let guard = 0;
+    while (shardNick(a) !== shardNick(b) && guard < 1000) {
+      b += 'z';
+      guard++;
+    }
+    if (shardNick(a) !== shardNick(b)) return;
+
+    const stub = shardForNick(a);
+    expect(await rpc(stub).reserveNick(a, 'conn-1')).toEqual({ ok: true });
+    // `conn-2` takes over `a` (e.g. after conn-1 was deemed gone).
+    expect(await rpc(stub).reserveNick(a, 'conn-2')).toEqual({ ok: false });
+    // conn-2 forcibly reserves via changeNick-from-itself path:
+    await rpc(stub).releaseNick(a);
+    expect(await rpc(stub).reserveNick(a, 'conn-2')).toEqual({ ok: true });
+
+    const ok = await rpc(stub).changeNick('conn-1', a, b);
+    expect(ok).toBe(false);
+    // conn-2 still owns `a`.
+    expect(await rpc(stub).lookupNick(a)).toBe('conn-2');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// releaseNick
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — releaseNick', () => {
+  it('clears the mapping so the nick becomes available again', async () => {
+    const stub = shardForNick('rel-1');
+    await rpc(stub).reserveNick('rel-1', 'conn-r1');
+    expect(await rpc(stub).lookupNick('rel-1')).toBe('conn-r1');
+
+    await rpc(stub).releaseNick('rel-1');
+    expect(await rpc(stub).lookupNick('rel-1')).toBeNull();
+    expect(await rpc(stub).reserveNick('rel-1', 'conn-r2')).toEqual({ ok: true });
+  });
+
+  it('is idempotent — releasing a missing nick does nothing', async () => {
+    const stub = shardForNick('rel-2');
+    await expect(rpc(stub).releaseNick('never-existed')).resolves.toBeUndefined();
+    await expect(rpc(stub).releaseNick('never-existed')).resolves.toBeUndefined();
+  });
+
+  it('is case-insensitive', async () => {
+    const stub = shardForNick('Rel3');
+    await rpc(stub).reserveNick('REL3', 'conn-r3');
+    await rpc(stub).releaseNick('rel3');
+    expect(await rpc(stub).lookupNick('REL3')).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// lookupNick
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — lookupNick', () => {
+  it('returns null for an unknown nick', async () => {
+    const stub = shardForNick('look-unknown');
+    expect(await rpc(stub).lookupNick('look-unknown')).toBeNull();
+  });
+
+  it('returns the registered conn id', async () => {
+    const stub = shardForNick('look-known');
+    await rpc(stub).reserveNick('look-known', 'conn-lk');
+    expect(await rpc(stub).lookupNick('look-known')).toBe('conn-lk');
+  });
+
+  it('survives a simulated shard reload (storage-backed)', async () => {
+    // Force the DO instance to drop in-memory state by toggling a test
+    // hook; the next call must reload from `state.storage`.
+    const stub = shardForNick('look-persist');
+    await rpc(stub).reserveNick('look-persist', 'conn-lp');
+    await runInDurableObject(stub, (instance: unknown) => {
+      const doi = instance as { __dropCache?: () => void };
+      doi.__dropCache?.();
+    });
+    expect(await rpc(stub).lookupNick('look-persist')).toBe('conn-lp');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Storage isolation between shards
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — shard isolation', () => {
+  it('two shards maintain independent nick maps', async () => {
+    // Address two different shard instances by index; both should be
+    // empty initially, then hold independent entries.
+    const i = shardByIndex(0);
+    const j = shardByIndex(31);
+
+    // Reserve different nicks in each shard; cross-shard lookups must
+    // not find a nick that lives in the other shard.
+    await rpc(i).reserveNick('in-shard-0', 'c0');
+    await rpc(j).reserveNick('in-shard-31', 'c31');
+
+    expect(await rpc(i).lookupNick('in-shard-0')).toBe('c0');
+    expect(await rpc(j).lookupNick('in-shard-31')).toBe('c31');
+    // The DO instance for shard 0 doesn't know about the shard-31 nick.
+    expect(await rpc(i).lookupNick('in-shard-31')).toBeNull();
+  });
+});

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

@@ -0,0 +1,100 @@
+/**
+ * 034 — 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
+ * shard owns a disjoint slice of the nick→connectionId map; two clients
+ * racing on the *same* nick both route to the same shard, where DO
+ * single-threadedness makes the uniqueness invariant structural.
+ *
+ * These are pure-function unit tests; no Durable Object involved.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { DEFAULT_REGISTRY_SHARDS, registryKeyForNick, shardNick } from '../src/sharding';
+
+describe('shardNick', () => {
+  it('returns a non-negative integer below the shard count', () => {
+    for (const nick of ['alice', 'Bob', 'carol123', 'x', 'irc-user']) {
+      const s = shardNick(nick, 32);
+      expect(Number.isInteger(s)).toBe(true);
+      expect(s).toBeGreaterThanOrEqual(0);
+      expect(s).toBeLessThan(32);
+    }
+  });
+
+  it('honors a custom shard count', () => {
+    for (let n = 1; n <= 64; n *= 2) {
+      for (const nick of ['a', 'bb', 'ccc']) {
+        expect(shardNick(nick, n)).toBeLessThan(n);
+        expect(shardNick(nick, n)).toBeGreaterThanOrEqual(0);
+      }
+    }
+  });
+
+  it('is deterministic — same nick + same N always shard alike', () => {
+    const a = shardNick('alice', 32);
+    const b = shardNick('alice', 32);
+    expect(a).toBe(b);
+  });
+
+  it('is case-insensitive — nick and its lowercased form shard alike', () => {
+    // The sharding function MUST case-fold the input: the registry
+    // treats `Alice` and `alice` as the same key (RFC 1459 nick
+    // case-insensitivity), so they MUST land in the same shard.
+    expect(shardNick('Alice', 32)).toBe(shardNick('alice', 32));
+    expect(shardNick('ALICE', 32)).toBe(shardNick('alice', 32));
+    expect(shardNick('BiRd', 32)).toBe(shardNick('bird', 32));
+  });
+
+  it('uses the default shard count (32) when omitted', () => {
+    expect(shardNick('alice')).toBe(shardNick('alice', DEFAULT_REGISTRY_SHARDS));
+  });
+
+  it('throws on non-positive shard count (programming error)', () => {
+    expect(() => shardNick('alice', 0)).toThrow();
+    expect(() => shardNick('alice', -1)).toThrow();
+  });
+
+  it('distributes a synthetic population across all shards', () => {
+    // Generate 10_000 nicks; every shard should get at least one hit.
+    // A reasonable hash spreads inputs roughly uniformly; this guards
+    // against degenerate hashes (e.g. identity, modulo bias on small N).
+    const N = 32;
+    const hits = new Set<number>();
+    for (let i = 0; i < 10_000; i++) {
+      hits.add(shardNick(`user${i}`, N));
+      if (hits.size === N) break;
+    }
+    expect(hits.size).toBe(N);
+  });
+
+  it('is stable across N=1 (single-shard degenerate case)', () => {
+    expect(shardNick('alice', 1)).toBe(0);
+    expect(shardNick('bob', 1)).toBe(0);
+  });
+});
+
+describe('registryKeyForNick', () => {
+  it('returns a stable string key suitable for idFromName', () => {
+    const key = registryKeyForNick('alice', 32);
+    expect(typeof key).toBe('string');
+    expect(key.length).toBeGreaterThan(0);
+  });
+
+  it('agrees with shardNick — same nick → same shard → same key', () => {
+    const N = 32;
+    expect(registryKeyForNick('alice', N)).toBe(registryKeyForNick('alice', N));
+    expect(registryKeyForNick('Alice', N)).toBe(registryKeyForNick('alice', N));
+  });
+
+  it('nicks in different shards produce different keys', () => {
+    // Find two nicks that hash to different shards.
+    const a = 'a';
+    let b = 'b';
+    while (shardNick(a, 32) === shardNick(b, 32)) {
+      b = `${b}z`;
+    }
+    expect(registryKeyForNick(a, 32)).not.toBe(registryKeyForNick(b, 32));
+  });
+});

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

@@ -0,0 +1,33 @@
+/**
+ * Test worker entry point for the cf-adapter `vitest-pool-workers` suite.
+ *
+ * Each test file gets its own isolate with `isolatedStorage: true`, so DO
+ * state is fresh per test. We export the {@link ConnectionDO} plus
+ * collaborators so tests can wire them via `wrangler.test.toml` bindings
+ * and assert cross-DO interactions.
+ *
+ * Bindings:
+ *   - `CONNECTION_DO` → `ConnectionDO` (real, 033).
+ *   - `REGISTRY_DO` → `RecordingRegistryDO` stub used by the
+ *     ConnectionDO tests (033). 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).
+ */
+
+import { ChannelDO } from '../../src/channel-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 default {
+  async fetch(): Promise<Response> {
+    return new Response('cf-adapter test worker', { status: 200 });
+  },
+};

package/packages/cf-adapter/tests/worker/stubs/channel-stub.ts

@@ -0,0 +1,50 @@
+/**
+ * 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,
+ * applyChannelDelta) reach it.
+ *
+ * Each instance is keyed by lowercased channel name (the convention the
+ * real ChannelDO will use). ConnectionDO looks up the right instance via
+ * `env.CHANNEL_DO.idFromName(chanLower)`.
+ */
+
+import { DurableObject } from 'cloudflare:workers';
+
+export interface RecordedChannelCall {
+  method: 'broadcast' | 'applyChannelDelta' | 'getChannelSnapshot';
+  args: unknown[];
+}
+
+interface ChannelRpc {
+  broadcast(lines: unknown[], except?: string): Promise<void>;
+  applyChannelDelta(delta: unknown): Promise<void>;
+  getChannelSnapshot(): Promise<unknown>;
+}
+
+const LOG_KEY = 'channel-call-log';
+
+export class RecordingChannelDO extends DurableObject implements ChannelRpc {
+  private async append(call: RecordedChannelCall): Promise<void> {
+    const existing = (await this.ctx.storage.get<RecordedChannelCall[]>(LOG_KEY)) ?? [];
+    existing.push(call);
+    await this.ctx.storage.put(LOG_KEY, existing);
+  }
+
+  async recordedCalls(): Promise<RecordedChannelCall[]> {
+    return (await this.ctx.storage.get<RecordedChannelCall[]>(LOG_KEY)) ?? [];
+  }
+
+  async broadcast(lines: unknown[], except?: string): Promise<void> {
+    await this.append({ method: 'broadcast', args: [lines, except] });
+  }
+
+  async applyChannelDelta(delta: unknown): Promise<void> {
+    await this.append({ method: 'applyChannelDelta', args: [delta] });
+  }
+
+  async getChannelSnapshot(): Promise<unknown> {
+    await this.append({ method: 'getChannelSnapshot', args: [] });
+    return null;
+  }
+}

package/packages/cf-adapter/tests/worker/stubs/registry-stub.ts

@@ -0,0 +1,57 @@
+/**
+ * Test-only {@link DurableObject} that records every cross-DO call from
+ * {@link ConnectionDO} into its `state.storage`. Tests inspect the call
+ * log via `runInDurableObject` after exercising the connection.
+ *
+ * PLAN §2.1 — the real RegistryDO ships in 034. For 033 we
+ * only need enough surface area to assert that ConnectionDO closes
+ * release the nick and fan out QUIT correctly. The stub records the
+ * requested operations verbatim; it does not enforce uniqueness.
+ */
+
+import { DurableObject } from 'cloudflare:workers';
+
+export interface RecordedRegistryCall {
+  method: 'reserveNick' | 'changeNick' | 'releaseNick' | 'lookupNick';
+  args: unknown[];
+}
+
+interface RegistryRpc {
+  reserveNick(nick: string, conn: string): Promise<{ ok: true } | { ok: false }>;
+  changeNick(conn: string, oldNick: string, newNick: string): Promise<boolean>;
+  releaseNick(nick: string): Promise<void>;
+  lookupNick(nick: string): Promise<string | null>;
+}
+
+const LOG_KEY = 'registry-call-log';
+
+export class RecordingRegistryDO extends DurableObject implements RegistryRpc {
+  private async append(call: RecordedRegistryCall): Promise<void> {
+    const existing = (await this.ctx.storage.get<RecordedRegistryCall[]>(LOG_KEY)) ?? [];
+    existing.push(call);
+    await this.ctx.storage.put(LOG_KEY, existing);
+  }
+
+  async recordedCalls(): Promise<RecordedRegistryCall[]> {
+    return (await this.ctx.storage.get<RecordedRegistryCall[]>(LOG_KEY)) ?? [];
+  }
+
+  async reserveNick(nick: string, conn: string): Promise<{ ok: true } | { ok: false }> {
+    await this.append({ method: 'reserveNick', args: [nick, conn] });
+    return { ok: true };
+  }
+
+  async changeNick(conn: string, oldNick: string, newNick: string): Promise<boolean> {
+    await this.append({ method: 'changeNick', args: [conn, oldNick, newNick] });
+    return true;
+  }
+
+  async releaseNick(nick: string): Promise<void> {
+    await this.append({ method: 'releaseNick', args: [nick] });
+  }
+
+  async lookupNick(nick: string): Promise<string | null> {
+    await this.append({ method: 'lookupNick', args: [nick] });
+    return null;
+  }
+}

package/packages/cf-adapter/tsconfig.build.json

@@ -0,0 +1,16 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "composite": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "tsBuildInfoFile": "./.tsbuildinfo",
+    "types": ["@cloudflare/workers-types"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "tests", "**/*.test.ts"],
+  "references": [
+    { "path": "../irc-core/tsconfig.build.json" },
+    { "path": "../irc-server/tsconfig.build.json" }
+  ]
+}

package/packages/cf-adapter/tsconfig.test.json

@@ -0,0 +1,18 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "types": ["@cloudflare/workers-types"]
+  },
+  "include": [
+    "src/**/*.ts",
+    "tests/**/*.ts",
+    "node_modules/@cloudflare/vitest-pool-workers/types/cloudflare-test.d.ts"
+  ],
+  "exclude": ["dist"],
+  "references": [
+    { "path": "../irc-core/tsconfig.build.json" },
+    { "path": "../irc-server/tsconfig.build.json" },
+    { "path": "../in-memory-runtime/tsconfig.build.json" }
+  ]
+}

package/packages/cf-adapter/vitest.config.ts

@@ -0,0 +1,32 @@
+import { cloudflareTest } from '@cloudflare/vitest-pool-workers';
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      all: false,
+      include: ['src/**/*.ts'],
+      exclude: ['src/**/index.ts'],
+      reporter: ['text', 'html', 'json-summary'],
+      thresholds: {
+        lines: 90,
+        functions: 90,
+        branches: 90,
+        statements: 90,
+      },
+    },
+  },
+  plugins: [
+    cloudflareTest({
+      wrangler: {
+        configPath: './wrangler.test.toml',
+      },
+      miniflare: {
+        // Ensure DO alarms and hibernation are supported in tests.
+        compatibilityFlags: ['nodejs_compat'],
+      },
+    }),
+  ],
+});