@bumail/queue 0.1.0

package/dist/index.js

@@ -0,0 +1,1089 @@
+import {
+  QueueError2,
+  invalid
+} from "./chunks/index-p4k4rjb7.js";
+// src/queue/envelope.ts
+import { isMailbox } from "@bumail/smtp/client";
+
+// src/text.ts
+var isControl = (code) => code < 32 || code >= 127 && code <= 159;
+function hasControl(text) {
+  for (let i = 0;i < text.length; i++) {
+    if (isControl(text.charCodeAt(i)))
+      return true;
+  }
+  return false;
+}
+function replaceControls(text, by) {
+  let out = "";
+  for (let i = 0;i < text.length; i++) {
+    out += isControl(text.charCodeAt(i)) ? by : text[i];
+  }
+  return out;
+}
+function cleanText(text, max) {
+  const clean = replaceControls(text, " ").replace(/ {2,}/g, " ").trim();
+  return clean.length > max ? `${clean.slice(0, max - 3)}...` : clean;
+}
+var asciiText = (text, max) => cleanText(text, max).replace(/[^ -~]/g, "?");
+
+// src/queue/envelope.ts
+var ADDRESS = /^[^\s<>]{1,64}@[^\s<>@]{1,253}$/u;
+function checkAddress(name, address) {
+  if (typeof address !== "string" || address.length > 254 || hasControl(address) || !ADDRESS.test(address) || !isMailbox(address)) {
+    throw invalid(`${name} must be an address, local@domain, not ${JSON.stringify(address)}`);
+  }
+  return address;
+}
+var domainOf = (address) => address.slice(address.lastIndexOf("@") + 1).toLowerCase();
+function checkEnvelope(envelope, maxRecipients) {
+  if (typeof envelope !== "object" || envelope === null) {
+    throw invalid("The envelope is an object: { from, to }");
+  }
+  const from = envelope.from === "" ? "" : checkAddress("from", envelope.from);
+  const list = typeof envelope.to === "string" ? [envelope.to] : envelope.to;
+  if (!Array.isArray(list) || list.length === 0) {
+    throw invalid("to must hold one recipient or more");
+  }
+  const seen = new Set;
+  const to = [];
+  for (const address of list) {
+    checkAddress("Each recipient", address);
+    const key = `${address.slice(0, address.lastIndexOf("@"))}@${domainOf(address)}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    to.push(address);
+  }
+  if (to.length > maxRecipients) {
+    throw new QueueError2("TOO_MANY_RECIPIENTS", `The message has ${to.length} recipients; the limit is ${maxRecipients}`);
+  }
+  return { from, to };
+}
+var tooBig = (max) => new QueueError2("MESSAGE_TOO_BIG", `The message is larger than the limit of ${max} bytes`);
+var CR = 13;
+var LF = 10;
+function checkLineEnds(bytes) {
+  for (let i = 0;i < bytes.length; i++) {
+    const byte = bytes[i];
+    const bare = byte === CR ? bytes[i + 1] !== LF : byte === LF && (i === 0 || bytes[i - 1] !== CR);
+    if (bare) {
+      throw invalid(`The message has a bare CR or LF at byte ${i}: every line must end in CRLF`);
+    }
+  }
+}
+async function readMessage(source, max) {
+  if (typeof source === "string")
+    source = new TextEncoder().encode(source);
+  if (source instanceof Uint8Array) {
+    if (source.length > max)
+      throw tooBig(max);
+    return source.slice();
+  }
+  if (!(source instanceof ReadableStream)) {
+    throw invalid("The message is a Uint8Array, a string or a ReadableStream<Uint8Array>");
+  }
+  const chunks = [];
+  let size = 0;
+  const reader = source.getReader();
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!(value instanceof Uint8Array)) {
+        throw invalid("The message stream must give Uint8Array chunks");
+      }
+      size += value.length;
+      if (size > max)
+        throw tooBig(max);
+      chunks.push(value);
+    }
+  } catch (error) {
+    await reader.cancel().catch(() => {});
+    throw error;
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(size);
+  let at = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, at);
+    at += chunk.length;
+  }
+  return bytes;
+}
+
+// src/queue/events.ts
+class Events {
+  #listeners = new Map;
+  on(event, listener) {
+    let set = this.#listeners.get(event);
+    if (!set) {
+      set = new Set;
+      this.#listeners.set(event, set);
+    }
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+    };
+  }
+  emit(event, payload) {
+    for (const listener of this.#listeners.get(event) ?? []) {
+      try {
+        listener(payload);
+      } catch {}
+    }
+  }
+}
+
+// src/queue/settings/index.ts
+import { sendMail } from "@bumail/smtp/client";
+
+// src/queue/settings/numbers.ts
+var MINUTE = 60000;
+var HOUR = 60 * MINUTE;
+var MAX_TIMER = 2147483647;
+function numberOf(name, value, fallback, min, max = Number.MAX_SAFE_INTEGER, integer = true) {
+  if (value === undefined)
+    return fallback;
+  const ok = typeof value === "number" && (integer ? Number.isInteger(value) : Number.isFinite(value)) && value >= min && value <= max;
+  if (!ok) {
+    const kind = integer ? "an integer" : "a number";
+    const range = max === Number.MAX_SAFE_INTEGER ? `of at least ${min}` : `from ${min} to ${max}`;
+    throw invalid(`${name} must be ${kind} ${range}, not ${value}`);
+  }
+  return value;
+}
+
+// src/queue/settings/dsn.ts
+function dsnOf(options, hostname) {
+  const d = options.dsn ?? {};
+  const from = checkAddress("dsn.from", d.from ?? `postmaster@${hostname}`);
+  const delayAfter = d.delayAfter === false ? false : numberOf("dsn.delayAfter", d.delayAfter, 4 * HOUR, 0);
+  const returnContent = d.returnContent ?? "headers";
+  if (returnContent !== "headers" && returnContent !== "full") {
+    throw invalid(`dsn.returnContent must be 'headers' or 'full', not ${returnContent}`);
+  }
+  return { from, delayAfter, returnContent };
+}
+
+// src/queue/settings/limits.ts
+function retryOf(options) {
+  const r = options.retry ?? {};
+  const first = numberOf("retry.first", r.first, 30 * MINUTE, 1);
+  return {
+    first,
+    factor: numberOf("retry.factor", r.factor, 2, 1, 100, false),
+    max: numberOf("retry.max", r.max, Math.max(first, 4 * HOUR), first),
+    jitter: numberOf("retry.jitter", r.jitter, 0.1, 0, 1, false),
+    giveUpAfter: numberOf("retry.giveUpAfter", r.giveUpAfter, 120 * HOUR, 0)
+  };
+}
+function limitsOf(options) {
+  const l = options.limits ?? {};
+  return {
+    maxMessageSize: numberOf("limits.maxMessageSize", l.maxMessageSize, 25 * 1024 * 1024, 1),
+    maxRecipients: numberOf("limits.maxRecipients", l.maxRecipients, 100, 1),
+    maxItems: l.maxItems === undefined ? undefined : numberOf("limits.maxItems", l.maxItems, 0, 1),
+    maxReplyText: numberOf("limits.maxReplyText", l.maxReplyText, 512, 64, 900),
+    maxDsnReturn: numberOf("limits.maxDsnReturn", l.maxDsnReturn, 64 * 1024, 0)
+  };
+}
+
+// src/queue/settings/sessions.ts
+var MAX_SECONDS = Math.floor(MAX_TIMER / 1000);
+function checkSeconds(name, value) {
+  if (value === undefined)
+    return;
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0 || value > MAX_SECONDS) {
+    throw invalid(`${name} must be a number of seconds above 0 and at most ${MAX_SECONDS}, not ${value}`);
+  }
+}
+function checkTls(name, tls) {
+  if (tls !== undefined && tls !== "opportunistic" && tls !== "required" && tls !== "none") {
+    throw invalid(`${name} must be 'opportunistic', 'required' or 'none', not ${tls}`);
+  }
+}
+function checkSessions(options) {
+  numberOf("mxPort", options.mxPort, 25, 1, 65535);
+  checkTls("mxTls", options.mxTls);
+  const timeouts = options.timeouts;
+  if (timeouts !== undefined) {
+    if (typeof timeouts !== "object" || timeouts === null) {
+      throw invalid("timeouts must be an object of seconds");
+    }
+    for (const [step, value] of Object.entries(timeouts)) {
+      checkSeconds(`timeouts.${step}`, value);
+    }
+  }
+  checkSeconds("deadline", options.deadline);
+}
+
+// src/queue/settings/routes.ts
+function checkRoute(name, route) {
+  if (route === "mx")
+    return;
+  const smarthost = route;
+  const host = smarthost?.host;
+  if (typeof host !== "string" || !/^[^\s/]+$/.test(host)) {
+    throw invalid(`${name} must be 'mx' or a smarthost with a host`);
+  }
+  const { port, secure, tls, auth } = smarthost;
+  numberOf(`${name}.port`, port, 25, 1, 65535);
+  if (secure !== undefined && typeof secure !== "boolean") {
+    throw invalid(`${name}.secure must be true or false, not ${secure}`);
+  }
+  checkTls(`${name}.tls`, tls);
+  if (tls === "none" && secure) {
+    throw invalid(`${name}.secure is TLS from the first byte: it cannot go with tls: 'none'`);
+  }
+  if (auth === undefined)
+    return;
+  if (typeof auth?.username !== "string" || auth.username === "") {
+    throw invalid(`${name}.auth.username must be a non-empty string`);
+  }
+  if (typeof auth.password !== "string" || auth.password === "") {
+    throw invalid(`${name}.auth.password must be a non-empty string`);
+  }
+  const { mechanism } = auth;
+  if (mechanism !== undefined && mechanism !== "PLAIN" && mechanism !== "LOGIN") {
+    throw invalid(`${name}.auth.mechanism must be 'PLAIN' or 'LOGIN', not ${mechanism}`);
+  }
+  if (tls !== undefined && tls !== "required") {
+    throw invalid(`${name}.auth needs tls: 'required', the default with auth: with tls: '${tls}' the password would go to a server whose certificate is not checked`);
+  }
+}
+function checkRoutes(options) {
+  checkRoute("route", options.route ?? "mx");
+  const routes = Object.entries(options.routes ?? {});
+  for (const [domain, route] of routes)
+    checkRoute(`routes["${domain}"]`, route);
+  const usesMx = (options.route ?? "mx") === "mx" || routes.some(([, r]) => r === "mx");
+  if (usesMx && typeof options.resolver?.mx !== "function") {
+    throw invalid("The 'mx' route needs a resolver, such as @bumail/dns's nodeResolver()");
+  }
+}
+
+// src/queue/settings/index.ts
+var HOSTNAME = /^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?)*$/;
+function settingsOf(options) {
+  if (typeof options !== "object" || options === null) {
+    throw invalid("createQueue() takes an options object");
+  }
+  if (typeof options.store?.claim !== "function") {
+    throw invalid("store must be a QueueStore, such as MemoryQueueStore");
+  }
+  const { hostname } = options;
+  if (typeof hostname !== "string" || !HOSTNAME.test(hostname)) {
+    throw invalid(`hostname must be this server's public host name, not ${hostname}`);
+  }
+  checkRoutes(options);
+  checkSessions(options);
+  const owner = options.owner ?? crypto.randomUUID();
+  if (typeof owner !== "string" || owner === "") {
+    throw invalid("owner must be a non-empty string");
+  }
+  const clock = options.clock;
+  return {
+    options,
+    hostname,
+    routes: new Map(Object.entries(options.routes ?? {}).map(([d, r]) => [
+      d.toLowerCase(),
+      r
+    ])),
+    retry: retryOf(options),
+    limits: limitsOf(options),
+    dsn: dsnOf(options, hostname),
+    concurrency: numberOf("concurrency", options.concurrency, 20, 1),
+    perDomain: numberOf("perDomain", options.perDomain, 2, 1),
+    leaseMs: numberOf("leaseMs", options.leaseMs, 10 * MINUTE, 1000, 3 * MAX_TIMER),
+    pollInterval: numberOf("pollInterval", options.pollInterval, 5000, 1, MAX_TIMER),
+    owner,
+    now: clock ? () => clock.now() : Date.now,
+    send: options.send ?? sendMail,
+    random: options.random ?? Math.random
+  };
+}
+
+// src/queue/deliver.ts
+import { isMailbox as isMailbox2 } from "@bumail/smtp/client";
+
+// src/dsn/build.ts
+import {
+  encodeHeaderValue,
+  encodeQuotedPrintable,
+  foldHeader as foldHeader2,
+  formatDate as formatDate2
+} from "@bumail/mime";
+
+// src/dsn/content.ts
+var CR2 = 13;
+var LF2 = 10;
+var MAX_LINE = 998;
+var isContinuation = (byte) => byte !== undefined && byte >= 128 && byte < 192;
+function crlf(bytes) {
+  const out = [];
+  let column = 0;
+  for (let i = 0;i < bytes.length; i++) {
+    const byte = bytes[i];
+    if (byte === CR2 || byte === LF2) {
+      out.push(CR2, LF2);
+      column = 0;
+      if (byte === CR2 && bytes[i + 1] === LF2)
+        i++;
+    } else if (column < MAX_LINE) {
+      out.push(byte);
+      column++;
+    } else if (column === MAX_LINE) {
+      if (isContinuation(byte)) {
+        while (isContinuation(out.at(-1))) {
+          out.pop();
+        }
+        if ((out.at(-1) ?? 0) >= 192)
+          out.pop();
+      }
+      column++;
+    }
+  }
+  return Uint8Array.from(out);
+}
+function headerEnd(bytes) {
+  for (let i = 0;i + 3 < bytes.length; i++) {
+    if (bytes[i] === CR2 && bytes[i + 1] === LF2 && bytes[i + 2] === CR2 && bytes[i + 3] === LF2) {
+      return i + 2;
+    }
+  }
+  return bytes.length;
+}
+function wholeLines(bytes, max) {
+  if (bytes.length <= max)
+    return bytes;
+  const cut = bytes.subarray(0, max).lastIndexOf(LF2);
+  return bytes.subarray(0, cut + 1);
+}
+function returned(original, mode, max) {
+  const message = crlf(original.subarray(0, max * 2 + 2));
+  const whole = original.length <= max && message.length <= max;
+  const body = whole && mode === "full" ? message : wholeLines(message.subarray(0, headerEnd(message)), max);
+  return {
+    type: whole && mode === "full" ? "message/rfc822" : "text/rfc822-headers",
+    body,
+    eightBit: body.some((byte) => byte > 127)
+  };
+}
+
+// src/dsn/fields.ts
+import { foldHeader, formatDate } from "@bumail/mime";
+var strip = (text) => replaceControls(text, "");
+var MAX_ESCAPED = 900;
+function typedAddress(address) {
+  const clean = strip(address).replace(/[\s\\]/g, "");
+  if (/^[\x21-\x7e]*$/.test(clean))
+    return `rfc822; ${clean}`;
+  let escaped = "";
+  for (const c of clean) {
+    const piece = /[\x21-\x7e]/.test(c) ? c : `\\x{${(c.codePointAt(0) ?? 0).toString(16).toUpperCase()}}`;
+    if (escaped.length + piece.length > MAX_ESCAPED)
+      break;
+    escaped += piece;
+  }
+  return `utf-8; ${escaped}`;
+}
+var remoteMta = (host) => host && /^[A-Za-z0-9.:[\]-]{1,255}$/.test(host) ? `dns; ${host}` : undefined;
+function statusOf(kind, reply) {
+  if (reply?.status)
+    return reply.status;
+  if (reply?.code !== undefined) {
+    return reply.code >= 500 ? "5.0.0" : "4.0.0";
+  }
+  return kind === "failed" ? "5.0.0" : "4.0.0";
+}
+function recipientFields(report, recipient) {
+  const { reply } = recipient;
+  const fields = [
+    ["Final-Recipient", typedAddress(recipient.address)],
+    ["Action", report.kind],
+    ["Status", statusOf(report.kind, reply)]
+  ];
+  const remote = remoteMta(reply?.host);
+  if (remote)
+    fields.push(["Remote-MTA", remote]);
+  if (reply) {
+    const text = asciiText(reply.text, 900);
+    fields.push(reply.code === undefined ? ["Diagnostic-Code", `X-Bumail; ${text}`] : ["Diagnostic-Code", `smtp; ${reply.code} ${text}`]);
+  }
+  fields.push(["Last-Attempt-Date", formatDate(recipient.lastAttempt)]);
+  if (report.kind === "delayed" && report.willRetryUntil) {
+    fields.push(["Will-Retry-Until", formatDate(report.willRetryUntil)]);
+  }
+  return fields.map(([name, value]) => foldHeader(name, value));
+}
+function deliveryStatus(report) {
+  const message = [
+    foldHeader("Reporting-MTA", `dns; ${strip(report.reportingMta)}`),
+    foldHeader("Arrival-Date", formatDate(report.arrival))
+  ].join(`\r
+`);
+  const blocks = report.recipients.map((r) => recipientFields(report, r).join(`\r
+`));
+  return `${[message, ...blocks].join(`\r
+\r
+`)}\r
+`;
+}
+
+// src/dsn/build.ts
+var encoder = new TextEncoder;
+var strip2 = (text) => replaceControls(text, "").replace(/[\s<>]/g, "");
+function humanText(input) {
+  const failed = input.kind === "failed";
+  const lines = failed ? [
+    `This is the mail system at ${input.reportingMta}.`,
+    "",
+    "Your message could not be delivered to the recipients below.",
+    "This is a permanent failure: the message will not be retried."
+  ] : [
+    `This is the mail system at ${input.reportingMta}.`,
+    "",
+    "Your message has not been delivered yet to the recipients below.",
+    "This is a warning only: the message is still being retried",
+    ...input.willRetryUntil ? [`until ${formatDate2(input.willRetryUntil)}.`] : [],
+    "You do not need to send it again."
+  ];
+  lines.push("");
+  for (const r of input.recipients) {
+    const said = r.reply ? `${r.reply.code ?? ""} ${cleanText(r.reply.text, 900)}`.trim() : statusOf(input.kind);
+    const why = r.reply?.status === "4.4.7" ? `delivery time expired, still failing: ${said}` : said;
+    lines.push(`<${cleanText(r.address, 254)}>: ${why}`);
+  }
+  return `${lines.join(`\r
+`)}\r
+`;
+}
+function headerFields(input, boundary) {
+  const subject = input.kind === "failed" ? "Undelivered Mail Returned to Sender" : "Delayed Mail (still being retried)";
+  const domain = strip2(input.reportingMta);
+  return [
+    foldHeader2("Date", formatDate2(input.date)),
+    foldHeader2("From", `Mail Delivery System <${strip2(input.from)}>`),
+    foldHeader2("To", `<${strip2(input.to)}>`),
+    foldHeader2("Subject", encodeHeaderValue(subject)),
+    foldHeader2("Message-ID", `<${crypto.randomUUID()}@${domain}>`),
+    foldHeader2("Auto-Submitted", "auto-replied"),
+    foldHeader2("MIME-Version", "1.0"),
+    foldHeader2("Content-Type", `multipart/report; report-type=delivery-status; boundary="${boundary}"`)
+  ];
+}
+var concat = (parts) => {
+  const out = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+};
+function boundaryFor(content) {
+  const text = new TextDecoder("latin1").decode(content);
+  for (;; ) {
+    const boundary = `=_dsn_${crypto.randomUUID()}`;
+    if (!text.includes(boundary))
+      return boundary;
+  }
+}
+function buildDsn(input) {
+  const original = returned(input.original, input.returnContent, input.maxReturn);
+  const boundary = boundaryFor(original.body);
+  const text = encodeQuotedPrintable(humanText(input));
+  const status = deliveryStatus({
+    kind: input.kind,
+    reportingMta: input.reportingMta,
+    arrival: input.arrival,
+    recipients: input.recipients,
+    ...input.willRetryUntil ? { willRetryUntil: input.willRetryUntil } : {}
+  });
+  const head = [
+    ...headerFields(input, boundary),
+    "",
+    "This is a MIME-formatted delivery status notification.",
+    "",
+    `--${boundary}`,
+    "Content-Type: text/plain; charset=utf-8",
+    "Content-Transfer-Encoding: quoted-printable",
+    "",
+    text,
+    `--${boundary}`,
+    "Content-Type: message/delivery-status",
+    "",
+    status,
+    `--${boundary}`,
+    `Content-Type: ${original.type}`,
+    ...original.eightBit ? ["Content-Transfer-Encoding: 8bit"] : [],
+    "",
+    ""
+  ].join(`\r
+`);
+  return concat([
+    encoder.encode(head),
+    original.body,
+    encoder.encode(`\r
+--${boundary}--\r
+`)
+  ]);
+}
+
+// src/queue/retry.ts
+function retryDelay(attempts, retry, random) {
+  const exponent = Math.max(0, attempts - 1);
+  const delay = Math.min(retry.first * retry.factor ** exponent, retry.max);
+  return delay + delay * retry.jitter * Math.min(1, Math.max(0, random()));
+}
+var giveUpAt = (createdAt, retry) => createdAt + retry.giveUpAfter;
+function nextAttemptAt(createdAt, now, attempts, retry, random) {
+  const end = giveUpAt(createdAt, retry);
+  if (now >= end)
+    return;
+  return Math.min(now + retryDelay(attempts, retry, random), end);
+}
+
+// src/queue/notify.ts
+async function notify(ctx, item, message, kind, recipients, now) {
+  if (item.from === "" || recipients.length === 0)
+    return;
+  const { settings, store, events } = ctx;
+  try {
+    const lastAttempt = new Date(now);
+    const dsn = buildDsn({
+      kind,
+      reportingMta: settings.hostname,
+      from: settings.dsn.from,
+      to: item.from,
+      arrival: new Date(item.createdAt),
+      date: lastAttempt,
+      recipients: recipients.map((r) => ({
+        address: r.address,
+        ...r.reply ? { reply: r.reply } : {},
+        lastAttempt
+      })),
+      ...kind === "delayed" ? { willRetryUntil: new Date(giveUpAt(item.createdAt, settings.retry)) } : {},
+      original: message,
+      returnContent: settings.dsn.returnContent,
+      maxReturn: settings.limits.maxDsnReturn
+    });
+    const added = await store.add({
+      from: "",
+      to: [item.from],
+      message: dsn,
+      createdAt: now
+    });
+    events.emit("dsn", {
+      kind,
+      id: added.id,
+      of: item.id,
+      to: item.from,
+      recipients: recipients.map((r) => r.address)
+    });
+  } catch (error) {
+    events.emit("error", { error, id: item.id });
+  }
+}
+
+// src/queue/outcome.ts
+var isSmtpError = (error) => error instanceof Error && error.name === "SmtpError" && typeof error.code === "string";
+var isRouteError = (error) => isSmtpError(error) && error.code === "INVALID_OPTION";
+var STATUS = /^[245]\.\d{1,3}\.\d{1,3}$/;
+function diagnosticOf(reply, max, host) {
+  const text = typeof reply.text === "string" ? reply.text : reply.text.join(" ");
+  return {
+    code: reply.code,
+    ...reply.status && STATUS.test(reply.status) ? { status: reply.status } : {},
+    text: cleanText(text, max),
+    ...host ? { host: cleanText(host, 255) } : {}
+  };
+}
+var ERROR_STATUS = {
+  NULL_MX: "1.10",
+  DNS_FAILED: "1.2",
+  CONNECTION_FAILED: "4.1",
+  CONNECTION_LOST: "4.2",
+  TIMEOUT: "4.2",
+  TLS_UNAVAILABLE: "7.10",
+  TLS_FAILED: "7.0",
+  AUTH_UNAVAILABLE: "7.0",
+  INVALID_OPTION: "3.5"
+};
+function diagnosticOfError(error, temporary, max, host) {
+  const text = error instanceof Error ? error.message : String(error);
+  const detail = isSmtpError(error) ? ERROR_STATUS[error.code] ?? "0.0" : "0.0";
+  return {
+    status: `${temporary ? 4 : 5}.${detail}`,
+    text: cleanText(text, max),
+    ...host ? { host } : {}
+  };
+}
+function outcomesOf(result, group, max) {
+  const host = result.host;
+  const updates = new Map;
+  for (const { recipient } of result.accepted) {
+    updates.set(recipient, {
+      address: recipient,
+      status: "delivered",
+      reply: diagnosticOf(result.reply, max, host)
+    });
+  }
+  for (const { recipient, reply } of result.rejected) {
+    updates.set(recipient, {
+      address: recipient,
+      status: reply.code >= 500 ? "failed" : "deferred",
+      reply: diagnosticOf(reply, max, host)
+    });
+  }
+  return group.map((address) => updates.get(address) ?? {
+    address,
+    status: "deferred",
+    reply: { text: "The delivery said nothing of this recipient", host }
+  });
+}
+function outcomesOfError(error, group, max, host) {
+  const rejected = new Map(isSmtpError(error) ? (error.rejected ?? []).map((r) => [r.recipient, r.reply]) : []);
+  const temporary = !isSmtpError(error) || error.temporary || isRouteError(error);
+  return group.map((address) => {
+    const own = rejected.get(address);
+    if (own) {
+      return {
+        address,
+        status: own.code >= 500 ? "failed" : "deferred",
+        reply: diagnosticOf(own, max, host)
+      };
+    }
+    const reply = isSmtpError(error) && error.reply ? diagnosticOf(error.reply, max, host) : diagnosticOfError(error, temporary, max, host);
+    return { address, status: temporary ? "deferred" : "failed", reply };
+  });
+}
+
+// src/queue/route.ts
+function routeOf(settings, domain) {
+  return settings.routes.get(domain) ?? settings.options.route ?? "mx";
+}
+function hostOf(route) {
+  return route === "mx" ? undefined : route.host;
+}
+function sendOptionsOf(settings, domain, from, to) {
+  const { options, hostname } = settings;
+  const common = {
+    from,
+    to,
+    helo: hostname,
+    ...options.timeouts ? { timeouts: options.timeouts } : {},
+    ...options.deadline !== undefined ? { deadline: options.deadline } : {}
+  };
+  const route = routeOf(settings, domain);
+  if (route === "mx") {
+    const resolver = options.resolver;
+    if (!resolver)
+      throw new Error("unreachable: settings check the resolver");
+    return {
+      ...common,
+      domain,
+      resolver,
+      ...options.mxPort !== undefined ? { port: options.mxPort } : {},
+      ...options.mxTls ? { tls: options.mxTls } : {}
+    };
+  }
+  return {
+    ...common,
+    host: route.host,
+    ...route.port !== undefined ? { port: route.port } : {},
+    ...route.secure !== undefined ? { secure: route.secure } : {},
+    ...route.tls ? { tls: route.tls } : {},
+    ...route.auth ? { auth: route.auth } : {},
+    ...route.ca ? { ca: route.ca } : {}
+  };
+}
+
+// src/queue/settle.ts
+function expired(update) {
+  return {
+    address: update.address,
+    status: "failed",
+    reply: { text: "", ...update.reply, status: "4.4.7" }
+  };
+}
+function settle(item, updates, skipped, now, settings) {
+  const attempts = item.attempts + (updates.length > 0 ? 1 : 0);
+  const next = nextAttemptAt(item.createdAt, now, attempts, settings.retry, settings.random);
+  const all = updates.map((u) => u.status === "deferred" && next === undefined ? expired(u) : u);
+  const deferred = all.filter((u) => u.status === "deferred");
+  const { delayAfter } = settings.dsn;
+  const delayDsn = !item.delayNotified && item.from !== "" && delayAfter !== false && deferred.length > 0 && now - item.createdAt >= delayAfter;
+  return {
+    result: {
+      now,
+      recipients: all,
+      nextAttemptAt: next === undefined || skipped && deferred.length === 0 ? now : next,
+      attempts,
+      delayNotified: item.delayNotified || delayDsn
+    },
+    delivered: all.filter((u) => u.status === "delivered"),
+    failed: all.filter((u) => u.status === "failed"),
+    deferred,
+    delayDsn
+  };
+}
+
+// src/queue/deliver.ts
+function groupsOf(item) {
+  const groups = new Map;
+  for (const r of item.recipients) {
+    if (r.status === "delivered" || r.status === "failed")
+      continue;
+    const domain = domainOf(r.address);
+    const group = groups.get(domain);
+    if (group)
+      group.push(r.address);
+    else
+      groups.set(domain, [r.address]);
+  }
+  return groups;
+}
+var badAddress = (address) => ({
+  address,
+  status: "failed",
+  reply: {
+    status: "5.1.3",
+    text: "The address is not one SMTP can carry"
+  }
+});
+var badSender = (address) => ({
+  address,
+  status: "failed",
+  reply: {
+    status: "5.1.7",
+    text: "The sender's address is not one SMTP can carry"
+  }
+});
+async function attemptGroup(ctx, item, message, domain, recipients) {
+  const { settings } = ctx;
+  const max = settings.limits.maxReplyText;
+  const bad = recipients.filter((address) => !isMailbox2(address));
+  const group = recipients.filter(isMailbox2);
+  if (group.length === 0)
+    return bad.map(badAddress);
+  try {
+    const options = sendOptionsOf(settings, domain, item.from, group);
+    const result = await settings.send(message, options);
+    return [...outcomesOf(result, group, max), ...bad.map(badAddress)];
+  } catch (error) {
+    if (isRouteError(error))
+      ctx.events.emit("error", { error, id: item.id });
+    const host = hostOf(routeOf(settings, domain));
+    return [
+      ...outcomesOfError(error, group, max, host),
+      ...bad.map(badAddress)
+    ];
+  }
+}
+function emitOutcomes(events, item, settled) {
+  const { attempts, nextAttemptAt } = settled.result;
+  const base = (u) => ({
+    id: item.id,
+    from: item.from,
+    recipient: u.address,
+    ...u.reply ? { reply: u.reply } : {},
+    attempts
+  });
+  for (const u of settled.delivered)
+    events.emit("delivered", base(u));
+  for (const u of settled.deferred) {
+    events.emit("deferred", { ...base(u), nextAttemptAt });
+  }
+  for (const u of settled.failed)
+    events.emit("failed", base(u));
+}
+async function deliverItem(ctx, item) {
+  const { settings, store, events } = ctx;
+  const message = await store.readMessage(item.id);
+  if (!message)
+    return;
+  const groups = groupsOf(item);
+  let skipped = false;
+  const outcomes = item.from !== "" && !isMailbox2(item.from) ? [[...groups.values()].flat().map(badSender)] : await Promise.all([...groups].map(async ([domain, group]) => {
+    const release = await ctx.domains.acquire(domain);
+    try {
+      if (ctx.stopping()) {
+        skipped = true;
+        return [];
+      }
+      return await attemptGroup(ctx, item, message, domain, group);
+    } finally {
+      release();
+    }
+  }));
+  const now = settings.now();
+  const settled = settle(item, outcomes.flat(), skipped, now, settings);
+  const after = await store.complete(item.id, settings.owner, settled.result);
+  ctx.recorded();
+  if (!after && await store.get(item.id) === undefined) {
+    emitOutcomes(events, item, settled);
+    return;
+  }
+  if (!after) {
+    const error = new QueueError2("LEASE_LOST", `The lease on ${item.id} was lost before its outcome was recorded; another worker will try it again`);
+    events.emit("error", { error, id: item.id });
+    return;
+  }
+  emitOutcomes(events, item, settled);
+  await notify(ctx, item, message, "failed", settled.failed, now);
+  if (settled.delayDsn) {
+    await notify(ctx, item, message, "delayed", settled.deferred, now);
+  }
+}
+
+// src/queue/limiter.ts
+class Limiter {
+  #size;
+  #used = 0;
+  #waiting = [];
+  constructor(size) {
+    this.#size = size;
+  }
+  async acquire() {
+    if (this.#used >= this.#size) {
+      await new Promise((resolve) => this.#waiting.push(resolve));
+    } else {
+      this.#used++;
+    }
+    let released = false;
+    return () => {
+      if (released)
+        return;
+      released = true;
+      const next = this.#waiting.shift();
+      if (next)
+        next();
+      else
+        this.#used--;
+    };
+  }
+}
+
+class KeyedLimiter {
+  #size;
+  #limiters = new Map;
+  constructor(size) {
+    this.#size = size;
+  }
+  async acquire(key) {
+    let entry = this.#limiters.get(key);
+    if (!entry) {
+      entry = { limiter: new Limiter(this.#size), users: 0 };
+      this.#limiters.set(key, entry);
+    }
+    entry.users++;
+    const release = await entry.limiter.acquire();
+    const held = entry;
+    return () => {
+      release();
+      if (--held.users === 0)
+        this.#limiters.delete(key);
+    };
+  }
+}
+
+// src/queue/worker.ts
+class Worker {
+  #ctx;
+  #slots;
+  #domains;
+  #inFlight = new Set;
+  #stopping = false;
+  #restart = false;
+  #loop;
+  #wake;
+  #woken = false;
+  constructor(ctx) {
+    this.#ctx = ctx;
+    this.#slots = new Limiter(ctx.settings.concurrency);
+    this.#domains = new KeyedLimiter(ctx.settings.perDomain);
+  }
+  #renewing(item) {
+    const { settings, store, events } = this.#ctx;
+    let done = false;
+    const stop = () => {
+      done = true;
+      clearInterval(timer);
+    };
+    const timer = setInterval(() => {
+      const expiresAt = settings.now() + settings.leaseMs;
+      store.renew(item.id, settings.owner, expiresAt).then((held) => {
+        if (held || done)
+          return;
+        stop();
+        const error = new QueueError2("LEASE_LOST", `The lease on ${item.id} was lost while it was delivered`);
+        events.emit("error", { error, id: item.id });
+      }, (error) => {
+        if (!done)
+          events.emit("error", { error, id: item.id });
+      });
+    }, settings.leaseMs / 3);
+    timer.unref?.();
+    return stop;
+  }
+  async#deliver(item) {
+    const stopRenewing = this.#renewing(item);
+    try {
+      await deliverItem({
+        ...this.#ctx,
+        domains: this.#domains,
+        stopping: () => this.#stopping,
+        recorded: stopRenewing
+      }, item);
+    } catch (error) {
+      this.#ctx.events.emit("error", { error, id: item.id });
+    } finally {
+      stopRenewing();
+    }
+  }
+  #claim() {
+    const { settings, store } = this.#ctx;
+    if (this.#stopping)
+      return Promise.resolve(undefined);
+    return store.claim({
+      owner: settings.owner,
+      now: settings.now(),
+      leaseMs: settings.leaseMs
+    });
+  }
+  async deliverDue() {
+    const mine = new Set;
+    let claimed = 0;
+    while (!this.#stopping) {
+      const release = await this.#slots.acquire();
+      let item;
+      try {
+        item = await this.#claim();
+      } catch (error) {
+        release();
+        await Promise.all(mine);
+        throw error;
+      }
+      if (!item) {
+        release();
+        if (mine.size === 0)
+          break;
+        await Promise.race(mine);
+        continue;
+      }
+      claimed++;
+      const delivery = this.#deliver(item).finally(() => {
+        release();
+        mine.delete(delivery);
+        this.#inFlight.delete(delivery);
+      });
+      mine.add(delivery);
+      this.#inFlight.add(delivery);
+    }
+    await Promise.all(mine);
+    return claimed;
+  }
+  wake() {
+    if (this.#wake)
+      this.#wake();
+    else
+      this.#woken = true;
+  }
+  start() {
+    if (this.#stopping) {
+      this.#restart = true;
+      return;
+    }
+    if (this.#loop)
+      return;
+    this.#loop = this.#run();
+  }
+  async#sleep() {
+    if (this.#woken) {
+      this.#woken = false;
+      return;
+    }
+    await new Promise((resolve) => {
+      const timer = setTimeout(resolve, this.#ctx.settings.pollInterval);
+      this.#wake = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+    });
+    this.#wake = undefined;
+  }
+  async#run() {
+    while (!this.#stopping) {
+      this.#woken = false;
+      try {
+        await this.deliverDue();
+      } catch (error) {
+        this.#ctx.events.emit("error", { error });
+      }
+      if (this.#stopping)
+        break;
+      await this.#sleep();
+    }
+  }
+  async stop() {
+    this.#restart = false;
+    this.#stopping = true;
+    this.#wake?.();
+    await this.#loop;
+    await Promise.all(this.#inFlight);
+    this.#loop = undefined;
+    this.#stopping = false;
+    if (this.#restart) {
+      this.#restart = false;
+      this.start();
+    }
+  }
+}
+
+// src/queue/queue.ts
+function createQueue(options) {
+  const settings = settingsOf(options);
+  const store = options.store;
+  const events = new Events;
+  const worker = new Worker({ settings, store, events });
+  const { limits } = settings;
+  return {
+    owner: settings.owner,
+    async enqueue(message, envelope) {
+      const { from, to } = checkEnvelope(envelope, limits.maxRecipients);
+      const bytes = await readMessage(message, limits.maxMessageSize);
+      checkLineEnds(bytes);
+      const item = await store.add({ from, to, message: bytes, createdAt: settings.now() }, limits.maxItems === undefined ? {} : { maxItems: limits.maxItems });
+      worker.wake();
+      return item;
+    },
+    deliverDue: () => worker.deliverDue(),
+    start: () => worker.start(),
+    stop: () => worker.stop(),
+    on: (event, listener) => events.on(event, listener),
+    list: (listOptions) => store.list(listOptions),
+    get: (id) => store.get(id),
+    async retryNow(id) {
+      const now = settings.now();
+      const lease = (await store.get(id))?.lease;
+      if (lease && lease.expiresAt > now)
+        return false;
+      const moved = await store.reschedule(id, now);
+      if (moved)
+        worker.wake();
+      return moved;
+    },
+    cancel: (id) => store.cancel(id)
+  };
+}
+export {
+  QueueError2 as QueueError,
+  createQueue
+};
+
+//# debugId=06C900A54468AF5364756E2164756E21
+//# sourceMappingURL=index.js.map