@mandujs/core 0.54.32 → 0.55.0-beta.1

package/src/email/__tests__/email.test.ts

@@ -1,355 +1,355 @@
-/**
- * @mandujs/core/email tests
- *
- * Exercises the memory adapter end-to-end (real spool, real timers) and the
- * Resend adapter with a fully injected fetch — we never touch the network.
- * The Resend tests also pin the exact wire format (headers, snake_case body
- * field names) so a future refactor can't silently break the contract.
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-  createMemoryEmailSender,
-  createResendSender,
-  createSmtpSender,
-  _validateMessage,
-  type EmailMessage,
-} from "../index";
-import { _buildResendBody } from "../resend";
-
-// ─── Fixtures ───────────────────────────────────────────────────────────────
-
-const VALID_MSG: EmailMessage = {
-  from: "sender@example.com",
-  to: "user@example.com",
-  subject: "Hello",
-  html: "<p>Hi</p>",
-};
-
-/**
- * Builds a fetch stub that returns a JSON response with the supplied `body`
- * and `status`. Records every call for assertions.
- */
-interface FetchCall {
-  url: string;
-  init: RequestInit;
-}
-function makeFetchStub(options: {
-  status?: number;
-  body?: unknown;
-  rawBody?: string;
-  throwError?: Error;
-}): { fetch: typeof globalThis.fetch; calls: FetchCall[] } {
-  const calls: FetchCall[] = [];
-  const fetchImpl = async (
-    input: URL | RequestInfo,
-    init?: RequestInit,
-  ): Promise<Response> => {
-    calls.push({
-      url: typeof input === "string" ? input : (input as URL).toString(),
-      init: init ?? {},
-    });
-    if (options.throwError) throw options.throwError;
-    const status = options.status ?? 200;
-    const body =
-      options.rawBody !== undefined
-        ? options.rawBody
-        : JSON.stringify(options.body ?? {});
-    return new Response(body, {
-      status,
-      headers: { "Content-Type": "application/json" },
-    });
-  };
-  // Bun's `typeof globalThis.fetch` has a `preconnect` callable property.
-  // Attach a no-op so the stub satisfies the structural type.
-  (fetchImpl as unknown as { preconnect: (url: string) => void }).preconnect =
-    () => {};
-  return { fetch: fetchImpl as unknown as typeof globalThis.fetch, calls };
-}
-
-// ─── Memory adapter ─────────────────────────────────────────────────────────
-
-describe("createMemoryEmailSender", () => {
-  it("stores the message in .sent with id and sentAt", async () => {
-    const sender = createMemoryEmailSender();
-    const result = await sender.send(VALID_MSG);
-    expect(sender.sent.length).toBe(1);
-    expect(sender.sent[0].id).toBe(result.id);
-    expect(sender.sent[0].sentAt).toBe(result.sentAt);
-    expect(sender.sent[0].subject).toBe("Hello");
-    expect(typeof result.id).toBe("string");
-    expect(result.id.length).toBeGreaterThan(0);
-    expect(typeof result.sentAt).toBe("number");
-  });
-
-  it("returns the same id that was stored", async () => {
-    const sender = createMemoryEmailSender();
-    const r1 = await sender.send(VALID_MSG);
-    const r2 = await sender.send(VALID_MSG);
-    expect(sender.sent[0].id).toBe(r1.id);
-    expect(sender.sent[1].id).toBe(r2.id);
-    expect(r1.id).not.toBe(r2.id); // unique per send
-  });
-
-  it("preserves send order across multiple calls", async () => {
-    const sender = createMemoryEmailSender();
-    for (let i = 0; i < 5; i++) {
-      await sender.send({ ...VALID_MSG, subject: `msg-${i}` });
-    }
-    expect(sender.sent.map((m) => m.subject)).toEqual([
-      "msg-0",
-      "msg-1",
-      "msg-2",
-      "msg-3",
-      "msg-4",
-    ]);
-  });
-
-  it("clear() empties the spool", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send(VALID_MSG);
-    await sender.send(VALID_MSG);
-    expect(sender.sent.length).toBe(2);
-    sender.clear();
-    expect(sender.sent.length).toBe(0);
-  });
-
-  it("waitFor(3) resolves after 3 sends", async () => {
-    const sender = createMemoryEmailSender();
-    // Drive the sends on a delay so waitFor actually has to poll.
-    setTimeout(() => {
-      void sender.send(VALID_MSG);
-    }, 5);
-    setTimeout(() => {
-      void sender.send(VALID_MSG);
-    }, 15);
-    setTimeout(() => {
-      void sender.send(VALID_MSG);
-    }, 25);
-    await sender.waitFor(3, 500);
-    expect(sender.sent.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it("waitFor(3, 50) rejects with timeout if fewer than 3 sent in 50ms", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send(VALID_MSG); // only one, not three
-    await expect(sender.waitFor(3, 50)).rejects.toThrow(/waitFor timed out/);
-  });
-
-  it("waitFor() with default args resolves immediately when already satisfied", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send(VALID_MSG);
-    await sender.waitFor(); // default n=1 — already satisfied
-    expect(sender.sent.length).toBe(1);
-  });
-
-  it("send() throws TypeError on missing html AND text", async () => {
-    const sender = createMemoryEmailSender();
-    await expect(
-      sender.send({
-        from: "a@b.com",
-        to: "c@d.com",
-        subject: "x",
-      }),
-    ).rejects.toBeInstanceOf(TypeError);
-  });
-
-  it("send() throws TypeError on empty to array", async () => {
-    const sender = createMemoryEmailSender();
-    await expect(
-      sender.send({ ...VALID_MSG, to: [] }),
-    ).rejects.toThrow(/'to' must be a non-empty/);
-  });
-
-  it("send() accepts a single-string to", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send({ ...VALID_MSG, to: "one@example.com" });
-    expect(sender.sent[0].to).toBe("one@example.com");
-  });
-
-  it("send() accepts an array to", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send({ ...VALID_MSG, to: ["a@x.com", "b@x.com"] });
-    expect(sender.sent[0].to).toEqual(["a@x.com", "b@x.com"]);
-  });
-
-  it("send() accepts display-name from", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send({ ...VALID_MSG, from: "Alice <alice@example.com>" });
-    expect(sender.sent[0].from).toBe("Alice <alice@example.com>");
-  });
-
-  it("send() throws TypeError on malformed from", async () => {
-    const sender = createMemoryEmailSender();
-    await expect(
-      sender.send({ ...VALID_MSG, from: "not-an-email" }),
-    ).rejects.toBeInstanceOf(TypeError);
-  });
-
-  it("send() throws TypeError on empty subject", async () => {
-    const sender = createMemoryEmailSender();
-    await expect(
-      sender.send({ ...VALID_MSG, subject: "" }),
-    ).rejects.toThrow(/subject/);
-  });
-
-  it("send() accepts text-only body", async () => {
-    const sender = createMemoryEmailSender();
-    await sender.send({
-      from: "a@b.com",
-      to: "c@d.com",
-      subject: "plain",
-      text: "hello",
-    });
-    expect(sender.sent[0].text).toBe("hello");
-    expect(sender.sent[0].html).toBeUndefined();
-  });
-
-  it("_validateMessage throws on non-object input", () => {
-    expect(() =>
-      _validateMessage(null as unknown as EmailMessage),
-    ).toThrow(/must be an object/);
-  });
-});
-
-// ─── Resend adapter ─────────────────────────────────────────────────────────
-
-describe("createResendSender", () => {
-  it("requires an apiKey", () => {
-    expect(() => createResendSender({ apiKey: "" })).toThrow(/apiKey/);
-  });
-
-  it("happy path: returns id + sentAt on 2xx", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "resend-123" } });
-    const sender = createResendSender({ apiKey: "re_test", fetch });
-    const result = await sender.send(VALID_MSG);
-    expect(result.id).toBe("resend-123");
-    expect(typeof result.sentAt).toBe("number");
-    expect(calls.length).toBe(1);
-  });
-
-  it("posts with correct headers and JSON body shape", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "id-1" } });
-    const sender = createResendSender({ apiKey: "re_abcdef", fetch });
-    await sender.send({
-      from: "Alice <alice@a.com>",
-      to: "bob@b.com",
-      subject: "hi",
-      html: "<p>hi</p>",
-    });
-    const call = calls[0];
-    expect(call.url).toBe("https://api.resend.com/emails");
-    expect(call.init.method).toBe("POST");
-    const headers = call.init.headers as Record<string, string>;
-    expect(headers.Authorization).toBe("Bearer re_abcdef");
-    expect(headers["Content-Type"]).toBe("application/json");
-    const body = JSON.parse(call.init.body as string);
-    expect(body.from).toBe("Alice <alice@a.com>");
-    expect(body.to).toEqual(["bob@b.com"]);
-    expect(body.subject).toBe("hi");
-    expect(body.html).toBe("<p>hi</p>");
-  });
-
-  it("passes array to through as array", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "id-2" } });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await sender.send({ ...VALID_MSG, to: ["a@x.com", "b@x.com"] });
-    const body = JSON.parse(calls[0].init.body as string);
-    expect(Array.isArray(body.to)).toBe(true);
-    expect(body.to).toEqual(["a@x.com", "b@x.com"]);
-  });
-
-  it("converts replyTo → reply_to (snake_case)", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "id-3" } });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await sender.send({ ...VALID_MSG, replyTo: "reply@x.com" });
-    const body = JSON.parse(calls[0].init.body as string);
-    expect(body.reply_to).toBe("reply@x.com");
-    expect(body.replyTo).toBeUndefined();
-  });
-
-  it("lowercases custom headers", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "id-4" } });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await sender.send({
-      ...VALID_MSG,
-      headers: { "X-Tag": "promo", "X-Campaign": "spring" },
-    });
-    const body = JSON.parse(calls[0].init.body as string);
-    expect(body.headers).toEqual({ "x-tag": "promo", "x-campaign": "spring" });
-  });
-
-  it("throws on non-2xx with status and body excerpt", async () => {
-    const { fetch } = makeFetchStub({
-      status: 422,
-      rawBody: "validation failed: invalid from address",
-    });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await expect(sender.send(VALID_MSG)).rejects.toThrow(/status=422/);
-    await expect(sender.send(VALID_MSG)).rejects.toThrow(/validation failed/);
-  });
-
-  it("throws on network failure with cause context", async () => {
-    const { fetch } = makeFetchStub({
-      throwError: new Error("ECONNRESET"),
-    });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await expect(sender.send(VALID_MSG)).rejects.toThrow(/email send failed/);
-    await expect(sender.send(VALID_MSG)).rejects.toThrow(/ECONNRESET/);
-  });
-
-  it("honors baseUrl override (trailing slash stripped)", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "id-5" } });
-    const sender = createResendSender({
-      apiKey: "k",
-      fetch,
-      baseUrl: "https://private.resend.example.com/",
-    });
-    await sender.send(VALID_MSG);
-    expect(calls[0].url).toBe("https://private.resend.example.com/emails");
-  });
-
-  it("throws when provider response is missing id", async () => {
-    const { fetch } = makeFetchStub({ body: { somethingElse: 1 } });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await expect(sender.send(VALID_MSG)).rejects.toThrow(/missing 'id'/);
-  });
-
-  it("validates message before calling fetch (fast-fail)", async () => {
-    const { fetch, calls } = makeFetchStub({ body: { id: "x" } });
-    const sender = createResendSender({ apiKey: "k", fetch });
-    await expect(
-      sender.send({ ...VALID_MSG, from: "bad" }),
-    ).rejects.toBeInstanceOf(TypeError);
-    expect(calls.length).toBe(0);
-  });
-
-  it("_buildResendBody omits undefined optional fields", () => {
-    const body = _buildResendBody(VALID_MSG);
-    expect(body.text).toBeUndefined();
-    expect(body.cc).toBeUndefined();
-    expect(body.bcc).toBeUndefined();
-    expect(body.reply_to).toBeUndefined();
-    expect(body.headers).toBeUndefined();
-  });
-
-  it("_buildResendBody includes cc/bcc arrays when provided", () => {
-    const body = _buildResendBody({
-      ...VALID_MSG,
-      cc: "c@c.com",
-      bcc: ["d@d.com", "e@e.com"],
-    });
-    expect(body.cc).toEqual(["c@c.com"]);
-    expect(body.bcc).toEqual(["d@d.com", "e@e.com"]);
-  });
-});
-
-// ─── SMTP stub ──────────────────────────────────────────────────────────────
-
-describe("createSmtpSender (stub)", () => {
-  it("throws with the planned-but-not-implemented message", () => {
-    expect(() =>
-      createSmtpSender({ host: "smtp.example.com" }),
-    ).toThrow(/not yet implemented/);
-  });
-});
+/**
+ * @mandujs/core/email tests
+ *
+ * Exercises the memory adapter end-to-end (real spool, real timers) and the
+ * Resend adapter with a fully injected fetch — we never touch the network.
+ * The Resend tests also pin the exact wire format (headers, snake_case body
+ * field names) so a future refactor can't silently break the contract.
+ */
+
+import { describe, it, expect } from "bun:test";
+import {
+  createMemoryEmailSender,
+  createResendSender,
+  createSmtpSender,
+  _validateMessage,
+  type EmailMessage,
+} from "../index";
+import { _buildResendBody } from "../resend";
+
+// ─── Fixtures ───────────────────────────────────────────────────────────────
+
+const VALID_MSG: EmailMessage = {
+  from: "sender@example.com",
+  to: "user@example.com",
+  subject: "Hello",
+  html: "<p>Hi</p>",
+};
+
+/**
+ * Builds a fetch stub that returns a JSON response with the supplied `body`
+ * and `status`. Records every call for assertions.
+ */
+interface FetchCall {
+  url: string;
+  init: RequestInit;
+}
+function makeFetchStub(options: {
+  status?: number;
+  body?: unknown;
+  rawBody?: string;
+  throwError?: Error;
+}): { fetch: typeof globalThis.fetch; calls: FetchCall[] } {
+  const calls: FetchCall[] = [];
+  const fetchImpl = async (
+    input: URL | RequestInfo,
+    init?: RequestInit,
+  ): Promise<Response> => {
+    calls.push({
+      url: typeof input === "string" ? input : (input as URL).toString(),
+      init: init ?? {},
+    });
+    if (options.throwError) throw options.throwError;
+    const status = options.status ?? 200;
+    const body =
+      options.rawBody !== undefined
+        ? options.rawBody
+        : JSON.stringify(options.body ?? {});
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+  // Bun's `typeof globalThis.fetch` has a `preconnect` callable property.
+  // Attach a no-op so the stub satisfies the structural type.
+  (fetchImpl as unknown as { preconnect: (url: string) => void }).preconnect =
+    () => {};
+  return { fetch: fetchImpl as unknown as typeof globalThis.fetch, calls };
+}
+
+// ─── Memory adapter ─────────────────────────────────────────────────────────
+
+describe("createMemoryEmailSender", () => {
+  it("stores the message in .sent with id and sentAt", async () => {
+    const sender = createMemoryEmailSender();
+    const result = await sender.send(VALID_MSG);
+    expect(sender.sent.length).toBe(1);
+    expect(sender.sent[0].id).toBe(result.id);
+    expect(sender.sent[0].sentAt).toBe(result.sentAt);
+    expect(sender.sent[0].subject).toBe("Hello");
+    expect(typeof result.id).toBe("string");
+    expect(result.id.length).toBeGreaterThan(0);
+    expect(typeof result.sentAt).toBe("number");
+  });
+
+  it("returns the same id that was stored", async () => {
+    const sender = createMemoryEmailSender();
+    const r1 = await sender.send(VALID_MSG);
+    const r2 = await sender.send(VALID_MSG);
+    expect(sender.sent[0].id).toBe(r1.id);
+    expect(sender.sent[1].id).toBe(r2.id);
+    expect(r1.id).not.toBe(r2.id); // unique per send
+  });
+
+  it("preserves send order across multiple calls", async () => {
+    const sender = createMemoryEmailSender();
+    for (let i = 0; i < 5; i++) {
+      await sender.send({ ...VALID_MSG, subject: `msg-${i}` });
+    }
+    expect(sender.sent.map((m) => m.subject)).toEqual([
+      "msg-0",
+      "msg-1",
+      "msg-2",
+      "msg-3",
+      "msg-4",
+    ]);
+  });
+
+  it("clear() empties the spool", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send(VALID_MSG);
+    await sender.send(VALID_MSG);
+    expect(sender.sent.length).toBe(2);
+    sender.clear();
+    expect(sender.sent.length).toBe(0);
+  });
+
+  it("waitFor(3) resolves after 3 sends", async () => {
+    const sender = createMemoryEmailSender();
+    // Drive the sends on a delay so waitFor actually has to poll.
+    setTimeout(() => {
+      void sender.send(VALID_MSG);
+    }, 5);
+    setTimeout(() => {
+      void sender.send(VALID_MSG);
+    }, 15);
+    setTimeout(() => {
+      void sender.send(VALID_MSG);
+    }, 25);
+    await sender.waitFor(3, 500);
+    expect(sender.sent.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("waitFor(3, 50) rejects with timeout if fewer than 3 sent in 50ms", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send(VALID_MSG); // only one, not three
+    await expect(sender.waitFor(3, 50)).rejects.toThrow(/waitFor timed out/);
+  });
+
+  it("waitFor() with default args resolves immediately when already satisfied", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send(VALID_MSG);
+    await sender.waitFor(); // default n=1 — already satisfied
+    expect(sender.sent.length).toBe(1);
+  });
+
+  it("send() throws TypeError on missing html AND text", async () => {
+    const sender = createMemoryEmailSender();
+    await expect(
+      sender.send({
+        from: "a@b.com",
+        to: "c@d.com",
+        subject: "x",
+      }),
+    ).rejects.toBeInstanceOf(TypeError);
+  });
+
+  it("send() throws TypeError on empty to array", async () => {
+    const sender = createMemoryEmailSender();
+    await expect(
+      sender.send({ ...VALID_MSG, to: [] }),
+    ).rejects.toThrow(/'to' must be a non-empty/);
+  });
+
+  it("send() accepts a single-string to", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send({ ...VALID_MSG, to: "one@example.com" });
+    expect(sender.sent[0].to).toBe("one@example.com");
+  });
+
+  it("send() accepts an array to", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send({ ...VALID_MSG, to: ["a@x.com", "b@x.com"] });
+    expect(sender.sent[0].to).toEqual(["a@x.com", "b@x.com"]);
+  });
+
+  it("send() accepts display-name from", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send({ ...VALID_MSG, from: "Alice <alice@example.com>" });
+    expect(sender.sent[0].from).toBe("Alice <alice@example.com>");
+  });
+
+  it("send() throws TypeError on malformed from", async () => {
+    const sender = createMemoryEmailSender();
+    await expect(
+      sender.send({ ...VALID_MSG, from: "not-an-email" }),
+    ).rejects.toBeInstanceOf(TypeError);
+  });
+
+  it("send() throws TypeError on empty subject", async () => {
+    const sender = createMemoryEmailSender();
+    await expect(
+      sender.send({ ...VALID_MSG, subject: "" }),
+    ).rejects.toThrow(/subject/);
+  });
+
+  it("send() accepts text-only body", async () => {
+    const sender = createMemoryEmailSender();
+    await sender.send({
+      from: "a@b.com",
+      to: "c@d.com",
+      subject: "plain",
+      text: "hello",
+    });
+    expect(sender.sent[0].text).toBe("hello");
+    expect(sender.sent[0].html).toBeUndefined();
+  });
+
+  it("_validateMessage throws on non-object input", () => {
+    expect(() =>
+      _validateMessage(null as unknown as EmailMessage),
+    ).toThrow(/must be an object/);
+  });
+});
+
+// ─── Resend adapter ─────────────────────────────────────────────────────────
+
+describe("createResendSender", () => {
+  it("requires an apiKey", () => {
+    expect(() => createResendSender({ apiKey: "" })).toThrow(/apiKey/);
+  });
+
+  it("happy path: returns id + sentAt on 2xx", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "resend-123" } });
+    const sender = createResendSender({ apiKey: "re_test", fetch });
+    const result = await sender.send(VALID_MSG);
+    expect(result.id).toBe("resend-123");
+    expect(typeof result.sentAt).toBe("number");
+    expect(calls.length).toBe(1);
+  });
+
+  it("posts with correct headers and JSON body shape", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "id-1" } });
+    const sender = createResendSender({ apiKey: "re_abcdef", fetch });
+    await sender.send({
+      from: "Alice <alice@a.com>",
+      to: "bob@b.com",
+      subject: "hi",
+      html: "<p>hi</p>",
+    });
+    const call = calls[0];
+    expect(call.url).toBe("https://api.resend.com/emails");
+    expect(call.init.method).toBe("POST");
+    const headers = call.init.headers as Record<string, string>;
+    expect(headers.Authorization).toBe("Bearer re_abcdef");
+    expect(headers["Content-Type"]).toBe("application/json");
+    const body = JSON.parse(call.init.body as string);
+    expect(body.from).toBe("Alice <alice@a.com>");
+    expect(body.to).toEqual(["bob@b.com"]);
+    expect(body.subject).toBe("hi");
+    expect(body.html).toBe("<p>hi</p>");
+  });
+
+  it("passes array to through as array", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "id-2" } });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await sender.send({ ...VALID_MSG, to: ["a@x.com", "b@x.com"] });
+    const body = JSON.parse(calls[0].init.body as string);
+    expect(Array.isArray(body.to)).toBe(true);
+    expect(body.to).toEqual(["a@x.com", "b@x.com"]);
+  });
+
+  it("converts replyTo → reply_to (snake_case)", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "id-3" } });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await sender.send({ ...VALID_MSG, replyTo: "reply@x.com" });
+    const body = JSON.parse(calls[0].init.body as string);
+    expect(body.reply_to).toBe("reply@x.com");
+    expect(body.replyTo).toBeUndefined();
+  });
+
+  it("lowercases custom headers", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "id-4" } });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await sender.send({
+      ...VALID_MSG,
+      headers: { "X-Tag": "promo", "X-Campaign": "spring" },
+    });
+    const body = JSON.parse(calls[0].init.body as string);
+    expect(body.headers).toEqual({ "x-tag": "promo", "x-campaign": "spring" });
+  });
+
+  it("throws on non-2xx with status and body excerpt", async () => {
+    const { fetch } = makeFetchStub({
+      status: 422,
+      rawBody: "validation failed: invalid from address",
+    });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await expect(sender.send(VALID_MSG)).rejects.toThrow(/status=422/);
+    await expect(sender.send(VALID_MSG)).rejects.toThrow(/validation failed/);
+  });
+
+  it("throws on network failure with cause context", async () => {
+    const { fetch } = makeFetchStub({
+      throwError: new Error("ECONNRESET"),
+    });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await expect(sender.send(VALID_MSG)).rejects.toThrow(/email send failed/);
+    await expect(sender.send(VALID_MSG)).rejects.toThrow(/ECONNRESET/);
+  });
+
+  it("honors baseUrl override (trailing slash stripped)", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "id-5" } });
+    const sender = createResendSender({
+      apiKey: "k",
+      fetch,
+      baseUrl: "https://private.resend.example.com/",
+    });
+    await sender.send(VALID_MSG);
+    expect(calls[0].url).toBe("https://private.resend.example.com/emails");
+  });
+
+  it("throws when provider response is missing id", async () => {
+    const { fetch } = makeFetchStub({ body: { somethingElse: 1 } });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await expect(sender.send(VALID_MSG)).rejects.toThrow(/missing 'id'/);
+  });
+
+  it("validates message before calling fetch (fast-fail)", async () => {
+    const { fetch, calls } = makeFetchStub({ body: { id: "x" } });
+    const sender = createResendSender({ apiKey: "k", fetch });
+    await expect(
+      sender.send({ ...VALID_MSG, from: "bad" }),
+    ).rejects.toBeInstanceOf(TypeError);
+    expect(calls.length).toBe(0);
+  });
+
+  it("_buildResendBody omits undefined optional fields", () => {
+    const body = _buildResendBody(VALID_MSG);
+    expect(body.text).toBeUndefined();
+    expect(body.cc).toBeUndefined();
+    expect(body.bcc).toBeUndefined();
+    expect(body.reply_to).toBeUndefined();
+    expect(body.headers).toBeUndefined();
+  });
+
+  it("_buildResendBody includes cc/bcc arrays when provided", () => {
+    const body = _buildResendBody({
+      ...VALID_MSG,
+      cc: "c@c.com",
+      bcc: ["d@d.com", "e@e.com"],
+    });
+    expect(body.cc).toEqual(["c@c.com"]);
+    expect(body.bcc).toEqual(["d@d.com", "e@e.com"]);
+  });
+});
+
+// ─── SMTP stub ──────────────────────────────────────────────────────────────
+
+describe("createSmtpSender (stub)", () => {
+  it("throws with the planned-but-not-implemented message", () => {
+    expect(() =>
+      createSmtpSender({ host: "smtp.example.com" }),
+    ).toThrow(/not yet implemented/);
+  });
+});