serverless-ircd 0.8.0 → 0.10.0

package/apps/cf-tcp-container/tests/config-loader.test.ts

@@ -161,6 +161,49 @@ describe('config-loader — container-specific knobs', () => {
     expect(cfg.server.operCreds).toEqual([{ user: 'admin', password: 'secret' }]);
   });
 
+  it('exercises the OPER_PASSWORD ?? "" default then rejects partial OPER_USER-only creds', () => {
+    // The `?? ''` default for the missing OPER_PASSWORD is exercised, but
+    // parseServerConfig then rejects the empty password — partial oper
+    // creds are a misconfiguration, not a silently-accepted one.
+    expect(() =>
+      loadContainerConfig({
+        SERVER_NAME: 'irc.test',
+        NETWORK_NAME: 'TestNet',
+        OPER_USER: 'admin',
+      }),
+    ).toThrowError(/password/u);
+  });
+
+  it('exercises the OPER_USER ?? "" default then rejects partial OPER_PASSWORD-only creds', () => {
+    expect(() =>
+      loadContainerConfig({
+        SERVER_NAME: 'irc.test',
+        NETWORK_NAME: 'TestNet',
+        OPER_PASSWORD: 'secret',
+      }),
+    ).toThrowError(/user/u);
+  });
+
+  it('treats an overflow-numeric CREATED_AT (Infinity) as a verbatim string', () => {
+    const cfg = loadContainerConfig({
+      SERVER_NAME: 'irc.test',
+      NETWORK_NAME: 'TestNet',
+      // 400 nines overflows Number.MAX_VALUE → Number() yields Infinity,
+      // which is not finite, so parseCreatedAt falls through to the raw string.
+      CREATED_AT: '9'.repeat(400),
+    });
+    expect(cfg.server.createdAt).toBe('9'.repeat(400));
+  });
+
+  it('skips a SASL line whose username is set but password is empty', () => {
+    const cfg = loadContainerConfig({
+      SERVER_NAME: 'irc.test',
+      NETWORK_NAME: 'TestNet',
+      SASL_ACCOUNTS: 'alice:\nbob:valid',
+    });
+    expect(cfg.server.saslAccounts).toEqual([{ username: 'bob', password: 'valid' }]);
+  });
+
   it('skips malformed SASL account lines', () => {
     const cfg = loadContainerConfig({
       SERVER_NAME: 'irc.test',

package/apps/cf-tcp-container/tests/container-server.test.ts

@@ -128,6 +128,58 @@ describe('container-server — lifecycle', () => {
   });
 });
 
+describe('container-server — option wiring (coverage matrix)', () => {
+  // Exercises the `opts.X ?? default` / `opts.X !== undefined ? ... : ...`
+  // branches in startContainerServer by starting the server with each optional
+  // knob set, so every "option provided" branch is taken at least once.
+
+  it('binds the default host when `host` is omitted', async () => {
+    const srv = await startContainerServer({
+      port: 0,
+      serverName: 'irc.defaulthost',
+      networkName: 'DefaultHostNet',
+    });
+    expect(srv.host).toBe('0.0.0.0');
+    // Connecting via 127.0.0.1 still reaches the 0.0.0.0 listener.
+    const c = new TcpClient('127.0.0.1', srv.port);
+    await c.opened();
+    await c.close();
+    await srv.close();
+  });
+
+  it('applies the default admission knobs when only maxConnectionsPerUser is set', async () => {
+    // Setting only maxConnectionsPerUser builds the admission config, so
+    // maxConnectionsPerIp and perIpConnectionRate fall back to their defaults.
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.admission',
+      networkName: 'AdmissionNet',
+      maxConnectionsPerUser: 5,
+    });
+    const c = new TcpClient('127.0.0.1', srv.port);
+    await c.opened();
+    await c.close();
+    await srv.close();
+  });
+
+  it('wires saslAccounts, serverPassword, and cloaking when provided', async () => {
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.options',
+      networkName: 'OptionsNet',
+      serverPassword: 'secret',
+      cloaking: { enabled: true, secret: 'cloak-secret', cloakedSuffix: '.hidden' },
+      saslAccounts: [{ username: 'alice', password: 'pw' }],
+    });
+    const c = new TcpClient('127.0.0.1', srv.port);
+    await c.opened();
+    await c.close();
+    await srv.close();
+  });
+});
+
 describe('container-server — IRC flows over TCP', () => {
   let server: ContainerServer;
 
@@ -329,7 +381,6 @@ describe('container-server — snapshot error resilience', () => {
     const path = join(dir, 'corrupt.json');
     const { writeFile } = await import('node:fs/promises');
     await writeFile(path, '{ this is not valid json', 'utf8');
-
     const srv = await startContainerServer({
       port: 0,
       host: '127.0.0.1',
@@ -373,6 +424,61 @@ describe('container-server — snapshot error resilience', () => {
     expect(c.socket.destroyed).toBe(true);
     await rm(dir, { recursive: true, force: true });
   });
+
+  it('close() skips sockets that are already destroyed', async () => {
+    // Covers closeServer's `!socket.destroyed` false branch: a server-side
+    // socket destroyed in the same tick as close() is still in the sockets
+    // set (its 'close' cleanup is async) but already destroyed.
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.skip',
+      networkName: 'SkipNet',
+    });
+    const c = new TcpClient('127.0.0.1', srv.port);
+    await c.opened();
+    for (let i = 0; i < 50 && srv.testSockets.size === 0; i++) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    const serverSideSocket = [...srv.testSockets][0];
+    if (serverSideSocket === undefined) throw new Error('no server-side socket');
+    // Destroy the server-side socket synchronously; its 'close' handler
+    // (which would remove it from the set) fires on a later tick.
+    serverSideSocket.destroy();
+    await expect(srv.close()).resolves.toBeUndefined();
+    await new Promise<void>((resolve) => c.socket.once('close', () => resolve()));
+  });
+
+  it('logs and resolves when the final snapshot save fails on close', async () => {
+    // Pointing persistencePath at an existing directory makes the boot-time
+    // load fail (EISDIR → caught → start fresh) AND the close-time save fail
+    // (writeFile on a directory → EISDIR → caught at the closeServer catch).
+    const dir = await mkdtemp(join(tmpdir(), 'sirc-finalfail-'));
+    const { mkdir } = await import('node:fs/promises');
+    const dirPath = join(dir, 'snap-target-dir');
+    await mkdir(dirPath);
+
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.finalfail',
+      networkName: 'FinalFailNet',
+      persistencePath: dirPath,
+      snapshotIntervalMs: 999_999,
+    });
+    const c = new TcpClient('127.0.0.1', srv.port);
+    await c.opened();
+    await c.send('NICK finalFail');
+    await c.send('USER finalFail 0 * :FinalFail');
+    await c.waitFor((l) => l.startsWith(':irc.finalfail 001 '), 2000);
+    // The server destroys live sockets on close; capture the close event first.
+    const closed = new Promise<void>((resolve) => c.socket.once('close', () => resolve()));
+    // close() must resolve (not reject) even though the final snapshot write
+    // throws — the error is logged and swallowed.
+    await expect(srv.close()).resolves.toBeUndefined();
+    await closed;
+    await rm(dir, { recursive: true, force: true });
+  });
 });
 
 describe('container-server — error paths', () => {
@@ -407,6 +513,95 @@ describe('container-server — error paths', () => {
     await srv.close();
   });
 
+  it('logs a non-Error rejection from the actor without crashing', async () => {
+    // logError's `err instanceof Error ? {...} : err` false branch is only
+    // reached when the caught value is NOT an Error instance.
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.nonerr',
+      networkName: 'NonErrNet',
+    });
+    const original = srv.runtime.send.bind(srv.runtime);
+    srv.runtime.send = async () => {
+      // eslint-disable-next-line no-throw-literal
+      throw { code: 'SYNTHETIC', detail: 'not an Error' };
+    };
+    const client = new TcpClient('127.0.0.1', srv.port);
+    await client.opened();
+    await client.send('NICK nonErrUser');
+    await client.send('USER nonErrUser 0 * :NonErr');
+    await client.send('PING :will-throw-non-error');
+    await new Promise((r) => setTimeout(r, 100));
+
+    srv.runtime.send = original;
+    const next = new TcpClient('127.0.0.1', srv.port);
+    await next.opened();
+    await next.send('NICK recover2');
+    await next.send('USER recover2 0 * :Recover2');
+    await next.waitFor((l) => l.startsWith(':irc.nonerr 001 '), 3000);
+    await next.close();
+    await client.close();
+    await srv.close();
+  });
+
+  it('disconnects a connection without an ERROR notice when no reason is supplied', async () => {
+    // Covers the disconnect callback's `reason === undefined` branch: no
+    // `ERROR :Closing link` line is sent, the transport is just closed.
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.noreason',
+      networkName: 'NoReasonNet',
+    });
+    const client = new TcpClient('127.0.0.1', srv.port);
+    await client.opened();
+    await client.send('NICK noReason');
+    await client.send('USER noReason 0 * :NoReason');
+    await client.waitFor((l) => l.startsWith(':irc.noreason 001 '), 2000);
+
+    const connId = await srv.runtime.lookupNick('noReason');
+    expect(connId).not.toBeNull();
+    const closed = new Promise<void>((resolve) => client.socket.once('close', () => resolve()));
+    await srv.runtime.disconnect(connId as string);
+    await closed;
+    // The client must NOT have received an `ERROR :Closing link` line.
+    expect(client.received.some((l) => l.startsWith('ERROR :Closing link:'))).toBe(false);
+    await srv.close();
+  });
+
+  it('skips writing when the server-side socket is no longer writable', async () => {
+    // Covers the sendText callback's `socket.writable` else branch: after the
+    // server-side socket is destroyed (writable=false) but before its 'close'
+    // handler removes the connection, a runtime send must skip the write.
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.unwritable',
+      networkName: 'UnwritableNet',
+    });
+    const client = new TcpClient('127.0.0.1', srv.port);
+    await client.opened();
+    await client.send('NICK unwritable');
+    await client.send('USER unwritable 0 * :Unwritable');
+    await client.waitFor((l) => l.startsWith(':irc.unwritable 001 '), 2000);
+    for (let i = 0; i < 50 && srv.testSockets.size === 0; i++) {
+      await new Promise((r) => setTimeout(r, 5));
+    }
+    const serverSideSocket = [...srv.testSockets][0];
+    if (serverSideSocket === undefined) throw new Error('no server-side socket');
+    const connId = (await srv.runtime.lookupNick('unwritable')) as string;
+    // Destroy the server-side socket: writable flips false synchronously,
+    // while the 'close' cleanup (which unregisters the connection) is queued.
+    serverSideSocket.destroy();
+    // The send resolves without writing because socket.writable is false.
+    await expect(
+      srv.runtime.send(connId, [{ text: ':irc.unwritable NOTICE unwritable :dropped' }]),
+    ).resolves.toBeUndefined();
+    await srv.close();
+    await new Promise<void>((resolve) => client.socket.once('close', () => resolve()));
+  });
+
   it('logs and recovers from a per-socket error', async () => {
     const srv = await startContainerServer({
       port: 0,
@@ -463,3 +658,56 @@ describe('container-server — error paths', () => {
     await rm(dir, { recursive: true, force: true });
   });
 });
+
+describe('container-server — draft/multiline BATCH to a nick target', () => {
+  // Driving a nick-target multi-line batch exercises the `batchId` and
+  // `nonce` id-factory seams in DEFAULT_ID_FACTORY (container-server lines
+  // 96/98), which are only invoked by closeMultilineBatchToNick.
+
+  /** Negotiates `batch` + `draft/multiline`, then registers the nick. */
+  async function registerMultilineCapable(srv: ContainerServer, nick: string): Promise<TcpClient> {
+    const c = new TcpClient('127.0.0.1', srv.port);
+    await c.opened();
+    await c.send('CAP LS 302');
+    await c.waitFor((l) => l.startsWith(':irc.ml CAP * LS :'), 2000);
+    await c.send('CAP REQ :batch draft/multiline');
+    await c.waitFor((l) => l.includes('CAP') && l.includes('ACK'), 2000);
+    await c.send('CAP END');
+    await c.send(`NICK ${nick}`);
+    await c.send(`USER ${nick} 0 * :${nick}`);
+    await c.waitFor((l) => l.startsWith(':irc.ml 001 '), 2000);
+    return c;
+  }
+
+  it('delivers a finalized nick-target batch and exercises batchId/nonce', async () => {
+    const srv = await startContainerServer({
+      port: 0,
+      host: '127.0.0.1',
+      serverName: 'irc.ml',
+      networkName: 'MLNet',
+    });
+    const alice = await registerMultilineCapable(srv, 'alice');
+    const bob = await registerMultilineCapable(srv, 'bob');
+
+    await alice.send('BATCH +m1 draft/multiline :bob');
+    await alice.send('PRIVMSG bob :line one');
+    await alice.send('PRIVMSG bob :line two');
+    await alice.send('BATCH -m1');
+
+    // Bob (also batch+draft/multiline capable) receives the replayed BATCH.
+    // The server allocates a fresh UUID batch id via the batchId() seam.
+    const open = await bob.waitFor(
+      (l) => /^BATCH \+[0-9a-f-]{36} draft\/multiline bob$/u.test(l),
+      3000,
+    );
+    const batchId = open?.match(/^BATCH \+([0-9a-f-]{36})/u)?.[1];
+    expect(batchId).toBeDefined();
+    await bob.waitFor((l) => l.includes(':alice!') && l.includes('PRIVMSG bob :line one'), 2000);
+    await bob.waitFor((l) => l.includes(':alice!') && l.includes('PRIVMSG bob :line two'), 2000);
+    await bob.waitFor((l) => l === `BATCH -${batchId}`, 2000);
+
+    await alice.close();
+    await bob.close();
+    await srv.close();
+  });
+});

package/apps/cf-tcp-container/tests/persistence.test.ts

@@ -143,6 +143,15 @@ describe('persistence — saveSnapshot / loadSnapshot file I/O', () => {
     expect(loaded).toBeNull();
   });
 
+  it('re-throws non-ENOENT read errors (e.g. EISDIR when the path is a directory)', async () => {
+    // Reading a directory produces EISDIR, which is NOT ENOENT, so
+    // loadSnapshot must propagate it instead of treating it as first-boot.
+    const { mkdir } = await import('node:fs/promises');
+    const subDir = join(dir, 'not-a-file-dir');
+    await mkdir(subDir);
+    await expect(loadSnapshot(subDir)).rejects.toThrow();
+  });
+
   it('overwrites a previous snapshot on re-save', async () => {
     const path = join(dir, 'overwrite.json');
     const rt1 = new InMemoryRuntime({ clock: { now: () => 0 } });

package/apps/cf-tcp-container/tests/tls-e2e.test.ts

@@ -1,4 +1,4 @@
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import { EventEmitter } from 'node:events';
 import { mkdtemp, readFile, rm } from 'node:fs/promises';
 import { type Socket, createConnection } from 'node:net';
@@ -10,9 +10,21 @@ import {
   connect as tlsConnect,
   createServer as tlsCreateServer,
 } from 'node:tls';
+import { promisify } from 'node:util';
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
 import { type ContainerServer, startContainerServer } from '../src/container-server.js';
 
+const execFileAsync = promisify(execFile);
+
+/**
+ * Maximum wall-clock budget for a single `openssl` invocation. RSA-2048
+ * keygen finishes in well under a second on any modern CPU; if it hasn't
+ * returned by this point the binary is wedged (or the runner is so starved
+ * that the TLS e2e would be flaky anyway), so we skip the suite instead of
+ * stalling the test process.
+ */
+const OPENSSL_TIMEOUT_MS = 15_000;
+
 /**
  * Generates a self-signed TLS certificate for the test proxy using the
  * system `openssl` binary. This mirrors what Cloudflare Spectrum does in
@@ -26,7 +38,12 @@ async function generateSelfSignedCert(dir: string): Promise<{ key: string; cert:
   const keyPath = join(dir, 'key.pem');
   const certPath = join(dir, 'cert.pem');
   try {
-    execFileSync(
+    // Bound openssl: the previous `execFileSync` blocked the event loop,
+    // which defeated vitest's hook timer and let a stuck/missing binary
+    // hang the whole suite. The async call + `timeout` fails fast and
+    // yields control back to the runner; beforeAll swallows the throw and
+    // skips the suite (each test also guards on `cert === undefined`).
+    await execFileAsync(
       'openssl',
       [
         'req',
@@ -43,10 +60,12 @@ async function generateSelfSignedCert(dir: string): Promise<{ key: string; cert:
         '-subj',
         '/CN=localhost',
       ],
-      { stdio: 'pipe' },
+      { timeout: OPENSSL_TIMEOUT_MS },
     );
   } catch {
-    throw new Error('openssl not available — required to generate test TLS cert');
+    throw new Error(
+      `openssl unavailable or did not finish within ${OPENSSL_TIMEOUT_MS}ms — required to generate test TLS cert`,
+    );
   }
   const key = await readFile(keyPath, 'utf8');
   const cert = await readFile(certPath, 'utf8');
@@ -205,7 +224,7 @@ describe('container-server — TLS e2e via in-process proxy (Spectrum analogue)'
       originHost: '127.0.0.1',
       originPort: origin.port,
     });
-  });
+  }, 30_000);
 
   afterAll(async () => {
     if (proxy !== undefined) await proxy.close();

package/apps/cf-tcp-container/wrangler.toml

@@ -13,7 +13,7 @@
 ##   - The container image is built from apps/cf-tcp-container/Dockerfile.
 ##
 ## Deploy:
-##   wrangler deploy --env staging
+##   wrangler deploy
 ##
 
 name = "sirc-tcp-origin"
@@ -52,12 +52,3 @@ NETWORK_NAME = "ExampleNet"
 MOTD_LINES = "Welcome to the ServerlessIRCd TCP origin."
 TCP_PORT = "6667"
 PERSISTENCE_PATH = "/data/state.json"
-
-# --- Staging ---
-[env.staging]
-name = "sirc-tcp-origin-staging"
-
-[env.staging.vars]
-SERVER_NAME = "irc-staging.example.com"
-NETWORK_NAME = "StagingNet"
-MOTD_LINES = "Welcome to the staging ServerlessIRCd TCP origin."

package/apps/cf-worker/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/cf-worker",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "private": true,
   "description": "Cloudflare Worker deploy glue: WebSocket edge entry point + DO bindings + wrangler pipeline",
   "license": "BSD-3-Clause",
@@ -13,9 +13,8 @@
     "test:watch": "vitest",
     "coverage": "vitest run --coverage",
     "dev": "wrangler dev",
-    "deploy:staging": "wrangler deploy --env staging",
-    "deploy:prod": "wrangler deploy",
-    "smoke:staging": "node scripts/smoke.mjs",
+    "deploy": "wrangler deploy",
+    "smoke": "node scripts/smoke.mjs",
     "clean": "rimraf dist coverage .tsbuildinfo .turbo"
   },
   "dependencies": {

package/apps/cf-worker/wrangler.toml

@@ -3,8 +3,7 @@
 ## Cloudflare Worker production config for ServerlessIRCd.
 ##
 ## Deploy:
-##   pnpm deploy:cf:staging     # wrangler deploy --env staging
-##   pnpm deploy:cf:prod        # wrangler deploy
+##   pnpm deploy:cf        # wrangler deploy
 ##
 ## The `apps/cf-worker` worker is the public edge for the IRC service.
 ## It owns the three Durable Object namespaces from the cf-adapter
@@ -13,10 +12,8 @@
 ## `src/worker.ts` and PLAN §6.1.
 ##
 ## Secrets: NEVER put secrets (API tokens, server passwords, account
-## credentials) in this file. Use `wrangler secret put <NAME>` per
-## environment; they live in the Workers KV secrets store, not the repo.
-## As of v1 the worker does not consume any secret bindings — server
-## password, SASL `AccountStore`, and oper creds are future work.
+## credentials) in this file. Use `wrangler secret put <NAME>`;
+## they live in the Workers KV secrets store, not the repo.
 
 name = "serverless-ircd"
 main = "src/worker.ts"
@@ -104,55 +101,20 @@ not_found_handling = "none"
 run_worker_first = true
 
 ## ---------------------------------------------------------------------------
-## Staging environment.
+## D1 database — unified services persistence (NickServ / ChanServ / SASL).
 ## ---------------------------------------------------------------------------
-## `wrangler deploy --env staging` ships to the staging Worker + DO
-## namespace. The CI workflow (`.github/workflows/deploy-cf.yml`) deploys
-## here on every push to `main` and then runs the smoke e2e.
-[env.staging]
-name = "serverless-ircd-staging"
-
-[env.staging.observability]
-enabled = true
-head_sampling_rate = 1
-
-[env.staging.vars]
-SERVER_NAME = "irc-staging.example.com"
-NETWORK_NAME = "ServerlessIRCd (staging)"
-MOTD_LINES = """
-Welcome to ServerlessIRCd staging.
-This is a deployed Cloudflare Worker.
-This Worker was deployed by CI from the main branch.
-"""
-
-# Staging serves the same `apps/web/dist` asset layer. Wrangler requires the
-# per-env assets block so `--env staging` deploys both the Worker and its
-# assets in a single `wrangler deploy --env staging` (the same `pnpm build`
-# populates `dist/` ahead of the deploy step).
-[env.staging.assets]
-directory = "../../apps/web/dist"
-binding = "ASSETS"
-not_found_handling = "none"
-run_worker_first = true
-
-## ---------------------------------------------------------------------------
-## D1 database — SASL account persistence.
-## ---------------------------------------------------------------------------
-## The `accounts` table stores scrypt-hashed SASL PLAIN credentials (never
-## plaintext). Loaded at ConnectionDO construction; when empty or unreachable
-## the resolver falls back to the `SASL_ACCOUNTS` env-var seed. Provision with:
+## The `nickserv_accounts` table is the single credential home for SASL
+## PLAIN, SASL EXTERNAL, PASS-auth, and NickServ IDENTIFY. All scrypt-hashed
+## credentials live here; the standalone `accounts` table was dropped.
+## Provision with:
 ##   wrangler d1 create serverless-ircd-accounts
-##   wrangler d1 execute serverless-ircd-accounts --command \
-##     "CREATE TABLE IF NOT EXISTS accounts (account TEXT PRIMARY KEY, algorithm TEXT NOT NULL, salt TEXT NOT NULL, hash TEXT NOT NULL)"
-## Seed accounts via `tools/seed-cf-accounts.ts`.
+## The services tables self-provision on first load (ConnectionDO runs
+## `CREATE TABLE IF NOT EXISTS` for each table). Seed accounts via
+## `tools/seed-cf-accounts.ts`.
 [[d1_databases]]
 binding = "ACCOUNTS_DB"
 database_name = "serverless-ircd-accounts"
-# database_id is filled in by `wrangler d1 create` and is env-specific.
-
-[[env.staging.d1_databases]]
-binding = "ACCOUNTS_DB"
-database_name = "serverless-ircd-accounts-staging"
+# database_id is filled in by `wrangler d1 create`.
 
 ## ---------------------------------------------------------------------------
 ## Durable Object bindings.
@@ -179,23 +141,6 @@ class_name = "ChannelDO"
 name = "CHANNEL_REGISTRY_DO"
 class_name = "ChannelRegistryDO"
 
-# Staging environment bindings (wrangler requires per-env blocks).
-[[env.staging.durable_objects.bindings]]
-name = "CONNECTION_DO"
-class_name = "ConnectionDO"
-
-[[env.staging.durable_objects.bindings]]
-name = "REGISTRY_DO"
-class_name = "RegistryDO"
-
-[[env.staging.durable_objects.bindings]]
-name = "CHANNEL_DO"
-class_name = "ChannelDO"
-
-[[env.staging.durable_objects.bindings]]
-name = "CHANNEL_REGISTRY_DO"
-class_name = "ChannelRegistryDO"
-
 # ## ---------------------------------------------------------------------------
 # ## Durable Object migrations.
 # ## ---------------------------------------------------------------------------
@@ -210,10 +155,6 @@ class_name = "ChannelRegistryDO"
 # tag = "v1"
 # new_sqlite_classes = ["ConnectionDO", "RegistryDO", "ChannelDO", "ChannelRegistryDO"]
 
-# [[env.staging.migrations]]
-# tag = "v1"
-# new_sqlite_classes = ["ConnectionDO", "RegistryDO", "ChannelDO", "ChannelRegistryDO"]
-
 [exports.ConnectionDO]
 type = "durable-object"
 storage = "sqlite"

package/apps/local-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/local-cli",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "private": true,
   "description": "Runnable WebSocket IRC server using the in-memory runtime; manual-test harness and e2e fixture target",
   "license": "BSD-3-Clause",