serverless-ircd 0.3.0 → 0.5.0

package/packages/irc-server/src/actor.ts

@@ -30,6 +30,7 @@ import {
   type ChanName,
   type ChannelState,
   type Clock,
+  type ConnSnapshot,
   type ConnectionState,
   Effect,
   type Effect as EffectType,
@@ -39,23 +40,38 @@ import {
   type Logger,
   type MessageStore,
   type MotdProvider,
+  type MtlsIdentityProvider,
+  type NickHistoryStore,
   NoopLoggerInstance,
   Numerics,
   type RawLine,
   type ServerConfig,
+  type ServerStats,
   buildCtx,
   chathistoryReducer,
   handleJoinZero,
   isChannelTarget,
+  isonReducer,
+  killReducer,
   listReducer,
+  lusersReducer,
   parse,
+  rehashLine,
+  rehashReducer,
+  statsReducer,
+  toSnapshot,
+  traceReducer,
+  userhostReducer,
+  wallopsReducer,
   whoReducer,
   whoisReducer,
+  whowasReducer,
 } from '@serverless-ircd/irc-core';
 import { dispatch } from './dispatch.js';
 import type { DispatchOptions } from './dispatch.js';
 import { type RoutedReducers, buildRoutedReducers } from './routing.js';
 import type { IrcRuntime } from './runtime.js';
+import { type Transport, WsTextFrameTransport } from './transport.js';
 
 /**
  * Channel-state access for the actor.
@@ -92,6 +108,13 @@ export interface ConnectionActorOptions {
   runtime: IrcRuntime;
   channels: ActorChannelAccess;
   serverConfig: ServerConfig;
+  /**
+   * Short label identifying the adapter's bound config source (e.g.
+   * `"KV"`, `"Secrets Manager"`, `"config file"`). Surfaced in the
+   * `382 RPL_REHASHING` reply's trailing text so the oper can see where the
+   * reload was attempted from. Defaults to `"server config"` when omitted.
+   */
+  readonly configSource?: string;
   clock: Clock;
   ids: IdFactory;
   motd?: MotdProvider;
@@ -114,6 +137,33 @@ export interface ConnectionActorOptions {
    * can vouch for the credentials.
    */
   readonly accounts?: AccountStore;
+  /**
+   * mTLS client-cert identity source for SASL EXTERNAL (absent when mTLS
+   * is not configured). When bound, `ctx.mtlsIdentity` is defined so the
+   * `AUTHENTICATE EXTERNAL` reducer can resolve the connection's verified
+   * certificate subject. Omitted (→ `ctx.mtlsIdentity` undefined) means
+   * EXTERNAL is rejected with `904 ERR_SASLFAIL`.
+   */
+  readonly mtlsIdentity?: MtlsIdentityProvider;
+  /**
+   * Nick-history source for the `WHOWAS` command (absent when WHOWAS
+   * history retention is disabled). When bound, `ctx.history` is defined
+   * so the QUIT and NICK-change reducers record sign-off entries and the
+   * WHOWAS reducer replays them. Omitted (→ `ctx.history` undefined)
+   * preserves the no-store behaviour: `WHOWAS <nick>` emits `406`+`369`.
+   */
+  readonly history?: NickHistoryStore;
+  /**
+   * Network-statistics source for the `LUSERS` and `STATS` commands
+   * (absent when no stats backend is wired). When bound, the actor
+   * awaits `stats.getStats()` once per LUSERS/STATS invocation and hands
+   * the resulting snapshot to the pure reducers — same pattern as
+   * `listChannels` → `listReducer`. Omitted (→ a zero-count fallback)
+   * preserves graceful behaviour for deployments/tests that have not
+   * opted in: `LUSERS` reports zero users/channels, `STATS u` reports
+   * zero uptime.
+   */
+  readonly stats?: ServerStats;
   /**
    * Structured-logger port. When omitted the actor runs
    * silently — observability is purely opt-in. When supplied, every
@@ -127,19 +177,39 @@ export interface ConnectionActorOptions {
    * still uniquely identifiable in logs.
    */
   readonly traceId?: string;
+  /**
+   * Line-framing seam (PLAN §9, ADR-009). Turns inbound transport input
+   * into complete IRC lines. Defaults to a {@link WsTextFrameTransport}
+   * (one message per WebSocket text frame, the serverless default). A raw
+   * TCP+TLS adapter injects a {@link TcpByteStreamTransport} for stateful
+   * `\r\n` byte-stream framing across chunks. The parser/reducer/dispatch
+   * pipeline is shared unchanged across both transports.
+   */
+  readonly transport?: Transport;
 }
 
 export class ConnectionActor {
   private readonly state: ConnectionState;
   private readonly runtime: IrcRuntime;
   private readonly channels: ActorChannelAccess;
-  private readonly serverConfig: ServerConfig;
+  private serverConfig: ServerConfig;
+  private readonly configSource: string;
   private readonly clock: Clock;
   private readonly ids: IdFactory;
   private readonly motd: MotdProvider;
   private readonly messages: MessageStore | undefined;
   private readonly accounts: AccountStore | undefined;
+  private readonly mtlsIdentity: MtlsIdentityProvider | undefined;
+  private readonly history: NickHistoryStore | undefined;
+  private readonly stats: ServerStats | undefined;
   private readonly reducers: RoutedReducers;
+  /**
+   * Line-framing seam. Turns inbound input (a WS text frame or a raw TCP
+   * chunk) into complete IRC lines. Defaulted to a WS-frame transport for
+   * the serverless default; a TCP+TLS adapter injects the stateful
+   * byte-stream transport at construction.
+   */
+  private readonly transport: Transport;
   /**
    * Bound logger. Defaults to a no-op so the actor pipeline has no
    * observable side effects when callers do not opt in.
@@ -158,11 +228,15 @@ export class ConnectionActor {
     this.runtime = opts.runtime;
     this.channels = opts.channels;
     this.serverConfig = opts.serverConfig;
+    this.configSource = opts.configSource ?? 'server config';
     this.clock = opts.clock;
     this.ids = opts.ids;
     this.motd = opts.motd ?? EmptyMotdProvider;
     this.messages = opts.messages;
     this.accounts = opts.accounts;
+    this.mtlsIdentity = opts.mtlsIdentity;
+    this.history = opts.history;
+    this.stats = opts.stats;
     this.logger = opts.logger ?? NoopLoggerInstance;
     this.pinnedTraceId = opts.traceId;
     // Bind the connection id once so every record the actor emits carries
@@ -176,15 +250,19 @@ export class ConnectionActor {
     // reducer when flood control is disabled) so a flooding client is bounded
     // regardless of which authority owns the command's state.
     this.reducers = buildRoutedReducers(opts.serverConfig);
+    this.transport = opts.transport ?? new WsTextFrameTransport();
   }
 
   /**
-   * Processes one WebSocket text frame. Splits on `\r\n` (tolerating bare
-   * `\n`) and dispatches each non-empty line in order. A parse failure on
-   * one line emits a `421` and processing continues with the next line.
+   * Transport-agnostic entry point: feeds `chunk` through the bound
+   * {@link Transport} and dispatches each complete, non-empty line in order.
+   * A WS adapter passes one text frame per call; a raw TCP+TLS adapter
+   * passes one arbitrary byte chunk per call and the transport buffers any
+   * partial trailing line across calls. A parse failure on one line emits a
+   * `421` and processing continues with the next line.
    */
-  async receiveTextFrame(text: string): Promise<void> {
-    const lines = splitFrameLines(text);
+  async receive(chunk: string): Promise<void> {
+    const lines = this.transport.feed(chunk);
     if (lines.length === 0) return;
     const traceId = this.pinnedTraceId ?? this.ids.traceId();
     const log = this.logger.child({ traceId });
@@ -194,6 +272,17 @@ export class ConnectionActor {
     }
   }
 
+  /**
+   * Processes one WebSocket text frame. Equivalent to {@link receive} — kept
+   * as the named entry point every WS adapter already calls. Splits on
+   * `\r\n` (tolerating bare `\n`) via the default WS-frame transport and
+   * dispatches each non-empty line in order. A parse failure on one line
+   * emits a `421` and processing continues with the next line.
+   */
+  async receiveTextFrame(text: string): Promise<void> {
+    await this.receive(text);
+  }
+
   private async processLine(line: string, log: Logger, traceId: string): Promise<void> {
     let msg: IrcMessage;
     let parseFailed = false;
@@ -256,6 +345,8 @@ export class ConnectionActor {
       connection: this.state,
       ...(this.messages !== undefined ? { messages: this.messages } : {}),
       ...(this.accounts !== undefined ? { accounts: this.accounts } : {}),
+      ...(this.mtlsIdentity !== undefined ? { mtlsIdentity: this.mtlsIdentity } : {}),
+      ...(this.history !== undefined ? { history: this.history } : {}),
     });
 
     switch (msg.command) {
@@ -276,12 +367,30 @@ export class ConnectionActor {
         return this.reducers.motd(this.state, msg, ctx).effects;
       case 'OPER':
         return this.reducers.oper(this.state, msg, ctx).effects;
+      case 'REHASH':
+        return this.routeRehash(msg, ctx);
       case 'CAP':
         return this.reducers.cap(this.state, msg, ctx).effects;
       case 'AUTHENTICATE':
         return this.reducers.authenticate(this.state, msg, ctx).effects;
       case 'AWAY':
         return this.reducers.away(this.state, msg, ctx).effects;
+      case 'SETNAME':
+        return this.reducers.setname(this.state, msg, ctx).effects;
+
+      // -------- Server-info query commands --------
+      case 'VERSION':
+        return this.reducers.version(this.state, msg, ctx).effects;
+      case 'TIME':
+        return this.reducers.time(this.state, msg, ctx).effects;
+      case 'ADMIN':
+        return this.reducers.admin(this.state, msg, ctx).effects;
+      case 'INFO':
+        return this.reducers.info(this.state, msg, ctx).effects;
+      case 'USERHOST':
+        return this.routeUserhost(msg, ctx);
+      case 'ISON':
+        return this.routeIson(msg, ctx);
 
       // -------- Channel-authority commands --------
       case 'JOIN':
@@ -305,6 +414,18 @@ export class ConnectionActor {
         return this.routeWho(msg, ctx);
       case 'WHOIS':
         return this.routeWhois(msg, ctx);
+      case 'WHOWAS':
+        return this.routeWhowas(msg, ctx);
+      case 'KILL':
+        return this.routeKill(msg, ctx);
+      case 'TRACE':
+        return this.routeTrace(msg, ctx);
+      case 'WALLOPS':
+        return this.routeWallops(msg, ctx);
+      case 'LUSERS':
+        return this.routeLusers(msg, ctx);
+      case 'STATS':
+        return this.routeStats(msg, ctx);
       case 'CHATHISTORY':
         return this.routeChathistory(msg, ctx);
 
@@ -339,6 +460,19 @@ export class ConnectionActor {
           : this.reducers.userMode(this.state, msg, ctx).effects;
 
       default:
+        // Remaining standard IRC verbs not yet implemented. They fall through
+        // to a graceful `421 ERR_UNKNOWNCOMMAND`. Triage of remaining verbs:
+        //   - Deferred (serverless-incompatible / needs new infra):
+        //     (none — LUSERS/STATS are now implemented).
+        //   - Deliberately dropped (S2S — PLAN non-goal):
+        //     CONNECT, SQUIT, LINKS. There is no server mesh to connect,
+        //     split, or list; these stay 421. Their reserved numerics
+        //     (RPL_LINKS/RPL_ENDOFLINKS/ERR_CANTKILLSERVER) were removed.
+        //   - Deliberately dropped (RFC 2812 obsolete, never widely
+        //     implemented): SERVICE, SUMMON, USERS. These
+        //     stay 421; their reserved numerics
+        //     (RPL_YOURESERVICE/ERR_NOSUCHSERVICE/ERR_SUMMONDISABLED/
+        //     ERR_USERSDISABLED) were removed.
         return [this.unknownCommandEffect(msg.command)];
     }
   }
@@ -351,6 +485,40 @@ export class ConnectionActor {
     return listReducer(snapshots, msg, ctx).effects;
   }
 
+  /**
+   * Routes `REHASH` (oper-gated config reload). The pure reducer enforces the
+   * oper gate and emits `382 RPL_REHASHING`; when the gate passes the actor
+   * re-invokes the runtime's bound config loader and swaps its live
+   * `serverConfig` reference so subsequent commands observe the refreshed
+   * value (rotated oper creds, new MOTD source, etc.).
+   *
+   * On reload failure the previous config stays in effect and a graceful
+   * error-suffixed `382` follows — the oper is NOT disconnected (per the
+   * serverless reload contract: a bad store read must never sever a live
+   * connection).
+   */
+  private async routeRehash(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const result = rehashReducer(this.state, msg, ctx, this.configSource);
+    if (!result.shouldReload) {
+      return result.effects;
+    }
+    const effects = [...result.effects];
+    try {
+      this.serverConfig = await this.runtime.reloadConfig();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      this.logger.warn('rehash.reload-failed', { reason });
+      const nick = this.state.nick ?? '*';
+      effects.push(
+        Effect.send(this.state.id, [rehashLine(ctx.serverName, nick, this.configSource, reason)]),
+      );
+    }
+    return effects;
+  }
+
   private async routeWho(msg: IrcMessage, ctx: ReturnType<typeof buildCtx>): Promise<EffectType[]> {
     const target = msg.params[0] ?? '';
     if (target.length === 0) {
@@ -387,6 +555,207 @@ export class ConnectionActor {
     return whoisReducer(target, channels, msg, ctx).effects;
   }
 
+  /**
+   * Routes `KILL <nick> <comment>` to the kill reducer. The actor resolves
+   * the target via the nick registry + a live connection fetch (mirroring
+   * {@link routeWhois}); no channel is created as a side effect. The
+   * reducer performs the oper gate and, on success, emits a
+   * {@link DisconnectEffect} for the target — the runtime's `disconnect`
+   * closes the target transport and fans QUIT out to shared-channel peers
+   * (peer fanout is the runtime's responsibility, not the reducer's).
+   */
+  private async routeKill(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const targetNick = msg.params[0] ?? '';
+    let target: ConnectionState | undefined;
+    if (targetNick.length > 0) {
+      const connId = await this.runtime.lookupNick(targetNick);
+      if (connId !== null) {
+        target = (await this.runtime.getConnection(connId)) ?? undefined;
+      }
+    }
+    return killReducer(target, msg, ctx).effects;
+  }
+
+  /**
+   * Routes `TRACE [<target>]` to the trace reducer. Single-server
+   * deployment: when `<target>` is absent or equals the local server name
+   * the reducer emits only the `262 RPL_ENDOFTRACE` terminator; when
+   * `<target>` resolves to a nick the reducer emits `205`/`204` per-conn
+   * detail (oper requester only) plus `262`; any other `<target>` is
+   * treated as a non-local server and yields `402 ERR_NOSUCHSERVER`.
+   *
+   * The actor resolves the target via `lookupNick` + `getConnection`
+   * (mirroring {@link routeWhois}). The local-server check is
+   * case-insensitive against `serverConfig.serverName`. Multi-hop S2S
+   * tracing is a PLAN non-goal.
+   */
+  private async routeTrace(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const rawTarget = msg.params[0] ?? '';
+    if (rawTarget.length === 0) {
+      return traceReducer(undefined, msg, ctx).effects;
+    }
+    // Local server name (case-insensitive) → collapse to the no-target path.
+    if (rawTarget.toLowerCase() === ctx.serverName.toLowerCase()) {
+      return traceReducer(undefined, msg, ctx).effects;
+    }
+    // Try to resolve as a nick.
+    const connId = await this.runtime.lookupNick(rawTarget);
+    if (connId !== null) {
+      const target = (await this.runtime.getConnection(connId)) ?? undefined;
+      return traceReducer(target, msg, ctx).effects;
+    }
+    // Unresolved: treat as a remote server → 402 ERR_NOSUCHSERVER.
+    return traceReducer(undefined, msg, ctx, rawTarget).effects;
+  }
+
+  /**
+   * Routes `WALLOPS :<message>` to the wallops reducer. The pure reducer
+   * enforces the oper gate (`481`) and the non-empty-message check
+   * (`412`); on success it emits a single {@link BroadcastWallopsEffect}
+   * that the dispatch layer interprets via the runtime's
+   * `broadcastWallops` method — a global fan-out to every `+w`
+   * connection (not channel-scoped). The originator is always excluded
+   * (skip-self, matching NOTICE/PRIVMSG broadcast semantics).
+   */
+  private routeWallops(msg: IrcMessage, ctx: ReturnType<typeof buildCtx>): EffectType[] {
+    return wallopsReducer(this.state, msg, ctx).effects;
+  }
+
+  /**
+   * Routes `WHOWAS <nick>{,<nick>} [<count>]` to the whowas reducer. The
+   * command is query-only: it reads the bound nick-history store
+   * (`this.history`, absent when no store is wired) and emits
+   * `314`/`369`/`406` numerics. No runtime lookups are needed — the store
+   * is synchronous and self-contained.
+   */
+  private async routeWhowas(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    return whowasReducer(this.history, msg, ctx).effects;
+  }
+
+  /**
+   * Routes `LUSERS [<mask> [<server>]]` to the lusers reducer. Awaits the
+   * bound {@link ServerStats} backend (or falls back to a zero-count
+   * snapshot when no backend is wired) and hands the result to the pure
+   * reducer, which emits the `251`–`255`/`265`/`266` numerics.
+   *
+   * Single-server deployment: a `<server>` argument that does not match
+   * the local server name (case-insensitive) is treated as a remote
+   * server and yields `402 ERR_NOSUCHSERVER`. S2S aggregation is a PLAN
+   * non-goal.
+   */
+  private async routeLusers(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const serverTarget = serverTargetOf(msg.params[1] ?? '', ctx.serverName);
+    const snapshot = await this.fetchStats();
+    return lusersReducer(snapshot, msg, ctx, serverTarget).effects;
+  }
+
+  /**
+   * Routes `STATS <query> [<server>]` to the stats reducer. Awaits the
+   * bound {@link ServerStats} backend (or zero-count fallback) and hands
+   * the result to the pure reducer. The reducer handles the implemented
+   * query letters (`u`, `l`), the unknown-letter charybdis-style empty
+   * body, and the `219` terminator; non-local `<server>` arguments
+   * produce `402 ERR_NOSUCHSERVER`.
+   */
+  private async routeStats(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const serverTarget = serverTargetOf(msg.params[1] ?? '', ctx.serverName);
+    const snapshot = await this.fetchStats();
+    return statsReducer(snapshot, msg, ctx, serverTarget).effects;
+  }
+
+  /**
+   * Fetches the current {@link ServerStatsSnapshot} from the bound backend.
+   * When no backend is wired, returns a zero-count snapshot so LUSERS/STATS
+   * still emit a well-formed reply rather than a 421/empty stream — the
+   * uptime anchor defaults to the actor's wall clock so `STATS u` reports
+   * zero uptime instead of a negative duration.
+   */
+  private async fetchStats(): Promise<import('@serverless-ircd/irc-core').ServerStatsSnapshot> {
+    if (this.stats !== undefined) {
+      return this.stats.getStats();
+    }
+    const now = this.clock.now();
+    return {
+      users: 0,
+      invisible: 0,
+      opers: 0,
+      unknownConnections: 0,
+      channels: 0,
+      servers: 1,
+      localConns: 0,
+      globalConns: 0,
+      maxLocalConns: 0,
+      maxGlobalConns: 0,
+      uptimeStartedAt: now,
+    };
+  }
+
+  /**
+   * Routes `USERHOST <nick>{ <nick>}` to the userhost reducer. Resolves each
+   * requested nick via the nick registry + connection lookup, passing the
+   * resulting snapshots (or `null` for offline nicks) to the pure formatter.
+   * The number of queried nicks is capped at
+   * `serverConfig.maxTargetsPerCommand` by the reducer.
+   */
+  private async routeUserhost(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const cap = ctx.serverConfig.maxTargetsPerCommand;
+    const resolved = new Map<string, ConnSnapshot | null>();
+    for (const nick of msg.params.slice(0, cap)) {
+      const connId = await this.runtime.lookupNick(nick);
+      if (connId === null) {
+        resolved.set(nick, null);
+        continue;
+      }
+      const conn = await this.runtime.getConnection(connId);
+      resolved.set(nick, conn === null ? null : toSnapshot(conn));
+    }
+    return userhostReducer(resolved, msg, ctx).effects;
+  }
+
+  /**
+   * Routes `ISON <nick>{ <nick>}` to the ison reducer. Resolves each requested
+   * nick via the nick registry; for online nicks, fetches the connection to
+   * recover the registered (display) spelling. Passes a folded→display map to
+   * the pure formatter.
+   */
+  private async routeIson(
+    msg: IrcMessage,
+    ctx: ReturnType<typeof buildCtx>,
+  ): Promise<EffectType[]> {
+    const cap = ctx.serverConfig.maxTargetsPerCommand;
+    const online = new Map<string, string>();
+    for (const nick of msg.params.slice(0, cap)) {
+      const connId = await this.runtime.lookupNick(nick);
+      if (connId === null) continue;
+      const conn = await this.runtime.getConnection(connId);
+      // `conn` can be null in the race where lookupNick resolved but the
+      // connection has since torn down (the nick map lags the connection
+      // map). Skip those — they are no longer online.
+      if (conn?.nick !== undefined) {
+        online.set(conn.nick.toLowerCase(), conn.nick);
+      }
+    }
+    return isonReducer(online, msg, ctx).effects;
+  }
+
   /**
    * Routes `CHATHISTORY <sub> <target> [<args>...]` to the chathistory
    * reducer. The command is query-only and must NOT create a channel as a
@@ -531,15 +900,6 @@ export class ConnectionActor {
   }
 }
 
-/**
- * Splits a WebSocket text frame into IRC lines. Tolerates `\r\n`, bare `\n`,
- * and missing trailing terminators. Returns each line bare (no CRLF).
- */
-export function splitFrameLines(text: string): string[] {
-  if (text.length === 0) return [];
-  return text.split(/\r?\n/u);
-}
-
 /** Returns the first whitespace-delimited token of `line`, or `''`. */
 function firstToken(line: string): string {
   const m = line.match(/^\S+/u);
@@ -555,6 +915,20 @@ function splitCsv(param: string): string[] {
   return param.split(',').filter((p) => p.length > 0);
 }
 
+/**
+ * Resolves the `<server>` parameter shared by `LUSERS` / `STATS` (and any
+ * future single-server-aware query verb). Returns `undefined` when the
+ * argument is absent OR names the local server (case-insensitive) — the
+ * caller then proceeds with the local-server code path. Returns the raw
+ * argument verbatim when it names a non-local server, which the reducer
+ * surfaces as `402 ERR_NOSUCHSERVER`.
+ */
+function serverTargetOf(rawServer: string, localServerName: string): string | undefined {
+  if (rawServer.length === 0) return undefined;
+  if (rawServer.toLowerCase() === localServerName.toLowerCase()) return undefined;
+  return rawServer;
+}
+
 /**
  * Extracts the channel names a reducer will read for the supplied command.
  * Used by `prefetchChannelState` to refresh only the channels the upcoming
@@ -564,8 +938,11 @@ function splitCsv(param: string): string[] {
  * Commands not listed here either have no channel target (PING, NICK, …)
  * or read channel membership from `ctx.connection.joinedChannels` directly
  * (QUIT), so they don't need a prefetch.
+ *
+ * Exported so the per-command dispatch table can be unit-tested without
+ * standing up a full {@link ConnectionActor} + runtime.
  */
-function channelTargetsForMessage(msg: IrcMessage): ChanName[] {
+export function channelTargetsForMessage(msg: IrcMessage): ChanName[] {
   const cmd = msg.command;
   switch (cmd) {
     case 'JOIN':

package/packages/irc-server/src/dispatch.ts

@@ -33,9 +33,7 @@ const handlers: { [K in Effect['tag']]: Handler<Extract<Effect, { tag: K }>> } =
   ChangeNick: (e, r) => r.changeNick(e.conn, e.oldNick, e.newNick).then(noop),
   ReleaseNick: (e, r) => r.releaseNick(e.nick),
   ApplyChannelDelta: (e, r) => r.applyChannelDelta(e.chan, e.delta),
-  LookupNick: (e, r) => r.lookupNick(e.nick).then(noop),
-  GetConnectionInfo: (e, r) => r.getConnectionInfo(e.conn).then(noop),
-  GetChannelSnapshot: (e, r) => r.getChannelSnapshot(e.chan).then(noop),
+  BroadcastWallops: (e, r) => r.broadcastWallops(e.lines, e.except),
 };
 
 function noop(): void {}

package/packages/irc-server/src/index.ts

@@ -3,11 +3,19 @@
  *
  * Orchestration layer: defines the {@link IrcRuntime} port, the {@link dispatch}
  * interpreter that runs an `Effect[]` against it, and the {@link ConnectionActor}
- * that turns a WebSocket text frame into reducer invocations + dispatch.
+ * that turns inbound transport input (a WebSocket text frame or a raw TCP byte
+ * chunk) into reducer invocations + dispatch via the transport-agnostic
+ * {@link Transport} framing seam.
  */
 export type { IrcRuntime } from './runtime.js';
 export { dispatch } from './dispatch.js';
-export { ConnectionActor, splitFrameLines } from './actor.js';
+export { ConnectionActor } from './actor.js';
 export type { ActorChannelAccess, ConnectionActorOptions } from './actor.js';
+export {
+  splitFrameLines,
+  WsTextFrameTransport,
+  TcpByteStreamTransport,
+} from './transport.js';
+export type { Transport } from './transport.js';
 export { buildRoutedReducers, resolveFloodControl } from './routing.js';
 export type { RoutedReducers } from './routing.js';

package/packages/irc-server/src/routing.ts

@@ -29,11 +29,13 @@ import {
   type FloodControlConfig,
   type Reducer,
   type ServerConfig,
+  adminReducer,
   authenticateReducer,
   awayReducer,
   capReducer,
   channelModeReducer,
   defaultCommandCost,
+  infoReducer,
   inviteReducer,
   joinReducer,
   kickReducer,
@@ -50,11 +52,14 @@ import {
   privmsgChannelReducer,
   privmsgUserReducer,
   quitReducer,
+  setnameReducer,
   tagmsgChannelReducer,
   tagmsgUserReducer,
+  timeReducer,
   topicReducer,
   userModeReducer,
   userReducer,
+  versionReducer,
   wrapWithFloodControl,
 } from '@serverless-ircd/irc-core';
 
@@ -76,6 +81,11 @@ export interface RoutedReducers {
   readonly cap: Reducer<ConnectionState>;
   readonly authenticate: Reducer<ConnectionState>;
   readonly away: Reducer<ConnectionState>;
+  readonly setname: Reducer<ConnectionState>;
+  readonly version: Reducer<ConnectionState>;
+  readonly time: Reducer<ConnectionState>;
+  readonly admin: Reducer<ConnectionState>;
+  readonly info: Reducer<ConnectionState>;
   // Channel-authority reducers.
   readonly join: Reducer<ChannelState>;
   readonly part: Reducer<ChannelState>;
@@ -142,6 +152,11 @@ export function buildRoutedReducers(serverConfig: ServerConfig): RoutedReducers
     cap: wrap(capReducer),
     authenticate: wrap(authenticateReducer),
     away: wrap(awayReducer),
+    setname: wrap(setnameReducer),
+    version: wrap(versionReducer),
+    time: wrap(timeReducer),
+    admin: wrap(adminReducer),
+    info: wrap(infoReducer),
     join: wrap(joinReducer),
     part: wrap(partReducer),
     topic: wrap(topicReducer),