best-email-builder 0.3.0 → 0.5.0

package/dist/server.js

@@ -5,38 +5,54 @@ import {
   sampleValues,
   unknownVariables,
   usedVariables
-} from "./chunk-BVOVAEEJ.js";
+} from "./chunk-LYMJ2TBX.js";
 import {
-  IMAGE_ATTRIBUTES,
-  LINK_ATTRIBUTES,
-  decodeEntities,
-  isSafeUrl
-} from "./chunk-57CTQNTK.js";
+  BRAND_IMPORT_ERRORS,
+  brandFromCss,
+  imageSize,
+  logoWidthFor,
+  readPage
+} from "./chunk-ECHGJZ2W.js";
+import {
+  simulateDarkMode
+} from "./chunk-UFKCLU2D.js";
 import {
   ASSET_KEY_PATTERN,
-  DEFAULT_ASSETS_PATH,
-  DEFAULT_VARIABLES,
   EMAIL_BUILDER_VERSION,
   EMAIL_DOCUMENT_SCHEMA_VERSION,
   EmailDocumentError,
-  LOCALES,
   MAX_IMAGE_BYTES,
+  createDocument,
+  detectImage,
+  readDocument,
+  serializeDocument
+} from "./chunk-7U6BAKM7.js";
+import {
+  IMAGE_ATTRIBUTES,
+  LINK_ATTRIBUTES,
+  assertValidMjml,
+  isSafeUrl,
+  validateMjml
+} from "./chunk-5SASKCUC.js";
+import {
+  DEFAULT_ASSETS_PATH,
+  DEFAULT_VARIABLES,
+  LOCALES,
   absoluteAssetUrls,
+  applyBrand,
   applyServiceLinks,
-  createDocument,
+  cleanBrand,
   createTranslator,
   defineVariables,
-  detectImage,
   identity,
   isAssetPath,
   keyFromLabel,
   mergeVariables,
-  readDocument,
-  serializeDocument,
+  messagesOf,
   tokenOf,
   translatorFor,
   validateCustomVariable
-} from "./chunk-3M36VVXS.js";
+} from "./chunk-DFNHICTF.js";
 
 // src/server/assets.js
 import { createHash } from "crypto";
@@ -130,198 +146,6 @@ function createMemoryAssetRepository() {
   };
 }
 
-// src/validation/mjmlValidator.js
-var MJML_MAX_LENGTH = 512 * 1024;
-var MJML_TAGS = /* @__PURE__ */ new Set([
-  "mjml",
-  "mj-head",
-  "mj-body",
-  "mj-attributes",
-  "mj-all",
-  "mj-class",
-  "mj-preview",
-  "mj-title",
-  "mj-breakpoint",
-  "mj-wrapper",
-  "mj-section",
-  "mj-group",
-  "mj-column",
-  "mj-text",
-  "mj-image",
-  "mj-button",
-  "mj-divider",
-  "mj-spacer",
-  "mj-table",
-  "mj-social",
-  "mj-social-element",
-  "mj-navbar",
-  "mj-navbar-link",
-  "mj-hero"
-]);
-var INLINE_TAGS = /* @__PURE__ */ new Set([
-  "a",
-  "b",
-  "strong",
-  "i",
-  "em",
-  "u",
-  "s",
-  "strike",
-  "del",
-  "br",
-  "span",
-  "p",
-  "div",
-  "font",
-  "sup",
-  "sub",
-  "small",
-  "big",
-  "ul",
-  "ol",
-  "li",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6",
-  "blockquote",
-  "code",
-  "pre",
-  "hr",
-  "img",
-  "table",
-  "tbody",
-  "thead",
-  "tr",
-  "td",
-  "th"
-]);
-var FORBIDDEN_TAGS = /* @__PURE__ */ new Map([
-  ["mj-include", "mj-include would read a file from the server"],
-  ["mj-raw", "mj-raw (free HTML) is not allowed"],
-  ["mj-style", "mj-style (free CSS) is outside the builder"],
-  ["mj-font", "mj-font (external font) is outside the builder"],
-  ["script", "script not allowed"],
-  ["iframe", "iframe not allowed"],
-  ["frame", "frame not allowed"],
-  ["object", "object not allowed"],
-  ["embed", "embed not allowed"],
-  ["form", "form not allowed"],
-  ["input", "form field not allowed"],
-  ["button", "HTML button not allowed (use the Button block)"],
-  ["textarea", "form field not allowed"],
-  ["select", "form field not allowed"],
-  ["style", "style sheet not allowed"],
-  ["link", "external resource not allowed"],
-  ["meta", "meta tag not allowed"],
-  ["base", "base tag not allowed"],
-  ["svg", "SVG not allowed"],
-  ["math", "MathML not allowed"]
-]);
-var TAG_RE = /<\s*(\/?)\s*([a-zA-Z][\w:-]*)([^>]*)>/g;
-var ATTR_RE = /([^\s=/>"']+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/g;
-function* attributesOf(source) {
-  ATTR_RE.lastIndex = 0;
-  let match;
-  while (match = ATTR_RE.exec(source)) {
-    const value = match[2] ?? match[3] ?? match[4] ?? "";
-    yield { name: match[1].toLowerCase(), value };
-  }
-}
-function styleIsSafe(style) {
-  const css = decodeEntities(style).toLowerCase().replace(/\s+/g, "");
-  if (css.includes("expression(") || css.includes("javascript:") || css.includes("behavior:")) return false;
-  const urls = css.match(/url\(([^)]*)\)/g) || [];
-  return urls.every((u) => isSafeUrl(u.slice(4, -1).replace(/^['"]|['"]$/g, ""), "image"));
-}
-function validateMjml(mjml, { t = identity } = {}) {
-  const issues = [];
-  const source = typeof mjml === "string" ? mjml : "";
-  if (!source.trim()) {
-    return { ok: false, issues: [{ code: "EMPTY", message: t("Empty MJML") }] };
-  }
-  if (source.length > MJML_MAX_LENGTH) {
-    issues.push({
-      code: "TOO_LARGE",
-      message: t("MJML too large ({size} KB, maximum {max} KB)", {
-        size: Math.round(source.length / 1024),
-        max: MJML_MAX_LENGTH / 1024
-      })
-    });
-  }
-  const withoutComments = source.replace(/<!--([\s\S]*?)-->/g, (whole, body) => {
-    if (/\[if\s/i.test(body)) {
-      issues.push({ code: "CONDITIONAL_COMMENT", message: t("conditional comment not allowed") });
-    }
-    return "";
-  });
-  if (/<!\[CDATA\[/i.test(withoutComments)) {
-    issues.push({ code: "CDATA", message: t("CDATA section not allowed") });
-  }
-  const trimmed = withoutComments.trim();
-  if (!/^<mjml[\s>]/i.test(trimmed)) {
-    issues.push({ code: "ROOT", message: t("the document must start with <mjml>") });
-  }
-  if (!/<mj-body[\s>]/i.test(trimmed)) {
-    issues.push({ code: "BODY", message: t("missing <mj-body>") });
-  }
-  TAG_RE.lastIndex = 0;
-  let match;
-  while (match = TAG_RE.exec(withoutComments)) {
-    const closing = match[1] === "/";
-    const tag = match[2].toLowerCase();
-    if (FORBIDDEN_TAGS.has(tag)) {
-      const template = FORBIDDEN_TAGS.get(tag);
-      issues.push({ code: "FORBIDDEN_TAG", message: template ? t(template) : tag, tag });
-      continue;
-    }
-    if (!MJML_TAGS.has(tag) && !INLINE_TAGS.has(tag)) {
-      issues.push({ code: "UNKNOWN_TAG", message: t("tag not allowed: <{tag}>", { tag }), tag });
-      continue;
-    }
-    if (closing) continue;
-    for (const { name, value } of attributesOf(match[3])) {
-      if (name.startsWith("on")) {
-        issues.push({
-          code: "EVENT_ATTRIBUTE",
-          message: t("attribute {name} not allowed", { name }),
-          tag,
-          attribute: name
-        });
-      } else if (LINK_ATTRIBUTES.has(name) && !isSafeUrl(value, "link")) {
-        issues.push({ code: "UNSAFE_URL", message: t("URL rejected ({name})", { name }), tag, attribute: name });
-      } else if (IMAGE_ATTRIBUTES.has(name) && !isSafeUrl(value, "image")) {
-        issues.push({
-          code: "UNSAFE_IMAGE",
-          message: t("image rejected ({name}): https only", { name }),
-          tag,
-          attribute: name
-        });
-      } else if (name === "style" && !styleIsSafe(value)) {
-        issues.push({ code: "UNSAFE_STYLE", message: t("inline style rejected"), tag, attribute: name });
-      }
-    }
-  }
-  return { ok: issues.length === 0, issues };
-}
-function assertValidMjml(mjml, { t = identity } = {}) {
-  const { ok, issues } = validateMjml(mjml, { t });
-  if (ok) return;
-  const shown = issues.slice(0, 3).map((i) => i.message).join("; ");
-  const more = issues.length - 3;
-  const error = (
-    /** @type {Error & {status?: number, issues?: ValidationIssue[]}} */
-    new Error(
-      more > 0 ? t("Template rejected: {issues} (+{more})", { issues: shown, more }) : t("Template rejected: {issues}", { issues: shown })
-    )
-  );
-  error.status = 422;
-  error.issues = issues;
-  throw error;
-}
-
 // src/validation/quality.js
 var GMAIL_CLIP_BYTES = 102 * 1024;
 function count(source, pattern) {
@@ -361,13 +185,13 @@ function qualityReport({ mjml, html = "", subject = null }, { t = identity } = {
       message: t("Button without link ({count})", { count: noHref })
     });
   }
-  const http = count(source, /\shref="http:\/\//gi);
-  if (http) {
+  const http2 = count(source, /\shref="http:\/\//gi);
+  if (http2) {
     issues.push({
       code: "HTTP_LINK",
       level: "info",
-      count: http,
-      message: t("Insecure http link ({count})", { count: http })
+      count: http2,
+      message: t("Insecure http link ({count})", { count: http2 })
     });
   }
   if (subject !== null && !String(subject).trim()) {
@@ -410,6 +234,13 @@ function prepareMjml(mjml, { title = null, preheader = null, lang = "en" } = {})
 
 // src/server/compileMjml.js
 import mjml2html from "mjml";
+var CLIENT_METAS = '<meta name="x-apple-disable-message-reformatting"><meta name="format-detection" content="telephone=no, date=no, address=no, email=no, url=no">';
+function withClientMetas(html) {
+  if (!html || html.includes("x-apple-disable-message-reformatting")) return html;
+  const viewport = /<meta name="viewport"[^>]*>/i.exec(html);
+  if (viewport) return html.slice(0, viewport.index + viewport[0].length) + CLIENT_METAS + html.slice(viewport.index + viewport[0].length);
+  return html.replace(/<head>/i, (head) => head + CLIENT_METAS);
+}
 async function compileMjml(mjml) {
   const compile = (
     /** @type {any} */
@@ -424,7 +255,7 @@ async function compileMjml(mjml) {
     fonts: {}
   });
   return {
-    html: String(result?.html || ""),
+    html: withClientMetas(String(result?.html || "")),
     warnings: (result?.errors || []).map((e) => ({
       line: e.line,
       message: String(e.formattedMessage || e.message || e),
@@ -564,7 +395,7 @@ function validateProject(raw, { t = identity } = {}) {
     for (
       const [key, pattern] of
       /** @type {[string, RegExp][]} */
-      [["type", DANGEROUS_TYPES], ["tagName", DANGEROUS_TAGS]]
+      [["type", DANGEROUS_TYPES], ["tagName", DANGEROUS_TAGS], ["tag", DANGEROUS_TAGS]]
     ) {
       const value = node[key];
       if (typeof value === "string" && pattern.test(value)) {
@@ -929,9 +760,377 @@ function createMemoryVariableRepository() {
   };
 }
 
+// src/server/brand.js
+function createBrandService({ repository = null, t = identity }) {
+  return {
+    /** The brand, `{}` when none was set (or no repository). */
+    async get() {
+      return repository ? cleanBrand(await repository.get()) : {};
+    },
+    /** @param {unknown} input @param {{id?: string|number, name?: string}|null} [user] */
+    async save(input, user = null) {
+      if (!repository) throw new HttpError(501, t("The brand is not configured"), "NO_BRAND_STORE");
+      if (!input || typeof input !== "object") throw new HttpError(400, t("Invalid JSON"), "INVALID_JSON");
+      const brand = cleanBrand(input);
+      await repository.save({ ...brand, updatedBy: user ? String(user.name ?? user.id ?? "") || null : null });
+      return brand;
+    }
+  };
+}
+function createMemoryBrandRepository() {
+  let row = null;
+  return {
+    async get() {
+      return row ? { ...row } : null;
+    },
+    async save(brand) {
+      row = { ...brand, updatedAt: /* @__PURE__ */ new Date() };
+    }
+  };
+}
+
+// src/server/brandImport.js
+import dns from "dns";
+import http from "http";
+import https from "https";
+import net from "net";
+import zlib from "zlib";
+var BRAND_IMPORT_LIMITS = {
+  pageBytes: 1.5 * 1024 * 1024,
+  cssBytes: 400 * 1024,
+  logoBytes: MAX_IMAGE_BYTES,
+  stylesheets: 4,
+  logos: 5,
+  redirects: 4,
+  timeoutMs: 8e3
+};
+var USER_AGENT = "BestEmailBuilder-BrandReader/1.0 (+https://github.com/SergeMiro/best-email-builder)";
+var BrandImportError = class extends Error {
+  /** @param {BrandImportCode} code @param {string} [detail] */
+  constructor(code, detail = "") {
+    super(detail ? `${code}: ${detail}` : code);
+    this.name = "BrandImportError";
+    this.code = code;
+  }
+};
+var blocked = new net.BlockList();
+for (
+  const [network, prefix] of
+  /** @type {[string, number][]} */
+  [
+    ["0.0.0.0", 8],
+    // "this network"
+    ["10.0.0.0", 8],
+    // private
+    ["100.64.0.0", 10],
+    // carrier-grade NAT
+    ["127.0.0.0", 8],
+    // loopback
+    ["169.254.0.0", 16],
+    // link-local, cloud metadata
+    ["172.16.0.0", 12],
+    // private
+    ["192.0.0.0", 24],
+    // IETF protocol assignments
+    ["192.0.2.0", 24],
+    // documentation
+    ["192.88.99.0", 24],
+    // 6to4 relay
+    ["192.168.0.0", 16],
+    // private
+    ["198.18.0.0", 15],
+    // benchmarking
+    ["198.51.100.0", 24],
+    // documentation
+    ["203.0.113.0", 24],
+    // documentation
+    ["224.0.0.0", 4],
+    // multicast
+    ["240.0.0.0", 4]
+    // reserved, broadcast
+  ]
+) {
+  blocked.addSubnet(network, prefix, "ipv4");
+}
+for (
+  const [network, prefix] of
+  /** @type {[string, number][]} */
+  [
+    ["::", 128],
+    // unspecified
+    ["::1", 128],
+    // loopback
+    ["::", 96],
+    // IPv4-compatible (deprecated)
+    ["100::", 64],
+    // discard
+    ["2001::", 32],
+    // Teredo
+    ["2001:db8::", 32],
+    // documentation
+    ["fc00::", 7],
+    // unique local
+    ["fe80::", 10],
+    // link-local
+    ["fec0::", 10],
+    // site-local (deprecated)
+    ["ff00::", 8]
+    // multicast
+  ]
+) {
+  blocked.addSubnet(network, prefix, "ipv6");
+}
+function embeddedIpv4(address) {
+  const lower = address.toLowerCase();
+  const dotted = lower.match(/^(?:::ffff:(?:0:)?|64:ff9b::)(\d+\.\d+\.\d+\.\d+)$/);
+  if (dotted) return dotted[1];
+  const groups = expandIpv6(lower);
+  if (!groups) return "";
+  const toV4 = (hi, lo) => `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+  if (groups.slice(0, 5).every((g) => g === 0) && groups[5] === 65535) return toV4(groups[6], groups[7]);
+  if (groups[0] === 100 && groups[1] === 65435 && groups.slice(2, 6).every((g) => g === 0)) return toV4(groups[6], groups[7]);
+  if (groups[0] === 8194) return toV4(groups[1], groups[2]);
+  return "";
+}
+function expandIpv6(address) {
+  if (!net.isIPv6(address)) return null;
+  let text2 = address.replace(/%.*$/, "");
+  const v4 = text2.match(/(\d+\.\d+\.\d+\.\d+)$/);
+  if (v4) {
+    const [a, b, c, d] = v4[1].split(".").map(Number);
+    text2 = text2.replace(v4[1], `${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(16)}`);
+  }
+  const [left, right = ""] = text2.split("::");
+  const head = left ? left.split(":") : [];
+  const tail = text2.includes("::") && right ? right.split(":") : [];
+  const fill = text2.includes("::") ? Array(8 - head.length - tail.length).fill("0") : [];
+  const groups = [...head, ...fill, ...tail].map((g) => parseInt(g || "0", 16));
+  return groups.length === 8 ? groups : null;
+}
+function isPublicAddress(address) {
+  const ip = String(address ?? "").replace(/^\[|\]$/g, "");
+  const family = net.isIP(ip);
+  if (family === 4) return !blocked.check(ip, "ipv4");
+  if (family === 6) {
+    const v4 = embeddedIpv4(ip);
+    if (v4) return !blocked.check(v4, "ipv4");
+    return !blocked.check(ip.replace(/%.*$/, ""), "ipv6");
+  }
+  return false;
+}
+function guardedLookup(allow) {
+  const lookup = (hostname, options, callback) => {
+    if (typeof options === "function") {
+      callback = options;
+      options = {};
+    }
+    dns.lookup(hostname, { ...options, all: true }, (error, addresses) => {
+      if (error) return callback(error);
+      const list = (
+        /** @type {dns.LookupAddress[]} */
+        /** @type {unknown} */
+        addresses
+      );
+      if (!list.length || list.some((entry) => !allow(entry.address))) {
+        return callback(new BrandImportError("PRIVATE_ADDRESS", hostname));
+      }
+      if (options.all) return callback(null, list);
+      return callback(null, list[0].address, list[0].family);
+    });
+  };
+  return lookup;
+}
+var isWebPort = (port) => port === 80 || port === 443;
+function checkUrl(input, allow, allowPort = isWebPort) {
+  let url;
+  try {
+    url = new URL(String(input));
+  } catch {
+    throw new BrandImportError("BAD_URL");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") throw new BrandImportError("BAD_URL", url.protocol);
+  if (url.username || url.password) throw new BrandImportError("BAD_URL", "credentials");
+  if (url.port && !allowPort(Number(url.port))) throw new BrandImportError("BAD_URL", `port ${url.port}`);
+  const host = url.hostname.replace(/^\[|\]$/g, "");
+  if (!host) throw new BrandImportError("BAD_URL");
+  if (net.isIP(host) && !allow(host)) throw new BrandImportError("PRIVATE_ADDRESS", host);
+  return url;
+}
+function siteUrl(input) {
+  const text2 = String(input ?? "").trim();
+  if (!text2 || text2.length > 500 || /\s/.test(text2)) throw new BrandImportError("BAD_URL");
+  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(text2) ? text2 : `https://${text2}`;
+  let url;
+  try {
+    url = new URL(withScheme);
+  } catch {
+    throw new BrandImportError("BAD_URL");
+  }
+  if (!/^https?:$/.test(url.protocol) || !url.hostname.includes(".") && !net.isIP(url.hostname.replace(/^\[|\]$/g, ""))) {
+    throw new BrandImportError("BAD_URL");
+  }
+  return url.href;
+}
+async function safeGet(address, { allow, allowPort = isWebPort, signal, maxBytes, truncate = false, accept = "*/*", redirects = BRAND_IMPORT_LIMITS.redirects }) {
+  let url = checkUrl(address, allow, allowPort);
+  for (let hop = 0; ; hop += 1) {
+    const response = await requestOnce(url, { allow, signal, maxBytes, truncate, accept });
+    if (response.location === null) return { bytes: response.bytes, url: url.href, contentType: response.contentType };
+    if (hop >= redirects) throw new BrandImportError("TOO_MANY_REDIRECTS");
+    url = checkUrl(new URL(response.location, url), allow, allowPort);
+  }
+}
+function requestOnce(url, { allow, signal, maxBytes, truncate, accept }) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) return reject(abortReason(signal));
+    const client = url.protocol === "https:" ? https : http;
+    const request = client.request(url, {
+      method: "GET",
+      agent: false,
+      lookup: guardedLookup(allow),
+      signal,
+      headers: {
+        "User-Agent": USER_AGENT,
+        Accept: accept,
+        "Accept-Encoding": "gzip, deflate, br",
+        "Accept-Language": "en;q=0.9, *;q=0.5"
+      }
+    });
+    request.on("error", (error) => reject(toImportError(error, signal)));
+    request.on("response", (response) => {
+      const status = response.statusCode || 0;
+      if (status >= 300 && status < 400 && response.headers.location) {
+        response.resume();
+        request.destroy();
+        return resolve({ location: response.headers.location, bytes: Buffer.alloc(0), contentType: "" });
+      }
+      if (status < 200 || status >= 300) {
+        response.resume();
+        request.destroy();
+        return reject(new BrandImportError("HTTP_ERROR", String(status)));
+      }
+      const encoding = String(response.headers["content-encoding"] || "").toLowerCase().trim();
+      let body = response;
+      if (encoding === "gzip" || encoding === "x-gzip") body = response.pipe(zlib.createGunzip());
+      else if (encoding === "deflate") body = response.pipe(zlib.createInflate());
+      else if (encoding === "br") body = response.pipe(zlib.createBrotliDecompress());
+      const chunks = [];
+      let size = 0;
+      let done = false;
+      const finish = (error) => {
+        if (done) return;
+        done = true;
+        request.destroy();
+        if (error) reject(error);
+        else resolve({ location: null, bytes: Buffer.concat(chunks), contentType: String(response.headers["content-type"] || "") });
+      };
+      body.on("data", (chunk) => {
+        if (done) return;
+        if (size + chunk.length > maxBytes) {
+          if (!truncate) return finish(new BrandImportError("TOO_LARGE"));
+          chunks.push(chunk.subarray(0, maxBytes - size));
+          size = maxBytes;
+          return finish(null);
+        }
+        chunks.push(chunk);
+        size += chunk.length;
+      });
+      body.on("end", () => finish(null));
+      body.on("error", (error) => finish(toImportError(error, signal)));
+      response.on("error", (error) => finish(toImportError(error, signal)));
+      response.on("close", () => {
+        if (!response.complete) finish(toImportError(new Error("connection closed"), signal));
+      });
+    });
+    request.end();
+  });
+}
+var abortReason = (signal) => signal.reason?.name === "TimeoutError" ? new BrandImportError("TIMEOUT") : Object.assign(new Error("Aborted"), { name: "AbortError" });
+function toImportError(error, signal) {
+  if (error instanceof BrandImportError) return error;
+  if (error?.cause instanceof BrandImportError) return error.cause;
+  if (signal.aborted) return abortReason(signal);
+  return new BrandImportError("UNREACHABLE", error?.code || error?.message || "");
+}
+function textOf(bytes, contentType) {
+  const sniffed = bytes.subarray(0, 2048).toString("latin1").match(/<meta[^>]+charset\s*=\s*["']?([\w-]+)/i)?.[1];
+  const charset = contentType.match(/charset\s*=\s*["']?([\w-]+)/i)?.[1] || sniffed || "utf-8";
+  try {
+    return new TextDecoder(charset).decode(bytes);
+  } catch {
+    return new TextDecoder("utf-8").decode(bytes);
+  }
+}
+function createBrandImporter({
+  timeoutMs = BRAND_IMPORT_LIMITS.timeoutMs,
+  allowAddress = isPublicAddress,
+  allowPort = isWebPort
+} = {}) {
+  async function importBrand(input, { signal } = {}) {
+    const deadline = AbortSignal.timeout(timeoutMs);
+    const all = signal ? AbortSignal.any([signal, deadline]) : deadline;
+    const get = (address, options) => safeGet(address, { allow: allowAddress, allowPort, signal: all, ...options });
+    const page = await get(siteUrl(input), {
+      maxBytes: BRAND_IMPORT_LIMITS.pageBytes,
+      truncate: true,
+      accept: "text/html,application/xhtml+xml;q=0.9,*/*;q=0.5"
+    });
+    if (page.contentType && !/html|xml/i.test(page.contentType)) throw new BrandImportError("NOT_HTML", page.contentType);
+    const reading = readPage(textOf(page.bytes, page.contentType), page.url);
+    const notes = [];
+    const [sheets, logo] = await Promise.all([
+      Promise.all(
+        reading.stylesheets.slice(0, BRAND_IMPORT_LIMITS.stylesheets).map(
+          (href) => get(href, { maxBytes: BRAND_IMPORT_LIMITS.cssBytes, truncate: true, accept: "text/css,*/*;q=0.1" }).then((sheet) => textOf(sheet.bytes, sheet.contentType)).catch((error) => {
+            if (error?.name === "AbortError") throw error;
+            return "";
+          })
+        )
+      ),
+      (async () => {
+        let unsupported = false;
+        for (const candidate of reading.logos.slice(0, BRAND_IMPORT_LIMITS.logos)) {
+          if (/\.(svg|webp|ico)(\?|#|$)/i.test(new URL(candidate.url).pathname)) {
+            unsupported ||= candidate.from !== "icon";
+            continue;
+          }
+          let file;
+          try {
+            file = await get(candidate.url, { maxBytes: BRAND_IMPORT_LIMITS.logoBytes, accept: "image/png,image/jpeg,image/gif;q=0.9,*/*;q=0.1" });
+          } catch (error) {
+            if (
+              /** @type {any} */
+              error?.name === "AbortError"
+            ) throw error;
+            continue;
+          }
+          const bytes = new Uint8Array(file.bytes);
+          const type = detectImage(bytes);
+          const size = type && imageSize(bytes);
+          if (!type || !size) {
+            unsupported ||= candidate.from !== "icon" && /svg|webp/i.test(file.contentType);
+            continue;
+          }
+          if (size.width < 32 && size.height < 32) continue;
+          if (candidate.from === "icon") notes.push("LOGO_ICON");
+          return { bytes, ...size, ...type };
+        }
+        notes.push(unsupported ? "LOGO_UNSUPPORTED" : "LOGO_NOT_FOUND");
+        return null;
+      })()
+    ]);
+    const style = brandFromCss({ css: [reading.css, ...sheets].join("\n"), themeColor: reading.themeColor });
+    if (!style.primary) notes.push("COLORS_NOT_FOUND");
+    const brand = cleanBrand({ name: reading.name, website: page.url, ...style });
+    return { brand, logo: logo && { ...logo, shownWidth: logoWidthFor(logo) }, notes };
+  }
+  return { import: importBrand };
+}
+
 // src/server/handler.js
 var MAX_JSON_BYTES = 3 * 1024 * 1024;
 var HOUR = 60 * 60 * 1e3;
+var isGenerationError = (error) => error?.name === "EmailGenerationError" && Number.isInteger(error.status) && typeof error.code === "string";
 var json = (data, status = 200) => new Response(JSON.stringify(data), {
   status,
   headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" }
@@ -959,6 +1158,8 @@ function createEmailBuilderHandler(options) {
     basePath = "/api/email-builder",
     publicUrl = null,
     transport = null,
+    generator = null,
+    brandImporter = null,
     locale = "en",
     messages,
     lang = locale.slice(0, 2),
@@ -976,12 +1177,17 @@ function createEmailBuilderHandler(options) {
   const base = basePath.replace(/\/+$/, "");
   const assetsPath = (options.assetsPath || `${base}/assets/`).replace(/\/*$/, "/");
   const variables = defineVariables(options.variables || DEFAULT_VARIABLES);
-  const t = translatorFor(locale, messages);
+  const t = translatorFor(locale, { ...messagesOf(generator?.messages, locale), ...messages });
   const templates = createTemplateService({ repository: templateRepository, t, lang, maxVersions });
   const assets = createAssetService({ repository: assetRepository, publicPath: assetsPath, t });
   const customVariables = createVariableService({ repository: options.variableStore || null, system: variables, t });
+  const brand = createBrandService({ repository: options.brandStore || null, t });
   const testLimiter = createLimiter(rateLimits.testPerHour ?? 20);
   const uploadLimiter = createLimiter(rateLimits.uploadsPerHour ?? 100);
+  const generateLimiter = createLimiter(rateLimits.generatePerHour ?? 30);
+  const rewriteLimiter = createLimiter(rateLimits.rewritePerHour ?? 200);
+  const subjectsLimiter = createLimiter(rateLimits.subjectsPerHour ?? 100);
+  const brandImportLimiter = createLimiter(rateLimits.brandImportsPerHour ?? 20);
   async function userFor(request, action) {
     const user = await authorize(request, { action });
     if (!user) throw new HttpError(401, t("Authentication required"), "UNAUTHORIZED");
@@ -991,6 +1197,7 @@ function createEmailBuilderHandler(options) {
     );
   }
   const userKey = (user) => String(user.id ?? user.name ?? "anonymous");
+  const languageOr = (value) => typeof value === "string" && /^[a-z]{2,3}(-[a-z0-9]{2,8})*$/i.test(value) ? value : lang;
   async function readJson(request) {
     const length = Number(request.headers.get("content-length") || 0);
     if (length > MAX_JSON_BYTES) throw new HttpError(413, t("Request too large"), "TOO_LARGE");
@@ -1002,6 +1209,16 @@ function createEmailBuilderHandler(options) {
       throw new HttpError(400, t("Invalid JSON"), "INVALID_JSON");
     }
   }
+  async function askModel(request, call) {
+    try {
+      return json({ data: await call() });
+    } catch (error) {
+      if (request.signal?.aborted) return json({ error: t("Cancelled"), code: "CANCELLED" }, 499);
+      if (isGenerationError(error)) throw new HttpError(error.status, t(error.message), error.code);
+      onError(error, request);
+      throw new HttpError(502, t("The AI service did not answer \u2014 try again in a moment."), "MODEL_ERROR");
+    }
+  }
   async function serveAsset(key) {
     const asset = await assets.get(key);
     if (!asset) return new Response("Not found", { status: 404, headers: { "Content-Type": "text/plain" } });
@@ -1099,6 +1316,40 @@ function createEmailBuilderHandler(options) {
       });
       return json({ data: result });
     }
+    if (section === "generate" && !id && method === "POST") {
+      const user = await userFor(request, "write");
+      const generate = generator?.generate;
+      if (typeof generate !== "function") throw new HttpError(501, t("Email generation is not configured"), "NO_GENERATOR");
+      if (!generateLimiter(userKey(user))) {
+        throw new HttpError(429, t("Too many generated emails \u2014 try again later"), "RATE_LIMITED");
+      }
+      const body = await readJson(request);
+      const catalog = await customVariables.catalog();
+      return askModel(
+        request,
+        () => generate.call(generator, { ...body, language: languageOr(body?.language), variables: catalog }, { signal: request.signal })
+      );
+    }
+    if (section === "rewrite" && !id && method === "POST") {
+      const user = await userFor(request, "write");
+      const rewrite = generator?.rewrite;
+      if (typeof rewrite !== "function") throw new HttpError(501, t("Text rewriting is not configured"), "NO_GENERATOR");
+      if (!rewriteLimiter(userKey(user))) throw new HttpError(429, t("Too many rewrites \u2014 try again later"), "RATE_LIMITED");
+      const body = await readJson(request);
+      return askModel(request, () => rewrite(body, { signal: request.signal }));
+    }
+    if (section === "subjects" && !id && method === "POST") {
+      const user = await userFor(request, "write");
+      const suggestSubjects = generator?.suggestSubjects;
+      if (typeof suggestSubjects !== "function") throw new HttpError(501, t("Subject ideas are not configured"), "NO_GENERATOR");
+      if (!subjectsLimiter(userKey(user))) throw new HttpError(429, t("Too many subject ideas \u2014 try again later"), "RATE_LIMITED");
+      const body = await readJson(request);
+      const catalog = await customVariables.catalog();
+      return askModel(
+        request,
+        () => suggestSubjects({ ...body, language: languageOr(body?.language), variables: catalog }, { signal: request.signal })
+      );
+    }
     if (section === "assets" && !id && method === "POST") {
       const user = await userFor(request, "write");
       if (!uploadLimiter(userKey(user))) throw new HttpError(429, t("Too many uploads \u2014 try again later"), "RATE_LIMITED");
@@ -1136,15 +1387,53 @@ function createEmailBuilderHandler(options) {
         return json({ data: await customVariables.remove(id) });
       }
     }
+    if (section === "brand" && !sub) {
+      if (!id && method === "GET") {
+        await userFor(request, "read");
+        return json({ data: await brand.get() });
+      }
+      if (!id && method === "PUT") {
+        const user = await userFor(request, "write");
+        return json({ data: await brand.save(await readJson(request), user) });
+      }
+      if (id === "import" && method === "POST") {
+        const user = await userFor(request, "write");
+        if (!brandImporter) throw new HttpError(501, t("Reading a brand from a website is not configured"), "NO_BRAND_IMPORTER");
+        if (!brandImportLimiter(userKey(user))) {
+          throw new HttpError(429, t("Too many websites read \u2014 try again later"), "RATE_LIMITED");
+        }
+        const body = await readJson(request);
+        return json({ data: await importBrand(request, body?.url, user) });
+      }
+    }
     throw new HttpError(404, t("Route not found"), "ROUTE_NOT_FOUND");
   }
+  async function importBrand(request, address, user) {
+    let result;
+    try {
+      result = await /** @type {NonNullable<typeof brandImporter>} */
+      brandImporter.import(String(address ?? ""), { signal: request.signal });
+    } catch (error) {
+      if (request.signal?.aborted) throw new HttpError(499, t("Cancelled"), "CANCELLED");
+      if (!(error instanceof BrandImportError)) throw error;
+      const [status, message] = BRAND_IMPORT_ERRORS[error.code] || BRAND_IMPORT_ERRORS.UNREACHABLE;
+      throw new HttpError(status, t(message), `BRAND_${error.code}`);
+    }
+    const found = { ...result.brand };
+    if (result.logo) {
+      const { path } = await assets.upload({ bytes: result.logo.bytes, name: `logo.${result.logo.ext}`, user });
+      found.logoUrl = path;
+      found.logoWidth = result.logo.shownWidth;
+    }
+    return { brand: found, notes: result.notes };
+  }
   async function handle(request) {
     try {
       const response = await route(request);
       return response || json({ error: t("Route not found"), code: "ROUTE_NOT_FOUND" }, 404);
     } catch (error) {
       const status = statusOf(error);
-      if (status >= 500 && status !== 501) {
+      if (status >= 500 && !(error instanceof HttpError)) {
         onError(error, request);
         return json({ error: t("Internal error"), code: "INTERNAL" }, 500);
       }
@@ -1205,6 +1494,8 @@ function toNodeListener(handler, { origin } = {}) {
   };
 }
 export {
+  BRAND_IMPORT_LIMITS,
+  BrandImportError,
   DEFAULT_ASSETS_PATH,
   DEFAULT_VARIABLES,
   EMAIL_BUILDER_VERSION,
@@ -1217,17 +1508,22 @@ export {
   MAX_ACTIVE_VERSIONS,
   MAX_TEST_RECIPIENTS,
   absoluteAssetUrls,
+  applyBrand,
   applyServiceLinks,
   applyVariables,
   applyVariablesToText,
   assertValidMjml,
   assertValidProject,
+  cleanBrand,
   compileMjml,
   compileTemplate,
   createAssetService,
+  createBrandImporter,
+  createBrandService,
   createDocument,
   createEmailBuilderHandler,
   createMemoryAssetRepository,
+  createMemoryBrandRepository,
   createMemoryTemplateRepository,
   createMemoryVariableRepository,
   createTemplateService,
@@ -1237,9 +1533,11 @@ export {
   htmlToText,
   inspectAsset,
   isAssetPath,
+  isPublicAddress,
   keyFromLabel,
   mapVariables,
   mergeVariables,
+  messagesOf,
   personalize,
   prepareMjml,
   qualityReport,
@@ -1248,6 +1546,7 @@ export {
   sampleValues,
   sendTestEmail,
   serializeDocument,
+  simulateDarkMode,
   toNodeListener,
   tokenOf,
   translatorFor,