@bumail/queue 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,243 @@
+# @bumail/queue
+
+The outbound queue of a mail server: it keeps every message your server
+sends to another one, delivers it through `@bumail/smtp/client`, retries
+what failed for now, and sends a delivery status notification (RFC 3464)
+back when it gives up. Each recipient has its own state, the queue
+survives a restart on `bun:sqlite`, and several workers can share one
+queue. No runtime dependency: only peers.
+
+## Install
+
+```sh
+bun add @bumail/queue @bumail/smtp @bumail/mime
+bun add @bumail/dns   # for direct delivery by MX: the resolver
+```
+
+`@bumail/smtp` (its client) and `@bumail/mime` (for the DSNs) are required
+peers. `@bumail/dns` is optional: any resolver of its shape will do, and a
+queue that only uses a smarthost needs none.
+
+## Subpaths
+
+| import | what it gives |
+| --- | --- |
+| `@bumail/queue` | `createQueue`, the `QueueStore` contract, `QueueError` and the types |
+| `@bumail/queue/memory` | `MemoryQueueStore`: in memory, lost on a restart — for specs and trials |
+| `@bumail/queue/sqlite` | `SqliteQueueStore`: on disk with `bun:sqlite`, shared by the processes of one machine |
+
+## Usage
+
+```ts
+import { nodeResolver } from '@bumail/dns';
+import { createQueue } from '@bumail/queue';
+import { SqliteQueueStore } from '@bumail/queue/sqlite';
+
+const queue = createQueue({
+	store: SqliteQueueStore.open({ directory: '/var/lib/bumail/queue' }),
+	hostname: 'mail.example.net', // your public name: EHLO, and the DSN's Reporting-MTA
+	resolver: nodeResolver(),
+});
+queue.start();
+
+// The message as it leaves: whole, headers first, CRLF, already DKIM-signed
+// (with @bumail/auth's signDkim, say).
+const signedMessage = await Bun.file('outgoing.eml').bytes();
+const item = await queue.enqueue(signedMessage, {
+	from: 'mary@example.net',
+	to: ['joe@example.com', 'ann@example.org'],
+});
+item.recipients; // [{ address: 'joe@example.com', status: 'pending' }, …]
+
+process.on('SIGTERM', () => queue.stop()); // lets deliveries under way end
+```
+
+The message is a `Uint8Array`, a string or a `ReadableStream<Uint8Array>`,
+with CRLF line ends: a bare CR or LF is refused, as `sendMail` would
+refuse it. Every address is checked as one `sendMail` takes
+(`@bumail/smtp/client`'s `isMailbox`: an RFC 5321 Mailbox with no source
+route, no control character (C0, DEL or C1), no `>`, no U+2028 or U+2029,
+no Unicode format character (`\p{Cf}`), no lone surrogate and no IPv4
+literal octet above 255), so a bad one is refused at `enqueue`, never at
+delivery.
+Delivery groups the recipients by domain: one session per domain per
+attempt, with STARTTLS when offered.
+
+## Retries and bounces
+
+A 4xx, a connection error or a timeout leaves the recipient `deferred`;
+the queue tries it again after 30 minutes, then 1 hour, 2, 4, and every 4
+hours, each plus up to 10% of jitter, and gives up after 5 days
+(RFC 5321 §4.5.4.1). A 5xx fails the recipient at once.
+
+```ts
+import { nodeResolver } from '@bumail/dns';
+import { createQueue } from '@bumail/queue';
+import { MemoryQueueStore } from '@bumail/queue/memory';
+
+const queue = createQueue({
+	store: new MemoryQueueStore(),
+	hostname: 'mail.example.net',
+	resolver: nodeResolver(),
+	retry: { first: 15 * 60_000, giveUpAfter: 3 * 24 * 3_600_000 },
+	dsn: { delayAfter: 4 * 3_600_000, returnContent: 'headers' },
+});
+```
+
+A failed recipient gets a DSN back to the sender, a `multipart/report`
+with the original's header fields; a recipient still deferred after
+`delayAfter` gets one "delayed" warning. A DSN is enqueued from the null
+sender `<>`, and a message from `<>` never causes one.
+
+## Routing
+
+```ts
+import { createQueue } from '@bumail/queue';
+import { MemoryQueueStore } from '@bumail/queue/memory';
+
+const smtpPassword = (await Bun.file('/run/secrets/smtp').text()).trim(); // from your secrets
+createQueue({
+	store: new MemoryQueueStore(),
+	hostname: 'mail.example.net',
+	// Port 25 blocked? Everything through a provider's submission port:
+	route: {
+		host: 'smtp.provider.example',
+		port: 587,
+		auth: { username: 'mary@example.net', password: smtpPassword },
+	},
+	// …or only some domains, the rest by MX (which needs the resolver):
+	routes: { 'partner.example': { host: 'relay.partner.example' } },
+});
+```
+
+`route` defaults to `'mx'`: each recipient domain's own mail hosts.
+Credentials go only over TLS whose certificate checked out: `createQueue`
+refuses `auth` with a `tls` other than `'required'`, and checks the ports,
+the TLS modes and the timeouts as `sendMail` would. A route `sendMail`
+still refuses (`INVALID_OPTION`) defers its recipients as `4.3.5` and
+says so on the `error` event; it does not bounce them until
+`retry.giveUpAfter`, when they fail as `4.4.7` with a DSN like any
+deferred recipient.
+
+## Several workers
+
+```ts
+import { nodeResolver } from '@bumail/dns';
+import { createQueue } from '@bumail/queue';
+import { SqliteQueueStore } from '@bumail/queue/sqlite';
+
+// In each process, on the same directory: a claim leases an item to one worker.
+const queue = createQueue({
+	store: SqliteQueueStore.open({ directory: '/var/lib/bumail/queue' }),
+	hostname: 'mail.example.net',
+	resolver: nodeResolver(),
+});
+queue.start();
+```
+
+A worker claims a due item with a lease, renews it while it delivers, and
+lets go of it with the outcome; a renewal that fails is told on `error`
+and tried again. If it crashes, another worker claims the item once the
+lease expires (`leaseMs`, 10 minutes by default). A directory the store
+makes is 0700; one that exists keeps its mode.
+`concurrency` (20) bounds the items one worker delivers at once — each
+item opens one session per recipient domain — and `perDomain` (2) its
+sessions to one recipient domain.
+
+## Events and admin
+
+```ts
+// queue: the one created under Usage.
+queue.on('delivered', ({ id, recipient, reply }) => console.info({ id, recipient, reply }));
+queue.on('deferred', ({ recipient, reply, nextAttemptAt }) => {});
+queue.on('failed', ({ recipient, reply }) => {}); // reply: { code?, status?, text, host? }
+queue.on('dsn', ({ kind, of, to }) => {});
+queue.on('error', ({ error, id }) => console.error(id, error)); // the store, a lost lease, a bad route
+
+const [next] = await queue.list({ limit: 50 }); // the next due first
+if (next) await queue.retryNow(next.id); // false while a worker delivers it
+if (next) await queue.cancel(next.id); // no DSN
+```
+
+## Testing
+
+```ts
+import { createQueue, type Sender } from '@bumail/queue';
+import { MemoryQueueStore } from '@bumail/queue/memory';
+
+let now = Date.UTC(2026, 0, 1);
+const send: Sender = async (_message, options) => ({
+	accepted: [options.to].flat().map((recipient) => ({ recipient, reply: { code: 250, text: 'OK' } })),
+	rejected: [],
+	reply: { code: 250, text: 'Queued' },
+	host: 'mx.test',
+	port: 25,
+	tls: false,
+	authenticated: false,
+});
+const queue = createQueue({
+	store: new MemoryQueueStore(),
+	hostname: 'mail.test',
+	route: { host: 'mx.test' },
+	clock: { now: () => now },
+	send,
+});
+await queue.enqueue('Subject: hi\r\n\r\nhello\r\n', { from: 'a@test', to: 'b@test' });
+await queue.deliverDue(); // one pass, by hand: no timer, no network
+now += 30 * 60_000;
+```
+
+## Limits
+
+```ts
+import { nodeResolver } from '@bumail/dns';
+import { createQueue } from '@bumail/queue';
+import { MemoryQueueStore } from '@bumail/queue/memory';
+
+createQueue({
+	store: new MemoryQueueStore(),
+	hostname: 'mail.example.net',
+	resolver: nodeResolver(),
+	limits: { maxMessageSize: 10 * 1024 * 1024, maxRecipients: 50, maxItems: 100_000 },
+});
+```
+
+Everything is bounded, through `limits`: the message (25 MiB), the
+recipients per message (100), the items in the store (none by default),
+the reply text kept per recipient (512 characters, control characters
+replaced by spaces), and the original a DSN returns (64 KiB, each line cut
+at 998 bytes). Nothing a
+remote server says reaches a DSN's header fields with a CR, an LF or a
+control character in it.
+
+## Traps
+
+- **Bun only.** The store on disk uses `bun:sqlite`, so the package runs
+  on Bun 1.4.2 or later, not on Node.
+- **It sends what you enqueue, to anyone.** The queue is not a relay
+  policy: enqueue only what an authenticated user submitted, or what your
+  own server writes, never what an unauthenticated client handed you.
+
+## API
+
+| export | |
+| --- | --- |
+| `createQueue(options)`, `Queue` | the queue: `enqueue`, `deliverDue`, `start`, `stop`, `on`, `list`, `get`, `retryNow`, `cancel`, `owner` |
+| `QueueOptions`, `Route`, `Smarthost`, `RetrySchedule`, `DsnOptions`, `QueueLimits`, `Clock`, `Sender` | what `createQueue` takes |
+| `MessageSource`, `QueueEnvelope` | what `enqueue` takes |
+| `QueueEvents`, `QueueListener`, `RecipientEvent`, `DeferredEvent`, `DsnEvent`, `QueueErrorEvent` | the events |
+| `QueueStore` | the contract a store answers: `add`, `get`, `list`, `count`, `readMessage`, `claim`, `renew`, `complete`, `reschedule`, `cancel` |
+| `QueueItem`, `RecipientState`, `RecipientStatus`, `FinalStatus`, `Diagnostic`, `Lease` | an item, and where each recipient stands |
+| `NewQueueItem`, `AddOptions`, `ClaimRequest`, `AttemptResult`, `RecipientUpdate`, `QueueListOptions` | what a store takes |
+| `QueueError`, `QueueErrorCode` | `INVALID`, `MESSAGE_TOO_BIG`, `TOO_MANY_RECIPIENTS`, `QUEUE_FULL`, `CLOSED`, `LEASE_LOST` |
+| `MemoryQueueStore` | from `@bumail/queue/memory` |
+| `SqliteQueueStore`, `SqliteQueueStoreOptions` | from `@bumail/queue/sqlite`: `SqliteQueueStore.open({ directory, busyTimeout? })`, `close()` |
+
+## Documentation
+
+These pages ship in the package, under `docs/`.
+
+- [Index](https://github.com/softistx/bumail/blob/develop/packages/queue/docs/README.md): the pages, and when to read each.
+- [Guide](https://github.com/softistx/bumail/blob/develop/packages/queue/docs/guide.md): enqueuing, delivery and routing, the retry schedule, DSNs, several workers and leases, events and admin, the stores, testing, and writing a store of your own.
+- [Troubleshooting](https://github.com/softistx/bumail/blob/develop/packages/queue/docs/troubleshooting.md): every `QueueError`, and what to do about it.
+- [Roadmap](https://github.com/softistx/bumail/blob/develop/packages/queue/docs/roadmap.md): what is coming, and what is not planned.

package/dist/chunks/index-p4k4rjb7.js

@@ -0,0 +1,15 @@
+// src/errors.ts
+class QueueError2 extends Error {
+  name = "QueueError";
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+var invalid = (message) => new QueueError2("INVALID", message);
+
+export { QueueError2, invalid };
+
+//# debugId=465D2E3985AB194764756E2164756E21
+//# sourceMappingURL=index-p4k4rjb7.js.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/errors.ts"],
+  "sourcesContent": [
+    "/**\n * Why the queue or a store refused a call. `INVALID`: an option or an\n * argument it cannot take. `MESSAGE_TOO_BIG`, `TOO_MANY_RECIPIENTS` and\n * `QUEUE_FULL`: a limit `enqueue` enforces. `CLOSED`: a store used after\n * `close()`. `LEASE_LOST`: given to the `error` event when another worker\n * took an item before its outcome was recorded.\n */\nexport type QueueErrorCode =\n\t| 'INVALID'\n\t| 'MESSAGE_TOO_BIG'\n\t| 'TOO_MANY_RECIPIENTS'\n\t| 'QUEUE_FULL'\n\t| 'CLOSED'\n\t| 'LEASE_LOST';\n\n/** Thrown by the queue and by every store, whichever answers the contract, with the same codes. */\nexport class QueueError extends Error {\n\toverride readonly name = 'QueueError';\n\treadonly code: QueueErrorCode;\n\n\tconstructor(code: QueueErrorCode, message: string) {\n\t\tsuper(message);\n\t\tthis.code = code;\n\t}\n}\n\n/** `INVALID`, for an option or an argument. */\nexport const invalid = (message: string) => new QueueError('INVALID', message);\n"
+  ],
+  "mappings": ";AAgBO,MAAM,oBAAmB,MAAM;AAAA,EACnB,OAAO;AAAA,EAChB;AAAA,EAET,WAAW,CAAC,MAAsB,SAAiB;AAAA,IAClD,MAAM,OAAO;AAAA,IACb,KAAK,OAAO;AAAA;AAEd;AAGO,IAAM,UAAU,CAAC,YAAoB,IAAI,YAAW,WAAW,OAAO;",
+  "debugId": "465D2E3985AB194764756E2164756E21",
+  "names": []
+}

package/dist/chunks/index-xhsw4xcz.js

@@ -0,0 +1,119 @@
+import {
+  invalid
+} from "./index-p4k4rjb7.js";
+
+// src/contract/checks.ts
+var isTime = (value) => typeof value === "number" && Number.isFinite(value);
+function checkTime(name, value) {
+  if (!isTime(value))
+    throw invalid(`${name} must be a finite number`);
+  return value;
+}
+function checkOwner(owner) {
+  if (typeof owner !== "string" || owner === "") {
+    throw invalid("owner must be a non-empty string");
+  }
+  return owner;
+}
+function checkNewItem(item) {
+  if (typeof item !== "object" || item === null) {
+    throw invalid("A new item is an object");
+  }
+  if (typeof item.from !== "string")
+    throw invalid("from must be a string");
+  const to = item.to;
+  if (!Array.isArray(to) || to.length === 0 || !to.every((a) => typeof a === "string" && a !== "")) {
+    throw invalid("to must be a non-empty array of addresses");
+  }
+  if (!(item.message instanceof Uint8Array)) {
+    throw invalid("message must be a Uint8Array");
+  }
+  checkTime("createdAt", item.createdAt);
+}
+function checkMaxItems(max) {
+  if (max === undefined)
+    return;
+  if (typeof max !== "number" || !Number.isInteger(max) || max < 1) {
+    throw invalid(`maxItems must be an integer of at least 1, not ${max}`);
+  }
+  return max;
+}
+function checkClaim(request) {
+  if (typeof request !== "object" || request === null) {
+    throw invalid("A claim is an object");
+  }
+  checkOwner(request.owner);
+  checkTime("now", request.now);
+  if (!isTime(request.leaseMs) || request.leaseMs <= 0) {
+    throw invalid("leaseMs must be a positive number");
+  }
+}
+function checkResult(result) {
+  if (typeof result !== "object" || result === null) {
+    throw invalid("An attempt result is an object");
+  }
+  checkTime("now", result.now);
+  checkTime("nextAttemptAt", result.nextAttemptAt);
+  if (!Number.isInteger(result.attempts) || result.attempts < 0) {
+    throw invalid("attempts must be an integer of at least 0");
+  }
+  if (typeof result.delayNotified !== "boolean") {
+    throw invalid("delayNotified must be true or false");
+  }
+  const statuses = ["delivered", "deferred", "failed"];
+  if (!Array.isArray(result.recipients) || !result.recipients.every((u) => typeof u?.address === "string" && statuses.includes(u.status))) {
+    throw invalid("recipients must be an array of { address, status: delivered, deferred or failed }");
+  }
+}
+function checkList(options = {}) {
+  const offset = options.offset ?? 0;
+  const limit = options.limit ?? 100;
+  if (!Number.isInteger(offset) || offset < 0) {
+    throw invalid(`offset must be an integer of at least 0, not ${offset}`);
+  }
+  if (!Number.isInteger(limit) || limit < 1 || limit > 1000) {
+    throw invalid(`limit must be an integer from 1 to 1000, not ${limit}`);
+  }
+  return { offset, limit };
+}
+var isDone = (item) => item.recipients.every((r) => r.status === "delivered" || r.status === "failed");
+function applyAttempt(item, result) {
+  const updates = new Map(result.recipients.map((u) => [u.address, u]));
+  const recipients = item.recipients.map((r) => {
+    const update = updates.get(r.address);
+    if (!update || r.status === "delivered" || r.status === "failed")
+      return r;
+    return {
+      address: r.address,
+      status: update.status,
+      ...update.reply ? { reply: update.reply } : {},
+      updatedAt: result.now
+    };
+  });
+  const { lease: _, ...rest } = item;
+  return {
+    ...rest,
+    recipients,
+    nextAttemptAt: result.nextAttemptAt,
+    attempts: result.attempts,
+    delayNotified: result.delayNotified
+  };
+}
+function newItem(id, item) {
+  return {
+    id,
+    from: item.from,
+    recipients: item.to.map((address) => ({ address, status: "pending" })),
+    size: item.message.length,
+    createdAt: item.createdAt,
+    nextAttemptAt: item.createdAt,
+    attempts: 0,
+    delayNotified: false
+  };
+}
+var claimable = (item, now) => item.nextAttemptAt <= now && (item.lease === undefined || item.lease.expiresAt <= now);
+
+export { checkTime, checkOwner, checkNewItem, checkMaxItems, checkClaim, checkResult, checkList, isDone, applyAttempt, newItem, claimable };
+
+//# debugId=70E823C3942B47A164756E2164756E21
+//# sourceMappingURL=index-xhsw4xcz.js.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/contract/checks.ts"],
+  "sourcesContent": [
+    "import { invalid } from '../errors';\nimport type {\n\tAttemptResult,\n\tClaimRequest,\n\tNewQueueItem,\n\tQueueItem,\n\tQueueListOptions,\n\tRecipientState,\n} from './types';\n\n/** What every store checks the same way, so each refuses the same input with the same error. */\n\nconst isTime = (value: unknown): value is number =>\n\ttypeof value === 'number' && Number.isFinite(value);\n\n/** A time in milliseconds since the epoch, or `INVALID` naming it. */\nexport function checkTime(name: string, value: unknown): number {\n\tif (!isTime(value)) throw invalid(`${name} must be a finite number`);\n\treturn value;\n}\n\n/** A lease owner: a non-empty string. */\nexport function checkOwner(owner: unknown): string {\n\tif (typeof owner !== 'string' || owner === '') {\n\t\tthrow invalid('owner must be a non-empty string');\n\t}\n\treturn owner;\n}\n\nexport function checkNewItem(item: NewQueueItem): void {\n\tif (typeof item !== 'object' || item === null) {\n\t\tthrow invalid('A new item is an object');\n\t}\n\tif (typeof item.from !== 'string') throw invalid('from must be a string');\n\tconst to = item.to as unknown;\n\tif (\n\t\t!Array.isArray(to) ||\n\t\tto.length === 0 ||\n\t\t!to.every((a) => typeof a === 'string' && a !== '')\n\t) {\n\t\tthrow invalid('to must be a non-empty array of addresses');\n\t}\n\tif (!(item.message instanceof Uint8Array)) {\n\t\tthrow invalid('message must be a Uint8Array');\n\t}\n\tcheckTime('createdAt', item.createdAt);\n}\n\n/** `maxItems`: a positive integer, or nothing. */\nexport function checkMaxItems(max: unknown): number | undefined {\n\tif (max === undefined) return undefined;\n\tif (typeof max !== 'number' || !Number.isInteger(max) || max < 1) {\n\t\tthrow invalid(`maxItems must be an integer of at least 1, not ${max}`);\n\t}\n\treturn max;\n}\n\nexport function checkClaim(request: ClaimRequest): void {\n\tif (typeof request !== 'object' || request === null) {\n\t\tthrow invalid('A claim is an object');\n\t}\n\tcheckOwner(request.owner);\n\tcheckTime('now', request.now);\n\tif (!isTime(request.leaseMs) || request.leaseMs <= 0) {\n\t\tthrow invalid('leaseMs must be a positive number');\n\t}\n}\n\nexport function checkResult(result: AttemptResult): void {\n\tif (typeof result !== 'object' || result === null) {\n\t\tthrow invalid('An attempt result is an object');\n\t}\n\tcheckTime('now', result.now);\n\tcheckTime('nextAttemptAt', result.nextAttemptAt);\n\tif (!Number.isInteger(result.attempts) || result.attempts < 0) {\n\t\tthrow invalid('attempts must be an integer of at least 0');\n\t}\n\tif (typeof result.delayNotified !== 'boolean') {\n\t\tthrow invalid('delayNotified must be true or false');\n\t}\n\tconst statuses = ['delivered', 'deferred', 'failed'];\n\tif (\n\t\t!Array.isArray(result.recipients) ||\n\t\t!result.recipients.every(\n\t\t\t(u) => typeof u?.address === 'string' && statuses.includes(u.status),\n\t\t)\n\t) {\n\t\tthrow invalid(\n\t\t\t'recipients must be an array of { address, status: delivered, deferred or failed }',\n\t\t);\n\t}\n}\n\n/** The offset and limit of a list: integers, the limit 1 to 1000. */\nexport function checkList(options: QueueListOptions = {}): {\n\toffset: number;\n\tlimit: number;\n} {\n\tconst offset = options.offset ?? 0;\n\tconst limit = options.limit ?? 100;\n\tif (!Number.isInteger(offset) || offset < 0) {\n\t\tthrow invalid(`offset must be an integer of at least 0, not ${offset}`);\n\t}\n\tif (!Number.isInteger(limit) || limit < 1 || limit > 1000) {\n\t\tthrow invalid(`limit must be an integer from 1 to 1000, not ${limit}`);\n\t}\n\treturn { offset, limit };\n}\n\n/** Every recipient is `delivered` or `failed`. */\nexport const isDone = (item: Pick<QueueItem, 'recipients'>): boolean =>\n\titem.recipients.every(\n\t\t(r) => r.status === 'delivered' || r.status === 'failed',\n\t);\n\n/**\n * The item once an attempt is recorded: its recipients' outcomes, a final\n * state never changed again, the schedule, and no lease.\n */\nexport function applyAttempt(\n\titem: QueueItem,\n\tresult: AttemptResult,\n): QueueItem {\n\tconst updates = new Map(result.recipients.map((u) => [u.address, u]));\n\tconst recipients = item.recipients.map((r): RecipientState => {\n\t\tconst update = updates.get(r.address);\n\t\tif (!update || r.status === 'delivered' || r.status === 'failed') return r;\n\t\treturn {\n\t\t\taddress: r.address,\n\t\t\tstatus: update.status,\n\t\t\t...(update.reply ? { reply: update.reply } : {}),\n\t\t\tupdatedAt: result.now,\n\t\t};\n\t});\n\tconst { lease: _, ...rest } = item;\n\treturn {\n\t\t...rest,\n\t\trecipients,\n\t\tnextAttemptAt: result.nextAttemptAt,\n\t\tattempts: result.attempts,\n\t\tdelayNotified: result.delayNotified,\n\t};\n}\n\n/** A new item as a store first keeps it. */\nexport function newItem(id: string, item: NewQueueItem): QueueItem {\n\treturn {\n\t\tid,\n\t\tfrom: item.from,\n\t\trecipients: item.to.map((address) => ({ address, status: 'pending' })),\n\t\tsize: item.message.length,\n\t\tcreatedAt: item.createdAt,\n\t\tnextAttemptAt: item.createdAt,\n\t\tattempts: 0,\n\t\tdelayNotified: false,\n\t};\n}\n\n/** Whether a lease, if any, leaves the item free to claim at `now`. */\nexport const claimable = (item: QueueItem, now: number): boolean =>\n\titem.nextAttemptAt <= now &&\n\t(item.lease === undefined || item.lease.expiresAt <= now);\n"
+  ],
+  "mappings": ";;;;;AAYA,IAAM,SAAS,CAAC,UACf,OAAO,UAAU,YAAY,OAAO,SAAS,KAAK;AAG5C,SAAS,SAAS,CAAC,MAAc,OAAwB;AAAA,EAC/D,IAAI,CAAC,OAAO,KAAK;AAAA,IAAG,MAAM,QAAQ,GAAG,8BAA8B;AAAA,EACnE,OAAO;AAAA;AAID,SAAS,UAAU,CAAC,OAAwB;AAAA,EAClD,IAAI,OAAO,UAAU,YAAY,UAAU,IAAI;AAAA,IAC9C,MAAM,QAAQ,kCAAkC;AAAA,EACjD;AAAA,EACA,OAAO;AAAA;AAGD,SAAS,YAAY,CAAC,MAA0B;AAAA,EACtD,IAAI,OAAO,SAAS,YAAY,SAAS,MAAM;AAAA,IAC9C,MAAM,QAAQ,yBAAyB;AAAA,EACxC;AAAA,EACA,IAAI,OAAO,KAAK,SAAS;AAAA,IAAU,MAAM,QAAQ,uBAAuB;AAAA,EACxE,MAAM,KAAK,KAAK;AAAA,EAChB,IACC,CAAC,MAAM,QAAQ,EAAE,KACjB,GAAG,WAAW,KACd,CAAC,GAAG,MAAM,CAAC,MAAM,OAAO,MAAM,YAAY,MAAM,EAAE,GACjD;AAAA,IACD,MAAM,QAAQ,2CAA2C;AAAA,EAC1D;AAAA,EACA,IAAI,EAAE,KAAK,mBAAmB,aAAa;AAAA,IAC1C,MAAM,QAAQ,8BAA8B;AAAA,EAC7C;AAAA,EACA,UAAU,aAAa,KAAK,SAAS;AAAA;AAI/B,SAAS,aAAa,CAAC,KAAkC;AAAA,EAC/D,IAAI,QAAQ;AAAA,IAAW;AAAA,EACvB,IAAI,OAAO,QAAQ,YAAY,CAAC,OAAO,UAAU,GAAG,KAAK,MAAM,GAAG;AAAA,IACjE,MAAM,QAAQ,kDAAkD,KAAK;AAAA,EACtE;AAAA,EACA,OAAO;AAAA;AAGD,SAAS,UAAU,CAAC,SAA6B;AAAA,EACvD,IAAI,OAAO,YAAY,YAAY,YAAY,MAAM;AAAA,IACpD,MAAM,QAAQ,sBAAsB;AAAA,EACrC;AAAA,EACA,WAAW,QAAQ,KAAK;AAAA,EACxB,UAAU,OAAO,QAAQ,GAAG;AAAA,EAC5B,IAAI,CAAC,OAAO,QAAQ,OAAO,KAAK,QAAQ,WAAW,GAAG;AAAA,IACrD,MAAM,QAAQ,mCAAmC;AAAA,EAClD;AAAA;AAGM,SAAS,WAAW,CAAC,QAA6B;AAAA,EACxD,IAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AAAA,IAClD,MAAM,QAAQ,gCAAgC;AAAA,EAC/C;AAAA,EACA,UAAU,OAAO,OAAO,GAAG;AAAA,EAC3B,UAAU,iBAAiB,OAAO,aAAa;AAAA,EAC/C,IAAI,CAAC,OAAO,UAAU,OAAO,QAAQ,KAAK,OAAO,WAAW,GAAG;AAAA,IAC9D,MAAM,QAAQ,2CAA2C;AAAA,EAC1D;AAAA,EACA,IAAI,OAAO,OAAO,kBAAkB,WAAW;AAAA,IAC9C,MAAM,QAAQ,qCAAqC;AAAA,EACpD;AAAA,EACA,MAAM,WAAW,CAAC,aAAa,YAAY,QAAQ;AAAA,EACnD,IACC,CAAC,MAAM,QAAQ,OAAO,UAAU,KAChC,CAAC,OAAO,WAAW,MAClB,CAAC,MAAM,OAAO,GAAG,YAAY,YAAY,SAAS,SAAS,EAAE,MAAM,CACpE,GACC;AAAA,IACD,MAAM,QACL,mFACD;AAAA,EACD;AAAA;AAIM,SAAS,SAAS,CAAC,UAA4B,CAAC,GAGrD;AAAA,EACD,MAAM,SAAS,QAAQ,UAAU;AAAA,EACjC,MAAM,QAAQ,QAAQ,SAAS;AAAA,EAC/B,IAAI,CAAC,OAAO,UAAU,MAAM,KAAK,SAAS,GAAG;AAAA,IAC5C,MAAM,QAAQ,gDAAgD,QAAQ;AAAA,EACvE;AAAA,EACA,IAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ,MAAM;AAAA,IAC1D,MAAM,QAAQ,gDAAgD,OAAO;AAAA,EACtE;AAAA,EACA,OAAO,EAAE,QAAQ,MAAM;AAAA;AAIjB,IAAM,SAAS,CAAC,SACtB,KAAK,WAAW,MACf,CAAC,MAAM,EAAE,WAAW,eAAe,EAAE,WAAW,QACjD;AAMM,SAAS,YAAY,CAC3B,MACA,QACY;AAAA,EACZ,MAAM,UAAU,IAAI,IAAI,OAAO,WAAW,IAAI,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AAAA,EACpE,MAAM,aAAa,KAAK,WAAW,IAAI,CAAC,MAAsB;AAAA,IAC7D,MAAM,SAAS,QAAQ,IAAI,EAAE,OAAO;AAAA,IACpC,IAAI,CAAC,UAAU,EAAE,WAAW,eAAe,EAAE,WAAW;AAAA,MAAU,OAAO;AAAA,IACzE,OAAO;AAAA,MACN,SAAS,EAAE;AAAA,MACX,QAAQ,OAAO;AAAA,SACX,OAAO,QAAQ,EAAE,OAAO,OAAO,MAAM,IAAI,CAAC;AAAA,MAC9C,WAAW,OAAO;AAAA,IACnB;AAAA,GACA;AAAA,EACD,QAAQ,OAAO,MAAM,SAAS;AAAA,EAC9B,OAAO;AAAA,OACH;AAAA,IACH;AAAA,IACA,eAAe,OAAO;AAAA,IACtB,UAAU,OAAO;AAAA,IACjB,eAAe,OAAO;AAAA,EACvB;AAAA;AAIM,SAAS,OAAO,CAAC,IAAY,MAA+B;AAAA,EAClE,OAAO;AAAA,IACN;AAAA,IACA,MAAM,KAAK;AAAA,IACX,YAAY,KAAK,GAAG,IAAI,CAAC,aAAa,EAAE,SAAS,QAAQ,UAAU,EAAE;AAAA,IACrE,MAAM,KAAK,QAAQ;AAAA,IACnB,WAAW,KAAK;AAAA,IAChB,eAAe,KAAK;AAAA,IACpB,UAAU;AAAA,IACV,eAAe;AAAA,EAChB;AAAA;AAIM,IAAM,YAAY,CAAC,MAAiB,QAC1C,KAAK,iBAAiB,QACrB,KAAK,UAAU,aAAa,KAAK,MAAM,aAAa;",
+  "debugId": "70E823C3942B47A164756E2164756E21",
+  "names": []
+}

package/dist/contract/checks.d.ts

@@ -0,0 +1,27 @@
+import type { AttemptResult, ClaimRequest, NewQueueItem, QueueItem, QueueListOptions } from './types';
+/** A time in milliseconds since the epoch, or `INVALID` naming it. */
+export declare function checkTime(name: string, value: unknown): number;
+/** A lease owner: a non-empty string. */
+export declare function checkOwner(owner: unknown): string;
+export declare function checkNewItem(item: NewQueueItem): void;
+/** `maxItems`: a positive integer, or nothing. */
+export declare function checkMaxItems(max: unknown): number | undefined;
+export declare function checkClaim(request: ClaimRequest): void;
+export declare function checkResult(result: AttemptResult): void;
+/** The offset and limit of a list: integers, the limit 1 to 1000. */
+export declare function checkList(options?: QueueListOptions): {
+    offset: number;
+    limit: number;
+};
+/** Every recipient is `delivered` or `failed`. */
+export declare const isDone: (item: Pick<QueueItem, "recipients">) => boolean;
+/**
+ * The item once an attempt is recorded: its recipients' outcomes, a final
+ * state never changed again, the schedule, and no lease.
+ */
+export declare function applyAttempt(item: QueueItem, result: AttemptResult): QueueItem;
+/** A new item as a store first keeps it. */
+export declare function newItem(id: string, item: NewQueueItem): QueueItem;
+/** Whether a lease, if any, leaves the item free to claim at `now`. */
+export declare const claimable: (item: QueueItem, now: number) => boolean;
+//# sourceMappingURL=checks.d.ts.map

package/dist/contract/checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checks.d.ts","sourceRoot":"","sources":["../../src/contract/checks.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACX,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,gBAAgB,EAEhB,MAAM,SAAS,CAAC;AAOjB,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CAG9D;AAED,yCAAyC;AACzC,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAKjD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAiBrD;AAED,kDAAkD;AAClD,wBAAgB,aAAa,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAM9D;AAED,wBAAgB,UAAU,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,CAStD;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAuBvD;AAED,qEAAqE;AACrE,wBAAgB,SAAS,CAAC,OAAO,GAAE,gBAAqB,GAAG;IAC1D,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACd,CAUA;AAED,kDAAkD;AAClD,eAAO,MAAM,MAAM,GAAI,MAAM,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,KAAG,OAG3D,CAAC;AAEH;;;GAGG;AACH,wBAAgB,YAAY,CAC3B,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,aAAa,GACnB,SAAS,CAoBX;AAED,4CAA4C;AAC5C,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,SAAS,CAWjE;AAED,uEAAuE;AACvE,eAAO,MAAM,SAAS,GAAI,MAAM,SAAS,EAAE,KAAK,MAAM,KAAG,OAEC,CAAC"}

package/dist/contract/queue-store.d.ts

@@ -0,0 +1,60 @@
+import type { AddOptions, AttemptResult, ClaimRequest, NewQueueItem, QueueItem, QueueListOptions } from './types';
+/**
+ * Where the queue keeps its items, made for several workers, in one
+ * process or many, sharing one store. A worker **claims** a due item: it
+ * gets a lease, an owner and an expiry, and no other worker gets the item
+ * until the lease expires — a worker that crashed loses it then, and
+ * another claims it. Its owner renews the lease while it delivers, records
+ * the outcome with `complete`, which lets go of the lease, or gives the
+ * item back with `reschedule`.
+ *
+ * An item whose every recipient is `delivered` or `failed` is done: the
+ * store drops it, and its message, in the same step. Times are
+ * milliseconds since the epoch, given by the caller: a store keeps no
+ * clock. Nothing a store returns is shared with what it keeps.
+ */
+export interface QueueStore {
+    /**
+     * Adds an item, due at once, with every recipient `pending`. With
+     * `maxItems`, refuses with `QUEUE_FULL` when the store holds that many
+     * already, in the same step as the add.
+     */
+    add(item: NewQueueItem, options?: AddOptions): Promise<QueueItem>;
+    /** The item, or `undefined` when there is none by that id (done, cancelled, or never added). */
+    get(id: string): Promise<QueueItem | undefined>;
+    /** The items, the next due first; done items are gone. */
+    list(options?: QueueListOptions): Promise<QueueItem[]>;
+    /** How many items the store holds. */
+    count(): Promise<number>;
+    /** The message of an item, or `undefined` once the item is gone. */
+    readMessage(id: string): Promise<Uint8Array | undefined>;
+    /**
+     * Takes the next item due at `now` — no lease, or a lease expired —
+     * and gives it a lease of `leaseMs` for `owner`, atomically: two
+     * claimers never take the same item. The earliest due goes first, then
+     * the oldest. `undefined` when nothing is due.
+     */
+    claim(request: ClaimRequest): Promise<QueueItem | undefined>;
+    /**
+     * Moves the lease's expiry, while `owner` still holds it. False when it
+     * does not: another worker claimed the item, or it is gone.
+     */
+    renew(id: string, owner: string, expiresAt: number): Promise<boolean>;
+    /**
+     * Records an attempt: each recipient's outcome, the next attempt and the
+     * count, and lets go of the lease — in one step, while `owner` holds it.
+     * Returns the item as it now stands, done (every recipient final, and
+     * the item dropped) or not; `undefined` when `owner` no longer holds it.
+     */
+    complete(id: string, owner: string, result: AttemptResult): Promise<QueueItem | undefined>;
+    /**
+     * Moves the next attempt to `at`. With `owner`, only while that owner
+     * holds the lease, which it lets go of: a worker giving an item back.
+     * Without, whoever holds it keeps the lease: an admin's "retry now".
+     * False when the item is gone, or `owner` does not hold it.
+     */
+    reschedule(id: string, at: number, owner?: string): Promise<boolean>;
+    /** Drops an item and its message, leased or not; the item as it stood, or `undefined`. */
+    cancel(id: string): Promise<QueueItem | undefined>;
+}
+//# sourceMappingURL=queue-store.d.ts.map

package/dist/contract/queue-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue-store.d.ts","sourceRoot":"","sources":["../../src/contract/queue-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,UAAU,EACV,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IAElE,gGAAgG;IAChG,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAEhD,0DAA0D;IAC1D,IAAI,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC;IAEvD,sCAAsC;IACtC,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAEzB,oEAAoE;IACpE,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC;IAEzD;;;;;OAKG;IACH,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAE7D;;;OAGG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAEtE;;;;;OAKG;IACH,QAAQ,CACP,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,aAAa,GACnB,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;IAElC;;;;;OAKG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAErE,0FAA0F;IAC1F,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC;CACnD"}

package/dist/contract/types.d.ts

@@ -0,0 +1,102 @@
+/**
+ * Where one recipient stands. `pending`: not tried yet. `deferred`: a
+ * temporary failure, tried again later. `delivered` and `failed` are
+ * final.
+ */
+export type RecipientStatus = 'pending' | 'delivered' | 'deferred' | 'failed';
+/** The final states: the queue never tries such a recipient again. */
+export type FinalStatus = 'delivered' | 'failed';
+/**
+ * What the other side said, or why nobody said anything: the SMTP reply
+ * (RFC 5321 §4.2) with its enhanced status code (RFC 3463), or, with no
+ * `code`, the connection error or the timeout. The text is bounded and
+ * holds no control character.
+ */
+export interface Diagnostic {
+    /** The reply code; absent when no server answered. */
+    readonly code?: number;
+    /** The enhanced status code, `x.y.z`. */
+    readonly status?: string;
+    readonly text: string;
+    /** The host that answered, or that the attempt was for. */
+    readonly host?: string;
+}
+export interface RecipientState {
+    /** `local@domain`, as enqueued. */
+    readonly address: string;
+    readonly status: RecipientStatus;
+    /** The last answer for this recipient. */
+    readonly reply?: Diagnostic;
+    /** When the status last changed, in milliseconds since the epoch. */
+    readonly updatedAt?: number;
+}
+/** Who is delivering an item, until when. */
+export interface Lease {
+    readonly owner: string;
+    /** Milliseconds since the epoch; past it, another worker may claim the item. */
+    readonly expiresAt: number;
+}
+/** A message in the queue, and where each of its recipients stands. */
+export interface QueueItem {
+    readonly id: string;
+    /** The reverse-path; `''` for the null sender of a DSN. */
+    readonly from: string;
+    readonly recipients: readonly RecipientState[];
+    /** The message's size in bytes. */
+    readonly size: number;
+    /** Milliseconds since the epoch. */
+    readonly createdAt: number;
+    /** When the item is due next, in milliseconds since the epoch. */
+    readonly nextAttemptAt: number;
+    /** How many attempts were made. */
+    readonly attempts: number;
+    /** The "delayed" DSN was sent for it. */
+    readonly delayNotified: boolean;
+    /** Present while a worker holds the item. */
+    readonly lease?: Lease;
+}
+/** What `add` takes. */
+export interface NewQueueItem {
+    readonly from: string;
+    /** One address or more, each once. */
+    readonly to: readonly string[];
+    /** The whole message, as it will be sent. */
+    readonly message: Uint8Array;
+    /** Milliseconds since the epoch; due at once. */
+    readonly createdAt: number;
+}
+export interface AddOptions {
+    /** Refuse with `QUEUE_FULL` when the store already holds this many items. */
+    readonly maxItems?: number;
+}
+/** What `claim` takes: who claims, at what time, for how long. */
+export interface ClaimRequest {
+    readonly owner: string;
+    /** Milliseconds since the epoch. */
+    readonly now: number;
+    /** How long the lease lasts, in milliseconds. */
+    readonly leaseMs: number;
+}
+/** One recipient's outcome in an attempt. */
+export interface RecipientUpdate {
+    readonly address: string;
+    readonly status: Exclude<RecipientStatus, 'pending'>;
+    readonly reply?: Diagnostic;
+}
+/** What `complete` records: the attempt's outcomes, and when to try again. */
+export interface AttemptResult {
+    /** Milliseconds since the epoch: when the outcomes were known. */
+    readonly now: number;
+    /** The recipients this attempt reached; the others keep their state. */
+    readonly recipients: readonly RecipientUpdate[];
+    readonly nextAttemptAt: number;
+    readonly attempts: number;
+    readonly delayNotified: boolean;
+}
+export interface QueueListOptions {
+    /** Default 0. */
+    readonly offset?: number;
+    /** Default 100. */
+    readonly limit?: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/contract/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/contract/types.ts"],"names":[],"mappings":"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"}