serverless-ircd 0.2.0 → 0.4.0

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

@@ -33,9 +33,11 @@
  */
 
 import {
+  SASL_CAP_NAME,
   SUPPORTED_CAPABILITIES,
   capToLsString,
   isSupportedCap,
+  saslCapValue,
   splitCapsForWire,
 } from '../caps/capabilities.js';
 import { Effect } from '../effects.js';
@@ -88,7 +90,12 @@ function handleLs(state: ConnectionState, ctx: Ctx): ReducerResult<ConnectionSta
   state.capNegotiating = true;
 
   const target = state.nick ?? '*';
-  const tokens = SUPPORTED_CAPABILITIES.map(capToLsString);
+  const hasMtls = ctx.mtlsIdentity !== undefined;
+  const tokens = SUPPORTED_CAPABILITIES.map((cap) =>
+    cap.name === SASL_CAP_NAME
+      ? capToLsString({ ...cap, value: saslCapValue(hasMtls) })
+      : capToLsString(cap),
+  );
   const maxLen = maxCapsContentLen(ctx, target);
   const chunks = splitCapsForWire(tokens, maxLen);
 

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,
@@ -33,6 +34,7 @@ export { channelModeReducer, userModeReducer } from './mode.js';
 export { inviteReducer } from './invite.js';
 export { whoReducer } from './who.js';
 export { whoisReducer } from './whois.js';
+export { whowasReducer } from './whowas.js';
 export { generateIsupport } from './isupport.js';
 export { capReducer } from './cap.js';
 export { emitChghost } from './chghost.js';
@@ -45,3 +47,12 @@ export {
   buildChathistoryBatch,
   CHATHISTORY_CAP,
 } from './chathistory.js';
+export { tagmsgChannelReducer, tagmsgUserReducer } from './tagmsg.js';
+export {
+  versionReducer,
+  timeReducer,
+  adminReducer,
+  infoReducer,
+} from './server-info.js';
+export { userhostReducer, formatUserhostReply } from './userhost.js';
+export { isonReducer } from './ison.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/ison.ts

@@ -0,0 +1,61 @@
+/**
+ * Pure reducer for the IRC `ISON` command.
+ *
+ * PLAN §2.1 location-of-authority: ISON is read-only — it checks which of the
+ * requested nicks are currently online and emits a single `303 RPL_ISON`
+ * line. The reducer itself does not perform lookups (those are async and
+ * belong to the actor / runtime layer); it receives the set of online nicks
+ * and the requested list, then reports the intersection.
+ *
+ * Wire format (RFC 2812 §5.8):
+ *   - `ISON <nick>{ <nick>}`
+ *   - `303 RPL_ISON`:
+ *     `:<server> 303 <nick> :<online_nick1> <online_nick2> …`
+ *
+ * Matching is case-insensitive per rfc1459 case-mapping. The reply carries
+ * the registered (display) spelling from the online map, not the requester's
+ * spelling, so a request for `BOB` reports `Bob` when that is the registered
+ * form.
+ */
+
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+import type { ConnectionState } from '../state/connection.js';
+import type { Ctx, ReducerResult } from '../types.js';
+
+/**
+ * Handles `ISON <nick>{ <nick>}`.
+ *
+ * `online` maps each online nick's case-folded (lowercased) form to its
+ * display spelling. Each requested nick is folded and looked up; matches are
+ * reported using the display spelling from the map.
+ *
+ * Signature is bespoke (not {@link Reducer}) because the actor must resolve
+ * the nicks asynchronously before formatting — mirrors `whoReducer` /
+ * `whoisReducer`.
+ */
+export function isonReducer(
+  online: ReadonlyMap<string, string>,
+  msg: { params: readonly string[] },
+  ctx: Ctx,
+): ReducerResult<ConnectionState> {
+  ctx.connection.lastSeen = ctx.clock.now();
+
+  const found: string[] = [];
+  for (const requested of msg.params) {
+    if (requested.length === 0) continue;
+    const display = online.get(requested.toLowerCase());
+    if (display !== undefined) {
+      found.push(display);
+    }
+  }
+
+  const nick = ctx.connection.nick ?? '*';
+  const codeStr = Numerics.RPL_ISON.toString().padStart(3, '0');
+  const trailing = found.join(' ');
+  const line: RawLine = { text: `:${ctx.serverName} ${codeStr} ${nick} :${trailing}` };
+
+  const effects: EffectType[] = [Effect.send(ctx.connId, [line])];
+  return { state: ctx.connection, effects };
+}

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;
+}

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

@@ -11,38 +11,16 @@
  * D1, or Secrets Manager) so the reducer itself stays pure and
  * deterministic — no IO in the handler.
  *
- * 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).
+ * The numeric rendering (`375`/`372`×N/`376`, or `422 ERR_NOMOTD`) is shared
+ * with the registration welcome block via {@link buildMotdNumerics} so the
+ * two paths cannot drift.
  */
 
 import { Effect } from '../effects.js';
 import type { Effect as EffectType, RawLine } from '../effects.js';
-import { Numerics } from '../protocol/numerics.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.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';
+import { buildMotdNumerics } from './motd-lines.js';
 
 /**
  * Handles `MOTD [server]`.
@@ -56,91 +34,9 @@ const NOMOTD_TRAILING_TEXT = 'MOTD File is missing';
 export const motdReducer: Reducer<ConnectionState> = (state, _msg, ctx) => {
   state.lastSeen = ctx.clock.now();
 
-  const lines = ctx.motd.lines();
-
-  if (lines.length === 0) {
-    return {
-      state,
-      effects: [
-        Effect.send(ctx.connId, [numericLine(ctx, Numerics.ERR_NOMOTD, NOMOTD_TRAILING_TEXT)]),
-      ],
-    };
-  }
-
-  const out: RawLine[] = [
-    numericLine(
-      ctx,
-      Numerics.RPL_MOTDSTART,
-      MOTDSTART_TRAILING_TEXT.replace('$server', ctx.serverName),
-    ),
-  ];
-
-  const maxContent = maxMotdContentLen(ctx);
-  for (const raw of lines) {
-    for (const chunk of splitForMotd(raw, maxContent)) {
-      out.push(numericLine(ctx, Numerics.RPL_MOTD, `- ${chunk}`));
-    }
-  }
-
-  out.push(numericLine(ctx, Numerics.RPL_ENDOFMOTD, ENDOFMOTD_TRAILING_TEXT));
+  const nick = ctx.connection.nick ?? '*';
+  const out: RawLine[] = buildMotdNumerics(ctx.serverName, nick, ctx.motd.lines());
 
   const effects: EffectType[] = [Effect.send(ctx.connId, out)];
   return { state, effects };
 };
-
-/**
- * Builds a `:<server> <code> <nick> :<trailing>` line. The nick falls back
- * to `*` when the connection has not yet registered one, matching the rest
- * of the codebase's numeric-error formatting.
- */
-function numericLine(ctx: Ctx, code: number, trailing: string): RawLine {
-  const nick = ctx.connection.nick ?? '*';
-  const codeStr = code.toString().padStart(3, '0');
-  return { text: `:${ctx.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 the connection's 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(ctx: Ctx): number {
-  const nick = ctx.connection.nick ?? '*';
-  const overhead = TRAILING_CRLF_LEN + 1 + ctx.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 reducer deterministic.
- *
- * Edge cases:
- *   - Empty string → `['']` (one empty 372 line, still RFC-conformant).
- *   - Zero/negative budget (impossible in practice but defensive) → `['']`
- *     so the reducer 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;
-}