@nxgt/mail 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Steve Tsala
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,341 @@
+# @nxgt/mail
+
+The run-time side of transactional e-mail: the renderer that fills a Maizzle
+build made with `@nxgt/mail-i18n`, the `Mailer` port a transport implements,
+the shape it sends, the two errors it throws, a memory transport for tests, and
+locale selection. **No dependency.**
+
+```ts
+import { createMemoryMailer } from '@nxgt/mail';
+import { createMailRenderer } from '@nxgt/mail/renderer';
+
+const mails = createMailRenderer({ dir: 'dist' }); // the folder `maizzle build` wrote
+const mailer = createMemoryMailer(); // in production, a transport's mailer — see below
+
+const { messageId } = await mailer.send({
+	to: { name: 'Ada Lovelace', address: 'ada@example.com' },
+	from: 'noreply@example.com',
+	...mails.render('verify-email', { name: 'Ada', link: 'https://app.example.com/verify?token=abc' }),
+}); // 'memory-1' — or it throws
+```
+
+In production, `mailer` comes from a transport:
+[`@nxgt/mail-smtp`](https://github.com/softistx/nxgt-mail/tree/develop/packages/mail-smtp)
+on your nodemailer, or
+[`@nxgt/mail-resend`](https://github.com/softistx/nxgt-mail/tree/develop/packages/mail-resend)
+over `fetch`.
+
+> **0.x.** A minor version may still change the surface; the changelog says how.
+
+## Install
+
+```sh
+bun add @nxgt/mail
+```
+
+No runtime dependency. `typescript` (6) is a required peer. Your tsconfig
+resolves as a bundler does (`"moduleResolution": "bundler"`): the declarations
+import without extensions, so `nodenext` is not supported.
+
+## Subpaths
+
+| Import | What it holds |
+| --- | --- |
+| `@nxgt/mail` | The port (`Mailer`, `MailMessage`, `Rendered`, `SentMail`, `Address`), the errors (`MailError`, `MailFailure`, `MailRefused`), `createMemoryMailer`, `pickLocale` and `parseAcceptLanguage`, and what a transport calls first: `checkMessage`, `recipientsOf`, `addressOf`. No Node built-in: it runs anywhere |
+| `@nxgt/mail/renderer` | The renderer: `createMailRenderer`, `MailRenderer`, `MailRendererOptions`, `RenderOptions`, `MailVariables`, and the types that type it with a build's `MailEmails` (`MailEmailsOf`, `AnyMailEmails`, `RenderArguments`). Reads the build with `node:fs` |
+| `@nxgt/mail/conformance` | **For transport authors**: `describeMailer`, its cases as data, `runMailerCase`, and the memory mailer's harness as a worked example |
+
+## Usage
+
+### Rendering — `createMailRenderer`
+
+Build the project with `maizzle build` and the `i18n()` plugin of
+`@nxgt/mail-i18n`, deploy its output folder with your server, and create one
+renderer at start-up. It reads `mail-manifest.json` and every built file once,
+so a missing build fails there, not at the first send:
+
+```ts
+import { type Mailer, pickLocale } from '@nxgt/mail';
+import { createMailRenderer } from '@nxgt/mail/renderer';
+import type { MailEmails } from './generated/mail'; // written by the build, committed
+
+export const mails = createMailRenderer<MailEmails>({ dir: 'dist' }); // throws now if dist/ is missing
+
+export async function sendVerification(
+	mailer: Mailer,
+	user: { email: string; name: string; locale: string | null },
+	link: string,
+): Promise<void> {
+	const locale = pickLocale(user.locale, mails.locales, 'en'); // 'fr-CA' renders 'fr'
+	await mailer.send({ to: user.email, ...mails.render('verify-email', { name: user.name, link }, { locale }) });
+}
+```
+
+Each value is HTML-escaped in `html` and written as is in `text` and the
+subject; line breaks in the subject become a space. A variable that starts an
+`href` or a `src` must be an `http:`, `https:` or `mailto:` URL, or `render`
+throws `MailRefused`. A missing or unknown variable, e-mail or locale throws an
+`Error`.
+
+`<MailEmails>` is optional. `@nxgt/mail-i18n` writes it after each build, in
+`generated/mail.ts`, from the manifest; commit it. With it, the compiler
+refuses what `render` would throw: an e-mail the build does not have, a
+variable missing or unknown, and a number for a URL variable, as
+`Argument of type '"verify-emial"' is not assignable to parameter of type
+'"sign-in-code" | "verify-email"'`. Without it, any name and any
+`MailVariables` compile, and the same mistakes throw at run time. See
+[Rendering](docs/guide/rendering.md) for the options, typing the renderer,
+the locale chosen through `getLanguage`, and every error.
+
+### Sending — the port and `MailMessage`
+
+A `MailMessage` is a rendered e-mail — `subject`, `html`, `text` — plus its
+addresses. `Rendered` is what `mails.render(…)` answers, and any function
+answering the same shape fits, so an e-mail can also be written by hand:
+
+```ts
+import type { Mailer, Rendered, SentMail } from '@nxgt/mail';
+
+function passwordChanged(): Rendered {
+	return {
+		subject: 'Your password was changed',
+		html: '<p>Your password was changed. If it was not you, reset it now.</p>',
+		text: 'Your password was changed. If it was not you, reset it now.',
+	};
+}
+
+export function notifyPasswordChanged(mailer: Mailer, to: string): Promise<SentMail> {
+	return mailer.send({
+		...passwordChanged(),
+		to,
+		replyTo: { name: 'Support', address: 'support@example.com' },
+		headers: { 'X-Entity-Ref-ID': 'password-changed' },
+	});
+}
+```
+
+`SentMail` is `{ messageId: string | null }`: `null` when the transport gives no
+id — an absence, not a failure. See [Sending](docs/guide/sending.md).
+
+### Errors — switch on `code`
+
+Both errors extend `MailError`, whose `code` is a union a `switch` exhausts.
+`MailError` is abstract: catch it, but throw `MailFailure` or `MailRefused`.
+
+```ts
+import { MailError, type MailErrorCode, type Mailer, type MailMessage } from '@nxgt/mail';
+
+function statusOf(code: MailErrorCode): number {
+	switch (code) {
+		case 'MAIL_FAILED':
+			return 503; // nothing is known to have been sent: retry later, or say it failed
+		case 'MAIL_REFUSED':
+			return 422; // the e-mail itself is malformed: sending it again fails again
+	}
+}
+
+export async function sendOrRespond(mailer: Mailer, message: MailMessage): Promise<Response> {
+	try {
+		await mailer.send(message);
+		return new Response(null, { status: 202 });
+	} catch (error) {
+		if (!(error instanceof MailError)) throw error;
+		return Response.json({ code: error.code }, { status: statusOf(error.code) });
+	}
+}
+```
+
+`MailFailure` carries the transport's own error as `cause`. An error's `message`
+names **where** the problem is, never the value: never an address, a subject or
+a link. See [Sending — errors](docs/guide/sending.md#errors).
+
+### Testing — the memory mailer
+
+`createMemoryMailer()` refuses what every transport refuses, keeps an outbox,
+and can be told to fail:
+
+```ts
+import { expect, it } from 'bun:test';
+import { createMemoryMailer, MailFailure } from '@nxgt/mail';
+
+it('says so when the e-mail could not be sent', async () => {
+	const mailer = createMemoryMailer();
+	mailer.failNext(); // the next send rejects with MailFailure, as an outage would
+
+	const error = await mailer
+		.send({ to: 'ada@example.com', subject: 'Hi', html: '<p>Hi</p>', text: 'Hi' })
+		.then(() => null, (e: unknown) => e);
+
+	expect(error).toBeInstanceOf(MailFailure);
+	expect(mailer.sent).toEqual([]); // the outbox
+	expect(mailer.attempts).toBe(1); // nothing retried in secret
+});
+```
+
+See [Testing](docs/guide/testing.md).
+
+### Locales — `pickLocale` and `parseAcceptLanguage`
+
+The locale of an e-mail is the **recipient's**: their stored preference first,
+then, if the recipient is the visitor, their `Accept-Language`:
+
+```ts
+import { parseAcceptLanguage, pickLocale } from '@nxgt/mail';
+
+const locale = pickLocale(
+	['fr-CA', ...parseAcceptLanguage('de;q=0.9,en;q=0.8')],
+	['en', 'fr'],
+	'en',
+); // 'fr' — typed 'en' | 'fr'
+```
+
+`fr-CA` matches `fr`; nothing matching answers the fallback. See
+[Locales](docs/guide/locales.md).
+
+### Writing a transport — `checkMessage` and `describeMailer`
+
+A transport calls `checkMessage` first, quotes or encodes a recipient's name
+itself (a name is free text), throws the classes imported from its `@nxgt/mail`
+peer, and passes the conformance suite:
+
+```ts
+import { checkMessage, MailFailure, MailRefused, type Mailer, recipientsOf } from '@nxgt/mail';
+
+export function createHttpMailer(endpoint: string, apiKey: string): Mailer {
+	return {
+		async send(message) {
+			checkMessage(message); // MailRefused, naming where, never the value
+			const response = await fetch(endpoint, {
+				method: 'POST',
+				headers: { authorization: `Bearer ${apiKey}`, 'content-type': 'application/json' },
+				body: JSON.stringify({ ...message, to: recipientsOf(message) }),
+			}).catch((cause: unknown) => {
+				throw new MailFailure('send: the provider could not be reached', { cause });
+			});
+			const cause = new Error(`the provider answered HTTP ${response.status}`);
+			if (response.status === 400 || response.status === 422) {
+				throw new MailRefused('send: the provider refused the message', { cause });
+			}
+			if (!response.ok) throw new MailFailure('send: the provider failed', { cause });
+			return { messageId: response.headers.get('x-message-id') }; // null when absent
+		},
+	};
+}
+```
+
+```ts
+import { describe, it } from 'bun:test';
+import { describeMailer, referenceMailerHarness } from '@nxgt/mail/conformance';
+
+describeMailer({
+	name: 'the memory mailer',
+	harness: referenceMailerHarness(), // yours: open() a fresh mailer, read back what it delivered
+	runner: { describe, it },
+});
+```
+
+See [Writing a transport](docs/guide/transports.md) for the harness, faults and
+skips.
+
+## Traps
+
+**A failure throws; never map it to "sent".** A mailer that could not hand an
+e-mail over rejects with `MailFailure`; it never answers `false`, and it never
+logs and resolves. A caller that reports a failed send as sent has told a user
+to check an inbox that will stay empty. The conformance suite fails a transport
+that breaks the rule.
+
+**Deploy the build with the server, and point `dir` at it.** `dir` is read
+from the working directory; resolve it from the module when the process may
+start elsewhere: `fileURLToPath(new URL('../mails/dist', import.meta.url))`.
+
+**The renderer needs a file system.** `@nxgt/mail/renderer` imports
+`node:fs`: it runs on Node, Bun and Deno, not on an edge runtime without `fs`.
+`@nxgt/mail` itself imports no Node built-in.
+
+**Create the renderer once.** It reads the whole build when created; one per
+request reads it every time, and a rebuild is only seen by a new renderer.
+
+**`{ locale }` must be one of `mails.locales`, spelled the same.** `'fr-CA'`
+throws where the build has `fr`; pass
+`pickLocale(user.locale, mails.locales, 'en')`.
+
+**A URL variable is refused unless it is `http:`, `https:` or `mailto:`.**
+`render` throws `MailRefused` before anything is sent, so keep it inside the
+`try` that handles `MailError`.
+
+**A string address is only an address.** `'Ada <ada@example.com>'` is refused
+with `MailRefused`; write `{ name: 'Ada', address: 'ada@example.com' }`.
+
+**Never fire and forget a send.** `void mailer.send(message)` turns a failure
+into an unhandled rejection and the user into someone waiting for an e-mail
+that never comes. `await` it, or hand it to a queue that does.
+
+**A custom header cannot set an address.** `headers: { Bcc: '…' }` would add
+a recipient no check saw: `checkMessage` refuses `To`, `Cc`, `Bcc`, `From`,
+`Sender`, `Reply-To`, `Return-Path`, `Subject`, `MIME-Version` and
+`Content-*` among `headers`, in any case. Use `to`, `from` and `replyTo`.
+
+**A refusal is not worth retrying; a failure may be.** `MAIL_REFUSED` fails
+again unchanged. Nothing in this package retries a `MAIL_FAILED`: a retry is
+your decision, made where you can see it.
+
+**The locale is the recipient's, not the request's.** An administrator who
+invites a user sends the invitation in the *user's* locale:
+`pickLocale(invitee.locale, supported, fallback)`.
+
+**A transport defines no error class.** It throws `MailFailure` and
+`MailRefused` from its `@nxgt/mail` peer; its own copy fails `instanceof`, and
+the conformance suite with it.
+
+**Under `bun test`, pass `runner: { describe, it }` to `describeMailer`.** Bun
+gives a test file `describe` and `it` as bare identifiers, not on `globalThis`.
+
+## Type safety, counted
+
+**17 plausible mistakes, 17 refused** at compile time, each measured by a
+`@ts-expect-error` in
+[`test/types/refusals.ts`](https://github.com/softistx/nxgt-mail/blob/develop/packages/mail/test/types/refusals.ts)
+that fails the typecheck the moment it stops holding:
+
+1. A `MailMessage` without `to`.
+2. A `MailMessage` without a `text` part.
+3. An address object without its `address`.
+4. A `Mailer` without `send`.
+5. A `Mailer` whose `send` answers a boolean.
+6. A `SentMail` whose `messageId` is `undefined` rather than `null`.
+7. A `pickLocale` fallback that is not one of the supported locales.
+8. A `MailErrorCode` the union does not declare.
+9. A bare `new MailError(…)` — it is abstract, so nothing throws an error that
+   passes a `code` check and fails `instanceof MailFailure`.
+10. A `createMailRenderer` without `dir`, the build's output folder.
+11. A `getLanguage` given as a locale rather than a function answering one.
+12. A `render` variable that is neither a string nor a number (a `URL`).
+
+With the renderer given the build's `MailEmails`
+(`createMailRenderer<MailEmails>(…)`):
+
+The name written as a literal and the variables at the call, as usual:
+
+13. An e-mail the build does not have (`render('verify-emial', …)`).
+14. A variable the e-mail does not take.
+15. A variable the e-mail takes, left out.
+16. The variables left out altogether, for an e-mail that takes some.
+17. A number for a URL variable: a URL is a string.
+
+The same file holds the calls that must keep compiling: a refusal that refuses
+the correct call is a bug.
+
+## Documentation
+
+- [The guides](docs/README.md) — one page per area, with every option and error.
+- [Troubleshooting](docs/troubleshooting.md) — an error message, its cause and
+  its fix.
+- [Roadmap](docs/roadmap.md) — what is next, and what is deliberately not
+  planned.
+- [Vocabulary](https://github.com/softistx/nxgt-mail/blob/develop/docs/vocabulary.md)
+  — the words these pages use, defined once.
+
+## Licence
+
+MIT

package/dist/chunks/index-0f7kdb8k.js

@@ -0,0 +1,114 @@
+import {
+  MailFailure2,
+  MailRefused2
+} from "./index-we4n5yfz.js";
+
+// src/message.ts
+var LINE_BREAK = /[\r\n]/;
+var ADDRESS = /^[^\s@<>,;:]+@[^\s@<>,;:]+$/;
+var HEADER_NAME = /^[A-Za-z0-9-]+$/;
+var RESERVED_HEADER = /^(?:to|cc|bcc|from|sender|reply-to|return-path|subject|mime-version|content-.*)$/i;
+function recipientsOf2(message) {
+  const to = Array.isArray(message.to) ? message.to : [message.to];
+  return to.map(addressOf2);
+}
+function addressOf2(address) {
+  return typeof address === "string" ? address : address.address;
+}
+function checkAddress(address, where) {
+  if (typeof address === "string") {
+    if (!ADDRESS.test(address)) {
+      throw new MailRefused2(`send: ${where} is not an e-mail address`);
+    }
+    return;
+  }
+  if (typeof address !== "object" || address === null) {
+    throw new MailRefused2(`send: ${where} is not an e-mail address`);
+  }
+  if (typeof address.address !== "string" || !ADDRESS.test(address.address)) {
+    throw new MailRefused2(`send: ${where}.address is not an e-mail address`);
+  }
+  if (typeof address.name !== "string" || LINE_BREAK.test(address.name)) {
+    throw new MailRefused2(`send: ${where}.name must be a string without a line break`);
+  }
+}
+function checkMessage2(message) {
+  if (typeof message !== "object" || message === null) {
+    throw new MailRefused2("send: the message must be an object");
+  }
+  if (message.to === undefined || message.to === null) {
+    throw new MailRefused2("send: to must hold at least one address");
+  }
+  const to = Array.isArray(message.to) ? message.to : [message.to];
+  if (to.length === 0) {
+    throw new MailRefused2("send: to must hold at least one address");
+  }
+  to.forEach((address, index) => {
+    checkAddress(address, Array.isArray(message.to) ? `to[${index}]` : "to");
+  });
+  if (message.from !== undefined)
+    checkAddress(message.from, "from");
+  if (message.replyTo !== undefined)
+    checkAddress(message.replyTo, "replyTo");
+  for (const part of ["subject", "html", "text"]) {
+    if (typeof message[part] !== "string") {
+      throw new MailRefused2(`send: ${part} must be a string`);
+    }
+  }
+  if (LINE_BREAK.test(message.subject)) {
+    throw new MailRefused2("send: subject must not hold a line break");
+  }
+  for (const [name, value] of Object.entries(message.headers ?? {})) {
+    if (!HEADER_NAME.test(name)) {
+      throw new MailRefused2("send: a header name must be letters, digits and hyphens");
+    }
+    if (RESERVED_HEADER.test(name)) {
+      throw new MailRefused2(`send: header ${name} is reserved — addresses, the subject and the MIME structure are never custom headers`);
+    }
+    if (typeof value !== "string" || LINE_BREAK.test(value)) {
+      throw new MailRefused2(`send: header ${name} must be a string without a line break`);
+    }
+  }
+}
+
+// src/memory.ts
+function createMemoryMailer2() {
+  let sent = [];
+  let failures = [];
+  let attempts = 0;
+  let counter = 0;
+  return {
+    get sent() {
+      return sent.map((mail) => structuredClone(mail));
+    },
+    get attempts() {
+      return attempts;
+    },
+    failNext(error) {
+      failures.push(error ?? new MailFailure2("send: the memory mailer was told to fail this send", {
+        cause: new Error("memory mailer: failNext")
+      }));
+    },
+    clear() {
+      sent = [];
+      failures = [];
+      attempts = 0;
+    },
+    async send(message) {
+      checkMessage2(message);
+      attempts += 1;
+      const failure = failures.shift();
+      if (failure !== undefined)
+        throw failure;
+      counter += 1;
+      const messageId = `memory-${counter}`;
+      sent.push({ ...structuredClone(message), messageId });
+      return { messageId };
+    }
+  };
+}
+
+export { recipientsOf2, addressOf2, checkMessage2, createMemoryMailer2 };
+
+//# debugId=44B7D62837EFA8BB64756E2164756E21
+//# sourceMappingURL=index-0f7kdb8k.js.map

package/dist/chunks/index-0f7kdb8k.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/message.ts", "../src/memory.ts"],
+  "sourcesContent": [
+    "import { MailRefused } from './errors';\nimport type { Address, MailMessage } from './types';\n\nconst LINE_BREAK = /[\\r\\n]/;\n// Deliberately loose: one `@`, something on each side, and none of what an\n// address list parser reads as structure — whitespace, `<` `>` (a display\n// name), `,` `;` (a second address), `:` (a group). A provider that parses\n// the string then finds one mailbox, the one checked. Whether the mailbox\n// exists is the receiving server's question.\nconst ADDRESS = /^[^\\s@<>,;:]+@[^\\s@<>,;:]+$/;\nconst HEADER_NAME = /^[A-Za-z0-9-]+$/;\n// The headers a transport writes from the message: the addresses, the subject\n// and the MIME structure. Set through `headers`, a Bcc reaches an SMTP\n// envelope unchecked, and a Content-Type rewrites how the parts are read.\nconst RESERVED_HEADER =\n\t/^(?:to|cc|bcc|from|sender|reply-to|return-path|subject|mime-version|content-.*)$/i;\n\n/** Every recipient of a message, as bare addresses, in order. */\nexport function recipientsOf(message: MailMessage): string[] {\n\tconst to = Array.isArray(message.to) ? message.to : [message.to];\n\treturn to.map(addressOf);\n}\n\n/** The bare address of an {@link Address}. */\nexport function addressOf(address: Address): string {\n\treturn typeof address === 'string' ? address : address.address;\n}\n\n/** Refuses `address` unless it is an {@link Address}. `undefined` is refused too. */\nfunction checkAddress(address: Address | undefined, where: string): void {\n\tif (typeof address === 'string') {\n\t\tif (!ADDRESS.test(address)) {\n\t\t\tthrow new MailRefused(`send: ${where} is not an e-mail address`);\n\t\t}\n\t\treturn;\n\t}\n\tif (typeof address !== 'object' || address === null) {\n\t\tthrow new MailRefused(`send: ${where} is not an e-mail address`);\n\t}\n\tif (typeof address.address !== 'string' || !ADDRESS.test(address.address)) {\n\t\tthrow new MailRefused(`send: ${where}.address is not an e-mail address`);\n\t}\n\tif (typeof address.name !== 'string' || LINE_BREAK.test(address.name)) {\n\t\tthrow new MailRefused(\n\t\t\t`send: ${where}.name must be a string without a line break`,\n\t\t);\n\t}\n}\n\n/**\n * Refuses a message no transport should hand over, with a {@link MailRefused}\n * that names **where** the problem is and never the value.\n *\n * A transport calls it first thing in `send`, so the refusals are the same\n * whichever transport is wired. It checks:\n *\n * - at least one recipient, each one an address;\n * - `from` and `replyTo`, when present, are addresses;\n * - `subject`, `html` and `text` are strings, and `subject` holds no line\n *   break — a line break in a subject is a header injection;\n * - every header name is letters, digits and hyphens, none names what the\n *   transport writes from the message (`To`, `Cc`, `Bcc`, `From`, `Sender`,\n *   `Reply-To`, `Return-Path`, `Subject`, `MIME-Version`, `Content-*`, in\n *   any case), and no header value holds a line break.\n */\nexport function checkMessage(message: MailMessage): void {\n\tif (typeof message !== 'object' || message === null) {\n\t\tthrow new MailRefused('send: the message must be an object');\n\t}\n\tif (message.to === undefined || message.to === null) {\n\t\tthrow new MailRefused('send: to must hold at least one address');\n\t}\n\tconst to = Array.isArray(message.to) ? message.to : [message.to];\n\tif (to.length === 0) {\n\t\tthrow new MailRefused('send: to must hold at least one address');\n\t}\n\tto.forEach((address, index) => {\n\t\tcheckAddress(address, Array.isArray(message.to) ? `to[${index}]` : 'to');\n\t});\n\tif (message.from !== undefined) checkAddress(message.from, 'from');\n\tif (message.replyTo !== undefined) checkAddress(message.replyTo, 'replyTo');\n\n\tfor (const part of ['subject', 'html', 'text'] as const) {\n\t\tif (typeof message[part] !== 'string') {\n\t\t\tthrow new MailRefused(`send: ${part} must be a string`);\n\t\t}\n\t}\n\tif (LINE_BREAK.test(message.subject)) {\n\t\tthrow new MailRefused('send: subject must not hold a line break');\n\t}\n\n\tfor (const [name, value] of Object.entries(message.headers ?? {})) {\n\t\tif (!HEADER_NAME.test(name)) {\n\t\t\tthrow new MailRefused(\n\t\t\t\t'send: a header name must be letters, digits and hyphens',\n\t\t\t);\n\t\t}\n\t\tif (RESERVED_HEADER.test(name)) {\n\t\t\tthrow new MailRefused(\n\t\t\t\t`send: header ${name} is reserved — addresses, the subject and the MIME structure are never custom headers`,\n\t\t\t);\n\t\t}\n\t\tif (typeof value !== 'string' || LINE_BREAK.test(value)) {\n\t\t\tthrow new MailRefused(\n\t\t\t\t`send: header ${name} must be a string without a line break`,\n\t\t\t);\n\t\t}\n\t}\n}\n",
+    "import { type MailError, MailFailure } from './errors';\nimport { checkMessage } from './message';\nimport type { Mailer, MailMessage, SentMail } from './types';\n\n/** One message the memory mailer accepted, with the id it gave it. */\nexport interface MemoryMail extends MailMessage {\n\treadonly messageId: string;\n}\n\n/**\n * The reference transport: it keeps what it sends in memory, for tests.\n *\n * It refuses exactly what every transport refuses (it calls\n * {@link checkMessage}), and it can be told to fail, so a test can prove what\n * the application does when a send throws.\n */\nexport interface MemoryMailer extends Mailer {\n\t/** Every message accepted so far, oldest first. A copy: mutating it changes nothing. */\n\treadonly sent: readonly MemoryMail[];\n\t/**\n\t * How many sends reached the hand-over, failed ones included. A message\n\t * refused as malformed never reaches it. A caller that retries in secret\n\t * shows up here.\n\t */\n\treadonly attempts: number;\n\t/**\n\t * Makes the next send that reaches the hand-over reject with `error`, by\n\t * default a {@link MailFailure} as an outage would. Calls queue: two calls\n\t * fail the next two sends.\n\t */\n\tfailNext(error?: MailError): void;\n\t/** Forgets what was sent, the attempts, and any queued failure. */\n\tclear(): void;\n}\n\n/** Creates a {@link MemoryMailer}. Message ids are `memory-1`, `memory-2`, … */\nexport function createMemoryMailer(): MemoryMailer {\n\tlet sent: MemoryMail[] = [];\n\tlet failures: MailError[] = [];\n\tlet attempts = 0;\n\tlet counter = 0;\n\n\treturn {\n\t\tget sent() {\n\t\t\treturn sent.map((mail) => structuredClone(mail));\n\t\t},\n\t\tget attempts() {\n\t\t\treturn attempts;\n\t\t},\n\t\tfailNext(error) {\n\t\t\tfailures.push(\n\t\t\t\terror ??\n\t\t\t\t\tnew MailFailure(\n\t\t\t\t\t\t'send: the memory mailer was told to fail this send',\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcause: new Error('memory mailer: failNext'),\n\t\t\t\t\t\t},\n\t\t\t\t\t),\n\t\t\t);\n\t\t},\n\t\tclear() {\n\t\t\tsent = [];\n\t\t\tfailures = [];\n\t\t\tattempts = 0;\n\t\t},\n\t\tasync send(message): Promise<SentMail> {\n\t\t\tcheckMessage(message);\n\t\t\tattempts += 1;\n\t\t\tconst failure = failures.shift();\n\t\t\tif (failure !== undefined) throw failure;\n\n\t\t\tcounter += 1;\n\t\t\tconst messageId = `memory-${counter}`;\n\t\t\tsent.push({ ...structuredClone(message), messageId });\n\t\t\treturn { messageId };\n\t\t},\n\t};\n}\n"
+  ],
+  "mappings": "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",
+  "debugId": "44B7D62837EFA8BB64756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-vq4e9n8f.js

@@ -0,0 +1,39 @@
+// src/locale.ts
+var normalise = (locale) => locale.trim().replace(/_/g, "-").toLowerCase();
+var languageOf = (locale) => normalise(locale).split("-")[0] ?? "";
+function pickLocale2(wanted, supported, fallback) {
+  if (supported.length === 0) {
+    throw new TypeError("pickLocale: supported must hold at least one locale");
+  }
+  if (!supported.includes(fallback)) {
+    throw new TypeError("pickLocale: fallback must be one of supported");
+  }
+  const list = Array.isArray(wanted) ? wanted : [wanted];
+  for (const locale of list) {
+    if (typeof locale !== "string" || locale.trim() === "")
+      continue;
+    const exact = supported.find((s) => normalise(s) === normalise(locale));
+    if (exact !== undefined)
+      return exact;
+    const language = languageOf(locale);
+    const sameLanguage = supported.find((s) => normalise(s) === language) ?? supported.find((s) => languageOf(s) === language);
+    if (sameLanguage !== undefined)
+      return sameLanguage;
+  }
+  return fallback;
+}
+function parseAcceptLanguage2(header) {
+  if (typeof header !== "string")
+    return [];
+  return header.split(",").map((entry, index) => {
+    const [tag = "", ...params] = entry.split(";").map((p) => p.trim());
+    const q = params.map((p) => /^q=([0-9.]+)$/i.exec(p)?.[1]).find((v) => v !== undefined);
+    const weight = q === undefined ? 1 : Number(q);
+    return { tag, weight: Number.isNaN(weight) ? 0 : weight, index };
+  }).filter(({ tag, weight }) => tag !== "" && tag !== "*" && weight > 0).sort((a, b) => b.weight - a.weight || a.index - b.index).map(({ tag }) => tag);
+}
+
+export { pickLocale2, parseAcceptLanguage2 };
+
+//# debugId=17ED638EE74DEAA764756E2164756E21
+//# sourceMappingURL=index-vq4e9n8f.js.map

package/dist/chunks/index-vq4e9n8f.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/locale.ts"],
+  "sourcesContent": [
+    "/** What {@link pickLocale} accepts as the wanted locales. */\nexport type WantedLocales =\n\t| string\n\t| null\n\t| undefined\n\t| readonly (string | null | undefined)[];\n\nconst normalise = (locale: string) =>\n\tlocale.trim().replace(/_/g, '-').toLowerCase();\nconst languageOf = (locale: string) => normalise(locale).split('-')[0] ?? '';\n\n/**\n * The locale to render an e-mail in: the first wanted locale this build\n * supports, or `fallback`.\n *\n * `wanted` is in order of preference — typically the recipient's stored\n * locale, then their `Accept-Language` (see {@link parseAcceptLanguage}).\n * For each wanted locale in turn, an exact match wins (case and `_` or `-`\n * do not matter), then a match on the language alone: `fr-CA` picks `fr`,\n * and `fr` picks `fr-CA` when that is the only French supported. Nothing\n * matching, or nothing wanted, answers `fallback`.\n *\n * Pure, with no request context: **the locale of an e-mail is the\n * recipient's**, usually a field of the user, and not the language of the\n * request that triggered the send.\n *\n * Throws a `TypeError` when `supported` is empty or does not hold `fallback`.\n * That is a wiring mistake, not a request's.\n */\nexport function pickLocale<const L extends string>(\n\twanted: WantedLocales,\n\tsupported: readonly L[],\n\tfallback: NoInfer<L>,\n): L {\n\tif (supported.length === 0) {\n\t\tthrow new TypeError('pickLocale: supported must hold at least one locale');\n\t}\n\tif (!supported.includes(fallback)) {\n\t\tthrow new TypeError('pickLocale: fallback must be one of supported');\n\t}\n\n\tconst list = Array.isArray(wanted) ? wanted : [wanted];\n\tfor (const locale of list) {\n\t\tif (typeof locale !== 'string' || locale.trim() === '') continue;\n\t\tconst exact = supported.find((s) => normalise(s) === normalise(locale));\n\t\tif (exact !== undefined) return exact;\n\t\tconst language = languageOf(locale);\n\t\tconst sameLanguage =\n\t\t\tsupported.find((s) => normalise(s) === language) ??\n\t\t\tsupported.find((s) => languageOf(s) === language);\n\t\tif (sameLanguage !== undefined) return sameLanguage;\n\t}\n\treturn fallback;\n}\n\n/**\n * The locales of an `Accept-Language` header, most wanted first.\n *\n * Entries are ordered by their `q` weight, ties keeping the header's order;\n * `q=0` entries and `*` are dropped. A missing or empty header answers `[]`.\n *\n * ```ts\n * parseAcceptLanguage('fr-CA,fr;q=0.9,en;q=0.8'); // ['fr-CA', 'fr', 'en']\n * ```\n */\nexport function parseAcceptLanguage(\n\theader: string | null | undefined,\n): string[] {\n\tif (typeof header !== 'string') return [];\n\treturn header\n\t\t.split(',')\n\t\t.map((entry, index) => {\n\t\t\tconst [tag = '', ...params] = entry.split(';').map((p) => p.trim());\n\t\t\tconst q = params\n\t\t\t\t.map((p) => /^q=([0-9.]+)$/i.exec(p)?.[1])\n\t\t\t\t.find((v) => v !== undefined);\n\t\t\tconst weight = q === undefined ? 1 : Number(q);\n\t\t\treturn { tag, weight: Number.isNaN(weight) ? 0 : weight, index };\n\t\t})\n\t\t.filter(({ tag, weight }) => tag !== '' && tag !== '*' && weight > 0)\n\t\t.sort((a, b) => b.weight - a.weight || a.index - b.index)\n\t\t.map(({ tag }) => tag);\n}\n"
+  ],
+  "mappings": ";AAOA,IAAM,YAAY,CAAC,WAClB,OAAO,KAAK,EAAE,QAAQ,MAAM,GAAG,EAAE,YAAY;AAC9C,IAAM,aAAa,CAAC,WAAmB,UAAU,MAAM,EAAE,MAAM,GAAG,EAAE,MAAM;AAoBnE,SAAS,WAAkC,CACjD,QACA,WACA,UACI;AAAA,EACJ,IAAI,UAAU,WAAW,GAAG;AAAA,IAC3B,MAAM,IAAI,UAAU,qDAAqD;AAAA,EAC1E;AAAA,EACA,IAAI,CAAC,UAAU,SAAS,QAAQ,GAAG;AAAA,IAClC,MAAM,IAAI,UAAU,+CAA+C;AAAA,EACpE;AAAA,EAEA,MAAM,OAAO,MAAM,QAAQ,MAAM,IAAI,SAAS,CAAC,MAAM;AAAA,EACrD,WAAW,UAAU,MAAM;AAAA,IAC1B,IAAI,OAAO,WAAW,YAAY,OAAO,KAAK,MAAM;AAAA,MAAI;AAAA,IACxD,MAAM,QAAQ,UAAU,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM,UAAU,MAAM,CAAC;AAAA,IACtE,IAAI,UAAU;AAAA,MAAW,OAAO;AAAA,IAChC,MAAM,WAAW,WAAW,MAAM;AAAA,IAClC,MAAM,eACL,UAAU,KAAK,CAAC,MAAM,UAAU,CAAC,MAAM,QAAQ,KAC/C,UAAU,KAAK,CAAC,MAAM,WAAW,CAAC,MAAM,QAAQ;AAAA,IACjD,IAAI,iBAAiB;AAAA,MAAW,OAAO;AAAA,EACxC;AAAA,EACA,OAAO;AAAA;AAaD,SAAS,oBAAmB,CAClC,QACW;AAAA,EACX,IAAI,OAAO,WAAW;AAAA,IAAU,OAAO,CAAC;AAAA,EACxC,OAAO,OACL,MAAM,GAAG,EACT,IAAI,CAAC,OAAO,UAAU;AAAA,IACtB,OAAO,MAAM,OAAO,UAAU,MAAM,MAAM,GAAG,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC;AAAA,IAClE,MAAM,IAAI,OACR,IAAI,CAAC,MAAM,iBAAiB,KAAK,CAAC,IAAI,EAAE,EACxC,KAAK,CAAC,MAAM,MAAM,SAAS;AAAA,IAC7B,MAAM,SAAS,MAAM,YAAY,IAAI,OAAO,CAAC;AAAA,IAC7C,OAAO,EAAE,KAAK,QAAQ,OAAO,MAAM,MAAM,IAAI,IAAI,QAAQ,MAAM;AAAA,GAC/D,EACA,OAAO,GAAG,KAAK,aAAa,QAAQ,MAAM,QAAQ,OAAO,SAAS,CAAC,EACnE,KAAK,CAAC,GAAG,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EACvD,IAAI,GAAG,UAAU,GAAG;AAAA;",
+  "debugId": "17ED638EE74DEAA764756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-we4n5yfz.js

@@ -0,0 +1,28 @@
+// src/errors.ts
+class MailError2 extends Error {
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "MailError";
+  }
+}
+
+class MailFailure2 extends MailError2 {
+  constructor() {
+    super(...arguments);
+    this.name = "MailFailure";
+    this.code = "MAIL_FAILED";
+  }
+}
+
+class MailRefused2 extends MailError2 {
+  constructor() {
+    super(...arguments);
+    this.name = "MailRefused";
+    this.code = "MAIL_REFUSED";
+  }
+}
+
+export { MailError2, MailFailure2, MailRefused2 };
+
+//# debugId=5753AA1D988C668964756E2164756E21
+//# sourceMappingURL=index-we4n5yfz.js.map

package/dist/chunks/index-we4n5yfz.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts"],
+  "sourcesContent": [
+    "/**\n * What a transport refuses, as a string a caller can switch on.\n *\n * Every code is a **refusal at call time**. A refusal that can only come from\n * how the application was wired — a bad option passed to a factory — is a\n * bare `TypeError` instead: no handler should ever answer one.\n *\n * The codes are `SCREAMING_SNAKE` because they are data values, not API\n * identifiers. Every key in this package is `camelCase`.\n */\nexport type MailErrorCode =\n\t/**\n\t * The transport could not hand the message over: a refused connection, a\n\t * timeout, a 5xx from the provider, an expired credential. The transport's\n\t * own error is the `cause`.\n\t *\n\t * **Nothing is known to have been sent** — after a timeout or a dropped\n\t * connection, the provider may have taken it all the same. Retry later,\n\t * or tell the user it failed. Never report it as sent.\n\t */\n\t| 'MAIL_FAILED'\n\t/**\n\t * The message itself was refused, before or by the transport: no\n\t * recipient, something that is not an address, a line break in the\n\t * subject or a header, a provider answering that the message is\n\t * malformed, or — from `@nxgt/mail/renderer` — a URL variable that is not\n\t * an `http:`, `https:` or `mailto:` URL. Sending it again unchanged fails\n\t * again.\n\t */\n\t| 'MAIL_REFUSED';\n\n/** Options every error of this package accepts. */\nexport interface MailErrorOptions {\n\t/** The error that caused this one, typically the transport's. */\n\treadonly cause?: unknown;\n}\n\n/**\n * The base class of every error this package throws at call time. It is\n * abstract: a transport throws {@link MailFailure} or {@link MailRefused}.\n *\n * **There is exactly one definition of this class.** A transport defines no\n * error class of its own and throws these, imported from its `@nxgt/mail`\n * peer, so `error instanceof MailFailure` holds whatever transport threw it.\n *\n * A message reports **a shape, never a value**: never a recipient address,\n * never a subject, never a link — the link in a verification e-mail is a\n * credential.\n */\nexport abstract class MailError extends Error {\n\toverride name = 'MailError';\n\t/**\n\t * Abstract, so a transport cannot throw a bare `MailError` that passes a\n\t * `code` check and fails `instanceof MailFailure`: it throws one of the two\n\t * subclasses.\n\t */\n\tabstract readonly code: MailErrorCode;\n\n\tconstructor(message: string, options?: MailErrorOptions) {\n\t\tsuper(message, { cause: options?.cause });\n\t}\n}\n\n/** The transport could not hand the message over. Code `MAIL_FAILED`. */\nexport class MailFailure extends MailError {\n\toverride name = 'MailFailure';\n\toverride readonly code = 'MAIL_FAILED' as const;\n}\n\n/** The message was refused as malformed. Code `MAIL_REFUSED`. */\nexport class MailRefused extends MailError {\n\toverride name = 'MailRefused';\n\toverride readonly code = 'MAIL_REFUSED' as const;\n}\n"
+  ],
+  "mappings": ";AAiDO,MAAe,mBAAkB,MAAM;AAAA,EAS7C,WAAW,CAAC,SAAiB,SAA4B;AAAA,IACxD,MAAM,SAAS,EAAE,OAAO,SAAS,MAAM,CAAC;AAAA,IAThC,YAAO;AAAA;AAWjB;AAAA;AAGO,MAAM,qBAAoB,WAAU;AAAA;AAAA;AAAA,IACjC,YAAO;AAAA,IACE,YAAO;AAAA;AAC1B;AAAA;AAGO,MAAM,qBAAoB,WAAU;AAAA;AAAA;AAAA,IACjC,YAAO;AAAA,IACE,YAAO;AAAA;AAC1B;",
+  "debugId": "5753AA1D988C668964756E2164756E21",
+  "names": []
+}

package/dist/conformance/assert.d.ts

@@ -0,0 +1,12 @@
+import type { MailerCaseContext } from './types';
+/** Throws when `condition` is false. The suite depends on no assertion library. */
+export declare function check(condition: boolean, what: string): asserts condition;
+export declare const same: (a: unknown, b: unknown) => boolean;
+/**
+ * Settles an expected rejection where it is created, and answers the error —
+ * or throws when the promise resolved.
+ */
+export declare function rejection(promise: Promise<unknown>, what: string): Promise<unknown>;
+/** Throws when the receiving end got anything. */
+export declare function nothingDelivered(context: MailerCaseContext, what: string): Promise<void>;
+//# sourceMappingURL=assert.d.ts.map

package/dist/conformance/assert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../src/conformance/assert.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,mFAAmF;AACnF,wBAAgB,KAAK,CAAC,SAAS,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAEzE;AAED,eAAO,MAAM,IAAI,GAAI,GAAG,OAAO,EAAE,GAAG,OAAO,YACH,CAAC;AAEzC;;;GAGG;AACH,wBAAsB,SAAS,CAC9B,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,EACzB,IAAI,EAAE,MAAM,GACV,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,kDAAkD;AAClD,wBAAsB,gBAAgB,CACrC,OAAO,EAAE,iBAAiB,EAC1B,IAAI,EAAE,MAAM,iBAMZ"}

package/dist/conformance/cases/failure.d.ts

@@ -0,0 +1,4 @@
+import type { MailerCase } from '../types';
+/** What a send must do when the transport fails. Needs {@link MailerFaults}. */
+export declare const failureCases: readonly MailerCase[];
+//# sourceMappingURL=failure.d.ts.map

package/dist/conformance/cases/failure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failure.d.ts","sourceRoot":"","sources":["../../../src/conformance/cases/failure.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAE3C,gFAAgF;AAChF,eAAO,MAAM,YAAY,EAAE,SAAS,UAAU,EAqF7C,CAAC"}

package/dist/conformance/cases/index.d.ts

@@ -0,0 +1,6 @@
+import type { MailerCase } from '../types';
+export { failureCases } from './failure';
+export { sendCases } from './send';
+/** Every case, in the order they are described. */
+export declare const allMailerCases: readonly MailerCase[];
+//# sourceMappingURL=index.d.ts.map

package/dist/conformance/cases/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/conformance/cases/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAI3C,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC;AAEnC,mDAAmD;AACnD,eAAO,MAAM,cAAc,EAAE,SAAS,UAAU,EAG/C,CAAC"}

package/dist/conformance/cases/send.d.ts

@@ -0,0 +1,4 @@
+import type { MailerCase } from '../types';
+/** What every send must do, with no fault injected. */
+export declare const sendCases: readonly MailerCase[];
+//# sourceMappingURL=send.d.ts.map