serverless-ircd 0.7.0 → 0.8.0

package/packages/cf-adapter/tests/d1-services-store.test.ts

@@ -0,0 +1,582 @@
+/**
+ * D1-backed {@link PersistentServicesStore} for the Cloudflare adapter.
+ *
+ * Exercises the real D1 round-trip via miniflare: every services mutator
+ * enqueues a write-behind op; `flush()` drains it into D1; a fresh
+ * `loadD1ServicesStore` against the same binding rehydrates the snapshot.
+ * This is the services-state persistence contract — a deploy (cold start)
+ * must not lose NickServ / ChanServ / HostServ / MemoServ / OperServ state.
+ */
+
+import { env } from 'cloudflare:test';
+import { FakeClock, type ServicesSnapshot } from '@serverless-ircd/irc-core';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import {
+  CREATE_SERVICES_TABLES_SQL,
+  D1ServicesStore,
+  loadD1ServicesStore,
+} from '../src/d1-services-store';
+
+declare global {
+  namespace Cloudflare {
+    interface Env {
+      ACCOUNTS_DB: D1Database;
+    }
+  }
+}
+
+const NOW = 1_700_000_000_000;
+
+async function resetDb(): Promise<void> {
+  for (const table of [
+    'nickserv_accounts',
+    'chanserv_channels',
+    'chanserv_access',
+    'chanserv_levels',
+    'hostserv_vhosts',
+    'hostserv_pending_vhosts',
+    'memoserv_memos',
+    'read_markers',
+    'operserv_akills',
+    'operserv_jupes',
+  ]) {
+    await env.ACCOUNTS_DB.exec(`DROP TABLE IF EXISTS ${table}`);
+  }
+  for (const sql of CREATE_SERVICES_TABLES_SQL) {
+    await env.ACCOUNTS_DB.exec(sql);
+  }
+}
+
+describe('loadD1ServicesStore — empty binding', () => {
+  it('returns undefined when the D1 binding is absent', async () => {
+    const store = await loadD1ServicesStore(undefined);
+    expect(store).toBeUndefined();
+  });
+});
+
+describe('loadD1ServicesStore — read-from-primary consistency', () => {
+  /**
+   * Builds a fake D1 binding that records the constraint passed to
+   * `withSession`. Every prepare/batch resolves to empty results so the
+   * load completes; the point is to assert the snapshot hydrate runs
+   * through a primary-forcing session, not to exercise D1 itself (miniflare
+   * has no replicas, so replica lag cannot be reproduced end-to-end here).
+   */
+  function makeRecordingFakeD1(): { db: unknown; constraints: string[] } {
+    const constraints: string[] = [];
+    const stmt = {
+      bind(): unknown {
+        return stmt;
+      },
+      async all(): Promise<{ results: unknown[] }> {
+        return { results: [] };
+      },
+      async run(): Promise<{ results: unknown[] }> {
+        return { results: [] };
+      },
+    };
+    const client = {
+      prepare(): unknown {
+        return stmt;
+      },
+      async batch(): Promise<unknown[]> {
+        return [];
+      },
+    };
+    const db = {
+      ...client,
+      withSession(constraint: string): unknown {
+        constraints.push(constraint);
+        return client;
+      },
+    };
+    return { db, constraints };
+  }
+
+  it('hydrates the snapshot through a first-primary D1 session', async () => {
+    const { db, constraints } = makeRecordingFakeD1();
+    const store = await loadD1ServicesStore(db as D1Database, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    // Forces the first read to the primary so a reconnecting client cannot
+    // hydrate from a lagging replica and cache it for the connection's life.
+    expect(constraints).toContain('first-primary');
+  });
+});
+
+describe('D1ServicesStore — schema migration (password → algorithm/salt/hash)', () => {
+  const LEGACY_NICKSERV_DDL =
+    'CREATE TABLE nickserv_accounts (nick_key TEXT PRIMARY KEY, nick TEXT NOT NULL, account TEXT NOT NULL, email TEXT NOT NULL, created_at INTEGER NOT NULL, enforce TEXT NOT NULL, password TEXT NOT NULL)';
+
+  beforeEach(async () => {
+    // Start from the pre-unification schema (single `password` column).
+    await env.ACCOUNTS_DB.exec('DROP TABLE IF EXISTS nickserv_accounts');
+    await env.ACCOUNTS_DB.exec(LEGACY_NICKSERV_DDL);
+  });
+
+  afterEach(async () => {
+    await env.ACCOUNTS_DB.exec('DROP TABLE IF EXISTS nickserv_accounts');
+  });
+
+  it('migrates the legacy nickserv_accounts schema on load', async () => {
+    // Seed a legacy row (unusable under the scrypt verify path).
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO nickserv_accounts (nick_key, nick, account, email, created_at, enforce, password) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    )
+      .bind('alice', 'alice', 'alice', 'a@x', 1, 'none', 'legacy-hash')
+      .run();
+
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+
+    // The table now has the new credential columns and no `password`.
+    const info = await env.ACCOUNTS_DB.prepare('PRAGMA table_info(nickserv_accounts)').all<{
+      name: string;
+    }>();
+    const cols = info.results.map((r) => r.name);
+    expect(cols).toContain('algorithm');
+    expect(cols).toContain('salt');
+    expect(cols).toContain('hash');
+    expect(cols).not.toContain('password');
+
+    // Legacy rows (non-scrypt credentials) are dropped during migration.
+    const rows = await env.ACCOUNTS_DB.prepare('SELECT COUNT(*) AS n FROM nickserv_accounts').all<{
+      n: number;
+    }>();
+    expect(rows.results[0]?.n).toBe(0);
+
+    // A fresh registration round-trips through the migrated schema.
+    store?.registerNick('bob', 'hunter2', 'b@example.com');
+    await store?.flush();
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW + 1000));
+    expect(reloaded?.isRegisteredNick('bob')).toBe(true);
+  });
+
+  it('is idempotent — does not drop data on an already-migrated schema', async () => {
+    const first = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    first?.registerNick('carol', 'pw', 'c@x');
+    await first?.flush();
+
+    // Second load: migration is a no-op (`algorithm` present); carol survives.
+    const second = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW + 1));
+    expect(second?.isRegisteredNick('carol')).toBe(true);
+  });
+});
+
+describe('D1ServicesStore — NickServ round-trip across reload', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('persists a NickServ registration and verifies after reload', async () => {
+    const clock = new FakeClock(NOW);
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, clock);
+    expect(store).toBeDefined();
+    store?.registerNick('alice', 'hunter2', 'a@example.com');
+    await store?.flush();
+
+    // Simulate a deploy: brand-new store rehydrating from D1.
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW + 1000));
+    expect(reloaded).toBeDefined();
+    expect(reloaded?.isRegisteredNick('alice')).toBe(true);
+    // Case-insensitive lookup survives the round-trip.
+    expect(reloaded?.isRegisteredNick('Alice')).toBe(true);
+    expect(reloaded?.verifyNick('alice', 'hunter2')).toEqual({ ok: true, account: 'alice' });
+    expect(reloaded?.verifyNick('alice', 'wrong').ok).toBe(false);
+  });
+
+  it('persists SET ENFORCE and round-trips the policy', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.registerNick('alice', 'pw', 'a@x');
+    store?.setNickEnforce('alice', 'kill');
+    await store?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getNickEnforce('alice')).toBe('kill');
+  });
+
+  it('drops a NickServ registration after flush + reload', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.registerNick('alice', 'pw', 'a@x');
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(mid?.isRegisteredNick('alice')).toBe(true);
+    mid?.dropNick('alice');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.isRegisteredNick('alice')).toBe(false);
+  });
+});
+
+describe('D1ServicesStore — ChanServ round-trip across reload', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('persists channel registration + access + levels + topic', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.registerNick('alice', 'pw', 'a@x');
+    store?.registerChannel('#chan', 'alice');
+    store?.setChannelAccess('#chan', 'bob', 5);
+    store?.setChannelLevel('#chan', 'AUTOOP', 7);
+    store?.setChannelRestricted('#chan', true);
+    store?.setChannelKeepTopic('#chan', true);
+    store?.setChannelTopic('#chan', { text: 'hello', setter: 'alice', setAt: NOW });
+    await store?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getChannelFounder('#chan')).toBe('alice');
+    expect(reloaded?.getChannelAccess('#chan', 'bob')).toBe(5);
+    expect(reloaded?.getChannelLevel('#chan', 'AUTOOP')).toBe(7);
+    expect(reloaded?.getChannel('#chan')?.restricted).toBe(true);
+    expect(reloaded?.getChannelTopic('#chan')).toEqual({
+      text: 'hello',
+      setter: 'alice',
+      setAt: NOW,
+    });
+  });
+
+  it('drops a channel + its access + levels on dropChannel', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.registerChannel('#chan', 'alice');
+    store?.setChannelAccess('#chan', 'bob', 5);
+    store?.setChannelLevel('#chan', 'AUTOOP', 7);
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    mid?.dropChannel('#chan');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getChannelFounder('#chan')).toBeUndefined();
+    expect(reloaded?.getChannelAccess('#chan', 'bob')).toBe(0);
+    expect(reloaded?.getChannelLevel('#chan', 'AUTOOP')).toBeUndefined();
+  });
+
+  it('removes access on setChannelAccess level<=0', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.registerChannel('#chan', 'alice');
+    store?.setChannelAccess('#chan', 'bob', 5);
+    store?.setChannelAccess('#chan', 'bob', 0);
+    await store?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getChannelAccess('#chan', 'bob')).toBe(0);
+  });
+
+  it('resetChannelLevels wipes only levels, leaving access intact', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.registerChannel('#chan', 'alice');
+    store?.setChannelAccess('#chan', 'bob', 5);
+    store?.setChannelLevel('#chan', 'AUTOOP', 7);
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    mid?.resetChannelLevels('#chan');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getChannelLevel('#chan', 'AUTOOP')).toBeUndefined();
+    expect(reloaded?.getChannelAccess('#chan', 'bob')).toBe(5);
+  });
+});
+
+describe('D1ServicesStore — HostServ / MemoServ / read-marker round-trip', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('persists a vhost and clears it on empty', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.setVhost('alice', 'cloak.example');
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(mid?.getVhost('alice')).toBe('cloak.example');
+    mid?.setVhost('alice', '');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getVhost('alice')).toBeUndefined();
+  });
+
+  it('persists a pending vhost request and round-trips it across reload', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.requestVhost('alice', 'queued.example');
+    await store?.flush();
+    expect(store?.getVhost('alice')).toBeUndefined();
+
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(mid?.getPendingVhost('alice')).toBe('queued.example');
+    expect(mid?.getVhost('alice')).toBeUndefined();
+
+    // approveVhost activates the request and clears the pending entry.
+    mid?.approveVhost('alice');
+    await mid?.flush();
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getPendingVhost('alice')).toBeUndefined();
+    expect(reloaded?.getVhost('alice')).toBe('queued.example');
+  });
+
+  it('persists a rejected (dropped) pending request after flush + reload', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.requestVhost('alice', 'queued.example');
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    mid?.rejectVhost('alice');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getPendingVhost('alice')).toBeUndefined();
+    expect(reloaded?.getVhost('alice')).toBeUndefined();
+  });
+
+  it('delivers a queued memo after identify-style reload', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    if (!store) throw new Error('services store failed to load');
+    const id = store.recordMemo({ from: 'bob', to: 'alice', body: 'hi', sentAt: NOW });
+    store.markMemoRead('alice', id);
+    await store.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded).toBeDefined();
+    if (!reloaded) throw new Error('reloaded services store failed to load');
+    const memos = reloaded.listMemos('alice');
+    expect(memos).toHaveLength(1);
+    expect(memos[0]).toMatchObject({ id, from: 'bob', body: 'hi', read: true });
+    // Next id continues after the reloaded max.
+    expect(reloaded.recordMemo({ from: 'x', to: 'alice', body: 'y', sentAt: NOW })).toBe(id + 1);
+  });
+
+  it('deletes a memo after flush + reload', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    if (!store) throw new Error('services store failed to load');
+    const id = store.recordMemo({ from: 'bob', to: 'alice', body: 'hi', sentAt: NOW });
+    await store.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(mid).toBeDefined();
+    if (!mid) throw new Error('mid services store failed to load');
+    mid.deleteMemo('alice', id);
+    await mid.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.listMemos('alice')).toEqual([]);
+  });
+
+  it('persists a draft/read-marker', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.setLastReadMarker('alice', '#chan', 'msgid-9');
+    await store?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.getLastReadMarker('alice', '#chan')).toBe('msgid-9');
+  });
+});
+
+describe('D1ServicesStore — OperServ round-trip', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('persists + matches an AKILL and removes it', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.addAkill('*!*@bad.example', 'flooding');
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(mid?.matchAkill('evil!spam@bad.example')?.reason).toBe('flooding');
+    mid?.removeAkill('*!*@bad.example');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.matchAkill('evil!spam@bad.example')).toBeUndefined();
+  });
+
+  it('persists + queries a JUPE and removes it', async () => {
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    store?.addJupe('moo', 'blocked');
+    await store?.flush();
+    const mid = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(mid?.isJuped('moo')).toBe(true);
+    mid?.removeJupe('moo');
+    await mid?.flush();
+
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(reloaded?.isJuped('moo')).toBe(false);
+  });
+});
+
+describe('D1ServicesStore — auto-provisioning', () => {
+  beforeEach(async () => {
+    await resetDb();
+  });
+
+  it('creates the services tables on load so a fresh deploy persists a registration without manual DDL', async () => {
+    // Simulate a fresh, un-provisioned deploy: every services table absent.
+    for (const table of [
+      'nickserv_accounts',
+      'chanserv_channels',
+      'chanserv_access',
+      'chanserv_levels',
+      'hostserv_vhosts',
+      'hostserv_pending_vhosts',
+      'memoserv_memos',
+      'read_markers',
+      'operserv_akills',
+      'operserv_jupes',
+    ]) {
+      await env.ACCOUNTS_DB.exec(`DROP TABLE IF EXISTS ${table}`);
+    }
+
+    // load must self-provision the schema; flush must not throw.
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    if (!store) throw new Error('services store failed to load');
+    store.registerNick('alice', 'hunter2', 'a@example.com');
+    await expect(store.flush()).resolves.toBeUndefined();
+
+    // A new DO / cold start rehydrates the persisted registration.
+    const reloaded = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW + 1000));
+    expect(reloaded?.isRegisteredNick('alice')).toBe(true);
+    expect(reloaded?.verifyNick('alice', 'hunter2')).toEqual({ ok: true, account: 'alice' });
+  });
+});
+
+describe('D1ServicesStore — tolerance', () => {
+  it('loads an empty snapshot when the tables do not exist yet', async () => {
+    // Fresh deploy: no tables created. load must not throw.
+    for (const table of [
+      'nickserv_accounts',
+      'chanserv_channels',
+      'chanserv_access',
+      'chanserv_levels',
+      'hostserv_vhosts',
+      'hostserv_pending_vhosts',
+      'memoserv_memos',
+      'read_markers',
+      'operserv_akills',
+      'operserv_jupes',
+    ]) {
+      await env.ACCOUNTS_DB.exec(`DROP TABLE IF EXISTS ${table}`);
+    }
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    expect(store?.snapshot()).toEqual(emptySnapshot());
+  });
+
+  it('a flush with no mutations is a no-op', async () => {
+    await resetDb();
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    await expect(store?.flush()).resolves.toBeUndefined();
+  });
+
+  it('skips ill-typed rows during load (defensive coercion)', async () => {
+    await resetDb();
+    // One ill-typed row per INTEGER-corruptible table → each loader's
+    // defensive `continue` fires. (All-TEXT tables — vhosts / read_markers —
+    // are covered by the permissive-table test below; SQLite TEXT affinity
+    // coerces inserted numbers to strings, so the string check cannot be
+    // exercised against a NOT NULL TEXT column.)
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO nickserv_accounts (nick_key, nick, account, email, created_at, enforce, algorithm, salt, hash) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+    )
+      .bind('bad#nick', 'b', 'b', 'b', 'not-a-number', 'none', 'scrypt', 's', 'h')
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO chanserv_channels (channel_key, channel, founder, created_at, mlock, restricted, keep_topic) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    )
+      .bind('bad#chan', '#c', 'f', 1, '', 'not-a-number', 0)
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO chanserv_access (channel_key, account_key, channel, account, level) VALUES (?, ?, ?, ?, ?)',
+    )
+      .bind('bad#a', 'b', '#c', 'b', 'not-a-number')
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO chanserv_levels (channel_key, op, channel, level) VALUES (?, ?, ?, ?)',
+    )
+      .bind('bad#l', 'AUTOOP', '#c', 'not-a-number')
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO memoserv_memos (id, from_account, to_account, body, sent_at, read) VALUES (?, ?, ?, ?, ?, ?)',
+    )
+      .bind(9, 'x', 'y', 'b', 'not-a-number', 0)
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO operserv_akills (mask_key, mask, reason, created_at) VALUES (?, ?, ?, ?)',
+    )
+      .bind('bad#ak', '*!*@x', 'r', 'not-a-number')
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO operserv_jupes (name_key, name, reason, created_at) VALUES (?, ?, ?, ?)',
+    )
+      .bind('bad#jp', 'n', 'r', 'not-a-number')
+      .run();
+
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    if (!store) throw new Error('services store failed to load');
+    const snap = store.snapshot();
+    expect(snap.nicks).toEqual([]);
+    expect(snap.channels).toEqual([]);
+    expect(snap.access).toEqual([]);
+    expect(snap.levels).toEqual([]);
+    expect(snap.memos).toEqual([]);
+    expect(snap.akills).toEqual([]);
+    expect(snap.jupes).toEqual([]);
+  });
+
+  it('skips rows with NULL fields in the all-TEXT tables (vhosts / read_markers)', async () => {
+    // Recreate the two all-TEXT tables without NOT NULL so a NULL field can
+    // survive — exercises the typeof-string defensive skip for the loaders
+    // whose INTEGER-corruption path is unreachable under SQLite affinity.
+    await env.ACCOUNTS_DB.exec('DROP TABLE hostserv_vhosts');
+    await env.ACCOUNTS_DB.exec(
+      'CREATE TABLE hostserv_vhosts (account_key TEXT PRIMARY KEY, account TEXT, vhost TEXT)',
+    );
+    await env.ACCOUNTS_DB.exec('DROP TABLE read_markers');
+    await env.ACCOUNTS_DB.exec(
+      'CREATE TABLE read_markers (account_key TEXT NOT NULL, channel_key TEXT NOT NULL, account TEXT, channel TEXT, msgid TEXT)',
+    );
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO hostserv_vhosts (account_key, account, vhost) VALUES (?, ?, ?)',
+    )
+      .bind('bad#v', null, 'cloak')
+      .run();
+    await env.ACCOUNTS_DB.prepare(
+      'INSERT INTO read_markers (account_key, channel_key, account, channel, msgid) VALUES (?, ?, ?, ?, ?)',
+    )
+      .bind('bad#rm', '#c', 'a', '#c', null)
+      .run();
+
+    const store = await loadD1ServicesStore(env.ACCOUNTS_DB, new FakeClock(NOW));
+    expect(store).toBeDefined();
+    if (!store) throw new Error('services store failed to load');
+    const snap = store.snapshot();
+    expect(snap.vhosts).toEqual([]);
+    expect(snap.readMarkers).toEqual([]);
+  });
+
+  it('constructs with defaults (no clock / no snapshot)', async () => {
+    await resetDb();
+    // Direct construction without clock/snapshot exercises the constructor's
+    // undefined branches (loadD1ServicesStore always passes both).
+    const store = new D1ServicesStore({ db: env.ACCOUNTS_DB });
+    store.registerNick('alice', 'pw', 'a@x');
+    await store.flush();
+    expect(store.isRegisteredNick('alice')).toBe(true);
+  });
+});
+
+function emptySnapshot(): ServicesSnapshot {
+  return {
+    nicks: [],
+    channels: [],
+    access: [],
+    levels: [],
+    vhosts: [],
+    pendingVhosts: [],
+    memos: [],
+    readMarkers: [],
+    akills: [],
+    jupes: [],
+  };
+}

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

@@ -35,6 +35,7 @@ function fullState(): ConnectionState {
     wallops: true,
     serverNotices: false,
     tls: true,
+    registered: false,
   };
   s.lastSeen = 200;
   return s;

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

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/in-memory-runtime",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Single-process reference implementation of the IrcRuntime port, backed by Maps",
   "license": "BSD-3-Clause",

package/packages/irc-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "description": "Platform-agnostic IRC protocol core: parser, serializer, command reducers, state shapes",
   "license": "BSD-3-Clause",

package/packages/irc-core/scripts/generate-build-info.mjs

@@ -1,10 +1,16 @@
 /**
- * Generates `src/build-info.ts` containing the build timestamp.
+ * Generates `src/build-info.ts` containing build-time constants.
+ *
+ *   - `BUILD_DATE`: ISO timestamp of the build that produced this artifact.
+ *   - `PACKAGE_VERSION`: the `version` field from `package.json`, so the
+ *     default server version advertised on the wire always tracks the
+ *     shipped package version without anyone remembering to update a
+ *     hardcoded constant.
  *
  * Runs as a `prebuild` / `pretest` / `pretypecheck` / `prepare` hook so the
  * file always exists before tsc or vitest resolves `./build-info.js` imports.
  * The emitted file is gitignored — it is regenerated on every build so the
- * published `dist/index.js` carries the timestamp of the build that produced
+ * published `dist/index.js` carries the values of the build that produced
  * it, never a stale committed value.
  *
  * Output shape:
@@ -12,20 +18,35 @@
  * ```ts
  * // AUTO-GENERATED by scripts/generate-build-info.mjs — do not edit.
  * export const BUILD_DATE = '2024-01-01T00:00:00.000Z';
+ * export const PACKAGE_VERSION = '0.7.0';
  * ```
  *
  * Failures here must abort the build rather than emit a half-file: a missing
  * or malformed `build-info.ts` would break every downstream tsc invocation.
  */
-import { writeFileSync } from 'node:fs';
+import { readFileSync, writeFileSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const target = resolve(here, '..', 'src', 'build-info.ts');
+const pkgPath = resolve(here, '..', 'package.json');
+
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+const pkgVersion = pkg?.version;
+if (typeof pkgVersion !== 'string' || pkgVersion.length === 0) {
+  throw new Error(`[generate-build-info] package.json is missing a valid "version" string`);
+}
 
 const iso = new Date().toISOString();
-const contents = `// AUTO-GENERATED by scripts/generate-build-info.mjs — do not edit.\nexport const BUILD_DATE = ${JSON.stringify(iso)};\n`;
+const contents = [
+  '// AUTO-GENERATED by scripts/generate-build-info.mjs — do not edit.',
+  `export const BUILD_DATE = ${JSON.stringify(iso)};`,
+  `export const PACKAGE_VERSION = ${JSON.stringify(pkgVersion)};`,
+  '',
+].join('\n');
 
 writeFileSync(target, contents, 'utf8');
-console.log(`[generate-build-info] wrote ${target} (BUILD_DATE=${iso})`);
+console.log(
+  `[generate-build-info] wrote ${target} (BUILD_DATE=${iso}, PACKAGE_VERSION=${pkgVersion})`,
+);