@owlmeans/bot 0.0.0-stage → 0.1.18-rc.2

package/src/protocols.ts

@@ -0,0 +1,121 @@
+import { contract, openProtocol, protocol, typed } from '@owlmeans/entrypoint'
+import { backend, route, RouteMethod, type RouteOptions } from '@owlmeans/route'
+import {
+  BotActivityQuerySchema, BotChallengeQuerySchema, BotConnectionInputSchema, BotHookParamsSchema, BotIdParamsSchema,
+  BotRuleInputSchema, BotRuleListQuerySchema, BotSimulateInputSchema,
+} from './schemas.js'
+import { botAliasUtils } from './utils/aliases.js'
+import type {
+  BotActivityQuery, BotBaseOptions, BotChallengeQuery, BotHookParams, BotHookPayload, BotHookProtocolOptions,
+  BotHookProtocols, BotHookReply, BotIdParams, BotProtocolOptions, BotProtocols, BotRemoveResult, BotRuleListQuery,
+} from './protocols/types.js'
+import type {
+  BotActivity, BotConnection, BotConnectionInput, BotRule, BotRuleInput, BotSimulateInput, BotSimulateResult,
+} from './types.js'
+
+const mountOf = (base: BotBaseOptions): Partial<RouteOptions> => ({
+  ...(base.parent != null ? { parent: base.parent } : {}),
+  ...(base.service != null ? { service: base.service } : {}),
+})
+
+/**
+ * Declare one managing surface of the bot — connections, rules, activity — as an immutable tree a
+ * server binds and a client calls.
+ *
+ * Every leaf hangs under ONE base that carries the guards and the gate, so they cannot drift apart;
+ * aliases derive from `opts.base.alias` (`<alias>:connection:list` …). A target declares one tree per
+ * area that runs bots (`api:bot:operator`, `api:bot:member`) — the same leaves, another gate.
+ */
+export const makeBotProtocols = (opts: BotProtocolOptions): BotProtocols => {
+  const aliases = botAliasUtils.botAliases(opts.base.alias)
+  const base = openProtocol(route(aliases.base, opts.base.path, backend(mountOf(opts.base))), {
+    ...(opts.guards != null ? { guards: opts.guards } : {}),
+    ...(opts.gates != null ? { gate: opts.gates } : {}),
+  })
+  const leaf = (alias: string, path: string, method: RouteMethod) =>
+    route(alias, path, backend({ parent: base }, method))
+
+  return Object.freeze({
+    base,
+
+    connection: Object.freeze({
+      list: protocol(
+        leaf(aliases.connection.list, '/connections', RouteMethod.GET),
+        contract(typed<BotConnection[]>())
+      ),
+      save: protocol(
+        leaf(aliases.connection.save, '/connections', RouteMethod.POST),
+        contract.request({ body: typed<BotConnectionInput>(BotConnectionInputSchema) }, typed<BotConnection>())
+      ),
+      verify: protocol(
+        leaf(aliases.connection.verify, '/connections/:id/verify', RouteMethod.POST),
+        contract.request({ params: typed<BotIdParams>(BotIdParamsSchema) }, typed<BotConnection>())
+      ),
+      remove: protocol(
+        leaf(aliases.connection.remove, '/connections/:id', RouteMethod.DELETE),
+        contract.request({ params: typed<BotIdParams>(BotIdParamsSchema) }, typed<BotRemoveResult>())
+      ),
+      simulate: protocol(
+        leaf(aliases.connection.simulate, '/connections/:id/simulate', RouteMethod.POST),
+        contract.request({
+          params: typed<BotIdParams>(BotIdParamsSchema),
+          body: typed<BotSimulateInput>(BotSimulateInputSchema),
+        }, typed<BotSimulateResult>())
+      ),
+    }),
+
+    rule: Object.freeze({
+      list: protocol(
+        leaf(aliases.rule.list, '/rules', RouteMethod.GET),
+        contract.request({ query: typed<BotRuleListQuery>(BotRuleListQuerySchema) }, typed<BotRule[]>())
+      ),
+      save: protocol(
+        leaf(aliases.rule.save, '/rules', RouteMethod.POST),
+        contract.request({ body: typed<BotRuleInput>(BotRuleInputSchema) }, typed<BotRule>())
+      ),
+      remove: protocol(
+        leaf(aliases.rule.remove, '/rules/:id', RouteMethod.DELETE),
+        contract.request({ params: typed<BotIdParams>(BotIdParamsSchema) }, typed<BotRemoveResult>())
+      ),
+    }),
+
+    activity: Object.freeze({
+      list: protocol(
+        leaf(aliases.activity.list, '/activity', RouteMethod.GET),
+        contract.request({ query: typed<BotActivityQuery>(BotActivityQuerySchema) }, typed<BotActivity[]>())
+      ),
+    }),
+  })
+}
+
+/**
+ * Declare the platforms' inbound surface: `receive` (POST) and `challenge` (GET) at
+ * `/:platform/:connection` under the base.
+ *
+ * NO guard and no gate, by design: the caller is the platform, and it proves itself by signing the
+ * request (Telegram's secret token, WhatsApp's app-secret HMAC, Slack's signing secret), which the
+ * server verifies against the connection's credentials. The body carries no schema — the signature
+ * covers the raw bytes, and the payload is the platform's own.
+ */
+export const makeBotHookProtocols = (opts: BotHookProtocolOptions): BotHookProtocols => {
+  const aliases = botAliasUtils.botHookAliases(opts.base.alias)
+  const base = openProtocol(route(aliases.base, opts.base.path, backend(mountOf(opts.base))))
+
+  return Object.freeze({
+    base,
+    receive: protocol(
+      route(aliases.receive, '/:platform/:connection', backend({ parent: base }, RouteMethod.POST)),
+      contract.request({
+        params: typed<BotHookParams>(BotHookParamsSchema),
+        body: typed<BotHookPayload>(),
+      }, typed<BotHookReply>())
+    ),
+    challenge: protocol(
+      route(aliases.challenge, '/:platform/:connection', backend({ parent: base }, RouteMethod.GET)),
+      contract.request({
+        params: typed<BotHookParams>(BotHookParamsSchema),
+        query: typed<BotChallengeQuery>(BotChallengeQuerySchema),
+      }, typed<string>())
+    ),
+  })
+}

package/src/schemas.ts

@@ -0,0 +1,159 @@
+import type { JSONSchemaType } from 'ajv'
+import {
+  BOT_ACTIVITY_LIMIT_MAX, BOT_CREDENTIAL_KEY_PATTERN, BOT_CREDENTIAL_MAX, BOT_CREDENTIALS_MAX, BOT_ID_MAX,
+  BOT_ID_PATTERN, BOT_INSTRUCTION_MAX, BOT_KEYWORD_MAX, BOT_KEYWORDS_MAX, BOT_LABEL_MAX, BOT_NAME_MAX,
+  BOT_REPLY_MAX, BOT_RULE_NAME_MAX, BOT_TEXT_MAX, BotChatKind, BotMatchMode, BotPlatform, BotRuleAction,
+  BotTransport,
+} from './consts.js'
+import type {
+  BotActivityQuery, BotChallengeQuery, BotHookParams, BotIdParams, BotRuleListQuery,
+} from './protocols/types.js'
+import type { BotConnectionInput, BotRuleInput, BotSimulateInput } from './types.js'
+
+/**
+ * Hand-written request schemas, cast: an optional key is OPTIONAL, never `null` — the wire matches the
+ * TypeScript type exactly. The only nullable is a rule's `connection`, whose `null` means "every
+ * connection of the scope". `additionalProperties: false` everywhere a client writes.
+ */
+const cast = <T>(schema: object): JSONSchemaType<T> => schema as unknown as JSONSchemaType<T>
+
+const Id = { type: 'string', minLength: 1, maxLength: BOT_ID_MAX, pattern: BOT_ID_PATTERN }
+const Name = { type: 'string', maxLength: BOT_NAME_MAX }
+/** A platform's own id (a chat, a user, a message) — no pattern: Telegram chat ids are negative numbers. */
+const PlatformId = { type: 'string', minLength: 1, maxLength: BOT_ID_MAX }
+
+export const BotIdParamsSchema = cast<BotIdParams>({
+  type: 'object',
+  properties: { id: Id },
+  required: ['id'],
+  additionalProperties: false,
+})
+
+export const BotConnectionInputSchema = cast<BotConnectionInput>({
+  type: 'object',
+  properties: {
+    id: Id,
+    platform: { type: 'string', enum: Object.values(BotPlatform) },
+    label: { type: 'string', minLength: 1, maxLength: BOT_LABEL_MAX },
+    transport: { type: 'string', enum: Object.values(BotTransport) },
+    enabled: { type: 'boolean' },
+    // Write-only. An omitted key keeps its stored value; an empty string is spellable so an optional
+    // credential can be cleared.
+    credentials: {
+      type: 'object',
+      propertyNames: { pattern: BOT_CREDENTIAL_KEY_PATTERN },
+      additionalProperties: { type: 'string', maxLength: BOT_CREDENTIAL_MAX },
+      maxProperties: BOT_CREDENTIALS_MAX,
+      required: [],
+    },
+  },
+  required: ['platform', 'label'],
+  additionalProperties: false,
+})
+
+export const BotRuleInputSchema = cast<BotRuleInput>({
+  type: 'object',
+  properties: {
+    id: Id,
+    connection: { ...Id, nullable: true },
+    name: { type: 'string', minLength: 1, maxLength: BOT_RULE_NAME_MAX },
+    keywords: {
+      type: 'array',
+      items: { type: 'string', minLength: 1, maxLength: BOT_KEYWORD_MAX },
+      minItems: 1,
+      maxItems: BOT_KEYWORDS_MAX,
+    },
+    mode: { type: 'string', enum: Object.values(BotMatchMode) },
+    action: { type: 'string', enum: Object.values(BotRuleAction) },
+    reply: { type: 'string', maxLength: BOT_REPLY_MAX },
+    instruction: { type: 'string', maxLength: BOT_INSTRUCTION_MAX },
+    enabled: { type: 'boolean' },
+    order: { type: 'number' },
+  },
+  required: ['name', 'keywords', 'action'],
+  additionalProperties: false,
+})
+
+export const BotSimulateInputSchema = cast<BotSimulateInput>({
+  type: 'object',
+  properties: {
+    text: { type: 'string', minLength: 1, maxLength: BOT_TEXT_MAX },
+    chat: {
+      type: 'object',
+      properties: {
+        id: PlatformId,
+        kind: { type: 'string', enum: Object.values(BotChatKind) },
+        title: Name,
+        thread: PlatformId,
+        space: PlatformId,
+      },
+      required: [],
+      additionalProperties: false,
+    },
+    sender: {
+      type: 'object',
+      properties: {
+        id: PlatformId,
+        name: Name,
+        username: Name,
+        bot: { type: 'boolean' },
+      },
+      required: [],
+      additionalProperties: false,
+    },
+    replyTo: {
+      type: 'object',
+      properties: {
+        id: PlatformId,
+        text: { type: 'string', maxLength: BOT_TEXT_MAX },
+      },
+      required: ['id'],
+      additionalProperties: false,
+    },
+  },
+  required: ['text'],
+  additionalProperties: false,
+})
+
+export const BotRuleListQuerySchema = cast<BotRuleListQuery>({
+  type: 'object',
+  properties: { connection: Id },
+  required: [],
+  additionalProperties: false,
+})
+
+/** A query string arrives as text: the server coerces `limit` before this checks it. */
+export const BotActivityQuerySchema = cast<BotActivityQuery>({
+  type: 'object',
+  properties: {
+    connection: Id,
+    limit: { type: 'integer', minimum: 1, maximum: BOT_ACTIVITY_LIMIT_MAX },
+  },
+  required: [],
+  additionalProperties: false,
+})
+
+export const BotHookParamsSchema = cast<BotHookParams>({
+  type: 'object',
+  properties: {
+    platform: { type: 'string', enum: Object.values(BotPlatform) },
+    connection: Id,
+  },
+  required: ['platform', 'connection'],
+  additionalProperties: false,
+})
+
+/**
+ * The handshake query. Open (`additionalProperties: true`): a platform adds keys at will, and a
+ * stripping validator must never drop the one the server reads.
+ */
+export const BotChallengeQuerySchema = cast<BotChallengeQuery>({
+  type: 'object',
+  properties: {
+    'hub.mode': { type: 'string', maxLength: BOT_NAME_MAX },
+    'hub.verify_token': { type: 'string', maxLength: BOT_CREDENTIAL_MAX },
+    'hub.challenge': { type: 'string', maxLength: BOT_CREDENTIAL_MAX },
+  },
+  required: [],
+  additionalProperties: true,
+})

package/src/types.ts

@@ -0,0 +1,228 @@
+import type {
+  BotActionKind, BotChatKind, BotConnectionStatus, BotMatchMode, BotPlatform, BotReceiveMode, BotRuleAction,
+  BotTransport, BotUpdateKind,
+} from './consts.js'
+
+/** One credential a platform needs — what the panel draws an input for. */
+export interface BotCredentialField {
+  key: string
+  /** Never shown back once saved; the connection only says the key holds a value. */
+  secret: boolean
+  /** The connection cannot be verified without it. */
+  required: boolean
+  /**
+   * The server creates it on save and nobody types it (WhatsApp's verify token); the connection's
+   * `setup` steps carry it for pasting into the platform console.
+   */
+  generated?: boolean
+  /** Optional credential only: the platform calls it adds when set (Slack's admin `userToken`: `delete`). */
+  enables?: BotActionKind[]
+}
+
+/** What a platform needs and can do. One per platform, in `BOT_PLATFORMS`. */
+export interface BotPlatformDescriptor {
+  platform: BotPlatform
+  title: string
+  credentials: BotCredentialField[]
+  /** The receive modes the platform offers, preferred first. */
+  receive: BotReceiveMode[]
+  /** The platform calls the required credentials allow; `note` is never listed. */
+  actions: BotActionKind[]
+  /** `auto`: the server registers the hook itself; `manual`: a person pastes `setup` into the console. */
+  setup: 'auto' | 'manual'
+  /** Where a person learns to create the bot and its credentials. */
+  docs: string
+}
+
+/** A connection as any client sees it — never a credential. */
+export interface BotConnection {
+  id: string
+  /** The organization (or application) key the connection belongs to — the server's, never the wire's. */
+  scope: string
+  platform: BotPlatform
+  label: string
+  transport: BotTransport
+  status: BotConnectionStatus
+  enabled: boolean
+  /** The receive mode in effect. */
+  receive: BotReceiveMode
+  /** Who the bot is on the platform, as verification answered. */
+  identity?: { id: string, username?: string, name?: string }
+  /** The address the platform posts to, for webhook platforms. */
+  hookUrl?: string
+  /** Manual steps: the URL / verify token to paste in the platform console. */
+  setup?: string[]
+  /** Which credential keys hold a value. */
+  credentialsSet: string[]
+  lastError?: string
+  lastEventAt?: string
+  createdAt: string
+  updatedAt: string
+}
+
+/**
+ * A connection as a client writes it. `credentials` is write-only: an omitted key keeps its stored
+ * value.
+ */
+export interface BotConnectionInput {
+  id?: string
+  platform: BotPlatform
+  label: string
+  transport?: BotTransport
+  enabled?: boolean
+  credentials?: Record<string, string>
+}
+
+/** A chat; `space` is the Discord guild or the Slack team. */
+export interface BotChatRef {
+  id: string
+  kind: BotChatKind
+  title?: string
+  thread?: string
+  space?: string
+}
+
+export interface BotSenderRef {
+  id: string
+  name?: string
+  username?: string
+  bot?: boolean
+}
+
+/**
+ * Enough to act on one message. `space` (the Discord guild / Slack team) is carried so a reference
+ * alone suffices where the platform addresses a member through it (a Discord timeout needs the guild).
+ */
+export interface BotMessageRef {
+  chat: string
+  id: string
+  thread?: string
+  space?: string
+}
+
+/** The message an update carries. */
+export interface BotReplyTarget extends BotMessageRef {
+  text?: string
+  sender?: BotSenderRef
+}
+
+export interface BotMessage {
+  ref: BotMessageRef
+  text: string
+  date: string
+  replyTo?: BotReplyTarget
+}
+
+/** A `/command`, its bot address stripped and its name lower-cased. */
+export interface BotCommand {
+  name: string
+  args: string
+}
+
+/** A keyword group: the keywords and what the bot does with a message that matches them. */
+export interface BotRule {
+  id: string
+  scope: string
+  /** One connection only; `null` or absent applies to every connection of the scope. */
+  connection?: string | null
+  name: string
+  keywords: string[]
+  mode: BotMatchMode
+  action: BotRuleAction
+  /** The fixed text of `reply` / `warn` (and the confirmation of `record`). */
+  reply?: string
+  /** What the product's agent is told for this group. */
+  instruction?: string
+  enabled: boolean
+  order: number
+  createdAt: string
+  updatedAt: string
+}
+
+export interface BotRuleInput {
+  id?: string
+  connection?: string | null
+  name: string
+  keywords: string[]
+  mode?: BotMatchMode
+  action: BotRuleAction
+  reply?: string
+  instruction?: string
+  enabled?: boolean
+  order?: number
+}
+
+/** A rule a message matched, with the rule's keywords (as stored) that matched it. */
+export interface BotMatch {
+  rule: BotRule
+  keywords: string[]
+}
+
+/** A normalized inbound update, as a handler receives it. */
+export interface BotUpdate {
+  id: string
+  connection: string
+  scope: string
+  platform: BotPlatform
+  kind: BotUpdateKind
+  chat: BotChatRef
+  sender?: BotSenderRef
+  message?: BotMessage
+  command?: BotCommand
+  /** A direct message, a mention of the bot, or a reply to it. */
+  addressed: boolean
+  /** Enabled rules of the scope (and connection) the text matches, by order. */
+  matches: BotMatch[]
+  receivedAt: string
+  raw?: unknown
+}
+
+/** Whom an activity acted on. */
+export interface BotActivityTarget {
+  chat: string
+  message?: string
+  user?: string
+}
+
+/** One thing the bot did — or tried to do — recorded whether it succeeded or not. */
+export interface BotActivity {
+  id: string
+  scope: string
+  connection: string
+  platform: BotPlatform
+  /** The update it answered. */
+  update?: string
+  action: BotActionKind
+  target?: BotActivityTarget
+  text?: string
+  /** The rule it followed. */
+  rule?: string
+  ok: boolean
+  /** Why it failed, as a short sentence a person reads. */
+  error?: string
+  /**
+   * The machine marker of the failure (`bot:<marker>:<detail>`) — what code compares and what a
+   * translating view keys its copy on; never shown as is.
+   */
+  code?: string
+  transport: BotTransport
+  at: string
+}
+
+/** A message fed to a MOCK connection through the platform's own path. */
+export interface BotSimulateInput {
+  text: string
+  chat?: Partial<BotChatRef>
+  sender?: Partial<BotSenderRef>
+  replyTo?: { id: string, text?: string }
+}
+
+export interface BotSimulateResult {
+  /** The id of the update the simulated message became. */
+  update: string
+  /**
+   * `true` when the simulated payload's dedupe key was already in the inbox: `update` is that
+   * existing row and nothing new is dispatched. `false` (or absent) for a new row.
+   */
+  duplicate?: boolean
+}

package/src/utils/aliases/types.ts

@@ -0,0 +1,25 @@
+/** The aliases one managing tree answers under — every one derived from the mount's base alias. */
+export interface BotAliases {
+  readonly base: string
+  readonly connection: {
+    readonly list: string
+    readonly save: string
+    readonly verify: string
+    readonly remove: string
+    readonly simulate: string
+  }
+  readonly rule: { readonly list: string, readonly save: string, readonly remove: string }
+  readonly activity: { readonly list: string }
+}
+
+export interface BotHookAliases {
+  readonly base: string
+  readonly receive: string
+  readonly challenge: string
+}
+
+export interface BotAliasUtils {
+  /** Two mounts in one deployment are two base aliases, never two copies of a table. */
+  botAliases: (base: string) => BotAliases
+  botHookAliases: (base: string) => BotHookAliases
+}

package/src/utils/aliases.ts

@@ -0,0 +1,30 @@
+import type { BotAliases, BotAliasUtils, BotHookAliases } from './aliases/types.js'
+
+export const createBotAliasUtils = (): BotAliasUtils => {
+  const botAliases = (base: string): BotAliases => Object.freeze({
+    base,
+    connection: Object.freeze({
+      list: `${base}:connection:list`,
+      save: `${base}:connection:save`,
+      verify: `${base}:connection:verify`,
+      remove: `${base}:connection:remove`,
+      simulate: `${base}:connection:simulate`,
+    }),
+    rule: Object.freeze({
+      list: `${base}:rule:list`,
+      save: `${base}:rule:save`,
+      remove: `${base}:rule:remove`,
+    }),
+    activity: Object.freeze({ list: `${base}:activity:list` }),
+  })
+
+  const botHookAliases = (base: string): BotHookAliases => Object.freeze({
+    base,
+    receive: `${base}:receive`,
+    challenge: `${base}:challenge`,
+  })
+
+  return { botAliases, botHookAliases }
+}
+
+export const botAliasUtils = createBotAliasUtils()

package/tests/command.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from 'bun:test'
+import { botCommandHelper } from '../src/index.js'
+
+describe('botCommandHelper.parse', () => {
+  test('reads a command addressed to this bot, its name lower-cased and its args trimmed', () => {
+    expect(botCommandHelper.parse('/report@MyBot some args', 'MyBot')).toEqual({ name: 'report', args: 'some args' })
+    expect(botCommandHelper.parse('  /Report@mybot   spam  here  ', '@MYBOT')).toEqual({ name: 'report', args: 'spam  here' })
+    expect(botCommandHelper.parse('/start')).toEqual({ name: 'start', args: '' })
+    expect(botCommandHelper.parse('/report\nline one\nline two', 'MyBot')).toEqual({ name: 'report', args: 'line one\nline two' })
+  })
+
+  test('ignores a command addressed to another bot, and accepts any address when its own name is unknown', () => {
+    expect(botCommandHelper.parse('/report@OtherBot spam', 'MyBot')).toBeNull()
+    expect(botCommandHelper.parse('/report@OtherBot spam')).toEqual({ name: 'report', args: 'spam' })
+  })
+
+  test('answers null for text that is not a command', () => {
+    expect(botCommandHelper.parse('hello /report')).toBeNull()
+    expect(botCommandHelper.parse('/usr/bin is a path')).toBeNull()
+    expect(botCommandHelper.parse('/')).toBeNull()
+    expect(botCommandHelper.parse('/report@')).toBeNull()
+  })
+})

package/tests/context.ts

@@ -0,0 +1,13 @@
+import Ajv from 'ajv'
+
+/**
+ * The one validator the suite shares, configured as the server's HTTP boundary validates a request
+ * (`coerceTypes`, so a query string's `limit=50` is a number) but without stripping, so a refused
+ * extra key is SEEN refused instead of silently dropped.
+ */
+export const ajv = new Ajv({ coerceTypes: true, allErrors: true, strict: false })
+
+export const validatorOf = (schema: object): ((value: unknown) => boolean) => {
+  const validate = ajv.compile(schema)
+  return (value: unknown) => validate(structuredClone(value)) === true
+}

package/tests/errors.spec.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'bun:test'
+import { ResilientError } from '@owlmeans/error'
+import * as errors from '../src/errors.js'
+
+/** What an HTTP boundary reads off a class: a static `httpStatus`, absent on a fault. */
+const statusOf = (error: Error): unknown => (error.constructor as { httpStatus?: unknown }).httpStatus
+
+const DECLARED: Record<string, number | undefined> = {
+  BotError: undefined,
+  BotConnectionNotFound: 404,
+  BotCredentialsRejected: 422,
+  BotSignatureRejected: 401,
+  BotTransportMismatch: 409,
+  BotUnsupportedAction: 422,
+}
+
+const classes = Object.entries(errors).filter(([, value]) =>
+  typeof value === 'function' && (value === errors.BotError || value.prototype instanceof errors.BotError)
+) as [string, new (message?: string) => ResilientError][]
+
+describe('bot errors', () => {
+  test('every class has decided its status', () => {
+    expect(classes.map(([name]) => name).sort()).toEqual(Object.keys(DECLARED).sort())
+    for (const [name, Class] of classes) {
+      expect([name, statusOf(new Class('x'))]).toEqual([name, DECLARED[name]])
+    }
+  })
+
+  test('messages carry the family prefix and the class marker', () => {
+    expect(new errors.BotConnectionNotFound('conn_1').message).toBe('bot:connection-not-found:conn_1')
+    expect(new errors.BotTransportMismatch('live').message).toBe('bot:transport-mismatch:live')
+  })
+
+  test('a refusal rebuilt from its marshalled form keeps its class and its status', () => {
+    for (const [name, Class] of classes) {
+      const back = ResilientError.ensure(new Class('x').marshal())
+      expect([name, back.constructor === Class, back instanceof errors.BotError, statusOf(back)])
+        .toEqual([name, true, true, DECLARED[name]])
+    }
+  })
+})