@bumail/queue 0.7.2 → 0.9.0

package/dist/index.js

@@ -1,12 +1,336 @@
 import {
-  QueueError2,
-  invalid,
   hasControl,
   replaceControls,
   cleanText,
   asciiText,
+  QueueError2,
+  invalid,
   checkOwner
-} from "./chunks/index-3pt7rc59.js";
+} from "./chunks/index-9yp15arf.js";
+
+// src/dsn/build.ts
+import {
+  encodeHeaderValue,
+  encodeQuotedPrintable,
+  foldHeader as foldHeader2,
+  formatDate as formatDate3
+} from "@bumail/mime";
+
+// src/dsn/content.ts
+var CR = 13;
+var LF = 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 === CR || byte === LF) {
+      out.push(CR, LF);
+      column = 0;
+      if (byte === CR && bytes[i + 1] === LF)
+        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] === CR && bytes[i + 1] === LF && bytes[i + 2] === CR && bytes[i + 3] === LF) {
+      return i + 2;
+    }
+  }
+  return bytes.length;
+}
+function wholeLines(bytes, max) {
+  if (bytes.length <= max)
+    return bytes;
+  const cut = bytes.subarray(0, max).lastIndexOf(LF);
+  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 = cleanAddress(address);
+  if (isAscii(clean))
+    return `rfc822; ${clean}`;
+  return `utf-8; ${escapedAddress(clean).slice(0, MAX_ESCAPED)}`;
+}
+var cleanAddress = (address) => strip(address).replace(/[\s\\]/g, "");
+var isAscii = (text) => /^[\x21-\x7e]*$/.test(text);
+function escapedAddress(clean) {
+  let escaped = "";
+  for (const c of clean) {
+    escaped += /[\x21-\x7e]/.test(c) ? c : `\\x{${(c.codePointAt(0) ?? 0).toString(16).toUpperCase()}}`;
+  }
+  return 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) {
+    if (reply.code < 400)
+      return "2.0.0";
+    return reply.code >= 500 ? "5.0.0" : "4.0.0";
+  }
+  if (kind === "relayed" || kind === "delivered")
+    return "2.0.0";
+  return kind === "failed" ? "5.0.0" : "4.0.0";
+}
+function originalRecipient(orcpt) {
+  const type = orcpt.type.toLowerCase();
+  if (type === "rfc822" || type === "utf-8") {
+    const clean = cleanAddress(orcpt.address);
+    const whole = isAscii(clean) ? clean : escapedAddress(clean);
+    return whole.length > MAX_ESCAPED ? undefined : typedAddress(orcpt.address);
+  }
+  const address = strip(orcpt.address).replace(/\s/g, "");
+  if (!/^[A-Za-z0-9-]{1,20}$/.test(orcpt.type) || !/^[\x21-\x7e]{1,900}$/.test(address)) {
+    return;
+  }
+  return `${orcpt.type.toLowerCase()}; ${address}`;
+}
+function recipientFields(report, recipient) {
+  const { reply } = recipient;
+  const original = recipient.orcpt && originalRecipient(recipient.orcpt);
+  const fields = [
+    ...original ? [["Original-Recipient", original]] : [],
+    ["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 envid = strip(report.envid ?? "").trim();
+  const message = [
+    ...envid === "" ? [] : [foldHeader("Original-Envelope-Id", envid)],
+    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/human.ts
+import { formatDate as formatDate2 } from "@bumail/mime";
+var SUBJECTS = {
+  failed: "Undelivered Mail Returned to Sender",
+  delayed: "Delayed Mail (still being retried)",
+  relayed: "Mail Relayed (delivery not confirmed)",
+  delivered: "Mail Delivered"
+};
+function opening(input) {
+  switch (input.kind) {
+    case "failed":
+      return [
+        "Your message could not be delivered to the recipients below.",
+        "This is a permanent failure: the message will not be retried."
+      ];
+    case "delayed":
+      return [
+        "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."
+      ];
+    case "relayed":
+      return [
+        "Your message was passed on to the recipients below, whose server",
+        "does not report delivery status (RFC 3461 §5.2.2).",
+        "This server can say no more: no further notice will follow."
+      ];
+    case "delivered":
+      return ["Your message was delivered to the recipients below."];
+  }
+}
+function humanText(input) {
+  const lines = [
+    `This is the mail system at ${input.reportingMta}.`,
+    "",
+    ...opening(input)
+  ];
+  if (!input.original && input.kind !== "delivered") {
+    lines.push("", "Your message could not be read from the queue, so it is not returned.");
+  }
+  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
+`;
+}
+
+// src/dsn/build.ts
+var encoder = new TextEncoder;
+var strip2 = (text) => replaceControls(text, "").replace(/[\s<>]/g, "");
+function headerFields(input, boundary) {
+  const subject = SUBJECTS[input.kind];
+  const domain = strip2(input.reportingMta);
+  return [
+    foldHeader2("Date", formatDate3(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 = input.original ? returned(input.original, input.returnContent, input.maxReturn) : undefined;
+  const boundary = boundaryFor(original?.body ?? new Uint8Array);
+  const text = encodeQuotedPrintable(humanText(input));
+  const status = deliveryStatus({
+    kind: input.kind,
+    reportingMta: input.reportingMta,
+    arrival: input.arrival,
+    ...input.envid === undefined ? {} : { envid: input.envid },
+    recipients: input.recipients,
+    ...input.willRetryUntil ? { willRetryUntil: input.willRetryUntil } : {}
+  });
+  const parts = [
+    ...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
+  ];
+  const end = `--${boundary}--\r
+`;
+  if (!original)
+    return encoder.encode(`${parts.join(`\r
+`)}\r
+${end}`);
+  const head = [
+    ...parts,
+    `--${boundary}`,
+    `Content-Type: ${original.type}`,
+    ...original.eightBit ? ["Content-Transfer-Encoding: 8bit"] : [],
+    "",
+    ""
+  ].join(`\r
+`);
+  return concat([
+    encoder.encode(head),
+    original.body,
+    encoder.encode(`\r
+${end}`)
+  ]);
+}
+
+// src/dsn/policy.ts
+function asked(kind, notify) {
+  if (notify === "NEVER")
+    return false;
+  if (notify === undefined)
+    return kind === "failed" || kind === "delayed";
+  const event = {
+    failed: "FAILURE",
+    delayed: "DELAY",
+    relayed: "SUCCESS",
+    delivered: "SUCCESS"
+  };
+  return notify.includes(event[kind]);
+}
+var returnOf = (ret, fallback) => ret === "HDRS" ? "headers" : ret === "FULL" ? "full" : fallback;
+
+// src/dsn/delivered.ts
+function deliveredDsn(input) {
+  const wanted = input.recipients.filter((r) => asked("delivered", r.notify));
+  if (input.to === "" || wanted.length === 0)
+    return;
+  const date = input.date ?? new Date;
+  return buildDsn({
+    kind: "delivered",
+    reportingMta: input.reportingMta,
+    from: input.from,
+    to: input.to,
+    arrival: input.arrival,
+    date,
+    ...input.envid === undefined ? {} : { envid: input.envid },
+    recipients: wanted.map((r) => ({
+      address: r.address,
+      lastAttempt: date,
+      ...r.orcpt ? { orcpt: r.orcpt } : {}
+    })),
+    ...input.original ? { original: input.original } : {},
+    returnContent: "headers",
+    maxReturn: input.maxReturn ?? 64 * 1024
+  });
+}
 // src/queue/envelope.ts
 import { isMailbox } from "@bumail/smtp/client";
 var ADDRESS = /^[^\s<>]{1,64}@[^\s<>@]{1,253}$/u;
@@ -39,15 +363,27 @@ function checkEnvelope(envelope, maxRecipients) {
   if (to.length > maxRecipients) {
     throw new QueueError2("TOO_MANY_RECIPIENTS", `The message has ${to.length} recipients; the limit is ${maxRecipients}`);
   }
-  return { from, to };
+  const keyOf = (a) => `${a.slice(0, a.lastIndexOf("@"))}@${domainOf(a)}`;
+  const kept = new Map(to.map((a) => [keyOf(a), a]));
+  const recipients = Array.isArray(envelope.recipients) ? envelope.recipients.map((r) => {
+    const target = typeof r?.address === "string" && list.includes(r.address) ? kept.get(keyOf(r.address)) : undefined;
+    return target === undefined ? r : { ...r, address: target };
+  }).filter((r, i, all) => all.findIndex((o) => o?.address === r?.address) === i) : envelope.recipients;
+  return {
+    from,
+    to,
+    ...envelope.ret === undefined ? {} : { ret: envelope.ret },
+    ...envelope.envid === undefined ? {} : { envid: envelope.envid },
+    ...recipients === undefined ? {} : { recipients }
+  };
 }
 var tooBig = (max) => new QueueError2("MESSAGE_TOO_BIG", `The message is larger than the limit of ${max} bytes`);
-var CR = 13;
-var LF = 10;
+var CR2 = 13;
+var LF2 = 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);
+    const bare = byte === CR2 ? bytes[i + 1] !== LF2 : byte === LF2 && (i === 0 || bytes[i - 1] !== CR2);
     if (bare) {
       throw invalid(`The message has a bare CR or LF at byte ${i}: every line must end in CRLF`);
     }
@@ -337,7 +673,8 @@ function outcomesOf(result, group, max) {
     updates.set(recipient, {
       address: recipient,
       status: "delivered",
-      reply: diagnosticOf(result.reply, max, host)
+      reply: diagnosticOf(result.reply, max, host),
+      ...result.dsnOffered === false ? { dsnOffered: false } : {}
     });
   }
   for (const { recipient, reply } of result.rejected) {
@@ -403,6 +740,19 @@ function routeOf(settings, domain) {
 function hostOf(route) {
   return route === "mx" ? undefined : route.host;
 }
+function dsnOptionsOf(item, group) {
+  const only = new Set(group);
+  const recipients = item.recipients.filter((r) => only.has(r.address) && (r.notify !== undefined || r.orcpt !== undefined)).map((r) => ({
+    address: r.address,
+    ...r.notify === undefined ? {} : { notify: r.notify },
+    ...r.orcpt === undefined ? {} : { orcpt: r.orcpt }
+  }));
+  return {
+    ...item.ret === undefined ? {} : { ret: item.ret },
+    ...item.envid === undefined ? {} : { envid: item.envid },
+    ...recipients.length === 0 ? {} : { recipients }
+  };
+}
 function sendOptionsOf(settings, domain, from, to, override) {
   const { options, hostname } = settings;
   const common = {
@@ -436,44 +786,89 @@ function sendOptionsOf(settings, domain, from, to, override) {
   };
 }
 
-// src/queue/attempt.ts
-var badAddress = (address) => ({
-  address,
-  status: "failed",
-  reply: {
-    status: "5.1.3",
-    text: "The address is not one SMTP can carry"
-  }
-});
-var marked = (u) => u.status === "delivered" ? u : { ...u, mayHaveReachedMx: true };
-function doubtful(updates, error) {
+// src/queue/session.ts
+var marked = (u, key) => u.status === "delivered" ? u : { ...u, [key]: true };
+function doubtful(updates, error, key) {
   if (!error.accepted)
-    return updates.map(marked);
+    return updates.map((u) => marked(u, key));
   const taken = new Set(error.accepted.map((r) => r.recipient));
   const refused = new Set((error.rejected ?? []).map((r) => r.recipient).filter((a) => !taken.has(a)));
-  return updates.map((u) => refused.has(u.address) ? u : marked(u));
+  return updates.map((u) => refused.has(u.address) ? u : marked(u, key));
 }
 async function session(ctx, item, message, domain, group, route, override) {
   const { settings } = ctx;
   const max = settings.limits.maxReplyText;
   try {
-    const options = sendOptionsOf(settings, domain, item.from, group, override);
+    const options = {
+      ...sendOptionsOf(settings, domain, item.from, group, override),
+      ...dsnOptionsOf(item, group)
+    };
     const result = await settings.send(message, options);
     return { updates: outcomesOf(result, group, max) };
   } catch (error) {
     if (isRouteError(error))
       ctx.events.emit("error", { error, id: item.id });
     const updates = outcomesOfError(error, group, max, hostOf(route));
-    const doubt = route === "mx" && isSmtpError(error) && error.afterData;
-    return { updates: doubt ? doubtful(updates, error) : updates, error };
+    const key = route === "mx" ? "mayHaveReachedMx" : "mayHaveReachedFallback";
+    const doubt = (route === "mx" || override !== undefined) && isSmtpError(error) && error.afterData;
+    return { updates: doubt ? doubtful(updates, error, key) : updates, error };
   }
 }
+
+// src/queue/fallback-session.ts
 function merged(mx, fb) {
   if (mx.status === "deferred" && fb.status === "failed") {
     return { ...fb, status: "deferred" };
   }
   return fb;
 }
+var stillHeld = (u) => u.status === "failed" ? { ...u, status: "deferred" } : u;
+async function fallBackAtOnce(ctx, item, message, domain, first, fallback, used) {
+  const mxHeld = new Set(item.recipients.filter((r) => r.mayHaveReachedMx).map((r) => r.address));
+  const mx = new Map(first.updates.filter((u) => u.status !== "delivered" && !u.mayHaveReachedMx && !mxHeld.has(u.address) && fallsBack(u.reply, first.error)).map((u) => [u.address, u]));
+  if (mx.size === 0)
+    return first.updates;
+  const second = await session(ctx, item, message, domain, [...mx.keys()], fallback, fallback);
+  for (const [address, u] of mx) {
+    used.set(address, {
+      route: "smarthost",
+      fallback: true,
+      ...u.reply ? { mxReply: u.reply } : {}
+    });
+  }
+  return [
+    ...first.updates.filter((u) => !mx.has(u.address)),
+    ...second.updates.map((u) => {
+      const was = mx.get(u.address);
+      return was ? merged(was, u) : u;
+    })
+  ];
+}
+function heldAtFallback(item, group, byMx, fallback) {
+  if (!byMx || fallback === undefined)
+    return [];
+  const held = new Set(item.recipients.filter((r) => r.mayHaveReachedFallback && !r.mayHaveReachedMx).map((r) => r.address));
+  return group.filter((address) => held.has(address));
+}
+async function deliverHeld(ctx, item, message, domain, held, fallback, used) {
+  if (held.length === 0)
+    return [];
+  for (const address of held) {
+    used.set(address, { route: "smarthost", fallback: true });
+  }
+  const second = await session(ctx, item, message, domain, held, fallback, fallback);
+  return second.updates.map(stillHeld);
+}
+
+// src/queue/attempt.ts
+var badAddress = (address) => ({
+  address,
+  status: "failed",
+  reply: {
+    status: "5.1.3",
+    text: "The address is not one SMTP can carry"
+  }
+});
 async function attemptGroup(ctx, item, message, domain, recipients, used) {
   const { settings } = ctx;
   const bad = recipients.filter((address) => !isMailbox2(address));
@@ -484,267 +879,16 @@ async function attemptGroup(ctx, item, message, domain, recipients, used) {
   const label = route === "mx" ? "mx" : "smarthost";
   for (const address of group)
     used.set(address, { route: label });
-  const first = await session(ctx, item, message, domain, group, route);
-  let updates = first.updates;
   const { fallback } = settings.options;
-  const doubtful = new Set(item.recipients.filter((r) => r.mayHaveReachedMx).map((r) => r.address));
-  if (fallback !== undefined && route === "mx") {
-    const mx = new Map(updates.filter((u) => u.status !== "delivered" && !u.mayHaveReachedMx && !doubtful.has(u.address) && fallsBack(u.reply, first.error)).map((u) => [u.address, u]));
-    if (mx.size > 0) {
-      const again = [...mx.keys()];
-      const second = await session(ctx, item, message, domain, again, fallback, fallback);
-      for (const [address, u] of mx) {
-        used.set(address, {
-          route: "smarthost",
-          fallback: true,
-          ...u.reply ? { mxReply: u.reply } : {}
-        });
-      }
-      updates = [
-        ...updates.filter((u) => !mx.has(u.address)),
-        ...second.updates.map((u) => {
-          const was = mx.get(u.address);
-          return was ? merged(was, u) : u;
-        })
-      ];
-    }
-  }
-  return [...updates, ...bad.map(badAddress)];
-}
-
-// 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."
-  ];
-  if (!input.original) {
-    lines.push("", "Your message could not be read from the queue, so it is not returned.");
-  }
-  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 = input.original ? returned(input.original, input.returnContent, input.maxReturn) : undefined;
-  const boundary = boundaryFor(original?.body ?? new Uint8Array);
-  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 parts = [
-    ...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
-  ];
-  const end = `--${boundary}--\r
-`;
-  if (!original)
-    return encoder.encode(`${parts.join(`\r
-`)}\r
-${end}`);
-  const head = [
-    ...parts,
-    `--${boundary}`,
-    `Content-Type: ${original.type}`,
-    ...original.eightBit ? ["Content-Transfer-Encoding: 8bit"] : [],
-    "",
-    ""
-  ].join(`\r
-`);
-  return concat([
-    encoder.encode(head),
-    original.body,
-    encoder.encode(`\r
-${end}`)
-  ]);
+  const held = heldAtFallback(item, group, route === "mx", fallback);
+  const kept = fallback === undefined ? [] : await deliverHeld(ctx, item, message, domain, held, fallback, used);
+  const viaMx = group.filter((address) => !held.includes(address));
+  let updates = [];
+  if (viaMx.length > 0) {
+    const first = await session(ctx, item, message, domain, viaMx, route);
+    updates = fallback !== undefined && route === "mx" ? await fallBackAtOnce(ctx, item, message, domain, first, fallback, used) : first.updates;
+  }
+  return [...kept, ...updates, ...bad.map(badAddress)];
 }
 
 // src/queue/retry.ts
@@ -763,17 +907,24 @@ function nextAttemptAt(createdAt, now, attempts, retry, random) {
 
 // src/queue/notify.ts
 var MAY_HAVE_REACHED = "An earlier attempt may have reached the receiving server, so the message may have been delivered.";
+var MAY_HAVE_REACHED_FALLBACK = "An earlier attempt may have reached the fallback smarthost, so the message may have been delivered.";
 function reported(r, kind) {
-  if (kind !== "failed" || !r.mayHaveReachedMx)
+  const said = [
+    ...r.mayHaveReachedMx ? [MAY_HAVE_REACHED] : [],
+    ...r.mayHaveReachedFallback ? [MAY_HAVE_REACHED_FALLBACK] : []
+  ];
+  if (kind !== "failed" || said.length === 0)
     return r.reply;
   const reply = r.reply ?? { text: "" };
   return {
     ...reply,
-    text: reply.text === "" ? MAY_HAVE_REACHED : `${reply.text} ${MAY_HAVE_REACHED}`
+    text: [reply.text, ...said].filter((t) => t !== "").join(" ")
   };
 }
 async function notify(ctx, item, message, kind, recipients, now) {
-  if (item.from === "" || recipients.length === 0)
+  const states = new Map(item.recipients.map((r) => [r.address, r]));
+  const wanted = recipients.filter((r) => asked(kind, states.get(r.address)?.notify));
+  if (item.from === "" || wanted.length === 0)
     return;
   const { settings, store, events } = ctx;
   try {
@@ -785,13 +936,20 @@ async function notify(ctx, item, message, kind, recipients, now) {
       to: item.from,
       arrival: new Date(item.createdAt),
       date: lastAttempt,
-      recipients: recipients.map((r) => {
+      ...item.envid === undefined ? {} : { envid: item.envid },
+      recipients: wanted.map((r) => {
         const reply = reported(r, kind);
-        return { address: r.address, ...reply ? { reply } : {}, lastAttempt };
+        const orcpt = states.get(r.address)?.orcpt;
+        return {
+          address: r.address,
+          ...reply ? { reply } : {},
+          lastAttempt,
+          ...orcpt ? { orcpt } : {}
+        };
       }),
       ...kind === "delayed" ? { willRetryUntil: new Date(giveUpAt(item.createdAt, settings.retry)) } : {},
       ...message ? { original: message } : {},
-      returnContent: settings.dsn.returnContent,
+      returnContent: kind === "relayed" ? "headers" : returnOf(item.ret, settings.dsn.returnContent),
       maxReturn: settings.limits.maxDsnReturn
     });
     const added = await store.add({
@@ -805,7 +963,7 @@ async function notify(ctx, item, message, kind, recipients, now) {
       id: added.id,
       of: item.id,
       to: item.from,
-      recipients: recipients.map((r) => r.address)
+      recipients: wanted.map((r) => r.address)
     });
   } catch (error) {
     events.emit("error", { error, id: item.id });
@@ -818,17 +976,27 @@ function expired(update) {
     address: update.address,
     status: "failed",
     reply: { text: "", ...update.reply, status: "4.4.7" },
-    ...update.mayHaveReachedMx ? { mayHaveReachedMx: true } : {}
+    ...update.mayHaveReachedMx ? { mayHaveReachedMx: true } : {},
+    ...update.mayHaveReachedFallback ? { mayHaveReachedFallback: true } : {}
   };
 }
 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 doubtful = new Set(item.recipients.filter((r) => r.mayHaveReachedMx).map((r) => r.address));
-  const all = updates.map((u) => doubtful.has(u.address) && u.status !== "delivered" ? { ...u, mayHaveReachedMx: true } : u).map((u) => u.status === "deferred" && next === undefined ? expired(u) : u);
+  const was = new Map(item.recipients.map((r) => [r.address, r]));
+  const all = updates.map((u) => {
+    const r = was.get(u.address);
+    if (!r || u.status === "delivered")
+      return u;
+    return {
+      ...u,
+      ...r.mayHaveReachedMx ? { mayHaveReachedMx: true } : {},
+      ...r.mayHaveReachedFallback ? { mayHaveReachedFallback: true } : {}
+    };
+  }).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;
+  const delayDsn = !item.delayNotified && deferred.some((u) => asked("delayed", was.get(u.address)?.notify)) && item.from !== "" && delayAfter !== false && deferred.length > 0 && now - item.createdAt >= delayAfter;
   return {
     result: {
       now,
@@ -887,7 +1055,10 @@ function emitOutcomes(events, item, settled, used) {
     attempts,
     ...used.get(u.address)
   });
-  const marked = (u) => u.mayHaveReachedMx ? { mayHaveReachedMx: true } : {};
+  const marked = (u) => ({
+    ...u.mayHaveReachedMx ? { mayHaveReachedMx: true } : {},
+    ...u.mayHaveReachedFallback ? { mayHaveReachedFallback: true } : {}
+  });
   for (const u of settled.delivered)
     events.emit("delivered", base(u));
   for (const u of settled.deferred) {
@@ -951,6 +1122,8 @@ async function record(ctx, item, updates, skipped, message, used) {
   }
   emitOutcomes(events, item, settled, used);
   await notify(ctx, item, message, "failed", settled.failed, now);
+  const relayed = settled.delivered.filter((u) => u.dsnOffered === false);
+  await notify(ctx, item, message, "relayed", relayed, now);
   if (settled.delayDsn) {
     await notify(ctx, item, message, "delayed", settled.deferred, now);
   }
@@ -1214,10 +1387,10 @@ function createQueue(options) {
   return {
     owner: settings.owner,
     async enqueue(message, envelope) {
-      const { from, to } = checkEnvelope(envelope, limits.maxRecipients);
+      const { from, to, ...dsn } = 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 });
+      const item = await store.add({ from, to, message: bytes, createdAt: settings.now(), ...dsn }, limits.maxItems === undefined ? {} : { maxItems: limits.maxItems });
       worker.wake();
       return item;
     },
@@ -1242,8 +1415,9 @@ function createQueue(options) {
 }
 export {
   QueueError2 as QueueError,
-  createQueue
+  createQueue,
+  deliveredDsn
 };
 
-//# debugId=14BF571A961D5A4C64756E2164756E21
+//# debugId=D24C84F35DEF0E8164756E2164756E21
 //# sourceMappingURL=index.js.map