serverless-ircd 0.2.0 → 0.3.0

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

@@ -27,6 +27,7 @@ import {
   type Nick,
   type RawLine,
   applyChannelDelta as applyDelta,
+  caseFold,
   createChannel,
   decideAdmission,
   toChannelSnapshot,
@@ -53,21 +54,6 @@ interface TrackedConnection {
   admissionRecordId?: string;
 }
 
-function lower(s: string): string {
-  return s.toLowerCase();
-}
-
-let disabledRecordCounter = 0;
-/**
- * Returns a unique record id for the "admission disabled" path. The id is
- * never consulted (no {@link AdmissionStats} exists), but emitting one
- * keeps {@link admitConnection}'s return shape uniform.
- */
-function _disabledRecordId(): string {
-  disabledRecordCounter += 1;
-  return `disabled-${disabledRecordCounter}`;
-}
-
 export interface InMemoryRuntimeOptions {
   clock: Clock;
   /**
@@ -113,7 +99,7 @@ export class InMemoryRuntime implements IrcRuntime {
    */
   admitConnection(ip: string, user: string | undefined): AdmissionDecision {
     if (this.admissionConfig === undefined || this.admissionStats === undefined) {
-      return { ok: true, recordId: _disabledRecordId() };
+      return { ok: true, recordId: '' };
     }
     return decideAdmission(ip, user, this.admissionStats, this.admissionConfig);
   }
@@ -185,7 +171,7 @@ export class InMemoryRuntime implements IrcRuntime {
    * return the same object.
    */
   getOrCreateChannel(name: ChanName): ChannelState {
-    const key = lower(name);
+    const key = caseFold('rfc1459', name);
     const existing = this.channels.get(key);
     if (existing !== undefined) return existing;
     const created = createChannel({
@@ -204,7 +190,7 @@ export class InMemoryRuntime implements IrcRuntime {
    * missing channel from an empty one.
    */
   getChannel(name: ChanName): ChannelState | undefined {
-    return this.channels.get(lower(name));
+    return this.channels.get(caseFold('rfc1459', name));
   }
 
   // ------------------------------------------------------------------
@@ -218,7 +204,7 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async broadcast(chan: ChanName, lines: RawLine[], except?: ConnId): Promise<void> {
-    const channel = this.channels.get(lower(chan));
+    const channel = this.channels.get(caseFold('rfc1459', chan));
     if (channel === undefined) return;
     for (const member of channel.members.keys()) {
       if (member === except) continue;
@@ -240,7 +226,7 @@ export class InMemoryRuntime implements IrcRuntime {
     lines: RawLine[],
     notFoundLines?: RawLine[],
   ): Promise<void> {
-    const owner = this.nicks.get(lower(nick));
+    const owner = this.nicks.get(caseFold('rfc1459', nick));
     if (owner !== undefined) {
       const conn = this.connections.get(owner);
       if (conn !== undefined) {
@@ -261,7 +247,7 @@ export class InMemoryRuntime implements IrcRuntime {
   // ------------------------------------------------------------------
 
   async reserveNick(nick: Nick, conn: ConnId): Promise<{ ok: true } | { ok: false }> {
-    const key = lower(nick);
+    const key = caseFold('rfc1459', nick);
     const existing = this.nicks.get(key);
     if (existing !== undefined && existing !== conn) {
       return { ok: false };
@@ -271,8 +257,8 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async changeNick(conn: ConnId, oldNick: Nick, newNick: Nick): Promise<boolean> {
-    const newKey = lower(newNick);
-    const oldKey = lower(oldNick);
+    const newKey = caseFold('rfc1459', newNick);
+    const oldKey = caseFold('rfc1459', oldNick);
     const owner = this.nicks.get(newKey);
     if (owner !== undefined && owner !== conn) {
       return false;
@@ -287,7 +273,7 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async releaseNick(nick: Nick): Promise<void> {
-    this.nicks.delete(lower(nick));
+    this.nicks.delete(caseFold('rfc1459', nick));
   }
 
   // ------------------------------------------------------------------
@@ -300,7 +286,7 @@ export class InMemoryRuntime implements IrcRuntime {
     // replace the stored object so subsequent snapshots see the new data
     // while any outstanding references to the prior state stay coherent.
     const next = applyDelta(channel, delta);
-    this.channels.set(lower(chan), next);
+    this.channels.set(caseFold('rfc1459', chan), next);
   }
 
   // ------------------------------------------------------------------
@@ -308,7 +294,7 @@ export class InMemoryRuntime implements IrcRuntime {
   // ------------------------------------------------------------------
 
   async lookupNick(nick: Nick): Promise<ConnId | null> {
-    return this.nicks.get(lower(nick)) ?? null;
+    return this.nicks.get(caseFold('rfc1459', nick)) ?? null;
   }
 
   async getConnectionInfo(conn: ConnId): Promise<ConnSnapshot | null> {
@@ -328,13 +314,13 @@ export class InMemoryRuntime implements IrcRuntime {
   }
 
   async getChannelSnapshot(chan: ChanName): Promise<ChanSnapshot | null> {
-    const channel = this.channels.get(lower(chan));
+    const channel = this.channels.get(caseFold('rfc1459', chan));
     if (channel === undefined) return null;
     return toChannelSnapshot(channel);
   }
 
   async getChannelConnections(chan: ChanName): Promise<ReadonlyMap<ConnId, ConnectionState>> {
-    const channel = this.channels.get(lower(chan));
+    const channel = this.channels.get(caseFold('rfc1459', chan));
     const out = new Map<ConnId, ConnectionState>();
     if (channel === undefined) return out;
     for (const connId of channel.members.keys()) {

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

@@ -227,6 +227,14 @@ describe('InMemoryRuntime — applyChannelDelta / getChannelSnapshot', () => {
     expect(snap?.members.has('c1')).toBe(true);
   });
 
+  it('treats rfc1459 special chars [ \\ ] ^ as equal to { | } ~', async () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const a = rt.getOrCreateChannel('#[Foo]');
+    const b = rt.getOrCreateChannel('#{foo}');
+    expect(b).toBe(a);
+    expect(b.nameLower).toBe('#{foo}');
+  });
+
   it('returns null from getChannelSnapshot for an unknown channel', async () => {
     const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
     expect(await rt.getChannelSnapshot('#nope')).toBeNull();
@@ -614,4 +622,15 @@ describe('InMemoryRuntime — admission gate', () => {
     }
     expect(decisions.every((d) => d.ok)).toBe(true);
   });
+
+  it('returns a stable recordId when admission is disabled (no per-call minting)', () => {
+    const rt = new InMemoryRuntime({ clock: new FakeClock(0) });
+    const d1 = rt.admitConnection('1.1.1.1', 'alice');
+    const d2 = rt.admitConnection('2.2.2.2', 'bob');
+    expect(d1.ok).toBe(true);
+    expect(d2.ok).toBe(true);
+    if (d1.ok && d2.ok) {
+      expect(d1.recordId).toBe(d2.recordId);
+    }
+  });
 });

package/packages/irc-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serverless-ircd/irc-core",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "private": true,
   "description": "Platform-agnostic IRC protocol core: parser, serializer, command reducers, state shapes",
   "license": "BSD-3-Clause",
@@ -34,6 +34,7 @@
   },
   "devDependencies": {
     "@stryker-mutator/core": "^9.6.1",
-    "@stryker-mutator/vitest-runner": "^9.6.1"
+    "@stryker-mutator/vitest-runner": "^9.6.1",
+    "vitest": "^4.1.0"
   }
 }

package/packages/irc-core/src/case-fold.ts

@@ -0,0 +1,64 @@
+/**
+ * IRC case-mapping (case folding) for nick and channel-name comparison.
+ *
+ * IRC servers compare nicks and channel names case-insensitively, but the
+ * exact set of characters that fold together is advertised to clients via
+ * the `005 RPL_ISUPPORT` `CASEMAPPING=` token. This module implements the
+ * two relevant mappings:
+ *
+ *   - `ascii`   — only `A`–`Z` fold to `a`–`z`.
+ *   - `rfc1459` — `ascii` plus the four characters `[ \ ] ^` folding to
+ *     `{ | } ~` respectively (per RFC 1459 §2.2). The targets
+ *     `{ | } ~` do NOT fold further, so the fold is idempotent:
+ *     `fold(fold(s)) === fold(s)`.
+ *
+ * The fold operates on one character at a time and leaves every other byte
+ * (including all non-ASCII) unchanged. It is pure and dependency-free so it
+ * runs unchanged on every runtime (Node, Workers, Lambda).
+ *
+ * Advertised via {@link CaseMapping} and consumed by the command reducers
+ * and the reference runtime so that the advertised case-mapping and the
+ * actual folding never diverge.
+ */
+
+/** Case-mapping algorithms supported for IRC-name comparison. */
+export type CaseMapping = 'rfc1459' | 'ascii';
+
+/**
+ * Lowercases `s` according to `mapping`, returning the canonical key used
+ * for case-insensitive nick and channel comparison.
+ *
+ * @param mapping  `rfc1459` (default behaviour everywhere in this server) or
+ *                 `ascii` (a strict subset — useful for strict-ASCII tests).
+ * @param s        The nick or channel name to fold.
+ */
+export function caseFold(mapping: CaseMapping, s: string): string {
+  let out = '';
+  for (let i = 0; i < s.length; i += 1) {
+    out += foldChar(mapping, s.charCodeAt(i));
+  }
+  return out;
+}
+
+/** Folds a single UTF-16 code unit per the active mapping. */
+function foldChar(mapping: CaseMapping, code: number): string {
+  if (code >= 0x41 && code <= 0x5a) {
+    // A–Z → a–z
+    return String.fromCharCode(code + 0x20);
+  }
+  if (mapping === 'rfc1459') {
+    switch (code) {
+      case 0x5b:
+        return '{'; // [ → {
+      case 0x5c:
+        return '|'; // \ → |
+      case 0x5d:
+        return '}'; // ] → }
+      case 0x5e:
+        return '~'; // ^ → ~
+      default:
+        break;
+    }
+  }
+  return String.fromCharCode(code);
+}

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

@@ -18,6 +18,7 @@ export { quitReducer } from './quit.js';
 export { handleJoinZero, isValidChannelName, joinReducer } from './join.js';
 export { partReducer } from './part.js';
 export { motdReducer } from './motd.js';
+export { operReducer, matchOperCred } from './oper.js';
 export {
   isChannelTarget,
   noticeChannelReducer,
@@ -45,3 +46,4 @@ export {
   buildChathistoryBatch,
   CHATHISTORY_CAP,
 } from './chathistory.js';
+export { tagmsgChannelReducer, tagmsgUserReducer } from './tagmsg.js';

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

@@ -20,6 +20,7 @@
  * case-insensitively against the roster (443 if already a member).
  */
 
+import { caseFold } from '../case-fold.js';
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
 import { Numerics } from '../protocol/numerics.js';
@@ -50,15 +51,11 @@ function numericErr(ctx: Ctx, code: number, trailing: string, middle?: string):
   return { text: parts.join(' ') };
 }
 
-function lowerNick(nick: string): string {
-  return nick.toLowerCase();
-}
-
-/** Finds a roster entry's connId by nick (case-insensitive). */
+/** Finds a roster entry's connId by nick (case-insensitively, per `CASEMAPPING=rfc1459`). */
 function findConnIdByNick(state: ChannelState, nick: string): string | null {
-  const target = lowerNick(nick);
+  const target = caseFold('rfc1459', nick);
   for (const entry of state.members.values()) {
-    if (lowerNick(entry.nick) === target) return entry.conn;
+    if (caseFold('rfc1459', entry.nick) === target) return entry.conn;
   }
   return null;
 }
@@ -132,9 +129,9 @@ export const inviteReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     return { state, effects };
   }
 
-  // Success: record the pending invite (by lowercased nick) so a later
+  // Success: record the pending invite (by case-folded nick) so a later
   // JOIN bypasses +i, emit 341, and route the INVITE notice to the invitee.
-  state.pendingInvites.add(targetNick.toLowerCase());
+  state.pendingInvites.add(caseFold('rfc1459', targetNick));
 
   const inviterNick = ctx.connection.nick ?? '*';
   effects.push(

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

@@ -39,7 +39,7 @@ const PREFIX = '(ov)@+';
 /** Channel name sigils this server recognises. */
 const CHANTYPES = '#';
 
-/** Case-mapping algorithm — v1 uses RFC 1459 (matches `lower.ts`). */
+/** Case-mapping algorithm — v1 uses RFC 1459 (matches `case-fold.ts`). */
 const CASEMAPPING = 'rfc1459';
 
 /** Default max mode changes per single MODE command (PLAN §3). */

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

@@ -15,6 +15,7 @@
  * channel.
  */
 
+import { caseFold } from '../case-fold.js';
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
 import type { StoredMessage } from '../ports.js';
@@ -213,9 +214,9 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     }
   }
 
-  // Invite-only check. pendingInvites stores lowercased nicks.
+  // Invite-only check. pendingInvites stores case-folded nicks.
   const myNick = ctx.connection.nick;
-  const invited = myNick !== undefined && state.pendingInvites.has(myNick.toLowerCase());
+  const invited = myNick !== undefined && state.pendingInvites.has(caseFold('rfc1459', myNick));
   if (state.modes.inviteOnly && !invited) {
     effects.push(
       Effect.send(ctx.connId, [
@@ -258,7 +259,7 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
   });
 
   // Pending invite is consumed on a successful join.
-  if (myNick !== undefined) state.pendingInvites.delete(myNick.toLowerCase());
+  if (myNick !== undefined) state.pendingInvites.delete(caseFold('rfc1459', myNick));
 
   // Track the channel on the connection's joined set (cross-authority).
   ctx.connection.joinedChannels.add(state.nameLower);

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

@@ -13,6 +13,7 @@
  * one channel per invocation.
  */
 
+import { caseFold } from '../case-fold.js';
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
 import { Numerics } from '../protocol/numerics.js';
@@ -52,14 +53,6 @@ function kickerHostmask(conn: ConnectionState): string {
   return hostmaskOf(conn) ?? conn.nick ?? '?';
 }
 
-/**
- * Lowercases a nick using ASCII case folding (good enough for v1; rfc1459
- * case mapping lands with the isupport `CASEMAPPING` token).
- */
-function lowerNick(nick: string): string {
-  return nick.toLowerCase();
-}
-
 /**
  * Handles `KICK <chan> <user> [:reason]`.
  *
@@ -117,11 +110,11 @@ export const kickReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     return { state, effects };
   }
 
-  // Find the target by nick (case-insensitive). IRC nicks fold by ASCII.
-  const targetLower = lowerNick(targetNick);
+  // Find the target by nick (case-insensitively, per `CASEMAPPING=rfc1459`).
+  const targetLower = caseFold('rfc1459', targetNick);
   let targetConnId: string | undefined;
   for (const entry of state.members.values()) {
-    if (lowerNick(entry.nick) === targetLower) {
+    if (caseFold('rfc1459', entry.nick) === targetLower) {
       targetConnId = entry.conn;
       break;
     }

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

@@ -26,6 +26,7 @@
  * the cap).
  */
 
+import { caseFold } from '../case-fold.js';
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
 import { Numerics } from '../protocol/numerics.js';
@@ -104,10 +105,10 @@ export const listReducer: Reducer<ChanSnapshot[]> = (state, msg, ctx) => {
     for (const rawName of requested) {
       if (lines.length >= max) break;
       if (!isValidChannelName(rawName, ctx.serverConfig.channelLen)) continue;
-      const lower = rawName.toLowerCase();
-      if (seen.has(lower)) continue;
-      seen.add(lower);
-      const chan = state.find((c) => c.nameLower === lower);
+      const key = caseFold('rfc1459', rawName);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const chan = state.find((c) => c.nameLower === key);
       if (chan === undefined) continue;
       if (!isVisible(chan, ctx)) continue;
       lines.push(listLine(chan, ctx, nick));

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

@@ -12,7 +12,7 @@
  *     for its own user modes, so the reducer's `state` argument is the
  *     caller's {@link ConnectionState}. A user may only change their own
  *     modes (502 otherwise). The oper flag (`+o`) is granted via the
- *     future OPER command, not via MODE — `+o` here is rejected with 481.
+ *     OPER command, not via MODE — `+o` here is rejected with 481.
  *
  * Mode classes (per modern IRC de-facto convention):
  *   - Type A (list mode, always takes arg): `b` (ban mask).
@@ -28,6 +28,7 @@
  *     channel.
  */
 
+import { caseFold } from '../case-fold.js';
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
 import { Numerics } from '../protocol/numerics.js';
@@ -66,11 +67,6 @@ function numericErr(ctx: Ctx, code: number, trailing: string, middle?: string):
   return { text: parts.join(' ') };
 }
 
-/** Lowercases a nick using ASCII case folding (matches kick.ts). */
-function lowerNick(nick: string): string {
-  return nick.toLowerCase();
-}
-
 /** Boolean channel mode letters → mode-field name. */
 const BOOLEAN_LETTERS: Readonly<Record<string, BooleanChannelMode>> = {
   i: 'inviteOnly',
@@ -417,9 +413,9 @@ function findMemberByNick(
   state: ChannelState,
   nick: string,
 ): { conn: string; nick: string; op: boolean; voice: boolean } | null {
-  const targetLower = lowerNick(nick);
+  const targetLower = caseFold('rfc1459', nick);
   for (const entry of state.members.values()) {
-    if (lowerNick(entry.nick) === targetLower) {
+    if (caseFold('rfc1459', entry.nick) === targetLower) {
       return entry;
     }
   }
@@ -566,7 +562,7 @@ export const userModeReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
 
   // Target must be the caller's own nick (case-insensitive).
   const myNick = state.nick;
-  if (myNick === undefined || lowerNick(target) !== lowerNick(myNick)) {
+  if (myNick === undefined || caseFold('rfc1459', target) !== caseFold('rfc1459', myNick)) {
     effects.push(
       Effect.send(ctx.connId, [
         numericErr(ctx, Numerics.ERR_USERSDONTMATCH, 'Cannot change mode for other users'),

package/packages/irc-core/src/commands/motd-lines.ts

@@ -0,0 +1,127 @@
+/**
+ * Shared MOTD-lines → IRC numerics builder.
+ *
+ * Both the registration welcome block ({@link buildWelcomeLines}) and the
+ * standalone `MOTD` command ({@link motdReducer}) render the same
+ * `375`/`372`×N/`376` sequence (or `422 ERR_NOMOTD` when no MOTD is
+ * configured) from the lines supplied by a {@link MotdProvider}. This module
+ * owns that rendering so the two call sites cannot drift.
+ *
+ * Wire format (RFC 2812 §5):
+ *   - `375 RPL_MOTDSTART`  — `:<server> 375 <nick> :- <server> Message of the day -`
+ *   - `372 RPL_MOTD`        — `:<server> 372 <nick> :- <line>`  (one per MOTD line)
+ *   - `376 RPL_ENDOFMOTD`  — `:<server> 376 <nick> :End of MOTD command`
+ *   - `422 ERR_NOMOTD`     — `:<server> 422 <nick> :MOTD File is missing`
+ *
+ * Per RFC 1459 §2.3 the maximum wire line length is 512 bytes including the
+ * trailing CR-LF. Over-long MOTD content lines are hard-wrapped at the
+ * 372-line content budget so every emitted line fits within the 512-byte
+ * limit (also leaving headroom for message-tags).
+ */
+
+import type { RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+
+/** RFC 1459 §2.3: maximum IRC line length in bytes, including the trailing CR-LF. */
+const MAX_LINE_BYTES = 512;
+
+/** Length of the trailing CR-LF that the wire layer appends to each line. */
+const TRAILING_CRLF_LEN = 2;
+
+/** Fixed text emitted for `375 RPL_MOTDSTART` (after `:- `). */
+const MOTDSTART_TRAILING_TEXT = '- $server Message of the day -';
+
+/** Fixed text emitted for `376 RPL_ENDOFMOTD`. */
+const ENDOFMOTD_TRAILING_TEXT = 'End of MOTD command';
+
+/** Fixed text emitted for `422 ERR_NOMOTD`. */
+const NOMOTD_TRAILING_TEXT = 'MOTD File is missing';
+
+/**
+ * Renders the MOTD numerics addressed to `nick` from the supplied `lines`.
+ *
+ * Returns `[422 ERR_NOMOTD]` when `lines` is empty (mirroring the standalone
+ * `MOTD` command), otherwise the `375`/`372`×N/`376` block with over-long
+ * lines hard-wrapped to fit the 512-byte wire limit.
+ *
+ * `nick` is taken verbatim from the caller — the welcome path passes the
+ * (guaranteed-defined) registering nick, the standalone command passes
+ * `connection.nick ?? '*'`.
+ */
+export function buildMotdNumerics(serverName: string, nick: string, lines: string[]): RawLine[] {
+  if (lines.length === 0) {
+    return [numericLine(serverName, nick, Numerics.ERR_NOMOTD, NOMOTD_TRAILING_TEXT)];
+  }
+
+  const out: RawLine[] = [
+    numericLine(
+      serverName,
+      nick,
+      Numerics.RPL_MOTDSTART,
+      MOTDSTART_TRAILING_TEXT.replace('$server', serverName),
+    ),
+  ];
+
+  const maxContent = maxMotdContentLen(serverName, nick);
+  for (const raw of lines) {
+    for (const chunk of splitForMotd(raw, maxContent)) {
+      out.push(numericLine(serverName, nick, Numerics.RPL_MOTD, `- ${chunk}`));
+    }
+  }
+
+  out.push(numericLine(serverName, nick, Numerics.RPL_ENDOFMOTD, ENDOFMOTD_TRAILING_TEXT));
+  return out;
+}
+
+/**
+ * Builds a `:<server> <code> <nick> :<trailing>` line.
+ */
+function numericLine(serverName: string, nick: string, code: number, trailing: string): RawLine {
+  const codeStr = code.toString().padStart(3, '0');
+  return { text: `:${serverName} ${codeStr} ${nick} :${trailing}` };
+}
+
+/**
+ * Returns the maximum content-byte length that fits in a single `372 RPL_MOTD`
+ * line for this connection, given the server name and nick.
+ *
+ * The 372 wire format is `:<server> 372 <nick> :- <chunk>\r\n`, so the
+ * per-chunk budget is:
+ *
+ *   512
+ *   - 2                              (trailing CR-LF)
+ *   - 1                              (leading `:`)
+ *   - <server>.length
+ *   - 5                              (` 372 `)
+ *   - <nick>.length
+ *   - 4                              (` :- `)
+ *
+ * The result is clamped at 0 so a pathologically long server/nick combo
+ * cannot drive the budget negative.
+ */
+function maxMotdContentLen(serverName: string, nick: string): number {
+  const overhead = TRAILING_CRLF_LEN + 1 + serverName.length + 5 + nick.length + 4;
+  return Math.max(0, MAX_LINE_BYTES - overhead);
+}
+
+/**
+ * Splits a single MOTD content line into chunks that each fit the per-372
+ * content budget.
+ *
+ * Hard-wraps at the byte budget (no word-boundary awareness) — matching the
+ * behavior of mainstream IRC daemons and keeping the rendering deterministic.
+ *
+ * Edge cases:
+ *   - Empty string → `['']` (one empty 372 line, still RFC-conformant).
+ *   - Zero/negative budget (impossible in practice but defensive) → `['']`
+ *     so the builder always emits at least one 372 per input line.
+ */
+function splitForMotd(text: string, maxLen: number): string[] {
+  if (maxLen <= 0) return [''];
+  if (text.length === 0) return [''];
+  const chunks: string[] = [];
+  for (let i = 0; i < text.length; i += maxLen) {
+    chunks.push(text.slice(i, i + maxLen));
+  }
+  return chunks;
+}