@crewhaus/channel-adapter-discord 0.1.3 → 0.1.5

package/src/index.test.ts

@@ -1,343 +0,0 @@
-import { beforeAll, describe, expect, test } from "bun:test";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-import {
-  type ChannelAdapter,
-  DiscordAdapterError,
-  type InboundEvent,
-  type ParsedInbound,
-  type RawRequest,
-  createDiscordAdapter,
-  generateEd25519Keypair,
-  signDiscordBody,
-  verifyDiscordSignature,
-} from "./index";
-
-// `tsc -b` also compiles this file into `dist/`; resolve fixtures from the
-// source tree so both the src and dist test copies find them.
-const FIXTURES_DIR = join(import.meta.dir.replace(/([/\\])dist$/, "$1src"), "fixtures");
-const fixture = (name: string) => readFileSync(join(FIXTURES_DIR, `${name}.json`), "utf8");
-
-let publicKeyHex: string;
-let privateKeyPem: string;
-let otherPublicKeyHex: string;
-
-beforeAll(() => {
-  const k = generateEd25519Keypair();
-  publicKeyHex = k.publicKeyHex;
-  privateKeyPem = k.privateKeyPem;
-  otherPublicKeyHex = generateEd25519Keypair().publicKeyHex;
-});
-
-function signedHeaders(body: string, ts: string | number = Math.floor(Date.now() / 1000)): Headers {
-  const sig = signDiscordBody({ body, timestamp: ts, privateKeyPem });
-  const h = new Headers();
-  h.set("X-Signature-Ed25519", sig);
-  h.set("X-Signature-Timestamp", String(ts));
-  return h;
-}
-
-function adapter(
-  overrides: Partial<{ publicKeyHex: string; fetch: typeof fetch }> = {},
-): ChannelAdapter {
-  return createDiscordAdapter(
-    {
-      applicationId: "200000000000000001",
-      botToken: "Bot.token",
-      publicKeyHex: overrides.publicKeyHex ?? publicKeyHex,
-    },
-    {
-      apiBaseUrl: "https://test.discord.local",
-      ...(overrides.fetch ? { fetch: overrides.fetch } : {}),
-    },
-  );
-}
-
-describe("verifyDiscordSignature (T8)", () => {
-  test("matches a valid signature", () => {
-    const body = fixture("ping");
-    const r = verifyDiscordSignature({
-      headers: signedHeaders(body),
-      body,
-      publicKeyHex,
-    });
-    expect(r).toBe(true);
-  });
-
-  test("rejects a tampered body", () => {
-    const body = fixture("ping");
-    const headers = signedHeaders(body);
-    expect(
-      verifyDiscordSignature({
-        headers,
-        body: `${body}--tampered`,
-        publicKeyHex,
-      }),
-    ).toBe(false);
-  });
-
-  test("rejects wrong public key", () => {
-    const body = fixture("ping");
-    expect(
-      verifyDiscordSignature({
-        headers: signedHeaders(body),
-        body,
-        publicKeyHex: otherPublicKeyHex,
-      }),
-    ).toBe(false);
-  });
-
-  test("rejects missing X-Signature-Ed25519 header", () => {
-    const body = fixture("ping");
-    const headers = signedHeaders(body);
-    headers.delete("X-Signature-Ed25519");
-    expect(verifyDiscordSignature({ headers, body, publicKeyHex })).toBe(false);
-  });
-
-  test("rejects missing X-Signature-Timestamp header", () => {
-    const body = fixture("ping");
-    const headers = signedHeaders(body);
-    headers.delete("X-Signature-Timestamp");
-    expect(verifyDiscordSignature({ headers, body, publicKeyHex })).toBe(false);
-  });
-
-  test("rejects malformed sig hex (wrong length)", () => {
-    const body = fixture("ping");
-    const headers = new Headers({
-      "X-Signature-Ed25519": "deadbeef",
-      "X-Signature-Timestamp": "1700000000",
-    });
-    expect(verifyDiscordSignature({ headers, body, publicKeyHex })).toBe(false);
-  });
-
-  test("rejects non-numeric timestamp", () => {
-    const body = fixture("ping");
-    const headers = signedHeaders(body, "abc");
-    expect(verifyDiscordSignature({ headers, body, publicKeyHex })).toBe(false);
-  });
-
-  // SECURITY: the timestamp is signed but was never checked against the clock,
-  // so a captured interaction replayed indefinitely (after a daemon restart or
-  // LRU dedup eviction). Reject stale/future timestamps, mirroring Slack.
-  test("rejects an expired timestamp (replay window)", () => {
-    const body = fixture("ping");
-    const oldTs = Math.floor(Date.now() / 1000) - 10 * 60; // 10 minutes ago
-    expect(
-      verifyDiscordSignature({ headers: signedHeaders(body, oldTs), body, publicKeyHex }),
-    ).toBe(false);
-  });
-
-  test("rejects a future timestamp", () => {
-    const body = fixture("ping");
-    const futureTs = Math.floor(Date.now() / 1000) + 10 * 60;
-    expect(
-      verifyDiscordSignature({ headers: signedHeaders(body, futureTs), body, publicKeyHex }),
-    ).toBe(false);
-  });
-
-  test("a stale-but-validly-signed triple verifies when now() is pinned (gate is freshness, not signature)", () => {
-    const body = fixture("ping");
-    const ts = 1700000000;
-    const headers = signedHeaders(body, ts);
-    expect(verifyDiscordSignature({ headers, body, publicKeyHex }, { now: () => ts * 1000 })).toBe(
-      true,
-    );
-  });
-
-  test("rejects malformed publicKeyHex", () => {
-    const body = fixture("ping");
-    expect(
-      verifyDiscordSignature({
-        headers: signedHeaders(body),
-        body,
-        publicKeyHex: "not-hex",
-      }),
-    ).toBe(false);
-  });
-});
-
-describe("parseInbound — fixtures (T2)", () => {
-  test("ping → challenge with PONG body", () => {
-    const a = adapter();
-    const body = fixture("ping");
-    const r = a.parseInbound({ headers: signedHeaders(body), body });
-    expect(r.kind).toBe("challenge");
-    if (r.kind === "challenge") {
-      expect(JSON.parse(r.challenge)).toEqual({ type: 1 });
-    }
-  });
-
-  test("slash_command_basic → event with text /<name>", () => {
-    const a = adapter();
-    const body = fixture("slash_command_basic");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.kind).toBe("event");
-    expect(r.event.text).toBe("/ping");
-    expect(r.event.channelId).toBe("300000000000000001");
-    expect(r.event.userId).toBe("500000000000000001");
-    expect(r.event.workspaceId).toBe("400000000000000001");
-    expect(r.event.threadTs).toBeUndefined();
-  });
-
-  test("slash_command_with_options → text encodes name=value pairs", () => {
-    const a = adapter();
-    const body = fixture("slash_command_with_options");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.event.text).toBe("/summarize url=https://example.com depth=3");
-  });
-
-  test("slash_command_thread → channelId is thread id, threadTs set", () => {
-    const a = adapter();
-    const body = fixture("slash_command_thread");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.event.channelId).toBe("300000000000000099");
-    expect(r.event.threadTs).toBe("300000000000000099");
-  });
-
-  test('slash_command_dm → workspaceId is "dm", user.id used', () => {
-    const a = adapter();
-    const body = fixture("slash_command_dm");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.event.workspaceId).toBe("dm");
-    expect(r.event.userId).toBe("500000000000000007");
-  });
-
-  test("component_button → text [component:<custom_id>]", () => {
-    const a = adapter();
-    const body = fixture("component_button");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.event.text).toBe("[component:approve:doc-123]");
-  });
-
-  test("modal_submit → text encodes form fields", () => {
-    const a = adapter();
-    const body = fixture("modal_submit");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.event.text).toBe("feedback-form: rating=5 comment=loved it");
-  });
-
-  test("unknown_type → skip", () => {
-    const a = adapter();
-    const body = fixture("unknown_type");
-    const r = a.parseInbound({ headers: signedHeaders(body), body });
-    expect(r.kind).toBe("skip");
-  });
-
-  test("missing_user → skip", () => {
-    const a = adapter();
-    const body = fixture("missing_user");
-    const r = a.parseInbound({ headers: signedHeaders(body), body });
-    expect(r.kind).toBe("skip");
-  });
-
-  test("malformed JSON → skip", () => {
-    const a = adapter();
-    const r = a.parseInbound({ headers: new Headers(), body: "not json{" });
-    expect(r.kind).toBe("skip");
-  });
-
-  test("idempotencyKey == interaction id", () => {
-    const a = adapter();
-    const body = fixture("slash_command_basic");
-    const r = a.parseInbound({ headers: signedHeaders(body), body }) as Extract<
-      ParsedInbound,
-      { kind: "event" }
-    >;
-    expect(r.event.idempotencyKey).toBe("100000000000000002");
-  });
-});
-
-describe("sendReply / setTyping (T3)", () => {
-  function captureFetch() {
-    const calls: Array<{ url: string; init: RequestInit }> = [];
-    const f = (async (input: string | Request | URL, init?: RequestInit) => {
-      calls.push({ url: String(input), init: init ?? {} });
-      return new Response("", { status: 204 });
-    }) as unknown as typeof fetch;
-    return { calls, fetch: f };
-  }
-
-  const event: InboundEvent = {
-    idempotencyKey: "100000000000000002",
-    workspaceId: "400000000000000001",
-    channelId: "300000000000000001",
-    userId: "500000000000000001",
-    ts: "100000000000000002",
-    text: "/ping",
-    subtype: "message",
-  };
-
-  test("sendReply POSTs /channels/{channelId}/messages with content", async () => {
-    const { calls, fetch: f } = captureFetch();
-    const a = adapter({ fetch: f });
-    await a.sendReply({ event, text: "pong" });
-    expect(calls.length).toBe(1);
-    expect(calls[0]?.url).toBe("https://test.discord.local/channels/300000000000000001/messages");
-    const body = JSON.parse(String(calls[0]?.init.body));
-    expect(body.content).toBe("pong");
-    const auth = (calls[0]?.init.headers as Record<string, string> | undefined)?.["Authorization"];
-    expect(auth).toBe("Bot Bot.token");
-  });
-
-  test("sendReply throws DiscordAdapterError on HTTP error", async () => {
-    const f = (async () =>
-      new Response("server fail", {
-        status: 500,
-        statusText: "Internal",
-      })) as unknown as typeof fetch;
-    const a = adapter({ fetch: f });
-    await expect(a.sendReply({ event, text: "x" })).rejects.toThrow(DiscordAdapterError);
-  });
-
-  test("setTyping POSTs /channels/{channelId}/typing", async () => {
-    const { calls, fetch: f } = captureFetch();
-    const a = adapter({ fetch: f });
-    await a.setTyping({ event });
-    expect(calls.length).toBe(1);
-    expect(calls[0]?.url).toBe("https://test.discord.local/channels/300000000000000001/typing");
-  });
-
-  test("setTyping swallows network rejection (best-effort)", async () => {
-    // A failed typing indicator must never reject and break the reply flow.
-    const f = (async () => {
-      throw new Error("network down");
-    }) as unknown as typeof fetch;
-    const a = adapter({ fetch: f });
-    await expect(a.setTyping({ event })).resolves.toBeUndefined();
-  });
-
-  test("setTyping ignores non-2xx responses (best-effort)", async () => {
-    const f = (async () =>
-      new Response("nope", { status: 500, statusText: "Internal" })) as unknown as typeof fetch;
-    const a = adapter({ fetch: f });
-    await expect(a.setTyping({ event })).resolves.toBeUndefined();
-  });
-});
-
-describe("createDiscordAdapter.verify()", () => {
-  test("forwards to verifyDiscordSignature", () => {
-    const a = adapter();
-    const body = fixture("ping");
-    expect(a.verify({ headers: signedHeaders(body), body })).toBe(true);
-    expect(a.verify({ headers: new Headers(), body })).toBe(false);
-  });
-});

package/src/index.ts

@@ -1,272 +0,0 @@
-/**
- * @crewhaus/channel-adapter-discord — Discord channel adapter for the
- * channel target (Section 33).
- *
- * Discord's interaction model is request/response: the bot is invoked
- * via slash commands (interaction type 2), button clicks (type 3), and
- * modal submits (type 5). Each request is Ed25519-signed via
- * `X-Signature-Ed25519` + `X-Signature-Timestamp`.
- *
- * Discord requires the bot to respond *to the request itself* — the
- * gateway POSTs the interaction-response body back. For backward
- * compatibility with the channel adapter contract, `sendReply` instead
- * uses Discord's "follow-up message" API (`POST /webhooks/{appId}/{token}`)
- * which works at any time after the initial deferred response.
- *
- * Thread session keying uses Discord's native `thread_id` when present
- * (forum / public thread / archived thread); otherwise the channel id.
- */
-import { CrewhausError } from "@crewhaus/errors";
-import { verifyDiscordSignature } from "./verify.js";
-
-export {
-  generateEd25519Keypair,
-  signDiscordBody,
-  verifyDiscordSignature,
-} from "./verify.js";
-
-export class DiscordAdapterError extends CrewhausError {
-  override readonly name = "DiscordAdapterError";
-  constructor(message: string, cause?: unknown) {
-    super("channel", message, cause);
-  }
-}
-
-export type RawRequest = {
-  readonly headers: Headers;
-  readonly body: string;
-};
-
-/**
- * Channel-generic inbound event. Same shape as Slack/Telegram:
- *
- * Mappings:
- *   - workspaceId   → guild_id (or "dm" when not in a guild)
- *   - channelId     → channel_id
- *   - userId        → user.id (or member.user.id in guild context)
- *   - threadTs      → channel_id when the channel is a thread
- *   - ts            → interaction id (snowflake; monotonic-ish)
- *   - text          → command-name + options for slash commands;
- *                     custom_id for component clicks; modal field values
- *                     joined for modal submits
- *   - subtype       → "message" | "app_mention"
- *   - idempotencyKey → interaction id (Discord doesn't redeliver, but we
- *                      surface the id so the gateway dedups consistently)
- */
-export type InboundEvent = {
-  readonly idempotencyKey: string;
-  readonly workspaceId: string;
-  readonly channelId: string;
-  readonly userId: string;
-  readonly threadTs?: string;
-  readonly ts: string;
-  readonly text: string;
-  readonly subtype: "app_mention" | "message";
-};
-
-export type ParsedInbound =
-  | { readonly kind: "event"; readonly event: InboundEvent }
-  /**
-   * Discord pings every interactions endpoint with a `type:1` PING that
-   * must be answered with `type:1` PONG before any real interactions
-   * arrive. The gateway responds with the canned PONG body.
-   */
-  | { readonly kind: "challenge"; readonly challenge: string }
-  | { readonly kind: "skip" };
-
-export interface ChannelAdapter {
-  readonly id: string;
-  verify(req: RawRequest): boolean;
-  parseInbound(req: RawRequest): ParsedInbound;
-  sendReply(args: { event: InboundEvent; text: string }): Promise<void>;
-  setTyping(args: { event: InboundEvent }): Promise<void>;
-}
-
-export type DiscordAdapterConfig = {
-  /** Application id (snowflake). Used by the follow-up webhook URL. */
-  readonly applicationId: string;
-  /** Bot user token — used to authorize follow-up REST calls. */
-  readonly botToken: string;
-  /** Public key (hex, 64 chars) for Ed25519 verification. */
-  readonly publicKeyHex: string;
-};
-
-export type DiscordAdapterOptions = {
-  readonly apiBaseUrl?: string;
-  readonly fetch?: typeof fetch;
-  /** Clock injection for the signature replay-window check (tests). */
-  readonly now?: () => number;
-};
-
-const DEFAULT_API_BASE_URL = "https://discord.com/api/v10";
-const PONG_RESPONSE_BODY = JSON.stringify({ type: 1 });
-
-export function createDiscordAdapter(
-  config: DiscordAdapterConfig,
-  opts: DiscordAdapterOptions = {},
-): ChannelAdapter {
-  const apiBaseUrl = opts.apiBaseUrl ?? process.env["DISCORD_API_BASE_URL"] ?? DEFAULT_API_BASE_URL;
-  const doFetch = opts.fetch ?? fetch;
-
-  return {
-    id: "discord",
-
-    verify(req: RawRequest): boolean {
-      return verifyDiscordSignature(
-        {
-          headers: req.headers,
-          body: req.body,
-          publicKeyHex: config.publicKeyHex,
-        },
-        opts.now !== undefined ? { now: opts.now } : {},
-      );
-    },
-
-    parseInbound(req: RawRequest): ParsedInbound {
-      let payload: unknown;
-      try {
-        payload = JSON.parse(req.body);
-      } catch {
-        return { kind: "skip" };
-      }
-      if (typeof payload !== "object" || payload === null) return { kind: "skip" };
-      const p = payload as DiscordInteraction;
-
-      // PING → PONG handshake (Discord's URL-verification analogue).
-      if (p.type === 1) {
-        return { kind: "challenge", challenge: PONG_RESPONSE_BODY };
-      }
-
-      // We handle types 2 (slash command), 3 (component click), 5 (modal submit).
-      if (p.type !== 2 && p.type !== 3 && p.type !== 5) {
-        return { kind: "skip" };
-      }
-      const interactionId = p.id;
-      const channelId = p.channel_id;
-      const userId = p.member?.user?.id ?? p.user?.id;
-      if (!interactionId || !channelId || !userId) return { kind: "skip" };
-
-      const workspaceId = p.guild_id ?? "dm";
-      // Threads: in Discord a "thread" is a Channel with `parent_id` set
-      // and type 11 (public thread) / 12 (private thread) / 10 (news
-      // thread). The interaction.channel object includes `parent_id` when
-      // the interaction is in a thread.
-      const isThread = typeof p.channel?.parent_id === "string" && p.channel.parent_id.length > 0;
-      const threadTs = isThread ? channelId : undefined;
-
-      const text = renderInteractionText(p);
-
-      const event: InboundEvent = {
-        idempotencyKey: interactionId,
-        workspaceId,
-        channelId,
-        userId,
-        ...(threadTs !== undefined ? { threadTs } : {}),
-        ts: interactionId,
-        text,
-        subtype: "message",
-      };
-      return { kind: "event", event };
-    },
-
-    async sendReply(args: { event: InboundEvent; text: string }): Promise<void> {
-      // Use Discord's interaction follow-up endpoint:
-      //   POST /webhooks/{application.id}/{interaction.token}
-      // The interaction.token isn't part of `InboundEvent`; in practice the
-      // gateway should call `interaction.respond({type:5, data: {...}})`
-      // synchronously to defer, then we follow up via this REST call. For
-      // the v0 channel-bot daemon we use the application's webhook channel
-      // POST as a fallback so the message reaches the channel even without
-      // the interaction token (slightly different rendering — no
-      // ephemeral, no per-user replies).
-      const url = `${apiBaseUrl}/channels/${args.event.channelId}/messages`;
-      const res = await doFetch(url, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bot ${config.botToken}`,
-        },
-        body: JSON.stringify({ content: args.text }),
-      });
-      if (!res.ok) {
-        throw new DiscordAdapterError(
-          `channels/${args.event.channelId}/messages failed: ${res.status} ${res.statusText}`,
-        );
-      }
-    },
-
-    async setTyping(args: { event: InboundEvent }): Promise<void> {
-      const url = `${apiBaseUrl}/channels/${args.event.channelId}/typing`;
-      // Best-effort — do not surface failures. A failed typing indicator must
-      // never reject and break the caller's reply flow, so we swallow both
-      // network rejections (DNS/abort/connection) and non-2xx responses.
-      try {
-        await doFetch(url, {
-          method: "POST",
-          headers: {
-            Authorization: `Bot ${config.botToken}`,
-          },
-        });
-      } catch {
-        // ignore — typing indicator is non-essential.
-      }
-    },
-  };
-}
-
-/** Reduce an interaction payload to a single text body for the agent. */
-function renderInteractionText(p: DiscordInteraction): string {
-  if (p.type === 2) {
-    // Slash command: render as `/<name> <option1=value1> <option2=value2>`
-    const cmd = p.data?.name ?? "?";
-    const opts = (p.data?.options ?? [])
-      .map((o) => `${o.name}=${stringifyOption(o.value)}`)
-      .join(" ");
-    return opts ? `/${cmd} ${opts}` : `/${cmd}`;
-  }
-  if (p.type === 3) {
-    // Component click: `[component:<custom_id>]`
-    return `[component:${p.data?.custom_id ?? ""}]`;
-  }
-  if (p.type === 5) {
-    // Modal submit: render as `<custom_id>: field1=value1 field2=value2`
-    const id = p.data?.custom_id ?? "";
-    const fields = (p.data?.components ?? [])
-      .flatMap((row) => row.components ?? [])
-      .map((c) => `${c.custom_id ?? "?"}=${c.value ?? ""}`)
-      .join(" ");
-    return `${id}: ${fields}`;
-  }
-  return "";
-}
-
-function stringifyOption(v: unknown): string {
-  if (v === null || v === undefined) return "";
-  if (typeof v === "string") return v;
-  return JSON.stringify(v);
-}
-
-// ─── Minimal Discord interaction shape (no SDK) ──────────────────────────────
-
-export type DiscordInteraction = {
-  readonly id: string;
-  readonly application_id?: string;
-  readonly type: number;
-  readonly token?: string;
-  readonly channel_id?: string;
-  readonly guild_id?: string;
-  readonly user?: { readonly id: string; readonly username?: string };
-  readonly member?: { readonly user?: { readonly id: string; readonly username?: string } };
-  readonly channel?: { readonly id?: string; readonly parent_id?: string };
-  readonly data?: {
-    readonly name?: string;
-    readonly custom_id?: string;
-    readonly options?: ReadonlyArray<{ readonly name: string; readonly value?: unknown }>;
-    readonly components?: ReadonlyArray<{
-      readonly components?: ReadonlyArray<{
-        readonly custom_id?: string;
-        readonly value?: string;
-      }>;
-    }>;
-  };
-};

package/src/verify.crypto-throw.test.ts

@@ -1,61 +0,0 @@
-/**
- * Isolated test for the defensive `catch` around Node's `crypto.verify` in
- * `verifyDiscordSignature`.
- *
- * With a valid Ed25519 key and a 64-byte signature, OpenSSL's `verify` returns
- * `false` rather than throwing, so the catch is unreachable through ordinary
- * inputs. It is still legitimate defensive code: `crypto.verify(null, …)` can
- * throw `ERR_OSSL_*` for unexpected key/state combinations. We exercise it by
- * stubbing `node:crypto.verify` to throw and asserting the function degrades to
- * `false` instead of propagating.
- *
- * `mock.module` mutates the module registry for the REST OF THE PROCESS —
- * `bun test` runs every test file in one process and does NOT give each file
- * a fresh module graph, and file execution order is nondeterministic. If this
- * file runs before `index.test.ts` without the `afterAll` restore below, the
- * throwing stub leaks into it and every valid-signature test fails (observed
- * intermittently in CI). The restore is load-bearing; keep it.
- */
-import { afterAll, expect, mock, test } from "bun:test";
-
-const realCrypto = require("node:crypto") as typeof import("node:crypto");
-
-mock.module("node:crypto", () => ({
-  ...realCrypto,
-  // Force the verification path to throw the way OpenSSL can under
-  // unexpected conditions (e.g. ERR_OSSL_NO_DEFAULT_DIGEST).
-  verify: () => {
-    throw new Error("ERR_OSSL synthetic failure");
-  },
-}));
-
-afterAll(() => {
-  // Bun has no mock.module restore API; re-mocking with the real exports is
-  // the documented way to undo a module mock. This updates live bindings in
-  // already-loaded importers (verify.ts), so files that run after this one
-  // see the real `crypto.verify` again.
-  mock.module("node:crypto", () => realCrypto);
-});
-
-// Import the module under test *after* the stub is registered so its
-// `import { verify } from "node:crypto"` binding resolves to the stub.
-const { verifyDiscordSignature, generateEd25519Keypair, signDiscordBody } = await import(
-  "./verify.js"
-);
-
-test("verifyDiscordSignature returns false when crypto.verify throws", () => {
-  // Keypair generation + signing still use the real crypto (spread above).
-  const { publicKeyHex, privateKeyPem } = generateEd25519Keypair();
-  const body = JSON.stringify({ type: 1 });
-  const timestamp = "1700000000";
-  const sig = signDiscordBody({ body, timestamp, privateKeyPem });
-
-  const headers = new Headers();
-  headers.set("X-Signature-Ed25519", sig);
-  headers.set("X-Signature-Timestamp", timestamp);
-
-  // Every guard (hex regex, timestamp regex, 64-byte length, public-key
-  // construction) passes, so control reaches the `verify(...)` call — which
-  // now throws — and the catch must convert it to a clean `false`.
-  expect(verifyDiscordSignature({ headers, body, publicKeyHex })).toBe(false);
-});