serverless-ircd 0.5.0 → 0.7.0

package/packages/irc-core/src/ports.ts

@@ -340,6 +340,13 @@ export type StoredCommand = 'PRIVMSG' | 'NOTICE' | 'TAGMSG';
  * is reconstructed by the reducer from the authoritative {@link ChannelState}
  * when building replay lines. `time` is epoch milliseconds from the injected
  * {@link Clock}; `msgid` is a fresh nonce from {@link IdFactory}.
+ *
+ * `clientTags` carries optional IRCv3 message-tags client-only entries
+ * (keys prefixed with `+`) that the recording reducer wants preserved on
+ * replay — e.g. `+draft/multiline` so a chathistory client can recognise
+ * that a stored PRIVMSG originated from a multi-line batch. Omitted (or
+ * empty) for normal PRIVMSG/NOTICE/TAGMSG. The chathistory replay weaves
+ * these into the `@time=…;msgid=…` tag section verbatim.
  */
 export interface StoredMessage {
   msgid: string;
@@ -350,6 +357,7 @@ export interface StoredMessage {
   user?: string;
   host?: string;
   text: string;
+  readonly clientTags?: readonly string[];
 }
 
 /** Subcommands of `CHATHISTORY` that select a slice of the backlog. */
@@ -570,6 +578,180 @@ function tail<T>(arr: readonly T[], n: number): T[] {
   return arr.slice(start);
 }
 
+// ============================================================================
+// Read-marker persistence (IRCv3 draft/read-marker)
+// ============================================================================
+
+/**
+ * One persisted last-read marker, keyed per `(account, channel)`.
+ *
+ * `channel` is the lowercased channel name (the storage key); `msgid` is the
+ * msgid of the most recent message the account has read in that channel.
+ * Returned by {@link ReadMarkerStore.forAccount} when seeding a fresh
+ * connection at identify time.
+ */
+export interface ReadMarkerEntry {
+  /** Canonical account name (as recorded by SASL). */
+  account: string;
+  /** Lowercased channel name (rfc1459-folded storage key). */
+  channel: string;
+  /** Msgid of the most recent read message in this channel. */
+  msgid: string;
+}
+
+/**
+ * Persistence port for IRCv3 `draft/read-marker`.
+ *
+ * The chathistory command keeps a per-`(connection, channel)`
+ * last-read marker in {@link ConnectionState.lastReadMarkers}; this port
+ * promotes that marker to a per-`(account, channel)` record so it survives
+ * reconnects and is shared across an account's connections.
+ *
+ * Mirrors the {@link MessageStore} / {@link AccountStore} pattern: the port
+ * is **synchronous** (reducers must stay pure and free of IO) and injected
+ * via {@link Ctx}. Adapters that need async storage (D1, DynamoDB) pre-load
+ * the relevant slice into a synchronously-readable store; the in-memory
+ * reference implementation ({@link InMemoryReadMarkerStore}) ships here.
+ *
+ * Account and channel keys are both case-folded (rfc1459) so lookups are
+ * case-insensitive, matching the rest of the server's comparison semantics.
+ */
+export interface ReadMarkerStore {
+  /**
+   * Returns the stored last-read msgid for `(account, channel)`, or
+   * `undefined` when no marker has been recorded.
+   */
+  get(account: string, channel: string): string | undefined;
+  /**
+   * Records (or replaces) the last-read msgid for `(account, channel)`.
+   * Callers MUST only move the marker forward (towards newer messages);
+   * the store itself does not order msgids, it stores the latest value set.
+   */
+  set(account: string, channel: string, msgid: string): void;
+  /**
+   * Enumerates every recorded marker for `account`. Used at identify time to
+   * seed a fresh connection's {@link ConnectionState.lastReadMarkers} so a
+   * reconnect restores the user's read position across all their channels.
+   */
+  forAccount(account: string): ReadonlyArray<ReadMarkerEntry>;
+}
+
+/**
+ * Reference in-memory {@link ReadMarkerStore} backed by a
+ * `foldedAccount → (foldedChannel → msgid)` nested map.
+ *
+ * Used by the local CLI, integration tests, and any deployment that has not
+ * bound a distributed backend. Cloud adapters replace this with a D1 /
+ * DynamoDB-backed implementation against the same surface.
+ *
+ * Both keys are folded via {@link caseFold} (`rfc1459`) so lookups are
+ * case-insensitive; the returned {@link ReadMarkerEntry.channel} carries the
+ * folded spelling and {@link ReadMarkerEntry.account} the canonical name
+ * passed to {@link ReadMarkerStore.forAccount}.
+ */
+export class InMemoryReadMarkerStore implements ReadMarkerStore {
+  private readonly byAccount = new Map<string, Map<string, string>>();
+
+  get(account: string, channel: string): string | undefined {
+    return this.byAccount.get(folded(account))?.get(folded(channel));
+  }
+
+  set(account: string, channel: string, msgid: string): void {
+    const acct = folded(account);
+    let chanMap = this.byAccount.get(acct);
+    if (chanMap === undefined) {
+      chanMap = new Map<string, string>();
+      this.byAccount.set(acct, chanMap);
+    }
+    chanMap.set(folded(channel), msgid);
+  }
+
+  forAccount(account: string): ReadonlyArray<ReadMarkerEntry> {
+    const chanMap = this.byAccount.get(folded(account));
+    if (chanMap === undefined) return [];
+    const out: ReadMarkerEntry[] = [];
+    for (const [channel, msgid] of chanMap) {
+      out.push({ account, channel, msgid });
+    }
+    return out;
+  }
+}
+
+/** rfc1459 case-fold used for both account and channel keys. */
+function folded(value: string): string {
+  return caseFold('rfc1459', value);
+}
+
+// ============================================================================
+// Away-status persistence (IRCv3 draft/pre-away)
+// ============================================================================
+
+/**
+ * Persistence port for IRCv3 `draft/pre-away`.
+ *
+ * The base `AWAY` reducer keeps the away reason in
+ * {@link ConnectionState.away} for the lifetime of a single connection; this
+ * port promotes that reason to a per-`account` record so it survives
+ * reconnects and is shared across an account's connections.
+ *
+ * Mirrors the {@link ReadMarkerStore} pattern: the port is
+ * **synchronous** (reducers must stay pure and free of IO) and injected
+ * via {@link Ctx}. Adapters that need async storage (D1, DynamoDB) pre-load
+ * the relevant slice into a synchronously-readable store; the in-memory
+ * reference implementation ({@link InMemoryAwayStore}) ships here.
+ *
+ * The account key is case-folded (rfc1459) so lookups are
+ * case-insensitive, matching the rest of the server's comparison
+ * semantics. The unified services `UserStore` should fold this store in
+ * when it lands.
+ */
+export interface AwayStore {
+  /**
+   * Returns the stored away reason for `account`, or `undefined` when no
+   * reason has been recorded.
+   */
+  get(account: string): string | undefined;
+  /**
+   * Records (or replaces) the away reason for `account`. An empty string
+   * is permitted at the store layer (callers avoid it via
+   * {@link clearAway}).
+   */
+  set(account: string, reason: string): void;
+  /**
+   * Removes the stored away reason for `account`. Used when the user
+   * unsets `AWAY` so the next reconnect does not auto-mark them away.
+   */
+  clear(account: string): void;
+}
+
+/**
+ * Reference in-memory {@link AwayStore} backed by a
+ * `foldedAccount → reason` map.
+ *
+ * Used by the local CLI, integration tests, and any deployment that has
+ * not bound a distributed backend. Cloud adapters replace this with a D1
+ * / DynamoDB-backed implementation against the same surface.
+ *
+ * The account key is folded via {@link caseFold} (`rfc1459`) so lookups
+ * are case-insensitive, matching the IRC nick-comparison semantics
+ * advertised via `005 RPL_ISUPPORT CASEMAPPING=rfc1459`.
+ */
+export class InMemoryAwayStore implements AwayStore {
+  private readonly byAccount = new Map<string, string>();
+
+  get(account: string): string | undefined {
+    return this.byAccount.get(folded(account));
+  }
+
+  set(account: string, reason: string): void {
+    this.byAccount.set(folded(account), reason);
+  }
+
+  clear(account: string): void {
+    this.byAccount.delete(folded(account));
+  }
+}
+
 // ============================================================================
 // Nick history (WHOWAS)
 // ============================================================================
@@ -672,6 +854,213 @@ export class InMemoryNickHistoryStore implements NickHistoryStore {
   }
 }
 
+// ============================================================================
+// MONITOR subscription registry (IRCv3 MONITOR)
+// ============================================================================
+
+/**
+ * One async push notification the {@link MonitorStore} requests from the
+ * actor layer. The actor turns each push into one or more `Send` effects
+ * addressed to the watcher's connection.
+ *
+ *   - `online` — the nick came online; the watcher should receive a
+ *     `730 RPL_MONONLINE` line naming `display`.
+ *   - `offline` — the nick went offline; the watcher should receive a
+ *     `731 RPL_MONOFFLINE` line naming `display`.
+ */
+export interface MonitorPush {
+  /** Watcher's connection id. */
+  connId: string;
+  /** Display spelling of the nick that changed state. */
+  display: string;
+  /** New state. */
+  status: 'online' | 'offline';
+}
+
+/**
+ * Subscription registry for the IRCv3 `MONITOR` command.
+ *
+ * The watchlist itself lives on {@link ConnectionState.monitorList} (so it
+ * persists across actor re-bindings); this port owns the **reverse index**
+ * (nick → set of watcher connIds) and the **online set** the actor consults
+ * when synchronously resolving `MONITOR +` / `MONITOR S`.
+ *
+ * Mirrors the {@link MessageStore} / {@link AccountStore} pattern: the port
+ * is **synchronous** (reducers must stay pure and free of IO). The actor
+ * layer drains pending pushes after each command via {@link drainPushes};
+ * adapters that need to fan notifications out across processes (CF
+ * ConnectionDO sharding, AWS WebSocket fanout) replace
+ * {@link InMemoryMonitorStore} with their own implementation against the
+ * same surface.
+ *
+ * Lifecycle:
+ *   - On `MONITOR +`, the actor calls {@link sync} with the before/after
+ *     watchlist snapshots; the store records each newly-added nick →
+ *     watcher mapping.
+ *   - On `MONITOR -` / `C`, {@link sync} drops the removed mappings.
+ *   - On `NICK` (reserve/change) the actor calls {@link onNickOnline} for
+ *     each newly-reserved nick; the store appends a {@link MonitorPush}
+ *     for every watcher of that nick.
+ *   - On `QUIT` (or any release) the actor calls {@link onNickOffline};
+ *     same flow with a `731` push.
+ *   - On connection teardown, the actor calls {@link unsubscribe} so the
+ *     reverse index does not leak.
+ */
+export interface MonitorStore {
+  /**
+   * Reconciles the reverse index for `connId` against a watchlist delta.
+   * `before` is the watchlist at the start of the command (folded nicks);
+   * `after` is the watchlist after the reducer ran. The store adds
+   * mappings for entries in `after` not in `before`, and removes mappings
+   * for entries in `before` not in `after`.
+   */
+  sync(connId: string, before: ReadonlySet<string>, after: ReadonlySet<string>): void;
+  /**
+   * Removes every subscription for `connId`. Safe to call when the
+   * connection had no subscriptions. Idempotent.
+   */
+  unsubscribe(connId: string): void;
+  /**
+   * Records `nick` as online and enqueues a `730 RPL_MONONLINE` push to
+   * every watcher currently subscribed to that nick. `display` is the
+   * registered spelling the wire line should carry.
+   *
+   * Idempotent: a no-op when `nick` was already online (the second call
+   * enqueues nothing — prevents double-pushes on a `ReserveNick` for an
+   * already-reserved nick the runtime allowed through as a same-conn
+   * re-reserve).
+   */
+  onNickOnline(display: string): void;
+  /**
+   * Records `nick` as offline and enqueues a `731 RPL_MONOFFLINE` push to
+   * every watcher currently subscribed to that nick. Idempotent in the
+   * same way {@link onNickOnline} is.
+   */
+  onNickOffline(display: string): void;
+  /**
+   * Returns every display spelling currently marked online, in insertion
+   * order. Used by the actor's synchronous `MONITOR +` / `MONITOR S`
+   * resolution so the reducer can emit `730`/`731` lines without an
+   * O(N) `lookupNick` per requested nick.
+   */
+  onlineNicks(): string[];
+  /**
+   * Drains the queue of pending {@link MonitorPush}es the store has
+   * enqueued since the last drain. The actor calls this once per
+   * dispatched batch (after `NICK`/`QUIT` reducers release/reserve
+   * nicks) and turns each push into a `Send` effect for the watcher.
+   */
+  drainPushes(): MonitorPush[];
+}
+
+/**
+ * Reference in-memory {@link MonitorStore} used by the local CLI, the
+ * integration tests, and any deployment that has not bound a distributed
+ * backend.
+ *
+ * Backed by three plain `Map`s:
+ *   - `watchers`     connId → set of folded watched nicks.
+ *   - `reverse`      folded nick → set of watcher connIds.
+ *   - `online`       folded nick → display spelling (insertion-ordered).
+ *
+ * Plus a `pending` array of {@link MonitorPush} entries drained by the
+ * actor after each dispatched batch.
+ */
+export class InMemoryMonitorStore implements MonitorStore {
+  private readonly watchers = new Map<string, Set<string>>();
+  private readonly reverse = new Map<string, Set<string>>();
+  private readonly online = new Map<string, string>();
+  private readonly pending: MonitorPush[] = [];
+
+  sync(connId: string, before: ReadonlySet<string>, after: ReadonlySet<string>): void {
+    // Compute the delta without mutating `before`/`after` (callers pass
+    // references to their own state).
+    const added: string[] = [];
+    const removed: string[] = [];
+    for (const n of after) if (!before.has(n)) added.push(n);
+    for (const n of before) if (!after.has(n)) removed.push(n);
+
+    if (added.length === 0 && removed.length === 0) return;
+
+    // Look up (or allocate) the watcher's per-connection set; cleared from
+    // `watchers` when it ends up empty so unsubscribed connections do not
+    // leak in the forward map.
+    let wSet = this.watchers.get(connId);
+    if (wSet === undefined) {
+      wSet = new Set<string>();
+      this.watchers.set(connId, wSet);
+    }
+
+    for (const folded of added) {
+      wSet.add(folded);
+      let watchers = this.reverse.get(folded);
+      if (watchers === undefined) {
+        watchers = new Set<string>();
+        this.reverse.set(folded, watchers);
+      }
+      watchers.add(connId);
+    }
+    for (const folded of removed) {
+      wSet.delete(folded);
+      // The forward (`watchers`) and reverse indexes are kept in lockstep
+      // by sync, so any folded nick present in `before` has a
+      // corresponding reverse entry. The non-null assertion encodes that
+      // invariant; the alternative `if (watchers === undefined) return`
+      // would introduce an unreachable branch that violates the project's
+      // 100% branch-coverage threshold.
+      // biome-ignore lint/style/noNonNullAssertion: invariant — see above.
+      const watchers = this.reverse.get(folded)!;
+      watchers.delete(connId);
+      if (watchers.size === 0) this.reverse.delete(folded);
+    }
+    if (wSet.size === 0) this.watchers.delete(connId);
+  }
+
+  unsubscribe(connId: string): void {
+    const wSet = this.watchers.get(connId);
+    if (wSet === undefined) return;
+    for (const folded of wSet) {
+      // Same invariant as in `sync`: the forward/reverse indexes are kept
+      // in lockstep, so every folded nick in `wSet` has a reverse entry.
+      // biome-ignore lint/style/noNonNullAssertion: invariant — see above.
+      const watchers = this.reverse.get(folded)!;
+      watchers.delete(connId);
+      if (watchers.size === 0) this.reverse.delete(folded);
+    }
+    this.watchers.delete(connId);
+  }
+
+  onNickOnline(display: string): void {
+    const folded = display.toLowerCase();
+    if (this.online.has(folded)) return;
+    this.online.set(folded, display);
+    const watchers = this.reverse.get(folded);
+    if (watchers === undefined) return;
+    for (const connId of watchers) {
+      this.pending.push({ connId, display, status: 'online' });
+    }
+  }
+
+  onNickOffline(display: string): void {
+    const folded = display.toLowerCase();
+    if (!this.online.has(folded)) return;
+    this.online.delete(folded);
+    const watchers = this.reverse.get(folded);
+    if (watchers === undefined) return;
+    for (const connId of watchers) {
+      this.pending.push({ connId, display, status: 'offline' });
+    }
+  }
+
+  onlineNicks(): string[] {
+    return Array.from(this.online.values());
+  }
+
+  drainPushes(): MonitorPush[] {
+    return this.pending.splice(0);
+  }
+}
+
 // ============================================================================
 // Network statistics (LUSERS / STATS)
 // ============================================================================

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

@@ -9,6 +9,14 @@ export {
   formatServerTime,
 } from './outbound.js';
 export { wrapBatch, type BatchFrame } from './batch.js';
+export {
+  LABELED_RESPONSE_CAP_NAME,
+  LABEL_TAG,
+  applyLabelToEffects,
+  type LabelApplyOptions,
+  extractLabel,
+  wrapLabeledResponse,
+} from './labeled-response.js';
 export { decodeBase64, encodeBase64 } from './base64.js';
 export {
   formatNumeric,
@@ -17,3 +25,9 @@ export {
   numericToName,
   Numerics,
 } from './numerics.js';
+export {
+  type ReplyKind,
+  type StandardReplyMapping,
+  numericToStandardReply,
+  toStandardReply,
+} from './standard-replies.js';

package/packages/irc-core/src/protocol/labeled-response.ts

@@ -0,0 +1,133 @@
+/**
+ * IRCv3 `labeled-response` — correlate a request with its replies.
+ *
+ * Spec: https://ircv3.net/specs/extensions/labeled-response
+ *
+ * A client tags an inbound message with the `+label=<id>` client tag; the
+ * server then wraps every reply caused by that message (addressed back to
+ * the requester) in a single `BATCH +id labeled-response … BATCH -id`
+ * frame. If the request produces no reply for the requester, the server
+ * emits an empty batch so the client can still correlate the label with a
+ * definitive "no replies" answer.
+ *
+ * Unlike the generic {@link wrapBatch} helper — which elides empty batches
+ * because the IRCv3 `batch` spec forbids them — {@link wrapLabeledResponse}
+ * ALWAYS emits the start/end markers. The empty-batch case is the whole
+ * point of labeled-response: it is the correlation signal when there is
+ * nothing else to send.
+ *
+ * This module is pure data transformation. The actor layer:
+ *   1. extracts the label from the parsed message tags,
+ *   2. plumbs it onto {@link Ctx.label} so every reducer's emitted effects
+ *      are uniformly attributable to the labeled request, and
+ *   3. runs {@link applyLabelToEffects} over the reducer's `Effect[]` to
+ *      gather every `Send`-to-self and wrap them (or emit an empty batch).
+ *
+ * Only `Send` effects addressed to the originating connection are wrapped.
+ * Broadcasts / `SendToNick` / `BroadcastWallops` reach OTHER connections
+ * and are left in place; the label correlation applies solely to the
+ * requester's own reply stream.
+ */
+
+import { Effect } from '../effects.js';
+import type { Effect as EffectType, RawLine } from '../effects.js';
+import type { ConnId } from '../state/connection.js';
+
+/** Wire name of the `labeled-response` capability. */
+export const LABELED_RESPONSE_CAP_NAME = 'labeled-response';
+
+/** Wire name of the `+label` client tag carried on the inbound message. */
+export const LABEL_TAG = '+label';
+
+/** Batch type token used for every labeled-response frame. */
+const LABELED_RESPONSE_BATCH_TYPE = 'labeled-response';
+
+/**
+ * Reads the `+label` client tag from a parsed message's tag map.
+ *
+ * Returns `undefined` when the tag is absent OR present-but-empty, so callers
+ * can treat a missing label and a bare `+label` (no value) identically: both
+ * mean "this request is unlabeled".
+ */
+export function extractLabel(tags: Readonly<Record<string, string>>): string | undefined {
+  const value = tags[LABEL_TAG];
+  if (value === undefined || value.length === 0) return undefined;
+  return value;
+}
+
+/**
+ * Wraps `lines` in IRCv3 `BATCH +label labeled-response … BATCH -label`
+ * framing. ALWAYS emits the start and end markers — even when `lines` is
+ * empty — because the labeled-response spec requires an empty batch when a
+ * labeled request produces no reply (it is the correlation signal).
+ */
+export function wrapLabeledResponse(label: string, lines: readonly RawLine[]): RawLine[] {
+  const start: RawLine = { text: `BATCH +${label} ${LABELED_RESPONSE_BATCH_TYPE}` };
+  const end: RawLine = { text: `BATCH -${label}` };
+  return [start, ...lines, end];
+}
+
+/**
+ * Options for {@link applyLabelToEffects}.
+ *
+ * `label` is `string | undefined` (NOT an optional field) so the helper can
+ * be a clean no-op under `exactOptionalPropertyTypes` when the inbound
+ * request carried no label.
+ */
+export interface LabelApplyOptions {
+  /** The label extracted from the inbound `+label` tag, or `undefined`. */
+  readonly label: string | undefined;
+  /** The originating connection id (replies wrapped are addressed here). */
+  readonly connId: ConnId;
+}
+
+/**
+ * Gathers every `Send` effect addressed to `connId` and replaces them with a
+ * single `Send` whose lines are wrapped in one `labeled-response` batch.
+ *
+ * Behaviour:
+ *   - When `label` is `undefined` the effect list is returned unchanged
+ *     (copy) — the request was not labeled.
+ *   - All `Send`-to-`connId` effects, wherever they appear, are accumulated
+ *     in original order into one batch.
+ *   - The wrapped batch is placed at the position of the FIRST collected
+ *     `Send`-to-self, so the reducer's intended ordering relative to other
+ *     effects (broadcasts, etc.) is preserved.
+ *   - When NO `Send`-to-self exists, an empty labeled batch is appended at
+ *     the end — the requester still observes the label correlation.
+ *   - Every other effect (Broadcast, SendToNick, Disconnect, …) is left in
+ *     place and in order; only the requester's own reply stream is wrapped.
+ */
+export function applyLabelToEffects(
+  effects: readonly EffectType[],
+  opts: LabelApplyOptions,
+): EffectType[] {
+  const { label, connId } = opts;
+  if (label === undefined) return [...effects];
+
+  const selfLines: RawLine[] = [];
+  let firstSelfIdx = -1;
+  for (const [i, effect] of effects.entries()) {
+    if (effect.tag === 'Send' && effect.to === connId) {
+      if (firstSelfIdx === -1) firstSelfIdx = i;
+      selfLines.push(...effect.lines);
+    }
+  }
+
+  const batchEffect: EffectType = Effect.send(connId, wrapLabeledResponse(label, selfLines));
+
+  // No self-send to anchor on: append the empty labeled batch at the end.
+  if (firstSelfIdx === -1) {
+    return [...effects, batchEffect];
+  }
+
+  const out: EffectType[] = [];
+  for (const [i, effect] of effects.entries()) {
+    // Emit the single wrapped batch where the first self-send lived.
+    if (i === firstSelfIdx) out.push(batchEffect);
+    // Drop every original self-send (they are now inside the batch).
+    if (effect.tag === 'Send' && effect.to === connId) continue;
+    out.push(effect);
+  }
+  return out;
+}

package/packages/irc-core/src/protocol/numerics.ts

@@ -53,6 +53,15 @@ export const Numerics = {
   RPL_UNAWAY: 305,
   RPL_NOWAWAY: 306,
 
+  // IRCv3 MONITOR (modern ISON replacement). The watchlist lives on
+  // {@link ConnectionState.monitorList}; transitions push 730/731
+  // asynchronously via the actor's nick-registry hooks.
+  RPL_MONONLINE: 730,
+  RPL_MONOFFLINE: 731,
+  RPL_MONLIST: 732,
+  RPL_ENDOFMONLIST: 733,
+  ERR_MONLISTFULL: 734,
+
   // Version
   RPL_VERSION: 351,
 
@@ -64,6 +73,12 @@ export const Numerics = {
   RPL_ENDOFWHOIS: 318,
   RPL_WHOISCHANNELS: 319,
   RPL_WHOISACCOUNT: 330,
+  /**
+   * `276 RPL_WHOISSECURE` — target is connected over TLS (user mode `S`).
+   * Surfaced between the oper/account lines and the idle line so clients
+   * render it as part of the secure-connection WHOIS block.
+   */
+  RPL_WHOISSECURE: 276,
   RPL_WHOWASUSER: 314,
 
   // LIST

package/packages/irc-core/src/protocol/outbound.ts

@@ -126,6 +126,14 @@ export function enforceLineLimit(
  * Server-defined tags (no `+` prefix) are left in place — each is gated by
  * its own capability (server-time, account-tag, …) applied elsewhere.
  *
+ * Spec exception: IRCv3 `draft/typing` carves out a whitelist for the
+ * `+draft/typing` client tag. A recipient that announced `draft/typing`
+ * (but NOT `message-tags`) still receives `+draft/typing` so typing
+ * indicators work without the broader message-tags cap. `draft/read-marker`
+ * carves out the same exception for its `+draft/read-marker` tag so a
+ * read-marker update reaches the user's other connections. Every other
+ * client tag remains stripped for such recipients.
+ *
  * When filtering removes every tag, the leading `@... ` section is dropped
  * entirely so legacy clients never observe a bare tag prefix.
  *
@@ -142,10 +150,17 @@ export function filterClientTags(line: RawLine, caps: ReadonlySet<string>): RawL
   const rest = line.text.slice(spaceIdx + 1);
   const entries = tagSection.split(';');
 
+  const typingWhitelisted = caps.has('draft/typing');
+  const readMarkerWhitelisted = caps.has('draft/read-marker');
   const hasClientTag = entries.some((entry) => clientTagKey(entry).startsWith('+'));
   if (!hasClientTag) return line;
 
-  const kept = entries.filter((entry) => !clientTagKey(entry).startsWith('+'));
+  const kept = entries.filter((entry) => {
+    const key = clientTagKey(entry);
+    if (!key.startsWith('+')) return true;
+    if (typingWhitelisted && key === '+draft/typing') return true;
+    return readMarkerWhitelisted && key === '+draft/read-marker';
+  });
   if (kept.length === 0) return { text: rest };
   return { text: `@${kept.join(';')} ${rest}` };
 }