serverless-ircd 0.1.0

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

@@ -0,0 +1,82 @@
+/**
+ * Pure reducer for the IRC `AWAY` command + IRCv3 `away-notify` capability.
+ *
+ * PLAN §2.1 location-of-authority: AWAY runs in the Connection entity. The
+ * reducer's `state` argument is the connection's authoritative
+ * {@link ConnectionState}; the away reason is stored as `state.away`.
+ *
+ * Wire format:
+ *   - `AWAY [:<reason>]` — sets away when `<reason>` is non-empty; clears
+ *     it when absent or empty.
+ *   - `:server 305 <nick> :You are no longer marked as being away` (RPL_UNAWAY)
+ *   - `:server 306 <nick> :You have been marked as being away` (RPL_NOWAWAY)
+ *
+ * IRCv3 away-notify: connections with the `away-notify` cap negotiated who
+ * share a channel with the away user receive an `AWAY` message broadcast:
+ *   - `:<hostmask> AWAY :<reason>` on set
+ *   - `:<hostmask> AWAY` on unset (no trailing param)
+ *
+ * The broadcast is cap-only (non-cap peers receive nothing) so legacy
+ * clients are unaffected.
+ */
+
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+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';
+
+/**
+ * Handles `AWAY [:<reason>]`.
+ *
+ * Validation order: missing/empty param → unset (305); otherwise set (306).
+ * away-notify cap peers in shared channels receive a cap-only broadcast.
+ */
+export const awayReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
+  state.lastSeen = ctx.clock.now();
+
+  const effects: EffectType[] = [];
+
+  const reason = msg.params[0];
+  const isSettingAway = reason !== undefined && reason.length > 0;
+
+  const nick = state.nick ?? '*';
+
+  if (isSettingAway) {
+    state.away = reason;
+    effects.push(
+      Effect.send(ctx.connId, [
+        {
+          text: `:${ctx.serverName} ${Numerics.RPL_NOWAWAY} ${nick} :You have been marked as being away`,
+        },
+      ]),
+    );
+  } else {
+    // biome-ignore lint/performance/noDelete: exactOptionalPropertyTypes forbids `= undefined`.
+    delete state.away;
+    effects.push(
+      Effect.send(ctx.connId, [
+        {
+          text: `:${ctx.serverName} ${Numerics.RPL_UNAWAY} ${nick} :You are no longer marked as being away`,
+        },
+      ]),
+    );
+  }
+
+  // away-notify fanout: emit a cap-only broadcast to each shared channel.
+  // The broadcast has no `lines` for non-cap peers (cap-only mode); cap
+  // peers receive the AWAY line.
+  if (state.joinedChannels.size > 0) {
+    const hostmask = hostmaskOf(state) ?? state.nick ?? '?';
+    const line: RawLine = isSettingAway
+      ? { text: `:${hostmask} AWAY :${reason}` }
+      : { text: `:${hostmask} AWAY` };
+    for (const chan of state.joinedChannels) {
+      effects.push(Effect.broadcast(chan as ChanName, [line], undefined, 'away-notify'));
+    }
+  }
+
+  return { state, effects };
+};

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

@@ -0,0 +1,257 @@
+/**
+ * Pure reducer for the IRCv3 `CAP` command.
+ *
+ * PLAN §2.1 location-of-authority: `CAP` runs in the Connection entity.
+ * The reducer consults the capability table in `caps/capabilities.ts` and
+ * maintains two pieces of state on {@link ConnectionState}:
+ *
+ *   - `caps` — the set of negotiated cap names (sticky, consulted by every
+ *     reducer that needs to know whether a peer opted into an IRCv3
+ *     extension).
+ *   - `capNegotiating` — true between `CAP LS`/`CAP REQ` and `CAP END`.
+ *     While true the registration welcome block is deferred (IRCv3 spec
+ *     requirement) so the client can complete capability negotiation
+ *     before being considered registered.
+ *
+ * Wire format (IRCv3 Capability Negotiation):
+ *
+ *   Client -> Server:
+ *     `CAP LS [<version>]`
+ *     `CAP REQ :<cap>{ <cap>}`           (each cap may be `-`-prefixed to disable)
+ *     `CAP END`
+ *     `CAP LIST`
+ *
+ *   Server -> Client:
+ *     `:<server> CAP <nick> LS [*] :<caps>`   (multiline with the `*` marker)
+ *     `:<server> CAP <nick> ACK :<caps>`
+ *     `:<server> CAP <nick> NAK :<caps>`
+ *     `:<server> CAP <nick> LIST [*] :<caps>`
+ *     `:<server> 410 <nick> <cmd> :Invalid CAP command`
+ *
+ * `CAP NEW` and `CAP DEL` are server-to-client only in IRCv3.2; when sent
+ * by a client they are rejected with `410 ERR_INVALIDCAPCMD`.
+ */
+
+import {
+  SUPPORTED_CAPABILITIES,
+  capToLsString,
+  isSupportedCap,
+  splitCapsForWire,
+} from '../caps/capabilities.js';
+import { Effect } from '../effects.js';
+import type { RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+import type { ConnectionState } from '../state/connection.js';
+import type { Ctx, Reducer, ReducerResult } from '../types.js';
+import { emitWelcomeIfReady } from './registration.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;
+
+/**
+ * Handles `CAP <subcommand> [<args>]`. Dispatches to a per-subcommand
+ * handler; unknown subcommands (including server-to-client-only ones
+ * like `NEW`/`DEL`) fall through to `410 ERR_INVALIDCAPCMD`.
+ */
+export const capReducer: Reducer<ConnectionState> = (state, msg, ctx) => {
+  state.lastSeen = ctx.clock.now();
+
+  const rawSub = msg.params[0];
+  const sub = (rawSub ?? '').toUpperCase();
+
+  switch (sub) {
+    case 'LS':
+      return handleLs(state, ctx);
+    case 'LIST':
+      return handleList(state, ctx);
+    case 'REQ':
+      return handleReq(state, msg, ctx);
+    case 'END':
+      return handleEnd(state, ctx);
+    default:
+      return { state, effects: [Effect.send(ctx.connId, [invalidCapCmd(ctx, rawSub)])] };
+  }
+};
+
+/**
+ * `CAP LS` — advertise the supported capability set.
+ *
+ * Marks the connection as `capNegotiating` so the welcome block is
+ * deferred until `CAP END`. Splits the payload across multiple lines
+ * when it would exceed the 512-byte wire limit, using the `*` multiline
+ * marker per the IRCv3 spec.
+ */
+function handleLs(state: ConnectionState, ctx: Ctx): ReducerResult<ConnectionState> {
+  state.capNegotiating = true;
+
+  const target = state.nick ?? '*';
+  const tokens = SUPPORTED_CAPABILITIES.map(capToLsString);
+  const maxLen = maxCapsContentLen(ctx, target);
+  const chunks = splitCapsForWire(tokens, maxLen);
+
+  const lines: RawLine[] = chunks.map((chunk, i) => {
+    const isLast = i === chunks.length - 1;
+    if (isLast) {
+      return { text: `:${ctx.serverName} CAP ${target} LS :${chunk}` };
+    }
+    return { text: `:${ctx.serverName} CAP ${target} LS * :${chunk}` };
+  });
+
+  return { state, effects: [Effect.send(ctx.connId, lines)] };
+}
+
+/**
+ * `CAP LIST` — report the caps currently negotiated on this connection.
+ *
+ * Read-only: does not mutate `caps` and does not start CAP negotiation.
+ */
+function handleList(state: ConnectionState, ctx: Ctx): ReducerResult<ConnectionState> {
+  const target = state.nick ?? '*';
+  const tokens = [...state.caps].sort();
+  const maxLen = maxCapsContentLen(ctx, target);
+  const chunks = splitCapsForWire(tokens, maxLen);
+
+  const lines: RawLine[] = chunks.map((chunk, i) => {
+    const isLast = i === chunks.length - 1;
+    if (isLast) {
+      return { text: `:${ctx.serverName} CAP ${target} LIST :${chunk}` };
+    }
+    return { text: `:${ctx.serverName} CAP ${target} LIST * :${chunk}` };
+  });
+
+  return { state, effects: [Effect.send(ctx.connId, lines)] };
+}
+
+/**
+ * `CAP REQ :<caps>` — atomically enable or disable caps.
+ *
+ * Per IRCv3 the request is all-or-nothing: if every requested cap is
+ * supported (and the disable-marker form is well-formed), the server
+ * ACKs the request verbatim and updates `state.caps`. If any cap is
+ * unknown the entire request is NAKed and `state.caps` is untouched.
+ *
+ * Marks the connection as `capNegotiating` so the welcome stays deferred.
+ */
+function handleReq(
+  state: ConnectionState,
+  msg: { params: string[] },
+  ctx: Ctx,
+): ReducerResult<ConnectionState> {
+  const rawCaps = msg.params[1];
+  if (rawCaps === undefined || rawCaps === '') {
+    return {
+      state,
+      effects: [
+        Effect.send(ctx.connId, [
+          numericErr(ctx, Numerics.ERR_NEEDMOREPARAMS, 'Not enough parameters', 'CAP'),
+        ]),
+      ],
+    };
+  }
+
+  state.capNegotiating = true;
+
+  const requested = rawCaps.split(' ').filter((c) => c.length > 0);
+  const target = state.nick ?? '*';
+
+  const allSupported = requested.every((tok) => {
+    const name = tok.startsWith('-') ? tok.slice(1) : tok;
+    return isSupportedCap(name);
+  });
+
+  if (!allSupported) {
+    return {
+      state,
+      effects: [
+        Effect.send(ctx.connId, [
+          L(`:${ctx.serverName} CAP ${target} NAK :${requested.join(' ')}`),
+        ]),
+      ],
+    };
+  }
+
+  for (const tok of requested) {
+    if (tok.startsWith('-')) {
+      state.caps.delete(tok.slice(1));
+    } else {
+      state.caps.add(tok);
+    }
+  }
+
+  return {
+    state,
+    effects: [
+      Effect.send(ctx.connId, [L(`:${ctx.serverName} CAP ${target} ACK :${requested.join(' ')}`)]),
+    ],
+  };
+}
+
+/**
+ * `CAP END` — client signals end of capability negotiation.
+ *
+ * Clears `capNegotiating` and attempts to finalize registration. If
+ * `NICK` and `USER` have already been received, the welcome block is
+ * emitted here; otherwise the connection stays pre-registered until the
+ * basic handshake catches up.
+ */
+function handleEnd(state: ConnectionState, ctx: Ctx): ReducerResult<ConnectionState> {
+  state.capNegotiating = false;
+  const welcome = emitWelcomeIfReady(state, ctx);
+  return { state, effects: welcome !== null ? [welcome] : [] };
+}
+
+/**
+ * Builds the `410 ERR_INVALIDCAPCMD` reply. `rawSub` is echoed verbatim
+ * (may be undefined when the client sent a bare `CAP`).
+ */
+function invalidCapCmd(ctx: Ctx, rawSub: string | undefined): RawLine {
+  const nick = ctx.connection.nick ?? '*';
+  const codeStr = Numerics.ERR_INVALIDCAPCMD.toString().padStart(3, '0');
+  if (rawSub !== undefined && rawSub !== '') {
+    return { text: `:${ctx.serverName} ${codeStr} ${nick} ${rawSub} :Invalid CAP command` };
+  }
+  return { text: `:${ctx.serverName} ${codeStr} ${nick} :Invalid CAP command` };
+}
+
+/** Formats a numeric error line addressed to the connection's nick (or `*`). */
+function numericErr(ctx: Ctx, code: number, trailing: string, middle: string): RawLine {
+  const nick = ctx.connection.nick ?? '*';
+  const codeStr = code.toString().padStart(3, '0');
+  return { text: [`:${ctx.serverName}`, codeStr, nick, middle, `:${trailing}`].join(' ') };
+}
+
+/** Constructs a {@link RawLine} from raw text (terse alias for the hot path). */
+function L(text: string): RawLine {
+  return { text };
+}
+
+/**
+ * Returns the maximum content-byte length available for the cap list in a
+ * single `CAP ... <SUB> [*] :<caps>` line.
+ *
+ * Wire layout:
+ *   `:<server> CAP <target> <SUB> [*] :<caps>\r\n`
+ *
+ * We budget for the multiline form (`*` marker present) on every line so
+ * the final greedy-packing decision never has to be re-evaluated for the
+ * non-final vs final distinction.
+ */
+function maxCapsContentLen(ctx: Ctx, target: string): number {
+  // 1 (':') + server + ' CAP ' + target + ' XXX ' (subcommand + spaces) + '* ' + ':' + CRLF
+  // ` CAP ` = 5, ` LS ` / ` LIST ` = 4 (` LS `) up to 6 (` LIST `); use the larger.
+  const subOverhead = 6;
+  const multilineMarker = 2;
+  const overhead =
+    TRAILING_CRLF_LEN +
+    1 +
+    ctx.serverName.length +
+    5 +
+    target.length +
+    subOverhead +
+    multilineMarker +
+    1;
+  return Math.max(0, MAX_LINE_BYTES - overhead);
+}

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

@@ -0,0 +1,30 @@
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { ChanName } from '../state/channel.js';
+import type { ConnectionState } from '../state/connection.js';
+
+export interface ChgHostInput {
+  conn: ConnectionState;
+  oldUser: string;
+  oldHost: string;
+  newUser: string;
+  newHost: string;
+}
+
+export function emitChghost(input: ChgHostInput): EffectType[] {
+  const { conn, oldUser, oldHost, newUser, newHost } = input;
+
+  if (conn.registration !== 'registered') return [];
+  if (oldUser === newUser && oldHost === newHost) return [];
+
+  const nick = conn.nick ?? '?';
+  const line: RawLine = {
+    text: `:${nick}!${oldUser}@${oldHost} CHGHOST ${newUser} :${newHost}`,
+  };
+
+  const effects: EffectType[] = [];
+  for (const chan of conn.joinedChannels) {
+    effects.push(Effect.broadcast(chan as ChanName, [], undefined, 'chghost', [line]));
+  }
+  return effects;
+}

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

@@ -0,0 +1,40 @@
+/**
+ * Command reducers (pure). One file per command family.
+ *
+ * Each reducer follows the signature
+ *   `(state, msg, ctx) => { state, effects }`
+ * from {@link Reducer}. Side effects are values, not performed here.
+ */
+export { pingReducer, pongReducer } from './ping.js';
+export {
+  buildWelcomeLines,
+  emitWelcomeIfReady,
+  isValidNick,
+  nickReducer,
+  passReducer,
+  userReducer,
+} from './registration.js';
+export { quitReducer } from './quit.js';
+export { handleJoinZero, isValidChannelName, joinReducer } from './join.js';
+export { partReducer } from './part.js';
+export { motdReducer } from './motd.js';
+export {
+  isChannelTarget,
+  noticeChannelReducer,
+  noticeUserReducer,
+  privmsgChannelReducer,
+  privmsgUserReducer,
+} from './privmsg.js';
+export { kickReducer } from './kick.js';
+export { topicReducer } from './topic.js';
+export { namesReducer } from './names.js';
+export { listReducer } from './list.js';
+export { channelModeReducer, userModeReducer } from './mode.js';
+export { inviteReducer } from './invite.js';
+export { whoReducer } from './who.js';
+export { whoisReducer } from './whois.js';
+export { generateIsupport } from './isupport.js';
+export { capReducer } from './cap.js';
+export { emitChghost } from './chghost.js';
+export type { ChgHostInput } from './chghost.js';
+export { awayReducer } from './away.js';

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

@@ -0,0 +1,156 @@
+/**
+ * Pure reducer for the IRC `INVITE` command.
+ *
+ * PLAN §2.1 location-of-authority: INVITE runs in the Channel entity. The
+ * reducer's `state` argument is the channel's authoritative state; the
+ * inviter's identity is read from `ctx.connection`. The pending-invite
+ * record (which lets the invitee bypass `+i` on a later JOIN) lives on
+ * the channel via {@link ChannelState.pendingInvites}.
+ *
+ * The actual routing of the INVITE notice to the invitee's connection is
+ * expressed as a `SendToNick` effect — the runtime resolves the nick.
+ *
+ * Wire format (RFC 2812 §3.2.7):
+ *   - `:<server> 341 <inviter> <chan> <invitee>`  — RPL_INVITING
+ *   - `:<inviter-hostmask> INVITE <invitee> <chan>` — sent to the invitee
+ *   - `443 ERR_USERONCHANNEL <inviter> <invitee> <chan> :is already on channel`
+ *
+ * +i (invite-only) requires the inviter to be a channel operator; non-+i
+ * channels allow any member to invite. The invitee's nick is resolved
+ * case-insensitively against the roster (443 if already a member).
+ */
+
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import { Numerics } from '../protocol/numerics.js';
+import type { ChannelState } from '../state/channel.js';
+import { hostmaskOf } from '../state/connection.js';
+import type { ConnectionState } from '../state/connection.js';
+import type { Ctx, Reducer } from '../types.js';
+
+const CHANNEL_NAME_RE = /^[#&][^\s,:]+$/u;
+
+function isValidChannelName(name: string, maxLen: number): boolean {
+  if (name.length === 0 || name.length > maxLen) return false;
+  return CHANNEL_NAME_RE.test(name);
+}
+
+/** Returns the caller's hostmask, falling back to nick then `?`. */
+function callerHostmask(conn: ConnectionState): string {
+  return hostmaskOf(conn) ?? conn.nick ?? '?';
+}
+
+/** Formats a numeric error/reply line addressed to the connection's nick. */
+function numericErr(ctx: Ctx, code: number, trailing: string, middle?: string): RawLine {
+  const nick = ctx.connection.nick ?? '*';
+  const codeStr = code.toString().padStart(3, '0');
+  const parts = [`:${ctx.serverName}`, codeStr, nick];
+  if (middle !== undefined) parts.push(middle);
+  parts.push(`:${trailing}`);
+  return { text: parts.join(' ') };
+}
+
+function lowerNick(nick: string): string {
+  return nick.toLowerCase();
+}
+
+/** Finds a roster entry's connId by nick (case-insensitive). */
+function findConnIdByNick(state: ChannelState, nick: string): string | null {
+  const target = lowerNick(nick);
+  for (const entry of state.members.values()) {
+    if (lowerNick(entry.nick) === target) return entry.conn;
+  }
+  return null;
+}
+
+/**
+ * Handles `INVITE <nick> <chan>`.
+ *
+ * Validation order: missing-params → invalid-name → not-on-channel →
+ * +i-requires-op → invitee-already-on-channel → success.
+ */
+export const inviteReducer: Reducer<ChannelState> = (state, msg, ctx) => {
+  ctx.connection.lastSeen = ctx.clock.now();
+
+  const effects: EffectType[] = [];
+
+  const targetNick = msg.params[0];
+  const rawName = msg.params[1];
+
+  if (targetNick === undefined || rawName === undefined) {
+    effects.push(
+      Effect.send(ctx.connId, [
+        numericErr(ctx, Numerics.ERR_NEEDMOREPARAMS, 'Not enough parameters', 'INVITE'),
+      ]),
+    );
+    return { state, effects };
+  }
+
+  if (!isValidChannelName(rawName, ctx.serverConfig.channelLen)) {
+    effects.push(
+      Effect.send(ctx.connId, [
+        numericErr(ctx, Numerics.ERR_NOSUCHCHANNEL, 'No such channel', rawName),
+      ]),
+    );
+    return { state, effects };
+  }
+
+  // Inviter must be on the channel.
+  const callerEntry = state.members.get(ctx.connId);
+  if (callerEntry === undefined) {
+    effects.push(
+      Effect.send(ctx.connId, [
+        numericErr(ctx, Numerics.ERR_NOTONCHANNEL, "You're not on that channel", state.name),
+      ]),
+    );
+    return { state, effects };
+  }
+
+  // +i (invite-only) requires op to invite.
+  if (state.modes.inviteOnly && !callerEntry.op) {
+    effects.push(
+      Effect.send(ctx.connId, [
+        numericErr(ctx, Numerics.ERR_CHANOPRIVSNEEDED, "You're not channel operator", state.name),
+      ]),
+    );
+    return { state, effects };
+  }
+
+  // Invitee already on the channel?
+  const targetConnId = findConnIdByNick(state, targetNick);
+  if (targetConnId !== null) {
+    effects.push(
+      Effect.send(ctx.connId, [
+        numericErr(
+          ctx,
+          Numerics.ERR_USERONCHANNEL,
+          'is already on channel',
+          `${targetNick} ${state.name}`,
+        ),
+      ]),
+    );
+    return { state, effects };
+  }
+
+  // Success: record the pending invite (by lowercased nick) so a later
+  // JOIN bypasses +i, emit 341, and route the INVITE notice to the invitee.
+  state.pendingInvites.add(targetNick.toLowerCase());
+
+  const inviterNick = ctx.connection.nick ?? '*';
+  effects.push(
+    Effect.send(ctx.connId, [
+      { text: `:${ctx.serverName} 341 ${inviterNick} ${state.name} ${targetNick}` },
+    ]),
+  );
+
+  const hostmask = callerHostmask(ctx.connection);
+  const inviteLine: RawLine = { text: `:${hostmask} INVITE ${targetNick} ${state.name}` };
+  effects.push(Effect.sendToNick(targetNick, ctx.connId, [inviteLine]));
+
+  // IRCv3 invite-notify: channel members with the `invite-notify` cap
+  // receive a copy of the INVITE. Cap-only broadcast so legacy members see
+  // nothing; the invitee is reached via SendToNick above (exactly once).
+  effects.push(Effect.broadcast(state.name, [inviteLine], undefined, 'invite-notify'));
+
+  return { state, effects };
+};

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

@@ -0,0 +1,133 @@
+/**
+ * Pure generator for the IRC `005 RPL_ISUPPORT` reply.
+ *
+ * PLAN §3 / RFC 2812 §3.1.1 / <https://modern.ircdocs.horse/#rplisupport-005>:
+ *
+ *   `<prefix> 005 <nick> <token>{ <token>} :are supported by this server`
+ *
+ * The full token set rarely fits in a single 510-byte wire line, so daemons
+ * split it across multiple `005` lines; only the final line carries the
+ * trailing `:are supported by this server` parameter. This module computes
+ * the token list from `serverConfig`, then packs tokens into batches that
+ * keep every emitted line within the 510-byte ceiling.
+ *
+ * Tokens are derived from config, not hard-coded, so adapters can tune limits
+ * per-deployment (PLAN §10 capacity planning).
+ */
+
+import type { RawLine } from '../effects.js';
+import type { ServerConfig } from '../types.js';
+
+/** Max bytes per IRC wire line, including trailing `\r\n`. */
+const LINE_MAX_BYTES = 510;
+
+/** Canonical channel mode classes, in CHANMODES order. */
+const CHANMODES = {
+  /** Class A — list modes (always take a parameter when set/unset). */
+  list: 'b',
+  /** Class B — parameter modes (param when set, no param when unset). */
+  paramSet: 'k',
+  /** Class C — parameter modes (param when set AND unset). */
+  paramAlways: 'l',
+  /** Class D — boolean modes (no parameter). */
+  boolean: 'imnpst',
+} as const;
+
+/** Channel-user prefix sigils, in PREFIX order (highest rank first). */
+const PREFIX = '(ov)@+';
+
+/** Channel name sigils this server recognises. */
+const CHANTYPES = '#';
+
+/** Case-mapping algorithm — v1 uses RFC 1459 (matches `lower.ts`). */
+const CASEMAPPING = 'rfc1459';
+
+/** Default max mode changes per single MODE command (PLAN §3). */
+const MODES_PER_COMMAND = 4;
+
+/** Trailing parameter appended to the final 005 line. */
+const TRAILER = 'are supported by this server';
+
+/**
+ * Builds the token list for one client based on its capabilities and the
+ * server's configuration.
+ *
+ * Order matters: RFC-style daemons emit tokens in a stable order so clients
+ * can diff between servers. Tokens are space-separated, never empty.
+ */
+function buildTokens(cfg: ServerConfig): string[] {
+  return [
+    `CHANTYPES=${CHANTYPES}`,
+    `CHANMODES=${CHANMODES.list},${CHANMODES.paramSet},${CHANMODES.paramAlways},${CHANMODES.boolean}`,
+    `PREFIX=${PREFIX}`,
+    `MODES=${MODES_PER_COMMAND}`,
+    `NICKLEN=${cfg.nickLen}`,
+    `CHANNELLEN=${cfg.channelLen}`,
+    `TOPICLEN=${cfg.topicLen}`,
+    `CASEMAPPING=${CASEMAPPING}`,
+    `NETWORK=${cfg.networkName}`,
+    `MAXCHANNELS=${cfg.maxChannelsPerUser}`,
+    `MAXTARGETS=${cfg.maxTargetsPerCommand}`,
+    // SAFELIST is a boolean ISUPPORT token advertising that LIST will not
+    // get the connection killed (the matching IRCv3 `safelist` cap is the
+    // per-connection opt-in). LIST is always non-destructive here so the
+    // token is unconditional.
+    'SAFELIST',
+  ];
+}
+
+/**
+ * Greedy packer: accumulates tokens into a single space-joined prefix until
+ * adding the next token would exceed the 510-byte ceiling, then starts a new
+ * batch. The caller appends the trailer separately.
+ *
+ * Each batch returns just the joined token string (no `005`, no trailer).
+ */
+function packTokens(tokens: ReadonlyArray<string>, baseLen: number): string[] {
+  const batches: string[] = [];
+  let current = '';
+  for (const tok of tokens) {
+    const candidate = current === '' ? tok : `${current} ${tok}`;
+    // +1 for the trailing space before the `:`-prefixed trailer.
+    if (baseLen + candidate.length + 1 > LINE_MAX_BYTES && current !== '') {
+      batches.push(current);
+      current = tok;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current !== '') batches.push(current);
+  return batches;
+}
+
+/**
+ * Generates the `005 RPL_ISUPPORT` reply for a connection.
+ *
+ * @param cfg          Server configuration (size limits, network name).
+ * @param _connCaps    IRCv3 capabilities negotiated by the connection
+ *                     (reserved for `BOT=` and similar v3 tokens; currently
+ *                     unused — kept in the signature per the ticket spec).
+ * @param nick         Optional nick for the reply target; defaults to `*`.
+ * @returns One or more {@link RawLine}s, each within the 510-byte ceiling.
+ *          Only the final line carries the `:are supported by this server`
+ *          trailer.
+ */
+export function generateIsupport(
+  cfg: ServerConfig,
+  _connCaps: ReadonlySet<string>,
+  nick = '*',
+): RawLine[] {
+  const tokens = buildTokens(cfg);
+  const prefix = `:${cfg.serverName} 005 ${nick} `;
+  const baseLen = prefix.length;
+
+  const batches = packTokens(tokens, baseLen);
+
+  const lines: RawLine[] = batches.map((batch, idx) => {
+    const isLast = idx === batches.length - 1;
+    const trailer = isLast ? ` :${TRAILER}` : '';
+    return { text: `${prefix}${batch}${trailer}` };
+  });
+
+  return lines;
+}