serverless-ircd 0.1.0 → 0.3.0

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

@@ -0,0 +1,305 @@
+/**
+ * Pure reducer for the IRCv3 `draft/chathistory` command.
+ *
+ * Spec: https://ircv3.net/specs/extensions/chathistory
+ *
+ * Surface 1 (explicit query): `CHATHISTORY <sub> <target> [<args>...]`. The
+ * reducer reads the backlog from the {@link MessageStore} injected via
+ * {@link Ctx} (mirroring `MotdProvider` / `AccountStore`) and emits the
+ * matching `PRIVMSG`/`NOTICE`/`TAGMSG` lines wrapped in a single
+ * `BATCH chathistory <target>` frame. Each replay line carries the original
+ * `@time=…` (server-time) and `msgid=…` tags so the client can de-dup and
+ * place it on the timeline.
+ *
+ * The cap `draft/chathistory` MUST be negotiated before any query is
+ * accepted; clients without the cap get `421 ERR_UNKNOWNCOMMAND` (the spec's
+ * permitted "unknown command" fallback).
+ *
+ * Location-of-authority: chathistory is read-only and runs against the
+ * requester's connection. The target channel is passed in (resolved by the
+ * actor layer); `undefined` means "no such channel" → `403`.
+ */
+
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { StoredMessage } from '../ports.js';
+import { wrapBatch } from '../protocol/batch.js';
+import type { IrcMessage } from '../protocol/messages.js';
+import { Numerics } from '../protocol/numerics.js';
+import { formatServerTime } from '../protocol/outbound.js';
+import type { ChannelState } from '../state/channel.js';
+import type { Ctx } from '../types.js';
+
+/** The cap name advertising chathistory support. */
+export const CHATHISTORY_CAP = 'draft/chathistory';
+
+/** Default query limit when the client omits one (spec recommends 50). */
+const DEFAULT_QUERY_LIMIT = 50;
+
+/** Sentinel the client uses to mean "most recent" / "now" / "beginning". */
+const WILDCARD = '*';
+
+/** Subcommands that operate on a single channel target. */
+type ChannelSubcommand = 'LATEST' | 'BEFORE' | 'AFTER' | 'AROUND' | 'BETWEEN';
+
+const CHANNEL_SUBCOMMANDS: ReadonlySet<string> = new Set<string>([
+  'LATEST',
+  'BEFORE',
+  'AFTER',
+  'AROUND',
+  'BETWEEN',
+]);
+
+/**
+ * Handles `CHATHISTORY <sub> <target> [<args>...]`.
+ *
+ * @param channel The authoritative ChannelState for `msg.params[1]`, or
+ *                `undefined` when no such channel exists (→ `403`).
+ */
+export function chathistoryReducer(
+  channel: ChannelState | undefined,
+  msg: IrcMessage,
+  ctx: Ctx,
+): { effects: EffectType[] } {
+  // Cap gate: clients that did not negotiate chathistory see RFC 2812 only.
+  if (!ctx.connection.caps.has(CHATHISTORY_CAP)) {
+    return {
+      effects: [
+        Effect.send(ctx.connId, [
+          numericErr(ctx, Numerics.ERR_UNKNOWNCOMMAND, 'Unknown command', 'CHATHISTORY'),
+        ]),
+      ],
+    };
+  }
+
+  const sub = (msg.params[0] ?? '').toUpperCase();
+  if (sub === '') {
+    return { effects: [Effect.send(ctx.connId, [needMoreParamsLine(ctx)])] };
+  }
+
+  if (sub === 'TARGETS') {
+    return handleTargets(msg, ctx);
+  }
+
+  if (!CHANNEL_SUBCOMMANDS.has(sub)) {
+    return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
+  }
+
+  return handleChannelSub(sub as ChannelSubcommand, channel, msg, ctx);
+}
+
+/** Handles the four channel-bound subcommands + BETWEEN. */
+function handleChannelSub(
+  sub: ChannelSubcommand,
+  channel: ChannelState | undefined,
+  msg: IrcMessage,
+  ctx: Ctx,
+): { effects: EffectType[] } {
+  const target = msg.params[1];
+  if (target === undefined) {
+    return { effects: [Effect.send(ctx.connId, [needMoreParamsLine(ctx)])] };
+  }
+
+  if (channel === undefined) {
+    return {
+      effects: [
+        Effect.send(ctx.connId, [
+          numericErr(ctx, Numerics.ERR_NOSUCHCHANNEL, 'No such channel', target),
+        ]),
+      ],
+    };
+  }
+
+  // +s/+p leak prevention: a non-member must not learn the channel has
+  // history. The spec says return an empty batch; we elide the batch entirely
+  // (empty batches are forbidden) so the requester observes nothing.
+  if ((channel.modes.secret || channel.modes.private) && !channel.members.has(ctx.connId)) {
+    return { effects: [] };
+  }
+
+  const chanLower = channel.nameLower;
+
+  if (sub === 'BETWEEN') {
+    const lo = msg.params[2];
+    const hi = msg.params[3];
+    if (lo === undefined || hi === undefined) {
+      return { effects: [Effect.send(ctx.connId, [needMoreParamsLine(ctx)])] };
+    }
+    if (!storeHas(ctx, chanLower, lo) || !storeHas(ctx, chanLower, hi)) {
+      return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
+    }
+    const result = storeQuery(ctx, {
+      chan: chanLower,
+      direction: 'between',
+      limit: DEFAULT_QUERY_LIMIT,
+      msgid: lo,
+      msgid2: hi,
+    });
+    return { effects: buildChathistoryBatch(ctx, channel.name, result) };
+  }
+
+  // LATEST / BEFORE / AFTER / AROUND
+  const pivot = msg.params[2];
+  const limitRaw = msg.params[3];
+  if (sub !== 'LATEST' && pivot === undefined) {
+    return { effects: [Effect.send(ctx.connId, [needMoreParamsLine(ctx)])] };
+  }
+  const limit = parseLimit(limitRaw);
+  if (limit === undefined) {
+    return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
+  }
+
+  if (sub === 'LATEST') {
+    const pivotArg = pivot === undefined || pivot === WILDCARD ? undefined : pivot;
+    if (pivotArg !== undefined && !storeHas(ctx, chanLower, pivotArg)) {
+      return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
+    }
+    const result = storeQuery(ctx, {
+      chan: chanLower,
+      direction: 'latest',
+      limit,
+      ...(pivotArg !== undefined ? { msgid: pivotArg } : {}),
+    });
+    return { effects: buildChathistoryBatch(ctx, channel.name, result) };
+  }
+
+  // BEFORE / AFTER / AROUND — pivot is required. The `sub !== 'LATEST' &&
+  // pivot === undefined` guard above already rejected the missing-pivot
+  // case and LATEST returned early just above; assert non-null for the
+  // type-checker without an unreachable branch.
+  const pivotMsgid = pivot as string;
+  if (!storeHas(ctx, chanLower, pivotMsgid)) {
+    return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
+  }
+  const result = storeQuery(ctx, {
+    chan: chanLower,
+    direction: sub.toLowerCase() as 'before' | 'after' | 'around',
+    limit,
+    msgid: pivotMsgid,
+  });
+  return { effects: buildChathistoryBatch(ctx, channel.name, result) };
+}
+
+/** Handles `CHATHISTORY TARGETS <since> <until>`. */
+function handleTargets(msg: IrcMessage, ctx: Ctx): { effects: EffectType[] } {
+  const sinceRaw = msg.params[1];
+  const untilRaw = msg.params[2];
+  if (sinceRaw === undefined || untilRaw === undefined) {
+    return { effects: [Effect.send(ctx.connId, [needMoreParamsLine(ctx)])] };
+  }
+  const since = parseTimestamp(sinceRaw, 0);
+  const until = parseTimestamp(untilRaw, ctx.clock.now());
+  if (since === undefined || until === undefined) {
+    return { effects: [Effect.send(ctx.connId, [invalidParamsLine(ctx)])] };
+  }
+
+  const entries = ctx.messages !== undefined ? ctx.messages.targets(since, until) : [];
+  if (entries.length === 0) {
+    return { effects: [] };
+  }
+
+  const body: RawLine[] = entries.map((e) => ({
+    text: `:${ctx.serverName} CHATHISTORY TARGETS ${formatServerTime(e.time)} ${e.chan}`,
+  }));
+  const frame = wrapBatch(body, ctx.ids.batchId(), 'chathistory');
+  return { effects: [Effect.send(ctx.connId, frame)] };
+}
+
+/**
+ * Wraps `messages` as replay lines in a `BATCH chathistory <chan>` frame
+ * addressed to the requester. Empty input elides the batch entirely (the
+ * spec forbids empty batches; the client interprets "no batch" as "no
+ * history").
+ *
+ * Shared by the explicit `CHATHISTORY` query and the JOIN auto-playback hook
+ * so both surfaces emit identical framing.
+ */
+export function buildChathistoryBatch(
+  ctx: Ctx,
+  displayChan: string,
+  messages: readonly StoredMessage[],
+): EffectType[] {
+  if (messages.length === 0) return [];
+  const body = messages.map((m) => formatReplayLine(m, displayChan));
+  const frame = wrapBatch(body, ctx.ids.batchId(), 'chathistory', displayChan);
+  return [Effect.send(ctx.connId, frame)];
+}
+
+/**
+ * Reconstructs the wire line for one stored message, decorated with the
+ * original server-time and msgid tags. PRIVMSG/NOTICE carry the trailing
+ * text; TAGMSG has no trailing parameter.
+ */
+export function formatReplayLine(m: StoredMessage, displayChan: string): RawLine {
+  const stamp = formatServerTime(m.time);
+  const prefix = storedHostmask(m);
+  const tag = `@time=${stamp};msgid=${m.msgid}`;
+  if (m.command === 'TAGMSG') {
+    return { text: `${tag} :${prefix} TAGMSG ${displayChan}` };
+  }
+  return { text: `${tag} :${prefix} ${m.command} ${displayChan} :${m.text}` };
+}
+
+/** Builds the `nick!user@host` source for a stored message. */
+function storedHostmask(m: StoredMessage): string {
+  if (m.user === undefined && m.host === undefined) return m.nick;
+  let out = m.nick;
+  if (m.user !== undefined) out = `${out}!${m.user}`;
+  if (m.host !== undefined) out = `${out}@${m.host}`;
+  return out;
+}
+
+/** 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(' ') };
+}
+
+/** `461 CHATHISTORY :Not enough parameters`. */
+function needMoreParamsLine(ctx: Ctx): RawLine {
+  return numericErr(ctx, Numerics.ERR_NEEDMOREPARAMS, 'Not enough parameters', 'CHATHISTORY');
+}
+
+/** `461 CHATHISTORY :Invalid parameters`. */
+function invalidParamsLine(ctx: Ctx): RawLine {
+  return numericErr(ctx, Numerics.ERR_NEEDMOREPARAMS, 'Invalid parameters', 'CHATHISTORY');
+}
+
+/** Parses a non-negative integer limit; returns undefined on garbage. */
+function parseLimit(raw: string | undefined): number | undefined {
+  if (raw === undefined) return DEFAULT_QUERY_LIMIT;
+  const n = Number(raw);
+  if (!Number.isInteger(n) || n < 0) return undefined;
+  return n;
+}
+
+/**
+ * Parses a CHATHISTORY timestamp bound. `*` resolves to `wildcardValue`
+ * (0 for `since`, `ctx.clock.now()` for `until`); an ISO-8601 string parses
+ * to epoch ms; anything else returns undefined (→ `461`).
+ */
+function parseTimestamp(raw: string, wildcardValue: number): number | undefined {
+  if (raw === WILDCARD) return wildcardValue;
+  const ms = Date.parse(raw);
+  return Number.isNaN(ms) ? undefined : ms;
+}
+
+/** store.hasMsgid that treats an unbound store as "the msgid is not known". */
+function storeHas(ctx: Ctx, chan: string, msgid: string): boolean {
+  return ctx.messages !== undefined ? ctx.messages.hasMsgid(chan, msgid) : false;
+}
+
+/** store.query that treats an unbound store as empty. */
+function storeQuery(
+  ctx: Ctx,
+  q: {
+    chan: string;
+    direction: 'latest' | 'before' | 'after' | 'around' | 'between';
+    limit: number;
+    msgid?: string;
+    msgid2?: string;
+  },
+): StoredMessage[] {
+  return ctx.messages !== undefined ? ctx.messages.query(q) : [];
+}

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,
@@ -38,3 +39,11 @@ export { capReducer } from './cap.js';
 export { emitChghost } from './chghost.js';
 export type { ChgHostInput } from './chghost.js';
 export { awayReducer } from './away.js';
+export { authenticateReducer } from './sasl.js';
+export {
+  chathistoryReducer,
+  formatReplayLine,
+  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,14 +15,17 @@
  * 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';
 import { wrapBatch } from '../protocol/batch.js';
 import { Numerics } from '../protocol/numerics.js';
 import { type ChanName, type ChannelState, prefixOf } from '../state/channel.js';
 import { hostmaskOf } from '../state/connection.js';
 import type { ConnectionState } from '../state/connection.js';
 import type { Ctx, Reducer } from '../types.js';
+import { CHATHISTORY_CAP, buildChathistoryBatch } from './chathistory.js';
 
 /**
  * RFC 1459/2812 channel-name grammar. The first character must be a channel
@@ -64,16 +67,13 @@ function buildNamesList(state: ChannelState): string {
 
 /**
  * Formats a single numeric error line addressed to the connection's current
- * nick (or `*` when unregistered). Optional `middle` is emitted before the
- * trailing `:`-prefixed text.
+ * nick (or `*` when unregistered). `middle` is emitted before the trailing
+ * `:`-prefixed text.
  */
-function numericErr(ctx: Ctx, code: number, trailing: string, middle?: string): RawLine {
+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(' ') };
+  return { text: [`:${ctx.serverName}`, codeStr, nick, middle, `:${trailing}`].join(' ') };
 }
 
 /**
@@ -107,6 +107,44 @@ function joinerHostmask(conn: ConnectionState): string {
   return hostmaskOf(conn) ?? conn.nick ?? '?';
 }
 
+/** Default backlog depth replayed on JOIN when ServerConfig omits a value. */
+const DEFAULT_CHATHISTORY_PLAYBACK_LIMIT = 50;
+
+/**
+ * Builds the IRCv3 `draft/chathistory` auto-playback BATCH for a cap-enabled
+ * joiner and computes the next "last read" marker.
+ *
+ * Returns `{ effects: [], marker: undefined }` when playback is disabled (cap
+ * not negotiated, no MessageStore bound, or no messages newer than the
+ * marker); otherwise a single `Send` carrying the BATCH frame and the msgid
+ * of the newest replayed message. The caller is responsible for prepending
+ * the effects before the JOIN broadcast and for advancing the per-connection
+ * marker so a PART/re-JOIN cycle with no new activity replays nothing.
+ */
+function buildChathistoryPlayback(
+  state: ChannelState,
+  ctx: Ctx,
+): { effects: EffectType[]; marker: string | undefined } {
+  if (!ctx.connection.caps.has(CHATHISTORY_CAP)) {
+    return { effects: [], marker: undefined };
+  }
+  if (ctx.messages === undefined) {
+    return { effects: [], marker: undefined };
+  }
+  const limit = ctx.serverConfig.chatHistoryPlaybackLimit ?? DEFAULT_CHATHISTORY_PLAYBACK_LIMIT;
+  const previousMarker = ctx.connection.lastReadMarkers?.get(state.nameLower);
+  const recent = ctx.messages.recent(state.nameLower, previousMarker, limit);
+  if (recent.length === 0) {
+    return { effects: [], marker: undefined };
+  }
+  // `recent` is non-empty here, so the last entry is defined; the assertion
+  // only satisfies the type-checker under `noUncheckedIndexedAccess` (no
+  // runtime branch, no `!` token).
+  const newest = recent[recent.length - 1] as StoredMessage;
+  const effects = buildChathistoryBatch(ctx, state.name, recent);
+  return { effects, marker: newest.msgid };
+}
+
 /**
  * Handles `JOIN <chan> [<key>]` for a single channel.
  *
@@ -176,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, [
@@ -221,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);
@@ -244,6 +282,21 @@ export const joinReducer: Reducer<ChannelState> = (state, msg, ctx) => {
     }),
   );
 
+  // IRCv3 draft/chathistory auto-playback: a cap-enabled joiner with a
+  // bound MessageStore receives the recent backlog as a BATCH *before*
+  // the JOIN broadcast, then the per-(connection, channel) "last read"
+  // marker advances to the newest replayed msgid. PART/re-JOIN cycles
+  // only replay messages newer than the marker, so a re-join with no
+  // new activity emits nothing.
+  const playback = buildChathistoryPlayback(state, ctx);
+  if (playback.marker !== undefined) {
+    if (ctx.connection.lastReadMarkers === undefined) {
+      ctx.connection.lastReadMarkers = new Map<string, string>();
+    }
+    ctx.connection.lastReadMarkers.set(state.nameLower, playback.marker);
+  }
+  effects.push(...playback.effects);
+
   const legacyJoin: RawLine = { text: `:${hostmask} JOIN ${state.name}` };
   const realname = ctx.connection.realname;
   if (realname !== undefined) {

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'),