@emailens/engine 0.1.0 → 0.3.0

package/dist/index.js

@@ -1,4 +1,6 @@
 var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __propIsEnum = Object.prototype.propertyIsEnumerable;
@@ -14,6 +16,19 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
 
 // src/clients.ts
 var EMAIL_CLIENTS = [
@@ -730,6 +745,189 @@ var CSS_SUPPORT = {
     "superhuman": "unsupported"
     // Superhuman strips forms for security
   },
+  // --- Text Wrapping ---
+  "word-break": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    // Word engine ignores word-break entirely
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "partial",
+    // break-all partially works; break-word unreliable
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "overflow-wrap": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    // Word engine ignores overflow-wrap
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "partial",
+    // inconsistent support
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "white-space": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "partial",
+    // only normal and nowrap
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "supported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "text-overflow": {
+    "gmail-web": "unsupported",
+    // Gmail strips overflow, so text-overflow is useless
+    "gmail-android": "unsupported",
+    "gmail-ios": "unsupported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "partial",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  // --- Table Layout ---
+  "vertical-align": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "partial",
+    // only on <td> elements via valign attribute
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "supported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "border-spacing": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    // use cellspacing attribute instead
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "supported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  // --- Sizing ---
+  "min-width": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    // Word engine ignores min-width
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "supported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "min-height": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    // Word engine ignores min-height
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "supported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "max-height": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "supported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  // --- Shadows ---
+  "text-shadow": {
+    "gmail-web": "unsupported",
+    "gmail-android": "unsupported",
+    "gmail-ios": "unsupported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "unsupported",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  // --- Background Sub-properties ---
+  "background-size": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "partial",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
+  "background-position": {
+    "gmail-web": "supported",
+    "gmail-android": "supported",
+    "gmail-ios": "supported",
+    "outlook-web": "supported",
+    "outlook-windows": "unsupported",
+    "apple-mail-macos": "supported",
+    "apple-mail-ios": "supported",
+    "yahoo-mail": "partial",
+    "samsung-mail": "supported",
+    "thunderbird": "supported",
+    "hey-mail": "supported",
+    "superhuman": "supported"
+  },
   // --- Misc ---
   "opacity": {
     "gmail-web": "unsupported",
@@ -822,6 +1020,8 @@ var OUTLOOK_WORD_UNSUPPORTED = /* @__PURE__ */ new Set([
   "text-shadow",
   "max-width",
   "max-height",
+  "min-width",
+  "min-height",
   "float",
   "position",
   "display",
@@ -834,7 +1034,30 @@ var OUTLOOK_WORD_UNSUPPORTED = /* @__PURE__ */ new Set([
   "background-position",
   "box-sizing",
   "object-fit",
-  "gap"
+  "gap",
+  "word-break",
+  "overflow-wrap",
+  "text-overflow",
+  "border-spacing"
+]);
+var STRUCTURAL_FIX_PROPERTIES = /* @__PURE__ */ new Set([
+  "display:flex",
+  "display:grid",
+  "word-break",
+  "overflow-wrap",
+  "text-overflow",
+  "position",
+  "float",
+  "gap",
+  "max-width",
+  "border-radius",
+  "background-image",
+  "background-size",
+  "background-position",
+  "<svg>",
+  "<video>",
+  "<form>",
+  "object-fit"
 ]);
 
 // src/fix-snippets.ts
@@ -1340,6 +1563,146 @@ h1 {
 <div style="font-size: 0; max-height: 0; overflow: hidden;
             mso-hide: all;" aria-hidden="true">
   Preheader text
+</div>`
+  },
+  // ── word-break → table cell wrapping ─────────────────────────────────────
+  "word-break": {
+    language: "html",
+    description: "Wrap long text in a table cell to force line breaks without word-break",
+    before: `<span style="word-break: break-all;">
+  https://example.com/very/long/url?token=abc123def456
+</span>`,
+    after: `<!-- Table cells force text wrapping in all clients including Outlook -->
+<table role="presentation" width="100%" cellpadding="0"
+  cellspacing="0" border="0">
+  <tr>
+    <td style="word-break: break-all; overflow-wrap: break-word;
+               word-wrap: break-word;">
+      https://example.com/very/long/url?token=abc123def456
+    </td>
+  </tr>
+</table>`
+  },
+  "word-break::jsx": {
+    language: "jsx",
+    description: "Wrap long text in a table cell for Outlook-safe word breaking",
+    before: `<span style={{ wordBreak: "break-all" }}>{url}</span>`,
+    after: `{/* Table cells force text wrapping in Outlook and Yahoo */}
+<table width="100%" cellPadding={0} cellSpacing={0}
+  role="presentation" style={{ borderCollapse: "collapse" }}>
+  <tr>
+    <td style={{
+      wordBreak: "break-all" as const,
+      overflowWrap: "break-word" as const,
+      wordWrap: "break-word" as const,
+    }}>
+      {url}
+    </td>
+  </tr>
+</table>`
+  },
+  "word-break::mjml": {
+    language: "mjml",
+    description: "MJML renders text in table cells by default \u2014 word-break works via mj-text",
+    before: `<mj-text>
+  <span style="word-break: break-all;">Long URL here</span>
+</mj-text>`,
+    after: `<!-- mj-text already renders inside a <td>, so add word-break
+     to the mj-text css-class or inline style -->
+<mj-text css-class="break-words"
+  padding="0">
+  Long URL here
+</mj-text>
+<mj-style>
+  .break-words td { word-break: break-all; word-wrap: break-word; }
+</mj-style>`
+  },
+  // ── overflow-wrap → table cell wrapping ────────────────────────────────
+  "overflow-wrap": {
+    language: "html",
+    description: "Use a table cell to force word wrapping without overflow-wrap",
+    before: `<p style="overflow-wrap: break-word;">
+  https://example.com/very/long/url?token=abc123def456
+</p>`,
+    after: `<table role="presentation" width="100%" cellpadding="0"
+  cellspacing="0" border="0">
+  <tr>
+    <td style="overflow-wrap: break-word; word-wrap: break-word;
+               word-break: break-all;">
+      https://example.com/very/long/url?token=abc123def456
+    </td>
+  </tr>
+</table>`
+  },
+  "overflow-wrap::jsx": {
+    language: "jsx",
+    description: "Wrap text in a table cell for Outlook-safe overflow wrapping",
+    before: `<p style={{ overflowWrap: "break-word" }}>{longText}</p>`,
+    after: `<table width="100%" cellPadding={0} cellSpacing={0}
+  role="presentation" style={{ borderCollapse: "collapse" }}>
+  <tr>
+    <td style={{
+      overflowWrap: "break-word" as const,
+      wordWrap: "break-word" as const,
+      wordBreak: "break-all" as const,
+    }}>
+      {longText}
+    </td>
+  </tr>
+</table>`
+  },
+  // ── text-shadow → border/font-weight alternative ───────────────────────
+  "text-shadow": {
+    language: "css",
+    description: "Use font-weight or border-bottom as alternatives to text-shadow",
+    before: `.glow {
+  text-shadow: 0 0 10px rgba(255, 255, 255, 0.5);
+}`,
+    after: `.glow {
+  /* text-shadow is not supported in Gmail, Outlook, Yahoo.
+     Use font-weight or letter-spacing for emphasis instead. */
+  font-weight: bold;
+  letter-spacing: 0.5px;
+}`
+  },
+  // ── border-spacing → cellspacing attribute ─────────────────────────────
+  "border-spacing": {
+    language: "html",
+    description: "Use the cellspacing HTML attribute instead of border-spacing CSS",
+    before: `<table style="border-spacing: 8px; border-collapse: separate;">
+  <tr><td>Cell</td></tr>
+</table>`,
+    after: `<table cellspacing="8" style="border-collapse: separate;">
+  <tr><td>Cell</td></tr>
+</table>`
+  },
+  // ── min-width → fixed width ────────────────────────────────────────────
+  "min-width": {
+    language: "html",
+    description: "Use a fixed width instead of min-width for Outlook compatibility",
+    before: `<td style="min-width: 200px;">Content</td>`,
+    after: `<!-- Outlook ignores min-width. Use a fixed width or a spacer. -->
+<td width="200" style="width: 200px;">Content</td>`
+  },
+  // ── min-height → fixed height ──────────────────────────────────────────
+  "min-height": {
+    language: "html",
+    description: "Use a fixed height or spacer instead of min-height",
+    before: `<td style="min-height: 100px;">Content</td>`,
+    after: `<!-- Outlook ignores min-height. Use height or a spacer image. -->
+<td height="100" style="height: 100px;">Content</td>`
+  },
+  // ── max-height → fixed height ──────────────────────────────────────────
+  "max-height": {
+    language: "html",
+    description: "Outlook ignores max-height \u2014 truncate content server-side",
+    before: `<div style="max-height: 200px; overflow: hidden;">
+  Long content...
+</div>`,
+    after: `<!-- Outlook ignores max-height. Truncate content server-side. -->
+<div style="height: 200px;">
+  Shortened content...
+  <a href="https://example.com/full">Read more</a>
 </div>`
   },
   // ── REACT EMAIL (jsx) framework-specific fixes ────────────────────────────
@@ -2074,6 +2437,8 @@ function getClientPrefix(clientId) {
   if (clientId.startsWith("outlook")) return null;
   if (clientId.startsWith("gmail")) return "gmail";
   if (clientId.startsWith("apple-mail")) return "apple";
+  if (clientId === "yahoo-mail") return "yahoo";
+  if (clientId === "samsung-mail") return "samsung";
   return null;
 }
 var SUGGESTION_DATABASE = {
@@ -2177,6 +2542,31 @@ var SUGGESTION_DATABASE = {
   "opacity::jsx": "Use solid colors. Opacity is not supported in many email clients.",
   "opacity::mjml": "Use solid colors. Most email clients don't support opacity.",
   "opacity::maizzle": "Use solid Tailwind color classes instead of opacity.",
+  // ── word-break ──────────────────────────────────────────────────────
+  "word-break": "Wrap long text in a <table><td> to force wrapping in clients that don't support word-break.",
+  "word-break::outlook": "Outlook's Word engine ignores word-break. Place text inside a <td> with a constrained width \u2014 tables always wrap.",
+  "word-break::jsx": "Wrap long text in a <table><tr><td> element. Outlook ignores wordBreak but respects table cell widths.",
+  "word-break::mjml": "mj-text renders inside a <td>, which helps. Add word-wrap: break-word to the td via mj-style.",
+  // ── overflow-wrap ──────────────────────────────────────────────────
+  "overflow-wrap": "Wrap text in a <table><td> to force wrapping. overflow-wrap is ignored by Outlook and unreliable in Yahoo.",
+  "overflow-wrap::jsx": "Wrap text in a <table><tr><td> element. Outlook ignores overflowWrap but respects table cell widths.",
+  // ── white-space ────────────────────────────────────────────────────
+  "white-space": "Outlook only supports 'normal' and 'nowrap'. Use &nbsp; for non-breaking spaces.",
+  // ── text-overflow ──────────────────────────────────────────────────
+  "text-overflow": "text-overflow requires overflow:hidden which is stripped by Gmail. Truncate content server-side.",
+  // ── vertical-align ─────────────────────────────────────────────────
+  "vertical-align": 'Use the valign HTML attribute on <td> elements for Outlook (e.g., valign="top").',
+  // ── border-spacing ─────────────────────────────────────────────────
+  "border-spacing": 'Use the cellspacing HTML attribute instead (e.g., <table cellspacing="8">).',
+  // ── min-width / min-height ─────────────────────────────────────────
+  "min-width": "Outlook ignores min-width. Use a fixed width attribute on <td> or <table>.",
+  "min-height": "Outlook ignores min-height. Use a fixed height or a spacer image.",
+  "max-height": "Outlook ignores max-height. Truncate content server-side or use a fixed height.",
+  // ── text-shadow ────────────────────────────────────────────────────
+  "text-shadow": "text-shadow is stripped by Gmail, Outlook, and Yahoo. Use font-weight for emphasis.",
+  // ── background-size / background-position ──────────────────────────
+  "background-size": "Not supported in many clients. Set image dimensions directly.",
+  "background-position": "Not supported in many clients. Use VML for positioning.",
   // ── Additional properties covered by transform helpers ────────────────
   "overflow": "Content will always be visible. Design accordingly.",
   "visibility": "Remove the element or use display:none as an alternative.",
@@ -2185,9 +2575,6 @@ var SUGGESTION_DATABASE = {
   "transition": "CSS transitions are not supported in email.",
   "box-sizing": "Account for padding in your width calculations (use padding on a nested element).",
   "object-fit": "Use width/height attributes on <img> directly.",
-  "max-height": "Use fixed height instead.",
-  "background-size": "Not supported in many clients. Set image dimensions directly.",
-  "background-position": "Not supported in many clients. Use VML for positioning.",
   "display": "Use tables for layout in email clients."
 };
 function getSuggestion(property, clientId, framework) {
@@ -2329,7 +2716,9 @@ function makeWarning(base, prop, clientId, framework) {
   const sug = getSuggestion(prop, clientId, framework);
   const fix = getCodeFix(prop, clientId, framework);
   const isFallback = framework && ((sug == null ? void 0 : sug.isGenericFallback) || fix && isCodeFixGenericFallback(prop, clientId, framework));
-  return __spreadValues(__spreadValues(__spreadValues(__spreadValues({}, base), sug ? { suggestion: sug.text } : {}), fix ? { fix } : {}), isFallback ? { fixIsGenericFallback: true } : {});
+  return __spreadProps(__spreadValues(__spreadValues(__spreadValues(__spreadValues({}, base), sug ? { suggestion: sug.text } : {}), fix ? { fix } : {}), isFallback ? { fixIsGenericFallback: true } : {}), {
+    fixType: STRUCTURAL_FIX_PROPERTIES.has(prop) ? "structural" : "css"
+  });
 }
 function transformGmail(html, clientId, framework) {
   const $ = cheerio.load(html);
@@ -2870,7 +3259,8 @@ function analyzeEmail(html, framework) {
           property: "<style>",
           message: `${client.name} strips <style> blocks. Styles must be inlined.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("<style>")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("<style>", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       } else if (support === "partial") {
         const sug = getSuggestion("<style>:partial", client.id, framework);
@@ -2881,7 +3271,8 @@ function analyzeEmail(html, framework) {
           property: "<style>",
           message: `${client.name} has partial <style> support (head only, with limitations). Inline styles recommended.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("<style>")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("<style>", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -2898,7 +3289,8 @@ function analyzeEmail(html, framework) {
           property: "<link>",
           message: `${client.name} does not support external stylesheets.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("<link>")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("<link>", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -2915,7 +3307,8 @@ function analyzeEmail(html, framework) {
           property: "<svg>",
           message: `${client.name} does not support inline SVG.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("<svg>")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("<svg>", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -2932,7 +3325,8 @@ function analyzeEmail(html, framework) {
           property: "<video>",
           message: `${client.name} does not support <video> elements.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("<video>")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("<video>", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -2949,7 +3343,8 @@ function analyzeEmail(html, framework) {
           property: "<form>",
           message: `${client.name} strips form elements.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("<form>")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("<form>", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -2994,7 +3389,8 @@ function analyzeEmail(html, framework) {
           property: "@font-face",
           message: `${client.name} does not support web fonts (@font-face).`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("@font-face")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("@font-face", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -3011,7 +3407,8 @@ function analyzeEmail(html, framework) {
           property: "@media",
           message: `${client.name} does not support @media queries.`,
           suggestion: sug.text,
-          fix
+          fix,
+          fixType: getFixType("@media")
         }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback("@media", client.id, framework)) ? { fixIsGenericFallback: true } : {}));
       }
     }
@@ -3050,7 +3447,8 @@ function analyzeEmail(html, framework) {
           severity: "warning",
           client: client.id,
           property: prop,
-          message: `${client.name} does not support "${prop}" in <style> blocks.`
+          message: `${client.name} does not support "${prop}" in <style> blocks.`,
+          fixType: getFixType(prop)
         });
       }
     }
@@ -3064,9 +3462,13 @@ function analyzeEmail(html, framework) {
   warnings.sort((a, b) => severityOrder[a.severity] - severityOrder[b.severity]);
   return warnings;
 }
+function getFixType(prop) {
+  return STRUCTURAL_FIX_PROPERTIES.has(prop) ? "structural" : "css";
+}
 function checkPropertySupport(prop, addWarning, framework) {
   const supportData = CSS_SUPPORT[prop];
   if (!supportData) return;
+  const fixType = getFixType(prop);
   for (const client of EMAIL_CLIENTS) {
     const support = supportData[client.id] || "unknown";
     if (support === "unsupported") {
@@ -3078,7 +3480,8 @@ function checkPropertySupport(prop, addWarning, framework) {
         property: prop,
         message: `${client.name} does not support "${prop}".`,
         suggestion: sug.text,
-        fix
+        fix,
+        fixType
       }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback(prop, client.id, framework)) ? { fixIsGenericFallback: true } : {}));
     } else if (support === "partial") {
       const sug = getSuggestion(prop, client.id, framework);
@@ -3089,7 +3492,8 @@ function checkPropertySupport(prop, addWarning, framework) {
         property: prop,
         message: `${client.name} has partial support for "${prop}".`,
         suggestion: sug.text,
-        fix
+        fix,
+        fixType
       }, framework && (sug.isGenericFallback || fix && isCodeFixGenericFallback(prop, client.id, framework)) ? { fixIsGenericFallback: true } : {}));
     }
   }
@@ -3311,8 +3715,13 @@ ${originalHtml}
 `;
       for (const w of group) {
         const clientName = (_f = (_e = getClient(w.client)) == null ? void 0 : _e.name) != null ? _f : w.client;
+        const fixTypeLabel = w.fixType === "structural" ? " [STRUCTURAL]" : "";
         issueSection += `
-- **${w.property}** (${clientName}): ${w.message}`;
+- **${w.property}** (${clientName})${fixTypeLabel}: ${w.message}`;
+        if (w.fixType === "structural") {
+          issueSection += `
+  - **Fix type: structural** \u2014 CSS-only changes will NOT work. HTML restructuring required.`;
+        }
         if (w.suggestion) {
           issueSection += `
   - Suggestion: ${w.suggestion}`;
@@ -3343,17 +3752,1005 @@ ${originalHtml}
   );
   return sections.join("\n\n");
 }
+
+// src/token-utils.ts
+var CHARS_PER_TOKEN = 3.5;
+var OUTPUT_RATIO = 1.3;
+var DEFAULT_SYSTEM_PROMPT_TOKENS = 250;
+async function estimateAiFixTokens(options) {
+  const _a = options, {
+    maxInputTokens = 16e3,
+    tokenCounter,
+    systemPromptTokens = DEFAULT_SYSTEM_PROMPT_TOKENS
+  } = _a, rest = __objRest(_a, [
+    "maxInputTokens",
+    "tokenCounter",
+    "systemPromptTokens"
+  ]);
+  const effectiveMaxTokens = maxInputTokens - systemPromptTokens;
+  const { warnings: finalWarnings, truncated, removed } = truncateWarnings(
+    rest.warnings,
+    rest.originalHtml,
+    effectiveMaxTokens,
+    rest.scope,
+    rest.selectedClientId
+  );
+  const prompt = generateFixPrompt(__spreadProps(__spreadValues({}, rest), { warnings: finalWarnings }));
+  const promptChars = prompt.length;
+  let promptTokens;
+  if (tokenCounter) {
+    const count = tokenCounter(prompt);
+    promptTokens = count instanceof Promise ? await count : count;
+  } else {
+    promptTokens = heuristicTokenCount(prompt);
+  }
+  const inputTokens = promptTokens + systemPromptTokens;
+  const estimatedOutputTokens = Math.ceil(
+    heuristicTokenCount(rest.originalHtml) * OUTPUT_RATIO
+  );
+  const structuralCount = finalWarnings.filter(
+    (w) => w.fixType === "structural"
+  ).length;
+  return {
+    inputTokens,
+    estimatedOutputTokens,
+    promptCharacters: promptChars,
+    htmlCharacters: rest.originalHtml.length,
+    warningCount: finalWarnings.length,
+    structuralCount,
+    truncated,
+    warningsRemoved: removed,
+    warnings: finalWarnings
+  };
+}
+function heuristicTokenCount(text) {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+function truncateWarnings(warnings, html, maxTokens, scope, selectedClientId) {
+  const originalCount = warnings.length;
+  const fullPromptEstimate = heuristicTokenCount(html) + heuristicTokenCount(
+    JSON.stringify(warnings)
+  ) + 500;
+  if (fullPromptEstimate <= maxTokens) {
+    return { warnings, truncated: false, removed: 0 };
+  }
+  let result = [...warnings];
+  const seen = /* @__PURE__ */ new Set();
+  result = result.filter((w) => {
+    const key = `${w.property}:${w.severity}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  if (estimateFits(result, html, maxTokens)) {
+    return { warnings: result, truncated: true, removed: originalCount - result.length };
+  }
+  result = result.filter((w) => w.severity !== "info");
+  if (estimateFits(result, html, maxTokens)) {
+    return { warnings: result, truncated: true, removed: originalCount - result.length };
+  }
+  result = result.filter((w) => w.fixType === "structural" || w.severity === "error");
+  if (estimateFits(result, html, maxTokens)) {
+    return { warnings: result, truncated: true, removed: originalCount - result.length };
+  }
+  result = result.map((w) => __spreadProps(__spreadValues({}, w), {
+    fix: w.fix ? __spreadProps(__spreadValues({}, w.fix), {
+      before: w.fix.before.length > 200 ? w.fix.before.slice(0, 200) + "\n/* ... truncated ... */" : w.fix.before,
+      after: w.fix.after.length > 200 ? w.fix.after.slice(0, 200) + "\n/* ... truncated ... */" : w.fix.after
+    }) : void 0
+  }));
+  return { warnings: result, truncated: true, removed: originalCount - result.length };
+}
+function estimateFits(warnings, html, maxTokens) {
+  const estimate = heuristicTokenCount(html) + heuristicTokenCount(JSON.stringify(warnings)) + 500;
+  return estimate <= maxTokens;
+}
+
+// src/ai-fix.ts
+async function generateAiFix(options) {
+  const _a = options, { provider, maxInputTokens = 16e3 } = _a, promptOptions = __objRest(_a, ["provider", "maxInputTokens"]);
+  const estimate = await estimateAiFixTokens(__spreadProps(__spreadValues({}, promptOptions), {
+    maxInputTokens
+  }));
+  const truncatedWarnings = estimate.warnings;
+  const prompt = generateFixPrompt(__spreadProps(__spreadValues({}, promptOptions), { warnings: truncatedWarnings }));
+  const structuralCount = countStructuralWarnings(
+    truncatedWarnings,
+    promptOptions.scope,
+    promptOptions.selectedClientId
+  );
+  const _b = estimate, { warnings: _discarded } = _b, tokenEstimate = __objRest(_b, ["warnings"]);
+  const response = await provider(prompt);
+  const code = extractCode(response);
+  return {
+    code,
+    prompt,
+    targetedWarnings: tokenEstimate.warningCount,
+    structuralCount,
+    tokenEstimate
+  };
+}
+var AI_FIX_SYSTEM_PROMPT = `You are an expert email developer specializing in cross-client HTML email compatibility. You fix emails to render correctly across all email clients.
+
+Rules:
+- Return ONLY the fixed code inside a single code fence. No explanations before or after.
+- Preserve all existing content, text, links, and visual design.
+- For structural issues (fixType: "structural"), you MUST restructure the HTML \u2014 CSS-only changes will not work.
+- Common structural patterns:
+  - word-break/overflow-wrap unsupported \u2192 wrap text in <table><tr><td> with constrained width
+  - display:flex/grid \u2192 convert to <table> layout (match the original column count and proportions)
+  - border-radius in Outlook \u2192 use VML <v:roundrect> with <!--[if mso]> conditionals
+  - background-image in Outlook \u2192 use VML <v:rect> with <v:fill>
+  - max-width in Outlook \u2192 wrap in <!--[if mso]><table width="N"> conditional
+  - position:absolute \u2192 use <table> cells for layout
+  - <svg> \u2192 replace with <img> pointing to a hosted PNG
+- For CSS-only issues (fixType: "css"), swap properties or add fallbacks.
+- Apply ALL fixes from the issues list \u2014 do not skip any.
+- Use the framework syntax specified (JSX/MJML/Maizzle/HTML).
+- For JSX: use camelCase style props, React Email components, and proper TypeScript types.
+- For MJML: use mj-* elements and attributes.
+- For Maizzle: use Tailwind CSS classes.`;
+function countStructuralWarnings(warnings, scope, selectedClientId) {
+  const filtered = scope === "current" && selectedClientId ? warnings.filter((w) => w.client === selectedClientId) : warnings;
+  return filtered.filter((w) => w.fixType === "structural").length;
+}
+function extractCode(response) {
+  const fencePattern = /```(?:[\w]*)\n([\s\S]*?)```/g;
+  let largest = null;
+  let match;
+  while ((match = fencePattern.exec(response)) !== null) {
+    const content = match[1].trim();
+    if (largest === null || content.length > largest.length) {
+      largest = content;
+    }
+  }
+  if (largest !== null) {
+    return largest;
+  }
+  return response.trim();
+}
+
+// src/spam-scorer.ts
+import * as cheerio4 from "cheerio";
+var SPAM_TRIGGER_PHRASES = [
+  "act now",
+  "limited time",
+  "click here",
+  "buy now",
+  "order now",
+  "don't miss",
+  "don't delete",
+  "urgent",
+  "congratulations",
+  "you've been selected",
+  "you've won",
+  "winner",
+  "free gift",
+  "risk free",
+  "no obligation",
+  "no cost",
+  "no fees",
+  "100% free",
+  "100% satisfied",
+  "double your money",
+  "earn extra cash",
+  "make money",
+  "cash bonus",
+  "as seen on",
+  "incredible deal",
+  "lowest price",
+  "once in a lifetime",
+  "special promotion",
+  "this isn't spam",
+  "what are you waiting for",
+  "apply now",
+  "sign up free",
+  "cancel anytime",
+  "no strings attached",
+  "no questions asked"
+];
+var URL_SHORTENERS = [
+  "bit.ly",
+  "tinyurl.com",
+  "t.co",
+  "goo.gl",
+  "ow.ly",
+  "is.gd",
+  "buff.ly",
+  "rebrand.ly",
+  "bl.ink",
+  "short.io",
+  "cutt.ly",
+  "rb.gy"
+];
+var WEIGHTS = {
+  "caps-ratio": 15,
+  "excessive-punctuation": 10,
+  "spam-phrases": 5,
+  "missing-unsubscribe": 15,
+  "hidden-text": 20,
+  "url-shortener": 10,
+  "image-only": 20,
+  "high-image-ratio": 10,
+  "deceptive-link": 15,
+  "all-caps-subject": 10
+};
+function extractVisibleText($) {
+  const clone = $.root().clone();
+  clone.find("script, style, head").remove();
+  return clone.text().replace(/\s+/g, " ").trim();
+}
+function checkCapsRatio(text) {
+  const words = text.split(/\s+/).filter((w) => w.length >= 3);
+  if (words.length < 5) return null;
+  const capsWords = words.filter((w) => w === w.toUpperCase() && /[A-Z]/.test(w));
+  const ratio = capsWords.length / words.length;
+  if (ratio > 0.2) {
+    return {
+      rule: "caps-ratio",
+      severity: "warning",
+      message: `${Math.round(ratio * 100)}% of words are ALL CAPS \u2014 spam filters flag excessive capitalization.`,
+      detail: `Found ${capsWords.length} of ${words.length} words in all caps.`
+    };
+  }
+  return null;
+}
+function checkExcessivePunctuation(text) {
+  const exclamations = (text.match(/!/g) || []).length;
+  const dollars = (text.match(/\$/g) || []).length;
+  const total = exclamations + dollars;
+  if (total > 5) {
+    return {
+      rule: "excessive-punctuation",
+      severity: "warning",
+      message: `Excessive special characters detected (${exclamations} "!", ${dollars} "$") \u2014 common spam trigger.`
+    };
+  }
+  return null;
+}
+function checkSpamPhrases(text) {
+  const lower = text.toLowerCase();
+  const found = [];
+  for (const phrase of SPAM_TRIGGER_PHRASES) {
+    if (lower.includes(phrase)) {
+      found.push({
+        rule: "spam-phrases",
+        severity: "info",
+        message: `Contains spam trigger phrase: "${phrase}"`
+      });
+    }
+  }
+  return found;
+}
+function checkUnsubscribe($) {
+  let hasUnsubscribe = false;
+  $("a").each((_, el) => {
+    const href = $(el).attr("href") || "";
+    const text = $(el).text().toLowerCase();
+    if (text.includes("unsubscribe") || href.toLowerCase().includes("unsubscribe") || text.includes("opt out") || text.includes("opt-out") || href.toLowerCase().includes("opt-out") || href.toLowerCase().includes("optout")) {
+      hasUnsubscribe = true;
+    }
+  });
+  if (!hasUnsubscribe) {
+    return {
+      rule: "missing-unsubscribe",
+      severity: "error",
+      message: "No unsubscribe link found \u2014 required by CAN-SPAM and GDPR. Most spam filters penalize this.",
+      detail: 'Add an <a> link with "unsubscribe" text or href.'
+    };
+  }
+  return null;
+}
+function checkHiddenText($) {
+  let found = false;
+  let detail = "";
+  $("[style]").each((_, el) => {
+    const style = ($(el).attr("style") || "").toLowerCase();
+    const text = $(el).text().trim();
+    if (!text) return;
+    if (/font-size\s*:\s*0(?:px|em|rem|pt)?(?:\s|;|$)/.test(style)) {
+      found = true;
+      detail = "font-size:0 on element with text content";
+      return false;
+    }
+    if (/visibility\s*:\s*hidden/.test(style)) {
+      found = true;
+      detail = "visibility:hidden on element with text content";
+      return false;
+    }
+    if (/display\s*:\s*none/.test(style)) {
+      found = true;
+      detail = "display:none on element with text content";
+      return false;
+    }
+  });
+  if (found) {
+    return {
+      rule: "hidden-text",
+      severity: "error",
+      message: "Hidden text detected \u2014 major spam filter red flag.",
+      detail
+    };
+  }
+  return null;
+}
+function checkUrlShorteners($) {
+  const issues = [];
+  const seen = /* @__PURE__ */ new Set();
+  $("a[href]").each((_, el) => {
+    const href = $(el).attr("href") || "";
+    for (const shortener of URL_SHORTENERS) {
+      if (href.includes(shortener) && !seen.has(shortener)) {
+        seen.add(shortener);
+        issues.push({
+          rule: "url-shortener",
+          severity: "warning",
+          message: `URL shortener detected (${shortener}) \u2014 spam filters distrust shortened links.`,
+          detail: href
+        });
+      }
+    }
+  });
+  return issues;
+}
+function checkImageToTextRatio($) {
+  const text = extractVisibleText($);
+  const images = $("img").length;
+  if (images === 0) return null;
+  if (text.length < 50 && images > 0) {
+    return {
+      rule: "image-only",
+      severity: "error",
+      message: `Image-heavy email with almost no text (${text.length} chars, ${images} images) \u2014 likely to be flagged as spam or clipped.`
+    };
+  }
+  const ratio = images / (text.length / 100);
+  if (ratio > 0.5 && images > 3) {
+    return {
+      rule: "high-image-ratio",
+      severity: "warning",
+      message: `High image-to-text ratio (${images} images for ${text.length} chars of text) \u2014 consider adding more text content.`
+    };
+  }
+  return null;
+}
+function checkDeceptiveLinks($) {
+  const issues = [];
+  $("a[href]").each((_, el) => {
+    const href = $(el).attr("href") || "";
+    const text = $(el).text().trim();
+    if (/^https?:\/\/\S+/i.test(text) || /^www\.\S+/i.test(text)) {
+      try {
+        const textDomain = new URL(
+          text.startsWith("www.") ? `https://${text}` : text
+        ).hostname.replace(/^www\./, "");
+        const hrefDomain = new URL(href).hostname.replace(/^www\./, "");
+        if (textDomain !== hrefDomain) {
+          issues.push({
+            rule: "deceptive-link",
+            severity: "error",
+            message: `Link text shows "${textDomain}" but links to "${hrefDomain}" \u2014 phishing red flag.`,
+            detail: `Text: ${text}
+Href: ${href}`
+          });
+        }
+      } catch (e) {
+      }
+    }
+  });
+  return issues;
+}
+function checkAllCapsTitle($) {
+  const title = $("title").text().trim();
+  if (title.length > 5 && title === title.toUpperCase() && /[A-Z]/.test(title)) {
+    return {
+      rule: "all-caps-subject",
+      severity: "warning",
+      message: "Email title/subject is ALL CAPS \u2014 common spam indicator."
+    };
+  }
+  return null;
+}
+function analyzeSpam(html) {
+  if (!html || !html.trim()) {
+    return { score: 100, level: "low", issues: [] };
+  }
+  const $ = cheerio4.load(html);
+  const text = extractVisibleText($);
+  const issues = [];
+  const capsIssue = checkCapsRatio(text);
+  if (capsIssue) issues.push(capsIssue);
+  const punctIssue = checkExcessivePunctuation(text);
+  if (punctIssue) issues.push(punctIssue);
+  issues.push(...checkSpamPhrases(text));
+  const unsubIssue = checkUnsubscribe($);
+  if (unsubIssue) issues.push(unsubIssue);
+  const hiddenIssue = checkHiddenText($);
+  if (hiddenIssue) issues.push(hiddenIssue);
+  issues.push(...checkUrlShorteners($));
+  const imageRatioIssue = checkImageToTextRatio($);
+  if (imageRatioIssue) issues.push(imageRatioIssue);
+  issues.push(...checkDeceptiveLinks($));
+  const capsTitle = checkAllCapsTitle($);
+  if (capsTitle) issues.push(capsTitle);
+  let penalty = 0;
+  const seenRules = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const count = (seenRules.get(issue.rule) || 0) + 1;
+    seenRules.set(issue.rule, count);
+    const weight = WEIGHTS[issue.rule] || 5;
+    if (issue.rule === "spam-phrases") {
+      if (count <= 5) penalty += weight;
+    } else if (issue.rule === "url-shortener" || issue.rule === "deceptive-link") {
+      if (count <= 2) penalty += weight;
+    } else {
+      penalty += weight;
+    }
+  }
+  const score = Math.max(0, Math.min(100, 100 - penalty));
+  const level = score >= 70 ? "low" : score >= 40 ? "medium" : "high";
+  return { score, level, issues };
+}
+
+// src/link-validator.ts
+import * as cheerio5 from "cheerio";
+var GENERIC_LINK_TEXT = /* @__PURE__ */ new Set([
+  "click here",
+  "here",
+  "read more",
+  "learn more",
+  "more",
+  "link",
+  "this link",
+  "click",
+  "tap here",
+  "this"
+]);
+function classifyHref(href) {
+  if (!href || !href.trim()) return "empty";
+  const h = href.trim().toLowerCase();
+  if (h.startsWith("https://")) return "https";
+  if (h.startsWith("http://")) return "http";
+  if (h.startsWith("mailto:")) return "mailto";
+  if (h.startsWith("tel:")) return "tel";
+  if (h.startsWith("#")) return "anchor";
+  if (h.startsWith("javascript:")) return "javascript";
+  if (h.startsWith("//")) return "protocol-relative";
+  return "other";
+}
+function isPlaceholderHref(href) {
+  const h = href.trim().toLowerCase();
+  return h === "#" || h === "" || h === "javascript:void(0)" || h === "javascript:;";
+}
+function validateLinks(html) {
+  if (!html || !html.trim()) {
+    return {
+      totalLinks: 0,
+      issues: [],
+      breakdown: { https: 0, http: 0, mailto: 0, tel: 0, anchor: 0, other: 0 }
+    };
+  }
+  const $ = cheerio5.load(html);
+  const issues = [];
+  const breakdown = { https: 0, http: 0, mailto: 0, tel: 0, anchor: 0, other: 0 };
+  const links = $("a");
+  const totalLinks = links.length;
+  if (totalLinks === 0) {
+    issues.push({
+      severity: "info",
+      rule: "no-links",
+      message: "Email contains no links"
+    });
+    return { totalLinks: 0, issues, breakdown };
+  }
+  links.each((_, el) => {
+    const href = $(el).attr("href") || "";
+    const text = $(el).text().trim();
+    const category = classifyHref(href);
+    switch (category) {
+      case "https":
+        breakdown.https++;
+        break;
+      case "http":
+        breakdown.http++;
+        break;
+      case "mailto":
+        breakdown.mailto++;
+        break;
+      case "tel":
+        breakdown.tel++;
+        break;
+      case "anchor":
+        breakdown.anchor++;
+        break;
+      default:
+        breakdown.other++;
+        break;
+    }
+    if (!href || !href.trim()) {
+      issues.push({
+        severity: "error",
+        rule: "empty-href",
+        message: "Link has no href attribute",
+        text: text.slice(0, 80) || "(no text)"
+      });
+      return;
+    }
+    if (category === "javascript" && !isPlaceholderHref(href)) {
+      issues.push({
+        severity: "error",
+        rule: "javascript-href",
+        message: "Link uses javascript: protocol",
+        href: href.slice(0, 100),
+        text: text.slice(0, 80) || "(no text)"
+      });
+      return;
+    }
+    if (isPlaceholderHref(href)) {
+      issues.push({
+        severity: "warning",
+        rule: "placeholder-href",
+        message: "Link has a placeholder href (# or javascript:void)",
+        href,
+        text: text.slice(0, 80) || "(no text)"
+      });
+      return;
+    }
+    if (category === "http") {
+      issues.push({
+        severity: "warning",
+        rule: "insecure-link",
+        message: "Link uses HTTP instead of HTTPS",
+        href: href.slice(0, 120),
+        text: text.slice(0, 80) || "(no text)"
+      });
+    }
+    if (text && GENERIC_LINK_TEXT.has(text.toLowerCase())) {
+      issues.push({
+        severity: "warning",
+        rule: "generic-link-text",
+        message: `Link text "${text}" is vague \u2014 use descriptive text for accessibility and engagement`,
+        href: href.slice(0, 120),
+        text
+      });
+    }
+    if (!text && !$(el).attr("aria-label") && !$(el).find("img[alt]").length) {
+      issues.push({
+        severity: "error",
+        rule: "empty-link-text",
+        message: "Link has no visible text or aria-label",
+        href: href.slice(0, 120)
+      });
+    }
+    if (category === "mailto" && href.trim().toLowerCase() === "mailto:") {
+      issues.push({
+        severity: "error",
+        rule: "empty-mailto",
+        message: "mailto: link has no email address",
+        href,
+        text: text.slice(0, 80) || "(no text)"
+      });
+    }
+    if (href.length > 2e3) {
+      issues.push({
+        severity: "info",
+        rule: "long-url",
+        message: "URL exceeds 2000 characters \u2014 may be truncated by some email clients",
+        href: href.slice(0, 120) + "...",
+        text: text.slice(0, 80) || "(no text)"
+      });
+    }
+  });
+  return { totalLinks, issues, breakdown };
+}
+
+// src/accessibility-checker.ts
+import * as cheerio6 from "cheerio";
+var GENERIC_LINK_TEXT2 = /* @__PURE__ */ new Set([
+  "click here",
+  "here",
+  "read more",
+  "learn more",
+  "more",
+  "link",
+  "this link",
+  "click",
+  "tap here",
+  "this"
+]);
+function describeElement($, el) {
+  var _a;
+  const tag = ((_a = el.tagName) == null ? void 0 : _a.toLowerCase()) || "unknown";
+  const src = $(el).attr("src");
+  const href = $(el).attr("href");
+  if (src) return `<${tag} src="${src.slice(0, 60)}${src.length > 60 ? "..." : ""}">`;
+  if (href) return `<${tag} href="${href.slice(0, 60)}${href.length > 60 ? "..." : ""}">`;
+  const text = $(el).text().trim().slice(0, 40);
+  if (text) return `<${tag}>${text}${$(el).text().trim().length > 40 ? "..." : ""}</${tag}>`;
+  return `<${tag}>`;
+}
+function checkLangAttribute($) {
+  const lang = $("html").attr("lang");
+  if (!lang || !lang.trim()) {
+    return {
+      severity: "error",
+      rule: "missing-lang",
+      message: "Missing lang attribute on <html> element",
+      details: 'Screen readers use the lang attribute to determine pronunciation. Add lang="en" (or appropriate language code).'
+    };
+  }
+  return null;
+}
+function checkTitle($) {
+  const title = $("title").text().trim();
+  if (!title) {
+    return {
+      severity: "warning",
+      rule: "missing-title",
+      message: "Missing or empty <title> element",
+      details: "The <title> helps screen readers identify the email content."
+    };
+  }
+  return null;
+}
+function checkImageAlt($) {
+  const issues = [];
+  $("img").each((_, el) => {
+    const alt = $(el).attr("alt");
+    const src = $(el).attr("src") || "";
+    const role = $(el).attr("role");
+    if (role === "presentation" || role === "none") return;
+    if (alt === void 0) {
+      issues.push({
+        severity: "error",
+        rule: "img-missing-alt",
+        message: "Image missing alt attribute",
+        element: describeElement($, el),
+        details: 'Every image must have an alt attribute. Use alt="" for decorative images.'
+      });
+    } else if (alt.trim() === "") {
+      const isLikelyContent = !src.includes("spacer") && !src.includes("pixel") && !src.includes("tracking") && !src.includes("1x1") && !src.includes("transparent");
+      if (isLikelyContent && ($(el).attr("width") || "0") !== "1") {
+        issues.push({
+          severity: "info",
+          rule: "img-empty-alt",
+          message: "Image has empty alt text \u2014 verify it is decorative",
+          element: describeElement($, el),
+          details: "Empty alt is correct for decorative images, but content images need descriptive alt text."
+        });
+      }
+    } else if (/\.(png|jpg|jpeg|gif|svg|webp|bmp)$/i.test(alt)) {
+      issues.push({
+        severity: "error",
+        rule: "img-filename-alt",
+        message: "Image alt text is a filename, not a description",
+        element: describeElement($, el),
+        details: `Alt "${alt}" should describe the image content, not the file name.`
+      });
+    }
+  });
+  return issues;
+}
+function checkLinkAccessibility($) {
+  const issues = [];
+  $("a").each((_, el) => {
+    const text = $(el).text().trim().toLowerCase();
+    const ariaLabel = $(el).attr("aria-label");
+    const title = $(el).attr("title");
+    const imgAlt = $(el).find("img").attr("alt");
+    if (!text && !ariaLabel && !title && !imgAlt) {
+      issues.push({
+        severity: "error",
+        rule: "link-no-accessible-name",
+        message: "Link has no accessible name",
+        element: describeElement($, el),
+        details: "Links need visible text, aria-label, or an image with alt text."
+      });
+      return;
+    }
+    if (text && GENERIC_LINK_TEXT2.has(text) && !ariaLabel) {
+      issues.push({
+        severity: "warning",
+        rule: "link-generic-text",
+        message: `Link text "${$(el).text().trim()}" is not descriptive`,
+        element: describeElement($, el),
+        details: "Screen readers often list links out of context. Use text that describes the destination."
+      });
+    }
+  });
+  return issues;
+}
+function checkTableAccessibility($) {
+  const issues = [];
+  $("table").each((_, el) => {
+    const role = $(el).attr("role");
+    const hasHeaders = $(el).find("th").length > 0;
+    const looksLikeLayout = !hasHeaders;
+    if (looksLikeLayout && role !== "presentation" && role !== "none") {
+      const nestedTables = $(el).find("table").length;
+      if (nestedTables > 0 || $(el).find("td").length > 2) {
+        issues.push({
+          severity: "info",
+          rule: "table-missing-role",
+          message: 'Layout table missing role="presentation"',
+          element: `<table> with ${$(el).find("td").length} cells`,
+          details: `Add role="presentation" to tables used for layout so screen readers don't announce them as data tables.`
+        });
+      }
+    }
+  });
+  return issues;
+}
+function checkColorContrast($) {
+  const issues = [];
+  let smallTextCount = 0;
+  $("[style]").each((_, el) => {
+    const style = $(el).attr("style") || "";
+    const fontSizeMatch = style.match(/font-size\s*:\s*(\d+(?:\.\d+)?)(px|pt)/i);
+    if (fontSizeMatch) {
+      const size = parseFloat(fontSizeMatch[1]);
+      const unit = fontSizeMatch[2].toLowerCase();
+      const pxSize = unit === "pt" ? size * 1.333 : size;
+      if (pxSize < 10 && pxSize > 0) {
+        smallTextCount++;
+        if (smallTextCount <= 3) {
+          issues.push({
+            severity: "warning",
+            rule: "small-text",
+            message: `Very small text (${fontSizeMatch[0].trim()})`,
+            element: describeElement($, el),
+            details: "Text smaller than 10px is difficult to read, especially on mobile devices."
+          });
+        }
+      }
+    }
+  });
+  if (smallTextCount > 3) {
+    issues.push({
+      severity: "warning",
+      rule: "small-text-multiple",
+      message: `${smallTextCount} elements with text smaller than 10px`,
+      details: "Consider using a minimum font size of 12-14px for readability."
+    });
+  }
+  return issues;
+}
+function checkSemanticStructure($) {
+  const issues = [];
+  const headings = [];
+  $("h1, h2, h3, h4, h5, h6").each((_, el) => {
+    const level = parseInt(el.tagName.replace(/h/i, ""), 10);
+    headings.push({ level, text: $(el).text().trim().slice(0, 60) });
+  });
+  for (let i = 1; i < headings.length; i++) {
+    const gap = headings[i].level - headings[i - 1].level;
+    if (gap > 1) {
+      issues.push({
+        severity: "info",
+        rule: "heading-skip",
+        message: `Heading level skipped: h${headings[i - 1].level} to h${headings[i].level}`,
+        details: "Skipped heading levels can confuse screen readers. Use sequential heading levels."
+      });
+      break;
+    }
+  }
+  return issues;
+}
+function checkAccessibility(html) {
+  if (!html || !html.trim()) {
+    return { score: 100, issues: [] };
+  }
+  const $ = cheerio6.load(html);
+  const issues = [];
+  const langIssue = checkLangAttribute($);
+  if (langIssue) issues.push(langIssue);
+  const titleIssue = checkTitle($);
+  if (titleIssue) issues.push(titleIssue);
+  issues.push(...checkImageAlt($));
+  issues.push(...checkLinkAccessibility($));
+  issues.push(...checkTableAccessibility($));
+  issues.push(...checkColorContrast($));
+  issues.push(...checkSemanticStructure($));
+  let penalty = 0;
+  for (const issue of issues) {
+    switch (issue.severity) {
+      case "error":
+        penalty += 12;
+        break;
+      case "warning":
+        penalty += 6;
+        break;
+      case "info":
+        penalty += 2;
+        break;
+    }
+  }
+  const score = Math.max(0, 100 - penalty);
+  return { score, issues };
+}
+
+// src/image-analyzer.ts
+import * as cheerio7 from "cheerio";
+var DATA_URI_WARN_BYTES = 100 * 1024;
+var TOTAL_DATA_URI_WARN_BYTES = 500 * 1024;
+var HIGH_IMAGE_COUNT = 10;
+function estimateBase64Bytes(dataUri) {
+  const commaIdx = dataUri.indexOf(",");
+  if (commaIdx === -1) return 0;
+  const payload = dataUri.slice(commaIdx + 1);
+  return Math.floor(payload.length * 3 / 4);
+}
+function isTrackingPixel(el) {
+  const width = el.attr("width");
+  const height = el.attr("height");
+  const style = (el.attr("style") || "").toLowerCase();
+  if (width === "1" && height === "1") return true;
+  if (width === "0" || height === "0") return true;
+  if (style.includes("display:none") || style.includes("display: none") || style.includes("visibility:hidden") || style.includes("visibility: hidden")) {
+    return true;
+  }
+  if (/width\s*:\s*1px/.test(style) && /height\s*:\s*1px/.test(style)) {
+    return true;
+  }
+  return false;
+}
+function truncateSrc(src, max = 60) {
+  if (src.startsWith("data:")) {
+    const semi = src.indexOf(";");
+    return semi > 0 ? src.slice(0, semi + 1) + "base64,..." : "data:...";
+  }
+  return src.length > max ? src.slice(0, max - 3) + "..." : src;
+}
+function analyzeImages(html) {
+  if (!html || !html.trim()) {
+    return { total: 0, totalDataUriBytes: 0, issues: [], images: [] };
+  }
+  const $ = cheerio7.load(html);
+  const issues = [];
+  const images = [];
+  let totalDataUriBytes = 0;
+  $("img").each((_, el) => {
+    var _a, _b, _c;
+    const img = $(el);
+    const src = img.attr("src") || "";
+    const alt = (_a = img.attr("alt")) != null ? _a : null;
+    const width = (_b = img.attr("width")) != null ? _b : null;
+    const height = (_c = img.attr("height")) != null ? _c : null;
+    const style = (img.attr("style") || "").toLowerCase();
+    const imgIssues = [];
+    const tracking = isTrackingPixel(img);
+    let dataUriBytes = 0;
+    if (src.startsWith("data:")) {
+      dataUriBytes = estimateBase64Bytes(src);
+      totalDataUriBytes += dataUriBytes;
+    }
+    if (tracking) {
+      images.push({
+        src: truncateSrc(src),
+        alt,
+        width,
+        height,
+        isTrackingPixel: true,
+        dataUriBytes,
+        issues: ["tracking-pixel"]
+      });
+      return;
+    }
+    if (!width && !height) {
+      const hasStyleWidth = /width\s*:/.test(style);
+      const hasStyleHeight = /height\s*:/.test(style);
+      if (!hasStyleWidth && !hasStyleHeight) {
+        imgIssues.push("missing-dimensions");
+        issues.push({
+          rule: "missing-dimensions",
+          severity: "warning",
+          message: "Image missing width/height attributes \u2014 causes layout shifts and Outlook rendering issues.",
+          src: truncateSrc(src)
+        });
+      }
+    }
+    if (dataUriBytes > DATA_URI_WARN_BYTES) {
+      const kb = Math.round(dataUriBytes / 1024);
+      imgIssues.push("large-data-uri");
+      issues.push({
+        rule: "large-data-uri",
+        severity: "warning",
+        message: `Data URI is ${kb}KB \u2014 consider hosting the image externally to reduce email size.`,
+        src: truncateSrc(src)
+      });
+    }
+    if (alt === null) {
+      imgIssues.push("missing-alt");
+      issues.push({
+        rule: "missing-alt",
+        severity: "warning",
+        message: "Image missing alt attribute \u2014 hurts deliverability and accessibility.",
+        src: truncateSrc(src)
+      });
+    }
+    if (src.toLowerCase().endsWith(".webp") || src.includes("image/webp")) {
+      imgIssues.push("webp-format");
+      issues.push({
+        rule: "webp-format",
+        severity: "info",
+        message: "WebP format detected \u2014 not supported by all email clients. Consider PNG or JPEG.",
+        src: truncateSrc(src)
+      });
+    }
+    if (src.toLowerCase().endsWith(".svg") || src.includes("image/svg")) {
+      imgIssues.push("svg-format");
+      issues.push({
+        rule: "svg-format",
+        severity: "info",
+        message: "SVG format detected \u2014 not supported by most email clients. Use PNG instead.",
+        src: truncateSrc(src)
+      });
+    }
+    if (!style.includes("display:block") && !style.includes("display: block")) {
+      imgIssues.push("missing-display-block");
+      issues.push({
+        rule: "missing-display-block",
+        severity: "info",
+        message: "Image without display:block \u2014 may cause unwanted gaps in Outlook.",
+        src: truncateSrc(src)
+      });
+    }
+    images.push({
+      src: truncateSrc(src),
+      alt,
+      width,
+      height,
+      isTrackingPixel: false,
+      dataUriBytes,
+      issues: imgIssues
+    });
+  });
+  const nonTrackingImages = images.filter((i) => !i.isTrackingPixel);
+  if (nonTrackingImages.length > HIGH_IMAGE_COUNT) {
+    issues.push({
+      rule: "high-image-count",
+      severity: "info",
+      message: `Email contains ${nonTrackingImages.length} images \u2014 heavy emails may be clipped or load slowly.`
+    });
+  }
+  const trackingPixels = images.filter((i) => i.isTrackingPixel);
+  if (trackingPixels.length > 0) {
+    issues.push({
+      rule: "tracking-pixel",
+      severity: "info",
+      message: `${trackingPixels.length} tracking pixel${trackingPixels.length > 1 ? "s" : ""} detected.`
+    });
+  }
+  if (totalDataUriBytes > TOTAL_DATA_URI_WARN_BYTES) {
+    const kb = Math.round(totalDataUriBytes / 1024);
+    issues.push({
+      rule: "total-data-uri-size",
+      severity: "warning",
+      message: `Total data URI size is ${kb}KB \u2014 consider hosting images externally to reduce email size.`
+    });
+  }
+  return { total: images.length, totalDataUriBytes, issues, images };
+}
 export {
+  AI_FIX_SYSTEM_PROMPT,
   EMAIL_CLIENTS,
+  STRUCTURAL_FIX_PROPERTIES,
   analyzeEmail,
+  analyzeImages,
+  analyzeSpam,
+  checkAccessibility,
   diffResults,
+  estimateAiFixTokens,
+  generateAiFix,
   generateCompatibilityScore,
   generateFixPrompt,
   getClient,
   getCodeFix,
   getSuggestion,
+  heuristicTokenCount,
   simulateDarkMode,
   transformForAllClients,
-  transformForClient
+  transformForClient,
+  validateLinks
 };
 //# sourceMappingURL=index.js.map