serverless-ircd 0.4.0 → 0.6.0

package/packages/in-memory-runtime/src/in-memory-runtime.ts

@@ -26,6 +26,7 @@ import {
   type ConnectionState,
   type Nick,
   type RawLine,
+  type ServerConfig,
   applyChannelDelta as applyDelta,
   caseFold,
   createChannel,
@@ -64,6 +65,15 @@ export interface InMemoryRuntimeOptions {
    * deployment's `ServerConfig`.
    */
   readonly admission?: AdmissionConfig;
+  /**
+   * Config-reload source for `REHASH`. When bound, the runtime re-invokes
+   * it on every {@link InMemoryRuntime.reloadConfig} call and returns the
+   * fresh {@link ServerConfig}; the local-cli binds the loader that
+   * re-derives config from its original options. When omitted
+   * `reloadConfig` rejects so the actor's graceful failure path applies a
+   * consistent error-suffixed `382`.
+   */
+  readonly configLoader?: () => Promise<ServerConfig>;
 }
 
 export class InMemoryRuntime implements IrcRuntime {
@@ -73,9 +83,11 @@ export class InMemoryRuntime implements IrcRuntime {
   private readonly nicks = new Map<string, ConnId>();
   private readonly admissionStats: AdmissionStats | undefined;
   private readonly admissionConfig: AdmissionConfig | undefined;
+  private readonly configLoader: (() => Promise<ServerConfig>) | undefined;
 
   constructor(opts: InMemoryRuntimeOptions) {
     this.clock = opts.clock;
+    this.configLoader = opts.configLoader;
     if (opts.admission !== undefined) {
       this.admissionConfig = opts.admission;
       this.admissionStats = new AdmissionStats(this.clock);
@@ -242,6 +254,22 @@ export class InMemoryRuntime implements IrcRuntime {
     }
   }
 
+  /**
+   * Global cross-connection fanout for `WALLOPS`. Scans the connection map
+   * and delivers `lines` to every live connection whose `+w` user mode is
+   * set, skipping `except` (the originator). Unlike {@link broadcast} this
+   * is NOT channel-scoped — it reaches connections with no shared channel
+   * membership. This is the reference implementation the CF and AWS
+   * adapters mirror against their own enumeration primitives.
+   */
+  async broadcastWallops(lines: RawLine[], except?: ConnId): Promise<void> {
+    for (const [connId, tracked] of this.connections) {
+      if (connId === except) continue;
+      if (!tracked.state.userModes.wallops) continue;
+      tracked.handlers.send(lines);
+    }
+  }
+
   // ------------------------------------------------------------------
   // IrcRuntime — nick registry
   // ------------------------------------------------------------------
@@ -333,4 +361,15 @@ export class InMemoryRuntime implements IrcRuntime {
   async listChannels(): Promise<ChanSnapshot[]> {
     return Array.from(this.channels.values(), (c) => toChannelSnapshot(c));
   }
+
+  // ------------------------------------------------------------------
+  // IrcRuntime — config reload (REHASH)
+  // ------------------------------------------------------------------
+
+  async reloadConfig(): Promise<ServerConfig> {
+    if (this.configLoader === undefined) {
+      throw new Error('no config loader bound to InMemoryRuntime');
+    }
+    return this.configLoader();
+  }
 }

package/packages/in-memory-runtime/tests/in-memory-runtime.test.ts

@@ -5,6 +5,7 @@ import {
   type ConnectionState,
   FakeClock,
   type RawLine,
+  type ServerConfig,
   createConnection,
 } from '@serverless-ircd/irc-core';
 import { describe, expect, it } from 'vitest';
@@ -124,6 +125,26 @@ describe('InMemoryRuntime — changeNick', () => {
     expect(await rt.lookupNick('alice')).toBe('c1');
     expect(await rt.lookupNick('bob')).toBe('c2');
   });
+
+  it('does not clobber a third party that grabbed the old nick via re-reserve (stale-release guard)', async () => {
+    // Covers the defensive branch on the old-mapping clear: c1 held
+    // `alice`, released it, c2 re-reserved it, then c1 reports a nick
+    // change FROM `alice` (stale state). The guard must NOT delete the
+    // alice mapping that now belongs to c2.
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    rt.registerConnection(makeConn('c1'), { send: () => {}, disconnect: () => {} });
+    rt.registerConnection(makeConn('c2'), { send: () => {}, disconnect: () => {} });
+
+    await rt.reserveNick('alice', 'c1');
+    await rt.releaseNick('alice'); // nicks[alice] deleted (still pointed at c1)
+    await rt.reserveNick('alice', 'c2'); // nicks[alice] = c2
+
+    const ok = await rt.changeNick('c1', 'alice', 'bob');
+    expect(ok).toBe(true);
+    // c1 got `bob`, c2 still holds `alice` (the stale clear was skipped).
+    expect(await rt.lookupNick('alice')).toBe('c2');
+    expect(await rt.lookupNick('bob')).toBe('c1');
+  });
 });
 
 describe('InMemoryRuntime — releaseNick', () => {
@@ -255,6 +276,100 @@ describe('InMemoryRuntime — applyChannelDelta / getChannelSnapshot', () => {
   });
 });
 
+describe('InMemoryRuntime — getChannel (peek-only)', () => {
+  it('returns the authoritative ChannelState when the channel exists', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    await rt.applyChannelDelta('#foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+
+    const chan = rt.getChannel('#foo');
+    expect(chan).toBeDefined();
+    expect(chan?.name).toBe('#foo');
+    expect(chan?.members.has('c1')).toBe(true);
+  });
+
+  it('returns undefined for an unknown channel (does not create it)', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    expect(rt.getChannel('#nope')).toBeUndefined();
+    // Peek-only: the channel map is still empty.
+    expect(await rt.listChannels()).toEqual([]);
+  });
+
+  it('folds the channel name with rfc1459 case-mapping on lookup', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    await rt.applyChannelDelta('#Foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    expect(rt.getChannel('#foo')).toBeDefined();
+    expect(rt.getChannel('#FOO')).toBeDefined();
+  });
+});
+
+describe('InMemoryRuntime — getChannelConnections', () => {
+  it('returns the live ConnectionState for each registered member', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    rt.registerConnection(makeConn('c1', 'alice'), { send: () => {}, disconnect: () => {} });
+    rt.registerConnection(makeConn('c2', 'bob'), { send: () => {}, disconnect: () => {} });
+    await rt.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
+    });
+
+    const conns = await rt.getChannelConnections('#foo');
+    expect(conns.size).toBe(2);
+    expect(conns.get('c1')?.nick).toBe('alice');
+    expect(conns.get('c2')?.nick).toBe('bob');
+  });
+
+  it('returns an empty map for an unknown channel', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    expect(await rt.getChannelConnections('#nope')).toEqual(new Map());
+  });
+
+  it('skips members whose connection is no longer tracked', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    rt.registerConnection(makeConn('c1', 'alice'), { send: () => {}, disconnect: () => {} });
+    // c2 is referenced by a membership but was never registered (and c1's
+    // registration is dropped mid-test to exercise the filter branch).
+    await rt.applyChannelDelta('#foo', {
+      memberships: [
+        { type: 'add', conn: 'c1', nick: 'alice' },
+        { type: 'add', conn: 'c2', nick: 'bob' },
+      ],
+    });
+
+    const conns = await rt.getChannelConnections('#foo');
+    expect(conns.size).toBe(1);
+    expect(conns.get('c1')?.nick).toBe('alice');
+    expect(conns.has('c2')).toBe(false);
+  });
+});
+
+describe('InMemoryRuntime — listChannels', () => {
+  it('returns an empty array when no channels exist', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    expect(await rt.listChannels()).toEqual([]);
+  });
+
+  it('returns a snapshot per channel, preserving original casing', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    await rt.applyChannelDelta('#Foo', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+    await rt.applyChannelDelta('#bar', {
+      memberships: [{ type: 'add', conn: 'c1', nick: 'alice' }],
+    });
+
+    const list = await rt.listChannels();
+    expect(list).toHaveLength(2);
+    const names = list.map((c) => c.name).sort();
+    expect(names).toEqual(['#Foo', '#bar']);
+  });
+});
+
 describe('InMemoryRuntime — send', () => {
   it('delivers lines to the target connection send handler', async () => {
     const sent: RawLine[][] = [];
@@ -430,6 +545,28 @@ describe('InMemoryRuntime — sendToNick', () => {
     const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
     await expect(rt.sendToNick('ghost', 'c1', [L('hi')], [L('401')])).resolves.toBeUndefined();
   });
+
+  it('falls through to notFoundLines when the owner nick is registered but its connection is gone', async () => {
+    // Covers the stale-nick defensive branch in sendToNick: `this.nicks`
+    // still maps the nick to a connId, but that conn is no longer tracked
+    // (unregisterConnection deletes the conn without releasing its nick —
+    // the comment on unregisterConnection documents this split).
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const senderOut: RawLine[][] = [];
+    rt.registerConnection(makeConn('c1', 'alice'), { send: () => {}, disconnect: () => {} });
+    rt.registerConnection(makeConn('c2', 'bob'), {
+      send: (lines) => {
+        senderOut.push(lines);
+      },
+      disconnect: () => {},
+    });
+    await rt.reserveNick('alice', 'c1');
+    // Remove c1 from the connection map while leaving the nick mapping intact.
+    rt.unregisterConnection('c1');
+
+    await rt.sendToNick('alice', 'c2', [L('hi')], [L('401 bob alice :No such nick')]);
+    expect(senderOut).toEqual([[{ text: '401 bob alice :No such nick' }]]);
+  });
 });
 
 describe('InMemoryRuntime — disconnect', () => {
@@ -634,3 +771,125 @@ describe('InMemoryRuntime — admission gate', () => {
     }
   });
 });
+
+describe('InMemoryRuntime — reloadConfig (REHASH)', () => {
+  const baseConfig: ServerConfig = {
+    serverName: 'irc.example.com',
+    networkName: 'ExampleNet',
+    maxChannelsPerUser: 30,
+    maxTargetsPerCommand: 10,
+    maxListEntries: 50,
+    nickLen: 30,
+    channelLen: 50,
+    topicLen: 390,
+    quitMessage: 'Client Quit',
+  };
+
+  it('re-invokes the bound loader and returns the fresh config', async () => {
+    let version = 1;
+    const rt = new InMemoryRuntime({
+      clock: new FakeClock(0),
+      configLoader: async () => ({ ...baseConfig, serverName: `v${version}.example.com` }),
+    });
+
+    const first = await rt.reloadConfig();
+    expect(first.serverName).toBe('v1.example.com');
+    version = 2;
+    const second = await rt.reloadConfig();
+    expect(second.serverName).toBe('v2.example.com');
+  });
+
+  it('propagates a loader rejection so the actor can apply the graceful failure path', async () => {
+    const rt = new InMemoryRuntime({
+      clock: new FakeClock(0),
+      configLoader: async () => {
+        throw new Error('store unreachable');
+      },
+    });
+
+    await expect(rt.reloadConfig()).rejects.toThrow('store unreachable');
+  });
+
+  it('rejects when no loader was bound at construction', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+
+    await expect(rt.reloadConfig()).rejects.toThrow('no config loader bound');
+  });
+});
+
+describe('InMemoryRuntime — broadcastWallops', () => {
+  it('delivers lines to every connection with the +w user mode set', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const received: Record<string, RawLine[][]> = { c1: [], c2: [], c3: [] };
+    const push = (id: string) => (lines: RawLine[]) => received[id]?.push(lines);
+    // c1 has NO +w; c2 and c3 do.
+    rt.registerConnection(makeConn('c1', 'alice'), { send: push('c1'), disconnect: () => {} });
+    const c2 = makeConn('c2', 'bob');
+    c2.userModes.wallops = true;
+    rt.registerConnection(c2, { send: push('c2'), disconnect: () => {} });
+    const c3 = makeConn('c3', 'carol');
+    c3.userModes.wallops = true;
+    rt.registerConnection(c3, { send: push('c3'), disconnect: () => {} });
+
+    await rt.broadcastWallops([L(':alice WALLOPS :reboot')]);
+
+    // c1 has no +w → no delivery.
+    expect(received.c1).toHaveLength(0);
+    expect(received.c2).toHaveLength(1);
+    expect(received.c3).toHaveLength(1);
+  });
+
+  it('skips the except connection even when it has +w', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const received: Record<string, RawLine[][]> = { c1: [], c2: [] };
+    const push = (id: string) => (lines: RawLine[]) => received[id]?.push(lines);
+    const oper = makeConn('c1', 'alice');
+    oper.userModes.wallops = true;
+    oper.userModes.oper = true;
+    rt.registerConnection(oper, { send: push('c1'), disconnect: () => {} });
+    const listener = makeConn('c2', 'bob');
+    listener.userModes.wallops = true;
+    rt.registerConnection(listener, { send: push('c2'), disconnect: () => {} });
+
+    await rt.broadcastWallops([L(':alice WALLOPS :hi')], 'c1');
+
+    // The oper (except) never receives their own wallops; the +w peer does.
+    expect(received.c1).toHaveLength(0);
+    expect(received.c2).toHaveLength(1);
+  });
+
+  it('does not deliver to +w connections that have unregistered', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    let c2Received = 0;
+    rt.registerConnection(makeConn('c1', 'alice'), {
+      send: () => {},
+      disconnect: () => {},
+    });
+    const c2 = makeConn('c2', 'bob');
+    c2.userModes.wallops = true;
+    rt.registerConnection(c2, {
+      send: () => {
+        c2Received++;
+      },
+      disconnect: () => {},
+    });
+
+    rt.unregisterConnection('c2');
+    await rt.broadcastWallops([L(':alice WALLOPS :hi')]);
+    expect(c2Received).toBe(0);
+  });
+
+  it('is a no-op when no connection has +w', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    let c1Received = 0;
+    rt.registerConnection(makeConn('c1', 'alice'), {
+      send: () => {
+        c1Received++;
+      },
+      disconnect: () => {},
+    });
+
+    await rt.broadcastWallops([L(':a WALLOPS :hi')]);
+    expect(c1Received).toBe(0);
+  });
+});

package/packages/irc-core/package.json

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

package/packages/irc-core/src/admission.ts

@@ -123,18 +123,18 @@ export class AdmissionStats {
     if (rec === undefined) return;
     this.records.delete(recordId);
 
-    const ipCount = this.perIpCount.get(rec.ip);
-    if (ipCount !== undefined) {
-      const next = ipCount - 1;
-      if (next <= 0) this.perIpCount.delete(rec.ip);
-      else this.perIpCount.set(rec.ip, next);
-    }
-    const userCount = this.perUserCount.get(rec.user);
-    if (userCount !== undefined) {
-      const next = userCount - 1;
-      if (next <= 0) this.perUserCount.delete(rec.user);
-      else this.perUserCount.set(rec.user, next);
-    }
+    // recordAdmission always sets both counters, so they are present for
+    // any id found in `records`. The decrement-and-delete-if-zero keeps
+    // the maps compact (no zero entries hanging around).
+    const ipCount = this.perIpCount.get(rec.ip) as number;
+    const ipNext = ipCount - 1;
+    if (ipNext <= 0) this.perIpCount.delete(rec.ip);
+    else this.perIpCount.set(rec.ip, ipNext);
+
+    const userCount = this.perUserCount.get(rec.user) as number;
+    const userNext = userCount - 1;
+    if (userNext <= 0) this.perUserCount.delete(rec.user);
+    else this.perUserCount.set(rec.user, userNext);
   }
 
   /**
@@ -147,9 +147,10 @@ export class AdmissionStats {
     if (times === undefined || times.length === 0) return 0;
     const cutoff = this.clock.now() - windowMs;
     let writeIdx = 0;
-    for (let i = 0; i < times.length; i++) {
-      const t = times[i];
-      if (t === undefined) continue;
+    // `times` is dense (only ever appended to via push, never spliced), so
+    // iterating values via for-of avoids the noUncheckedIndexedAccess trap
+    // while still allowing in-place compaction of stale entries.
+    for (const t of times) {
       if (t >= cutoff) {
         times[writeIdx++] = t;
       }

package/packages/irc-core/src/caps/capabilities.ts

@@ -3,7 +3,7 @@
  *
  * The CAP *negotiation reducer* ships separately; this module is the
  * pure-data table that advertises what caps this server supports. PLAN §3
- * lists the v1 cap set; later tickets implement each cap's behavior.
+ * lists the v1 cap set; later phases implement each cap's behavior.
  *
  * The table is exposed as a frozen, sorted list so the `CAP LS` response
  * (and any future `CAP NEW` push) serializes deterministically.
@@ -21,29 +21,63 @@ export interface Capability {
   value?: string;
 }
 
+/** Wire name of the SASL capability. */
+export const SASL_CAP_NAME = 'sasl';
+
+/** Wire name of the IRCv3 `draft/multiline` capability. */
+export const MULTILINE_CAP_NAME = 'draft/multiline';
+
+/** Wire name of the IRCv3 `draft/read-marker` capability. */
+export const READ_MARKER_CAP_NAME = 'draft/read-marker';
+
+/** Wire name of the IRCv3 `draft/pre-away` capability. */
+export const PRE_AWAY_CAP_NAME = 'draft/pre-away';
+
+/**
+ * Default byte budget advertised in `draft/multiline=<n>` and enforced on
+ * every finalized multi-line batch. Mirrors the IRCv3 spec's canonical
+ * recommendation; deployments override via `ServerConfig.multilineMaxBytes`.
+ */
+export const DEFAULT_MULTILINE_MAX_BYTES = 4096;
+
+/**
+ * Builds the `draft/multiline` cap *value* (the substring after `=`) for the
+ * advertised byte budget. The {@link CapReducer} and the multi-line reducer
+ * share this helper so the wire token has one source of truth.
+ */
+export function multilineCapValue(maxBytes: number): string {
+  return String(maxBytes);
+}
+
 /**
  * Every cap advertised by this server in PLAN §3, in canonical (alpha) order
  * so wire output is deterministic across runs.
  */
 export const SUPPORTED_CAPABILITIES: ReadonlyArray<Capability> = Object.freeze([
+  { name: 'account-notify' },
   { name: 'account-tag' },
   { name: 'away-notify' },
   { name: 'batch' },
   { name: 'chghost' },
   { name: 'draft/chathistory' },
+  { name: 'draft/multiline', value: multilineCapValue(DEFAULT_MULTILINE_MAX_BYTES) },
+  { name: 'draft/pre-away' },
+  { name: 'draft/read-marker' },
+  { name: 'draft/typing' },
   { name: 'echo-message' },
   { name: 'extended-join' },
   { name: 'invite-notify' },
+  { name: 'labeled-response' },
   { name: 'message-tags' },
+  { name: 'msgid' },
+  { name: 'monitor' },
   { name: 'multi-prefix' },
   { name: 'safelist' },
   { name: 'sasl', value: 'PLAIN' },
   { name: 'server-time' },
+  { name: 'standard-replies' },
 ]);
 
-/** Wire name of the SASL capability. */
-export const SASL_CAP_NAME = 'sasl';
-
 /**
  * Returns the `sasl` cap value to advertise given whether an mTLS identity
  * provider is bound for the connection.

package/packages/irc-core/src/caps/index.ts

@@ -1 +1,2 @@
 export * from './capabilities.js';
+export * from './sts.js';

package/packages/irc-core/src/caps/sts.ts

@@ -0,0 +1,84 @@
+/**
+ * IRCv3 `sts` (Strict Transport Security) policy.
+ *
+ * Spec: https://ircv3.net/specs/extensions/sts
+ *
+ * The server advertises an `sts` capability whose value is a
+ * comma-separated `key=value` policy. Compliant clients inspect the
+ * policy and:
+ *
+ *   - On a plaintext connection: reconnect over TLS to the advertised
+ *     `port` and pin it for `duration` seconds. `preload` (optional)
+ *     signals the client may hard-code the policy into a preload list.
+ *   - On a TLS connection: only the `duration` is locked in — `port`
+ *     is meaningless once the client is already on the secure listener,
+ *     and `preload` is an upgrade-time directive.
+ *
+ * Config-driven only: there is no per-connection protocol state. The
+ * deployment supplies the policy through {@link StsConfig} on
+ * {@link ServerConfig}; when omitted entirely the cap is not advertised.
+ */
+
+/**
+ * IRC-over-TLS port per RFC 7193 / IRCv3 STS spec examples. Used as the
+ * fallback `port` when a deployment turns on STS without pinning a port.
+ */
+export const DEFAULT_STS_PORT = 6697;
+
+/**
+ * Default pin duration (30 days, in seconds). Mirrors the IRCv3 spec's
+ * canonical example and what mainstream IRC networks publish. Deployments
+ * override via {@link StsConfig.duration}.
+ */
+export const DEFAULT_STS_DURATION_SECONDS = 30 * 24 * 60 * 60;
+
+/** Wire name of the STS capability. */
+export const STS_CAP_NAME = 'sts';
+
+/**
+ * Raw STS policy as supplied by {@link ServerConfig}. Every field is
+ * optional; {@link stsCapValue} applies the documented defaults when a
+ * field is omitted. `undefined` (the whole object) disables STS.
+ *
+ * Optional fields are widened to `T | undefined` to mirror Zod's
+ * `.optional()` output under `exactOptionalPropertyTypes: true` so the
+ * parsed config is structurally assignable here.
+ */
+export interface StsPolicy {
+  /** Pin duration in seconds. Defaults to 30 days. */
+  readonly duration?: number;
+  /** TLS listener port advertised on plaintext connections. Defaults to 6697. */
+  readonly port?: number;
+  /** Optional preload directive (plaintext advertisements only). */
+  readonly preload?: boolean | undefined;
+}
+
+/**
+ * Builds the IRCv3 `sts` capability *value* (the substring after `sts=`)
+ * for the given policy and transport.
+ *
+ * Returns `undefined` when STS is disabled (`policy` undefined), so the cap
+ * table consumer can omit the token entirely from `CAP LS`.
+ *
+ * On a plaintext transport the full policy is advertised:
+ *   `duration=<seconds>,port=<tls-port>[,preload]`
+ *
+ * On a TLS transport only `duration=<seconds>` is sent — the port is
+ * meaningless (the client is already on the secure listener) and
+ * `preload` is an upgrade-time directive that does not apply.
+ *
+ * Missing `duration`/`port` fall back to {@link DEFAULT_STS_DURATION_SECONDS}
+ * and {@link DEFAULT_STS_PORT} so a deployment can enable STS with a bare
+ * `{}` policy and still publish a sensible value.
+ */
+export function stsCapValue(policy: StsPolicy | undefined, secure: boolean): string | undefined {
+  if (policy === undefined) return undefined;
+  const duration = policy.duration ?? DEFAULT_STS_DURATION_SECONDS;
+  if (secure) {
+    return `duration=${duration}`;
+  }
+  const port = policy.port ?? DEFAULT_STS_PORT;
+  const parts = [`duration=${duration}`, `port=${port}`];
+  if (policy.preload === true) parts.push('preload');
+  return parts.join(',');
+}

package/packages/irc-core/src/commands/account-notify.ts

@@ -0,0 +1,53 @@
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { ChanName } from '../state/channel.js';
+import { hostmaskOf } from '../state/connection.js';
+import type { ConnectionState } from '../state/connection.js';
+
+export interface AccountNotifyInput {
+  conn: ConnectionState;
+  /**
+   * New account name on login. Pass `undefined` to signal a logout, which
+   * serializes the account field as `*` per IRCv3 `account-notify`.
+   */
+  account?: string | undefined;
+}
+
+/**
+ * Builds the cap-split Broadcast effects that announce an `ACCOUNT` login
+ * (or logout) to peers in every shared channel.
+ *
+ * Mirrors the `emitChghost` broadcast helper: each joined channel produces
+ * one {@link Effect.broadcast} carrying empty `lines` (so non-cap peers
+ * receive nothing) and the `ACCOUNT` line in `capLines` for peers that
+ * negotiated `account-notify`. The sender is excluded via `except` unless
+ * they negotiated `echo-message`, in which case a single echo
+ * {@link Effect.send} is appended (one echo regardless of how many shared
+ * channels the user occupies).
+ *
+ * Returns `[]` before registration completes or when the connection holds
+ * no joined channels — there is no audience to notify.
+ */
+export function emitAccountNotify(input: AccountNotifyInput): EffectType[] {
+  const { conn, account } = input;
+
+  if (conn.registration !== 'registered') return [];
+  if (conn.joinedChannels.size === 0) return [];
+
+  const source = hostmaskOf(conn) ?? conn.nick ?? '?';
+  const accountField = account ?? '*';
+  const line: RawLine = { text: `:${source} ACCOUNT ${accountField}` };
+
+  const effects: EffectType[] = [];
+  for (const chan of conn.joinedChannels) {
+    effects.push(Effect.broadcast(chan as ChanName, [], conn.id, 'account-notify', [line]));
+  }
+
+  // IRCv3 echo-message: the sender observes its own ACCOUNT change exactly
+  // once, regardless of how many channels it shares with peers.
+  if (conn.caps.has('echo-message')) {
+    effects.push(Effect.send(conn.id, [line]));
+  }
+
+  return effects;
+}

package/packages/irc-core/src/commands/away.ts

@@ -27,6 +27,7 @@ import type { ChanName } from '../state/channel.js';
 import { hostmaskOf } from '../state/connection.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Reducer } from '../types.js';
+import { clearPersistedAway, persistAway } from './pre-away.js';
 
 /**
  * Handles `AWAY [:<reason>]`.
@@ -45,7 +46,10 @@ export const awayReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
   const nick = state.nick ?? '*';
 
   if (isSettingAway) {
-    state.away = reason;
+    // IRCv3 draft/pre-away: persist the reason keyed by account when an
+    // AwayStore is bound and the connection is identified. The in-memory
+    // away is also set so the current session tracks the new reason.
+    persistAway(ctx, reason as string);
     effects.push(
       Effect.send(ctx.connId, [
         {
@@ -54,8 +58,10 @@ export const awayReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
       ]),
     );
   } else {
-    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
-    delete state.away;
+    // IRCv3 draft/pre-away: clear the persisted reason on unset so a
+    // reconnect does not re-mark the user away. The in-memory away is
+    // also cleared so the session's view stays consistent.
+    clearPersistedAway(ctx);
     effects.push(
       Effect.send(ctx.connId, [
         {