spamscanner 7.0.4 → 7.0.6

package/dist/esm/cli.js

@@ -6,9 +6,14 @@ import process4 from "node:process";
 // src/cli.js
 import { Buffer as Buffer14 } from "node:buffer";
 import { spawn } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import {
+  createReadStream as createReadStream2,
+  existsSync as existsSync3,
+  readFileSync as readFileSync2,
+  statSync as statSync2
+} from "node:fs";
 import process3 from "node:process";
-import { parseArgs } from "node:util";
+import { format, parseArgs } from "node:util";
 
 // src/classifier.js
 import { Buffer } from "node:buffer";
@@ -1067,10 +1072,10 @@ function detectLanguage(text) {
   if (total === 0) {
     return result;
   }
-  const [[script, count]] = counts;
+  const [[script, count2]] = counts;
   result.script = script;
   result.scripts = [...counts.keys()].filter((name) => counts.get(name) / total >= 0.1);
-  result.confidence = count / total;
+  result.confidence = count2 / total;
   const kana = (counts.get("Hiragana") || 0) + (counts.get("Katakana") || 0);
   if (kana / total >= 0.05) {
     result.language = "ja";
@@ -2308,9 +2313,9 @@ function visibleText(html) {
       }
     }
   };
-  const closeImplied = ([names, limits]) => {
+  const closeImplied = ([names, limits2]) => {
     const index = nearest(names);
-    if (index !== -1 && index >= (limits ? nearest(limits) + 1 : blocks.at(-1))) {
+    if (index !== -1 && index >= (limits2 ? nearest(limits2) + 1 : blocks.at(-1))) {
       popTo(index);
     }
   };
@@ -2857,8 +2862,8 @@ for (const [char, latin] of Object.entries(LOOKALIKES)) {
 function foldLookalikes(word) {
   let most = "Latin";
   const counts = scriptLetters(word);
-  for (const [script, count] of counts) {
-    if (count > (counts.get(most) ?? 0)) {
+  for (const [script, count2] of counts) {
+    if (count2 > (counts.get(most) ?? 0)) {
       most = script;
     }
   }
@@ -3305,18 +3310,18 @@ function addPatternFeatures(text, add) {
     ["phone", PHONE_PATTERN]
   ];
   for (const [name, pattern] of patterns) {
-    let count = 0;
+    let count2 = 0;
     let out = "";
     let from = 0;
     for (const match of matchesOf(pattern, body)) {
       out += `${body.slice(from, match.index)} `;
       from = match.index + match[0].length;
-      count++;
+      count2++;
     }
     body = out + body.slice(from);
-    if (count > 0) {
+    if (count2 > 0) {
       add(`pat:${name}`);
-      add(`pat:${name}:${bucket(count, [1, 3, 10])}`);
+      add(`pat:${name}:${bucket(count2, [1, 3, 10])}`);
     }
   }
   MONEY_PATTERN.lastIndex = 0;
@@ -4612,15 +4617,491 @@ var LLMClassifier = class {
 };
 
 // src/milter.js
-import { Buffer as Buffer6 } from "node:buffer";
+import { Buffer as Buffer8 } from "node:buffer";
 import { EventEmitter } from "node:events";
-import net from "node:net";
+import net2 from "node:net";
 
 // src/auth.js
-import { Buffer as Buffer5, File } from "node:buffer";
+import { Buffer as Buffer6, File } from "node:buffer";
 import dns2 from "node:dns";
 import { debuglog } from "node:util";
 
+// src/parse.js
+import { Buffer as Buffer5 } from "node:buffer";
+import { createHash as createHash2 } from "node:crypto";
+import { Readable } from "node:stream";
+import { MailParser, simpleParser } from "mailparser";
+var ADDRESS_FIELDS = /* @__PURE__ */ new Set(["from", "to", "cc", "bcc", "sender", "reply-to", "delivered-to", "return-path", "disposition-notification-to"]);
+var MAX_ADDRESS_FIELD = 16 * 1024;
+var MAX_ADDRESS_SEPARATORS = 2e3;
+var MAX_ADDRESS_GROUPS = 16;
+var MAX_ADDRESS_TOTAL = 64 * 1024;
+var AUTH_ADDRESS_FIELDS = /* @__PURE__ */ new Set(["from", "return-path"]);
+var ADDRESS_OPERATORS = /* @__PURE__ */ new Map([['"', '"'], ["(", ")"], ["<", ">"], [",", ""], [":", ";"], [";", ""]]);
+var SINGLE_FIELDS = /* @__PURE__ */ new Set(["message-id", "content-id", "from", "sender", "in-reply-to", "reply-to", "subject", "date", "content-disposition", "content-type", "content-transfer-encoding", "priority", "mime-version", "content-description", "precedence", "errors-to", "disposition-notification-to"]);
+var PRIORITY_FIELDS = /* @__PURE__ */ new Set(["priority", "x-priority", "x-msmail-priority", "importance"]);
+var BOUNDED2 = /* @__PURE__ */ Symbol("bounded address fields");
+var ROOM = /* @__PURE__ */ Symbol("room left for address fields");
+var PARSER_OPTIONS = {
+  skipHtmlToText: true,
+  skipImageLinks: true,
+  skipTextToHtml: true,
+  skipTextLinks: true,
+  [BOUNDED2]: true
+};
+function boundAddressField(line, room) {
+  const start = line.indexOf(":") + 1;
+  const limit = Math.min(line.length, MAX_ADDRESS_FIELD, room);
+  let end = start;
+  let expecting = "";
+  let escaped = false;
+  let separators = 0;
+  let groups = 0;
+  let index = start;
+  for (; index < limit; index++) {
+    const chr = line[index];
+    if ((chr === "," || chr === ";") && ++separators > MAX_ADDRESS_SEPARATORS) {
+      break;
+    }
+    if (escaped) {
+      escaped = false;
+    } else if (expecting !== "" && chr === expecting) {
+      expecting = "";
+      end = chr === ";" ? index + 1 : end;
+    } else if (expecting === "" && ADDRESS_OPERATORS.has(chr)) {
+      expecting = ADDRESS_OPERATORS.get(chr);
+      end = chr === "," || chr === ";" ? index : end;
+    } else if (expecting === '"' && chr === "\\") {
+      escaped = true;
+    }
+    if (chr === ":" && expecting === ";" && ++groups > MAX_ADDRESS_GROUPS) {
+      break;
+    }
+  }
+  return index === line.length ? line : line.slice(0, end).trimEnd();
+}
+function boundAddressLines(lines2, budget, only = null) {
+  const cut = /* @__PURE__ */ new Set();
+  const bounded = lines2.map((entry) => {
+    if (only ? !only.has(entry.key) : !ADDRESS_FIELDS.has(entry.key) && !entry.key.startsWith("list-")) {
+      return entry;
+    }
+    const line = boundAddressField(entry.line, budget.room);
+    budget.room = Math.max(budget.room - line.length, 0);
+    if (line === entry.line) {
+      return entry;
+    }
+    cut.add(entry.key);
+    return { ...entry, line };
+  });
+  return { lines: bounded, cut };
+}
+var { processHeaders } = MailParser.prototype;
+MailParser.prototype.processHeaders = function(lines2) {
+  if (!this.options[BOUNDED2]) {
+    return processHeaders.call(this, lines2);
+  }
+  this[ROOM] ??= { room: MAX_ADDRESS_TOTAL };
+  const bounded = boundAddressLines(lines2, this[ROOM]);
+  const headers = processHeaders.call(this, bounded.lines);
+  const keyOf = (entry) => PRIORITY_FIELDS.has(entry.key) ? "priority" : entry.key;
+  const counts = /* @__PURE__ */ new Map();
+  for (const key of bounded.lines.map((entry) => keyOf(entry)).filter((key2) => SINGLE_FIELDS.has(key2))) {
+    counts.set(key, (counts.get(key) || 0) + 1);
+  }
+  for (const key of [...counts.keys()].filter((key2) => counts.get(key2) > 1)) {
+    const last = bounded.lines.findLast((entry) => keyOf(entry) === key && processHeaders.call(this, [entry]).has(key));
+    if (last) {
+      headers.set(key, processHeaders.call(this, [last]).get(key));
+    }
+  }
+  for (const value of [...bounded.cut].flatMap((key) => headers.get(key) ?? [])) {
+    value.truncated = true;
+  }
+  return headers;
+};
+function boundedForAuth(raw) {
+  const ends = [raw.indexOf("\n\n"), raw.indexOf("\n\r\n")].filter((index) => index !== -1);
+  const end = ends.length > 0 ? Math.min(...ends) + 1 : raw.length;
+  const body = raw.subarray(ends.length > 0 ? raw.indexOf(10, end) + 1 : raw.length);
+  const text = raw.subarray(0, end).toString("latin1");
+  let { length } = text;
+  while (length > 0 && (text[length - 1] === "\n" || text[length - 1] === "\r")) {
+    length--;
+  }
+  const fields = [];
+  let folds = 0;
+  let work = 0;
+  for (let start = 0; start <= length; ) {
+    let stop = text.indexOf("\n", start);
+    stop = stop === -1 || stop > length ? length : stop;
+    const lineEnd = stop > start && text[stop - 1] === "\r" ? stop - 1 : stop;
+    const last = fields.at(-1);
+    if (last && /\s/.test(text[start])) {
+      last.end = lineEnd;
+      last.folds++;
+      folds++;
+      work += last.folds;
+    } else {
+      fields.push({ start, end: lineEnd, folds: 0 });
+    }
+    start = stop + 1;
+  }
+  let signatures = 0;
+  let dkim = 0;
+  for (const field of fields) {
+    field.line = text.slice(field.start, field.end);
+    const colon = field.line.indexOf(":");
+    field.key = (colon === -1 ? field.line : field.line.slice(0, colon)).trim().toLowerCase();
+    field.dropped = field.key === "dkim-signature" && ++dkim > MAX_DKIM_SIGNATURES;
+    if (SIGNATURE_FIELDS.has(field.key) && !field.dropped) {
+      signatures += field.line.split(":").length - 1;
+    }
+  }
+  const read = dkim > MAX_DKIM_SIGNATURES ? fields.filter((field) => !field.dropped) : fields;
+  work += (folds + signatures) * read.length;
+  const bounded = boundAddressLines(read, { room: MAX_ADDRESS_TOTAL }, AUTH_ADDRESS_FIELDS);
+  let kept = bounded.lines;
+  let fromCut = bounded.cut.has("from");
+  if (work > MAX_AUTH_WORK) {
+    const counts = /* @__PURE__ */ new Map();
+    kept = kept.filter((field) => {
+      counts.set(field.key, (counts.get(field.key) || 0) + 1);
+      const keep = AUTH_FIELDS.has(field.key) && counts.get(field.key) <= (SIGNATURE_FIELDS.has(field.key) ? MAX_SIGNATURES : MAX_REPEATED);
+      fromCut ||= field.key === "from" && !keep;
+      return keep;
+    }).map((field) => {
+      const line = field.line.replaceAll(/\r?\n(?=\s)/g, "");
+      return { ...field, line: ADDRESS_FIELDS.has(field.key) ? line : line.slice(0, MAX_FIELD) };
+    });
+  } else if (bounded.cut.size === 0 && read === fields) {
+    return { raw, fromCut };
+  }
+  const header = kept.map((field) => field.line).join("\r\n");
+  return { raw: Buffer5.concat([Buffer5.from(`${header}\r
+\r
+`, "latin1"), body]), fromCut };
+}
+var TOO_MANY_PARTS = "Max allowed child nodes exceeded";
+var HEADER_TOO_LARGE = "Max header size for a MIME node exceeded";
+var MAX_PART_LINES = 990;
+var MAX_PREFIX_BYTES = 1e6;
+var MAX_LINE2 = 998;
+var MAX_FIELD = 8192;
+var MAX_HEADER = 512 * 1024;
+var MAX_REPEATED = 100;
+var KEPT_FIELDS = /* @__PURE__ */ new Set([
+  "from",
+  "sender",
+  "reply-to",
+  "to",
+  "cc",
+  "subject",
+  "date",
+  "message-id",
+  "return-path",
+  "received",
+  "authentication-results",
+  "arc-authentication-results",
+  "dkim-signature",
+  "mime-version",
+  "content-type",
+  "content-transfer-encoding",
+  "list-unsubscribe",
+  "list-id"
+]);
+var MAX_AUTH_WORK = 1e7;
+var SIGNATURE_FIELDS = /* @__PURE__ */ new Set(["dkim-signature", "arc-message-signature"]);
+var AUTH_FIELDS = /* @__PURE__ */ new Set([...KEPT_FIELDS, "arc-seal", "arc-message-signature"]);
+var MAX_SIGNATURES = 10;
+var MAX_DKIM_SIGNATURES = 8;
+var MAX_NESTED_DEPTH = 3;
+var MAX_ATTACHMENTS = 100;
+var MAX_NESTED_BYTES = 25 * 1024 * 1024;
+var PARSE_TIMEOUT = 6e4;
+async function simpleParse(raw, { timeout = PARSE_TIMEOUT, parser = simpleParser } = {}) {
+  const input = Readable.from([finishable(unfoldHeaders(raw))], { objectMode: false, autoDestroy: false });
+  input.on("error", () => {
+  });
+  const { pipe } = input;
+  input.pipe = function(parser2, options) {
+    parser2.splitter?.on("error", (error) => input.destroy(error));
+    return pipe.call(this, parser2, options);
+  };
+  let timer;
+  try {
+    return await Promise.race([
+      parser(input, PARSER_OPTIONS),
+      new Promise((resolve, reject) => {
+        timer = setTimeout(() => {
+          const error = Object.assign(new Error(`Message not parsed within ${timeout} ms`), { code: "ETIMEDOUT" });
+          input.destroy(error);
+          reject(error);
+        }, timeout);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+    input.destroy();
+  }
+}
+async function parseMessage(raw, options = {}) {
+  const buffer = Buffer5.isBuffer(raw) ? raw : Buffer5.from(raw);
+  const mail = await simpleParse(buffer, options);
+  const added = buffer.at(-1) === 10 ? 2 : 3;
+  for (const key of ["text", "html"]) {
+    if (typeof mail[key] === "string") {
+      mail[key] = mail[key].replace(new RegExp(`\\n{0,${added}}$`), "");
+    }
+  }
+  const tail = Buffer5.from("\r\n".repeat(added));
+  const last = mail.attachments?.at(-1);
+  const encoding = String(last?.headers?.get?.("content-transfer-encoding") ?? "7bit").trim().toLowerCase();
+  const own = Buffer5.isBuffer(last?.content) && last.content.length >= tail.length && last.content.subarray(-tail.length).equals(tail) ? last.content.subarray(0, -tail.length) : null;
+  if (own && ["7bit", "8bit", "binary"].includes(encoding) && own.length <= buffer.length && buffer.subarray(buffer.length - own.length).equals(own)) {
+    last.content = own;
+    last.size = own.length;
+    last.checksum = createHash2("md5").update(own).digest("hex");
+  }
+  return mail;
+}
+function finishable(raw) {
+  const buffer = Buffer5.isBuffer(raw) ? raw : Buffer5.from(raw);
+  return Buffer5.concat([buffer, Buffer5.from(buffer.at(-1) === 10 ? "\r\n\r\n" : "\r\n\r\n\r\n")]);
+}
+var MAX_FOLDS = 256;
+function headerValue2(line) {
+  const parameters = /* @__PURE__ */ new Map();
+  let key = null;
+  let inKey = false;
+  let quoted = false;
+  let escaped = false;
+  let value = "";
+  for (const chr of line.slice(line.indexOf(":") + 1).replaceAll(/\r?\n[ \t]*/g, " ")) {
+    if (inKey && chr === "=") {
+      key = value.trim().toLowerCase();
+      inKey = false;
+      value = "";
+    } else if (inKey || escaped) {
+      value += chr;
+      escaped = false;
+    } else if (chr === "\\") {
+      escaped = true;
+    } else if (chr === '"') {
+      quoted = !quoted;
+    } else if (chr === ";" && !quoted) {
+      parameters.set(key, value.trim());
+      inKey = true;
+      value = "";
+    } else {
+      value += chr;
+    }
+  }
+  if (!inKey) {
+    parameters.set(key, value.trim());
+  }
+  return { value: parameters.get(null).toLowerCase(), boundary: parameters.get("boundary") ?? "" };
+}
+function delimiter(raw, start, stop, boundary) {
+  const rest = start + 2 + boundary.length;
+  if (stop - start < boundary.length + 2 || stop - rest > 4 || raw[start] !== 45 || raw[start + 1] !== 45 || !raw.subarray(start + 2, rest).equals(boundary)) {
+    return 0;
+  }
+  if (raw[rest] === 13 || raw[rest] === 10) {
+    return 1;
+  }
+  const tail = raw.subarray(rest, stop).toString("latin1");
+  return /^-{0,2}$|^--\r?\n$|^--\r$/.test(tail) ? 2 : 0;
+}
+function unfoldHeaders(raw) {
+  const boundaries = [];
+  const unfold = [];
+  let head = true;
+  let fields = [];
+  const endHead = (blank) => {
+    unfold.push(...fields.filter((field) => field.folds > MAX_FOLDS));
+    const first = /* @__PURE__ */ new Map();
+    for (const field of fields) {
+      const name = raw.toString("latin1", field.start, Math.min(field.end, field.start + 32));
+      const key = name.slice(0, name.indexOf(":")).trim().toLowerCase();
+      if (["content-type", "content-transfer-encoding", "content-disposition"].includes(key) && !first.has(key)) {
+        first.set(key, headerValue2(raw.toString("latin1", field.start, field.end)));
+      }
+    }
+    fields = [];
+    const type = first.get("content-type") ?? { value: "", boundary: "" };
+    const encoding = (first.get("content-transfer-encoding")?.value ?? "").replaceAll(/\(.*\)/g, "").trim();
+    if (blank && type.boundary) {
+      boundaries.push(Buffer5.from(type.boundary));
+    }
+    head = blank && type.value === "message/rfc822" && ["", "7bit", "8bit", "binary"].includes(encoding) && first.get("content-disposition")?.value === "inline";
+  };
+  for (let start = 0; start < raw.length; ) {
+    const lf = raw.indexOf(10, start);
+    const stop = lf === -1 ? raw.length : lf + 1;
+    const end = lf === -1 ? stop : raw[lf - 1] === 13 ? lf - 1 : lf;
+    const kind = boundaries.length > 0 ? delimiter(raw, start, stop, boundaries.at(-1)) : 0;
+    if (kind !== 0) {
+      if (head) {
+        endHead(false);
+      }
+      head = kind === 1;
+      if (kind === 2) {
+        boundaries.pop();
+      }
+    } else if (head && end === start) {
+      endHead(true);
+    } else if (head && fields.length > 0 && (raw[start] === 32 || raw[start] === 9)) {
+      fields.at(-1).end = end;
+      fields.at(-1).folds++;
+    } else if (head) {
+      fields.push({ start, end, folds: 0 });
+    }
+    start = stop;
+  }
+  unfold.push(...fields.filter((field) => field.folds > MAX_FOLDS));
+  if (unfold.length === 0) {
+    return raw;
+  }
+  const chunks = [];
+  let copied = 0;
+  for (const field of unfold) {
+    chunks.push(raw.subarray(copied, field.start), Buffer5.from(raw.toString("latin1", field.start, field.end).replaceAll(/\r?\n[ \t]*/g, " "), "latin1"));
+    copied = field.end;
+  }
+  chunks.push(raw.subarray(copied));
+  return Buffer5.concat(chunks);
+}
+function upToLine(raw, offset) {
+  return raw.subarray(0, Math.max(raw.lastIndexOf(10, offset - 1) + 1, 0));
+}
+function fewerParts(raw) {
+  let offset = -1;
+  for (let count2 = 0; count2 < MAX_PART_LINES; count2++) {
+    offset = raw.indexOf("\n--", offset + 1);
+    if (offset === -1) {
+      return upToLine(raw, Math.floor(raw.length / 2));
+    }
+  }
+  return raw.subarray(0, offset + 1);
+}
+function smallerHeader(raw) {
+  const text = raw.toString("latin1");
+  const blank = /\r?\n\r?\n/.exec(text);
+  const end = blank ? blank.index : text.length;
+  const fields = [];
+  let start = 0;
+  while (start < end) {
+    let stop = text.indexOf("\n", start);
+    stop = stop === -1 || stop > end ? end : stop;
+    const last = fields.at(-1);
+    const whole = text.slice(start, stop).replace(/\r$/, "");
+    if (last && (whole.startsWith(" ") || whole.startsWith("	"))) {
+      const line = last.address ? whole : whole.slice(0, MAX_LINE2);
+      if (last.address || last.size + line.length <= MAX_FIELD) {
+        last.lines.push(line);
+        last.size += line.length;
+      }
+    } else {
+      const name = whole.slice(0, whole.indexOf(":")).trim().toLowerCase();
+      const address2 = ADDRESS_FIELDS.has(name) || name.startsWith("list-");
+      const line = address2 ? whole : whole.slice(0, MAX_LINE2);
+      fields.push({
+        name,
+        address: address2,
+        lines: [line],
+        size: line.length
+      });
+    }
+    start = stop + 1;
+  }
+  let fromCut = false;
+  for (const field of fields.filter((field2) => field2.address)) {
+    const line = field.lines.join("\r\n");
+    const bounded = boundAddressField(line, Number.POSITIVE_INFINITY);
+    fromCut ||= field.name === "from" && bounded !== line;
+    field.lines = [bounded];
+    field.size = bounded.length;
+  }
+  const total = fields.reduce((sum, field) => sum + field.size, 0);
+  const counts = /* @__PURE__ */ new Map();
+  const kept = total > MAX_HEADER ? fields.filter((field) => {
+    counts.set(field.name, (counts.get(field.name) || 0) + 1);
+    const keep = KEPT_FIELDS.has(field.name) && counts.get(field.name) <= MAX_REPEATED;
+    fromCut ||= field.name === "from" && !keep;
+    return keep;
+  }) : fields;
+  const header = kept.flatMap((field) => field.lines).join("\r\n");
+  return { raw: Buffer5.concat([Buffer5.from(`${header}\r
+\r
+`, "latin1"), raw.subarray(blank ? blank.index + blank[0].length : raw.length)]), fromCut };
+}
+async function parseWithin(raw, parse = parseMessage, deadline = Date.now() + PARSE_TIMEOUT) {
+  let input = raw;
+  let reason = null;
+  let fromCut = false;
+  for (; ; ) {
+    try {
+      const mail = await parse(input, { timeout: Math.max(1, deadline - Date.now()) });
+      if (fromCut && mail.from) {
+        mail.from.truncated = true;
+      }
+      return { mail, error: reason };
+    } catch (error) {
+      const limit = error.code === "EMAXLEN" && [TOO_MANY_PARTS, HEADER_TOO_LARGE].includes(error.message) ? error.message : null;
+      let shorter = input;
+      if (limit === TOO_MANY_PARTS) {
+        shorter = fewerParts(input);
+      } else if (limit === HEADER_TOO_LARGE) {
+        const smaller = smallerHeader(input);
+        shorter = smaller.raw.length < input.length ? smaller.raw : upToLine(input, MAX_PREFIX_BYTES);
+        fromCut ||= smaller.raw === shorter && smaller.fromCut;
+      }
+      if (shorter.length >= input.length) {
+        throw error;
+      }
+      reason ??= limit;
+      input = shorter;
+    }
+  }
+}
+async function expandAttachments(attachments = [], errors = [], parse = parseMessage) {
+  const all = [];
+  const deadline = Date.now() + PARSE_TIMEOUT;
+  let budget = MAX_NESTED_BYTES;
+  let nested = 0;
+  const visit = async (list, prefix, depth) => {
+    for (const attachment of list) {
+      if (prefix) {
+        if (nested >= MAX_ATTACHMENTS) {
+          return;
+        }
+        nested++;
+      }
+      const name = attachment.filename || (prefix ? "unnamed attachment" : "");
+      all.push(prefix ? { ...attachment, filename: `${prefix}/${name}` } : attachment);
+      const { content } = attachment;
+      const attached = attachment.contentType === "message/rfc822" || /\.eml$/i.test(attachment.filename || "");
+      if (attached && depth < MAX_NESTED_DEPTH && Buffer5.isBuffer(content) && content.length <= budget) {
+        budget -= content.length;
+        let inner;
+        try {
+          inner = await parseWithin(content, parse, deadline);
+        } catch (error) {
+          errors.push(`${name || "attached message"}: ${error.message}`);
+          continue;
+        }
+        if (inner.error) {
+          errors.push(inner.error);
+        }
+        await visit(inner.mail.attachments, prefix ? `${prefix}/${name}` : name || "attached message", depth + 1);
+      }
+    }
+  };
+  await visit(attachments, "", 0);
+  return all;
+}
+
 // src/reputation.js
 import { isIP as isIP2 } from "node:net";
 import { domainToASCII } from "node:url";
@@ -4662,11 +5143,11 @@ function normalizeIp(ip) {
     return ipv4;
   }
   const embedded = groups.slice(0, 4).every((group) => group === 0) && groups[4] === 65535 && groups[5] === 0 || groups[0] === 100 && groups[1] === 65435 && groups.slice(2, 6).every((group) => group === 0);
-  const count = embedded ? 6 : 8;
+  const count2 = embedded ? 6 : 8;
   let run = { start: -1, length: 1 };
-  for (let i = 0; i < count; i++) {
+  for (let i = 0; i < count2; i++) {
     let length = 0;
-    while (i + length < count && groups[i + length] === 0) {
+    while (i + length < count2 && groups[i + length] === 0) {
       length++;
     }
     if (length > run.length) {
@@ -4674,7 +5155,7 @@ function normalizeIp(ip) {
     }
     i += length;
   }
-  const hex = groups.slice(0, count).map((group) => group.toString(16));
+  const hex = groups.slice(0, count2).map((group) => group.toString(16));
   const written = run.start === -1 ? hex.join(":") : `${hex.slice(0, run.start).join(":")}::${hex.slice(run.start + run.length).join(":")}`;
   if (!embedded) {
     return written;
@@ -5121,7 +5602,7 @@ function trustedReputationValues(mail = {}, session = {}, authentication = null)
     ...[spfAligned].filter((signer) => signer !== null && (alignment?.spf?.strict !== true || signer === domain))
   ])];
   const fromValues = [];
-  for (const { address: address2 } of mail.from?.value || []) {
+  for (const { address: address2 } of mail.from?.truncated ? [] : mail.from?.value || []) {
     const domain = domainOf(address2);
     const values = reputationValues({ from: { value: [{ address: address2 }] } });
     if (domain !== null && dmarcDomain !== null && (domain === dmarcDomain || registrableDomain(domain) === dmarcDomain)) {
@@ -5184,6 +5665,37 @@ function createResolver(timeout = 1e4, servers) {
     }
   };
 }
+var MAX_DNS_QUERIES = 300;
+var MAX_AUTH_RESULTS_LENGTH = 8192;
+function dnsTimeout(message) {
+  const error = new Error(message);
+  error.code = "ETIMEOUT";
+  return error;
+}
+function limitResolver(resolver, { maxQueries = MAX_DNS_QUERIES, deadline = Number.POSITIVE_INFINITY } = {}) {
+  let count2 = 0;
+  return async (...args) => {
+    count2++;
+    if (count2 > maxQueries) {
+      throw dnsTimeout(`More than ${maxQueries} DNS lookups for one message`);
+    }
+    const left = deadline - Date.now();
+    if (left <= 0) {
+      throw dnsTimeout("Out of time for this message's DNS lookups");
+    }
+    let timer;
+    try {
+      return await Promise.race([
+        resolver(...args),
+        new Promise((_resolve, reject) => {
+          timer = setTimeout(() => reject(dnsTimeout("Out of time for this message's DNS lookups")), Math.min(left, 2147483647));
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+}
 function emptyResult() {
   return {
     dkim: { status: { result: "none", comment: "not checked" }, results: [], aligned: null },
@@ -5323,9 +5835,14 @@ async function authenticate(message, options = {}) {
   }
   try {
     const { authenticate: run } = await getMailauth();
-    const resolver = options.resolver || createResolver(timeout, options.dnsServers);
-    const raw = Buffer5.isBuffer(message) ? message : Buffer5.from(String(message));
-    const output = await run(raw, {
+    const resolver = limitResolver(options.resolver || createResolver(timeout, options.dnsServers), {
+      maxQueries: options.maxDnsQueries ?? MAX_DNS_QUERIES,
+      // (a little after `timeout`, so a caller that waits that long for the
+      //  result, as scan() does, has its answer first)
+      deadline: Date.now() + timeout + 100
+    });
+    const bounded = boundedForAuth(Buffer6.isBuffer(message) ? message : Buffer6.from(String(message)));
+    const output = await run(bounded.raw, {
       ip,
       helo: helo || void 0,
       sender: sender ?? void 0,
@@ -5333,6 +5850,10 @@ async function authenticate(message, options = {}) {
       resolver
     });
     Object.assign(result, normalizeAuthOutput(output, { trustedArcSealers: options.trustedArcSealers }));
+    if (bounded.fromCut) {
+      result.dmarc = { ...result.dmarc, status: { result: "fail", comment: "From field too long to read whole" } };
+      result.headers = "";
+    }
   } catch (error) {
     debug("authentication failed: %s", error.message);
     result.error = error.message;
@@ -5383,11 +5904,24 @@ function calculateAuthScore(auth, weights = {}) {
   }
   return { score: tests.reduce((sum, test) => sum + test.score, 0), tests };
 }
+function limitResults(value) {
+  if (value.length <= MAX_AUTH_RESULTS_LENGTH) {
+    return value;
+  }
+  const [server, ...results] = value.split(/;(?=\s*(?:dkim|spf|dmarc|arc|bimi)=)/i);
+  let kept = server;
+  for (const result of results) {
+    if (kept.length + 1 + result.length <= MAX_AUTH_RESULTS_LENGTH) {
+      kept += `;${result}`;
+    }
+  }
+  return kept;
+}
 function formatAuthResultsHeader(auth, hostname) {
   if (typeof auth?.headers === "string") {
     const match = auth.headers.match(/^authentication-results:[ \t]*([\s\S]*?)(?=\r?\n\S|(?![\s\S]))/im);
     if (match) {
-      const value = match[1].replaceAll(/\r?\n/g, "\r\n").trim();
+      const value = limitResults(match[1].replaceAll(/\r?\n/g, "\r\n").trim());
       return hostname ? value.replace(/^[^;\s]+/, hostname) : value;
     }
   }
@@ -5401,11 +5935,17 @@ function summarizeAuth(auth) {
   return ["spf", "dkim", "dmarc", "arc"].map((name) => `${name}=${auth?.[name]?.status?.result || "none"}`).join(" ");
 }
 
+// src/server.js
+import { Buffer as Buffer7 } from "node:buffer";
+import { timingSafeEqual } from "node:crypto";
+import http2 from "node:http";
+import net from "node:net";
+
 // package.json
 var package_default = {
   name: "spamscanner",
   description: "Spam, phishing and malware filter for email in any language: a trainable classifier, link and attachment checks, SPF/DKIM/DMARC, and an optional AI second opinion from any LLM, including local Ollama models. Works as a library, CLI, Postfix milter or HTTP API.",
-  version: "7.0.4",
+  version: "7.0.6",
   author: "Forward Email (https://forwardemail.net)",
   bin: {
     spamscanner: "./dist/esm/cli.js"
@@ -5551,29 +6091,212 @@ var package_default = {
 // src/version.js
 var VERSION = package_default.version;
 
-// src/milter.js
-var COMMANDS = {
-  ABORT: "A",
-  BODY: "B",
-  CONNECT: "C",
-  MACRO: "D",
-  BODYEOB: "E",
-  HELO: "H",
-  QUIT_NC: "K",
-  HEADER: "L",
-  MAIL: "M",
-  EOH: "N",
-  OPTNEG: "O",
-  QUIT: "Q",
-  RCPT: "R",
-  DATA: "T",
-  UNKNOWN: "U"
-};
-var RESPONSES = {
-  ACCEPT: "a",
-  CONTINUE: "c",
-  DISCARD: "d",
-  ADDHEADER: "h",
+// src/server.js
+var MAX_MESSAGE_SIZE = 25 * 1024 * 1024;
+var MAX_CONNECTIONS = 200;
+function serializeResult(result, options = {}) {
+  const { mail, tokens, ...rest } = result;
+  const output = {
+    ...rest,
+    results: { ...result.results }
+  };
+  if (output.results.authentication) {
+    const { receivedChain, ...auth } = output.results.authentication;
+    output.results.authentication = auth;
+  }
+  if (options.verbose) {
+    output.tokens = tokens;
+    output.subject = mail?.subject ?? null;
+  }
+  return output;
+}
+function sessionFromQuery(query) {
+  const session = {};
+  if (query.get("ip")) {
+    session.remoteAddress = query.get("ip");
+  }
+  if (query.get("hostname")) {
+    session.resolvedClientHostname = query.get("hostname");
+  }
+  if (query.get("helo")) {
+    session.helo = query.get("helo");
+  }
+  const recipients = query.getAll("to").flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
+  if (query.has("from") || recipients.length > 0) {
+    session.envelope = { mailFrom: { address: query.get("from") || "" }, rcptTo: recipients.map((address2) => ({ address: address2 })) };
+  }
+  return session;
+}
+function sameToken(given, expected) {
+  const a = Buffer7.from(String(given));
+  const b = Buffer7.from(String(expected));
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function readBody(request, limit) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    request.on("data", (chunk2) => {
+      size += chunk2.length;
+      if (size <= limit) {
+        chunks.push(chunk2);
+      }
+    });
+    request.on("end", () => {
+      if (size > limit) {
+        const error = new Error(`Message larger than ${limit} bytes`);
+        error.statusCode = 413;
+        reject(error);
+        return;
+      }
+      resolve(Buffer7.concat(chunks));
+    });
+    request.on("error", reject);
+  });
+}
+function createHttpServer(scanner, options = {}) {
+  const {
+    token = null,
+    maxSize = MAX_MESSAGE_SIZE,
+    modelPath = null,
+    maxConnections = MAX_CONNECTIONS
+  } = options;
+  let active = 0;
+  const server = http2.createServer(async (request, response) => {
+    const send = (status, body, headers = {}) => {
+      const isBuffer = Buffer7.isBuffer(body);
+      response.writeHead(status, { "content-type": isBuffer ? "message/rfc822" : "application/json; charset=utf-8", "cache-control": "no-store", ...headers });
+      response.end(isBuffer ? body : `${JSON.stringify(body)}
+`);
+    };
+    try {
+      const url = new URL(request.url, "http://localhost");
+      if (request.method === "GET" && url.pathname === "/health") {
+        send(200, { ok: true, version: VERSION });
+        return;
+      }
+      if (token && !sameToken((request.headers.authorization || "").replace(/^bearer\s+/i, ""), token)) {
+        send(401, { error: "Unauthorized" }, { "www-authenticate": "Bearer" });
+        return;
+      }
+      if (request.method !== "POST") {
+        send(405, { error: "Method not allowed" }, { allow: "POST" });
+        return;
+      }
+      const learn = /^\/learn\/(spam|ham)$/.exec(url.pathname);
+      if (!["/scan", "/check"].includes(url.pathname) && !learn) {
+        send(404, { error: "Not found" });
+        return;
+      }
+      if (learn && !token) {
+        send(403, { error: "Learning needs the server to be started with a token" });
+        return;
+      }
+      const length = request.headers["content-length"];
+      if (length !== void 0 && Number(length) > maxSize) {
+        send(413, { error: `Message larger than ${maxSize} bytes` }, { connection: "close" });
+        return;
+      }
+      if (active >= maxConnections) {
+        send(503, { error: "Too many requests at once" }, { connection: "close", "retry-after": "1" });
+        return;
+      }
+      active++;
+      try {
+        const raw = await readBody(request, maxSize);
+        if (learn) {
+          await scanner.learn(raw, learn[1]);
+          if (modelPath) {
+            scanner.saveModel(modelPath);
+          }
+          send(200, { ok: true, learned: learn[1] });
+          return;
+        }
+        const result = await scanner.scan(raw, { session: sessionFromQuery(url.searchParams) });
+        if (url.pathname === "/scan") {
+          send(200, serializeResult(result, { verbose: url.searchParams.get("verbose") === "1" }));
+          return;
+        }
+        const tag = url.searchParams.get("subjectTag");
+        const rewritten = rewriteMessage(raw, spamHeaders(result, { version: VERSION }), { subjectTag: result.isSpam && tag ? tag : null });
+        send(200, rewritten, { "x-spam-flag": result.isSpam ? "YES" : "NO", "x-spam-score": result.score.toFixed(1), "x-spam-action": result.action });
+      } finally {
+        active--;
+      }
+    } catch (error) {
+      send(error.statusCode || 500, { error: error.message });
+    }
+  });
+  server.maxConnections = maxConnections;
+  return server;
+}
+function createTcpServer(scanner, options = {}) {
+  const {
+    json = true,
+    maxSize = MAX_MESSAGE_SIZE,
+    timeout = 6e4,
+    maxConnections = MAX_CONNECTIONS
+  } = options;
+  const server = net.createServer({ allowHalfOpen: true }, (socket) => {
+    const chunks = [];
+    let size = 0;
+    socket.setTimeout(timeout, () => socket.destroy());
+    const onEnd = async () => {
+      socket.setTimeout(0);
+      try {
+        const result = await scanner.scan(Buffer7.concat(chunks));
+        socket.end(json ? `${JSON.stringify(serializeResult(result))}
+` : `${result.isSpam ? "SPAM" : "HAM"} ${result.score.toFixed(1)}/${result.threshold.toFixed(1)} ${result.tests.map((test) => test.name).join(",")}
+`);
+      } catch (error) {
+        socket.end(json ? `${JSON.stringify({ error: error.message })}
+` : `ERROR ${error.message}
+`);
+      }
+    };
+    const onData = (chunk2) => {
+      size += chunk2.length;
+      if (size > maxSize) {
+        socket.off("data", onData);
+        socket.off("end", onEnd);
+        socket.end(`${JSON.stringify({ error: `Message larger than ${maxSize} bytes` })}
+`, () => socket.destroy());
+        return;
+      }
+      chunks.push(chunk2);
+    };
+    socket.on("data", onData);
+    socket.on("end", onEnd);
+    socket.on("error", () => {
+    });
+  });
+  server.maxConnections = maxConnections;
+  return server;
+}
+
+// src/milter.js
+var COMMANDS = {
+  ABORT: "A",
+  BODY: "B",
+  CONNECT: "C",
+  MACRO: "D",
+  BODYEOB: "E",
+  HELO: "H",
+  QUIT_NC: "K",
+  HEADER: "L",
+  MAIL: "M",
+  EOH: "N",
+  OPTNEG: "O",
+  QUIT: "Q",
+  RCPT: "R",
+  DATA: "T",
+  UNKNOWN: "U"
+};
+var RESPONSES = {
+  ACCEPT: "a",
+  CONTINUE: "c",
+  DISCARD: "d",
+  ADDHEADER: "h",
   INSHEADER: "i",
   CHGHEADER: "m",
   QUARANTINE: "q",
@@ -5615,12 +6338,12 @@ var PROTOCOL = {
   HDR_LEADSPC: 1048576
 };
 var MAX_PACKET = 1024 * 1024;
-function packet(command, data = Buffer6.alloc(0)) {
-  const payload = Buffer6.isBuffer(data) ? data : Buffer6.from(data, "latin1");
-  const header = Buffer6.alloc(5);
+function packet(command, data = Buffer8.alloc(0)) {
+  const payload = Buffer8.isBuffer(data) ? data : Buffer8.from(data, "latin1");
+  const header = Buffer8.alloc(5);
   header.writeUInt32BE(payload.length + 1);
   header.write(command, 4, "latin1");
-  return Buffer6.concat([header, payload]);
+  return Buffer8.concat([header, payload]);
 }
 function cstrings(data) {
   const parts = data.toString("latin1").split("\0");
@@ -5630,7 +6353,7 @@ function cstrings(data) {
   return parts;
 }
 function cstring(value) {
-  return Buffer6.from(`${value}\0`, "latin1");
+  return Buffer8.from(`${value}\0`, "latin1");
 }
 function address(value) {
   const text = String(value ?? "").trim();
@@ -5666,6 +6389,15 @@ var MilterSession = class {
     this.body = [];
     this.size = 0;
     this.truncated = false;
+    this.headerSize = 0;
+  }
+  // The envelope and headers are kept whole for the scan, so beyond the
+  // message size limit the message is not scanned (see onError).
+  keep(data) {
+    this.headerSize += data.length;
+    if (this.headerSize > this.server.options.maxSize) {
+      throw new Error(`Message headers larger than ${this.server.options.maxSize} bytes`);
+    }
   }
   send(command, data) {
     if (!this.socket.destroyed) {
@@ -5678,7 +6410,7 @@ var MilterSession = class {
     if (this.buffered < this.needed) {
       return;
     }
-    let buffer = this.chunks.length === 1 ? this.chunks[0] : Buffer6.concat(this.chunks);
+    let buffer = this.chunks.length === 1 ? this.chunks[0] : Buffer8.concat(this.chunks);
     this.needed = 4;
     while (buffer.length >= 4) {
       const length = buffer.readUInt32BE(0);
@@ -5723,7 +6455,7 @@ var MilterSession = class {
         const protocol = data.readUInt32BE(8);
         const wanted = ACTIONS.ADDHDRS | ACTIONS.CHGHDRS | ACTIONS.QUARANTINE;
         this.leadingSpace = Boolean(protocol & PROTOCOL.HDR_LEADSPC);
-        const reply2 = Buffer6.alloc(12);
+        const reply2 = Buffer8.alloc(12);
         reply2.writeUInt32BE(Math.min(version, 6), 0);
         reply2.writeUInt32BE(actions & wanted, 4);
         reply2.writeUInt32BE(protocol & (PROTOCOL.HDR_LEADSPC | PROTOCOL.NOUNKNOWN), 8);
@@ -5766,16 +6498,19 @@ var MilterSession = class {
       }
       case COMMANDS.MAIL: {
         this.resetMessage();
+        this.keep(data);
         this.envelope.mailFrom = { address: address(cstrings(data)[0]) };
         this.send(RESPONSES.CONTINUE);
         break;
       }
       case COMMANDS.RCPT: {
+        this.keep(data);
         this.envelope.rcptTo.push({ address: address(cstrings(data)[0]) });
         this.send(RESPONSES.CONTINUE);
         break;
       }
       case COMMANDS.HEADER: {
+        this.keep(data);
         const [name, value = ""] = cstrings(data);
         this.headers.push([name, value]);
         this.send(RESPONSES.CONTINUE);
@@ -5785,14 +6520,19 @@ var MilterSession = class {
         if (this.truncated || this.size + data.length > options.maxSize) {
           this.truncated = true;
         } else {
-          this.body.push(Buffer6.from(data));
+          this.body.push(Buffer8.from(data));
           this.size += data.length;
         }
         this.send(RESPONSES.CONTINUE);
         break;
       }
       case COMMANDS.BODYEOB: {
-        await this.endOfMessage();
+        this.socket.pause();
+        try {
+          await this.endOfMessage();
+        } finally {
+          this.socket.resume();
+        }
         break;
       }
       case COMMANDS.ABORT: {
@@ -5815,7 +6555,7 @@ var MilterSession = class {
   /** @returns {Buffer} */
   rawMessage() {
     const head = this.headers.map(([name, value]) => `${name}:${this.leadingSpace || value.startsWith(" ") || value.startsWith("	") ? "" : " "}${value}`).join("\r\n");
-    return Buffer6.concat([Buffer6.from(this.headers.length > 0 ? `${head}\r
+    return Buffer8.concat([Buffer8.from(this.headers.length > 0 ? `${head}\r
 \r
 ` : "\r\n", "latin1"), ...this.body]);
   }
@@ -5826,9 +6566,9 @@ var MilterSession = class {
       const key = name.toLowerCase();
       counts.set(key, (counts.get(key) || 0) + 1);
       if (key.startsWith("x-spam-")) {
-        const index = Buffer6.alloc(4);
+        const index = Buffer8.alloc(4);
         index.writeUInt32BE(counts.get(key));
-        this.send(RESPONSES.CHGHEADER, Buffer6.concat([index, cstring(name), cstring("")]));
+        this.send(RESPONSES.CHGHEADER, Buffer8.concat([index, cstring(name), cstring("")]));
       }
     }
   }
@@ -5851,7 +6591,7 @@ var MilterSession = class {
       }
       this.server.report(error);
       this.removeForgedHeaders();
-      this.send(RESPONSES.ADDHEADER, Buffer6.concat([cstring("X-Spam-Virus-Scan"), cstring(`${this.leadingSpace ? " " : ""}failed`)]));
+      this.send(RESPONSES.ADDHEADER, Buffer8.concat([cstring("X-Spam-Virus-Scan"), cstring(`${this.leadingSpace ? " " : ""}failed`)]));
       this.send(RESPONSES.CONTINUE);
       this.resetMessage();
       return;
@@ -5872,15 +6612,15 @@ var MilterSession = class {
       headers.unshift(["Authentication-Results", formatAuthResultsHeader(result.results.authentication, options.hostname)]);
     }
     for (const [name, value] of headers) {
-      this.send(RESPONSES.ADDHEADER, Buffer6.concat([cstring(name), cstring(`${this.leadingSpace ? " " : ""}${value}`.replaceAll("\r\n", "\n"))]));
+      this.send(RESPONSES.ADDHEADER, Buffer8.concat([cstring(name), cstring(`${this.leadingSpace ? " " : ""}${value}`.replaceAll("\r\n", "\n"))]));
     }
     if (result.isSpam && options.subjectTag) {
       const subject = this.headers.find(([name]) => name.toLowerCase() === "subject");
       const value = taggedSubject(options.subjectTag, subject ? subject[1].trim() : "", "\n");
       if (value !== null) {
-        const index = Buffer6.alloc(4);
+        const index = Buffer8.alloc(4);
         index.writeUInt32BE(1);
-        this.send(RESPONSES.CHGHEADER, Buffer6.concat([index, cstring("Subject"), cstring(`${this.leadingSpace ? " " : ""}${value}`.replaceAll("\r\n", "\n"))]));
+        this.send(RESPONSES.CHGHEADER, Buffer8.concat([index, cstring("Subject"), cstring(`${this.leadingSpace ? " " : ""}${value}`.replaceAll("\r\n", "\n"))]));
       }
     }
     if (result.action === "reject" && options.reject) {
@@ -5907,8 +6647,10 @@ var MilterServer = class extends EventEmitter {
    * @param {boolean} [options.quarantine] - hold spam in the MTA's quarantine
    * @param {string|null} [options.subjectTag] - e.g. "[SPAM]"
    * @param {string} [options.hostname] - this server's name, for Authentication-Results
-   * @param {number} [options.maxSize] - body bytes kept for scanning
+   * @param {number} [options.maxSize] - body bytes kept for scanning (and the
+   *   most bytes of envelope and headers: beyond them a message is not scanned)
    * @param {'tempfail'|'accept'} [options.onError] - answer when a scan fails
+   * @param {number} [options.maxConnections] - connections kept open at once; more are closed at once
    */
   constructor(scanner, options = {}) {
     super();
@@ -5920,19 +6662,21 @@ var MilterServer = class extends EventEmitter {
       quarantine: false,
       subjectTag: null,
       hostname: "spamscanner",
-      maxSize: 25 * 1024 * 1024,
+      maxSize: MAX_MESSAGE_SIZE,
       onError: "tempfail",
+      maxConnections: MAX_CONNECTIONS,
       ...options
     };
     if (!/^[45]\d\d$/.test(String(this.options.rejectCode))) {
       throw new RangeError(`rejectCode must be a 4xx or 5xx SMTP code, not ${this.options.rejectCode}`);
     }
     this.sockets = /* @__PURE__ */ new Set();
-    this.server = net.createServer((socket) => {
+    this.server = net2.createServer((socket) => {
       this.sockets.add(socket);
       socket.on("close", () => this.sockets.delete(socket));
       return new MilterSession(socket, this);
     });
+    this.server.maxConnections = this.options.maxConnections;
     this.server.on("error", (error) => this.report(error));
   }
   // Errors go to "error" listeners; with none, a broken connection or failed
@@ -5980,7 +6724,11 @@ var MilterServer = class extends EventEmitter {
 
 // src/model.js
 import {
+  closeSync,
   existsSync,
+  fchmodSync,
+  fsyncSync,
+  openSync,
   readFileSync,
   writeFileSync,
   mkdirSync,
@@ -6056,9 +6804,19 @@ function saveModel(classifier, file, options = {}) {
   const resolved = path.resolve(file);
   mkdirSync(path.dirname(resolved), { recursive: true });
   const temporary = `${resolved}.${process2.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+  const mode = statSync(resolved, { throwIfNoEntry: false })?.mode;
+  const fd = openSync(temporary, "wx");
   try {
-    writeFileSync(temporary, `${JSON.stringify(classifier.toJSON(options))}
+    try {
+      if (mode !== void 0) {
+        fchmodSync(fd, mode % 512);
+      }
+      writeFileSync(fd, `${JSON.stringify(classifier.toJSON(options))}
 `);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
     renameSync(temporary, resolved);
   } catch (error) {
     rmSync(temporary, { force: true });
@@ -6204,164 +6962,8 @@ var CLASSIFIER_MODELS = [
   }
 ];
 
-// src/server.js
-import { Buffer as Buffer7 } from "node:buffer";
-import { timingSafeEqual } from "node:crypto";
-import http2 from "node:http";
-import net2 from "node:net";
-function serializeResult(result, options = {}) {
-  const { mail, tokens, ...rest } = result;
-  const output = {
-    ...rest,
-    results: { ...result.results }
-  };
-  if (output.results.authentication) {
-    const { receivedChain, ...auth } = output.results.authentication;
-    output.results.authentication = auth;
-  }
-  if (options.verbose) {
-    output.tokens = tokens;
-    output.subject = mail?.subject ?? null;
-  }
-  return output;
-}
-function sessionFromQuery(query) {
-  const session = {};
-  if (query.get("ip")) {
-    session.remoteAddress = query.get("ip");
-  }
-  if (query.get("hostname")) {
-    session.resolvedClientHostname = query.get("hostname");
-  }
-  if (query.get("helo")) {
-    session.helo = query.get("helo");
-  }
-  const recipients = query.getAll("to").flatMap((value) => value.split(",")).map((value) => value.trim()).filter(Boolean);
-  if (query.has("from") || recipients.length > 0) {
-    session.envelope = { mailFrom: { address: query.get("from") || "" }, rcptTo: recipients.map((address2) => ({ address: address2 })) };
-  }
-  return session;
-}
-function sameToken(given, expected) {
-  const a = Buffer7.from(String(given));
-  const b = Buffer7.from(String(expected));
-  return a.length === b.length && timingSafeEqual(a, b);
-}
-function readBody(request, limit) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    let size = 0;
-    request.on("data", (chunk2) => {
-      size += chunk2.length;
-      if (size <= limit) {
-        chunks.push(chunk2);
-      }
-    });
-    request.on("end", () => {
-      if (size > limit) {
-        const error = new Error(`Message larger than ${limit} bytes`);
-        error.statusCode = 413;
-        reject(error);
-        return;
-      }
-      resolve(Buffer7.concat(chunks));
-    });
-    request.on("error", reject);
-  });
-}
-function createHttpServer(scanner, options = {}) {
-  const { token = null, maxSize = 25 * 1024 * 1024, modelPath = null } = options;
-  return http2.createServer(async (request, response) => {
-    const send = (status, body, headers = {}) => {
-      const isBuffer = Buffer7.isBuffer(body);
-      response.writeHead(status, { "content-type": isBuffer ? "message/rfc822" : "application/json; charset=utf-8", "cache-control": "no-store", ...headers });
-      response.end(isBuffer ? body : `${JSON.stringify(body)}
-`);
-    };
-    try {
-      const url = new URL(request.url, "http://localhost");
-      if (request.method === "GET" && url.pathname === "/health") {
-        send(200, { ok: true, version: VERSION });
-        return;
-      }
-      if (token && !sameToken((request.headers.authorization || "").replace(/^bearer\s+/i, ""), token)) {
-        send(401, { error: "Unauthorized" }, { "www-authenticate": "Bearer" });
-        return;
-      }
-      if (request.method !== "POST") {
-        send(405, { error: "Method not allowed" }, { allow: "POST" });
-        return;
-      }
-      const learn = /^\/learn\/(spam|ham)$/.exec(url.pathname);
-      if (!["/scan", "/check"].includes(url.pathname) && !learn) {
-        send(404, { error: "Not found" });
-        return;
-      }
-      if (learn && !token) {
-        send(403, { error: "Learning needs the server to be started with a token" });
-        return;
-      }
-      const raw = await readBody(request, maxSize);
-      if (learn) {
-        await scanner.learn(raw, learn[1]);
-        if (modelPath) {
-          scanner.saveModel(modelPath);
-        }
-        send(200, { ok: true, learned: learn[1] });
-        return;
-      }
-      const result = await scanner.scan(raw, { session: sessionFromQuery(url.searchParams) });
-      if (url.pathname === "/scan") {
-        send(200, serializeResult(result, { verbose: url.searchParams.get("verbose") === "1" }));
-        return;
-      }
-      const tag = url.searchParams.get("subjectTag");
-      const rewritten = rewriteMessage(raw, spamHeaders(result, { version: VERSION }), { subjectTag: result.isSpam && tag ? tag : null });
-      send(200, rewritten, { "x-spam-flag": result.isSpam ? "YES" : "NO", "x-spam-score": result.score.toFixed(1), "x-spam-action": result.action });
-    } catch (error) {
-      send(error.statusCode || 500, { error: error.message });
-    }
-  });
-}
-function createTcpServer(scanner, options = {}) {
-  const { json = true, maxSize = 25 * 1024 * 1024, timeout = 6e4 } = options;
-  return net2.createServer({ allowHalfOpen: true }, (socket) => {
-    const chunks = [];
-    let size = 0;
-    socket.setTimeout(timeout, () => socket.destroy());
-    const onEnd = async () => {
-      socket.setTimeout(0);
-      try {
-        const result = await scanner.scan(Buffer7.concat(chunks));
-        socket.end(json ? `${JSON.stringify(serializeResult(result))}
-` : `${result.isSpam ? "SPAM" : "HAM"} ${result.score.toFixed(1)}/${result.threshold.toFixed(1)} ${result.tests.map((test) => test.name).join(",")}
-`);
-      } catch (error) {
-        socket.end(json ? `${JSON.stringify({ error: error.message })}
-` : `ERROR ${error.message}
-`);
-      }
-    };
-    const onData = (chunk2) => {
-      size += chunk2.length;
-      if (size > maxSize) {
-        socket.off("data", onData);
-        socket.off("end", onEnd);
-        socket.end(`${JSON.stringify({ error: `Message larger than ${maxSize} bytes` })}
-`, () => socket.destroy());
-        return;
-      }
-      chunks.push(chunk2);
-    };
-    socket.on("data", onData);
-    socket.on("end", onEnd);
-    socket.on("error", () => {
-    });
-  });
-}
-
 // src/spamd.js
-import { Buffer as Buffer8 } from "node:buffer";
+import { Buffer as Buffer9 } from "node:buffer";
 import net3 from "node:net";
 var EX_OK = 0;
 var EX_USAGE = 64;
@@ -6392,7 +6994,7 @@ function reply(code, text, headers = [], body = null) {
     lines2.push(`Content-length: ${body.length}`);
   }
   lines2.push(...headers.map(([name, value]) => `${name}: ${value}`), "", "");
-  return body === null ? Buffer8.from(lines2.join("\r\n")) : Buffer8.concat([Buffer8.from(lines2.join("\r\n")), body]);
+  return body === null ? Buffer9.from(lines2.join("\r\n")) : Buffer9.concat([Buffer9.from(lines2.join("\r\n")), body]);
 }
 function report(result) {
   const lines2 = [
@@ -6437,11 +7039,11 @@ async function answer(scanner, request, message, options) {
       return reply(EX_OK, "EX_OK", [verdict]);
     }
     case "SYMBOLS": {
-      return reply(EX_OK, "EX_OK", [verdict], Buffer8.from(result.tests.map((test) => test.name).join(",")));
+      return reply(EX_OK, "EX_OK", [verdict], Buffer9.from(result.tests.map((test) => test.name).join(",")));
     }
     case "REPORT":
     case "REPORT_IFSPAM": {
-      return reply(EX_OK, "EX_OK", [verdict], command === "REPORT" || result.isSpam ? Buffer8.from(report(result)) : Buffer8.alloc(0));
+      return reply(EX_OK, "EX_OK", [verdict], command === "REPORT" || result.isSpam ? Buffer9.from(report(result)) : Buffer9.alloc(0));
     }
     default: {
       const rewritten = rewriteMessage(message, spamHeaders(result, { version: VERSION }), { subjectTag: result.isSpam ? options.subjectTag : null });
@@ -6449,21 +7051,22 @@ async function answer(scanner, request, message, options) {
         return reply(EX_OK, "EX_OK", [verdict], rewritten);
       }
       const { header, newline } = splitMessage(rewritten);
-      return reply(EX_OK, "EX_OK", [verdict], Buffer8.from(`${header}${newline}${newline}`, "latin1"));
+      return reply(EX_OK, "EX_OK", [verdict], Buffer9.from(`${header}${newline}${newline}`, "latin1"));
     }
   }
 }
 function createSpamdServer(scanner, options = {}) {
   const settings = {
-    maxSize: 25 * 1024 * 1024,
+    maxSize: MAX_MESSAGE_SIZE,
     allowTell: false,
     modelPath: null,
     subjectTag: null,
     timeout: 6e4,
+    maxConnections: MAX_CONNECTIONS,
     ...options
   };
-  return net3.createServer({ allowHalfOpen: true }, (socket) => {
-    let head = Buffer8.alloc(0);
+  const server = net3.createServer({ allowHalfOpen: true }, (socket) => {
+    let head = Buffer9.alloc(0);
     const chunks = [];
     let size = 0;
     let request = null;
@@ -6489,7 +7092,7 @@ function createSpamdServer(scanner, options = {}) {
         return;
       }
       if (!request) {
-        head = Buffer8.concat([head, chunk2]);
+        head = Buffer9.concat([head, chunk2]);
         const end = head.indexOf("\r\n\r\n");
         if (end === -1) {
           if (head.length > 64 * 1024) {
@@ -6524,7 +7127,7 @@ function createSpamdServer(scanner, options = {}) {
       chunks.push(chunk2);
       size += chunk2.length;
       if (request.length === null ? ["PING", "SKIP"].includes(request.command) : size >= request.length) {
-        finish(Buffer8.concat(chunks).subarray(0, request.length ?? 0));
+        finish(Buffer9.concat(chunks).subarray(0, request.length ?? 0));
       } else if (size > settings.maxSize) {
         fail(EX_DATAERR, `Message larger than ${settings.maxSize} bytes`);
       }
@@ -6536,7 +7139,7 @@ function createSpamdServer(scanner, options = {}) {
       if (!request) {
         fail(EX_PROTOCOL, "Incomplete request");
       } else if (request.length === null) {
-        finish(Buffer8.concat(chunks));
+        finish(Buffer9.concat(chunks));
       } else {
         fail(EX_PROTOCOL, `Message shorter than its Content-length of ${request.length} bytes`);
       }
@@ -6544,181 +7147,14 @@ function createSpamdServer(scanner, options = {}) {
     socket.on("error", () => {
     });
   });
+  server.maxConnections = settings.maxConnections;
+  return server;
 }
 
 // src/train.js
 import { createHash as createHash3 } from "node:crypto";
 import path3 from "node:path";
 
-// src/parse.js
-import { Buffer as Buffer9 } from "node:buffer";
-import { createHash as createHash2 } from "node:crypto";
-import { simpleParser } from "mailparser";
-var PARSER_OPTIONS = {
-  skipHtmlToText: true,
-  skipImageLinks: true,
-  skipTextToHtml: true,
-  skipTextLinks: true
-};
-var TOO_MANY_PARTS = "Max allowed child nodes exceeded";
-var HEADER_TOO_LARGE = "Max header size for a MIME node exceeded";
-var MAX_PART_LINES = 990;
-var MAX_PREFIX_BYTES = 1e6;
-var MAX_LINE2 = 998;
-var MAX_FIELD = 8192;
-var MAX_HEADER = 512 * 1024;
-var MAX_REPEATED = 100;
-var KEPT_FIELDS = /* @__PURE__ */ new Set([
-  "from",
-  "sender",
-  "reply-to",
-  "to",
-  "cc",
-  "subject",
-  "date",
-  "message-id",
-  "return-path",
-  "received",
-  "authentication-results",
-  "arc-authentication-results",
-  "dkim-signature",
-  "mime-version",
-  "content-type",
-  "content-transfer-encoding",
-  "list-unsubscribe",
-  "list-id"
-]);
-var MAX_NESTED_DEPTH = 3;
-var MAX_ATTACHMENTS = 100;
-var MAX_NESTED_BYTES = 25 * 1024 * 1024;
-async function parseMessage(raw) {
-  const buffer = Buffer9.isBuffer(raw) ? raw : Buffer9.from(raw);
-  const mail = await simpleParser(finishable(buffer), PARSER_OPTIONS);
-  const added = buffer.at(-1) === 10 ? 2 : 3;
-  for (const key of ["text", "html"]) {
-    if (typeof mail[key] === "string") {
-      mail[key] = mail[key].replace(new RegExp(`\\n{0,${added}}$`), "");
-    }
-  }
-  const tail = Buffer9.from("\r\n".repeat(added));
-  const last = mail.attachments?.at(-1);
-  const encoding = String(last?.headers?.get?.("content-transfer-encoding") ?? "7bit").trim().toLowerCase();
-  const own = Buffer9.isBuffer(last?.content) && last.content.length >= tail.length && last.content.subarray(-tail.length).equals(tail) ? last.content.subarray(0, -tail.length) : null;
-  if (own && ["7bit", "8bit", "binary"].includes(encoding) && own.length <= buffer.length && buffer.subarray(buffer.length - own.length).equals(own)) {
-    last.content = own;
-    last.size = own.length;
-    last.checksum = createHash2("md5").update(own).digest("hex");
-  }
-  return mail;
-}
-function finishable(raw) {
-  const buffer = Buffer9.isBuffer(raw) ? raw : Buffer9.from(raw);
-  return Buffer9.concat([buffer, Buffer9.from(buffer.at(-1) === 10 ? "\r\n\r\n" : "\r\n\r\n\r\n")]);
-}
-function upToLine(raw, offset) {
-  return raw.subarray(0, Math.max(raw.lastIndexOf(10, offset - 1) + 1, 0));
-}
-function fewerParts(raw) {
-  let offset = -1;
-  for (let count = 0; count < MAX_PART_LINES; count++) {
-    offset = raw.indexOf("\n--", offset + 1);
-    if (offset === -1) {
-      return upToLine(raw, Math.floor(raw.length / 2));
-    }
-  }
-  return raw.subarray(0, offset + 1);
-}
-function smallerHeader(raw) {
-  const text = raw.toString("latin1");
-  const blank = /\r?\n\r?\n/.exec(text);
-  const end = blank ? blank.index : text.length;
-  const fields = [];
-  let start = 0;
-  while (start < end) {
-    let stop = text.indexOf("\n", start);
-    stop = stop === -1 || stop > end ? end : stop;
-    const line = text.slice(start, Math.min(stop, start + MAX_LINE2)).replace(/\r$/, "");
-    const last = fields.at(-1);
-    if (last && (line.startsWith(" ") || line.startsWith("	"))) {
-      if (last.size + line.length <= MAX_FIELD) {
-        last.lines.push(line);
-        last.size += line.length;
-      }
-    } else {
-      fields.push({ name: line.slice(0, line.indexOf(":")).trim().toLowerCase(), lines: [line], size: line.length });
-    }
-    start = stop + 1;
-  }
-  const total = fields.reduce((sum, field) => sum + field.size, 0);
-  const counts = /* @__PURE__ */ new Map();
-  const kept = total > MAX_HEADER ? fields.filter((field) => {
-    counts.set(field.name, (counts.get(field.name) || 0) + 1);
-    return KEPT_FIELDS.has(field.name) && counts.get(field.name) <= MAX_REPEATED;
-  }) : fields;
-  const header = kept.flatMap((field) => field.lines).join("\r\n");
-  return Buffer9.concat([Buffer9.from(`${header}\r
-\r
-`, "latin1"), raw.subarray(blank ? blank.index + blank[0].length : raw.length)]);
-}
-async function parseWithin(raw, parse = parseMessage) {
-  let input = raw;
-  let reason = null;
-  for (; ; ) {
-    try {
-      return { mail: await parse(input), error: reason };
-    } catch (error) {
-      const limit = error.code === "EMAXLEN" && [TOO_MANY_PARTS, HEADER_TOO_LARGE].includes(error.message) ? error.message : null;
-      let shorter = input;
-      if (limit === TOO_MANY_PARTS) {
-        shorter = fewerParts(input);
-      } else if (limit === HEADER_TOO_LARGE) {
-        shorter = smallerHeader(input);
-        shorter = shorter.length < input.length ? shorter : upToLine(input, MAX_PREFIX_BYTES);
-      }
-      if (shorter.length >= input.length) {
-        throw error;
-      }
-      reason ??= limit;
-      input = shorter;
-    }
-  }
-}
-async function expandAttachments(attachments = [], errors = [], parse = parseMessage) {
-  const all = [];
-  let budget = MAX_NESTED_BYTES;
-  let nested = 0;
-  const visit = async (list, prefix, depth) => {
-    for (const attachment of list) {
-      if (prefix) {
-        if (nested >= MAX_ATTACHMENTS) {
-          return;
-        }
-        nested++;
-      }
-      const name = attachment.filename || (prefix ? "unnamed attachment" : "");
-      all.push(prefix ? { ...attachment, filename: `${prefix}/${name}` } : attachment);
-      const { content } = attachment;
-      const attached = attachment.contentType === "message/rfc822" || /\.eml$/i.test(attachment.filename || "");
-      if (attached && depth < MAX_NESTED_DEPTH && Buffer9.isBuffer(content) && content.length <= budget) {
-        budget -= content.length;
-        let inner;
-        try {
-          inner = await parseWithin(content, parse);
-        } catch (error) {
-          errors.push(`${name || "attached message"}: ${error.message}`);
-          continue;
-        }
-        if (inner.error) {
-          errors.push(inner.error);
-        }
-        await visit(inner.mail.attachments, prefix ? `${prefix}/${name}` : name || "attached message", depth + 1);
-      }
-    }
-  };
-  await visit(attachments, "", 0);
-  return all;
-}
-
 // src/sources.js
 import { Buffer as Buffer10 } from "node:buffer";
 import { createReadStream } from "node:fs";
@@ -6949,16 +7385,16 @@ function featuresFromText(row, options = {}) {
 async function* readExamples(sources, options = {}) {
   const { onProgress, limit = Infinity } = options;
   const seen = /* @__PURE__ */ new Set();
-  let count = 0;
+  let count2 = 0;
   const emit = (label, features, content) => {
     const id = createHash3("sha1").update(content).digest("hex");
     if (seen.has(id)) {
       return null;
     }
     seen.add(id);
-    count++;
-    if (onProgress && count % 1e3 === 0) {
-      onProgress(count);
+    count2++;
+    if (onProgress && count2 % 1e3 === 0) {
+      onProgress(count2);
     }
     return { label, features, id };
   };
@@ -7314,17 +7750,22 @@ function zipEntries(buffer, limit = 2e3) {
       records.push(i);
     }
   }
-  const entries = [];
-  const read = /* @__PURE__ */ new Set();
+  const state = {
+    entries: [],
+    limit,
+    read: /* @__PURE__ */ new Set(),
+    names: MAX_NAME_BYTES
+  };
   for (const eocd of records) {
     const offset = directoryOf(buffer, eocd);
-    if (offset !== -1 && !read.has(offset)) {
-      read.add(offset);
-      readDirectory(buffer, offset, limit - entries.length, entries);
+    if (offset !== -1) {
+      readDirectory(buffer, offset, state);
     }
   }
-  return entries;
+  return state.entries;
 }
+var MAX_NAME_LENGTH = 1024;
+var MAX_NAME_BYTES = 1024 * 1024;
 var DIRECTORY = 33639248;
 var isDirectory = (buffer, offset) => offset >= 0 && offset + 46 <= buffer.length && buffer.readUInt32LE(offset) === DIRECTORY;
 function directoryOf(buffer, eocd) {
@@ -7351,18 +7792,32 @@ function directoryOf(buffer, eocd) {
   }
   return -1;
 }
-function readDirectory(buffer, offset, count, entries) {
-  for (let n = 0; n < count && isDirectory(buffer, offset); n++) {
+function readDirectory(buffer, offset, state) {
+  while (state.entries.length < state.limit && isDirectory(buffer, offset) && !state.read.has(offset)) {
+    state.read.add(offset);
     const flags = buffer.readUInt16LE(offset + 8);
     const size = buffer.readUInt32LE(offset + 24);
     const nameLength = buffer.readUInt16LE(offset + 28);
     const extraLength = buffer.readUInt16LE(offset + 30);
     const commentLength = buffer.readUInt16LE(offset + 32);
-    const name = buffer.subarray(offset + 46, offset + 46 + nameLength).toString(flags & 2048 ? "utf8" : "latin1");
-    entries.push({ name, encrypted: (flags & 1) === 1, size });
+    const encoding = flags & 2048 ? "utf8" : "latin1";
+    const start = offset + 46;
+    const end = Math.min(buffer.length, start + nameLength);
+    const kept = Math.min(end - start, MAX_NAME_LENGTH);
+    state.names -= kept;
+    if (state.names < 0) {
+      return;
+    }
+    const half = MAX_NAME_LENGTH / 2;
+    const name = end - start > MAX_NAME_LENGTH ? `${buffer.toString(encoding, start, start + half)}\u2026${buffer.toString(encoding, end - half, end)}` : buffer.toString(encoding, start, end);
+    state.entries.push({ name, encrypted: (flags & 1) === 1, size });
     offset += 46 + nameLength + extraLength + commentLength;
   }
 }
+function shorten(name, max = 100) {
+  const characters = [...name];
+  return characters.length <= max ? name : `${characters.slice(0, max - 41).join("")}\u2026${characters.slice(-40).join("")}`;
+}
 function extensionOf(name) {
   const base = trimEndOf(String(name).toLowerCase().split(/[/\\]/).pop(), ". ");
   const dot = base.lastIndexOf(".");
@@ -7425,7 +7880,7 @@ function inspectAttachments(attachments = []) {
       }
       const inner = entries.filter((entry) => EXECUTABLE_EXTENSIONS.has(extensionOf(entry.name)) && !(office && OFFICE_EMBEDDED.has(extensionOf(entry.name))));
       const details = { extension: extensionOf(inner[0]?.name ?? ""), extensions: [...new Set(inner.map((entry) => extensionOf(entry.name)))] };
-      const listed = inner.slice(0, 3).map((entry) => entry.name.split("/").pop()).join(", ");
+      const listed = inner.slice(0, 3).map((entry) => shorten(entry.name.split("/").pop())).join(", ");
       if (inner.some((entry) => !SCRIPT_EXTENSIONS.has(extensionOf(entry.name)))) {
         add("executable_in_archive", `Archive "${name}" contains ${inner.length === 1 ? "a program" : `${inner.length} programs`} (${listed})`, details);
       } else if (inner.length > 0) {
@@ -7482,7 +7937,7 @@ function exchange(address2, write, timeout) {
         resolve(value);
       }
     };
-    const timer = setTimeout(() => finish(new Error(`clamd did not answer within ${timeout} ms`)), timeout);
+    const timer = setTimeout(() => finish(Object.assign(new Error(`clamd did not answer within ${timeout} ms`), { code: "ETIMEDOUT", timedOut: true })), timeout);
     socket.on("connect", () => write(socket));
     socket.on("data", (chunk2) => chunks.push(chunk2));
     socket.on("end", () => finish(null, Buffer12.concat(chunks).toString("utf8").replaceAll("\0", "").trim()));
@@ -7613,7 +8068,7 @@ var NEXT_WORD = /[^\S\n]{1,8}([\p{L}\p{N}]+)/uy;
 var MAX_AFTER = 8;
 function namesPlace(name, end) {
   NEXT_WORD.lastIndex = end;
-  for (let count = 0; count < MAX_AFTER; count++) {
+  for (let count2 = 0; count2 < MAX_AFTER; count2++) {
     const word = NEXT_WORD.exec(name);
     if (word === null || word[1].toLowerCase() === "apple") {
       return false;
@@ -8496,6 +8951,7 @@ var SpamScanner = class {
     const settings = config.clamav === true ? {} : config.clamav;
     const budget = settings.timeout ?? CLAMAV_TIMEOUT;
     const deadline = Date.now() + budget;
+    let expired = false;
     const viruses = [];
     const errors = [];
     const skipped = [];
@@ -8515,7 +8971,7 @@ var SpamScanner = class {
       while (queue.length > 0) {
         const attachment = queue.shift();
         const filename = attachment.filename || "unnamed attachment";
-        if (deadline <= Date.now()) {
+        if (expired || deadline <= Date.now()) {
           errors.push({ filename, error: `not scanned within ${budget} ms` });
           continue;
         }
@@ -8535,6 +8991,7 @@ var SpamScanner = class {
           }
         } catch (error) {
           debug2("virus scan failed: %s", error.message);
+          expired ||= Boolean(error.timedOut);
           if (CLAMAV_LIMITS.test(error.message)) {
             skipped.push({ filename, reason: error.message.replace(/^clamd: (?:stream: )?/, "") });
           } else {
@@ -8823,6 +9280,8 @@ Scanning:
   --no-classifier      Do not use the classifier
   --config <file>      JSON file with scanner settings (see the API docs)
   --allow-language <codes>  Accepted languages, e.g. en,de,fr
+  --max-size <bytes>   Largest message read, by every command and server
+                       (default ${MAX_MESSAGE_SIZE}, 25 MiB)
 
 SMTP session (improves accuracy):
   --ip <address>       IP address of the client that sent the message
@@ -8869,6 +9328,8 @@ Filter (Postfix pipe):
 
 Servers:
   --port <n>  --host <ip>  --socket <path>
+  --max-connections <n>  Connections open at once (default ${MAX_CONNECTIONS}; HTTP: also
+                       requests at once, more get 503)
   --reject             Milter: refuse mail at the reject threshold
   --reject-code <n>    Milter: a 4xx or 5xx code, 451 (try later; default) or 550
   --name <hostname>    Milter: this server's name in Authentication-Results
@@ -8905,6 +9366,8 @@ var OPTIONS = {
   "no-classifier": { type: "boolean" },
   config: { type: "string" },
   "allow-language": { type: "string" },
+  "max-size": { type: "string" },
+  "max-connections": { type: "string" },
   ip: { type: "string" },
   "sender-ip": { type: "string" },
   hostname: { type: "string" },
@@ -8977,6 +9440,19 @@ function number(value, name) {
   }
   return parsed;
 }
+function count(value, name, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  const parsed = number(value, name);
+  if (!Number.isInteger(parsed) || parsed < 1) {
+    throw new TypeError(`${name} must be a whole number of at least 1, not "${value}"`);
+  }
+  return parsed;
+}
+function limits(values) {
+  return { maxSize: count(values["max-size"], "--max-size", MAX_MESSAGE_SIZE), maxConnections: count(values["max-connections"], "--max-connections", MAX_CONNECTIONS) };
+}
 function isSocketArgument(value) {
   return /[/:]|\.(?:sock|ctl)$/.test(value) && !statSync2(value, { throwIfNoEntry: false })?.isFile();
 }
@@ -9109,15 +9585,31 @@ function buildSession(values) {
   }
   return session;
 }
-async function readInput(file, stdin) {
-  if (!file || file === "-") {
-    const chunks = [];
-    for await (const chunk2 of stdin) {
-      chunks.push(Buffer14.from(chunk2));
+async function readMessage(stream, maxSize) {
+  const iterator = stream[Symbol.asyncIterator]();
+  const chunks = [];
+  let size = 0;
+  for (; ; ) {
+    const { value, done } = await iterator.next();
+    if (done) {
+      return { data: Buffer14.concat(chunks), complete: true, rest: iterator };
     }
-    return Buffer14.concat(chunks);
+    const chunk2 = Buffer14.from(value);
+    chunks.push(chunk2);
+    size += chunk2.length;
+    if (size > maxSize) {
+      return { data: Buffer14.concat(chunks), complete: false, rest: iterator };
+    }
+  }
+}
+async function readInput(file, stdin, maxSize) {
+  const stream = !file || file === "-" ? stdin : createReadStream2(file);
+  const { data, complete, rest } = await readMessage(stream, maxSize);
+  if (!complete) {
+    await rest.return();
+    throw new Error(`Message larger than ${maxSize} bytes (see --max-size)`);
   }
-  return readFileSync2(file);
+  return data;
 }
 function formatResult(result, verbose) {
   const lines2 = [`${result.isSpam ? "SPAM" : "HAM"}  score ${result.score.toFixed(1)} (spam at ${result.threshold.toFixed(1)}, reject at ${result.rejectThreshold.toFixed(1)})  action: ${result.action}${result.language ? `  language: ${result.language}` : ""}`];
@@ -9149,18 +9641,49 @@ function listen(server, values, defaultPort, io) {
     }
   });
 }
-function deliver(sendmail, args, message) {
+function deliver(sendmail, args, message, rest) {
   return new Promise((resolve, reject) => {
     const child = spawn(sendmail, args, { stdio: ["pipe", "ignore", "inherit"] });
+    let written = Promise.resolve(true);
     child.on("error", reject);
-    child.on("close", (code) => resolve(code ?? "a signal"));
+    child.on("close", async (code) => {
+      resolve(await written ? code ?? "a signal" : "a signal");
+    });
     child.stdin.on("error", () => {
     });
-    child.stdin.end(message);
+    if (!rest) {
+      child.stdin.end(message);
+      return;
+    }
+    written = (async () => {
+      try {
+        for await (const chunk2 of prepend(message, rest)) {
+          await new Promise((resolve2, reject2) => {
+            child.stdin.write(chunk2, (error) => {
+              if (error) {
+                reject2(error);
+              } else {
+                resolve2();
+              }
+            });
+          });
+        }
+        child.stdin.end();
+        return true;
+      } catch {
+        child.kill("SIGKILL");
+        child.stdin.destroy();
+        return false;
+      }
+    })();
   });
 }
-async function deliverOrDefer(sendmail, args, message, stderr) {
-  const code = await deliver(sendmail, args, message);
+async function* prepend(first, rest) {
+  yield first;
+  yield* rest;
+}
+async function deliverOrDefer({ sendmail, args, message, rest }, stderr) {
+  const code = await deliver(sendmail, args, message, rest);
   if (code !== 0) {
     stderr.write(`filter: sendmail exited with ${code}, deferring
 `);
@@ -9189,7 +9712,7 @@ function waitForClose(server) {
 }
 var HANDLERS = {
   async scan({ positionals, values, config, session, stdin, stdout, out }) {
-    const raw = await readInput(positionals[0], stdin);
+    const raw = await readInput(positionals[0], stdin, limits(values).maxSize);
     const scanner = new SpamScanner(config);
     const result = await scanner.scan(raw, { session });
     const tag = values["subject-tag"] ?? (values["prepend-subject"] ? "[SPAM]" : null);
@@ -9204,13 +9727,30 @@ var HANDLERS = {
   },
   // Postfix: argv=spamscanner filter -f ${sender} -- ${recipient}
   async filter({ positionals: recipients, values, config, session, stdin, stderr }) {
-    const raw = await readInput("-", stdin);
+    const { maxSize } = limits(values);
+    const { data: raw, complete, rest } = await readMessage(stdin, maxSize);
     if (recipients.length === 0) {
       stderr.write("filter: no recipients given (use: spamscanner filter -f sender -- recipient...)\n");
       return 64;
     }
     const accept = onError(values) === "accept";
     const sendmail = ["-G", "-i", "-f", values.from ?? values.sender ?? "", "--", ...recipients];
+    if (!complete) {
+      const unscanned = `filter: message larger than ${maxSize} bytes (see --max-size)`;
+      if (!accept || !/^\r?\n|\r?\n\r?\n/.test(raw.toString("latin1"))) {
+        stderr.write(`${unscanned}, deferring
+`);
+        return 75;
+      }
+      stderr.write(`${unscanned}, passing it on unscanned
+`);
+      return deliverOrDefer({
+        sendmail: values.sendmail,
+        args: sendmail,
+        message: rewriteMessage(raw, [["X-Spam-Virus-Scan", "failed"]]),
+        rest
+      }, stderr);
+    }
     let message;
     let result;
     try {
@@ -9233,7 +9773,7 @@ var HANDLERS = {
       return 75;
     }
     if (result === null) {
-      return deliverOrDefer(values.sendmail, sendmail, message, stderr);
+      return deliverOrDefer({ sendmail: values.sendmail, args: sendmail, message }, stderr);
     }
     if (result.action === "reject" && values.reject) {
       stderr.write(`5.7.1 Message rejected as spam (score ${result.score.toFixed(1)})
@@ -9243,11 +9783,12 @@ var HANDLERS = {
     if (result.action === "reject" && values.discard) {
       return 0;
     }
-    return deliverOrDefer(values.sendmail, sendmail, message, stderr);
+    return deliverOrDefer({ sendmail: values.sendmail, args: sendmail, message }, stderr);
   },
   async milter({ values, config, stderr, io }) {
     const scanner = new SpamScanner(config);
     const milter = new MilterServer(scanner, {
+      ...limits(values),
       reject: Boolean(values.reject),
       rejectCode: values["reject-code"] ? number(values["reject-code"], "--reject-code") : 451,
       quarantine: Boolean(values.quarantine),
@@ -9267,21 +9808,26 @@ var HANDLERS = {
   },
   async http({ values, config, env, stderr, io }) {
     warnWithoutClientIp("http", config, stderr);
-    const server = createHttpServer(new SpamScanner(config), { token: values.token || env.SPAMSCANNER_TOKEN || null, modelPath: values.out || null });
+    const server = createHttpServer(new SpamScanner(config), { ...limits(values), token: values.token || env.SPAMSCANNER_TOKEN || null, modelPath: values.out || null });
     await listen(server, values, 7832, { stderr });
     io.onListening?.(server);
     return waitForClose(server);
   },
   async server({ values, config, stderr, io }) {
     warnWithoutClientIp("server", config, stderr);
-    const server = createTcpServer(new SpamScanner(config), { json: !values.verbose });
+    const server = createTcpServer(new SpamScanner(config), { ...limits(values), json: !values.verbose });
     await listen(server, values, 7830, { stderr });
     io.onListening?.(server);
     return waitForClose(server);
   },
   async spamd({ values, config, stderr, io }) {
     warnWithoutClientIp("spamd", config, stderr);
-    const server = createSpamdServer(new SpamScanner(config), { allowTell: Boolean(values["allow-tell"]), modelPath: values.out || null, subjectTag: values["subject-tag"] ?? null });
+    const server = createSpamdServer(new SpamScanner(config), {
+      ...limits(values),
+      allowTell: Boolean(values["allow-tell"]),
+      modelPath: values.out || null,
+      subjectTag: values["subject-tag"] ?? null
+    });
     await listen(server, values, 783, { stderr });
     io.onListening?.(server);
     return waitForClose(server);
@@ -9295,7 +9841,7 @@ var HANDLERS = {
     const base = values.merge ? values.model ? loadModel(values.model) : loadDefaultModel() : new Classifier();
     const { classifier, spam, ham } = await train({ spam: values.spam, ham: values.ham, datasets }, {
       classifier: base,
-      onProgress: (count) => stderr.write(`\r${count} messages`)
+      onProgress: (count2) => stderr.write(`\r${count2} messages`)
     });
     const file = values.out || "spamscanner-model.json";
     saveModel(classifier, file, {
@@ -9337,7 +9883,7 @@ var HANDLERS = {
       return 2;
     }
     const base = [values.model, values.out].find((candidate) => candidate && existsSync3(candidate));
-    const raw = await readInput(source, stdin);
+    const raw = await readInput(source, stdin, limits(values).maxSize);
     const scanner = new SpamScanner({ ...config, classifier: base });
     await scanner.learn(raw, category);
     scanner.saveModel(file);
@@ -9386,6 +9932,28 @@ var HANDLERS = {
     return 0;
   }
 };
+var consoleTargets = [];
+var consoleMethods;
+async function withConsoleTo(stderr, run) {
+  if (consoleTargets.length === 0) {
+    consoleMethods = { log: console.log, info: console.info };
+    const write = (...args) => {
+      consoleTargets.at(-1).write(`${format(...args)}
+`);
+    };
+    console.log = write;
+    console.info = write;
+  }
+  consoleTargets.push(stderr);
+  try {
+    return await run();
+  } finally {
+    consoleTargets.splice(consoleTargets.lastIndexOf(stderr), 1);
+    if (consoleTargets.length === 0) {
+      Object.assign(console, consoleMethods);
+    }
+  }
+}
 async function main(argv = process3.argv.slice(2), io = {}) {
   const stdin = io.stdin || process3.stdin;
   const stdout = io.stdout || process3.stdout;
@@ -9413,7 +9981,7 @@ Run "spamscanner help" for usage.
     return command || values.help ? 0 : 2;
   }
   try {
-    return await HANDLERS[command]({
+    return await withConsoleTo(stderr, () => HANDLERS[command]({
       positionals,
       values,
       config: buildConfig(values, env),
@@ -9424,7 +9992,7 @@ Run "spamscanner help" for usage.
       env,
       out,
       io
-    });
+    }));
   } catch (error) {
     stderr.write(`spamscanner: ${error.message}
 `);