@stacksjs/email 0.70.87 → 0.70.90

package/dist/preview.js

@@ -0,0 +1,97 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { existsSync } from "@stacksjs/storage";
+import { userEmailsPath, userMailPath } from "@stacksjs/path";
+import { kebabCase } from "@stacksjs/strings";
+import { Mailable } from "./mailable";
+import { template } from "./template";
+export function discoverMailables() {
+  const dir = userMailPath();
+  if (!existsSync(dir))
+    return [];
+  const entries = readdirSync(dir, { withFileTypes: !0 }), out = [];
+  for (const entry of entries) {
+    if (!entry.isFile())
+      continue;
+    if (!entry.name.endsWith(".ts"))
+      continue;
+    if (entry.name.endsWith(".d.ts"))
+      continue;
+    if (entry.name.endsWith(".test.ts"))
+      continue;
+    if (entry.name.endsWith(".spec.ts"))
+      continue;
+    const base = entry.name.replace(/\.ts$/, "");
+    out.push({
+      name: base,
+      path: join(dir, entry.name),
+      slug: kebabCase(base)
+    });
+  }
+  out.sort((a, b) => a.name.localeCompare(b.name));
+  return out;
+}
+export async function loadSampleProps(slug) {
+  const samplePath = userEmailsPath(`_previews/${slug}.ts`);
+  if (!existsSync(samplePath))
+    return null;
+  try {
+    const mod = await import(samplePath), props = mod.default ?? mod.props ?? null;
+    return props && typeof props === "object" ? props : null;
+  } catch (err) {
+    return { __preview_error__: `Failed to load sample props: ${err instanceof Error ? err.message : String(err)}` };
+  }
+}
+export async function renderMailablePreview(mailable) {
+  const empty = {
+    inspection: { to: [], cc: [], bcc: [], attachments: [] },
+    html: "",
+    text: "",
+    sampleProps: null
+  };
+  try {
+    const mod = await import(mailable.path), Cls = pickMailableConstructor(mod);
+    if (!Cls)
+      return { ...empty, error: `No subclass of \`Mailable\` exported from ${mailable.path}.` };
+    const sampleProps = await loadSampleProps(mailable.slug), instance = new Cls(sampleProps ?? {});
+    if (!(instance instanceof Mailable))
+      return { ...empty, sampleProps, error: "Constructor did not produce a Mailable instance." };
+    await instance.build();
+    const inspection = instance.inspect();
+    if (!inspection.template)
+      return {
+        inspection,
+        html: inspection.html ?? "",
+        text: inspection.text ?? "",
+        sampleProps
+      };
+    const rendered = await template(inspection.template.name, {
+      variables: inspection.template.props,
+      subject: inspection.subject
+    });
+    return {
+      inspection,
+      html: rendered.html,
+      text: rendered.text,
+      sampleProps
+    };
+  } catch (err) {
+    return { ...empty, error: err instanceof Error ? `${err.name}: ${err.message}` : String(err) };
+  }
+}
+function pickMailableConstructor(mod) {
+  const candidates = [];
+  if (mod.default)
+    candidates.push(mod.default);
+  for (const key of Object.keys(mod))
+    if (key !== "default")
+      candidates.push(mod[key]);
+  for (const candidate of candidates) {
+    if (typeof candidate !== "function")
+      continue;
+    if (!(candidate.prototype instanceof Mailable))
+      continue;
+    return candidate;
+  }
+  return null;
+}

package/dist/sdk/index.d.ts

@@ -0,0 +1,81 @@
+// Export singleton instance
+export declare const emailSDK: EmailSDK;
+// Export convenience functions
+export declare const sendEmail: (message: EmailMessage) => unknown;
+export declare const getInbox: (mailbox: string, options?: { limit?: number; offset?: number }) => unknown;
+export declare const searchEmails: (mailbox: string, options: EmailSearchOptions) => unknown;
+export declare const deleteEmail: (mailbox: string, messageId: string) => unknown;
+export declare interface EmailAddress {
+  name?: string
+  address: string
+}
+export declare interface EmailMessage {
+  from?: EmailAddress | string
+  to: string | string[] | EmailAddress[]
+  cc?: string | string[] | EmailAddress[]
+  bcc?: string | string[] | EmailAddress[]
+  replyTo?: string | EmailAddress
+  subject: string
+  text?: string
+  html?: string
+  attachments?: EmailAttachment[]
+}
+export declare interface EmailAttachment {
+  filename: string
+  content: string | Buffer
+  contentType?: string
+  encoding?: 'base64' | 'binary'
+}
+export declare interface InboxEmail {
+  messageId: string
+  from: string
+  fromName?: string
+  to: string
+  subject: string
+  date: string
+  read: boolean
+  preview?: string
+  hasAttachments?: boolean
+  path: string
+}
+export declare interface EmailSearchOptions {
+  from?: string
+  to?: string
+  subject?: string
+  after?: Date
+  before?: Date
+  hasAttachments?: boolean
+  limit?: number
+  offset?: number
+}
+export declare interface SendResult {
+  success: boolean
+  messageId?: string
+  error?: string
+}
+/**
+ * Email SDK class for Stacks applications
+ */
+export declare class EmailSDK {
+  constructor(options?: { bucket?: string; region?: string; domain?: string });
+  send(message: EmailMessage): Promise<SendResult>;
+  sendTemplate(options: {
+    to: string | string[]
+    template: string
+    data: Record<string, any>
+    from?: EmailAddress | string
+    subject?: string
+  }): Promise<SendResult>;
+  getInbox(mailbox: string, options?: { limit?: number; offset?: number }): Promise<InboxEmail[]>;
+  getEmail(mailbox: string, messageId: string): Promise<{
+    metadata: Record<string, any>
+    html?: string
+    text?: string
+    raw?: string
+  } | null>;
+  search(mailbox: string, options: EmailSearchOptions): Promise<InboxEmail[]>;
+  delete(mailbox: string, messageId: string): Promise<boolean>;
+  markAsRead(mailbox: string, messageId: string): Promise<boolean>;
+  markAsUnread(mailbox: string, messageId: string): Promise<boolean>;
+}
+export default EmailSDK;

package/dist/sdk/index.js

@@ -0,0 +1,219 @@
+import { email as emailConfig } from "@stacksjs/config";
+import { getErrorMessage } from "@stacksjs/utils";
+
+export class EmailSDK {
+  bucket;
+  region;
+  domain;
+  constructor(options) {
+    this.bucket = options?.bucket || `${process.env.APP_NAME?.toLowerCase() || "stacks"}-emails`;
+    this.region = options?.region || process.env.AWS_REGION || "us-east-1";
+    const fromAddress = emailConfig?.from?.address, parsedDomain = fromAddress?.includes("@") ? fromAddress.split("@")[1] : void 0;
+    this.domain = options?.domain || parsedDomain || "stacksjs.com";
+  }
+  async send(message) {
+    try {
+      const { SESClient } = await import("@stacksjs/ts-cloud"), ses = new SESClient(this.region), from = this.normalizeAddress(message.from || emailConfig?.from || { address: `noreply@${this.domain}` }), toAddresses = this.normalizeAddresses(message.to), ccAddresses = message.cc ? this.normalizeAddresses(message.cc) : void 0, bccAddresses = message.bcc ? this.normalizeAddresses(message.bcc) : void 0;
+      return {
+        success: !0,
+        messageId: (await ses.sendEmail({
+          FromEmailAddress: typeof from === "string" ? from : `${from.name} <${from.address}>`,
+          Destination: {
+            ToAddresses: toAddresses,
+            CcAddresses: ccAddresses,
+            BccAddresses: bccAddresses
+          },
+          ReplyToAddresses: message.replyTo ? [typeof message.replyTo === "string" ? message.replyTo : message.replyTo.address] : void 0,
+          Content: {
+            Simple: {
+              Subject: {
+                Data: message.subject,
+                Charset: "UTF-8"
+              },
+              Body: {
+                ...message.html && {
+                  Html: {
+                    Data: message.html,
+                    Charset: "UTF-8"
+                  }
+                },
+                ...message.text && {
+                  Text: {
+                    Data: message.text,
+                    Charset: "UTF-8"
+                  }
+                }
+              }
+            }
+          }
+        })).MessageId
+      };
+    } catch (error) {
+      return {
+        success: !1,
+        error: getErrorMessage(error)
+      };
+    }
+  }
+  async sendTemplate(options) {
+    const html = this.renderTemplate(options.template, options.data), subject = options.subject || options.template;
+    return this.send({
+      to: options.to,
+      from: options.from,
+      subject,
+      html
+    });
+  }
+  async getInbox(mailbox, options) {
+    try {
+      const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(this.region), [localPart, domain] = mailbox.includes("@") ? mailbox.split("@") : [mailbox, this.domain], indexKey = `mailboxes/${domain}/${localPart}/inbox.json`, result = await s3.getObject(this.bucket, indexKey);
+      if (!result)
+        return [];
+      let inbox = JSON.parse(result);
+      const offset = options?.offset || 0, limit = options?.limit || 50;
+      return inbox.slice(offset, offset + limit);
+    } catch (error) {
+      if (getErrorMessage(error).includes("NoSuchKey") || getErrorMessage(error).includes("404"))
+        return [];
+      throw error;
+    }
+  }
+  async getEmail(mailbox, messageId) {
+    try {
+      const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(this.region), [localPart, domain] = mailbox.includes("@") ? mailbox.split("@") : [mailbox, this.domain], email = (await this.getInbox(mailbox, { limit: 1000 })).find((e) => e.messageId === messageId);
+      if (!email)
+        return null;
+      const basePath = email.path, metaResult = await s3.getObject(this.bucket, `${basePath}/metadata.json`);
+      let metadata = {};
+      if (metaResult)
+        try {
+          metadata = JSON.parse(metaResult);
+        } catch (parseError) {
+          console.debug(`[email-sdk] Failed to parse email metadata: ${parseError.message}`);
+        }
+      let html;
+      try {
+        html = await s3.getObject(this.bucket, `${basePath}/body.html`) || void 0;
+      } catch (error) {
+        if (!getErrorMessage(error)?.includes("NoSuchKey") && !getErrorMessage(error)?.includes("404"))
+          console.debug(`[email-sdk] Failed to fetch HTML body: ${getErrorMessage(error)}`);
+      }
+      let text;
+      try {
+        text = await s3.getObject(this.bucket, `${basePath}/body.txt`) || void 0;
+      } catch (error) {
+        if (!getErrorMessage(error)?.includes("NoSuchKey") && !getErrorMessage(error)?.includes("404"))
+          console.debug(`[email-sdk] Failed to fetch text body: ${getErrorMessage(error)}`);
+      }
+      return { metadata, html, text };
+    } catch (error) {
+      if (getErrorMessage(error).includes("NoSuchKey") || getErrorMessage(error).includes("404"))
+        return null;
+      throw error;
+    }
+  }
+  async search(mailbox, options) {
+    let results = await this.getInbox(mailbox, { limit: 1000 });
+    if (options.from) {
+      const fromLower = options.from.toLowerCase();
+      results = results.filter((e) => e.from.toLowerCase().includes(fromLower));
+    }
+    if (options.subject) {
+      const subjectLower = options.subject.toLowerCase();
+      results = results.filter((e) => e.subject.toLowerCase().includes(subjectLower));
+    }
+    if (options.after)
+      results = results.filter((e) => new Date(e.date) >= options.after);
+    if (options.before)
+      results = results.filter((e) => new Date(e.date) <= options.before);
+    if (options.hasAttachments !== void 0)
+      results = results.filter((e) => e.hasAttachments === options.hasAttachments);
+    const offset = options.offset || 0, limit = options.limit || 50;
+    return results.slice(offset, offset + limit);
+  }
+  async delete(mailbox, messageId) {
+    try {
+      const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(this.region), [localPart, domain] = mailbox.includes("@") ? mailbox.split("@") : [mailbox, this.domain], inbox = await this.getInbox(mailbox, { limit: 1000 }), emailIndex = inbox.findIndex((e) => e.messageId === messageId);
+      if (emailIndex === -1)
+        return !1;
+      const email = inbox[emailIndex];
+      if (!email)
+        return !1;
+      const basePath = email.path, keysToDelete = [
+        `${basePath}/metadata.json`,
+        `${basePath}/raw.eml`,
+        `${basePath}/body.html`,
+        `${basePath}/body.txt`,
+        `${basePath}/preview.txt`
+      ];
+      for (const key of keysToDelete)
+        try {
+          await s3.deleteObject(this.bucket, key);
+        } catch (error) {
+          if (!getErrorMessage(error)?.includes("NoSuchKey") && !getErrorMessage(error)?.includes("404"))
+            console.debug(`[email-sdk] Failed to delete ${key}: ${getErrorMessage(error)}`);
+        }
+      inbox.splice(emailIndex, 1);
+      await s3.putObject({
+        bucket: this.bucket,
+        key: `mailboxes/${domain}/${localPart}/inbox.json`,
+        body: JSON.stringify(inbox, null, 2),
+        contentType: "application/json"
+      });
+      return !0;
+    } catch (error) {
+      console.debug(`[email-sdk] Failed to delete email ${messageId}: ${getErrorMessage(error)}`);
+      return !1;
+    }
+  }
+  async markAsRead(mailbox, messageId) {
+    return this.updateEmailStatus(mailbox, messageId, { read: !0 });
+  }
+  async markAsUnread(mailbox, messageId) {
+    return this.updateEmailStatus(mailbox, messageId, { read: !1 });
+  }
+  async updateEmailStatus(mailbox, messageId, updates) {
+    try {
+      const { S3Client } = await import("@stacksjs/ts-cloud"), s3 = new S3Client(this.region), [localPart, domain] = mailbox.includes("@") ? mailbox.split("@") : [mailbox, this.domain], inbox = await this.getInbox(mailbox, { limit: 1000 }), emailIndex = inbox.findIndex((e) => e.messageId === messageId);
+      if (emailIndex === -1)
+        return !1;
+      Object.assign(inbox[emailIndex], updates);
+      await s3.putObject({
+        bucket: this.bucket,
+        key: `mailboxes/${domain}/${localPart}/inbox.json`,
+        body: JSON.stringify(inbox, null, 2),
+        contentType: "application/json"
+      });
+      return !0;
+    } catch (error) {
+      console.debug(`[email-sdk] Failed to update email status for ${messageId}: ${getErrorMessage(error)}`);
+      return !1;
+    }
+  }
+  normalizeAddress(addr) {
+    if (typeof addr === "string") {
+      const match = addr.match(/^(.+?)\s*<(.+)>$/);
+      if (match)
+        return { name: match[1].trim(), address: match[2].trim() };
+      return { address: addr };
+    }
+    return addr;
+  }
+  normalizeAddresses(addrs) {
+    return (Array.isArray(addrs) ? addrs : [addrs]).map((a) => {
+      if (typeof a === "string")
+        return a;
+      return a.name ? `${a.name} <${a.address}>` : a.address;
+    });
+  }
+  renderTemplate(template, data) {
+    let result = template;
+    for (const [key, value] of Object.entries(data)) {
+      const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      result = result.replace(new RegExp(`{{\\s*${escapedKey}\\s*}}`, "g"), String(value));
+    }
+    return result;
+  }
+}
+export const emailSDK = new EmailSDK, sendEmail = (message) => emailSDK.send(message), getInbox = (mailbox, options) => emailSDK.getInbox(mailbox, options), searchEmails = (mailbox, options) => emailSDK.search(mailbox, options), deleteEmail = (mailbox, messageId) => emailSDK.delete(mailbox, messageId);
+export default EmailSDK;

package/dist/send.d.ts

@@ -0,0 +1 @@
+

package/dist/server/converter.d.ts

@@ -0,0 +1 @@
+

package/dist/server/inbound.d.ts

@@ -0,0 +1 @@
+

package/dist/server/outbound.d.ts

@@ -0,0 +1 @@
+

package/dist/suppression.js

@@ -0,0 +1,104 @@
+import { db } from "@stacksjs/database";
+let warnedAboutMissingTable = !1;
+function warnOnceAboutMissingTable() {
+  if (warnedAboutMissingTable)
+    return;
+  warnedAboutMissingTable = !0;
+  console.warn("[email/suppression] email_suppressions table missing \u2014 suppression checks accepted but NOT enforced. " + "Run migrations to enable enforcement.");
+}
+export function isMissingTableError(err) {
+  const e = err, msg = e?.message ?? "";
+  return e?.code === "42P01" || msg.includes("no such table") || msg.includes("doesn't exist") || /relation "[^"]*" does not exist/i.test(msg);
+}
+function isSuppressionStoreUnavailable(err) {
+  if (isMissingTableError(err))
+    return !0;
+  const msg = (err?.message ?? "").toLowerCase();
+  return msg.includes("connection closed") || msg.includes("unable to open database") || msg.includes("econnrefused") || msg.includes("connection terminated") || msg.includes("no database") || msg.includes("database connection");
+}
+function canonicalize(email) {
+  return String(email).trim().toLowerCase();
+}
+export async function isSuppressed(email, type) {
+  const canon = canonicalize(email);
+  try {
+    let query = db.selectFrom("email_suppressions").where("email", "=", canon).select(["email"]);
+    if (type)
+      query = query.where("type", "=", type);
+    const row = await query.executeTakeFirst();
+    return Boolean(row);
+  } catch (err) {
+    if (isSuppressionStoreUnavailable(err)) {
+      warnOnceAboutMissingTable();
+      return !1;
+    }
+    throw err;
+  }
+}
+export async function getSuppressions(email) {
+  const canon = canonicalize(email);
+  try {
+    return await db.selectFrom("email_suppressions").where("email", "=", canon).selectAll().execute() ?? [];
+  } catch (err) {
+    if (isSuppressionStoreUnavailable(err)) {
+      warnOnceAboutMissingTable();
+      return [];
+    }
+    throw err;
+  }
+}
+export async function suppress(email, type, reason) {
+  const canon = canonicalize(email), createdAt = new Date().toISOString().slice(0, 19).replace("T", " ");
+  try {
+    await db.insertInto("email_suppressions").values({
+      email: canon,
+      type,
+      reason: reason ?? null,
+      created_at: createdAt
+    }).execute();
+  } catch (err) {
+    if (isSuppressionStoreUnavailable(err)) {
+      warnOnceAboutMissingTable();
+      return;
+    }
+    const msg = err?.message ?? "";
+    if (msg.includes("UNIQUE constraint") || msg.includes("Duplicate entry"))
+      return;
+    throw err;
+  }
+}
+export async function unsuppress(email, type) {
+  const canon = canonicalize(email);
+  try {
+    await db.deleteFrom("email_suppressions").where("email", "=", canon).where("type", "=", type).execute();
+  } catch (err) {
+    if (isSuppressionStoreUnavailable(err)) {
+      warnOnceAboutMissingTable();
+      return;
+    }
+    throw err;
+  }
+}
+export async function getSuppressionPolicy() {
+  try {
+    const { config } = await import("@stacksjs/config"), policy = config?.email?.suppressionPolicy;
+    if (policy === "strict" || policy === "transactional-allowed" || policy === "off")
+      return policy;
+  } catch {}
+  return "strict";
+}
+export async function checkSuppressionFor(email, tag) {
+  const policy = await getSuppressionPolicy();
+  if (policy === "off")
+    return null;
+  if (policy === "transactional-allowed" && tag === "transactional")
+    return null;
+  const suppressions = await getSuppressions(email);
+  if (suppressions.length === 0)
+    return null;
+  const priority = ["unsubscribe", "complaint", "bounce", "manual"];
+  for (const p of priority)
+    if (suppressions.some((s) => s.type === p))
+      return p;
+  return suppressions[0].type;
+}

package/dist/template.js

@@ -0,0 +1,170 @@
+import { config } from "@stacksjs/config";
+import { log } from "@stacksjs/logging";
+import { fs } from "@stacksjs/storage";
+import { defaultsResourcesPath, resourcesPath } from "@stacksjs/path";
+import { join } from "node:path";
+import { inlineCss, shouldInlineByDefault } from "./css-inliner";
+
+export class SafeHtml {
+  value;
+  __safeHtml = !0;
+  constructor(value) {
+    this.value = value;
+  }
+}
+export function safe(html) {
+  return new SafeHtml(html);
+}
+function getDefaultVariables() {
+  const primaryColor = config.app.primaryColor || "#3b82f6";
+  return {
+    appName: config.app.name || "Stacks",
+    appUrl: config.app.url || "https://localhost",
+    primaryColor,
+    primaryColorDark: darkenColor(primaryColor, 15),
+    year: new Date().getFullYear()
+  };
+}
+function darkenColor(hex, percent) {
+  const num = Number.parseInt(hex.replace("#", ""), 16), amt = Math.round(2.55 * percent), R = Math.max(0, (num >> 16) - amt), G = Math.max(0, (num >> 8 & 255) - amt), B = Math.max(0, (num & 255) - amt);
+  return `#${(16777216 + R * 65536 + G * 256 + B).toString(16).slice(1)}`;
+}
+function escapeHtml(input) {
+  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function replaceVariables(html, variables) {
+  let result = html;
+  for (const [key, value] of Object.entries(variables)) {
+    const escapedKey = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), regex = new RegExp(`\\{\\{\\s*${escapedKey}\\s*\\}\\}`, "g");
+    result = result.replace(regex, renderTemplateValue(value));
+  }
+  return result;
+}
+function renderTemplateValue(value) {
+  if (value === null || value === void 0)
+    return "";
+  if (value instanceof SafeHtml)
+    return value.value;
+  return escapeHtml(String(value));
+}
+const templateRoots = [
+  (relativePath) => resourcesPath(join("emails", relativePath)),
+  (relativePath) => defaultsResourcesPath(join("emails", relativePath))
+];
+function resolveTemplatePath(templateName) {
+  for (const root of templateRoots) {
+    if (templateName.endsWith(".stx")) {
+      const fullPath = root(templateName);
+      if (fs.existsSync(fullPath))
+        return { path: fullPath, type: "stx" };
+      continue;
+    }
+    if (templateName.endsWith(".html")) {
+      const fullPath = root(templateName);
+      if (fs.existsSync(fullPath))
+        return { path: fullPath, type: "html" };
+      continue;
+    }
+    const stxPath = root(`${templateName}.stx`);
+    if (fs.existsSync(stxPath))
+      return { path: stxPath, type: "stx" };
+    const htmlPath = root(`${templateName}.html`);
+    if (fs.existsSync(htmlPath))
+      return { path: htmlPath, type: "html" };
+  }
+  return null;
+}
+function loadHtmlTemplate(templatePath) {
+  const path = templatePath.endsWith(".html") ? templatePath : `${templatePath}.html`;
+  for (const root of templateRoots) {
+    const fullPath = root(path);
+    if (fs.existsSync(fullPath))
+      return fs.readFileSync(fullPath, "utf-8");
+  }
+  return null;
+}
+function loadLayout(layoutName) {
+  return loadHtmlTemplate(`layouts/${layoutName}`);
+}
+function htmlToText(html) {
+  return html.replace(/<br\s*\/?>/gi, `
+`).replace(/<\/(p|div|h[1-6]|li|tr)>/gi, `
+`).replace(/<\/td>/gi, "\t").replace(/<[^>]*>/g, "").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&copy;/g, "(c)").replace(/\n\s*\n\s*\n/g, `
+
+`).trim();
+}
+export async function template(templateName, options = {}) {
+  const {
+    variables = {},
+    layout = "base",
+    subject = "",
+    inline = shouldInlineByDefault()
+  } = options, allVariables = {
+    ...getDefaultVariables(),
+    subject,
+    ...variables
+  }, resolved = resolveTemplatePath(templateName);
+  if (!resolved) {
+    console.warn(`[Email Template] Template "${templateName}" not found`);
+    return { html: "", text: "" };
+  }
+  if (resolved.type === "stx")
+    try {
+      const { renderEmail } = await import("@stacksjs/stx"), result = await renderEmail(resolved.path, allVariables, {
+        componentsDir: defaultsResourcesPath("components/Email")
+      });
+      return {
+        ...result,
+        html: inlineCss(result.html, { inline })
+      };
+    } catch (error) {
+      log.warn(`[email] STX template rendering failed for ${templateName}: ${error instanceof Error ? error.message : String(error)}`);
+      return { html: "", text: "" };
+    }
+  let content = fs.readFileSync(resolved.path, "utf-8");
+  content = replaceVariables(content, allVariables);
+  let html;
+  if (layout !== !1) {
+    const layoutHtml = loadLayout(layout);
+    if (!layoutHtml) {
+      console.warn(`[Email Template] Layout "${layout}" not found, using content only`);
+      html = content;
+    } else {
+      allVariables.content = safe(content);
+      html = replaceVariables(layoutHtml, allVariables);
+    }
+  } else
+    html = content;
+  html = inlineCss(html, { inline });
+  const text = htmlToText(html);
+  return { html, text };
+}
+export function renderHtml(htmlContent, variables = {}) {
+  const allVariables = {
+    ...getDefaultVariables(),
+    ...variables
+  }, html = replaceVariables(htmlContent, allVariables), text = htmlToText(html);
+  return { html, text };
+}
+export function templateExists(templateName) {
+  return resolveTemplatePath(templateName) !== null;
+}
+export function listTemplates() {
+  const emailsPath = resourcesPath("emails");
+  if (!fs.existsSync(emailsPath))
+    return [];
+  const templates = [];
+  function scanDir(dir, prefix = "") {
+    const entries = fs.readdirSync(dir, { withFileTypes: !0 });
+    for (const entry of entries)
+      if (entry.isDirectory() && entry.name !== "layouts")
+        scanDir(join(dir, entry.name), `${prefix}${entry.name}/`);
+      else if (entry.isFile() && (entry.name.endsWith(".html") || entry.name.endsWith(".stx"))) {
+        const name = entry.name.replace(/\.(html|stx)$/, "");
+        if (!templates.includes(`${prefix}${name}`))
+          templates.push(`${prefix}${name}`);
+      }
+  }
+  scanDir(emailsPath);
+  return templates;
+}