serverless-ircd 0.5.0 → 0.7.0

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

@@ -169,3 +169,52 @@ describe('loadServerConfigFromCfEnv — failure modes', () => {
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// SASL_ACCOUNTS env parsing — malformed entries are skipped, valid ones kept.
+// ---------------------------------------------------------------------------
+
+describe('loadServerConfigFromCfEnv — SASL_ACCOUNTS parsing', () => {
+  it('skips blank lines within the seed', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      SASL_ACCOUNTS: 'alice:secret\n\nbob:password\n   \n',
+    });
+    expect(cfg.saslAccounts).toEqual([
+      { username: 'alice', password: 'secret' },
+      { username: 'bob', password: 'password' },
+    ]);
+  });
+
+  it('skips lines with no colon separator', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      SASL_ACCOUNTS: 'alice:secret\nnocolonhere\nbob:password',
+    });
+    expect(cfg.saslAccounts).toHaveLength(2);
+  });
+
+  it('skips lines where the colon is at position 0 (empty username)', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      SASL_ACCOUNTS: ':secret\nalice:valid',
+    });
+    expect(cfg.saslAccounts).toEqual([{ username: 'alice', password: 'valid' }]);
+  });
+
+  it('skips lines with an empty password after the colon', () => {
+    const cfg = loadServerConfigFromCfEnv({
+      ...baseEnv(),
+      SASL_ACCOUNTS: 'alice:\nbob:valid',
+    });
+    expect(cfg.saslAccounts).toEqual([{ username: 'bob', password: 'valid' }]);
+  });
+
+  it('passes CREATED_AT verbatim when it overflows Number precision', () => {
+    // A digit string so large that Number() produces Infinity — the
+    // parser must fall back to the raw string rather than emit Infinity.
+    const huge = '9'.repeat(400);
+    const cfg = loadServerConfigFromCfEnv({ ...baseEnv(), CREATED_AT: huge });
+    expect(cfg.createdAt).toBe(huge);
+  });
+});

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

@@ -0,0 +1,91 @@
+/**
+ * Pure exported helpers from `connection-do.ts`.
+ *
+ * These functions are independent of Durable Object state, so they are
+ * unit-tested directly without the workerd/miniflare DO harness.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { parseSaslAccountsEnv, wsFrameModeFromTags } from '../src/connection-do';
+
+describe('parseSaslAccountsEnv', () => {
+  it('returns an empty array for undefined input', () => {
+    expect(parseSaslAccountsEnv(undefined)).toEqual([]);
+  });
+
+  it('returns an empty array for an empty string', () => {
+    expect(parseSaslAccountsEnv('')).toEqual([]);
+  });
+
+  it('parses a single well-formed entry', () => {
+    expect(parseSaslAccountsEnv('alice:secret')).toEqual([
+      { username: 'alice', password: 'secret' },
+    ]);
+  });
+
+  it('parses multiple newline-delimited entries', () => {
+    expect(parseSaslAccountsEnv('alice:secret\nbob:pw')).toEqual([
+      { username: 'alice', password: 'secret' },
+      { username: 'bob', password: 'pw' },
+    ]);
+  });
+
+  it('skips blank lines', () => {
+    expect(parseSaslAccountsEnv('alice:secret\n\nbob:pw\n   \n')).toEqual([
+      { username: 'alice', password: 'secret' },
+      { username: 'bob', password: 'pw' },
+    ]);
+  });
+
+  it('skips lines with no colon separator', () => {
+    expect(parseSaslAccountsEnv('alice:secret\nnocolonhere\nbob:pw')).toEqual([
+      { username: 'alice', password: 'secret' },
+      { username: 'bob', password: 'pw' },
+    ]);
+  });
+
+  it('skips lines where the colon is at position 0 (empty username)', () => {
+    expect(parseSaslAccountsEnv(':secret\nalice:valid')).toEqual([
+      { username: 'alice', password: 'valid' },
+    ]);
+  });
+
+  it('skips lines with an empty password after the colon', () => {
+    expect(parseSaslAccountsEnv('alice:\nbob:valid')).toEqual([
+      { username: 'bob', password: 'valid' },
+    ]);
+  });
+
+  it('returns an empty array when every line is malformed', () => {
+    expect(parseSaslAccountsEnv('\n   \n:no-user\nuser:')).toEqual([]);
+  });
+});
+
+describe('wsFrameModeFromTags', () => {
+  it("returns 'legacy' when no tags are present", () => {
+    expect(wsFrameModeFromTags([])).toBe('legacy');
+  });
+
+  it("returns 'legacy' when no recognized tag matches", () => {
+    // Unknown tags (e.g. from an older deployment's tag scheme) fall
+    // back to the legacy-tolerant mode.
+    expect(wsFrameModeFromTags(['unknown:tag', 'another'])).toBe('legacy');
+  });
+
+  it("returns 'spec-text' when the spec-text tag is present", () => {
+    expect(wsFrameModeFromTags(['ws:spec-text'])).toBe('spec-text');
+  });
+
+  it("returns 'spec-binary' when the spec-binary tag is present", () => {
+    expect(wsFrameModeFromTags(['ws:spec-binary'])).toBe('spec-binary');
+  });
+
+  it("returns 'legacy' when the legacy tag is present", () => {
+    expect(wsFrameModeFromTags(['ws:legacy'])).toBe('legacy');
+  });
+
+  it('picks the first recognized tag when multiple are present', () => {
+    // The scan is order-sensitive; the first matching tag wins.
+    expect(wsFrameModeFromTags(['ws:spec-text', 'ws:legacy'])).toBe('spec-text');
+  });
+});

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

@@ -224,3 +224,51 @@ describe('resolveAccountStore precedence', () => {
     ).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// resolveAccountStore seed parsing — malformed entries are skipped so a
+// trailing newline or partial edit does not break boot.
+// ---------------------------------------------------------------------------
+
+describe('resolveAccountStore — SASL_ACCOUNTS seed edge cases', () => {
+  it('skips blank lines within the seed', async () => {
+    const store = await resolveAccountStore(undefined, 'alice:secret\n\nbob:pw\n   \n');
+    expect(store).toBeDefined();
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'secret' }).ok,
+    ).toBe(true);
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'bob', password: 'pw' }).ok).toBe(
+      true,
+    );
+  });
+
+  it('skips lines with no colon separator', async () => {
+    const store = await resolveAccountStore(undefined, 'alice:secret\nnocolon\nbob:pw');
+    // Only the two well-formed entries are loaded.
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'nocolon', password: '' }).ok).toBe(
+      false,
+    );
+    expect(
+      store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'secret' }).ok,
+    ).toBe(true);
+  });
+
+  it('skips lines where the colon is at position 0', async () => {
+    const store = await resolveAccountStore(undefined, ':secret\nalice:valid');
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'alice', password: 'valid' }).ok).toBe(
+      true,
+    );
+  });
+
+  it('skips lines with an empty password', async () => {
+    const store = await resolveAccountStore(undefined, 'alice:\nbob:valid');
+    expect(store?.verify('PLAIN', { kind: 'PLAIN', username: 'bob', password: 'valid' }).ok).toBe(
+      true,
+    );
+  });
+
+  it('returns undefined when every line is malformed', async () => {
+    const store = await resolveAccountStore(undefined, '\n   \n:no-user\nuser:');
+    expect(store).toBeUndefined();
+  });
+});

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

@@ -53,6 +53,7 @@ interface RegistryRpc {
   changeNick(conn: string, oldNick: string, newNick: string): Promise<boolean>;
   releaseNick(nick: string): Promise<void>;
   lookupNick(nick: string): Promise<string | null>;
+  listEntries(): Promise<Array<[nickLower: string, connId: string]>>;
 }
 
 function rpc(stub: DurableObjectStub): RegistryRpc {
@@ -333,3 +334,106 @@ describe('RegistryDO — shard isolation', () => {
     expect(await rpc(i).lookupNick('in-shard-31')).toBeNull();
   });
 });
+
+// ---------------------------------------------------------------------------
+// changeNick — direct contract tests (sharding is a CfRuntime concern; the
+// DO method itself operates on whatever keys it is given, so we address a
+// single DO instance directly to exercise every branch without depending on
+// the FNV-1a hash landing two nicks in the same shard).
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — changeNick branch coverage (direct on one shard)', () => {
+  // Pin every test to a single, stable shard instance. The DO method is
+  // agnostic to which shard it lives on; what matters is the storage
+  // state we put in place before the call.
+  const shard = () => shardByIndex(1);
+
+  it('returns false when the new nick is held by a different conn', async () => {
+    const s = shard();
+    // Seed storage so both `taken` and `current` are owned by different
+    // conns on this same DO.
+    expect(await rpc(s).reserveNick('taken-new', 'conn-owner')).toEqual({ ok: true });
+    expect(await rpc(s).reserveNick('current-old', 'conn-changer')).toEqual({ ok: true });
+
+    const ok = await rpc(s).changeNick('conn-changer', 'current-old', 'taken-new');
+    expect(ok).toBe(false);
+    // State untouched: owners stay as they were.
+    expect(await rpc(s).lookupNick('taken-new')).toBe('conn-owner');
+    expect(await rpc(s).lookupNick('current-old')).toBe('conn-changer');
+  });
+
+  it('clears the old nick when it still points at the caller', async () => {
+    const s = shard();
+    expect(await rpc(s).reserveNick('cn-clear-old', 'conn-self')).toEqual({ ok: true });
+
+    const ok = await rpc(s).changeNick('conn-self', 'cn-clear-old', 'cn-clear-new');
+    expect(ok).toBe(true);
+    expect(await rpc(s).lookupNick('cn-clear-old')).toBeNull();
+    expect(await rpc(s).lookupNick('cn-clear-new')).toBe('conn-self');
+  });
+
+  it('leaves a stale old nick alone when it no longer points at the caller', async () => {
+    // Crash-recovery / race defence: another conn grabbed `old` between
+    // our reserve and our changeNick. The conditional delete must not
+    // clobber that third party.
+    const s = shard();
+    // `old` is currently held by `conn-other`, not by `conn-caller`.
+    expect(await rpc(s).reserveNick('cn-stale-old', 'conn-other')).toEqual({ ok: true });
+
+    const ok = await rpc(s).changeNick('conn-caller', 'cn-stale-old', 'cn-stale-new');
+    expect(ok).toBe(true);
+    // New nick reserved for the caller...
+    expect(await rpc(s).lookupNick('cn-stale-new')).toBe('conn-caller');
+    // ...but `old` is untouched because it never pointed at the caller.
+    expect(await rpc(s).lookupNick('cn-stale-old')).toBe('conn-other');
+  });
+});
+
+// ---------------------------------------------------------------------------
+// listEntries — backs the global WALLOPS fan-out (CfRuntime.broadcastWallops
+// walks every shard via this method).
+// ---------------------------------------------------------------------------
+
+describe('RegistryDO — listEntries', () => {
+  it('returns an empty array for a fresh shard', async () => {
+    expect(await rpc(shardByIndex(2)).listEntries()).toEqual([]);
+  });
+
+  it('enumerates every (nickLower, connId) pair in this shard', async () => {
+    const s = shardByIndex(3);
+    await rpc(s).reserveNick('Alice', 'conn-a');
+    await rpc(s).reserveNick('Bob', 'conn-b');
+    await rpc(s).reserveNick('Carol', 'conn-c');
+
+    const entries = await rpc(s).listEntries();
+    // Keys are lowercased in storage; the strip recovers the lowercased
+    // nick (matches what CfRuntime expects when deduping conn ids).
+    const sorted = [...entries].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    expect(sorted).toEqual([
+      ['alice', 'conn-a'],
+      ['bob', 'conn-b'],
+      ['carol', 'conn-c'],
+    ]);
+  });
+
+  it('reflects releases: a freed nick drops out of the listing', async () => {
+    const s = shardByIndex(4);
+    await rpc(s).reserveNick('keep', 'conn-k');
+    await rpc(s).reserveNick('drop', 'conn-d');
+    await rpc(s).releaseNick('drop');
+
+    const entries = await rpc(s).listEntries();
+    expect(entries).toEqual([['keep', 'conn-k']]);
+  });
+
+  it('strips the storage prefix so callers see a bare nickLower', async () => {
+    const s = shardByIndex(5);
+    await rpc(s).reserveNick('prefixed', 'conn-p');
+    const entries = await rpc(s).listEntries();
+    const nickLower = entries[0]?.[0];
+    // The internal key is `nick:prefixed`; the public API must not leak
+    // that implementation detail.
+    expect(nickLower).toBe('prefixed');
+    expect(nickLower?.startsWith('nick:')).toBe(false);
+  });
+});

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

@@ -0,0 +1,308 @@
+/**
+ * `serialize` / `deserialize` / `migrate`.
+ *
+ * These helpers bridge {@link ConnectionState} (which carries `Set` and
+ * `Map` fields that degrade under `JSON.stringify`) and the JSON-safe
+ * {@link PersistedConnectionState} shape stored in DO transactional KV.
+ *
+ * Coverage focus: every optional-field branch in both directions, the
+ * `secure` / `userModes.tls` backfill paths in `migrate`, and the
+ * rejection paths (non-object record, too-new version).
+ */
+
+import { type ConnectionState, createConnection } from '@serverless-ircd/irc-core';
+import { describe, expect, it } from 'vitest';
+import { PERSISTED_STATE_VERSION, deserialize, migrate, serialize } from '../src/serialize';
+
+/** Builds a fully-populated connection state for round-trip assertions. */
+function fullState(): ConnectionState {
+  const s = createConnection({ id: 'conn-1', connectedSince: 100 });
+  s.registration = 'registered';
+  s.capNegotiating = false;
+  s.secure = true;
+  s.nick = 'Alice';
+  s.user = 'alice';
+  s.host = 'example.com';
+  s.realname = 'Alice Example';
+  s.passAttempt = 'hunter2';
+  s.account = 'alice-account';
+  s.away = 'brb';
+  s.caps = new Set(['server-time', 'message-tags']);
+  s.joinedChannels = new Set(['#one', '#two']);
+  s.userModes = {
+    invisible: true,
+    oper: false,
+    wallops: true,
+    serverNotices: false,
+    tls: true,
+  };
+  s.lastSeen = 200;
+  return s;
+}
+
+describe('serialize — round trip', () => {
+  it('survives serialize → deserialize for a fully-populated state', () => {
+    const original = fullState();
+    const round = deserialize(serialize(original));
+    // Sets are rebuilt with the same members.
+    expect(round.caps).toEqual(new Set(['server-time', 'message-tags']));
+    expect(round.joinedChannels).toEqual(new Set(['#one', '#two']));
+    // Optional fields preserved.
+    expect(round.nick).toBe('Alice');
+    expect(round.user).toBe('alice');
+    expect(round.host).toBe('example.com');
+    expect(round.realname).toBe('Alice Example');
+    expect(round.passAttempt).toBe('hunter2');
+    expect(round.account).toBe('alice-account');
+    expect(round.away).toBe('brb');
+    // userModes cloned (mutating the round trip must not leak back).
+    expect(round.userModes).toEqual(original.userModes);
+    expect(round.userModes).not.toBe(original.userModes);
+    expect(round.secure).toBe(true);
+  });
+
+  it('is JSON-stable: serialize → JSON.stringify → JSON.parse → deserialize', () => {
+    // This is the actual production path through DO storage: the runtime
+    // structured-clones the value, but the persisted shape must also be
+    // JSON-tolerant for older storage rows and snapshots written to R2.
+    const original = fullState();
+    const json = JSON.stringify(serialize(original));
+    const round = deserialize(JSON.parse(json));
+    expect(round.caps).toEqual(original.caps);
+    expect(round.nick).toBe(original.nick);
+    expect(round.away).toBe(original.away);
+  });
+
+  it('stamps the current persisted schema version', () => {
+    expect(serialize(fullState()).version).toBe(PERSISTED_STATE_VERSION);
+  });
+});
+
+describe('serialize — optional-field branches', () => {
+  it('omits host when undefined', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.nick = 'n';
+    expect(serialize(s).host).toBeUndefined();
+  });
+
+  it('omits passAttempt when undefined', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    expect(serialize(s).passAttempt).toBeUndefined();
+  });
+
+  it('omits away when undefined', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    expect(serialize(s).away).toBeUndefined();
+  });
+
+  it('clones caps and joinedChannels arrays away from the live Set', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.caps = new Set(['a']);
+    s.joinedChannels = new Set(['#x']);
+    const out = serialize(s);
+    expect(out.caps).toEqual(['a']);
+    expect(out.joinedChannels).toEqual(['#x']);
+  });
+});
+
+describe('deserialize — optional-field branches', () => {
+  it('populates host when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.host = 'host.example';
+    expect(deserialize(serialize(s)).host).toBe('host.example');
+  });
+
+  it('populates passAttempt when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.passAttempt = 'pw';
+    expect(deserialize(serialize(s)).passAttempt).toBe('pw');
+  });
+
+  it('populates account when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.account = 'acc';
+    expect(deserialize(serialize(s)).account).toBe('acc');
+  });
+
+  it('populates away when the persisted record carries it', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    s.away = 'afk';
+    expect(deserialize(serialize(s)).away).toBe('afk');
+  });
+
+  it('leaves optional fields absent on a minimal pre-registration state', () => {
+    const s = createConnection({ id: 'c', connectedSince: 0 });
+    const round = deserialize(serialize(s));
+    expect(round.nick).toBeUndefined();
+    expect(round.host).toBeUndefined();
+    expect(round.away).toBeUndefined();
+    expect(round.account).toBeUndefined();
+    expect(round.passAttempt).toBeUndefined();
+  });
+});
+
+describe('migrate — backfills additive fields', () => {
+  it('defaults `secure` to false when the field is absent', () => {
+    // Pre-feature record: no `secure` key at all.
+    const legacy = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    const migrated = migrate(legacy);
+    expect(migrated.secure).toBe(false);
+    // The mutation landed on the original object reference (defensive
+    // backfill writes through to the record).
+    expect((legacy as Record<string, unknown>).secure).toBe(false);
+  });
+
+  it('defaults `userModes.tls` to false when the field is absent', () => {
+    const legacy = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    const migrated = migrate(legacy);
+    expect(migrated.userModes.tls).toBe(false);
+  });
+
+  it('leaves an explicit `secure: true` untouched', () => {
+    const rec = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      secure: true,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+        tls: true,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(migrate(rec).secure).toBe(true);
+    expect(migrate(rec).userModes.tls).toBe(true);
+  });
+
+  it('tolerates a missing `userModes` object without throwing', () => {
+    // A record corrupted in storage (or hand-built by an older code
+    // path) might not carry userModes at all. Migrate must not crash.
+    const rec = {
+      version: 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(() => migrate(rec)).not.toThrow();
+  });
+});
+
+describe('migrate — rejection paths', () => {
+  it('rejects a non-object record', () => {
+    for (const bad of [null, 'string', 42, true, undefined]) {
+      expect(() => migrate(bad)).toThrow(/not an object/u);
+    }
+  });
+
+  it('rejects an array record (arrays are not plain objects)', () => {
+    expect(() => migrate([])).toThrow(/not an object/u);
+  });
+
+  it('rejects a record persisted with a newer schema version', () => {
+    const future = {
+      version: PERSISTED_STATE_VERSION + 1,
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+        tls: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(() => migrate(future)).toThrow(/newer than/u);
+  });
+
+  it('treats a missing version as the legacy default (0)', () => {
+    // No `version` field — old shape. Migrate must accept it rather
+    // than fail the boot path; the backfill covers the additive keys.
+    const legacy = {
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: [],
+      joinedChannels: [],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: false,
+        serverNotices: false,
+      },
+      lastSeen: 0,
+      connectedSince: 0,
+    };
+    expect(() => migrate(legacy)).not.toThrow();
+  });
+});
+
+describe('deserialize — migrate integration', () => {
+  it('backfills `secure` and `userModes.tls` on a legacy record, then materializes', () => {
+    const legacy = {
+      id: 'c',
+      registration: 'registered' as const,
+      capNegotiating: false,
+      caps: ['server-time'],
+      joinedChannels: ['#x'],
+      userModes: {
+        invisible: false,
+        oper: false,
+        wallops: true,
+        serverNotices: false,
+      },
+      lastSeen: 5,
+      connectedSince: 1,
+    };
+    const state = deserialize(legacy);
+    expect(state.secure).toBe(false);
+    expect(state.userModes.tls).toBe(false);
+    expect(state.userModes.wallops).toBe(true);
+    expect(state.caps).toEqual(new Set(['server-time']));
+  });
+});

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

@@ -5,7 +5,7 @@ export default defineConfig({
   test: {
     include: ['tests/**/*.test.ts'],
     coverage: {
-      provider: 'v8',
+      provider: 'istanbul',
       all: false,
       include: ['src/**/*.ts'],
       exclude: ['src/**/index.ts'],

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

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/in-memory-runtime",
-  "version": "0.5.0",
+  "version": "0.7.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.5.0",
+  "version": "0.7.0",
   "private": true,
   "description": "Platform-agnostic IRC protocol core: parser, serializer, command reducers, state shapes",
   "license": "BSD-3-Clause",