@ic-reactor/mcp 0.0.0-stage → 0.0.0

package/e2e/README.md

@@ -0,0 +1,101 @@
+# End-to-End Test Workspace
+
+The real-replica suite of ic-reactor 4: a small Rust canister, `hello_actor`,
+deployed to a local icp-cli 1.2.0 network, and twelve vitest cases that call it
+through the published API of `@ic-reactor/core`, `@ic-reactor/react` and
+`@ic-reactor/vite-plugin`, with the module `meant gen` writes from its `.did`.
+Seven more deploy the response headers of the docs guide "Deploy to a frontend
+canister" to DFINITY's two asset canisters, and check what they serve.
+
+## Running it
+
+From the repository root, once:
+
+```bash
+pnpm install   # installs icp-cli 1.2.0 and ic-wasm 0.11.1 into e2e/node_modules
+pnpm build     # the suite imports the built packages
+```
+
+Rust with the `wasm32-unknown-unknown` target builds the canister.
+
+Then `pnpm test` in `e2e/` (or `pnpm test-e2e` at the root, or
+`bash e2e/test.sh`):
+
+1. checks that `icp` is the pinned 1.2.0 (`node_modules/.bin` comes first on
+   PATH, so CI runs these copies too; a global install of the same version is
+   only a fallback, and CI checks that its global one matches the pins), and
+   that `src/declarations` matches the `.did` (`pnpm gen:check`);
+2. starts a local network (`icp network start -d`, port 8000) and deploys
+   the canisters of `icp.yaml` (`icp deploy`): `hello_actor`, and the two
+   frontend canisters;
+3. calls `greet` once with `icp` to check the deployment;
+4. runs `vitest run`;
+5. stops the network, also when a step fails.
+
+To iterate on the cases, keep a network up yourself:
+
+```bash
+pnpm icp:start && pnpm icp:deploy
+pnpm test:vitest            # or: pnpm exec vitest run src/errors.test.ts
+pnpm icp:stop
+```
+
+`global-setup.ts` asks `icp` for the network's URL and root key and the
+canisters' ids, and fails the run when there is none. A run that finds no test
+file fails too: there is no `passWithNoTests`.
+
+## The canister
+
+`src/actor/src/lib.rs`; each method puts one kind of value or failure on the
+wire.
+
+| Method          | Signature                                       | Covers                                                                                 |
+| --------------- | ----------------------------------------------- | -------------------------------------------------------------------------------------- |
+| `greet`         | `(text) -> (text) query`                        | A query.                                                                               |
+| `is_replicated` | `() -> (bool) query`                            | How a query went out: `false` as a query, `true` as an update call (a certified read). |
+| `increment`     | `() -> (nat)`                                   | A stateful update.                                                                     |
+| `count`         | `() -> (nat) query`                             | Reads what the updates wrote.                                                          |
+| `increment_by`  | `(nat64) -> (variant { Ok : nat; Err : text })` | Both arms of a Result from an update. Zero returns `Err` and changes nothing.          |
+| `refuse`        | `() -> ()`                                      | `ic0.msg_reject`: reject code 4.                                                       |
+| `boom`          | `() -> ()`                                      | A trap: reject code 5.                                                                 |
+| `whoami`        | `() -> (principal) query`                       | The caller, for the identity switch.                                                   |
+
+`src/actor/hello_actor.did` is written by hand, so change it together with
+`lib.rs`; the build embeds it as the canister's `candid:service` metadata.
+`src/declarations/hello_actor.ts` (and its Contract envelope) is what
+`meant gen` writes from it: run `pnpm gen` after a change to the `.did`, and
+commit both. Prettier leaves them alone.
+
+## The frontend canisters
+
+Two more canisters of `icp.yaml` serve one page each, with the headers of the
+docs guide "Deploy to a frontend canister"
+(`docs/src/content/docs/guides/deploy.mdx`), on the recipes and versions the
+guide names:
+
+| Canister         | Recipe                                                      | Uploads                                                                      |
+| ---------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------- |
+| `asset_canister` | `@dfinity/asset-canister@v2.3.0`, the asset canister 0.30.2 | `frontends/index.html` and the wallet example's `public/.ic-assets.json5`    |
+| `static_site`    | `@dfinity/static-site@v0.4.2` (certified-assets)            | `frontends/index.html` and the `_headers` of the guide's static-site section |
+
+Their builds run `frontends/build.mjs`, which copies those files into
+`frontends/dist/` as they are, so the cases check the example's and the
+guide's own text. Bump a recipe here, in the guide and in the wallet example
+together: a case checks that the three agree.
+
+## The cases
+
+The files run one at a time (`fileParallelism: false`): they share the
+canister's counter, and the anonymous-write case reads it back. Each runs in
+jsdom, where `auth` sign-in, the `ic_env` cookie and `ReactorProvider` exist;
+the agent sends with Node's `fetch`. `frontend-headers.test.ts` runs in Node:
+it needs no page.
+
+| File                       | Case                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `calls.test.ts`            | A query (direct and through `queryOptions`, sent as a query); an update through `mutationOptions`, which invalidates the canister's reads; a certified read (`{ id, certified: true }`); the root key fetched from the local replica.                                                                                                                                                                                                                                                                                              |
+| `errors.test.ts`           | A reject 4 and a trap (reject 5), both `rejected` and may have executed; a Result `Err` as `canister_err`, which did not leave the outcome open; an anonymous write refused before sending (`unauthenticated`, `anonymous_write`); an unresolved `{ name }` (`invalid_args`, `canister_id_unresolved`).                                                                                                                                                                                                                            |
+| `identity.test.ts`         | A switch between two Ed25519 identities on one client: the caller the canister sees, `client.caller()` and the query keys all follow it.                                                                                                                                                                                                                                                                                                                                                                                           |
+| `vite-env.test.ts`         | A Vite dev server with `@ic-reactor/vite-plugin`, started in the test: the page load's `ic_env` cookie resolves `{ name: "hello_actor" }`, and the call goes through the server's `/api` proxy.                                                                                                                                                                                                                                                                                                                                    |
+| `react.test.tsx`           | `ReactorProvider`, `useClient` and `useQuery`: the component renders what the canister answers, as whoever is signed in, and again after a switch.                                                                                                                                                                                                                                                                                                                                                                                 |
+| `frontend-headers.test.ts` | The guide's headers, as both frontend canisters serve them through the local HTTP gateway: every header the example and the guide give, certified (the response's `ic-certificateexpression` names it); the asset canister's `hardened` headers; its raw host (`<id>.raw.icp0.io`) redirected (308) to `<id>.icp0.io` with the path and query, and the static site's raw host served. Also that the guide, core's `llms.txt` and the example show the same `.ic-assets.json5`, and that the guide names the recipes deployed here. |

package/e2e/frontends/build.mjs

@@ -0,0 +1,94 @@
+// Writes what the two frontend canisters of e2e/icp.yaml upload, from the
+// files the docs guide "Deploy to a frontend canister" gives
+// (docs/src/content/docs/guides/deploy.mdx):
+//
+//   dist/asset-canister/  index.html, and the wallet example's
+//                         public/.ic-assets.json5, for DFINITY's asset canister
+//   dist/static-site/     index.html, and the _headers of the guide's
+//                         static-site section, for the certified-assets one
+//
+// Each file is copied as it is, so src/frontend-headers.test.ts checks what
+// the example deploys and what the guide says, not a copy kept here.
+//
+// Usage: node frontends/build.mjs asset-canister | static-site
+// (each canister's build writes its own directory only, so the two can run
+// at once).
+import {
+  copyFileSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const here = path.dirname(fileURLToPath(import.meta.url))
+const repository = path.resolve(here, "..", "..")
+
+/** The wallet example's `.ic-assets.json5`. */
+export const icAssetsFile = path.join(
+  repository,
+  "examples/vite-wallet/public/.ic-assets.json5"
+)
+
+/** The docs guide that gives both files. */
+export const guideFile = path.join(
+  repository,
+  "docs/src/content/docs/guides/deploy.mdx"
+)
+
+/**
+ * The fenced code blocks of a Markdown text, with their language.
+ *
+ * @param {string} markdown
+ * @returns {{ lang: string, body: string }[]}
+ */
+export function fences(markdown) {
+  return [...markdown.matchAll(/^```(\w*)\n([\s\S]*?)^```$/gm)].map(
+    ([, lang, body]) => ({ lang, body })
+  )
+}
+
+/**
+ * The guide's `_headers`: its one `text` fence that starts with a path.
+ *
+ * @param {string} markdown
+ * @returns {string}
+ */
+export function guideHeaders(markdown) {
+  const found = fences(markdown).filter(
+    (fence) => fence.lang === "text" && fence.body.startsWith("/*\n")
+  )
+  if (found.length !== 1) {
+    throw new Error(
+      `${guideFile}: expected one text fence that starts with "/*", found ${found.length}`
+    )
+  }
+  return found[0].body
+}
+
+const sites = {
+  "asset-canister": (dir) =>
+    copyFileSync(icAssetsFile, path.join(dir, ".ic-assets.json5")),
+  "static-site": (dir) =>
+    writeFileSync(
+      path.join(dir, "_headers"),
+      guideHeaders(readFileSync(guideFile, "utf8"))
+    ),
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const site = process.argv[2]
+  const write = sites[site]
+  if (write === undefined) {
+    throw new Error(
+      `Usage: node frontends/build.mjs ${Object.keys(sites).join(" | ")}`
+    )
+  }
+  const dir = path.join(here, "dist", site)
+  rmSync(dir, { recursive: true, force: true })
+  mkdirSync(dir, { recursive: true })
+  copyFileSync(path.join(here, "index.html"), path.join(dir, "index.html"))
+  write(dir)
+}

package/e2e/frontends/index.html

@@ -0,0 +1,10 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <title>Frontend headers</title>
+  </head>
+  <body>
+    <p>The page whose headers src/frontend-headers.test.ts reads.</p>
+  </body>
+</html>

package/e2e/global-setup.ts

@@ -0,0 +1,65 @@
+/**
+ * Runs once before the suite, in the vitest process. It asks the `icp` CLI on
+ * PATH (the 1.2.0 this package installs, under `pnpm exec`) where the local
+ * network is and which ids the canisters of icp.yaml were deployed with, and
+ * hands them to the test files through `inject("replica")`.
+ */
+import { execFileSync } from "node:child_process"
+import { fileURLToPath } from "node:url"
+import type { TestProject } from "vitest/node"
+
+export interface Replica {
+  /** The replica's API URL, without the trailing slash: `http://127.0.0.1:8000`. */
+  readonly host: string
+  /** The replica's root key as hex, as `icp network status` reports it. */
+  readonly rootKey: string
+  /** The id `icp deploy` gave `hello_actor`. */
+  readonly canisterId: string
+  /** The ids of the two frontend canisters, `asset_canister` and `static_site`. */
+  readonly frontends: {
+    readonly assetCanister: string
+    readonly staticSite: string
+  }
+}
+
+declare module "vitest" {
+  export interface ProvidedContext {
+    replica: Replica
+  }
+}
+
+const cwd = fileURLToPath(new URL(".", import.meta.url))
+
+const icp = (...args: string[]): string => {
+  try {
+    return execFileSync("icp", args, {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim()
+  } catch (error) {
+    const stderr = (error as { stderr?: string }).stderr?.trim()
+    throw new Error(
+      `\`icp ${args.join(" ")}\` failed${stderr ? `: ${stderr}` : ""}. ` +
+        "The e2e suite needs a local network with the canisters of icp.yaml deployed: run `bash test.sh` in e2e/.",
+      { cause: error }
+    )
+  }
+}
+
+export default function setup(project: TestProject): void {
+  const status = JSON.parse(icp("network", "status", "-e", "local", "--json"))
+  const host = String(status.api_url).replace(/\/+$/, "")
+  const rootKey = String(status.root_key)
+  const idOf = (name: string): string =>
+    icp("canister", "status", name, "-e", "local", "-i")
+  project.provide("replica", {
+    host,
+    rootKey,
+    canisterId: idOf("hello_actor"),
+    frontends: {
+      assetCanister: idOf("asset_canister"),
+      staticSite: idOf("static_site"),
+    },
+  })
+}

package/e2e/icp.yaml

@@ -0,0 +1,38 @@
+# yaml-language-server: $schema=https://github.com/dfinity/icp-cli/raw/refs/tags/v1.2.0/docs/schemas/icp-yaml-schema.json
+
+canisters:
+  - name: hello_actor
+    recipe:
+      type: "@dfinity/rust@v3.2.0"
+      configuration:
+        package: hello_actor
+        candid: src/actor/hello_actor.did
+
+  # The response headers of the docs guide "Deploy to a frontend canister", on
+  # DFINITY's two asset canisters: frontends/build.mjs writes what each one
+  # uploads, and src/frontend-headers.test.ts reads what it serves.
+  - name: asset_canister
+    recipe:
+      type: "@dfinity/asset-canister@v2.3.0"
+      configuration:
+        version: 0.30.2
+        build:
+          - node frontends/build.mjs asset-canister
+        dir: frontends/dist/asset-canister
+  - name: static_site
+    recipe:
+      type: "@dfinity/static-site@v0.4.2"
+      configuration:
+        build:
+          - node frontends/build.mjs static-site
+        dir: frontends/dist/static-site
+
+networks:
+  # The implicit `local` network, with its network launcher pinned. Left at
+  # "latest", `icp network start` asks the GitHub API which release that is,
+  # unauthenticated, and E2E failed with "403 rate limit exceeded" whenever many
+  # runs started at once (#555). An exact version is downloaded straight from
+  # its release. Bump it deliberately, like ICP_CLI_VERSION in e2e.yml.
+  - name: local
+    mode: managed
+    version: v16.0.0-2026-09-18-03-28

package/e2e/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "hello-world",
+  "version": "0.0.0",
+  "private": true,
+  "license": "MIT",
+  "type": "module",
+  "scripts": {
+    "start": "bash ./test.sh",
+    "test": "bash ./test.sh",
+    "test:vitest": "vitest run",
+    "gen": "meant gen src/actor/hello_actor.did -o src/declarations",
+    "gen:check": "meant gen src/actor/hello_actor.did -o src/declarations --check",
+    "icp:start": "icp network start -d",
+    "icp:deploy": "icp deploy",
+    "icp:stop": "icp network stop",
+    "typecheck": "tsc --noEmit -p tsconfig.typecheck.json"
+  },
+  "dependencies": {
+    "@meantjs/schema": "0.6.0",
+    "@ic-reactor/core": "workspace:*",
+    "@ic-reactor/react": "workspace:*",
+    "@icp-sdk/core": "^6.1.0"
+  },
+  "devDependencies": {
+    "@meantjs/cli": "0.5.1",
+    "@ic-reactor/vite-plugin": "workspace:*",
+    "@icp-sdk/ic-wasm": "0.11.1",
+    "@icp-sdk/icp-cli": "1.2.0",
+    "@tanstack/react-query": "^5.102.8",
+    "@testing-library/react": "^16.3.3",
+    "@types/node": "^26.5.1",
+    "@types/react": "^19.3.0",
+    "jsdom": "^30.0.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.0"
+  }
+}

package/e2e/setup.ts

@@ -0,0 +1,6 @@
+import { TextDecoder, TextEncoder } from "node:util"
+
+// Node's encoders, so that the bytes the agent builds and the bytes it checks
+// are Uint8Arrays of the same realm under jsdom.
+globalThis.TextEncoder = TextEncoder as typeof globalThis.TextEncoder
+globalThis.TextDecoder = TextDecoder as typeof globalThis.TextDecoder

package/e2e/src/actor/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "hello_actor"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+candid = "0.10.24"
+ic-cdk = "0.19.0"
+serde = { version = "1.0.228", features = ["derive"] }

package/e2e/src/actor/hello_actor.did

@@ -0,0 +1,10 @@
+service : {
+    "greet" : (text) -> (text) query;
+    "is_replicated" : () -> (bool) query;
+    "increment" : () -> (nat);
+    "count" : () -> (nat) query;
+    "increment_by" : (nat64) -> (variant { Ok : nat; Err : text });
+    "refuse" : () -> ();
+    "boom" : () -> ();
+    "whoami" : () -> (principal) query
+}

package/e2e/src/actor/src/lib.rs

@@ -0,0 +1,73 @@
+//! The canister the e2e suite runs against. Each method puts one kind of
+//! value, or one kind of failure, on the wire. The interface is written out by
+//! hand in `hello_actor.did`, which the build embeds as the `candid:service`
+//! metadata, so a method added here must be added there too, and the module in
+//! `src/declarations` generated again (see the e2e README).
+
+use std::cell::Cell;
+
+use candid::{Nat, Principal};
+
+thread_local! {
+    static COUNTER: Cell<u64> = const { Cell::new(0) };
+}
+
+/// A query.
+#[ic_cdk::query]
+fn greet(name: String) -> String {
+    format!("Hello, {}!", name)
+}
+
+/// Whether the call runs in replicated mode: `false` for a query sent as one,
+/// `true` for a query sent as an update call, which is how a certified read
+/// goes out.
+#[ic_cdk::query]
+fn is_replicated() -> bool {
+    ic_cdk::api::in_replicated_execution()
+}
+
+/// Adds one to the counter and returns the new value.
+#[ic_cdk::update]
+fn increment() -> Nat {
+    let next = COUNTER.get() + 1;
+    COUNTER.set(next);
+    Nat::from(next)
+}
+
+/// The counter, as `increment` and `increment_by` left it.
+#[ic_cdk::query]
+fn count() -> Nat {
+    Nat::from(COUNTER.get())
+}
+
+/// Adds `by` to the counter and returns `Ok` with the new value, or returns
+/// `Err` without changing anything when `by` is zero: the `Err` arm of a
+/// Result from an update.
+#[ic_cdk::update]
+fn increment_by(by: u64) -> Result<Nat, String> {
+    if by == 0 {
+        return Err("by must be positive".to_string());
+    }
+    let next = COUNTER.get().saturating_add(by);
+    COUNTER.set(next);
+    Ok(Nat::from(next))
+}
+
+/// Rejects the call with `ic0.msg_reject`, which the IC reports as reject code
+/// 4 (CANISTER_REJECT).
+#[ic_cdk::update(manual_reply = true)]
+fn refuse() {
+    ic_cdk::api::msg_reject("refused: this method always rejects");
+}
+
+/// Always traps, which the IC reports as reject code 5 (CANISTER_ERROR).
+#[ic_cdk::update]
+fn boom() {
+    ic_cdk::trap("boom: this method always traps");
+}
+
+/// The principal that signed the call.
+#[ic_cdk::query]
+fn whoami() -> Principal {
+    ic_cdk::api::msg_caller()
+}

package/e2e/src/calls.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Calls that succeed on the real replica: a query, an update and its
+ * invalidation, a certified read, and the root key the client fetches from the
+ * local replica (Q4).
+ */
+import { createClient, isReactorError } from "@ic-reactor/core"
+import { MutationObserver } from "@tanstack/react-query"
+import { afterEach, describe, expect, it } from "vitest"
+import { actor, type Actor } from "./declarations/hello_actor"
+import { ANONYMOUS, ed25519, network, replica, target } from "./replica"
+
+const clients: { dispose(): void }[] = []
+const track = <C extends { dispose(): void }>(client: C): C => {
+  clients.push(client)
+  return client
+}
+afterEach(() => {
+  for (const client of clients.splice(0)) client.dispose()
+})
+
+describe("calls on the local replica", () => {
+  it("a query answers, through its options and directly, without replicated execution", async () => {
+    const client = track(createClient({ network, identity: "anonymous" }))
+    const hello = client.canister<Actor>(actor, target)
+
+    await expect(hello.greet("World")).resolves.toBe("Hello, World!")
+
+    const options = client.queryOptions(hello, "greet", "Query")
+    // The network, the caller, the canister, the method, then the encoded
+    // arguments.
+    expect(options.queryKey.slice(0, 5)).toEqual([
+      "ic-reactor",
+      replica.host,
+      ANONYMOUS,
+      replica.canisterId,
+      "greet",
+    ])
+    expect(options.queryKey).toEqual(client.queryKey(hello, "greet", "Query"))
+    await expect(client.queryClient.fetchQuery(options)).resolves.toBe(
+      "Hello, Query!"
+    )
+
+    // The canister itself says the call went out as a query, not as an
+    // update call: one that sent queries as updates would still greet.
+    await expect(hello.is_replicated()).resolves.toBe(false)
+  })
+
+  it("an update changes state, and its mutation invalidates the canister's reads", async () => {
+    const client = track(createClient({ network, identity: ed25519() }))
+    const hello = client.canister<Actor>(actor, target)
+
+    const countOptions = client.queryOptions(hello, "count")
+    const before = await client.queryClient.fetchQuery(countOptions)
+    expect(typeof before).toBe("bigint")
+    expect(
+      client.queryClient.getQueryState(countOptions.queryKey)
+    ).toMatchObject({ status: "success", isInvalidated: false })
+
+    const increment = new MutationObserver(
+      client.queryClient,
+      client.mutationOptions(hello, "increment")
+    )
+    await expect(increment.mutate()).resolves.toBe(before + 1n)
+
+    // The cached count is stale now, and a direct read sees the write.
+    expect(
+      client.queryClient.getQueryState(countOptions.queryKey)
+    ).toMatchObject({ isInvalidated: true })
+    await expect(hello.count()).resolves.toBe(before + 1n)
+  })
+
+  it("a certified canister sends its queries as update calls, under keys of their own (Q19)", async () => {
+    const client = track(createClient({ network, identity: "anonymous" }))
+    const plain = client.canister<Actor>(actor, target)
+    const certified = client.canister<Actor>(actor, {
+      id: replica.canisterId,
+      certified: true,
+    })
+
+    await expect(certified.greet("Certified")).resolves.toBe(
+      "Hello, Certified!"
+    )
+    // Replicated execution: the reply came back certified by the subnet,
+    // where a plain query is answered by one replica.
+    await expect(certified.is_replicated()).resolves.toBe(true)
+    await expect(plain.is_replicated()).resolves.toBe(false)
+
+    const key = client.queryKey(certified, "greet", "Certified")
+    expect(key.at(-1)).toBe("certified")
+    expect(key).not.toEqual(client.queryKey(plain, "greet", "Certified"))
+    await expect(
+      client.queryClient.fetchQuery(
+        client.queryOptions(certified, "is_replicated")
+      )
+    ).resolves.toBe(true)
+  })
+
+  it("fetches the root key from the local replica, and verifies replies with it (Q4)", async () => {
+    // No rootKey: the host is local, so the client asks the replica for its
+    // key, and the certified reply verifies against it.
+    const fetched = track(createClient({ network, identity: ed25519() }))
+    const hello = fetched.canister<Actor>(actor, {
+      id: replica.canisterId,
+      certified: true,
+    })
+    await expect(hello.greet("root key")).resolves.toBe("Hello, root key!")
+    await expect(hello.increment_by(1n)).resolves.toEqual(expect.any(BigInt))
+
+    // The same replica without the fetch: the agent checks the certificate
+    // against mainnet's key, and the read fails. So the check above is real.
+    const unfetched = track(
+      createClient({
+        network: { host: replica.host, fetchRootKey: false },
+        identity: "anonymous",
+      })
+    )
+    const error = await unfetched
+      .canister<Actor>(actor, { id: replica.canisterId, certified: true })
+      .greet("mainnet key")
+      .then(
+        () => undefined,
+        (e: unknown) => e
+      )
+    // A failed verification, not just any error.
+    expect(isReactorError(error)).toBe(true)
+    expect(error).toMatchObject({
+      kind: "not_delivered",
+      mayHaveExecuted: false,
+    })
+    expect((error as Error).message).toContain("could not be verified")
+  })
+})