serverless-ircd 0.2.0 → 0.4.0

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

@@ -14,8 +14,12 @@
  *   - nick registry: {@link ReserveNickEffect}, {@link ChangeNickEffect},
  *     {@link ReleaseNickEffect}
  *   - channel ownership: {@link ApplyChannelDeltaEffect}
- *   - lookups: {@link LookupNickEffect}, {@link GetConnectionInfoEffect},
- *     {@link GetChannelSnapshotEffect}
+ *
+ *   Lookup-shaped runtime methods (`lookupNick`, `getConnectionInfo`,
+ *   `getChannelSnapshot`) are consumed directly inside `dispatch`'s
+ *   broadcast helper and the actor — they are request/response and cannot
+ *   be modelled as pure fire-and-forget effects, so no Effect variants
+ *   wrap them.
  */
 
 import type { ChanName, ChannelDelta } from './state/channel.js';
@@ -71,21 +75,6 @@ export interface ApplyChannelDeltaEffect {
   delta: ChannelDelta;
 }
 
-export interface LookupNickEffect {
-  tag: 'LookupNick';
-  nick: Nick;
-}
-
-export interface GetConnectionInfoEffect {
-  tag: 'GetConnectionInfo';
-  conn: ConnId;
-}
-
-export interface GetChannelSnapshotEffect {
-  tag: 'GetChannelSnapshot';
-  chan: ChanName;
-}
-
 /**
  * Routes `lines` to whichever connection currently owns `nick`. If the nick
  * is offline, `notFoundLines` (when supplied) is sent back to `sender` —
@@ -109,9 +98,6 @@ export type Effect =
   | ChangeNickEffect
   | ReleaseNickEffect
   | ApplyChannelDeltaEffect
-  | LookupNickEffect
-  | GetConnectionInfoEffect
-  | GetChannelSnapshotEffect
   | SendToNickEffect;
 
 /** Literal string tag of every {@link Effect} variant. */
@@ -167,15 +153,6 @@ export const Effect = {
   applyChannelDelta(chan: ChanName, delta: ChannelDelta): Effect {
     return { tag: 'ApplyChannelDelta', chan, delta };
   },
-  lookupNick(nick: Nick): Effect {
-    return { tag: 'LookupNick', nick };
-  },
-  getConnectionInfo(conn: ConnId): Effect {
-    return { tag: 'GetConnectionInfo', conn };
-  },
-  getChannelSnapshot(chan: ChanName): Effect {
-    return { tag: 'GetChannelSnapshot', chan };
-  },
   sendToNick(nick: Nick, sender: ConnId, lines: RawLine[], notFoundLines?: RawLine[]): Effect {
     const e: SendToNickEffect = { tag: 'SendToNick', nick, sender, lines };
     if (notFoundLines !== undefined) e.notFoundLines = notFoundLines;

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

@@ -10,14 +10,17 @@ export * from './caps/index.js';
 export * from './commands/index.js';
 export * from './effects.js';
 export * from './ports.js';
+export * from './credential-hashing.js';
 export * from './flood-control.js';
 export * from './cloak.js';
+export * from './case-fold.js';
 export * from './admission.js';
 export * from './config.js';
 export type {
   BuildCtxOptions,
   CloakingConfig,
   Ctx,
+  OperCred,
   Reducer,
   ReducerResult,
   ServerConfig,

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

@@ -6,6 +6,8 @@
  * can pin the timeline and identity space (PLAN §8 determinism rules).
  */
 
+import { caseFold } from './case-fold.js';
+
 /** Read-only wall clock, epoch milliseconds. */
 export interface Clock {
   now(): number;
@@ -55,7 +57,7 @@ export interface IdFactory {
 
 /**
  * Production id factory. Generates UUIDv4-shaped strings without relying
- * on `crypto` so the same code runs on Node 20, Cloudflare Workers, and
+ * on `crypto` so the same code runs on Node 24, Cloudflare Workers, and
  * Lambda without per-platform type wrangling. Uniqueness is statistical;
  * for cryptographic IDs, adapters can supply their own {@link IdFactory}.
  */
@@ -169,7 +171,8 @@ export const EmptyMotdProvider: MotdProvider = new StaticMotdProvider([]);
  */
 export type SaslPayload =
   | { kind: 'PLAIN'; username: string; password: string }
-  | { kind: 'RAW'; data: string };
+  | { kind: 'RAW'; data: string }
+  | { kind: 'EXTERNAL'; identity: string };
 
 /**
  * Outcome of an {@link AccountStore.verify} call: either the canonical
@@ -192,6 +195,134 @@ export interface AccountStore {
   verify(mech: string, payload: SaslPayload): SaslResult;
 }
 
+/**
+ * One SASL PLAIN credential entry seeded into an {@link InMemoryAccountStore}.
+ * The `username` is also the canonical account name recorded on the
+ * connection for `extended-join` / `account-tag`.
+ */
+export interface SaslAccountCredential {
+  username: string;
+  password: string;
+  /**
+   * Optional mTLS client-certificate subject (e.g. `CN=alice` or a
+   * fingerprint hash). When set, SASL `EXTERNAL` authentications that
+   * present this subject are mapped to {@link username} as the account.
+   */
+  certSubject?: string;
+}
+
+/**
+ * Reference in-memory {@link AccountStore} backed by a static list of PLAIN
+ * credentials seeded at construction.
+ *
+ * Mirrors the {@link InMemoryMessageStore} / {@link StaticMotdProvider}
+ * pattern: the port is synchronous, so adapters that need an async backend
+ * (D1, DynamoDB, Secrets Manager) pre-load their credentials into this store
+ * at boot. All three adapters (local-cli, CF, AWS) use this as the minimum
+ * viable `AccountStore`; a persistent variant (DynamoDB `Accounts` table, D1)
+ * is a documented follow-up that swaps in by replacing the construction call.
+ *
+ * Password comparison is constant-time to avoid the early-return timing
+ * oracle a naive `===` would expose. Only `PLAIN` is verified; any other
+ * mechanism returns failure (matching the reducer's mech gating).
+ */
+export class InMemoryAccountStore implements AccountStore {
+  private readonly creds: ReadonlyMap<string, string>;
+  private readonly certMap: ReadonlyMap<string, string>;
+
+  constructor(credentials: ReadonlyArray<SaslAccountCredential>) {
+    this.creds = new Map(credentials.map((c) => [c.username, c.password]));
+    this.certMap = new Map(
+      credentials
+        .filter((c) => c.certSubject !== undefined)
+        .map((c) => [c.certSubject as string, c.username]),
+    );
+  }
+
+  verify(mech: string, payload: SaslPayload): SaslResult {
+    const m = mech.toUpperCase();
+    if (m === 'PLAIN' && payload.kind === 'PLAIN') {
+      const expected = this.creds.get(payload.username);
+      if (expected === undefined) {
+        return { ok: false, reason: 'invalid credentials' };
+      }
+      if (!constantTimeEquals(payload.password, expected)) {
+        return { ok: false, reason: 'invalid credentials' };
+      }
+      return { ok: true, account: payload.username };
+    }
+    if (m === 'EXTERNAL' && payload.kind === 'EXTERNAL') {
+      const account = this.certMap.get(payload.identity);
+      if (account === undefined) {
+        return { ok: false, reason: 'untrusted certificate' };
+      }
+      return { ok: true, account };
+    }
+    return { ok: false, reason: `unsupported mechanism: ${mech}` };
+  }
+}
+
+/**
+ * Constant-time string equality. Compares every byte regardless of early
+ * mismatches so a remote attacker cannot short-circuit the comparison via a
+ * timing side-channel. Returns `false` when the lengths differ (the length
+ * is not considered secret for SASL PLAIN passwords).
+ */
+function constantTimeEquals(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+// ============================================================================
+// mTLS identity (SASL EXTERNAL)
+// ============================================================================
+
+/**
+ * Port that resolves the verified client-certificate identity for a
+ * connection.
+ *
+ * At the edge (CF API Shield mTLS, AWS API Gateway custom-domain mTLS) the
+ * platform terminates TLS, validates the client certificate against the
+ * configured trust store, and surfaces the certificate subject to the
+ * Worker/Lambda. The adapter captures this at connection-admission time
+ * and stores it keyed by connection ID.
+ *
+ * The method is **synchronous** — adapters pre-populate the identity at
+ * admission time (before the first reducer runs), so the SASL EXTERNAL
+ * reducer can look it up without awaiting. When no client certificate was
+ * presented (or mTLS is not configured), `getIdentity` returns `undefined`
+ * and EXTERNAL authentication fails with `904`.
+ */
+export interface MtlsIdentityProvider {
+  /**
+   * @returns the verified client-cert subject for `connId`, or `undefined`
+   *   when no trusted certificate was presented.
+   */
+  getIdentity(connId: string): string | undefined;
+}
+
+/**
+ * Reference in-memory {@link MtlsIdentityProvider} backed by a static map
+ * of connection IDs to certificate subjects. Useful for tests and the
+ * local-cli adapter; cloud adapters replace this with a lookup keyed by
+ * the platform's connection identifier.
+ */
+export class InMemoryMtlsIdentityProvider implements MtlsIdentityProvider {
+  private readonly identities: ReadonlyMap<string, string>;
+
+  constructor(entries: ReadonlyArray<{ connId: string; identity: string }>) {
+    this.identities = new Map(entries.map((e) => [e.connId, e.identity]));
+  }
+
+  getIdentity(connId: string): string | undefined {
+    return this.identities.get(connId);
+  }
+}
+
 // ============================================================================
 // Chat-history persistence (IRCv3 draft/chathistory)
 // ============================================================================
@@ -301,7 +432,7 @@ export class InMemoryMessageStore implements MessageStore {
   }
 
   record(message: StoredMessage): void {
-    const key = message.chan.toLowerCase();
+    const key = caseFold('rfc1459', message.chan);
     let arr = this.byChan.get(key);
     if (arr === undefined) {
       arr = [];
@@ -315,7 +446,7 @@ export class InMemoryMessageStore implements MessageStore {
 
   query(q: HistoryQuery): StoredMessage[] {
     if (q.limit <= 0) return [];
-    const arr = this.byChan.get(q.chan.toLowerCase());
+    const arr = this.byChan.get(caseFold('rfc1459', q.chan));
     if (arr === undefined || arr.length === 0) return [];
 
     switch (q.direction) {
@@ -335,14 +466,14 @@ export class InMemoryMessageStore implements MessageStore {
   }
 
   hasMsgid(chan: string, msgid: string): boolean {
-    const arr = this.byChan.get(chan.toLowerCase());
+    const arr = this.byChan.get(caseFold('rfc1459', chan));
     if (arr === undefined) return false;
     return arr.some((m) => m.msgid === msgid);
   }
 
   recent(chan: string, sinceMsgid: string | undefined, limit: number): StoredMessage[] {
     if (limit <= 0) return [];
-    const arr = this.byChan.get(chan.toLowerCase());
+    const arr = this.byChan.get(caseFold('rfc1459', chan));
     if (arr === undefined || arr.length === 0) return [];
     let start = 0;
     if (sinceMsgid !== undefined) {
@@ -437,6 +568,108 @@ function tail<T>(arr: readonly T[], n: number): T[] {
   return arr.slice(start);
 }
 
+// ============================================================================
+// Nick history (WHOWAS)
+// ============================================================================
+
+/**
+ * One persisted sign-off record for a nick, written by the QUIT and
+ * post-registration NICK-change reducers and replayed by `WHOWAS`.
+ *
+ * `nick` preserves the original case the client used; `connId` is the
+ * connection that owned the nick at sign-off. `username` / `hostname` /
+ * `realname` mirror the {@link ConnectionState} fields at sign-off time
+ * (optional because a never-fully-registered connection may still quit with
+ * a nick). `signoffTime` is epoch milliseconds from the injected
+ * {@link Clock}.
+ */
+export interface NickHistoryEntry {
+  nick: string;
+  connId: string;
+  username?: string;
+  hostname?: string;
+  realname?: string;
+  signoffTime: number;
+}
+
+/**
+ * Persistence port for the IRC `WHOWAS` command.
+ *
+ * Mirrors the {@link MessageStore} 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; Phase 8 ships the in-memory
+ * reference implementation only.
+ *
+ * `query` always returns matches most-recent-first (the order `WHOWAS`
+ * emits `314 RPL_WHOWASUSER` lines in), capped at `count`.
+ */
+export interface NickHistoryStore {
+  /** Records a sign-off entry for a nick (TTL eviction is impl-defined). */
+  record(entry: NickHistoryEntry): void;
+  /** Returns up to `count` most-recent entries for `nick` (case-insensitive). */
+  query(nick: string, count: number): NickHistoryEntry[];
+}
+
+/** Default retention window for nick-history entries: 24 hours. */
+const DEFAULT_NICK_HISTORY_MAX_AGE = 24 * 60 * 60 * 1000;
+
+/**
+ * Reference in-memory {@link NickHistoryStore} backed by a per-nick
+ * chronological array with a configurable TTL.
+ *
+ * Used by the local CLI and by tests. Each nick keeps its sign-off records
+ * in arrival order; entries older than `maxAge` (measured against the
+ * injected {@link Clock}) are dropped lazily on `record` and `query` so the
+ * per-nick buffers do not grow unbounded.
+ *
+ * Nicks are keyed via {@link caseFold} (`rfc1459`) so lookups are
+ * case-insensitive, matching the IRC nick-comparison semantics advertised
+ * via `005 RPL_ISUPPORT CASEMAPPING=rfc1459`.
+ */
+export class InMemoryNickHistoryStore implements NickHistoryStore {
+  private readonly byNick = new Map<string, NickHistoryEntry[]>();
+  private readonly clock: Clock;
+  private readonly maxAge: number;
+
+  constructor(clock: Clock, opts?: { maxAge?: number }) {
+    this.clock = clock;
+    this.maxAge = opts?.maxAge ?? DEFAULT_NICK_HISTORY_MAX_AGE;
+  }
+
+  record(entry: NickHistoryEntry): void {
+    const key = caseFold('rfc1459', entry.nick);
+    let arr = this.byNick.get(key);
+    if (arr === undefined) {
+      arr = [];
+      this.byNick.set(key, arr);
+    }
+    this.purgeExpired(arr);
+    arr.push(entry);
+  }
+
+  query(nick: string, count: number): NickHistoryEntry[] {
+    if (count <= 0) return [];
+    const arr = this.byNick.get(caseFold('rfc1459', nick));
+    if (arr === undefined) return [];
+    this.purgeExpired(arr);
+    if (arr.length === 0) return [];
+    return arr.slice(Math.max(0, arr.length - count)).reverse();
+  }
+
+  /**
+   * Drops entries whose `signoffTime` is older than `now - maxAge`, in place.
+   * Entries arrive in chronological order (append-only), so the first alive
+   * entry marks the boundary; everything before it is expired.
+   */
+  private purgeExpired(arr: NickHistoryEntry[]): void {
+    const cutoff = this.clock.now() - this.maxAge;
+    let firstAlive = arr.findIndex((e) => e.signoffTime >= cutoff);
+    if (firstAlive === -1) firstAlive = arr.length;
+    arr.splice(0, firstAlive);
+  }
+}
+
 // ============================================================================
 // Observability — structured logger
 // ============================================================================
@@ -790,7 +1023,7 @@ export class ConsoleLogger implements Logger {
 
 /** Returns the global `console` as a {@link ConsoleLoggerSinks}. */
 function globalThisConsoleSinks(): ConsoleLoggerSinks {
-  // `globalThis.console` is universal across Node 20, Workers, and Lambda.
+  // `globalThis.console` is universal across Node 24, Workers, and Lambda.
   // Reference it lazily so tests that stub the logger do not need to
   // replace the global.
   const c = (globalThis as { console?: GlobalConsole }).console;

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

@@ -13,7 +13,7 @@ export const Numerics = {
   RPL_ISUPPORT: 5,
   RPL_BOUNCE: 10,
 
-  // Capability / stats admin
+  // Capability / stats admin / version
   RPL_ADMINME: 256,
 
   // Away / userhost / ison
@@ -23,7 +23,10 @@ export const Numerics = {
   RPL_UNAWAY: 305,
   RPL_NOWAWAY: 306,
 
-  // WHOIS
+  // Version
+  RPL_VERSION: 351,
+
+  // WHOIS / WHOWAS
   RPL_WHOISUSER: 311,
   RPL_WHOISSERVER: 312,
   RPL_WHOISOPERATOR: 313,
@@ -31,6 +34,7 @@ export const Numerics = {
   RPL_ENDOFWHOIS: 318,
   RPL_WHOISCHANNELS: 319,
   RPL_WHOISACCOUNT: 330,
+  RPL_WHOWASUSER: 314,
 
   // LIST
   RPL_LISTSTART: 321,
@@ -57,7 +61,8 @@ export const Numerics = {
   RPL_NAMREPLY: 353,
   RPL_ENDOFNAMES: 366,
 
-  // Links / ban / whowas
+  // Links / ban / whowas. RPL_LINKS/RPL_ENDOFLINKS retained for the deferred
+  // LINKS verb (S2S server list — PLAN non-goal; see actor default-route triage).
   RPL_LINKS: 364,
   RPL_ENDOFLINKS: 365,
   RPL_BANLIST: 367,
@@ -71,7 +76,8 @@ export const Numerics = {
   RPL_MOTDSTART: 375,
   RPL_ENDOFMOTD: 376,
 
-  // Oper
+  // Oper. RPL_REHASHING retained for the deferred REHASH verb (no runtime
+  // config-reload path in serverless; see actor default-route triage).
   RPL_YOUREOPER: 381,
   RPL_REHASHING: 382,
   RPL_YOURESERVICE: 383,
@@ -96,7 +102,7 @@ export const Numerics = {
   ERR_TOOMANYCHANNELS: 405,
   ERR_WASNOSUCHNICK: 406,
   ERR_TOOMANYTARGETS: 407,
-  ERR_NOSUCHSERVICE: 408,
+  ERR_NOSUCHSERVICE: 408, // retained: deferred SERVICE verb (RFC 2812 obsolete)
   ERR_INVALIDCAPCMD: 410,
   ERR_NORECIPIENT: 411,
   ERR_NOTEXTTOSEND: 412,
@@ -115,8 +121,8 @@ export const Numerics = {
   ERR_NOTONCHANNEL: 442,
   ERR_USERONCHANNEL: 443,
   ERR_NOLOGIN: 444,
-  ERR_SUMMONDISABLED: 445,
-  ERR_USERSDISABLED: 446,
+  ERR_SUMMONDISABLED: 445, // retained: deferred SUMMON verb (RFC 2812 obsolete)
+  ERR_USERSDISABLED: 446, // retained: deferred USERS verb (RFC 2812 obsolete)
   ERR_NOTREGISTERED: 451,
   ERR_NEEDMOREPARAMS: 461,
   ERR_ALREADYREGISTRED: 462,
@@ -134,7 +140,7 @@ export const Numerics = {
   ERR_BANLISTFULL: 478,
   ERR_NOPRIVILEGES: 481,
   ERR_CHANOPRIVSNEEDED: 482,
-  ERR_CANTKILLSERVER: 483,
+  ERR_CANTKILLSERVER: 483, // retained: deferred SQUIT verb (S2S, PLAN non-goal)
   ERR_NOOPERHOST: 491,
   ERR_UMODEUNKNOWNFLAG: 501,
   ERR_USERSDONTMATCH: 502,

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

@@ -8,7 +8,15 @@
 
 import type { Effect } from './effects.js';
 import type { FloodControlConfig } from './flood-control.js';
-import type { AccountStore, Clock, IdFactory, MessageStore, MotdProvider } from './ports.js';
+import type {
+  AccountStore,
+  Clock,
+  IdFactory,
+  MessageStore,
+  MotdProvider,
+  MtlsIdentityProvider,
+  NickHistoryStore,
+} from './ports.js';
 import type { IrcMessage } from './protocol/messages.js';
 import type { ConnectionState } from './state/connection.js';
 
@@ -25,6 +33,17 @@ export interface CloakingConfig {
   readonly cloakedSuffix?: string | undefined;
 }
 
+/**
+ * A single IRC operator credential. The {@link operReducer} consults the
+ * configured list to authenticate `OPER <name> <password>`. Both fields are
+ * compared verbatim; adapters are responsible for any hashing at the auth
+ * boundary if they layer one on top.
+ */
+export interface OperCred {
+  readonly user: string;
+  readonly password: string;
+}
+
 /**
  * Per-deployment server configuration. Adapters load this from a KV store
  * (CF) or Secrets Manager / SSM (AWS); the core only reads it.
@@ -35,6 +54,18 @@ export interface CloakingConfig {
 export interface ServerConfig {
   serverName: string;
   networkName: string;
+  /**
+   * Server version surfaced in `002`/`004`/`351`/`371`. When undefined the
+   * reducer falls back to {@link DEFAULT_SERVER_VERSION} (the irc-core
+   * package version); adapters inject the deploy-time version via config.
+   */
+  readonly serverVersion?: string | undefined;
+  /**
+   * "Created" text for `003 RPL_CREATED`. A string is used verbatim; a
+   * number is treated as epoch-ms and formatted as a UTC timestamp. When
+   * undefined the reducer falls back to {@link DEFAULT_CREATED_TEXT}.
+   */
+  readonly createdAt?: string | number | undefined;
   /**
    * Server password gate. Empty string or undefined disables enforcement.
    * When set, registration refuses to complete until the connection
@@ -53,6 +84,17 @@ export interface ServerConfig {
    * (see `serverPassword` note).
    */
   readonly cloaking?: CloakingConfig | undefined;
+  /**
+   * IRC operator credentials consulted by the `OPER` reducer. `undefined`
+   * (or an empty array) disables oper authentication entirely — an `OPER`
+   * attempt then receives `491 ERR_NOOPERHOST`.
+   *
+   * Typed `ReadonlyArray<OperCred> | undefined` to mirror Zod's `.optional()`
+   * output under `exactOptionalPropertyTypes: true`; the parsed config always
+   * supplies an array (defaulting to `[]`), so a parsed config is assignable
+   * here.
+   */
+  readonly operCreds?: ReadonlyArray<OperCred> | undefined;
   maxChannelsPerUser: number;
   maxTargetsPerCommand: number;
   maxListEntries: number;
@@ -93,6 +135,12 @@ export interface Ctx {
   readonly motd: MotdProvider;
   /** SASL account verification source (absent when no accounts are configured). */
   readonly accounts?: AccountStore;
+  /**
+   * mTLS client-cert identity source for SASL EXTERNAL (absent when mTLS
+   * is not configured). When present, `AUTHENTICATE EXTERNAL` resolves the
+   * connection's verified certificate subject through this port.
+   */
+  readonly mtlsIdentity?: MtlsIdentityProvider;
   /**
    * Chat-history persistence source (absent when chathistory playback is
    * disabled for this deployment). When present, the PRIVMSG/NOTICE channel
@@ -100,6 +148,13 @@ export interface Ctx {
    * cap-enabled joiners.
    */
   readonly messages?: MessageStore;
+  /**
+   * Nick-history source for the `WHOWAS` command (absent when WHOWAS
+   * history retention is disabled for this deployment). When present, the
+   * QUIT and post-registration NICK-change reducers record sign-off
+   * entries and the WHOWAS reducer replays them.
+   */
+  readonly history?: NickHistoryStore;
   /** The connection invoking the command. Reducers mutate this freely. */
   readonly connection: ConnectionState;
   /** Convenience: `connection.id`. */
@@ -125,7 +180,9 @@ export interface BuildCtxOptions {
   ids: IdFactory;
   motd: MotdProvider;
   accounts?: AccountStore;
+  mtlsIdentity?: MtlsIdentityProvider;
   messages?: MessageStore;
+  history?: NickHistoryStore;
   connection: ConnectionState;
 }
 
@@ -141,7 +198,9 @@ export function buildCtx(opts: BuildCtxOptions): Ctx {
     connection: opts.connection,
     connId: opts.connection.id,
     ...(opts.accounts !== undefined ? { accounts: opts.accounts } : {}),
+    ...(opts.mtlsIdentity !== undefined ? { mtlsIdentity: opts.mtlsIdentity } : {}),
     ...(opts.messages !== undefined ? { messages: opts.messages } : {}),
+    ...(opts.history !== undefined ? { history: opts.history } : {}),
   };
   return ctx;
 }