payload-plugin-newsletter 0.17.1 → 0.17.3

package/dist/index.cjs

@@ -2873,270 +2873,660 @@ var createSignoutEndpoint = (_config) => {
   };
 };
 
-// src/endpoints/broadcasts/send.ts
-init_types();
+// src/endpoints/broadcasts/index.ts
+var createBroadcastManagementEndpoints = (config) => {
+  return [];
+};
 
-// src/utils/auth.ts
-async function getAuthenticatedUser(req) {
-  try {
-    const me = await req.payload.find({
-      collection: "users",
-      where: {
-        id: {
-          equals: "me"
-          // Special value in Payload to get current user
-        }
-      },
-      limit: 1,
-      depth: 0
-    });
-    return me.docs[0] || null;
-  } catch {
-    return null;
-  }
-}
-async function requireAdmin(req, config) {
-  const user = await getAuthenticatedUser(req);
-  if (!user) {
-    return {
-      authorized: false,
-      error: "Authentication required"
-    };
-  }
-  if (!isAdmin(user, config)) {
-    return {
-      authorized: false,
-      error: "Admin access required"
-    };
+// src/endpoints/index.ts
+function createNewsletterEndpoints(config) {
+  const endpoints = [
+    createSubscribeEndpoint(config),
+    createUnsubscribeEndpoint(config)
+  ];
+  if (config.auth?.enabled !== false) {
+    endpoints.push(
+      createVerifyMagicLinkEndpoint(config),
+      createPreferencesEndpoint(config),
+      createUpdatePreferencesEndpoint(config),
+      createSigninEndpoint(config),
+      createMeEndpoint(config),
+      createSignoutEndpoint(config)
+    );
   }
-  return {
-    authorized: true,
-    user
-  };
+  endpoints.push(...createBroadcastManagementEndpoints(config));
+  return endpoints;
 }
 
-// src/utils/getBroadcastConfig.ts
-async function getBroadcastConfig(req, pluginConfig) {
-  try {
-    const settings = await req.payload.findGlobal({
-      slug: pluginConfig.settingsSlug || "newsletter-settings",
-      req
-    });
-    if (settings?.provider === "broadcast" && settings?.broadcastSettings) {
-      return {
-        apiUrl: settings.broadcastSettings.apiUrl || pluginConfig.providers?.broadcast?.apiUrl || "",
-        token: settings.broadcastSettings.token || pluginConfig.providers?.broadcast?.token || "",
-        fromAddress: settings.fromAddress || pluginConfig.providers?.broadcast?.fromAddress || "",
-        fromName: settings.fromName || pluginConfig.providers?.broadcast?.fromName || "",
-        replyTo: settings.replyTo || pluginConfig.providers?.broadcast?.replyTo
-      };
+// src/fields/newsletterScheduling.ts
+function createNewsletterSchedulingFields(config) {
+  const groupName = config.features?.newsletterScheduling?.fields?.groupName || "newsletterScheduling";
+  const contentField = config.features?.newsletterScheduling?.fields?.contentField || "content";
+  const createMarkdownField = config.features?.newsletterScheduling?.fields?.createMarkdownField !== false;
+  const fields = [
+    {
+      name: groupName,
+      type: "group",
+      label: "Newsletter Scheduling",
+      admin: {
+        condition: (data, { user }) => user?.collection === "users"
+        // Only show for admin users
+      },
+      fields: [
+        {
+          name: "scheduled",
+          type: "checkbox",
+          label: "Schedule for Newsletter",
+          defaultValue: false,
+          admin: {
+            description: "Schedule this content to be sent as a newsletter"
+          }
+        },
+        {
+          name: "scheduledDate",
+          type: "date",
+          label: "Send Date",
+          required: true,
+          admin: {
+            date: {
+              pickerAppearance: "dayAndTime"
+            },
+            condition: (data) => data?.[groupName]?.scheduled,
+            description: "When to send this newsletter"
+          }
+        },
+        {
+          name: "sentDate",
+          type: "date",
+          label: "Sent Date",
+          admin: {
+            readOnly: true,
+            condition: (data) => data?.[groupName]?.sendStatus === "sent",
+            description: "When this newsletter was sent"
+          }
+        },
+        {
+          name: "sendStatus",
+          type: "select",
+          label: "Status",
+          options: [
+            { label: "Draft", value: "draft" },
+            { label: "Scheduled", value: "scheduled" },
+            { label: "Sending", value: "sending" },
+            { label: "Sent", value: "sent" },
+            { label: "Failed", value: "failed" }
+          ],
+          defaultValue: "draft",
+          admin: {
+            readOnly: true,
+            description: "Current send status"
+          }
+        },
+        {
+          name: "emailSubject",
+          type: "text",
+          label: "Email Subject",
+          required: true,
+          admin: {
+            condition: (data) => data?.[groupName]?.scheduled,
+            description: "Subject line for the newsletter email"
+          }
+        },
+        {
+          name: "preheader",
+          type: "text",
+          label: "Email Preheader",
+          admin: {
+            condition: (data) => data?.[groupName]?.scheduled,
+            description: "Preview text that appears after the subject line"
+          }
+        },
+        {
+          name: "segments",
+          type: "select",
+          label: "Target Segments",
+          hasMany: true,
+          options: [
+            { label: "All Subscribers", value: "all" },
+            ...config.i18n?.locales?.map((locale) => ({
+              label: `${locale.toUpperCase()} Subscribers`,
+              value: locale
+            })) || []
+          ],
+          defaultValue: ["all"],
+          admin: {
+            condition: (data) => data?.[groupName]?.scheduled,
+            description: "Which subscriber segments to send to"
+          }
+        },
+        {
+          name: "testEmails",
+          type: "array",
+          label: "Test Email Recipients",
+          admin: {
+            condition: (data) => data?.[groupName]?.scheduled && data?.[groupName]?.sendStatus === "draft",
+            description: "Send test emails before scheduling"
+          },
+          fields: [
+            {
+              name: "email",
+              type: "email",
+              required: true
+            }
+          ]
+        }
+      ]
     }
-    return pluginConfig.providers?.broadcast || null;
-  } catch (error) {
-    req.payload.logger.error("Failed to get broadcast config from settings:", error);
-    return pluginConfig.providers?.broadcast || null;
+  ];
+  if (createMarkdownField) {
+    fields.push(createMarkdownFieldInternal({
+      name: `${contentField}Markdown`,
+      richTextField: contentField,
+      label: "Email Content (Markdown)",
+      admin: {
+        position: "sidebar",
+        condition: (data) => Boolean(data?.[contentField] && data?.[groupName]?.scheduled),
+        description: "Markdown version for email rendering",
+        readOnly: true
+      }
+    }));
   }
+  return fields;
 }
-
-// src/endpoints/broadcasts/send.ts
-var createSendBroadcastEndpoint = (config, collectionSlug) => {
+function createMarkdownFieldInternal(config) {
   return {
-    path: `/${collectionSlug}/:id/send`,
-    method: "post",
-    handler: async (req) => {
-      try {
-        const auth = await requireAdmin(req, config);
-        if (!auth.authorized) {
-          return Response.json({
-            success: false,
-            error: auth.error
-          }, { status: 401 });
+    name: config.name,
+    type: "textarea",
+    label: config.label || "Markdown",
+    admin: {
+      ...config.admin,
+      description: config.admin?.description || "Auto-generated from rich text content"
+    },
+    hooks: {
+      afterRead: [
+        async ({ data }) => {
+          if (data?.[config.richTextField]) {
+            try {
+              const { convertLexicalToMarkdown } = await import("@payloadcms/richtext-lexical");
+              return convertLexicalToMarkdown({
+                data: data[config.richTextField]
+              });
+            } catch {
+              return "";
+            }
+          }
+          return "";
         }
-        if (!config.features?.newsletterManagement?.enabled) {
-          return Response.json({
-            success: false,
-            error: "Broadcast management is not enabled"
-          }, { status: 400 });
+      ],
+      beforeChange: [
+        () => {
+          return null;
         }
-        const url = new URL(req.url || "", `http://localhost`);
-        const pathParts = url.pathname.split("/");
-        const id = pathParts[pathParts.length - 2];
-        if (!id) {
-          return Response.json({
-            success: false,
-            error: "Broadcast ID is required"
-          }, { status: 400 });
-        }
-        const data = await (req.json?.() || Promise.resolve({}));
-        const broadcastDoc = await req.payload.findByID({
-          collection: collectionSlug,
-          id,
-          user: auth.user
-        });
-        if (!broadcastDoc || !broadcastDoc.providerId) {
-          return Response.json({
-            success: false,
-            error: "Broadcast not found or not synced with provider"
-          }, { status: 404 });
-        }
-        const providerConfig = await getBroadcastConfig(req, config);
-        if (!providerConfig || !providerConfig.token) {
-          return Response.json({
-            success: false,
-            error: "Broadcast provider not configured in Newsletter Settings or environment variables"
-          }, { status: 500 });
-        }
-        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
-        const provider = new BroadcastApiProvider2(providerConfig);
-        const broadcast = await provider.send(broadcastDoc.providerId, data);
-        await req.payload.update({
-          collection: collectionSlug,
-          id,
-          data: {
-            sendStatus: "sending" /* SENDING */,
-            sentAt: (/* @__PURE__ */ new Date()).toISOString()
-          },
-          user: auth.user
-        });
-        return Response.json({
-          success: true,
-          message: "Broadcast sent successfully",
-          broadcast
-        });
-      } catch (error) {
-        console.error("Failed to send broadcast:", error);
-        if (error instanceof NewsletterProviderError) {
-          return Response.json({
-            success: false,
-            error: error.message,
-            code: error.code
-          }, { status: error.code === "NOT_SUPPORTED" ? 501 : 500 });
-        }
-        return Response.json({
-          success: false,
-          error: "Failed to send broadcast"
-        }, { status: 500 });
-      }
+      ]
     }
   };
-};
+}
 
-// src/endpoints/broadcasts/schedule.ts
-init_types();
-var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
+// src/jobs/sync-unsubscribes.ts
+var createUnsubscribeSyncJob = (pluginConfig) => {
   return {
-    path: `/${collectionSlug}/:id/schedule`,
-    method: "post",
-    handler: async (req) => {
+    slug: "sync-unsubscribes",
+    label: "Sync Unsubscribes from Email Service",
+    handler: async ({ req }) => {
+      const subscribersSlug = pluginConfig.subscribersSlug || "subscribers";
+      const emailService = req.payload.newsletterEmailService;
+      if (!emailService) {
+        console.error("Email service not configured");
+        return {
+          output: {
+            syncedCount: 0
+          }
+        };
+      }
+      let syncedCount = 0;
       try {
-        const auth = await requireAdmin(req, config);
-        if (!auth.authorized) {
-          return Response.json({
-            success: false,
-            error: auth.error
-          }, { status: 401 });
-        }
-        if (!config.features?.newsletterManagement?.enabled) {
-          return Response.json({
-            success: false,
-            error: "Broadcast management is not enabled"
-          }, { status: 400 });
-        }
-        const url = new URL(req.url || "", `http://localhost`);
-        const pathParts = url.pathname.split("/");
-        const id = pathParts[pathParts.length - 2];
-        if (!id) {
-          return Response.json({
-            success: false,
-            error: "Broadcast ID is required"
-          }, { status: 400 });
-        }
-        const data = await (req.json?.() || Promise.resolve({}));
-        const { scheduledAt } = data;
-        if (!scheduledAt) {
-          return Response.json({
-            success: false,
-            error: "scheduledAt is required"
-          }, { status: 400 });
-        }
-        const scheduledDate = new Date(scheduledAt);
-        if (isNaN(scheduledDate.getTime())) {
-          return Response.json({
-            success: false,
-            error: "Invalid scheduledAt date"
-          }, { status: 400 });
-        }
-        if (scheduledDate <= /* @__PURE__ */ new Date()) {
-          return Response.json({
-            success: false,
-            error: "scheduledAt must be in the future"
-          }, { status: 400 });
+        if (emailService.getProvider() === "broadcast") {
+          console.warn("Starting Broadcast unsubscribe sync...");
+          const broadcastConfig = pluginConfig.providers?.broadcast;
+          if (!broadcastConfig) {
+            throw new Error("Broadcast configuration not found");
+          }
+          const apiUrl = broadcastConfig.apiUrl.replace(/\/$/, "");
+          const token = broadcastConfig.token;
+          let page = 1;
+          let hasMore = true;
+          while (hasMore) {
+            const response = await fetch(
+              `${apiUrl}/api/v1/subscribers.json?page=${page}`,
+              {
+                headers: {
+                  "Authorization": `Bearer ${token}`
+                }
+              }
+            );
+            if (!response.ok) {
+              throw new Error(`Broadcast API error: ${response.status}`);
+            }
+            const data = await response.json();
+            const broadcastSubscribers = data.subscribers || [];
+            for (const broadcastSub of broadcastSubscribers) {
+              const payloadSubscribers = await req.payload.find({
+                collection: subscribersSlug,
+                where: {
+                  email: {
+                    equals: broadcastSub.email
+                  }
+                },
+                limit: 1
+              });
+              if (payloadSubscribers.docs.length > 0) {
+                const payloadSub = payloadSubscribers.docs[0];
+                const broadcastUnsubscribed = !broadcastSub.is_active || broadcastSub.unsubscribed_at;
+                const payloadUnsubscribed = payloadSub.subscriptionStatus === "unsubscribed";
+                if (broadcastUnsubscribed && !payloadUnsubscribed) {
+                  await req.payload.update({
+                    collection: subscribersSlug,
+                    id: payloadSub.id,
+                    data: {
+                      subscriptionStatus: "unsubscribed",
+                      unsubscribedAt: broadcastSub.unsubscribed_at || (/* @__PURE__ */ new Date()).toISOString()
+                    }
+                  });
+                  syncedCount++;
+                  console.warn(`Unsubscribed: ${broadcastSub.email}`);
+                }
+              }
+            }
+            if (data.pagination && data.pagination.current < data.pagination.total_pages) {
+              page++;
+            } else {
+              hasMore = false;
+            }
+          }
+          console.warn(`Broadcast sync complete. Unsubscribed ${syncedCount} contacts.`);
         }
-        const broadcastDoc = await req.payload.findByID({
-          collection: collectionSlug,
-          id,
-          user: auth.user
-        });
-        if (!broadcastDoc || !broadcastDoc.providerId) {
-          return Response.json({
-            success: false,
-            error: "Broadcast not found or not synced with provider"
-          }, { status: 404 });
+        if (emailService.getProvider() === "resend") {
+          console.warn("Starting Resend unsubscribe sync...");
+          const resendConfig = pluginConfig.providers?.resend;
+          if (!resendConfig) {
+            throw new Error("Resend configuration not found");
+          }
+          console.warn("Resend polling implementation needed - webhooks recommended");
         }
-        const providerConfig = config.providers?.broadcast;
-        if (!providerConfig) {
-          return Response.json({
-            success: false,
-            error: "Broadcast provider not configured"
-          }, { status: 500 });
+        if (pluginConfig.hooks?.afterUnsubscribeSync) {
+          await pluginConfig.hooks.afterUnsubscribeSync({
+            req,
+            syncedCount
+          });
         }
-        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
-        const provider = new BroadcastApiProvider2(providerConfig);
-        const broadcast = await provider.schedule(broadcastDoc.providerId, scheduledDate);
-        await req.payload.update({
-          collection: collectionSlug,
-          id,
-          data: {
-            sendStatus: "scheduled" /* SCHEDULED */,
-            scheduledAt: scheduledDate.toISOString()
-          },
-          user: auth.user
-        });
-        return Response.json({
-          success: true,
-          message: `Broadcast scheduled for ${scheduledDate.toISOString()}`,
-          broadcast
-        });
       } catch (error) {
-        console.error("Failed to schedule broadcast:", error);
-        if (error instanceof NewsletterProviderError) {
-          return Response.json({
-            success: false,
-            error: error.message,
-            code: error.code
-          }, { status: error.code === "NOT_SUPPORTED" ? 501 : 500 });
-        }
-        return Response.json({
-          success: false,
-          error: "Failed to schedule broadcast"
-        }, { status: 500 });
+        console.error("Unsubscribe sync error:", error);
+        throw error;
       }
+      return {
+        output: {
+          syncedCount
+        }
+      };
     }
   };
 };
 
-// src/utils/emailSafeHtml.ts
-var import_isomorphic_dompurify2 = __toESM(require("isomorphic-dompurify"), 1);
-var EMAIL_SAFE_CONFIG = {
-  ALLOWED_TAGS: [
-    "p",
-    "br",
-    "strong",
-    "b",
-    "em",
-    "i",
-    "u",
-    "strike",
+// src/collections/Broadcasts.ts
+init_types();
+
+// src/fields/emailContent.ts
+var import_richtext_lexical = require("@payloadcms/richtext-lexical");
+
+// src/utils/blockValidation.ts
+var EMAIL_INCOMPATIBLE_TYPES = [
+  "chart",
+  "dataTable",
+  "interactive",
+  "streamable",
+  "video",
+  "iframe",
+  "form",
+  "carousel",
+  "tabs",
+  "accordion",
+  "map"
+];
+var validateEmailBlocks = (blocks) => {
+  blocks.forEach((block) => {
+    if (EMAIL_INCOMPATIBLE_TYPES.includes(block.slug)) {
+      console.warn(`\u26A0\uFE0F  Block "${block.slug}" may not be email-compatible. Consider creating an email-specific version.`);
+    }
+    const hasComplexFields = block.fields?.some((field) => {
+      const complexTypes = ["code", "json", "richText", "blocks", "array"];
+      return complexTypes.includes(field.type);
+    });
+    if (hasComplexFields) {
+      console.warn(`\u26A0\uFE0F  Block "${block.slug}" contains complex field types that may not render consistently in email clients.`);
+    }
+  });
+};
+var createEmailSafeBlocks = (customBlocks = []) => {
+  validateEmailBlocks(customBlocks);
+  const baseBlocks = [
+    {
+      slug: "button",
+      fields: [
+        {
+          name: "text",
+          type: "text",
+          label: "Button Text",
+          required: true
+        },
+        {
+          name: "url",
+          type: "text",
+          label: "Button URL",
+          required: true,
+          admin: {
+            description: "Enter the full URL (including https://)"
+          }
+        },
+        {
+          name: "style",
+          type: "select",
+          label: "Button Style",
+          defaultValue: "primary",
+          options: [
+            { label: "Primary", value: "primary" },
+            { label: "Secondary", value: "secondary" },
+            { label: "Outline", value: "outline" }
+          ]
+        }
+      ],
+      interfaceName: "EmailButton",
+      labels: {
+        singular: "Button",
+        plural: "Buttons"
+      }
+    },
+    {
+      slug: "divider",
+      fields: [
+        {
+          name: "style",
+          type: "select",
+          label: "Divider Style",
+          defaultValue: "solid",
+          options: [
+            { label: "Solid", value: "solid" },
+            { label: "Dashed", value: "dashed" },
+            { label: "Dotted", value: "dotted" }
+          ]
+        }
+      ],
+      interfaceName: "EmailDivider",
+      labels: {
+        singular: "Divider",
+        plural: "Dividers"
+      }
+    }
+  ];
+  return [
+    ...baseBlocks,
+    ...customBlocks
+  ];
+};
+
+// src/fields/emailContent.ts
+var createEmailSafeFeatures = (additionalBlocks) => {
+  const baseBlocks = [
+    {
+      slug: "button",
+      fields: [
+        {
+          name: "text",
+          type: "text",
+          label: "Button Text",
+          required: true
+        },
+        {
+          name: "url",
+          type: "text",
+          label: "Button URL",
+          required: true,
+          admin: {
+            description: "Enter the full URL (including https://)"
+          }
+        },
+        {
+          name: "style",
+          type: "select",
+          label: "Button Style",
+          defaultValue: "primary",
+          options: [
+            { label: "Primary", value: "primary" },
+            { label: "Secondary", value: "secondary" },
+            { label: "Outline", value: "outline" }
+          ]
+        }
+      ],
+      interfaceName: "EmailButton",
+      labels: {
+        singular: "Button",
+        plural: "Buttons"
+      }
+    },
+    {
+      slug: "divider",
+      fields: [
+        {
+          name: "style",
+          type: "select",
+          label: "Divider Style",
+          defaultValue: "solid",
+          options: [
+            { label: "Solid", value: "solid" },
+            { label: "Dashed", value: "dashed" },
+            { label: "Dotted", value: "dotted" }
+          ]
+        }
+      ],
+      interfaceName: "EmailDivider",
+      labels: {
+        singular: "Divider",
+        plural: "Dividers"
+      }
+    }
+  ];
+  const allBlocks = [
+    ...baseBlocks,
+    ...additionalBlocks || []
+  ];
+  return [
+    // Toolbars
+    (0, import_richtext_lexical.FixedToolbarFeature)(),
+    // Fixed toolbar at the top
+    (0, import_richtext_lexical.InlineToolbarFeature)(),
+    // Floating toolbar when text is selected
+    // Basic text formatting
+    (0, import_richtext_lexical.BoldFeature)(),
+    (0, import_richtext_lexical.ItalicFeature)(),
+    (0, import_richtext_lexical.UnderlineFeature)(),
+    (0, import_richtext_lexical.StrikethroughFeature)(),
+    // Links with enhanced configuration
+    (0, import_richtext_lexical.LinkFeature)({
+      fields: [
+        {
+          name: "url",
+          type: "text",
+          required: true,
+          admin: {
+            description: "Enter the full URL (including https://)"
+          }
+        },
+        {
+          name: "newTab",
+          type: "checkbox",
+          label: "Open in new tab",
+          defaultValue: false
+        }
+      ]
+    }),
+    // Lists
+    (0, import_richtext_lexical.OrderedListFeature)(),
+    (0, import_richtext_lexical.UnorderedListFeature)(),
+    // Headings - limited to h1, h2, h3 for email compatibility
+    (0, import_richtext_lexical.HeadingFeature)({
+      enabledHeadingSizes: ["h1", "h2", "h3"]
+    }),
+    // Basic paragraph and alignment
+    (0, import_richtext_lexical.ParagraphFeature)(),
+    (0, import_richtext_lexical.AlignFeature)(),
+    // Blockquotes
+    (0, import_richtext_lexical.BlockquoteFeature)(),
+    // Upload feature for images
+    (0, import_richtext_lexical.UploadFeature)({
+      collections: {
+        media: {
+          fields: [
+            {
+              name: "caption",
+              type: "text",
+              admin: {
+                description: "Optional caption for the image"
+              }
+            },
+            {
+              name: "altText",
+              type: "text",
+              label: "Alt Text",
+              required: true,
+              admin: {
+                description: "Alternative text for accessibility and when image cannot be displayed"
+              }
+            }
+          ]
+        }
+      }
+    }),
+    // Custom blocks for email-specific content
+    (0, import_richtext_lexical.BlocksFeature)({
+      blocks: allBlocks
+    })
+  ];
+};
+var createEmailLexicalEditor = (customBlocks = []) => {
+  const emailSafeBlocks = createEmailSafeBlocks(customBlocks);
+  return (0, import_richtext_lexical.lexicalEditor)({
+    features: [
+      // Toolbars
+      (0, import_richtext_lexical.FixedToolbarFeature)(),
+      (0, import_richtext_lexical.InlineToolbarFeature)(),
+      // Basic text formatting
+      (0, import_richtext_lexical.BoldFeature)(),
+      (0, import_richtext_lexical.ItalicFeature)(),
+      (0, import_richtext_lexical.UnderlineFeature)(),
+      (0, import_richtext_lexical.StrikethroughFeature)(),
+      // Links with enhanced configuration
+      (0, import_richtext_lexical.LinkFeature)({
+        fields: [
+          {
+            name: "url",
+            type: "text",
+            required: true,
+            admin: {
+              description: "Enter the full URL (including https://)"
+            }
+          },
+          {
+            name: "newTab",
+            type: "checkbox",
+            label: "Open in new tab",
+            defaultValue: false
+          }
+        ]
+      }),
+      // Lists
+      (0, import_richtext_lexical.OrderedListFeature)(),
+      (0, import_richtext_lexical.UnorderedListFeature)(),
+      // Headings - limited to h1, h2, h3 for email compatibility
+      (0, import_richtext_lexical.HeadingFeature)({
+        enabledHeadingSizes: ["h1", "h2", "h3"]
+      }),
+      // Basic paragraph and alignment
+      (0, import_richtext_lexical.ParagraphFeature)(),
+      (0, import_richtext_lexical.AlignFeature)(),
+      // Blockquotes
+      (0, import_richtext_lexical.BlockquoteFeature)(),
+      // Upload feature for images
+      (0, import_richtext_lexical.UploadFeature)({
+        collections: {
+          media: {
+            fields: [
+              {
+                name: "caption",
+                type: "text",
+                admin: {
+                  description: "Optional caption for the image"
+                }
+              },
+              {
+                name: "altText",
+                type: "text",
+                label: "Alt Text",
+                required: true,
+                admin: {
+                  description: "Alternative text for accessibility and when image cannot be displayed"
+                }
+              }
+            ]
+          }
+        }
+      }),
+      // Email-safe blocks (processed server-side)
+      (0, import_richtext_lexical.BlocksFeature)({
+        blocks: emailSafeBlocks
+      })
+    ]
+  });
+};
+var emailSafeFeatures = createEmailSafeFeatures();
+var createEmailContentField = (overrides) => {
+  const editor = overrides?.editor || createEmailLexicalEditor(overrides?.additionalBlocks);
+  return {
+    name: "content",
+    type: "richText",
+    required: true,
+    editor,
+    admin: {
+      description: "Email content with limited formatting for compatibility",
+      ...overrides?.admin
+    },
+    ...overrides
+  };
+};
+
+// src/fields/broadcastInlinePreview.ts
+var createBroadcastInlinePreviewField = () => {
+  return {
+    name: "broadcastInlinePreview",
+    type: "ui",
+    admin: {
+      components: {
+        Field: "payload-plugin-newsletter/components#BroadcastInlinePreview"
+      }
+    }
+  };
+};
+
+// src/utils/emailSafeHtml.ts
+var import_isomorphic_dompurify2 = __toESM(require("isomorphic-dompurify"), 1);
+var EMAIL_SAFE_CONFIG = {
+  ALLOWED_TAGS: [
+    "p",
+    "br",
+    "strong",
+    "b",
+    "em",
+    "i",
+    "u",
+    "strike",
     "s",
     "span",
     "a",
@@ -3403,819 +3793,420 @@ function getAlignment(format) {
 function escapeHtml(text) {
   const map = {
     "&": "&amp;",
-    "<": "&lt;",
-    ">": "&gt;",
-    '"': "&quot;",
-    "'": "&#039;"
-  };
-  return text.replace(/[&<>"']/g, (m) => map[m]);
-}
-function wrapInEmailTemplate(content, preheader) {
-  return `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Email</title>
-  <!--[if mso]>
-  <noscript>
-    <xml>
-      <o:OfficeDocumentSettings>
-        <o:PixelsPerInch>96</o:PixelsPerInch>
-      </o:OfficeDocumentSettings>
-    </xml>
-  </noscript>
-  <![endif]-->
-</head>
-<body style="margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial, sans-serif; font-size: 16px; line-height: 1.5; color: #333333; background-color: #f3f4f6;">
-  ${preheader ? `<div style="display: none; max-height: 0; overflow: hidden;">${escapeHtml(preheader)}</div>` : ""}
-  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="margin: 0; padding: 0;">
-    <tr>
-      <td align="center" style="padding: 20px 0;">
-        <table role="presentation" cellpadding="0" cellspacing="0" width="600" style="margin: 0 auto; background-color: #ffffff; border-radius: 8px; overflow: hidden;">
-          <tr>
-            <td style="padding: 40px 30px;">
-              ${content}
-            </td>
-          </tr>
-        </table>
-      </td>
-    </tr>
-  </table>
-</body>
-</html>`;
-}
-
-// src/endpoints/broadcasts/test.ts
-var createTestBroadcastEndpoint = (config, collectionSlug) => {
-  return {
-    path: `/${collectionSlug}/:id/test`,
-    method: "post",
-    handler: async (req) => {
-      try {
-        const auth = await requireAdmin(req, config);
-        if (!auth.authorized) {
-          return Response.json({
-            success: false,
-            error: auth.error
-          }, { status: 401 });
-        }
-        const url = new URL(req.url || "", `http://localhost`);
-        const pathParts = url.pathname.split("/");
-        const id = pathParts[pathParts.length - 2];
-        if (!id) {
-          return Response.json({
-            success: false,
-            error: "Broadcast ID is required"
-          }, { status: 400 });
-        }
-        const data = await (req.json?.() || Promise.resolve({}));
-        const testEmail = data.email || auth.user.email;
-        if (!testEmail) {
-          return Response.json({
-            success: false,
-            error: "No email address available for test send"
-          }, { status: 400 });
-        }
-        const broadcast = await req.payload.findByID({
-          collection: collectionSlug,
-          id,
-          user: auth.user
-        });
-        if (!broadcast) {
-          return Response.json({
-            success: false,
-            error: "Broadcast not found"
-          }, { status: 404 });
-        }
-        const htmlContent = await convertToEmailSafeHtml(broadcast.content, {
-          wrapInTemplate: true,
-          preheader: broadcast.preheader,
-          customBlockConverter: config.customizations?.broadcasts?.customBlockConverter
-        });
-        const emailService = req.payload.newsletterEmailService;
-        if (!emailService) {
-          return Response.json({
-            success: false,
-            error: "Email service is not configured"
-          }, { status: 500 });
-        }
-        const providerConfig = config.providers.default === "resend" ? config.providers.resend : config.providers.broadcast;
-        const fromEmail = providerConfig?.fromAddress || providerConfig?.fromEmail || "noreply@example.com";
-        const fromName = providerConfig?.fromName || "Newsletter";
-        const replyTo = broadcast.settings?.replyTo || providerConfig?.replyTo;
-        await emailService.send({
-          to: testEmail,
-          from: fromEmail,
-          fromName,
-          replyTo,
-          subject: `[TEST] ${broadcast.subject}`,
-          html: htmlContent,
-          trackOpens: false,
-          trackClicks: false
-        });
-        return Response.json({
-          success: true,
-          message: `Test email sent to ${testEmail}`
-        });
-      } catch (error) {
-        console.error("Failed to send test broadcast:", error);
-        return Response.json({
-          success: false,
-          error: "Failed to send test email"
-        }, { status: 500 });
-      }
-    }
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#039;"
   };
-};
+  return text.replace(/[&<>"']/g, (m) => map[m]);
+}
+function wrapInEmailTemplate(content, preheader) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Email</title>
+  <!--[if mso]>
+  <noscript>
+    <xml>
+      <o:OfficeDocumentSettings>
+        <o:PixelsPerInch>96</o:PixelsPerInch>
+      </o:OfficeDocumentSettings>
+    </xml>
+  </noscript>
+  <![endif]-->
+</head>
+<body style="margin: 0; padding: 0; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial, sans-serif; font-size: 16px; line-height: 1.5; color: #333333; background-color: #f3f4f6;">
+  ${preheader ? `<div style="display: none; max-height: 0; overflow: hidden;">${escapeHtml(preheader)}</div>` : ""}
+  <table role="presentation" cellpadding="0" cellspacing="0" width="100%" style="margin: 0; padding: 0;">
+    <tr>
+      <td align="center" style="padding: 20px 0;">
+        <table role="presentation" cellpadding="0" cellspacing="0" width="600" style="margin: 0 auto; background-color: #ffffff; border-radius: 8px; overflow: hidden;">
+          <tr>
+            <td style="padding: 40px 30px;">
+              ${content}
+            </td>
+          </tr>
+        </table>
+      </td>
+    </tr>
+  </table>
+</body>
+</html>`;
+}
 
-// src/endpoints/broadcasts/preview.ts
-var createBroadcastPreviewEndpoint = (config, collectionSlug) => {
-  return {
-    path: `/${collectionSlug}/preview`,
-    method: "post",
-    handler: async (req) => {
-      try {
-        const data = await (req.json?.() || Promise.resolve({}));
-        const { content, preheader, subject } = data;
-        if (!content) {
-          return Response.json({
-            success: false,
-            error: "Content is required for preview"
-          }, { status: 400 });
-        }
-        const mediaUrl = req.payload.config.serverURL ? `${req.payload.config.serverURL}/api/media` : "/api/media";
-        const htmlContent = await convertToEmailSafeHtml(content, {
-          wrapInTemplate: true,
-          preheader,
-          mediaUrl,
-          customBlockConverter: config.customizations?.broadcasts?.customBlockConverter
-        });
-        return Response.json({
-          success: true,
-          preview: {
-            subject: subject || "Preview",
-            preheader: preheader || "",
-            html: htmlContent
-          }
-        });
-      } catch (error) {
-        console.error("Failed to generate email preview:", error);
-        return Response.json({
-          success: false,
-          error: "Failed to generate email preview"
-        }, { status: 500 });
-      }
+// src/utils/getBroadcastConfig.ts
+async function getBroadcastConfig(req, pluginConfig) {
+  try {
+    const settings = await req.payload.findGlobal({
+      slug: pluginConfig.settingsSlug || "newsletter-settings",
+      req
+    });
+    if (settings?.provider === "broadcast" && settings?.broadcastSettings) {
+      return {
+        apiUrl: settings.broadcastSettings.apiUrl || pluginConfig.providers?.broadcast?.apiUrl || "",
+        token: settings.broadcastSettings.token || pluginConfig.providers?.broadcast?.token || "",
+        fromAddress: settings.fromAddress || pluginConfig.providers?.broadcast?.fromAddress || "",
+        fromName: settings.fromName || pluginConfig.providers?.broadcast?.fromName || "",
+        replyTo: settings.replyTo || pluginConfig.providers?.broadcast?.replyTo
+      };
     }
-  };
-};
-
-// src/endpoints/broadcasts/index.ts
-var createBroadcastManagementEndpoints = (config) => {
-  if (!config.features?.newsletterManagement?.enabled) {
-    return [];
-  }
-  const collectionSlug = config.features.newsletterManagement.collections?.broadcasts || "broadcasts";
-  return [
-    createSendBroadcastEndpoint(config, collectionSlug),
-    createScheduleBroadcastEndpoint(config, collectionSlug),
-    createTestBroadcastEndpoint(config, collectionSlug),
-    createBroadcastPreviewEndpoint(config, collectionSlug)
-  ];
-};
-
-// src/endpoints/index.ts
-function createNewsletterEndpoints(config) {
-  const endpoints = [
-    createSubscribeEndpoint(config),
-    createUnsubscribeEndpoint(config)
-  ];
-  if (config.auth?.enabled !== false) {
-    endpoints.push(
-      createVerifyMagicLinkEndpoint(config),
-      createPreferencesEndpoint(config),
-      createUpdatePreferencesEndpoint(config),
-      createSigninEndpoint(config),
-      createMeEndpoint(config),
-      createSignoutEndpoint(config)
-    );
+    return pluginConfig.providers?.broadcast || null;
+  } catch (error) {
+    req.payload.logger.error("Failed to get broadcast config from settings:", error);
+    return pluginConfig.providers?.broadcast || null;
   }
-  endpoints.push(...createBroadcastManagementEndpoints(config));
-  return endpoints;
 }
 
-// src/fields/newsletterScheduling.ts
-function createNewsletterSchedulingFields(config) {
-  const groupName = config.features?.newsletterScheduling?.fields?.groupName || "newsletterScheduling";
-  const contentField = config.features?.newsletterScheduling?.fields?.contentField || "content";
-  const createMarkdownField = config.features?.newsletterScheduling?.fields?.createMarkdownField !== false;
-  const fields = [
-    {
-      name: groupName,
-      type: "group",
-      label: "Newsletter Scheduling",
-      admin: {
-        condition: (data, { user }) => user?.collection === "users"
-        // Only show for admin users
-      },
-      fields: [
-        {
-          name: "scheduled",
-          type: "checkbox",
-          label: "Schedule for Newsletter",
-          defaultValue: false,
-          admin: {
-            description: "Schedule this content to be sent as a newsletter"
-          }
-        },
-        {
-          name: "scheduledDate",
-          type: "date",
-          label: "Send Date",
-          required: true,
-          admin: {
-            date: {
-              pickerAppearance: "dayAndTime"
-            },
-            condition: (data) => data?.[groupName]?.scheduled,
-            description: "When to send this newsletter"
-          }
-        },
-        {
-          name: "sentDate",
-          type: "date",
-          label: "Sent Date",
-          admin: {
-            readOnly: true,
-            condition: (data) => data?.[groupName]?.sendStatus === "sent",
-            description: "When this newsletter was sent"
-          }
-        },
-        {
-          name: "sendStatus",
-          type: "select",
-          label: "Status",
-          options: [
-            { label: "Draft", value: "draft" },
-            { label: "Scheduled", value: "scheduled" },
-            { label: "Sending", value: "sending" },
-            { label: "Sent", value: "sent" },
-            { label: "Failed", value: "failed" }
-          ],
-          defaultValue: "draft",
-          admin: {
-            readOnly: true,
-            description: "Current send status"
-          }
-        },
-        {
-          name: "emailSubject",
-          type: "text",
-          label: "Email Subject",
-          required: true,
-          admin: {
-            condition: (data) => data?.[groupName]?.scheduled,
-            description: "Subject line for the newsletter email"
-          }
-        },
-        {
-          name: "preheader",
-          type: "text",
-          label: "Email Preheader",
-          admin: {
-            condition: (data) => data?.[groupName]?.scheduled,
-            description: "Preview text that appears after the subject line"
-          }
-        },
-        {
-          name: "segments",
-          type: "select",
-          label: "Target Segments",
-          hasMany: true,
-          options: [
-            { label: "All Subscribers", value: "all" },
-            ...config.i18n?.locales?.map((locale) => ({
-              label: `${locale.toUpperCase()} Subscribers`,
-              value: locale
-            })) || []
-          ],
-          defaultValue: ["all"],
-          admin: {
-            condition: (data) => data?.[groupName]?.scheduled,
-            description: "Which subscriber segments to send to"
-          }
-        },
-        {
-          name: "testEmails",
-          type: "array",
-          label: "Test Email Recipients",
-          admin: {
-            condition: (data) => data?.[groupName]?.scheduled && data?.[groupName]?.sendStatus === "draft",
-            description: "Send test emails before scheduling"
-          },
-          fields: [
-            {
-              name: "email",
-              type: "email",
-              required: true
-            }
-          ]
-        }
-      ]
-    }
-  ];
-  if (createMarkdownField) {
-    fields.push(createMarkdownFieldInternal({
-      name: `${contentField}Markdown`,
-      richTextField: contentField,
-      label: "Email Content (Markdown)",
-      admin: {
-        position: "sidebar",
-        condition: (data) => Boolean(data?.[contentField] && data?.[groupName]?.scheduled),
-        description: "Markdown version for email rendering",
-        readOnly: true
-      }
-    }));
+// src/endpoints/broadcasts/send.ts
+init_types();
+
+// src/utils/auth.ts
+async function getAuthenticatedUser(req) {
+  try {
+    const me = await req.payload.find({
+      collection: "users",
+      where: {
+        id: {
+          equals: "me"
+          // Special value in Payload to get current user
+        }
+      },
+      limit: 1,
+      depth: 0
+    });
+    return me.docs[0] || null;
+  } catch {
+    return null;
   }
-  return fields;
 }
-function createMarkdownFieldInternal(config) {
+async function requireAdmin(req, config) {
+  const user = await getAuthenticatedUser(req);
+  if (!user) {
+    return {
+      authorized: false,
+      error: "Authentication required"
+    };
+  }
+  if (!isAdmin(user, config)) {
+    return {
+      authorized: false,
+      error: "Admin access required"
+    };
+  }
   return {
-    name: config.name,
-    type: "textarea",
-    label: config.label || "Markdown",
-    admin: {
-      ...config.admin,
-      description: config.admin?.description || "Auto-generated from rich text content"
-    },
-    hooks: {
-      afterRead: [
-        async ({ data }) => {
-          if (data?.[config.richTextField]) {
-            try {
-              const { convertLexicalToMarkdown } = await import("@payloadcms/richtext-lexical");
-              return convertLexicalToMarkdown({
-                data: data[config.richTextField]
-              });
-            } catch {
-              return "";
-            }
-          }
-          return "";
-        }
-      ],
-      beforeChange: [
-        () => {
-          return null;
-        }
-      ]
-    }
+    authorized: true,
+    user
   };
 }
 
-// src/jobs/sync-unsubscribes.ts
-var createUnsubscribeSyncJob = (pluginConfig) => {
+// src/endpoints/broadcasts/send.ts
+var createSendBroadcastEndpoint = (config, collectionSlug) => {
   return {
-    slug: "sync-unsubscribes",
-    label: "Sync Unsubscribes from Email Service",
-    handler: async ({ req }) => {
-      const subscribersSlug = pluginConfig.subscribersSlug || "subscribers";
-      const emailService = req.payload.newsletterEmailService;
-      if (!emailService) {
-        console.error("Email service not configured");
-        return {
-          output: {
-            syncedCount: 0
-          }
-        };
-      }
-      let syncedCount = 0;
+    path: "/:id/send",
+    method: "post",
+    handler: async (req) => {
       try {
-        if (emailService.getProvider() === "broadcast") {
-          console.warn("Starting Broadcast unsubscribe sync...");
-          const broadcastConfig = pluginConfig.providers?.broadcast;
-          if (!broadcastConfig) {
-            throw new Error("Broadcast configuration not found");
-          }
-          const apiUrl = broadcastConfig.apiUrl.replace(/\/$/, "");
-          const token = broadcastConfig.token;
-          let page = 1;
-          let hasMore = true;
-          while (hasMore) {
-            const response = await fetch(
-              `${apiUrl}/api/v1/subscribers.json?page=${page}`,
-              {
-                headers: {
-                  "Authorization": `Bearer ${token}`
-                }
-              }
-            );
-            if (!response.ok) {
-              throw new Error(`Broadcast API error: ${response.status}`);
-            }
-            const data = await response.json();
-            const broadcastSubscribers = data.subscribers || [];
-            for (const broadcastSub of broadcastSubscribers) {
-              const payloadSubscribers = await req.payload.find({
-                collection: subscribersSlug,
-                where: {
-                  email: {
-                    equals: broadcastSub.email
-                  }
-                },
-                limit: 1
-              });
-              if (payloadSubscribers.docs.length > 0) {
-                const payloadSub = payloadSubscribers.docs[0];
-                const broadcastUnsubscribed = !broadcastSub.is_active || broadcastSub.unsubscribed_at;
-                const payloadUnsubscribed = payloadSub.subscriptionStatus === "unsubscribed";
-                if (broadcastUnsubscribed && !payloadUnsubscribed) {
-                  await req.payload.update({
-                    collection: subscribersSlug,
-                    id: payloadSub.id,
-                    data: {
-                      subscriptionStatus: "unsubscribed",
-                      unsubscribedAt: broadcastSub.unsubscribed_at || (/* @__PURE__ */ new Date()).toISOString()
-                    }
-                  });
-                  syncedCount++;
-                  console.warn(`Unsubscribed: ${broadcastSub.email}`);
-                }
-              }
-            }
-            if (data.pagination && data.pagination.current < data.pagination.total_pages) {
-              page++;
-            } else {
-              hasMore = false;
-            }
-          }
-          console.warn(`Broadcast sync complete. Unsubscribed ${syncedCount} contacts.`);
-        }
-        if (emailService.getProvider() === "resend") {
-          console.warn("Starting Resend unsubscribe sync...");
-          const resendConfig = pluginConfig.providers?.resend;
-          if (!resendConfig) {
-            throw new Error("Resend configuration not found");
-          }
-          console.warn("Resend polling implementation needed - webhooks recommended");
+        const auth = await requireAdmin(req, config);
+        if (!auth.authorized) {
+          return Response.json({
+            success: false,
+            error: auth.error
+          }, { status: 401 });
         }
-        if (pluginConfig.hooks?.afterUnsubscribeSync) {
-          await pluginConfig.hooks.afterUnsubscribeSync({
-            req,
-            syncedCount
-          });
+        if (!config.features?.newsletterManagement?.enabled) {
+          return Response.json({
+            success: false,
+            error: "Broadcast management is not enabled"
+          }, { status: 400 });
         }
-      } catch (error) {
-        console.error("Unsubscribe sync error:", error);
-        throw error;
-      }
-      return {
-        output: {
-          syncedCount
+        const url = new URL(req.url || "", `http://localhost`);
+        const pathParts = url.pathname.split("/");
+        const id = pathParts[pathParts.length - 2];
+        if (!id) {
+          return Response.json({
+            success: false,
+            error: "Broadcast ID is required"
+          }, { status: 400 });
         }
-      };
-    }
-  };
-};
-
-// src/collections/Broadcasts.ts
-init_types();
-
-// src/fields/emailContent.ts
-var import_richtext_lexical = require("@payloadcms/richtext-lexical");
-
-// src/utils/blockValidation.ts
-var EMAIL_INCOMPATIBLE_TYPES = [
-  "chart",
-  "dataTable",
-  "interactive",
-  "streamable",
-  "video",
-  "iframe",
-  "form",
-  "carousel",
-  "tabs",
-  "accordion",
-  "map"
-];
-var validateEmailBlocks = (blocks) => {
-  blocks.forEach((block) => {
-    if (EMAIL_INCOMPATIBLE_TYPES.includes(block.slug)) {
-      console.warn(`\u26A0\uFE0F  Block "${block.slug}" may not be email-compatible. Consider creating an email-specific version.`);
-    }
-    const hasComplexFields = block.fields?.some((field) => {
-      const complexTypes = ["code", "json", "richText", "blocks", "array"];
-      return complexTypes.includes(field.type);
-    });
-    if (hasComplexFields) {
-      console.warn(`\u26A0\uFE0F  Block "${block.slug}" contains complex field types that may not render consistently in email clients.`);
-    }
-  });
-};
-var createEmailSafeBlocks = (customBlocks = []) => {
-  validateEmailBlocks(customBlocks);
-  const baseBlocks = [
-    {
-      slug: "button",
-      fields: [
-        {
-          name: "text",
-          type: "text",
-          label: "Button Text",
-          required: true
-        },
-        {
-          name: "url",
-          type: "text",
-          label: "Button URL",
-          required: true,
-          admin: {
-            description: "Enter the full URL (including https://)"
-          }
-        },
-        {
-          name: "style",
-          type: "select",
-          label: "Button Style",
-          defaultValue: "primary",
-          options: [
-            { label: "Primary", value: "primary" },
-            { label: "Secondary", value: "secondary" },
-            { label: "Outline", value: "outline" }
-          ]
+        const data = await (req.json?.() || Promise.resolve({}));
+        const broadcastDoc = await req.payload.findByID({
+          collection: collectionSlug,
+          id,
+          user: auth.user
+        });
+        if (!broadcastDoc || !broadcastDoc.providerId) {
+          return Response.json({
+            success: false,
+            error: "Broadcast not found or not synced with provider"
+          }, { status: 404 });
         }
-      ],
-      interfaceName: "EmailButton",
-      labels: {
-        singular: "Button",
-        plural: "Buttons"
-      }
-    },
-    {
-      slug: "divider",
-      fields: [
-        {
-          name: "style",
-          type: "select",
-          label: "Divider Style",
-          defaultValue: "solid",
-          options: [
-            { label: "Solid", value: "solid" },
-            { label: "Dashed", value: "dashed" },
-            { label: "Dotted", value: "dotted" }
-          ]
+        const providerConfig = await getBroadcastConfig(req, config);
+        if (!providerConfig || !providerConfig.token) {
+          return Response.json({
+            success: false,
+            error: "Broadcast provider not configured in Newsletter Settings or environment variables"
+          }, { status: 500 });
         }
-      ],
-      interfaceName: "EmailDivider",
-      labels: {
-        singular: "Divider",
-        plural: "Dividers"
+        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+        const provider = new BroadcastApiProvider2(providerConfig);
+        const broadcast = await provider.send(broadcastDoc.providerId, data);
+        await req.payload.update({
+          collection: collectionSlug,
+          id,
+          data: {
+            sendStatus: "sending" /* SENDING */,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          user: auth.user
+        });
+        return Response.json({
+          success: true,
+          message: "Broadcast sent successfully",
+          broadcast
+        });
+      } catch (error) {
+        console.error("Failed to send broadcast:", error);
+        if (error instanceof NewsletterProviderError) {
+          return Response.json({
+            success: false,
+            error: error.message,
+            code: error.code
+          }, { status: error.code === "NOT_SUPPORTED" ? 501 : 500 });
+        }
+        return Response.json({
+          success: false,
+          error: "Failed to send broadcast"
+        }, { status: 500 });
       }
     }
-  ];
-  return [
-    ...baseBlocks,
-    ...customBlocks
-  ];
+  };
 };
 
-// src/fields/emailContent.ts
-var createEmailSafeFeatures = (additionalBlocks) => {
-  const baseBlocks = [
-    {
-      slug: "button",
-      fields: [
-        {
-          name: "text",
-          type: "text",
-          label: "Button Text",
-          required: true
-        },
-        {
-          name: "url",
-          type: "text",
-          label: "Button URL",
-          required: true,
-          admin: {
-            description: "Enter the full URL (including https://)"
-          }
-        },
-        {
-          name: "style",
-          type: "select",
-          label: "Button Style",
-          defaultValue: "primary",
-          options: [
-            { label: "Primary", value: "primary" },
-            { label: "Secondary", value: "secondary" },
-            { label: "Outline", value: "outline" }
-          ]
+// src/endpoints/broadcasts/schedule.ts
+init_types();
+var createScheduleBroadcastEndpoint = (config, collectionSlug) => {
+  return {
+    path: "/:id/schedule",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const auth = await requireAdmin(req, config);
+        if (!auth.authorized) {
+          return Response.json({
+            success: false,
+            error: auth.error
+          }, { status: 401 });
         }
-      ],
-      interfaceName: "EmailButton",
-      labels: {
-        singular: "Button",
-        plural: "Buttons"
-      }
-    },
-    {
-      slug: "divider",
-      fields: [
-        {
-          name: "style",
-          type: "select",
-          label: "Divider Style",
-          defaultValue: "solid",
-          options: [
-            { label: "Solid", value: "solid" },
-            { label: "Dashed", value: "dashed" },
-            { label: "Dotted", value: "dotted" }
-          ]
+        if (!config.features?.newsletterManagement?.enabled) {
+          return Response.json({
+            success: false,
+            error: "Broadcast management is not enabled"
+          }, { status: 400 });
         }
-      ],
-      interfaceName: "EmailDivider",
-      labels: {
-        singular: "Divider",
-        plural: "Dividers"
-      }
-    }
-  ];
-  const allBlocks = [
-    ...baseBlocks,
-    ...additionalBlocks || []
-  ];
-  return [
-    // Toolbars
-    (0, import_richtext_lexical.FixedToolbarFeature)(),
-    // Fixed toolbar at the top
-    (0, import_richtext_lexical.InlineToolbarFeature)(),
-    // Floating toolbar when text is selected
-    // Basic text formatting
-    (0, import_richtext_lexical.BoldFeature)(),
-    (0, import_richtext_lexical.ItalicFeature)(),
-    (0, import_richtext_lexical.UnderlineFeature)(),
-    (0, import_richtext_lexical.StrikethroughFeature)(),
-    // Links with enhanced configuration
-    (0, import_richtext_lexical.LinkFeature)({
-      fields: [
-        {
-          name: "url",
-          type: "text",
-          required: true,
-          admin: {
-            description: "Enter the full URL (including https://)"
-          }
-        },
-        {
-          name: "newTab",
-          type: "checkbox",
-          label: "Open in new tab",
-          defaultValue: false
+        const url = new URL(req.url || "", `http://localhost`);
+        const pathParts = url.pathname.split("/");
+        const id = pathParts[pathParts.length - 2];
+        if (!id) {
+          return Response.json({
+            success: false,
+            error: "Broadcast ID is required"
+          }, { status: 400 });
         }
-      ]
-    }),
-    // Lists
-    (0, import_richtext_lexical.OrderedListFeature)(),
-    (0, import_richtext_lexical.UnorderedListFeature)(),
-    // Headings - limited to h1, h2, h3 for email compatibility
-    (0, import_richtext_lexical.HeadingFeature)({
-      enabledHeadingSizes: ["h1", "h2", "h3"]
-    }),
-    // Basic paragraph and alignment
-    (0, import_richtext_lexical.ParagraphFeature)(),
-    (0, import_richtext_lexical.AlignFeature)(),
-    // Blockquotes
-    (0, import_richtext_lexical.BlockquoteFeature)(),
-    // Upload feature for images
-    (0, import_richtext_lexical.UploadFeature)({
-      collections: {
-        media: {
-          fields: [
-            {
-              name: "caption",
-              type: "text",
-              admin: {
-                description: "Optional caption for the image"
-              }
-            },
-            {
-              name: "altText",
-              type: "text",
-              label: "Alt Text",
-              required: true,
-              admin: {
-                description: "Alternative text for accessibility and when image cannot be displayed"
-              }
-            }
-          ]
+        const data = await (req.json?.() || Promise.resolve({}));
+        const { scheduledAt } = data;
+        if (!scheduledAt) {
+          return Response.json({
+            success: false,
+            error: "scheduledAt is required"
+          }, { status: 400 });
+        }
+        const scheduledDate = new Date(scheduledAt);
+        if (isNaN(scheduledDate.getTime())) {
+          return Response.json({
+            success: false,
+            error: "Invalid scheduledAt date"
+          }, { status: 400 });
+        }
+        if (scheduledDate <= /* @__PURE__ */ new Date()) {
+          return Response.json({
+            success: false,
+            error: "scheduledAt must be in the future"
+          }, { status: 400 });
+        }
+        const broadcastDoc = await req.payload.findByID({
+          collection: collectionSlug,
+          id,
+          user: auth.user
+        });
+        if (!broadcastDoc || !broadcastDoc.providerId) {
+          return Response.json({
+            success: false,
+            error: "Broadcast not found or not synced with provider"
+          }, { status: 404 });
         }
-      }
-    }),
-    // Custom blocks for email-specific content
-    (0, import_richtext_lexical.BlocksFeature)({
-      blocks: allBlocks
-    })
-  ];
-};
-var createEmailLexicalEditor = (customBlocks = []) => {
-  const emailSafeBlocks = createEmailSafeBlocks(customBlocks);
-  return (0, import_richtext_lexical.lexicalEditor)({
-    features: [
-      // Toolbars
-      (0, import_richtext_lexical.FixedToolbarFeature)(),
-      (0, import_richtext_lexical.InlineToolbarFeature)(),
-      // Basic text formatting
-      (0, import_richtext_lexical.BoldFeature)(),
-      (0, import_richtext_lexical.ItalicFeature)(),
-      (0, import_richtext_lexical.UnderlineFeature)(),
-      (0, import_richtext_lexical.StrikethroughFeature)(),
-      // Links with enhanced configuration
-      (0, import_richtext_lexical.LinkFeature)({
-        fields: [
-          {
-            name: "url",
-            type: "text",
-            required: true,
-            admin: {
-              description: "Enter the full URL (including https://)"
-            }
+        const providerConfig = config.providers?.broadcast;
+        if (!providerConfig) {
+          return Response.json({
+            success: false,
+            error: "Broadcast provider not configured"
+          }, { status: 500 });
+        }
+        const { BroadcastApiProvider: BroadcastApiProvider2 } = await Promise.resolve().then(() => (init_broadcast2(), broadcast_exports));
+        const provider = new BroadcastApiProvider2(providerConfig);
+        const broadcast = await provider.schedule(broadcastDoc.providerId, scheduledDate);
+        await req.payload.update({
+          collection: collectionSlug,
+          id,
+          data: {
+            sendStatus: "scheduled" /* SCHEDULED */,
+            scheduledAt: scheduledDate.toISOString()
           },
-          {
-            name: "newTab",
-            type: "checkbox",
-            label: "Open in new tab",
-            defaultValue: false
-          }
-        ]
-      }),
-      // Lists
-      (0, import_richtext_lexical.OrderedListFeature)(),
-      (0, import_richtext_lexical.UnorderedListFeature)(),
-      // Headings - limited to h1, h2, h3 for email compatibility
-      (0, import_richtext_lexical.HeadingFeature)({
-        enabledHeadingSizes: ["h1", "h2", "h3"]
-      }),
-      // Basic paragraph and alignment
-      (0, import_richtext_lexical.ParagraphFeature)(),
-      (0, import_richtext_lexical.AlignFeature)(),
-      // Blockquotes
-      (0, import_richtext_lexical.BlockquoteFeature)(),
-      // Upload feature for images
-      (0, import_richtext_lexical.UploadFeature)({
-        collections: {
-          media: {
-            fields: [
-              {
-                name: "caption",
-                type: "text",
-                admin: {
-                  description: "Optional caption for the image"
-                }
-              },
-              {
-                name: "altText",
-                type: "text",
-                label: "Alt Text",
-                required: true,
-                admin: {
-                  description: "Alternative text for accessibility and when image cannot be displayed"
-                }
-              }
-            ]
-          }
+          user: auth.user
+        });
+        return Response.json({
+          success: true,
+          message: `Broadcast scheduled for ${scheduledDate.toISOString()}`,
+          broadcast
+        });
+      } catch (error) {
+        console.error("Failed to schedule broadcast:", error);
+        if (error instanceof NewsletterProviderError) {
+          return Response.json({
+            success: false,
+            error: error.message,
+            code: error.code
+          }, { status: error.code === "NOT_SUPPORTED" ? 501 : 500 });
         }
-      }),
-      // Email-safe blocks (processed server-side)
-      (0, import_richtext_lexical.BlocksFeature)({
-        blocks: emailSafeBlocks
-      })
-    ]
-  });
+        return Response.json({
+          success: false,
+          error: "Failed to schedule broadcast"
+        }, { status: 500 });
+      }
+    }
+  };
 };
-var emailSafeFeatures = createEmailSafeFeatures();
-var createEmailContentField = (overrides) => {
-  const editor = overrides?.editor || createEmailLexicalEditor(overrides?.additionalBlocks);
+
+// src/endpoints/broadcasts/test.ts
+var createTestBroadcastEndpoint = (config, collectionSlug) => {
   return {
-    name: "content",
-    type: "richText",
-    required: true,
-    editor,
-    admin: {
-      description: "Email content with limited formatting for compatibility",
-      ...overrides?.admin
-    },
-    ...overrides
+    path: "/:id/test",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const auth = await requireAdmin(req, config);
+        if (!auth.authorized) {
+          return Response.json({
+            success: false,
+            error: auth.error
+          }, { status: 401 });
+        }
+        const url = new URL(req.url || "", `http://localhost`);
+        const pathParts = url.pathname.split("/");
+        const id = pathParts[pathParts.length - 2];
+        if (!id) {
+          return Response.json({
+            success: false,
+            error: "Broadcast ID is required"
+          }, { status: 400 });
+        }
+        const data = await (req.json?.() || Promise.resolve({}));
+        const testEmail = data.email || auth.user.email;
+        if (!testEmail) {
+          return Response.json({
+            success: false,
+            error: "No email address available for test send"
+          }, { status: 400 });
+        }
+        const broadcast = await req.payload.findByID({
+          collection: collectionSlug,
+          id,
+          user: auth.user
+        });
+        if (!broadcast) {
+          return Response.json({
+            success: false,
+            error: "Broadcast not found"
+          }, { status: 404 });
+        }
+        const htmlContent = await convertToEmailSafeHtml(broadcast.content, {
+          wrapInTemplate: true,
+          preheader: broadcast.preheader,
+          customBlockConverter: config.customizations?.broadcasts?.customBlockConverter
+        });
+        const emailService = req.payload.newsletterEmailService;
+        if (!emailService) {
+          return Response.json({
+            success: false,
+            error: "Email service is not configured"
+          }, { status: 500 });
+        }
+        const providerConfig = config.providers.default === "resend" ? config.providers.resend : config.providers.broadcast;
+        const fromEmail = providerConfig?.fromAddress || providerConfig?.fromEmail || "noreply@example.com";
+        const fromName = providerConfig?.fromName || "Newsletter";
+        const replyTo = broadcast.settings?.replyTo || providerConfig?.replyTo;
+        await emailService.send({
+          to: testEmail,
+          from: fromEmail,
+          fromName,
+          replyTo,
+          subject: `[TEST] ${broadcast.subject}`,
+          html: htmlContent,
+          trackOpens: false,
+          trackClicks: false
+        });
+        return Response.json({
+          success: true,
+          message: `Test email sent to ${testEmail}`
+        });
+      } catch (error) {
+        console.error("Failed to send test broadcast:", error);
+        return Response.json({
+          success: false,
+          error: "Failed to send test email"
+        }, { status: 500 });
+      }
+    }
   };
 };
 
-// src/fields/broadcastInlinePreview.ts
-var createBroadcastInlinePreviewField = () => {
+// src/endpoints/broadcasts/preview.ts
+var createBroadcastPreviewEndpoint = (config, collectionSlug) => {
   return {
-    name: "broadcastInlinePreview",
-    type: "ui",
-    admin: {
-      components: {
-        Field: "payload-plugin-newsletter/components#BroadcastInlinePreview"
+    path: "/preview",
+    method: "post",
+    handler: async (req) => {
+      try {
+        const data = await (req.json?.() || Promise.resolve({}));
+        const { content, preheader, subject } = data;
+        if (!content) {
+          return Response.json({
+            success: false,
+            error: "Content is required for preview"
+          }, { status: 400 });
+        }
+        const mediaUrl = req.payload.config.serverURL ? `${req.payload.config.serverURL}/api/media` : "/api/media";
+        const htmlContent = await convertToEmailSafeHtml(content, {
+          wrapInTemplate: true,
+          preheader,
+          mediaUrl,
+          customBlockConverter: config.customizations?.broadcasts?.customBlockConverter
+        });
+        return Response.json({
+          success: true,
+          preview: {
+            subject: subject || "Preview",
+            preheader: preheader || "",
+            html: htmlContent
+          }
+        });
+      } catch (error) {
+        console.error("Failed to generate email preview:", error);
+        return Response.json({
+          success: false,
+          error: "Failed to generate email preview"
+        }, { status: 500 });
       }
     }
   };
@@ -4225,8 +4216,9 @@ var createBroadcastInlinePreviewField = () => {
 var createBroadcastsCollection = (pluginConfig) => {
   const hasProviders = !!(pluginConfig.providers?.broadcast || pluginConfig.providers?.resend);
   const customizations = pluginConfig.customizations?.broadcasts;
+  const collectionSlug = "broadcasts";
   return {
-    slug: "broadcasts",
+    slug: collectionSlug,
     access: {
       read: () => true,
       // Public read access
@@ -4255,6 +4247,12 @@ var createBroadcastsCollection = (pluginConfig) => {
       description: "Individual email campaigns sent to subscribers",
       defaultColumns: ["subject", "_status", "sendStatus", "sentAt", "recipientCount"]
     },
+    endpoints: [
+      createSendBroadcastEndpoint(pluginConfig, collectionSlug),
+      createScheduleBroadcastEndpoint(pluginConfig, collectionSlug),
+      createTestBroadcastEndpoint(pluginConfig, collectionSlug),
+      createBroadcastPreviewEndpoint(pluginConfig, collectionSlug)
+    ],
     fields: [
       {
         name: "subject",