serverless-ircd 0.4.0 → 0.6.0

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

@@ -7,6 +7,8 @@
  */
 
 import { caseFold } from './case-fold.js';
+import type { ChannelState } from './state/channel.js';
+import type { ConnId, ConnectionState } from './state/connection.js';
 
 /** Read-only wall clock, epoch milliseconds. */
 export interface Clock {
@@ -338,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;
@@ -348,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. */
@@ -568,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)
 // ============================================================================
@@ -670,6 +854,390 @@ 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)
+// ============================================================================
+
+/**
+ * Snapshot of network-wide counts returned by a {@link ServerStats} backend.
+ *
+ * The shape mirrors the fields the `LUSERS` and `STATS` reducers need to
+ * format their numerics:
+ *   - `users` / `invisible`: the split registered-user counts that drive
+ *     `251 RPL_LUSERCLIENT` ("There are X users and Y invisible on Z
+ *     servers"). `users` is the *visible* (non-`+i`) registered count;
+ *     `invisible` is the `+i` registered count. Total registered users
+ *     is `users + invisible`.
+ *   - `opers`: count of IRC operators; emitted as `252 RPL_LUSEROP` when
+ *     non-zero. An oper counts here regardless of `+i` (an `+o` oper who
+ *     is also `+i` still bumps `opers`, `invisible`, and `users` is
+ *     computed as visible = total-registered − invisible).
+ *   - `unknownConnections`: pre-registration connection count; emitted as
+ *     `253 RPL_LUSERUNKNOWN` when non-zero.
+ *   - `channels`: live channel count; emitted as `254 RPL_LUSERCHANNELS`
+ *     when non-zero.
+ *   - `servers`: server count seen by `251`/`255`. Always 1 for the
+ *     single-server serverless deployment; S2S aggregation is a PLAN
+ *     non-goal.
+ *   - `localConns` / `globalConns`: total connection counts (registered
+ *     + pre-registration) for the optional `265 RPL_LOCALUSERS` /
+ *     `266 RPL_GLOBALUSERS` numerics. Equal for a single-server network.
+ *   - `maxLocalConns` / `maxGlobalConns`: high-water marks accompanying
+ *     `265`/`266`. When the backend has no recorded max it reports the
+ *     current count (so the wire numeric never claims a max below live).
+ *   - `uptimeStartedAt`: epoch-ms the server (or stats backend) started
+ *     counting from. Drives the `STATS u` uptime line.
+ */
+export interface ServerStatsSnapshot {
+  users: number;
+  invisible: number;
+  opers: number;
+  unknownConnections: number;
+  channels: number;
+  servers: number;
+  localConns: number;
+  globalConns: number;
+  maxLocalConns: number;
+  maxGlobalConns: number;
+  uptimeStartedAt: number;
+}
+
+/**
+ * Port that aggregates network-wide statistics for `LUSERS` and `STATS`.
+ *
+ * Unlike the synchronous {@link MotdProvider} / {@link AccountStore} ports
+ * (which reducers consume directly via {@link Ctx}), this port is
+ * **asynchronous** (`Promise`-returning) because the aggregation crosses
+ * every connection and channel in the deployment — it cannot be pre-loaded
+ * into a synchronous view the way MOTD or a credential table can. The
+ * actor layer awaits {@link getStats} once per `LUSERS` / `STATS`
+ * invocation, then passes the resulting {@link ServerStatsSnapshot} to the
+ * pure reducers (`lusersReducer`, `statsReducer`). This mirrors the
+ * `listChannels` → `listReducer` pattern.
+ *
+ * Each adapter implements this against its authoritative store:
+ *   - in-memory runtime: derive from its `Map`s (reference impl
+ *     {@link InMemoryStats}).
+ *   - CF: aggregate via `listChannels` / connection-enumeration RPCs.
+ *   - AWS: `Scan` / `Count` queries against `Connections` / `ChannelMeta`.
+ */
+export interface ServerStats {
+  getStats(): Promise<ServerStatsSnapshot>;
+}
+
+/**
+ * Aggregates a snapshot from already-collected connection state and a
+ * channel count.
+ *
+ * Pure: backends that gather their data through async I/O (CF RPC fan-out,
+ * AWS DynamoDB `Scan`) call this once they have the raw inputs. The
+ * {@link InMemoryStats} reference backend delegates here so the
+ * classification logic (oper / invisible / unknown) lives in exactly one
+ * place and is unit-tested independently of any adapter's I/O.
+ *
+ * Counting rules (RFC 2812 §4.6.2 + modern practice):
+ *   - `users` is the **visible** registered count (total registered minus
+ *     `+i`); the first number in "There are X users and Y invisible".
+ *   - `invisible` is the `+i` registered count; the second number.
+ *   - An oper who is also `+i` increments `opers`, `invisible`, and
+ *     reduces `users` (because they are invisible) — matching charybdis.
+ *   - `localConns` is every tracked connection (registered + unknown).
+ */
+export function computeStatsSnapshot(
+  connections: Iterable<ConnectionState>,
+  channelCount: number,
+  uptimeStartedAt: number,
+  opts?: { maxLocalConns?: number; maxGlobalConns?: number; servers?: number },
+): ServerStatsSnapshot {
+  let registered = 0;
+  let invisible = 0;
+  let opers = 0;
+  let unknown = 0;
+  let total = 0;
+  for (const conn of connections) {
+    total++;
+    if (conn.registration !== 'registered') {
+      unknown++;
+      continue;
+    }
+    registered++;
+    if (conn.userModes.invisible) invisible++;
+    if (conn.userModes.oper) opers++;
+  }
+  return {
+    users: registered - invisible,
+    invisible,
+    opers,
+    unknownConnections: unknown,
+    channels: channelCount,
+    servers: opts?.servers ?? 1,
+    localConns: total,
+    globalConns: total,
+    // The wire numeric must never claim a max below the current live count;
+    // when the backend's recorded max is stale (or never seeded) the live
+    // count is the lower bound.
+    maxLocalConns: Math.max(opts?.maxLocalConns ?? 0, total),
+    maxGlobalConns: Math.max(opts?.maxGlobalConns ?? 0, total),
+    uptimeStartedAt,
+  };
+}
+
+/**
+ * Reference in-memory {@link ServerStats} backed by the live `Map`s the
+ * {@link InMemoryRuntime} (and tests) already maintain.
+ *
+ * The constructor takes *references* to the runtime's mutable maps; later
+ * mutations are visible on the next {@link getStats} call without
+ * re-binding. Used by the local CLI, by integration tests, and as the
+ * contract spec the CF / AWS backends mirror.
+ *
+ * `uptimeStartedAt` is supplied at construction (typically the runtime's
+ * boot time). `maxLocalConns` / `maxGlobalConns` are optional high-water
+ * marks; when omitted the live count is reported as the max so `265`/`266`
+ * never regress below the current connection total.
+ */
+export class InMemoryStats implements ServerStats {
+  private readonly connections: ReadonlyMap<ConnId, ConnectionState>;
+  private readonly channels: ReadonlyMap<string, ChannelState>;
+  private readonly uptimeStartedAt: number;
+  private readonly maxLocalConns: number | undefined;
+  private readonly maxGlobalConns: number | undefined;
+
+  constructor(opts: {
+    connections: ReadonlyMap<ConnId, ConnectionState>;
+    channels: ReadonlyMap<string, ChannelState>;
+    uptimeStartedAt: number;
+    clock?: Clock;
+    maxLocalConns?: number;
+    maxGlobalConns?: number;
+  }) {
+    this.connections = opts.connections;
+    this.channels = opts.channels;
+    this.uptimeStartedAt = opts.uptimeStartedAt;
+    this.maxLocalConns = opts.maxLocalConns;
+    this.maxGlobalConns = opts.maxGlobalConns;
+  }
+
+  async getStats(): Promise<ServerStatsSnapshot> {
+    return computeStatsSnapshot(
+      this.connections.values(),
+      this.channels.size,
+      this.uptimeStartedAt,
+      {
+        ...(this.maxLocalConns !== undefined ? { maxLocalConns: this.maxLocalConns } : {}),
+        ...(this.maxGlobalConns !== undefined ? { maxGlobalConns: this.maxGlobalConns } : {}),
+      },
+    );
+  }
+}
+
 // ============================================================================
 // Observability — structured logger
 // ============================================================================

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';