@suphark/notify 0.4.0 → 0.5.0

package/dist/chunk-FL5ZV3S2.js

@@ -0,0 +1,1290 @@
+// src/address.ts
+var NAMED_RE = /^\s*(?:"?([^"<]*?)"?\s*)?<([^<>\s]+@[^<>\s]+)>\s*$/;
+var EMAIL_RE = /^[^\s@<>]+@[^\s@<>]+\.[^\s@<>]+$/;
+function parseAddress(input) {
+  if (typeof input !== "string") {
+    const email2 = input.email.trim();
+    if (!EMAIL_RE.test(email2)) throw new TypeError(`Invalid email address: "${email2}"`);
+    return input.name?.trim() ? { name: input.name.trim(), email: email2 } : { email: email2 };
+  }
+  const named = NAMED_RE.exec(input);
+  if (named) {
+    const name = named[1]?.trim();
+    const email2 = named[2];
+    if (!EMAIL_RE.test(email2)) throw new TypeError(`Invalid email address: "${input}"`);
+    return name ? { name, email: email2 } : { email: email2 };
+  }
+  const email = input.trim();
+  if (!EMAIL_RE.test(email)) throw new TypeError(`Invalid email address: "${input}"`);
+  return { email };
+}
+function requireFrom(msg, provider) {
+  if (!msg.from) throw new TypeError(`${provider}: message has no "from" address`);
+  return msg.from;
+}
+function parseAddressList(input) {
+  if (input === void 0 || input === null) return [];
+  return (Array.isArray(input) ? input : [input]).map(parseAddress);
+}
+function formatAddress(a) {
+  if (!a.name) return a.email;
+  const name = /[",<>@()[\]:;\\]/.test(a.name) ? `"${a.name.replace(/"/g, '\\"')}"` : a.name;
+  return `${name} <${a.email}>`;
+}
+
+// src/providers/smtp.ts
+import nodemailer from "nodemailer";
+function createSmtpProvider(opts) {
+  const name = opts.name ?? "smtp";
+  const secure = opts.secure ?? (opts.port === void 0 ? true : opts.port === 465);
+  const port = opts.port ?? (secure ? 465 : 587);
+  const timeout = opts.timeoutMs ?? 15e3;
+  let transporter;
+  const getTransporter = () => {
+    const common = {
+      host: opts.host,
+      port,
+      secure,
+      auth: opts.user ? { user: opts.user, pass: opts.pass ?? "" } : void 0,
+      connectionTimeout: timeout,
+      greetingTimeout: timeout,
+      socketTimeout: timeout * 2,
+      tls: opts.rejectUnauthorized === false ? { rejectUnauthorized: false } : void 0
+    };
+    transporter ??= opts.pool ? nodemailer.createTransport({ ...common, pool: true }) : nodemailer.createTransport(common);
+    return transporter;
+  };
+  return {
+    name,
+    type: opts.type ?? "smtp",
+    from: opts.from,
+    async send(msg) {
+      const info = await getTransporter().sendMail({
+        from: formatAddress(requireFrom(msg, name)),
+        to: msg.to.map(formatAddress),
+        cc: msg.cc.map(formatAddress),
+        bcc: msg.bcc.map(formatAddress),
+        replyTo: msg.replyTo.map(formatAddress),
+        subject: msg.subject,
+        html: msg.html,
+        text: msg.text,
+        headers: msg.headers,
+        attachments: msg.attachments.map((a) => ({
+          filename: a.filename,
+          content: a.base64,
+          encoding: "base64",
+          contentType: a.contentType
+        }))
+      });
+      return { id: info.messageId };
+    },
+    async verify() {
+      await getTransporter().verify();
+    }
+  };
+}
+var SMTP_PRESETS = {
+  zoho: { host: "smtp.zoho.com", port: 465, secure: true },
+  /** Zoho Mail แบบองค์กร (custom domain) — บาง region ต้องใช้ smtppro.zoho.com */
+  zohopro: { host: "smtppro.zoho.com", port: 465, secure: true },
+  gmail: { host: "smtp.gmail.com", port: 465, secure: true },
+  office365: { host: "smtp.office365.com", port: 587, secure: false },
+  /** Brevo (Sendinblue) SMTP */
+  brevo: { host: "smtp-relay.brevo.com", port: 587, secure: false },
+  /** Mailtrap sandbox (ทดสอบ) */
+  mailtrap: { host: "sandbox.smtp.mailtrap.io", port: 2525, secure: false }
+};
+function createPresetSmtpProvider(preset, opts) {
+  const base = SMTP_PRESETS[preset];
+  return createSmtpProvider({
+    ...base,
+    ...opts,
+    host: opts.host ?? base.host,
+    port: opts.port ?? base.port,
+    secure: opts.secure ?? base.secure,
+    name: opts.name ?? preset,
+    type: preset
+  });
+}
+
+// src/env.ts
+var KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "hub",
+  "resend",
+  "smtp",
+  "zeptomail",
+  "console",
+  ...Object.keys(SMTP_PRESETS)
+]);
+var num = (v) => v === void 0 || v === "" ? void 0 : Number(v);
+var bool = (v) => v === void 0 || v === "" ? void 0 : /^(1|true|yes|on)$/i.test(v);
+function quotaFrom(get) {
+  const q = {};
+  const h = num(get("QUOTA_HOUR"));
+  const d = num(get("QUOTA_DAY"));
+  const m = num(get("QUOTA_MONTH"));
+  if (h !== void 0) q.perHour = h;
+  if (d !== void 0) q.perDay = d;
+  if (m !== void 0) q.perMonth = m;
+  return Object.keys(q).length ? q : void 0;
+}
+function providersFromEnv(env = process.env) {
+  const list = env.MAIL_PROVIDERS?.split(",").map((s) => s.trim()).filter(Boolean) ?? [];
+  const hub = env.PI_NOTIFY_KEY ? [{ type: "hub", apiKey: env.PI_NOTIFY_KEY, url: env.PI_NOTIFY_URL }] : [];
+  if (list.length === 0) {
+    const out = [...hub];
+    if (env.RESEND_API_KEY) out.push({ type: "resend", apiKey: env.RESEND_API_KEY });
+    if (env.SMTP_HOST)
+      out.push({
+        type: "smtp",
+        host: env.SMTP_HOST,
+        port: num(env.SMTP_PORT),
+        secure: bool(env.SMTP_SECURE),
+        user: env.SMTP_USER,
+        pass: env.SMTP_PASS
+      });
+    return out;
+  }
+  const listed = list.map((name) => {
+    const key = `MAIL_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_`;
+    const get = (k) => env[key + k];
+    const explicit = get("TYPE")?.toLowerCase();
+    const type = explicit ?? (KNOWN_TYPES.has(name.toLowerCase()) ? name.toLowerCase() : get("HOST") ? "smtp" : void 0);
+    if (!type)
+      throw new TypeError(
+        `Mail provider "${name}": set ${key}TYPE (resend | smtp | zoho | gmail | zeptomail | ...)`
+      );
+    const common = {
+      name,
+      from: get("FROM"),
+      senderDomains: get("SENDER_DOMAINS")?.split(",").map((d) => d.trim()).filter(Boolean),
+      quota: quotaFrom(get),
+      disabled: bool(get("DISABLED")) ?? false
+    };
+    const apiKey = get("API_KEY") ?? get("KEY") ?? get("TOKEN");
+    switch (type) {
+      case "hub": {
+        const hubKey = apiKey ?? env.PI_NOTIFY_KEY;
+        if (!hubKey)
+          throw new TypeError(
+            `Mail provider "${name}": PI_NOTIFY_KEY or ${key}API_KEY is required`
+          );
+        return { ...common, type, apiKey: hubKey, url: get("URL") ?? env.PI_NOTIFY_URL };
+      }
+      case "resend":
+        if (!apiKey) throw new TypeError(`Mail provider "${name}": ${key}API_KEY is required`);
+        return { ...common, type, apiKey, baseUrl: get("BASE_URL") };
+      case "zeptomail":
+        if (!apiKey) throw new TypeError(`Mail provider "${name}": ${key}API_KEY is required`);
+        return { ...common, type, apiKey, region: get("REGION"), baseUrl: get("BASE_URL") };
+      case "console":
+        return { ...common, type, body: bool(get("BODY")) };
+      case "smtp": {
+        const host = get("HOST");
+        if (!host) throw new TypeError(`Mail provider "${name}": ${key}HOST is required`);
+        return {
+          ...common,
+          type,
+          host,
+          port: num(get("PORT")),
+          secure: bool(get("SECURE")),
+          user: get("USER"),
+          pass: get("PASS") ?? get("PASSWORD"),
+          pool: bool(get("POOL")),
+          timeoutMs: num(get("TIMEOUT_MS")),
+          rejectUnauthorized: bool(get("REJECT_UNAUTHORIZED"))
+        };
+      }
+      default:
+        if (type in SMTP_PRESETS)
+          return {
+            ...common,
+            type,
+            host: get("HOST"),
+            port: num(get("PORT")),
+            secure: bool(get("SECURE")),
+            user: get("USER"),
+            pass: get("PASS") ?? get("PASSWORD"),
+            pool: bool(get("POOL")),
+            timeoutMs: num(get("TIMEOUT_MS"))
+          };
+        throw new TypeError(`Mail provider "${name}": unknown type "${type}"`);
+    }
+  });
+  return listed.some((p) => p.type === "hub") ? listed : [...hub, ...listed];
+}
+
+// src/errors.ts
+var MailError = class extends Error {
+  kind;
+  provider;
+  status;
+  /** เวลาที่ปลายทางขอให้รอก่อนลองใหม่ (วินาที จาก Retry-After) — mailer ใช้เป็นเวลาพักแทน backoff */
+  retryAfterSec;
+  constructor(message, opts = {}) {
+    super(message, opts.cause === void 0 ? void 0 : { cause: opts.cause });
+    this.name = "MailError";
+    this.kind = opts.kind ?? "unknown";
+    this.provider = opts.provider;
+    this.status = opts.status;
+    this.retryAfterSec = opts.retryAfterSec;
+  }
+};
+function retryAfterOf(res, body) {
+  if (res.status !== 429 && res.status !== 503) return void 0;
+  const fromHeader = Number(res.headers?.get?.("Retry-After")?.trim() ?? "");
+  if (Number.isFinite(fromHeader) && fromHeader > 0) return Math.ceil(fromHeader);
+  const fromBody = body?.error?.retryAfterSec;
+  return typeof fromBody === "number" && fromBody > 0 ? Math.ceil(fromBody) : void 0;
+}
+var AllProvidersFailedError = class extends MailError {
+  attempts;
+  constructor(attempts) {
+    const tried = attempts.filter((a) => !a.skipped);
+    const summary = attempts.length === 0 ? "no providers configured" : attempts.map(
+      (a) => a.skipped ? `${a.provider}: skipped (${a.skipped})` : `${a.provider}: ${a.error}`
+    ).join(" | ");
+    super(`All mail providers failed (${tried.length}/${attempts.length} tried): ${summary}`);
+    this.name = "AllProvidersFailedError";
+    this.attempts = attempts;
+  }
+};
+var QUOTA_RE = /quota|limit exceeded|exceeded.*(limit|quota)|daily.*limit|monthly.*limit|sending limit|too many messages/i;
+var RATE_RE = /rate.?limit|too many requests|throttl|slow down/i;
+var AUTH_RE = /authenticat|credential|password|invalid.*(key|token)|api key|unauthori[sz]ed|forbidden|not verified|verify.*domain|domain.*verif/i;
+var NET_CODE_RE = /^(ECONN|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|EPIPE|ESOCKET|EDNS|ECONNECTION)/i;
+var NET_RE = /ECONN|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|socket|timed? ?out|network|fetch failed/i;
+var INVALID_RE = /invalid.*(email|address|recipient)|no recipients|recipient.*(rejected|invalid)|malformed|missing.*(to|subject|from)/i;
+function classifyError(err) {
+  if (err instanceof MailError)
+    return {
+      kind: err.kind,
+      message: err.message,
+      status: err.status,
+      retryAfterSec: err.retryAfterSec
+    };
+  const e = typeof err === "object" && err !== null ? err : {};
+  const message = String(e.message ?? e.response ?? err ?? "unknown error");
+  const code = typeof e.code === "string" ? e.code : void 0;
+  const status = [e.responseCode, e.status, e.statusCode].find(
+    (v) => typeof v === "number"
+  );
+  const text = `${code ?? ""} ${message} ${typeof e.response === "string" ? e.response : ""}`;
+  if (code && NET_CODE_RE.test(code)) return { kind: "network", message, status };
+  if (status === 552 || QUOTA_RE.test(text)) return { kind: "quota", message, status };
+  if (status === 429 || RATE_RE.test(text)) return { kind: "rate_limit", message, status };
+  if (status === 401 || status === 403 || status === 534 || status === 535 || AUTH_RE.test(text))
+    return { kind: "auth", message, status };
+  if (INVALID_RE.test(text)) return { kind: "invalid", message, status };
+  if (status !== void 0) {
+    if ([400, 422, 550, 553, 554].includes(status)) return { kind: "invalid", message, status };
+    if (status >= 420 && status < 460) return { kind: "server", message, status };
+    if (status >= 500) return { kind: "server", message, status };
+  }
+  if (NET_RE.test(text)) return { kind: "network", message, status };
+  return { kind: "unknown", message, status };
+}
+
+// src/health.ts
+var DEFAULT_COOLDOWN = {
+  network: 60,
+  server: 60,
+  unknown: 60,
+  rate_limit: 120,
+  auth: 15 * 60,
+  quota: 60 * 60,
+  invalid: 0
+  // ความผิดของข้อความ ไม่พัก provider
+};
+var WINDOWS = [
+  { window: "hour", key: "perHour", ttlSec: 3600 },
+  { window: "day", key: "perDay", ttlSec: 86400 },
+  { window: "month", key: "perMonth", ttlSec: 32 * 86400 }
+];
+function windowId(window, now = /* @__PURE__ */ new Date()) {
+  const iso = now.toISOString();
+  if (window === "hour") return iso.slice(0, 13);
+  if (window === "day") return iso.slice(0, 10);
+  return iso.slice(0, 7);
+}
+var MAX_RETRY_AFTER_SEC = 60 * 60;
+var PROBE_INTERVAL_SEC = 30;
+var Health = class {
+  store;
+  cooldown;
+  maxCooldownSec;
+  /** ค่าที่แอปตั้งเอง (ไม่ตั้ง = undefined) — แยกจากค่าเริ่มต้นเพื่อไม่เปลี่ยนพฤติกรรมของแอปที่ไม่ได้ตั้ง */
+  userMaxCooldownSec;
+  emit;
+  constructor(opts) {
+    this.store = opts.store;
+    this.cooldown = { ...DEFAULT_COOLDOWN, ...opts.cooldown };
+    this.maxCooldownSec = opts.maxCooldownSec ?? 30 * 60;
+    this.userMaxCooldownSec = opts.maxCooldownSec;
+    this.emit = opts.onEvent ?? (() => {
+    });
+  }
+  /**
+   * เหตุผลที่ต้องข้าม provider นี้ตอนนี้ (null = ใช้ได้ และ **จองโควต้า** ไว้แล้ว 1 หน่วยทุก window)
+   * จองก่อนส่ง (incr แล้วดูค่าที่ได้) เพื่อให้คำขอพร้อมกันหลายตัวไม่ทะลุเพดาน — ส่งพังต้องเรียก release
+   */
+  async check(p, quota) {
+    const cd = await this.cooldownOf(p.name);
+    if (cd) return "cooldown";
+    return this.reserve(p, quota);
+  }
+  /** จองโควต้าอย่างเดียว (ไม่ดู cooldown) — ใช้ตอน half-open ที่ตั้งใจลองตัวที่ติด cooldown */
+  async reserve(p, quota) {
+    const reserved = [];
+    for (const w of WINDOWS) {
+      const limit = quota?.[w.key];
+      if (limit === void 0) continue;
+      const key = `q:${p.name}:${w.window}:${windowId(w.window)}`;
+      const used = await this.store.incr(key, w.ttlSec);
+      reserved.push(key);
+      if (used > limit) {
+        await this.releaseKeys(reserved);
+        return "quota";
+      }
+    }
+    return null;
+  }
+  /** คืนโควต้าที่ check() จองไว้ (เรียกเมื่อส่งไม่สำเร็จ) */
+  async release(p, quota) {
+    const keys = WINDOWS.filter((w) => quota?.[w.key] !== void 0).map(
+      (w) => `q:${p.name}:${w.window}:${windowId(w.window)}`
+    );
+    await this.releaseKeys(keys);
+  }
+  async releaseKeys(keys) {
+    if (!this.store.decr) return;
+    for (const key of keys) await this.store.decr(key);
+  }
+  async recordSuccess(p) {
+    const failures = await this.store.get(`fail:${p.name}`);
+    if (failures) {
+      await this.store.del(`fail:${p.name}`);
+      await this.store.del(`cd:${p.name}`);
+      this.emit({ type: "recovered", provider: p.name });
+    }
+  }
+  /**
+   * พักหลังพัง: ปลายทางบอก Retry-After มา = พักเท่านั้น (ไม่คูณสอง, ไม่เกิน 1 ชม.)
+   * ไม่บอก = backoff base, 2x, 4x, ... · แอปตั้ง maxCooldownSec เอง = เพดานของทั้งสองแบบ
+   */
+  async recordFailure(p, kind, retryAfterSec) {
+    const base = this.cooldown[kind];
+    if (!base) return;
+    const failures = await this.store.incr(`fail:${p.name}`, 86400);
+    let sec = retryAfterSec && retryAfterSec > 0 ? Math.min(retryAfterSec, MAX_RETRY_AFTER_SEC) : this.userMaxCooldownSec !== void 0 ? base * 2 ** Math.min(failures - 1, 10) : Math.min(base * 2 ** Math.min(failures - 1, 10), Math.max(base, this.maxCooldownSec));
+    if (this.userMaxCooldownSec !== void 0) sec = Math.min(sec, this.userMaxCooldownSec);
+    if (sec <= 0) return;
+    const until = Date.now() + sec * 1e3;
+    await this.store.set(
+      `cd:${p.name}`,
+      JSON.stringify({ until, kind }),
+      Math.ceil(sec)
+    );
+    this.emit({ type: "cooldown", provider: p.name, kind, untilMs: until, failures });
+  }
+  /** ล้าง cooldown/ตัวนับพัง (ไม่ล้างโควต้าที่ใช้ไปแล้ว) */
+  async reset(name) {
+    await this.store.del(`cd:${name}`);
+    await this.store.del(`fail:${name}`);
+  }
+  /**
+   * half-open: อนุญาตให้ลองตัวที่ติด cooldown ได้ 1 ครั้งต่อ PROBE_INTERVAL_SEC (แชร์ข้าม instance ถ้า store แชร์)
+   * true = ได้สิทธิ์ลองรอบนี้
+   */
+  async allowProbe(name) {
+    return await this.store.incr(`probe:${name}`, PROBE_INTERVAL_SEC) === 1;
+  }
+  async status(p, quota) {
+    const cd = await this.cooldownOf(p.name);
+    const usage = await this.usage(p, quota);
+    const failures = Number(await this.store.get(`fail:${p.name}`) ?? 0);
+    return {
+      name: p.name,
+      type: p.type,
+      available: !cd && usage.every((u) => u.used < u.limit),
+      cooldownUntil: cd?.until,
+      cooldownKind: cd?.kind,
+      failures,
+      quota: usage
+    };
+  }
+  /** cooldown ที่ยังไม่หมด (null = ใช้ได้) */
+  async cooldownOf(name) {
+    const raw = await this.store.get(`cd:${name}`);
+    if (!raw) return null;
+    try {
+      const cd = JSON.parse(raw);
+      return cd.until > Date.now() ? cd : null;
+    } catch {
+      return null;
+    }
+  }
+  async usage(p, quota) {
+    const out = [];
+    for (const w of WINDOWS) {
+      const limit = quota?.[w.key];
+      if (limit === void 0) continue;
+      const used = Number(
+        await this.store.get(`q:${p.name}:${w.window}:${windowId(w.window)}`) ?? 0
+      );
+      out.push({ window: w.window, used, limit });
+    }
+    return out;
+  }
+};
+
+// src/providers/console.ts
+function createConsoleProvider(opts = {}) {
+  const name = opts.name ?? "console";
+  const log = opts.log ?? ((l) => console.log(l));
+  let seq = 0;
+  return {
+    name,
+    type: "console",
+    from: opts.from,
+    async send(msg) {
+      const id = `console-${Date.now()}-${++seq}`;
+      const lines = [
+        `[mailer:${name}] ${id}`,
+        `  from:    ${msg.from ? formatAddress(msg.from) : "(hub default)"}`,
+        `  to:      ${msg.to.map(formatAddress).join(", ")}`,
+        ...msg.cc.length ? [`  cc:      ${msg.cc.map(formatAddress).join(", ")}`] : [],
+        ...msg.bcc.length ? [`  bcc:     ${msg.bcc.map(formatAddress).join(", ")}`] : [],
+        `  subject: ${msg.subject}`,
+        ...msg.attachments.length ? [`  files:   ${msg.attachments.map((a) => a.filename).join(", ")}`] : [],
+        ...opts.body ? [`  ---`, msg.text ?? msg.html ?? "(empty)"] : []
+      ];
+      log(lines.join("\n"));
+      return { id };
+    }
+  };
+}
+
+// src/providers/hub.ts
+var DEFAULT_HUB_URL = "https://notify.suphark.com";
+function createHubProvider(opts) {
+  const name = opts.name ?? "hub";
+  const url = `${(opts.url ?? DEFAULT_HUB_URL).replace(/\/$/, "")}/api/v1/send`;
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  return {
+    name,
+    type: "hub",
+    from: opts.from,
+    optionalFrom: true,
+    async send(msg) {
+      const body = {
+        from: msg.from,
+        to: msg.to,
+        cc: msg.cc.length ? msg.cc : void 0,
+        bcc: msg.bcc.length ? msg.bcc : void 0,
+        replyTo: msg.replyTo.length ? msg.replyTo : void 0,
+        subject: msg.subject,
+        html: msg.html,
+        text: msg.text,
+        attachments: msg.attachments.length ? msg.attachments : void 0,
+        headers: Object.keys(msg.headers).length ? msg.headers : void 0,
+        tags: Object.keys(msg.tags).length ? msg.tags : void 0,
+        prefer: msg.prefer
+      };
+      const res = await doFetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${opts.apiKey}`, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        // mailer หมดเวลา → abort คำขอนี้ทิ้ง (Pi Notify อาจส่งไปแล้ว — แอปที่มีตัวสำรองในเครื่องอาจได้เมลซ้ำ ยอมรับได้)
+        signal: msg.signal
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        const err = data.error;
+        const kind = err?.kind ?? (res.status === 401 || res.status === 403 ? "auth" : res.status === 429 ? "rate_limit" : res.status === 400 || res.status === 422 ? "invalid" : "server");
+        throw new MailError(`Pi Notify ${res.status}: ${err?.message ?? res.statusText}`, {
+          kind,
+          provider: name,
+          status: res.status,
+          cause: data,
+          retryAfterSec: retryAfterOf(res, data)
+        });
+      }
+      return { id: data.id };
+    },
+    async listProviders() {
+      const res = await doFetch(url.replace(/\/send$/, "/providers"), {
+        headers: { Authorization: `Bearer ${opts.apiKey}` }
+      });
+      if (!res.ok)
+        throw new MailError(`Pi Notify ${res.status}: ${res.statusText}`, {
+          kind: res.status === 401 ? "auth" : "server",
+          provider: name,
+          status: res.status
+        });
+      const data = await res.json();
+      return data.providers.map((p) => ({ ...p, via: name }));
+    },
+    async verify() {
+      const res = await doFetch(url.replace(/\/send$/, "/status"), {
+        headers: { Authorization: `Bearer ${opts.apiKey}` }
+      });
+      if (!res.ok) {
+        throw new MailError(`Pi Notify ${res.status}: ${res.statusText}`, {
+          kind: res.status === 401 ? "auth" : "server",
+          provider: name,
+          status: res.status
+        });
+      }
+    }
+  };
+}
+
+// src/providers/resend.ts
+function createResendProvider(opts) {
+  const name = opts.name ?? "resend";
+  const baseUrl = (opts.baseUrl ?? "https://api.resend.com").replace(/\/$/, "");
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  async function request(path, init) {
+    const res = await doFetch(`${baseUrl}${path}`, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${opts.apiKey}`,
+        "Content-Type": "application/json",
+        ...init.headers ?? {}
+      }
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      const msg = `Resend ${res.status} ${body?.name ?? ""}: ${body?.message ?? res.statusText}`;
+      const errName = String(body?.name ?? "");
+      const kind = /quota/i.test(errName) ? "quota" : /rate_limit/i.test(errName) || res.status === 429 ? "rate_limit" : res.status === 401 || res.status === 403 ? "auth" : res.status === 422 || errName === "validation_error" ? "invalid" : res.status >= 500 ? "server" : "unknown";
+      throw new MailError(msg, { kind, provider: name, status: res.status, cause: body });
+    }
+    return body;
+  }
+  return {
+    name,
+    type: "resend",
+    from: opts.from,
+    async send(msg) {
+      const body = {
+        from: formatAddress(requireFrom(msg, name)),
+        to: msg.to.map(formatAddress),
+        cc: msg.cc.length ? msg.cc.map(formatAddress) : void 0,
+        bcc: msg.bcc.length ? msg.bcc.map(formatAddress) : void 0,
+        reply_to: msg.replyTo.length ? msg.replyTo.map(formatAddress) : void 0,
+        subject: msg.subject,
+        html: msg.html,
+        text: msg.text,
+        headers: Object.keys(msg.headers).length ? msg.headers : void 0,
+        attachments: msg.attachments.length ? msg.attachments.map((a) => ({
+          filename: a.filename,
+          content: a.base64,
+          content_type: a.contentType
+        })) : void 0,
+        tags: Object.keys(msg.tags).length ? Object.entries(msg.tags).map(([k, v]) => ({ name: k, value: v })) : void 0
+      };
+      const data = await request("/emails", { method: "POST", body: JSON.stringify(body) });
+      return { id: data?.id };
+    },
+    async verify() {
+      const res = await doFetch(`${baseUrl}/emails/00000000-0000-4000-8000-000000000000`, {
+        headers: { Authorization: `Bearer ${opts.apiKey}` }
+      });
+      if (res.ok || res.status === 404) return;
+      const body = await res.json().catch(() => ({}));
+      throw new MailError(
+        `Resend ${res.status} ${body?.name ?? ""}: ${body?.message ?? res.statusText}`,
+        {
+          kind: res.status === 401 || res.status === 403 ? "auth" : "server",
+          provider: name,
+          status: res.status
+        }
+      );
+    }
+  };
+}
+
+// src/providers/zeptomail.ts
+var addr = (a) => ({ address: a.email, name: a.name });
+var recipient = (a) => ({ email_address: addr(a) });
+function createZeptoMailProvider(opts) {
+  const name = opts.name ?? "zeptomail";
+  const baseUrl = (opts.baseUrl ?? `https://api.zeptomail.${opts.region ?? "com"}`).replace(
+    /\/$/,
+    ""
+  );
+  const doFetch = opts.fetch ?? globalThis.fetch;
+  return {
+    name,
+    type: "zeptomail",
+    from: opts.from,
+    async send(msg) {
+      const body = {
+        from: addr(requireFrom(msg, name)),
+        to: msg.to.map(recipient),
+        cc: msg.cc.length ? msg.cc.map(recipient) : void 0,
+        bcc: msg.bcc.length ? msg.bcc.map(recipient) : void 0,
+        reply_to: msg.replyTo.length ? msg.replyTo.map(addr) : void 0,
+        subject: msg.subject,
+        htmlbody: msg.html,
+        textbody: msg.text,
+        attachments: msg.attachments.length ? msg.attachments.map((a) => ({
+          name: a.filename,
+          content: a.base64,
+          mime_type: a.contentType ?? "application/octet-stream"
+        })) : void 0
+      };
+      const res = await doFetch(`${baseUrl}/v1.1/email`, {
+        method: "POST",
+        headers: {
+          Authorization: `Zoho-enczapikey ${opts.apiKey}`,
+          "Content-Type": "application/json",
+          Accept: "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      const data = await res.json().catch(() => ({}));
+      if (!res.ok) {
+        const code = String(data?.error?.code ?? "");
+        const detail = data?.error?.details?.[0]?.message ?? data?.error?.message ?? res.statusText;
+        const msg2 = `ZeptoMail ${res.status} ${code}: ${detail}`;
+        const kind = /credit|quota|limit/i.test(detail) ? "quota" : res.status === 429 ? "rate_limit" : res.status === 401 || res.status === 403 || /TM_4001|token|key/i.test(`${code} ${detail}`) ? "auth" : res.status === 400 || res.status === 422 ? "invalid" : res.status >= 500 ? "server" : "unknown";
+        throw new MailError(msg2, { kind, provider: name, status: res.status, cause: data });
+      }
+      return { id: data?.request_id };
+    }
+  };
+}
+
+// src/providers/index.ts
+function isProvider(x) {
+  return typeof x === "object" && x !== null && typeof x.send === "function" && typeof x.name === "string";
+}
+function buildProvider(cfg) {
+  if (isProvider(cfg)) return { provider: cfg, disabled: false };
+  const { type, name, from, quota, disabled, senderDomains, ...rest } = cfg;
+  const base = { name, from: from === void 0 ? void 0 : parseAddress(from) };
+  let provider;
+  switch (type) {
+    case "hub":
+      provider = createHubProvider({ ...rest, ...base });
+      break;
+    case "resend":
+      provider = createResendProvider({ ...rest, ...base });
+      break;
+    case "smtp":
+      provider = createSmtpProvider({ ...rest, ...base });
+      break;
+    case "zeptomail":
+      provider = createZeptoMailProvider({ ...rest, ...base });
+      break;
+    case "console":
+      provider = createConsoleProvider({ ...rest, ...base });
+      break;
+    case "custom": {
+      const custom = cfg.provider;
+      provider = base.from || name ? { ...custom, name: name ?? custom.name, from: base.from ?? custom.from } : custom;
+      break;
+    }
+    default:
+      if (type in SMTP_PRESETS) {
+        provider = createPresetSmtpProvider(type, { ...rest, ...base });
+        break;
+      }
+      throw new TypeError(`Unknown mail provider type: "${String(type)}"`);
+  }
+  return {
+    provider,
+    quota,
+    disabled: disabled ?? false,
+    senderDomains: senderDomains?.map((d) => d.trim().toLowerCase()).filter(Boolean)
+  };
+}
+
+// src/stores/memory.ts
+function createMemoryStore() {
+  const data = /* @__PURE__ */ new Map();
+  const read = (key) => {
+    const hit = data.get(key);
+    if (!hit) return void 0;
+    if (hit.expiresAt <= Date.now()) {
+      data.delete(key);
+      return void 0;
+    }
+    return hit;
+  };
+  let ops = 0;
+  const sweep = () => {
+    if (++ops % 500 !== 0) return;
+    const now = Date.now();
+    for (const [k, v] of data) if (v.expiresAt <= now) data.delete(k);
+  };
+  return {
+    async get(key) {
+      sweep();
+      return read(key)?.value ?? null;
+    },
+    async set(key, value, ttlSec) {
+      sweep();
+      data.set(key, { value, expiresAt: Date.now() + ttlSec * 1e3 });
+    },
+    async incr(key, ttlSec) {
+      sweep();
+      const hit = read(key);
+      if (!hit) {
+        data.set(key, { value: "1", expiresAt: Date.now() + ttlSec * 1e3 });
+        return 1;
+      }
+      const next = Number(hit.value) + 1;
+      hit.value = String(next);
+      return next;
+    },
+    async decr(key) {
+      const hit = read(key);
+      if (hit) hit.value = String(Math.max(0, Number(hit.value) - 1));
+    },
+    async del(key) {
+      data.delete(key);
+    }
+  };
+}
+
+// src/mailer.ts
+var PROBE_KINDS = /* @__PURE__ */ new Set(["network", "server", "unknown"]);
+var timeoutError = (name, ms) => new MailError(`${name}: send timed out after ${ms}ms`, { kind: "network", provider: name });
+function withTimeout(run, ms, name) {
+  const ac = new AbortController();
+  return new Promise((resolve2, reject) => {
+    const t = setTimeout(() => {
+      const err = timeoutError(name, ms);
+      reject(err);
+      ac.abort(err);
+    }, ms);
+    Promise.resolve().then(() => run(ac.signal)).then(
+      (v) => {
+        clearTimeout(t);
+        resolve2(v);
+      },
+      (e) => {
+        clearTimeout(t);
+        reject(e);
+      }
+    );
+  });
+}
+function toBase64(content, encoding) {
+  if (Buffer.isBuffer(content)) return content.toString("base64");
+  return encoding === "base64" ? content : Buffer.from(content, "utf8").toString("base64");
+}
+function debugLogger(e) {
+  const tag = "[mailer]";
+  switch (e.type) {
+    case "sent":
+      console.log(
+        `${tag} sent via ${e.provider} (${e.ms}ms)${e.failedOver ? " [failover]" : ""}`,
+        e.id ?? ""
+      );
+      break;
+    case "failed":
+      console.warn(`${tag} ${e.provider} failed [${e.kind}] ${e.error} (${e.ms}ms)`);
+      break;
+    case "skipped":
+      console.warn(`${tag} ${e.provider} skipped (${e.reason})`);
+      break;
+    case "cooldown":
+      console.warn(
+        `${tag} ${e.provider} cooldown [${e.kind}] until ${new Date(e.untilMs).toISOString()} (failures=${e.failures})`
+      );
+      break;
+    case "recovered":
+      console.log(`${tag} ${e.provider} recovered`);
+      break;
+    case "exhausted":
+      console.error(`${tag} all providers failed`, e.attempts);
+      break;
+  }
+}
+function createMailer(options = {}) {
+  const env = options.env ?? process.env;
+  const entries = (options.providers ?? providersFromEnv(env)).map(buildProvider);
+  if (entries.length === 0) {
+    throw new TypeError(
+      "createMailer: no providers configured \u2014 pass { providers } or set MAIL_PROVIDERS / RESEND_API_KEY / SMTP_HOST"
+    );
+  }
+  const names = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (names.has(e.provider.name))
+      throw new TypeError(
+        `createMailer: duplicate provider name "${e.provider.name}" \u2014 set a unique name`
+      );
+    names.add(e.provider.name);
+  }
+  const fromRaw = options.from ?? env.MAIL_FROM ?? env.EMAIL_FROM;
+  const defaultFrom = fromRaw === void 0 ? void 0 : parseAddress(fromRaw);
+  const strategy = options.strategy ?? env.MAIL_STRATEGY ?? "priority";
+  const timeoutMs = options.timeoutMs ?? 2e4;
+  const debug = options.debug ?? /^(1|true)$/i.test(env.MAIL_DEBUG ?? "");
+  const emit = (e) => {
+    if (debug) debugLogger(e);
+    options.onEvent?.(e);
+  };
+  const health = new Health({
+    store: options.store ?? createMemoryStore(),
+    cooldown: options.cooldown,
+    maxCooldownSec: options.maxCooldownSec,
+    onEvent: emit
+  });
+  let rr = 0;
+  const order = () => {
+    if (strategy !== "round-robin" || entries.length < 2) return entries;
+    const start = rr++ % entries.length;
+    return [...entries.slice(start), ...entries.slice(0, start)];
+  };
+  const normalizeBase = (m) => {
+    try {
+      return {
+        requested: m.from !== void 0 ? parseAddress(m.from) : void 0,
+        to: parseAddressList(m.to),
+        cc: parseAddressList(m.cc),
+        bcc: parseAddressList(m.bcc),
+        replyTo: parseAddressList(m.replyTo),
+        subject: m.subject,
+        html: m.html,
+        text: m.text,
+        attachments: (m.attachments ?? []).map((a) => ({
+          filename: a.filename,
+          base64: toBase64(a.content, a.encoding),
+          contentType: a.contentType
+        })),
+        headers: m.headers ?? {},
+        tags: m.tags ?? {},
+        prefer: m.prefer
+      };
+    } catch (err) {
+      throw new MailError(err.message, { kind: "invalid", cause: err });
+    }
+  };
+  const resolveFrom = (requested, e) => {
+    const p = e.provider;
+    if (!p.from) {
+      const from = requested ?? defaultFrom;
+      if (!from && !p.optionalFrom)
+        throw new MailError(`No "from" address \u2014 set message.from, provider from, or MAIL_FROM`, {
+          kind: "invalid",
+          provider: p.name
+        });
+      return from;
+    }
+    if (!requested) return p.from;
+    const domain = requested.email.slice(requested.email.indexOf("@") + 1).toLowerCase();
+    const allowed = e.senderDomains?.length ? e.senderDomains.includes(domain) : requested.email.toLowerCase() === p.from.email.toLowerCase();
+    if (allowed) return requested;
+    return requested.name ? { name: requested.name, email: p.from.email } : p.from;
+  };
+  async function pickProbe(candidates, attempts) {
+    const cooled = candidates.filter(
+      (e) => attempts.some((a) => a.provider === e.provider.name && a.skipped === "cooldown")
+    );
+    const ranked = [];
+    for (const entry of cooled) {
+      const cd = await health.cooldownOf(entry.provider.name);
+      if (cd && PROBE_KINDS.has(cd.kind)) ranked.push({ entry, until: cd.until });
+    }
+    ranked.sort((a, b) => a.until - b.until);
+    const pick = ranked[0]?.entry;
+    if (!pick || !await health.allowProbe(pick.provider.name)) return null;
+    if (await health.reserve(pick.provider, pick.quota)) return null;
+    return pick;
+  }
+  async function send(message) {
+    if (!message?.to || Array.isArray(message.to) && message.to.length === 0)
+      throw new MailError("Message has no recipients (to)", { kind: "invalid" });
+    if (!message.subject) throw new MailError("Message has no subject", { kind: "invalid" });
+    if (message.html === void 0 && message.text === void 0)
+      throw new MailError("Message needs html or text", { kind: "invalid" });
+    let candidates = order();
+    if (message.prefer) {
+      const i = candidates.findIndex((e) => e.provider.name === message.prefer);
+      if (i > 0) candidates = [candidates[i], ...candidates.filter((_, j) => j !== i)];
+    }
+    if (message.provider) {
+      candidates = candidates.filter((e) => e.provider.name === message.provider);
+      if (candidates.length === 0)
+        throw new MailError(`Unknown provider "${message.provider}"`, { kind: "invalid" });
+    }
+    const { requested, ...base } = normalizeBase(message);
+    const attempts = [];
+    const forced = message.provider !== void 0;
+    const attempt = async (entry, opts) => {
+      const p = entry.provider;
+      const started = Date.now();
+      let id;
+      try {
+        ({ id } = await withTimeout(
+          (signal) => {
+            const normalized = {
+              ...base,
+              from: resolveFrom(requested, entry),
+              signal
+            };
+            return p.send(normalized);
+          },
+          timeoutMs,
+          p.name
+        ));
+      } catch (err) {
+        const ms2 = Date.now() - started;
+        const { kind, message: error, retryAfterSec } = classifyError(err);
+        attempts.push({ provider: p.name, ok: false, error, kind, ms: ms2 });
+        emit({ type: "failed", provider: p.name, kind, error, ms: ms2 });
+        try {
+          if (opts.reserved) await health.release(p, entry.quota);
+          await health.recordFailure(p, kind, retryAfterSec);
+        } catch {
+        }
+        return null;
+      }
+      const ms = Date.now() - started;
+      attempts.push({ provider: p.name, ok: true, ms });
+      await health.recordSuccess(p).catch(() => {
+      });
+      const failedOver = opts.failedOver();
+      emit({ type: "sent", provider: p.name, id, ms, failedOver });
+      return { id, provider: p.name, failedOver, attempts };
+    };
+    for (const entry of candidates) {
+      const p = entry.provider;
+      if (entry.disabled) {
+        attempts.push({ provider: p.name, ok: false, skipped: "disabled", ms: 0 });
+        emit({ type: "skipped", provider: p.name, reason: "disabled" });
+        continue;
+      }
+      const skip = forced ? null : await health.check(p, entry.quota);
+      if (skip) {
+        attempts.push({ provider: p.name, ok: false, skipped: skip, ms: 0 });
+        emit({ type: "skipped", provider: p.name, reason: skip });
+        continue;
+      }
+      const result = await attempt(entry, {
+        reserved: !forced,
+        failedOver: () => attempts.length > 1
+      });
+      if (result) return result;
+    }
+    if (!forced && attempts.every((a) => a.skipped)) {
+      const probe = await pickProbe(candidates, attempts).catch(() => null);
+      if (probe) {
+        const first = candidates.find((e) => !e.disabled)?.provider.name;
+        const result = await attempt(probe, {
+          reserved: true,
+          failedOver: () => probe.provider.name !== first
+        });
+        if (result) return result;
+      }
+    }
+    emit({ type: "exhausted", attempts });
+    throw new AllProvidersFailedError(attempts);
+  }
+  return {
+    send,
+    providers: entries.map((e) => e.provider.name),
+    status: () => Promise.all(entries.map((e) => health.status(e.provider, e.quota))),
+    async listProviders() {
+      const out = [];
+      for (const e of entries) {
+        if (e.disabled) continue;
+        const st = await health.status(e.provider, e.quota);
+        if (e.provider.listProviders) {
+          try {
+            out.push(...await e.provider.listProviders());
+            continue;
+          } catch {
+          }
+        }
+        out.push({ name: e.provider.name, type: e.provider.type, available: st.available });
+      }
+      return out;
+    },
+    async verify() {
+      const out = {};
+      await Promise.all(
+        entries.map(async (e) => {
+          try {
+            const verify = e.provider.verify?.bind(e.provider);
+            if (verify) await withTimeout(() => verify(), timeoutMs, e.provider.name);
+            out[e.provider.name] = { ok: true };
+          } catch (err) {
+            out[e.provider.name] = { ok: false, error: classifyError(err).message };
+          }
+        })
+      );
+      return out;
+    },
+    async reset(name) {
+      for (const e of entries)
+        if (!name || e.provider.name === name) await health.reset(e.provider.name);
+    }
+  };
+}
+
+// src/default.ts
+var instance;
+var pending;
+function configureMailer(options) {
+  pending = options;
+  instance = createMailer(options);
+  return instance;
+}
+function getMailer() {
+  instance ??= createMailer(pending);
+  return instance;
+}
+function sendMail(message) {
+  return getMailer().send(message);
+}
+function listProviders() {
+  return getMailer().listProviders();
+}
+function resetMailer() {
+  instance = void 0;
+  pending = void 0;
+}
+
+// src/recipients.ts
+var emailOf = (r) => {
+  const raw = typeof r === "string" ? r : r?.email;
+  const email = raw?.trim().toLowerCase();
+  return email ? email : null;
+};
+function toEmails(to) {
+  if (Array.isArray(to)) {
+    const emails = [...new Set(to.map(emailOf).filter((e) => e !== null))];
+    if (emails.length === 0) throw invalidRecipient("\u0E44\u0E21\u0E48\u0E21\u0E35\u0E1C\u0E39\u0E49\u0E23\u0E31\u0E1A\u0E17\u0E35\u0E48\u0E21\u0E35\u0E2D\u0E35\u0E40\u0E21\u0E25\u0E40\u0E25\u0E22");
+    return emails;
+  }
+  const email = emailOf(to);
+  if (!email) throw invalidRecipient("\u0E1C\u0E39\u0E49\u0E23\u0E31\u0E1A\u0E44\u0E21\u0E48\u0E21\u0E35\u0E2D\u0E35\u0E40\u0E21\u0E25");
+  return email;
+}
+var invalidRecipient = (why) => new MailError(`notify(): ${why}`, { kind: "invalid", provider: "hub" });
+function toEmail(to) {
+  const email = toEmails(to);
+  if (Array.isArray(email)) throw invalidRecipient("\u0E15\u0E49\u0E2D\u0E07\u0E40\u0E1B\u0E47\u0E19\u0E1C\u0E39\u0E49\u0E23\u0E31\u0E1A\u0E04\u0E19\u0E40\u0E14\u0E35\u0E22\u0E27");
+  return email;
+}
+
+// src/notify.ts
+var NOTIFY_TIMEOUT_MS = { notify: 65e3, recipient: 1e4 };
+function resolve(opts) {
+  const env = opts.env ?? process.env;
+  const apiKey = opts.apiKey ?? env.PI_NOTIFY_KEY;
+  if (!apiKey) throw new MailError("notify(): PI_NOTIFY_KEY is required", { kind: "auth" });
+  const base = (opts.url ?? env.PI_NOTIFY_URL ?? DEFAULT_HUB_URL).replace(/\/$/, "");
+  return { apiKey, base, doFetch: opts.fetch ?? globalThis.fetch };
+}
+function hasNotifyKey(opts = {}) {
+  return Boolean(opts.apiKey ?? (opts.env ?? process.env).PI_NOTIFY_KEY);
+}
+async function hubRequest(opts, path, init) {
+  const { apiKey, base, doFetch } = resolve(opts);
+  const ms = opts.timeoutMs ?? init.timeoutMs;
+  const ac = new AbortController();
+  const timer = setTimeout(() => ac.abort(), ms);
+  const timedOut = () => new MailError(`Pi Notify timeout after ${ms}ms`, { kind: "network", provider: "hub" });
+  let res;
+  let data;
+  try {
+    res = await doFetch(`${base}${path}`, {
+      method: init.method ?? "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        ...init.body !== void 0 ? { "Content-Type": "application/json" } : {}
+      },
+      body: init.body !== void 0 ? JSON.stringify(init.body) : void 0,
+      signal: ac.signal
+    });
+    data = await res.json().catch(() => ({}));
+  } catch (err) {
+    if (ac.signal.aborted) throw timedOut();
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+  if (ac.signal.aborted) throw timedOut();
+  if (!res.ok) {
+    const err = data?.error;
+    const kind = err?.kind ?? (res.status === 401 || res.status === 403 ? "auth" : res.status === 429 ? "rate_limit" : res.status === 400 || res.status === 422 ? "invalid" : "server");
+    throw new MailError(`Pi Notify ${res.status}: ${err?.message ?? res.statusText}`, {
+      kind,
+      provider: "hub",
+      status: res.status,
+      cause: data,
+      retryAfterSec: retryAfterOf(res, data)
+    });
+  }
+  return data;
+}
+async function notify(input, opts = {}) {
+  const data = await hubRequest(opts, "/api/v1/notify", {
+    method: "POST",
+    body: { ...input, to: toEmails(input.to) },
+    timeoutMs: NOTIFY_TIMEOUT_MS.notify
+  });
+  return { results: data.results, ...data.summary };
+}
+async function getRecipient(email, opts = {}) {
+  return hubRequest(
+    opts,
+    `/api/v1/recipients/${encodeURIComponent(toEmail(email))}`,
+    {
+      timeoutMs: NOTIFY_TIMEOUT_MS.recipient
+    }
+  );
+}
+async function createLink(email, channel = "telegram", opts = {}) {
+  const { piUserId, ...rest } = opts;
+  const link = await hubRequest(
+    rest,
+    `/api/v1/recipients/${encodeURIComponent(toEmail(email))}/link`,
+    {
+      method: "POST",
+      body: { channel, ...piUserId ? { piUserId } : {} },
+      timeoutMs: NOTIFY_TIMEOUT_MS.recipient
+    }
+  );
+  const code = link.code ?? safeStartParam(link.url);
+  return { ...link, code };
+}
+function safeStartParam(url) {
+  try {
+    return new URL(url).searchParams.get("start") ?? "";
+  } catch {
+    return "";
+  }
+}
+async function getChannelStatus(email, channel = "telegram", opts = {}) {
+  const recipient2 = await getRecipient(email, opts);
+  const found = recipient2.channels.find((c) => c.type === channel && c.enabled);
+  return {
+    linked: Boolean(found),
+    label: found?.label ?? null,
+    linkedAt: found?.linkedAt ?? null,
+    manageUrl: recipient2.linkUrl
+  };
+}
+async function getPushConfig(opts = {}) {
+  return hubRequest(opts, "/api/v1/push/config", { timeoutMs: NOTIFY_TIMEOUT_MS.recipient });
+}
+async function savePushSubscription(email, subscription, opts = {}) {
+  const { label, piUserId, ...rest } = opts;
+  return hubRequest(rest, `/api/v1/recipients/${encodeURIComponent(email)}/push`, {
+    method: "POST",
+    body: { subscription, ...label ? { label } : {}, ...piUserId ? { piUserId } : {} },
+    timeoutMs: NOTIFY_TIMEOUT_MS.recipient
+  });
+}
+async function deletePushSubscription(email, endpoint, opts = {}) {
+  return hubRequest(opts, `/api/v1/recipients/${encodeURIComponent(email)}/push`, {
+    method: "DELETE",
+    body: { endpoint },
+    timeoutMs: NOTIFY_TIMEOUT_MS.recipient
+  });
+}
+async function listPushDevices(email, opts = {}) {
+  return hubRequest(opts, `/api/v1/recipients/${encodeURIComponent(email)}/push`, {
+    timeoutMs: NOTIFY_TIMEOUT_MS.recipient
+  });
+}
+
+// src/safe.ts
+var warnedDisabled = false;
+function warnDisabled(what, env) {
+  if (env.NODE_ENV !== "production") {
+    if (warnedDisabled) return;
+    warnedDisabled = true;
+  }
+  console.warn(`[pi-notify] ${what} \u0E44\u0E21\u0E48\u0E17\u0E33\u0E07\u0E32\u0E19 \u2014 \u0E44\u0E21\u0E48\u0E44\u0E14\u0E49\u0E15\u0E31\u0E49\u0E07 PI_NOTIFY_KEY`);
+}
+function resetSafeWarnings() {
+  warnedDisabled = false;
+}
+var messageOf = (err) => err instanceof Error ? err.message : String(err);
+async function notifySafe(input, opts = {}) {
+  const none = { sent: 0, failed: 0, skipped: 0, results: [] };
+  if (!hasNotifyKey(opts)) {
+    warnDisabled("notify()", opts.env ?? process.env);
+    return { ok: false, disabled: true, ...none };
+  }
+  try {
+    const r = await notify(input, opts);
+    return { ok: r.failed === 0, ...r };
+  } catch (err) {
+    const body = err instanceof MailError ? err.cause : void 0;
+    return {
+      ok: false,
+      ...none,
+      ...body?.error?.summary ?? {},
+      results: body?.error?.results ?? [],
+      error: messageOf(err)
+    };
+  }
+}
+function noProvidersConfigured(err) {
+  return err instanceof AllProvidersFailedError && err.attempts.length === 0 || err instanceof TypeError && /no providers configured/.test(err.message);
+}
+async function sendMailSafe(message) {
+  try {
+    const r = await sendMail(message);
+    return { ok: true, provider: r.provider, id: r.id, failedOver: r.failedOver };
+  } catch (err) {
+    if (noProvidersConfigured(err)) {
+      warnDisabled("sendMail()", process.env);
+      return { ok: false, disabled: true };
+    }
+    return { ok: false, error: messageOf(err) };
+  }
+}
+
+export {
+  parseAddress,
+  requireFrom,
+  parseAddressList,
+  formatAddress,
+  createSmtpProvider,
+  SMTP_PRESETS,
+  createPresetSmtpProvider,
+  providersFromEnv,
+  MailError,
+  AllProvidersFailedError,
+  classifyError,
+  DEFAULT_COOLDOWN,
+  createConsoleProvider,
+  DEFAULT_HUB_URL,
+  createHubProvider,
+  createResendProvider,
+  createZeptoMailProvider,
+  createMemoryStore,
+  createMailer,
+  configureMailer,
+  getMailer,
+  sendMail,
+  listProviders,
+  resetMailer,
+  toEmails,
+  NOTIFY_TIMEOUT_MS,
+  hasNotifyKey,
+  notify,
+  getRecipient,
+  createLink,
+  getChannelStatus,
+  getPushConfig,
+  savePushSubscription,
+  deletePushSubscription,
+  listPushDevices,
+  resetSafeWarnings,
+  notifySafe,
+  sendMailSafe
+};