featuredrop 1.2.0 → 1.4.0

package/dist/index.cjs

@@ -1,9 +1,33 @@
 'use strict';
 
-var module$1 = require('module');
+var moduleApi = require('module');
 var zod = require('zod');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var promises = require('fs/promises');
+var path = require('path');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var moduleApi__namespace = /*#__PURE__*/_interopNamespace(moduleApi);
+
 // src/semver.ts
 var SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/;
 function parseSemver(input) {
@@ -225,6 +249,20 @@ function isVersionMatch(feature, appVersion) {
   if (v.showNewUntil && compareSemver(appVersion, v.showNewUntil) >= 0) return false;
   return true;
 }
+function isFlagMatch(feature, flagBridge, userContext) {
+  if (!feature.flagKey) return true;
+  if (!flagBridge) return false;
+  try {
+    return flagBridge.isEnabled(feature.flagKey, userContext);
+  } catch {
+    return false;
+  }
+}
+function isProductMatch(feature, product) {
+  if (!feature.product || feature.product === "*") return true;
+  if (!product) return false;
+  return feature.product === product;
+}
 function isDependencyMatch(feature, dismissedIds, dependencyState) {
   const dependsOn = feature.dependsOn;
   if (!dependsOn) return true;
@@ -249,11 +287,13 @@ function isDependencyMatch(feature, dismissedIds, dependencyState) {
   }
   return true;
 }
-function isNew(feature, watermark, dismissedIds, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+function isNew(feature, watermark, dismissedIds, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext, flagBridge, product) {
   if (dismissedIds.has(feature.id)) return false;
   if (!isAudienceMatch(feature, userContext, matchAudience)) return false;
   if (!isDependencyMatch(feature, dismissedIds, dependencyState)) return false;
   if (!isVersionMatch(feature, appVersion)) return false;
+  if (!isFlagMatch(feature, flagBridge, userContext)) return false;
+  if (!isProductMatch(feature, product)) return false;
   if (!isTriggerMatch(feature.trigger, triggerContext)) return false;
   const nowMs = now.getTime();
   if (feature.publishAt) {
@@ -269,7 +309,7 @@ function isNew(feature, watermark, dismissedIds, now = /* @__PURE__ */ new Date(
   }
   return true;
 }
-function getNewFeatures(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+function getNewFeatures(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext, flagBridge, product) {
   const watermark = storage.getWatermark();
   const dismissedIds = storage.getDismissedIds();
   return manifest.filter(
@@ -282,11 +322,13 @@ function getNewFeatures(manifest, storage, now = /* @__PURE__ */ new Date(), use
       matchAudience,
       appVersion,
       dependencyState,
-      triggerContext
+      triggerContext,
+      flagBridge,
+      product
     )
   );
 }
-function getNewFeatureCount(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+function getNewFeatureCount(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext, flagBridge, product) {
   return getNewFeatures(
     manifest,
     storage,
@@ -295,10 +337,12 @@ function getNewFeatureCount(manifest, storage, now = /* @__PURE__ */ new Date(),
     matchAudience,
     appVersion,
     dependencyState,
-    triggerContext
+    triggerContext,
+    flagBridge,
+    product
   ).length;
 }
-function hasNewFeature(manifest, sidebarKey, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+function hasNewFeature(manifest, sidebarKey, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext, flagBridge, product) {
   const watermark = storage.getWatermark();
   const dismissedIds = storage.getDismissedIds();
   return manifest.some(
@@ -311,11 +355,13 @@ function hasNewFeature(manifest, sidebarKey, storage, now = /* @__PURE__ */ new
       matchAudience,
       appVersion,
       dependencyState,
-      triggerContext
+      triggerContext,
+      flagBridge,
+      product
     )
   );
 }
-function getNewFeaturesSorted(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+function getNewFeaturesSorted(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext, flagBridge, product) {
   const priorityOrder = { critical: 0, normal: 1, low: 2 };
   return getNewFeatures(
     manifest,
@@ -325,7 +371,9 @@ function getNewFeaturesSorted(manifest, storage, now = /* @__PURE__ */ new Date(
     matchAudience,
     appVersion,
     dependencyState,
-    triggerContext
+    triggerContext,
+    flagBridge,
+    product
   ).sort(
     (a, b) => {
       const pa = priorityOrder[a.priority ?? "normal"];
@@ -350,10 +398,11 @@ function getNewFeaturesByCategory(manifest, category, storage, now = /* @__PURE_
     (f) => f.category === category && isNew(f, watermark, dismissedIds, now, userContext, matchAudience, appVersion)
   );
 }
-var dynamicRequire = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+var dynamicRequire = typeof moduleApi__namespace.createRequire === "function" ? moduleApi__namespace.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))) : null;
 var cachedMarked = null;
 var cachedShiki = null;
 function optionalRequire(name) {
+  if (!dynamicRequire) return null;
   try {
     return dynamicRequire(name);
   } catch (error) {
@@ -577,209 +626,1709 @@ function parseDescription(markdown) {
   return sanitizeHtml(decoded);
 }
 
-// src/theme.ts
-var LIGHT_THEME = {
-  colors: {
-    primary: "#2563eb",
-    background: "#ffffff",
-    text: "#111827",
-    textMuted: "#6b7280",
-    border: "#e5e7eb",
-    success: "#16a34a",
-    warning: "#f59e0b",
-    error: "#dc2626"
-  },
-  fonts: {
-    family: "system-ui, -apple-system, Segoe UI, sans-serif",
-    sizeBase: "14px",
-    sizeSm: "12px",
-    sizeLg: "16px"
-  },
-  spacing: {
-    xs: "4px",
-    sm: "8px",
-    md: "12px",
-    lg: "16px",
-    xl: "24px"
-  },
-  radii: {
-    sm: "6px",
-    md: "8px",
-    lg: "12px",
-    full: "999px"
-  },
-  shadows: {
-    sm: "0 2px 8px rgba(0, 0, 0, 0.08)",
-    md: "0 8px 24px rgba(0, 0, 0, 0.12)",
-    lg: "0 20px 60px rgba(0, 0, 0, 0.16)"
-  },
-  zIndex: {
-    base: 9998,
-    tooltip: 1e4,
-    modal: 10001,
-    overlay: 9997
-  }
-};
-var DARK_THEME = {
-  ...LIGHT_THEME,
-  colors: {
-    primary: "#60a5fa",
-    background: "#0b1220",
-    text: "#f3f4f6",
-    textMuted: "#9ca3af",
-    border: "#1f2937",
-    success: "#4ade80",
-    warning: "#fbbf24",
-    error: "#f87171"
-  },
-  shadows: {
-    sm: "0 2px 8px rgba(0, 0, 0, 0.35)",
-    md: "0 8px 24px rgba(0, 0, 0, 0.42)",
-    lg: "0 20px 60px rgba(0, 0, 0, 0.52)"
-  }
-};
-var MINIMAL_THEME = {
-  ...LIGHT_THEME,
-  colors: {
-    ...LIGHT_THEME.colors,
-    primary: "#111827",
-    background: "#ffffff",
-    text: "#111827",
-    textMuted: "#6b7280",
-    border: "#d1d5db",
-    success: "#111827",
-    warning: "#111827",
-    error: "#111827"
-  },
-  shadows: {
-    sm: "none",
-    md: "none",
-    lg: "none"
-  },
-  radii: {
-    sm: "0",
-    md: "0",
-    lg: "0",
-    full: "0"
-  }
-};
-var VIBRANT_THEME = {
-  ...LIGHT_THEME,
-  colors: {
-    primary: "#ec4899",
-    background: "#fff7ed",
-    text: "#3f1d57",
-    textMuted: "#6d4c84",
-    border: "#fdba74",
-    success: "#10b981",
-    warning: "#f59e0b",
-    error: "#ef4444"
-  },
-  shadows: {
-    sm: "0 2px 10px rgba(236, 72, 153, 0.15)",
-    md: "0 10px 26px rgba(236, 72, 153, 0.22)",
-    lg: "0 22px 58px rgba(236, 72, 153, 0.28)"
-  }
-};
-var FEATUREDROP_THEMES = {
-  light: LIGHT_THEME,
-  dark: DARK_THEME,
-  minimal: MINIMAL_THEME,
-  vibrant: VIBRANT_THEME
-};
-function isThemePreset(value) {
-  return value === "light" || value === "dark" || value === "auto" || value === "minimal" || value === "vibrant";
+// src/renderer.ts
+function sortFeatures(features) {
+  const priorityOrder = { critical: 0, normal: 1, low: 2 };
+  return [...features].sort((a, b) => {
+    const pa = priorityOrder[a.priority ?? "normal"];
+    const pb = priorityOrder[b.priority ?? "normal"];
+    if (pa !== pb) return pa - pb;
+    return new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime();
+  });
 }
-function mergeTheme(base, overrides) {
-  if (!overrides) return base;
+function createChangelogRenderer({
+  manifest: initialManifest,
+  storage,
+  userContext: initialUserContext,
+  matchAudience: initialMatchAudience,
+  appVersion: initialAppVersion,
+  flagBridge: initialFlagBridge,
+  product: initialProduct,
+  now = () => /* @__PURE__ */ new Date()
+}) {
+  let manifest = initialManifest;
+  let userContext = initialUserContext;
+  let matchAudience = initialMatchAudience;
+  let appVersion = initialAppVersion;
+  let flagBridge = initialFlagBridge;
+  let product = initialProduct;
+  const listeners = /* @__PURE__ */ new Set();
+  let state = {
+    manifest,
+    newFeatures: [],
+    newFeaturesSorted: [],
+    newCount: 0,
+    watermark: storage.getWatermark(),
+    dismissedIds: new Set(storage.getDismissedIds())
+  };
+  const refresh = () => {
+    const features = getNewFeatures(
+      manifest,
+      storage,
+      now(),
+      userContext,
+      matchAudience,
+      appVersion,
+      void 0,
+      void 0,
+      flagBridge,
+      product
+    );
+    state = {
+      manifest,
+      newFeatures: features,
+      newFeaturesSorted: sortFeatures(features),
+      newCount: features.length,
+      watermark: storage.getWatermark(),
+      dismissedIds: new Set(storage.getDismissedIds())
+    };
+    listeners.forEach((listener) => listener(state));
+  };
+  const dismiss = (id) => {
+    if (!id) return;
+    storage.dismiss(id);
+    refresh();
+  };
+  const dismissAll = async () => {
+    await storage.dismissAll(now());
+    refresh();
+  };
+  const setManifest = (nextManifest) => {
+    manifest = nextManifest;
+    refresh();
+  };
+  const setUserContext = (nextUserContext) => {
+    userContext = nextUserContext;
+    refresh();
+  };
+  const setAppVersion = (nextAppVersion) => {
+    appVersion = nextAppVersion;
+    refresh();
+  };
+  const setAudienceMatcher = (nextMatchAudience) => {
+    matchAudience = nextMatchAudience;
+    refresh();
+  };
+  const setFlagBridge = (nextFlagBridge) => {
+    flagBridge = nextFlagBridge;
+    refresh();
+  };
+  const setProduct = (nextProduct) => {
+    product = nextProduct;
+    refresh();
+  };
+  const isNew2 = (sidebarKey) => state.newFeatures.some((feature) => feature.sidebarKey === sidebarKey);
+  const getFeature = (sidebarKey) => state.newFeatures.find((feature) => feature.sidebarKey === sidebarKey);
+  const getFeatureById2 = (id) => state.newFeatures.find((feature) => feature.id === id);
+  const getFeaturesByCategory = (category) => state.newFeatures.filter((feature) => feature.category === category);
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    listener(state);
+    return () => {
+      listeners.delete(listener);
+    };
+  };
+  refresh();
   return {
-    colors: {
-      ...base.colors,
-      ...overrides.colors ?? {}
-    },
-    fonts: {
-      ...base.fonts,
-      ...overrides.fonts ?? {}
-    },
-    spacing: {
-      ...base.spacing,
-      ...overrides.spacing ?? {}
+    get state() {
+      return state;
     },
-    radii: {
-      ...base.radii,
-      ...overrides.radii ?? {}
+    actions: {
+      refresh,
+      dismiss,
+      dismissAll,
+      setManifest,
+      setUserContext,
+      setAppVersion,
+      setAudienceMatcher,
+      setFlagBridge,
+      setProduct
     },
-    shadows: {
-      ...base.shadows,
-      ...overrides.shadows ?? {}
+    computed: {
+      isNew: isNew2,
+      getFeature,
+      getFeatureById: getFeatureById2,
+      getFeaturesByCategory
     },
-    zIndex: {
-      ...base.zIndex,
-      ...overrides.zIndex ?? {}
-    }
+    subscribe
   };
 }
-function createTheme(overrides, base = LIGHT_THEME) {
-  return mergeTheme(base, overrides);
+
+// src/rss.ts
+function escape(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-function resolveTheme(input = "light", options = {}) {
-  if (isThemePreset(input)) {
-    if (input === "auto") {
-      return options.prefersDark ? DARK_THEME : LIGHT_THEME;
-    }
-    return FEATUREDROP_THEMES[input];
-  }
-  return mergeTheme(LIGHT_THEME, input);
+function generateRSS(manifest, options) {
+  const title = escape(options?.title ?? "Featuredrop Changelog");
+  const link = escape(options?.link ?? "");
+  const desc = escape(options?.description ?? "Product updates");
+  const items = manifest.slice().sort((a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()).map((item) => {
+    const descriptionHtml = item.description ? parseDescription(item.description) : "";
+    const itemLink = item.url ? escape(item.url) : "";
+    return [
+      "<item>",
+      `<title>${escape(item.label)}</title>`,
+      itemLink ? `<link>${itemLink}</link>` : "",
+      `<guid isPermaLink="false">${escape(item.id)}</guid>`,
+      `<pubDate>${new Date(item.releasedAt).toUTCString()}</pubDate>`,
+      `<description><![CDATA[${descriptionHtml}]]></description>`,
+      "</item>"
+    ].join("");
+  }).join("");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<rss version="2.0">',
+    "<channel>",
+    `<title>${title}</title>`,
+    link ? `<link>${link}</link>` : "",
+    `<description>${desc}</description>`,
+    items,
+    "</channel>",
+    "</rss>"
+  ].join("");
 }
-function applyThemeSection(vars, key, values) {
-  for (const [token, value] of Object.entries(values)) {
-    vars[`--featuredrop-${key}-${token}`] = value;
+
+// src/bridges.ts
+async function postJson(url, payload, headers) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...headers ?? {}
+    },
+    body: JSON.stringify(payload)
+  });
+  if (!response.ok) {
+    throw new Error(`[featuredrop] Bridge request failed (${response.status}) for ${url}`);
   }
 }
-function themeToCSSVariables(theme) {
-  const vars = {};
-  applyThemeSection(vars, "color", theme.colors);
-  applyThemeSection(vars, "font", theme.fonts);
-  applyThemeSection(vars, "space", theme.spacing);
-  applyThemeSection(vars, "radius", theme.radii);
-  applyThemeSection(vars, "shadow", theme.shadows);
-  applyThemeSection(vars, "z", theme.zIndex);
-  vars["--featuredrop-font-family"] = theme.fonts.family;
-  vars["--featuredrop-widget-bg"] = theme.colors.background;
-  vars["--featuredrop-trigger-bg"] = theme.colors.background;
-  vars["--featuredrop-trigger-color"] = theme.colors.text;
-  vars["--featuredrop-entry-title-color"] = theme.colors.text;
-  vars["--featuredrop-entry-desc-color"] = theme.colors.textMuted;
-  vars["--featuredrop-title-color"] = theme.colors.text;
-  vars["--featuredrop-border-color"] = theme.colors.border;
-  vars["--featuredrop-cta-bg"] = theme.colors.primary;
-  vars["--featuredrop-cta-color"] = theme.colors.background;
-  vars["--featuredrop-mark-all-color"] = theme.colors.primary;
-  vars["--featuredrop-widget-shadow"] = theme.shadows.md;
-  vars["--featuredrop-widget-radius"] = theme.radii.lg;
-  vars["--featuredrop-trigger-radius"] = theme.radii.md;
-  vars["--featuredrop-badge-bg"] = theme.colors.warning;
-  vars["--featuredrop-z-index"] = theme.zIndex.base;
-  vars["--featuredrop-toast-z-index"] = theme.zIndex.tooltip;
-  vars["--featuredrop-tour-z-index"] = theme.zIndex.modal;
-  vars["--featuredrop-tour-overlay-z-index"] = theme.zIndex.overlay;
-  return vars;
+function formatFeatureLine(feature) {
+  const released = new Date(feature.releasedAt).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+  return `${feature.label} (${released})`;
 }
-
-// src/i18n.ts
-var EN_TRANSLATIONS = {
-  newBadge: "New",
-  whatsNewTitle: "What's New",
-  markAllRead: "Mark all as read",
-  allCaughtUp: "You're all caught up!",
-  close: "Close",
-  changelogTitle: "Changelog",
+var SlackBridge = {
+  async notify(feature, options) {
+    const payload = options.formatter ? options.formatter(feature) : {
+      username: options.username,
+      icon_emoji: options.iconEmoji,
+      channel: options.channel,
+      text: `New feature published: *${feature.label}*`,
+      attachments: [
+        {
+          color: "#2563eb",
+          title: feature.label,
+          text: feature.description ?? "No description provided.",
+          title_link: feature.url,
+          footer: `featuredrop | ${feature.id}`
+        }
+      ]
+    };
+    await postJson(options.webhookUrl, payload);
+  }
+};
+var DiscordBridge = {
+  async notify(feature, options) {
+    const payload = options.formatter ? options.formatter(feature) : {
+      username: options.username ?? "featuredrop",
+      avatar_url: options.avatarUrl,
+      embeds: [
+        {
+          title: feature.label,
+          description: feature.description ?? "No description provided.",
+          url: feature.url,
+          color: 2450411,
+          footer: {
+            text: `featuredrop | ${feature.id}`
+          }
+        }
+      ]
+    };
+    await postJson(options.webhookUrl, payload);
+  }
+};
+var WebhookBridge = {
+  async post(feature, options) {
+    const payload = {
+      event: options.event ?? "feature.published",
+      feature,
+      sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ...options.body ?? {}
+    };
+    await postJson(options.url, payload, options.headers);
+  }
+};
+var EmailDigestGenerator = {
+  generate(features, options = {}) {
+    const title = options.title ?? "Product Updates";
+    const intro = options.intro ?? "Here are the latest updates:";
+    const productName = options.productName ?? "Your Product";
+    const template = options.template ?? "default";
+    const listItems = features.map((feature) => {
+      const safeLabel = feature.label.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      const safeDescription = (feature.description ?? "").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+      const link = feature.url ? `<a href="${feature.url}" style="color:#2563eb;text-decoration:none;">Read more</a>` : "";
+      if (template === "minimal") {
+        return `<li><strong>${safeLabel}</strong>${safeDescription ? ` - ${safeDescription}` : ""}</li>`;
+      }
+      return [
+        '<li style="margin:0 0 14px;">',
+        `<p style="margin:0 0 4px;font-weight:600;color:#111827;">${safeLabel}</p>`,
+        safeDescription ? `<p style="margin:0 0 6px;color:#4b5563;line-height:1.45;">${safeDescription}</p>` : "",
+        link ? `<p style="margin:0;">${link}</p>` : "",
+        "</li>"
+      ].join("");
+    }).join("");
+    if (template === "minimal") {
+      return [
+        "<!doctype html>",
+        "<html><body>",
+        `<h2>${title}</h2>`,
+        `<p>${intro}</p>`,
+        `<ul>${listItems}</ul>`,
+        "</body></html>"
+      ].join("");
+    }
+    const summary = features.map((feature) => formatFeatureLine(feature)).join(" | ");
+    return [
+      "<!doctype html>",
+      "<html>",
+      `<body style="font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',sans-serif;background:#f8fafc;padding:20px;">`,
+      '<div style="max-width:640px;margin:0 auto;background:#ffffff;border:1px solid #e5e7eb;border-radius:12px;padding:20px;">',
+      `<p style="margin:0 0 12px;color:#6b7280;font-size:12px;letter-spacing:0.08em;text-transform:uppercase;">${productName}</p>`,
+      `<h1 style="margin:0 0 8px;font-size:22px;color:#111827;">${title}</h1>`,
+      `<p style="margin:0 0 14px;color:#374151;">${intro}</p>`,
+      `<p style="margin:0 0 18px;color:#6b7280;font-size:13px;">${summary}</p>`,
+      `<ul style="padding-left:18px;margin:0;">${listItems}</ul>`,
+      "</div>",
+      "</body>",
+      "</html>"
+    ].join("");
+  }
+};
+var RSSFeedGenerator = {
+  generate(manifest, options) {
+    return generateRSS(manifest, options);
+  }
+};
+
+// src/dependencies.ts
+function getDirectDependencies(feature) {
+  const dependsOn = feature.dependsOn;
+  if (!dependsOn) return [];
+  const seen = dependsOn.seen ?? [];
+  const clicked = dependsOn.clicked ?? [];
+  const dismissed = dependsOn.dismissed ?? [];
+  const unique = /* @__PURE__ */ new Set();
+  for (const id of [...seen, ...clicked, ...dismissed]) {
+    if (id) unique.add(id);
+  }
+  return Array.from(unique);
+}
+function resolveDependencyOrder(manifest) {
+  const ids = new Set(manifest.map((feature) => feature.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = /* @__PURE__ */ new Map();
+  for (const feature of manifest) {
+    outgoing.set(feature.id, /* @__PURE__ */ new Set());
+    indegree.set(feature.id, 0);
+  }
+  for (const feature of manifest) {
+    for (const dependencyId of getDirectDependencies(feature)) {
+      if (!ids.has(dependencyId)) continue;
+      const edges = outgoing.get(dependencyId);
+      if (!edges || edges.has(feature.id)) continue;
+      edges.add(feature.id);
+      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+  }
+  const ordered = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id) continue;
+    ordered.push(id);
+    const edges = outgoing.get(id);
+    if (!edges) continue;
+    for (const nextId of edges) {
+      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, nextDegree);
+      if (nextDegree === 0) queue.push(nextId);
+    }
+  }
+  if (ordered.length < manifest.length) {
+    const included = new Set(ordered);
+    for (const feature of manifest) {
+      if (included.has(feature.id)) continue;
+      ordered.push(feature.id);
+    }
+  }
+  return ordered;
+}
+function hasDependencyCycle(manifest) {
+  const ids = new Set(manifest.map((feature) => feature.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = /* @__PURE__ */ new Map();
+  for (const feature of manifest) {
+    outgoing.set(feature.id, /* @__PURE__ */ new Set());
+    indegree.set(feature.id, 0);
+  }
+  for (const feature of manifest) {
+    for (const dependencyId of getDirectDependencies(feature)) {
+      if (!ids.has(dependencyId)) continue;
+      const edges = outgoing.get(dependencyId);
+      if (!edges || edges.has(feature.id)) continue;
+      edges.add(feature.id);
+      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id) continue;
+    visited += 1;
+    const edges = outgoing.get(id);
+    if (!edges) continue;
+    for (const nextId of edges) {
+      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, nextDegree);
+      if (nextDegree === 0) queue.push(nextId);
+    }
+  }
+  return visited !== manifest.length;
+}
+function sortFeaturesByDependencies(features) {
+  if (features.length <= 1) return [...features];
+  const order = resolveDependencyOrder(features);
+  const rank = new Map(order.map((id, index) => [id, index]));
+  return [...features].sort((a, b) => {
+    const ra = rank.get(a.id);
+    const rb = rank.get(b.id);
+    if (ra === void 0 || rb === void 0) return 0;
+    return ra - rb;
+  });
+}
+var featureEntryJsonSchema = {
+  type: "object",
+  required: ["id", "label", "releasedAt", "showNewUntil"],
+  properties: {
+    id: { type: "string" },
+    label: { type: "string" },
+    description: { type: "string" },
+    releasedAt: { type: "string", format: "date-time" },
+    showNewUntil: { type: "string", format: "date-time" },
+    flagKey: { type: "string" },
+    product: { type: "string" },
+    url: { type: "string" },
+    image: { type: "string" },
+    type: { enum: ["feature", "improvement", "fix", "breaking"] },
+    priority: { enum: ["critical", "normal", "low"] },
+    cta: {
+      type: "object",
+      properties: {
+        label: { type: "string" },
+        url: { type: "string" }
+      }
+    },
+    meta: { type: "object" }
+  }
+};
+var featureManifestJsonSchema = {
+  type: "array",
+  items: featureEntryJsonSchema
+};
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isValidDate(value) {
+  return Number.isFinite(new Date(value).getTime());
+}
+var nonEmptyString = zod.z.string().trim().min(1, "must be a non-empty string");
+var isoDateString = nonEmptyString.refine(isValidDate, {
+  message: "must be a valid date",
+  params: { featuredropCode: "invalid_date" }
+});
+var dependsOnSchema = zod.z.object({
+  seen: zod.z.array(zod.z.string()).optional(),
+  clicked: zod.z.array(zod.z.string()).optional(),
+  dismissed: zod.z.array(zod.z.string()).optional()
+}).optional();
+var ctaSchema = zod.z.object({
+  label: nonEmptyString,
+  url: nonEmptyString
+}).optional();
+var featureEntrySchema = zod.z.object({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  releasedAt: isoDateString,
+  showNewUntil: isoDateString,
+  description: zod.z.string().optional(),
+  flagKey: zod.z.string().optional(),
+  product: zod.z.string().optional(),
+  url: zod.z.string().optional(),
+  image: zod.z.string().optional(),
+  type: zod.z.enum(["feature", "improvement", "fix", "breaking"]).optional(),
+  priority: zod.z.enum(["critical", "normal", "low"]).optional(),
+  cta: ctaSchema,
+  meta: zod.z.record(zod.z.unknown()).optional(),
+  dependsOn: dependsOnSchema
+}).passthrough();
+var featureManifestSchema = zod.z.array(featureEntrySchema);
+function toIssuePath(path) {
+  if (path.length === 0) return "$";
+  let output = "";
+  for (const part of path) {
+    if (typeof part === "number") output += `[${part}]`;
+    else output += output ? `.${part}` : part;
+  }
+  return output;
+}
+function mapZodIssue(issue) {
+  const codeParam = issue.params?.featuredropCode;
+  if (codeParam === "invalid_date") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: "invalid_date"
+    };
+  }
+  if (issue.code === "invalid_type") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: issue.received === "undefined" ? "missing_required" : "invalid_type"
+    };
+  }
+  return {
+    path: toIssuePath(issue.path),
+    message: issue.message,
+    code: "invalid_value"
+  };
+}
+var UNSAFE_META_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeUrl(value) {
+  const normalized = value.trim();
+  if (!normalized) return false;
+  if (/^(\/|\.\/|\.\.\/|\?|#)/.test(normalized)) return true;
+  if (/^https?:\/\//i.test(normalized)) return true;
+  return false;
+}
+function findUnsafeMetaPath(value, path = "meta") {
+  if (Array.isArray(value)) {
+    for (let index = 0; index < value.length; index++) {
+      const nested = findUnsafeMetaPath(value[index], `${path}[${index}]`);
+      if (nested) return nested;
+    }
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  for (const [key, nestedValue] of Object.entries(value)) {
+    if (UNSAFE_META_KEYS.has(key)) {
+      return `${path}.${key}`;
+    }
+    const nested = findUnsafeMetaPath(nestedValue, `${path}.${key}`);
+    if (nested) return nested;
+  }
+  return null;
+}
+function validateFeatureEntry(raw, index) {
+  if (!isRecord(raw)) {
+    return {
+      issues: [
+        {
+          path: `[${index}]`,
+          message: "Feature entry must be an object",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const parsed = featureEntrySchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      issues: parsed.error.issues.map((issue) => ({
+        ...mapZodIssue(issue),
+        path: `[${index}]${issue.path.length > 0 ? `.${toIssuePath(issue.path)}` : ""}`
+      }))
+    };
+  }
+  return {
+    issues: [],
+    entry: parsed.data
+  };
+}
+function validateManifest(data) {
+  const errors = [];
+  if (!Array.isArray(data)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: "$",
+          message: "Manifest must be an array",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const entries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  data.forEach((item, index) => {
+    const result = validateFeatureEntry(item, index);
+    errors.push(...result.issues);
+    if (!result.entry) return;
+    if (seenIds.has(result.entry.id)) {
+      errors.push({
+        path: `[${index}].id`,
+        message: `Duplicate feature id "${result.entry.id}"`,
+        code: "duplicate_id"
+      });
+      return;
+    }
+    seenIds.add(result.entry.id);
+    entries.push(result.entry);
+  });
+  if (entries.length > 0 && hasDependencyCycle(entries)) {
+    errors.push({
+      path: "$",
+      message: "Circular dependsOn relationship detected",
+      code: "circular_dependency"
+    });
+  }
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index];
+    if (new Date(entry.showNewUntil).getTime() <= new Date(entry.releasedAt).getTime()) {
+      errors.push({
+        path: `[${index}].showNewUntil`,
+        message: "showNewUntil must be after releasedAt",
+        code: "invalid_value"
+      });
+    }
+    if (entry.url && !isSafeUrl(entry.url)) {
+      errors.push({
+        path: `[${index}].url`,
+        message: "url must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    if (entry.image && !isSafeUrl(entry.image)) {
+      errors.push({
+        path: `[${index}].image`,
+        message: "image must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    if (entry.cta?.url && !isSafeUrl(entry.cta.url)) {
+      errors.push({
+        path: `[${index}].cta.url`,
+        message: "cta.url must be http, https, or relative",
+        code: "invalid_value"
+      });
+    }
+    const unsafeMetaPath = findUnsafeMetaPath(entry.meta);
+    if (unsafeMetaPath) {
+      errors.push({
+        path: `[${index}].${unsafeMetaPath}`,
+        message: `meta contains unsafe key "${unsafeMetaPath.split(".").pop()}"`,
+        code: "invalid_value"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+
+// src/ci.ts
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function collectChangedFields(beforeValue, afterValue, path, output) {
+  if (beforeValue === afterValue) return;
+  if (Array.isArray(beforeValue) && Array.isArray(afterValue)) {
+    if (beforeValue.length !== afterValue.length) {
+      output.push(path);
+      return;
+    }
+    for (let i = 0; i < beforeValue.length; i += 1) {
+      collectChangedFields(beforeValue[i], afterValue[i], `${path}[${i}]`, output);
+    }
+    return;
+  }
+  if (isRecord2(beforeValue) && isRecord2(afterValue)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(beforeValue), ...Object.keys(afterValue)]);
+    keys.forEach((key) => {
+      const nextPath = path ? `${path}.${key}` : key;
+      collectChangedFields(beforeValue[key], afterValue[key], nextPath, output);
+    });
+    return;
+  }
+  output.push(path);
+}
+function diffManifest(before, after) {
+  const beforeById = new Map(before.map((feature) => [feature.id, feature]));
+  const afterById = new Map(after.map((feature) => [feature.id, feature]));
+  const added = after.filter((feature) => !beforeById.has(feature.id));
+  const removed = before.filter((feature) => !afterById.has(feature.id));
+  const changed = after.filter((feature) => beforeById.has(feature.id)).map((feature) => {
+    const previous = beforeById.get(feature.id);
+    if (!previous) return null;
+    const changedFields = [];
+    collectChangedFields(previous, feature, "", changedFields);
+    if (changedFields.length === 0) return null;
+    return {
+      id: feature.id,
+      before: previous,
+      after: feature,
+      changedFields
+    };
+  }).filter((item) => item !== null);
+  return { added, removed, changed };
+}
+function generateChangelogDiff(diff, options = {}) {
+  const parts = [];
+  if (diff.added.length > 0) {
+    parts.push(`Added: ${diff.added.map((feature) => feature.label).join(", ")}`);
+  }
+  if (diff.changed.length > 0) {
+    const changedText = diff.changed.map((item) => {
+      if (!options.includeFieldChanges) return item.after.label;
+      return `${item.after.label} [${item.changedFields.join(", ")}]`;
+    });
+    parts.push(`Changed: ${changedText.join(", ")}`);
+  }
+  if (diff.removed.length > 0) {
+    parts.push(`Removed: ${diff.removed.map((feature) => feature.label).join(", ")}`);
+  }
+  return parts.length > 0 ? parts.join(". ") : "No manifest changes.";
+}
+function validateManifestForCI(manifest) {
+  return validateManifest(manifest);
+}
+
+// src/flags.ts
+function createFlagBridge(options) {
+  return {
+    isEnabled: (flagKey, userContext) => {
+      if (!flagKey) return false;
+      return options.isEnabled(flagKey, userContext);
+    }
+  };
+}
+var LaunchDarklyBridge = class {
+  client;
+  options;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  isEnabled(flagKey, userContext) {
+    const defaultUser = {
+      key: userContext?.traits?.id ?? userContext?.role ?? "anonymous",
+      custom: {
+        plan: userContext?.plan,
+        role: userContext?.role,
+        region: userContext?.region,
+        ...userContext?.traits ?? {}
+      }
+    };
+    const user = this.options.userResolver ? this.options.userResolver(userContext) : defaultUser;
+    return this.client.variation(flagKey, user, this.options.defaultValue ?? false);
+  }
+};
+var PostHogBridge = class {
+  client;
+  options;
+  constructor(client, options = {}) {
+    this.client = client;
+    this.options = options;
+  }
+  isEnabled(flagKey, userContext) {
+    const distinctId = this.options.distinctIdResolver ? this.options.distinctIdResolver(userContext) : typeof userContext?.traits?.id === "string" ? userContext.traits.id : void 0;
+    const groups = this.options.groupsResolver ? this.options.groupsResolver(userContext) : void 0;
+    return this.client.isFeatureEnabled(flagKey, distinctId, groups, userContext?.traits);
+  }
+};
+var panelStyles = {
+  border: "1px solid #e5e7eb",
+  borderRadius: "10px",
+  padding: "12px",
+  background: "#ffffff"
+};
+var headingStyles = {
+  margin: "0 0 8px",
+  fontSize: "15px",
+  fontWeight: 700
+};
+function ManifestEditor({
+  features,
+  onSave,
+  readOnly = false,
+  children
+}) {
+  const [draft, setDraft] = react.useState(() => JSON.stringify(features, null, 2));
+  const [status, setStatus] = react.useState("idle");
+  const [error, setError] = react.useState("");
+  const parsed = react.useMemo(() => {
+    try {
+      const next = JSON.parse(draft);
+      if (!Array.isArray(next)) throw new Error("Manifest must be an array");
+      return next;
+    } catch {
+      return null;
+    }
+  }, [draft]);
+  const save = async () => {
+    if (readOnly || !parsed) return;
+    setStatus("saving");
+    setError("");
+    try {
+      await onSave(parsed);
+      setStatus("saved");
+    } catch (cause) {
+      setStatus("error");
+      setError(cause instanceof Error ? cause.message : "Failed to save manifest");
+    }
+  };
+  if (children) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  return /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-featuredrop-admin-manifest-editor": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { style: headingStyles, children: "Manifest Editor" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      "textarea",
+      {
+        "aria-label": "Manifest JSON",
+        value: draft,
+        onChange: (event) => setDraft(event.target.value),
+        readOnly,
+        style: {
+          width: "100%",
+          minHeight: "180px",
+          fontFamily: "ui-monospace, SFMono-Regular, Menlo, monospace",
+          fontSize: "12px",
+          lineHeight: 1.45,
+          border: "1px solid #d1d5db",
+          borderRadius: "8px",
+          padding: "10px"
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "flex", alignItems: "center", gap: "8px", marginTop: "8px" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: save, disabled: readOnly || !parsed, children: "Save" }),
+      /* @__PURE__ */ jsxRuntime.jsx("span", { "aria-live": "polite", children: status }),
+      !parsed && /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: "#dc2626" }, children: "Invalid JSON" }),
+      error && /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: "#dc2626" }, children: error })
+    ] })
+  ] });
+}
+function ScheduleCalendar({ features, onSchedule }) {
+  const [values, setValues] = react.useState({});
+  return /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-featuredrop-admin-schedule-calendar": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { style: headingStyles, children: "Schedule Calendar" }),
+    /* @__PURE__ */ jsxRuntime.jsx("ul", { style: { margin: 0, padding: 0, listStyle: "none", display: "grid", gap: "10px" }, children: features.map((feature) => /* @__PURE__ */ jsxRuntime.jsxs(
+      "li",
+      {
+        style: {
+          border: "1px solid #e5e7eb",
+          borderRadius: "8px",
+          padding: "10px",
+          display: "grid",
+          gap: "6px"
+        },
+        children: [
+          /* @__PURE__ */ jsxRuntime.jsx("strong", { children: feature.label }),
+          /* @__PURE__ */ jsxRuntime.jsxs("label", { style: { display: "grid", gap: "4px" }, children: [
+            "Publish at",
+            /* @__PURE__ */ jsxRuntime.jsx(
+              "input",
+              {
+                type: "datetime-local",
+                value: values[feature.id] ?? "",
+                onChange: (event) => {
+                  const value = event.target.value;
+                  setValues((previous) => ({ ...previous, [feature.id]: value }));
+                }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            "button",
+            {
+              type: "button",
+              onClick: () => {
+                const value = values[feature.id];
+                if (!value) return;
+                void onSchedule(feature.id, new Date(value).toISOString());
+              },
+              children: "Schedule"
+            }
+          )
+        ]
+      },
+      feature.id
+    )) })
+  ] });
+}
+function PreviewPanel({ feature, components = ["badge", "changelog"] }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-featuredrop-admin-preview-panel": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { style: headingStyles, children: "Preview Panel" }),
+    !feature ? /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: 0, color: "#6b7280" }, children: "Select a feature to preview." }) : /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+      /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: "0 0 6px", fontWeight: 600 }, children: feature.label }),
+      /* @__PURE__ */ jsxRuntime.jsx("p", { style: { margin: "0 0 8px", color: "#6b7280" }, children: feature.description ?? "No description" }),
+      /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexWrap: "wrap", gap: "6px" }, children: components.map((component) => /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          style: {
+            border: "1px solid #d1d5db",
+            borderRadius: "999px",
+            padding: "2px 8px",
+            fontSize: "12px"
+          },
+          children: component
+        },
+        component
+      )) })
+    ] })
+  ] });
+}
+function toggle(list, value) {
+  const items = new Set(list ?? []);
+  if (items.has(value)) items.delete(value);
+  else items.add(value);
+  return Array.from(items);
+}
+function AudienceBuilder({
+  segments = [],
+  roles = [],
+  regions = [],
+  value,
+  onChange,
+  onSave
+}) {
+  const [audience, setAudience] = react.useState({
+    plan: value?.plan ?? [],
+    role: value?.role ?? [],
+    region: value?.region ?? []
+  });
+  const updateAudience = (next) => {
+    setAudience(next);
+    onChange?.(next);
+  };
+  const section = (title, values, selected, onToggle) => /* @__PURE__ */ jsxRuntime.jsxs("fieldset", { style: { border: "none", margin: 0, padding: 0 }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("legend", { style: { fontWeight: 600, marginBottom: "4px" }, children: title }),
+    /* @__PURE__ */ jsxRuntime.jsx("div", { style: { display: "flex", flexWrap: "wrap", gap: "8px" }, children: values.map((item) => /* @__PURE__ */ jsxRuntime.jsxs("label", { style: { display: "inline-flex", alignItems: "center", gap: "6px" }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: Boolean(selected?.includes(item)),
+          onChange: () => onToggle(item)
+        }
+      ),
+      item
+    ] }, item)) })
+  ] });
+  return /* @__PURE__ */ jsxRuntime.jsxs("section", { "data-featuredrop-admin-audience-builder": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsxRuntime.jsx("p", { style: headingStyles, children: "Audience Builder" }),
+    /* @__PURE__ */ jsxRuntime.jsxs("div", { style: { display: "grid", gap: "10px" }, children: [
+      section("Plans", segments, audience.plan, (item) => updateAudience({ ...audience, plan: toggle(audience.plan, item) })),
+      section("Roles", roles, audience.role, (item) => updateAudience({ ...audience, role: toggle(audience.role, item) })),
+      section("Regions", regions, audience.region, (item) => updateAudience({ ...audience, region: toggle(audience.region, item) }))
+    ] }),
+    onSave && /* @__PURE__ */ jsxRuntime.jsx(
+      "button",
+      {
+        type: "button",
+        style: { marginTop: "10px" },
+        onClick: () => {
+          void onSave(audience);
+        },
+        children: "Save audience"
+      }
+    )
+  ] });
+}
+function parseScalar(raw) {
+  const value = raw.trim();
+  if (!value) return "";
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null") return null;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (!inner) return [];
+    return inner.split(",").map((part) => String(parseScalar(part.trim())));
+  }
+  return value;
+}
+function parseFrontmatter(raw) {
+  const lines = raw.split(/\r?\n/);
+  const root = {};
+  const stack = [
+    { indent: -1, value: root }
+  ];
+  const isArrayContext = (idx) => {
+    for (let i = idx + 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.trim()) continue;
+      const indent = line.length - line.trimStart().length;
+      if (indent <= lines[idx].length - lines[idx].trimStart().length) return false;
+      return line.trimStart().startsWith("- ");
+    }
+    return false;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.trim() || line.trimStart().startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const trimmed = line.trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+      stack.pop();
+    }
+    const current = stack[stack.length - 1].value;
+    if (trimmed.startsWith("- ")) {
+      if (!Array.isArray(current)) {
+        throw new Error(`Invalid frontmatter list at line ${i + 1}`);
+      }
+      const item = trimmed.slice(2).trim();
+      current.push(parseScalar(item));
+      continue;
+    }
+    const colon = trimmed.indexOf(":");
+    if (colon === -1) {
+      throw new Error(`Invalid frontmatter line ${i + 1}: ${trimmed}`);
+    }
+    const key = trimmed.slice(0, colon).trim();
+    const rest = trimmed.slice(colon + 1).trim();
+    if (Array.isArray(current)) {
+      throw new Error(`Unexpected key in list at line ${i + 1}`);
+    }
+    if (!rest) {
+      const container = isArrayContext(i) ? [] : {};
+      current[key] = container;
+      stack.push({ indent, value: container });
+      continue;
+    }
+    current[key] = parseScalar(rest);
+  }
+  return root;
+}
+function splitFrontmatter(markdown) {
+  const normalized = markdown.replace(/\r\n/g, "\n");
+  if (!normalized.startsWith("---\n")) {
+    return { frontmatter: {}, body: normalized.trim() };
+  }
+  const end = normalized.indexOf("\n---\n", 4);
+  if (end === -1) {
+    throw new Error("Frontmatter block is not closed with ---");
+  }
+  const fmRaw = normalized.slice(4, end);
+  const body = normalized.slice(end + 5).trim();
+  return {
+    frontmatter: parseFrontmatter(fmRaw),
+    body
+  };
+}
+function asString(value, field, source) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${source}: "${field}" must be a non-empty string`);
+  }
+  return value;
+}
+function asOptionalObject(value, field, source) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${source}: "${field}" must be an object`);
+  }
+  return value;
+}
+function parseFeatureFile(markdown, source = "feature.md") {
+  const { frontmatter, body } = splitFrontmatter(markdown);
+  const entry = {
+    id: asString(frontmatter.id, "id", source),
+    label: asString(frontmatter.label, "label", source),
+    releasedAt: asString(frontmatter.releasedAt, "releasedAt", source),
+    showNewUntil: asString(frontmatter.showNewUntil, "showNewUntil", source),
+    description: body || void 0
+  };
+  if (frontmatter.sidebarKey !== void 0) entry.sidebarKey = asString(frontmatter.sidebarKey, "sidebarKey", source);
+  if (frontmatter.category !== void 0) entry.category = asString(frontmatter.category, "category", source);
+  if (frontmatter.product !== void 0) entry.product = asString(frontmatter.product, "product", source);
+  if (frontmatter.url !== void 0) entry.url = asString(frontmatter.url, "url", source);
+  if (frontmatter.flagKey !== void 0) entry.flagKey = asString(frontmatter.flagKey, "flagKey", source);
+  if (frontmatter.image !== void 0) entry.image = asString(frontmatter.image, "image", source);
+  if (frontmatter.publishAt !== void 0) entry.publishAt = asString(frontmatter.publishAt, "publishAt", source);
+  if (frontmatter.version !== void 0) {
+    if (typeof frontmatter.version === "string" || typeof frontmatter.version === "object") {
+      entry.version = frontmatter.version;
+    } else {
+      throw new Error(`${source}: "version" must be a string or object`);
+    }
+  }
+  if (frontmatter.type !== void 0) {
+    const type = asString(frontmatter.type, "type", source);
+    if (!["feature", "improvement", "fix", "breaking"].includes(type)) {
+      throw new Error(`${source}: invalid "type" value "${type}"`);
+    }
+    entry.type = type;
+  }
+  if (frontmatter.priority !== void 0) {
+    const priority = asString(frontmatter.priority, "priority", source);
+    if (!["critical", "normal", "low"].includes(priority)) {
+      throw new Error(`${source}: invalid "priority" value "${priority}"`);
+    }
+    entry.priority = priority;
+  }
+  const cta = asOptionalObject(frontmatter.cta, "cta", source);
+  if (cta) {
+    entry.cta = {
+      label: asString(cta.label, "cta.label", source),
+      url: asString(cta.url, "cta.url", source)
+    };
+  }
+  const audience = asOptionalObject(frontmatter.audience, "audience", source);
+  if (audience) {
+    const parsedAudience = {};
+    for (const field of ["plan", "role", "region"]) {
+      const value = audience[field];
+      if (value !== void 0) {
+        if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+          throw new Error(`${source}: "audience.${field}" must be string[]`);
+        }
+        parsedAudience[field] = value;
+      }
+    }
+    if (audience.custom !== void 0) {
+      if (!audience.custom || typeof audience.custom !== "object" || Array.isArray(audience.custom)) {
+        throw new Error(`${source}: "audience.custom" must be an object`);
+      }
+      parsedAudience.custom = audience.custom;
+    }
+    entry.audience = parsedAudience;
+  }
+  return entry;
+}
+function normalizePattern(pattern) {
+  const normalized = pattern.replaceAll("\\", "/");
+  if (normalized.endsWith("/**/*.md")) {
+    return {
+      baseDir: normalized.slice(0, -"/**/*.md".length),
+      ext: ".md"
+    };
+  }
+  throw new Error(`Unsupported pattern "${pattern}". Use "features/**/*.md" style patterns.`);
+}
+async function collectFiles(dir, ext) {
+  const out = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await promises.readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+        continue;
+      }
+      if (entry.isFile() && entry.name.endsWith(ext)) {
+        out.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return out.sort();
+}
+async function buildManifestFromPattern(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const pattern = options.pattern ?? "features/**/*.md";
+  const { baseDir, ext } = normalizePattern(pattern);
+  const baseAbs = path.join(cwd, baseDir);
+  const stats = await promises.stat(baseAbs).catch(() => null);
+  if (!stats || !stats.isDirectory()) {
+    throw new Error(`Pattern base directory does not exist: ${baseDir}`);
+  }
+  const files = await collectFiles(baseAbs, ext);
+  const entries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const file of files) {
+    const content = await promises.readFile(file, "utf8");
+    const source = path.relative(cwd, file).split(path.sep).join("/");
+    const entry = parseFeatureFile(content, source);
+    if (seenIds.has(entry.id)) {
+      throw new Error(`Duplicate feature id "${entry.id}" found at ${source}`);
+    }
+    seenIds.add(entry.id);
+    entries.push(entry);
+  }
+  if (options.outFile) {
+    const outPath = path.join(cwd, options.outFile);
+    await promises.writeFile(outPath, `${JSON.stringify(entries, null, 2)}
+`, "utf8");
+  }
+  return entries;
+}
+
+// src/cms.ts
+var DEFAULT_FIELDS = {
+  id: "id",
+  label: "label",
+  releasedAt: "releasedAt",
+  showNewUntil: "showNewUntil",
+  description: "description",
+  sidebarKey: "sidebarKey",
+  category: "category",
+  product: "product",
+  flagKey: "flagKey",
+  url: "url",
+  image: "image",
+  publishAt: "publishAt",
+  type: "type",
+  priority: "priority",
+  ctaLabel: "cta.label",
+  ctaUrl: "cta.url"
+};
+function getByPath(record, path) {
+  const parts = path.split(".").filter(Boolean);
+  let cursor = record;
+  for (const part of parts) {
+    if (!cursor || typeof cursor !== "object") return void 0;
+    cursor = cursor[part];
+  }
+  return cursor;
+}
+function normalizeLocalizedValue(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const objectValue = value;
+    const keys = Object.keys(objectValue);
+    if (keys.length === 1) {
+      const nested = objectValue[keys[0]];
+      if (typeof nested === "string" || typeof nested === "number" || typeof nested === "boolean" || nested == null) {
+        return nested;
+      }
+    }
+  }
+  return value;
+}
+function resolveField(record, resolver) {
+  if (!resolver) return void 0;
+  if (typeof resolver === "function") return resolver(record);
+  return normalizeLocalizedValue(getByPath(record, resolver));
+}
+function asString2(value) {
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed ? trimmed : void 0;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return void 0;
+}
+function normalizeFieldMapping(defaults, overrides) {
+  return {
+    ...defaults,
+    ...overrides
+  };
+}
+function validateMappedEntries(entries, options) {
+  const strictValidation = options?.strictValidation ?? false;
+  const validEntries = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  const errors = [];
+  for (const entry of entries) {
+    if (seenIds.has(entry.id)) {
+      errors.push(`${entry.id}: duplicate id`);
+      continue;
+    }
+    seenIds.add(entry.id);
+    const validation = validateManifest([entry]);
+    if (validation.valid) {
+      validEntries.push(entry);
+      continue;
+    }
+    const reason = validation.errors.map((error) => `${error.path} ${error.message}`).join("; ");
+    errors.push(`${entry.id}: ${reason}`);
+  }
+  if (errors.length > 0) {
+    if (strictValidation) {
+      throw new Error(`[featuredrop] CMS mapping validation failed: ${errors.join(" | ")}`);
+    }
+    if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+      console.warn(`[featuredrop] Skipped ${errors.length} invalid CMS entries.`);
+    }
+  }
+  return validEntries;
+}
+function mapRecordToFeatureEntry(record, mapping) {
+  const id = asString2(resolveField(record, mapping.id));
+  const label = asString2(resolveField(record, mapping.label));
+  const releasedAt = asString2(resolveField(record, mapping.releasedAt));
+  const showNewUntil = asString2(resolveField(record, mapping.showNewUntil));
+  if (!id || !label || !releasedAt || !showNewUntil) return null;
+  const entry = {
+    id,
+    label,
+    releasedAt,
+    showNewUntil
+  };
+  const description = asString2(resolveField(record, mapping.description));
+  if (description) entry.description = description;
+  const sidebarKey = asString2(resolveField(record, mapping.sidebarKey));
+  if (sidebarKey) entry.sidebarKey = sidebarKey;
+  const category = asString2(resolveField(record, mapping.category));
+  if (category) entry.category = category;
+  const product = asString2(resolveField(record, mapping.product));
+  if (product) entry.product = product;
+  const flagKey = asString2(resolveField(record, mapping.flagKey));
+  if (flagKey) entry.flagKey = flagKey;
+  const url = asString2(resolveField(record, mapping.url));
+  if (url) entry.url = url;
+  const image = asString2(resolveField(record, mapping.image));
+  if (image) entry.image = image;
+  const publishAt = asString2(resolveField(record, mapping.publishAt));
+  if (publishAt) entry.publishAt = publishAt;
+  const type = asString2(resolveField(record, mapping.type));
+  if (type && ["feature", "improvement", "fix", "breaking"].includes(type)) {
+    entry.type = type;
+  }
+  const priority = asString2(resolveField(record, mapping.priority));
+  if (priority && ["critical", "normal", "low"].includes(priority)) {
+    entry.priority = priority;
+  }
+  const ctaLabel = asString2(resolveField(record, mapping.ctaLabel));
+  const ctaUrl = asString2(resolveField(record, mapping.ctaUrl));
+  if (ctaLabel && ctaUrl) {
+    entry.cta = { label: ctaLabel, url: ctaUrl };
+  }
+  return entry;
+}
+async function fetchJson(input, init) {
+  const response = await fetch(input, init);
+  if (!response.ok) {
+    throw new Error(`[featuredrop] CMS request failed (${response.status}) for ${input}`);
+  }
+  return response.json();
+}
+var ContentfulAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const environment = this.options.environment ?? "master";
+    const params = new URLSearchParams({
+      content_type: this.options.contentType,
+      limit: String(this.options.limit ?? 1e3)
+    });
+    if (this.options.locale) {
+      params.set("locale", this.options.locale);
+    }
+    const url = `https://cdn.contentful.com/spaces/${encodeURIComponent(this.options.spaceId)}/environments/${encodeURIComponent(environment)}/entries?${params.toString()}`;
+    const payload = await fetchJson(url, {
+      headers: {
+        Authorization: `Bearer ${this.options.accessToken}`
+      }
+    });
+    const mapping = normalizeFieldMapping(
+      {
+        ...DEFAULT_FIELDS,
+        id: "sys.id",
+        label: "fields.label",
+        description: "fields.description",
+        releasedAt: "fields.releasedAt",
+        showNewUntil: "fields.showNewUntil",
+        sidebarKey: "fields.sidebarKey",
+        category: "fields.category",
+        product: "fields.product",
+        flagKey: "fields.flagKey",
+        url: "fields.url",
+        image: "fields.image",
+        publishAt: "fields.publishAt",
+        type: "fields.type",
+        priority: "fields.priority",
+        ctaLabel: "fields.ctaLabel",
+        ctaUrl: "fields.ctaUrl"
+      },
+      this.options.fieldMapping
+    );
+    const entries = (payload.items ?? []).map((item) => mapRecordToFeatureEntry(item, mapping)).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+var SanityAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const version = this.options.apiVersion ?? "v2023-10-01";
+    const queryParam = encodeURIComponent(this.options.query);
+    const url = `https://${encodeURIComponent(this.options.projectId)}.api.sanity.io/${version}/data/query/${encodeURIComponent(this.options.dataset)}?query=${queryParam}`;
+    const headers = {};
+    if (this.options.token) {
+      headers.Authorization = `Bearer ${this.options.token}`;
+    }
+    const payload = await fetchJson(url, {
+      headers
+    });
+    const mapping = normalizeFieldMapping(
+      {
+        ...DEFAULT_FIELDS,
+        id: "_id"
+      },
+      this.options.fieldMapping
+    );
+    const entries = (payload.result ?? []).map((item) => mapRecordToFeatureEntry(item, mapping)).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+var StrapiAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const endpoint = this.options.endpoint ?? "/api/features";
+    const base = this.options.baseUrl.replace(/\/+$/, "");
+    const query = this.options.query ? `?${this.options.query}` : "";
+    const url = `${base}${endpoint}${query}`;
+    const headers = {};
+    if (this.options.token) {
+      headers.Authorization = `Bearer ${this.options.token}`;
+    }
+    const payload = await fetchJson(url, { headers });
+    const mapping = normalizeFieldMapping(DEFAULT_FIELDS, this.options.fieldMapping);
+    const entries = (payload.data ?? []).map((item) => {
+      if (!item || typeof item !== "object") return null;
+      const record = item;
+      const attributes = record.attributes;
+      if (attributes && typeof attributes === "object") {
+        return mapRecordToFeatureEntry(
+          { id: record.id, ...attributes },
+          mapping
+        );
+      }
+      return mapRecordToFeatureEntry(record, mapping);
+    }).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+function notionPropertyToValue(property) {
+  if (!property || typeof property !== "object") return void 0;
+  const typed = property;
+  const type = typed.type;
+  if (typeof type !== "string") return void 0;
+  const value = typed[type];
+  if (type === "title" || type === "rich_text") {
+    if (!Array.isArray(value)) return void 0;
+    return value.map((item) => {
+      if (!item || typeof item !== "object") return "";
+      return asString2(item.plain_text) ?? "";
+    }).join("").trim();
+  }
+  if (type === "select") {
+    if (!value || typeof value !== "object") return void 0;
+    return asString2(value.name);
+  }
+  if (type === "multi_select") {
+    if (!Array.isArray(value)) return void 0;
+    return value.map((item) => item && typeof item === "object" ? asString2(item.name) : void 0).filter((item) => Boolean(item));
+  }
+  if (type === "date") {
+    if (!value || typeof value !== "object") return void 0;
+    return asString2(value.start);
+  }
+  if (type === "number" || type === "url" || type === "email" || type === "phone_number") {
+    return value;
+  }
+  if (type === "checkbox") {
+    return value === true ? "true" : value === false ? "false" : void 0;
+  }
+  return void 0;
+}
+function flattenNotionPage(page) {
+  if (!page || typeof page !== "object") return {};
+  const record = page;
+  const properties = record.properties;
+  const flattened = {
+    id: record.id
+  };
+  if (properties && typeof properties === "object") {
+    Object.entries(properties).forEach(([key, value]) => {
+      flattened[key] = notionPropertyToValue(value);
+    });
+  }
+  return flattened;
+}
+var NotionAdapter = class {
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  async load() {
+    const body = {};
+    if (this.options.filter) body.filter = this.options.filter;
+    if (this.options.sorts) body.sorts = this.options.sorts;
+    const payload = await fetchJson(
+      `https://api.notion.com/v1/databases/${encodeURIComponent(this.options.databaseId)}/query`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.options.token}`,
+          "Notion-Version": this.options.notionVersion ?? "2022-06-28"
+        },
+        body: JSON.stringify(body)
+      }
+    );
+    const mapping = normalizeFieldMapping(DEFAULT_FIELDS, this.options.fieldMapping);
+    const entries = (payload.results ?? []).map((page) => mapRecordToFeatureEntry(flattenNotionPage(page), mapping)).filter((entry) => entry !== null);
+    return validateMappedEntries(entries, this.options);
+  }
+};
+var MarkdownAdapter = class {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async load() {
+    if (this.options.pattern) {
+      const entries2 = await buildManifestFromPattern({
+        cwd: this.options.cwd,
+        pattern: this.options.pattern
+      });
+      return validateMappedEntries(entries2, this.options);
+    }
+    const entries = this.options.entries ?? [];
+    const mapped = entries.map((entry, index) => {
+      const source = entry.source ?? `feature-${index + 1}.md`;
+      return parseFeatureFile(entry.markdown, source);
+    });
+    return validateMappedEntries(mapped, this.options);
+  }
+};
+
+// src/theme.ts
+var LIGHT_THEME = {
+  colors: {
+    primary: "#2563eb",
+    background: "#ffffff",
+    text: "#111827",
+    textMuted: "#6b7280",
+    border: "#e5e7eb",
+    success: "#16a34a",
+    warning: "#f59e0b",
+    error: "#dc2626"
+  },
+  fonts: {
+    family: "system-ui, -apple-system, Segoe UI, sans-serif",
+    sizeBase: "14px",
+    sizeSm: "12px",
+    sizeLg: "16px"
+  },
+  spacing: {
+    xs: "4px",
+    sm: "8px",
+    md: "12px",
+    lg: "16px",
+    xl: "24px"
+  },
+  radii: {
+    sm: "6px",
+    md: "8px",
+    lg: "12px",
+    full: "999px"
+  },
+  shadows: {
+    sm: "0 2px 8px rgba(0, 0, 0, 0.08)",
+    md: "0 8px 24px rgba(0, 0, 0, 0.12)",
+    lg: "0 20px 60px rgba(0, 0, 0, 0.16)"
+  },
+  zIndex: {
+    base: 9998,
+    tooltip: 1e4,
+    modal: 10001,
+    overlay: 9997
+  }
+};
+var DARK_THEME = {
+  ...LIGHT_THEME,
+  colors: {
+    primary: "#60a5fa",
+    background: "#0b1220",
+    text: "#f3f4f6",
+    textMuted: "#9ca3af",
+    border: "#1f2937",
+    success: "#4ade80",
+    warning: "#fbbf24",
+    error: "#f87171"
+  },
+  shadows: {
+    sm: "0 2px 8px rgba(0, 0, 0, 0.35)",
+    md: "0 8px 24px rgba(0, 0, 0, 0.42)",
+    lg: "0 20px 60px rgba(0, 0, 0, 0.52)"
+  }
+};
+var MINIMAL_THEME = {
+  ...LIGHT_THEME,
+  colors: {
+    ...LIGHT_THEME.colors,
+    primary: "#111827",
+    background: "#ffffff",
+    text: "#111827",
+    textMuted: "#6b7280",
+    border: "#d1d5db",
+    success: "#111827",
+    warning: "#111827",
+    error: "#111827"
+  },
+  shadows: {
+    sm: "none",
+    md: "none",
+    lg: "none"
+  },
+  radii: {
+    sm: "0",
+    md: "0",
+    lg: "0",
+    full: "0"
+  }
+};
+var VIBRANT_THEME = {
+  ...LIGHT_THEME,
+  colors: {
+    primary: "#ec4899",
+    background: "#fff7ed",
+    text: "#3f1d57",
+    textMuted: "#6d4c84",
+    border: "#fdba74",
+    success: "#10b981",
+    warning: "#f59e0b",
+    error: "#ef4444"
+  },
+  shadows: {
+    sm: "0 2px 10px rgba(236, 72, 153, 0.15)",
+    md: "0 10px 26px rgba(236, 72, 153, 0.22)",
+    lg: "0 22px 58px rgba(236, 72, 153, 0.28)"
+  }
+};
+var FEATUREDROP_THEMES = {
+  light: LIGHT_THEME,
+  dark: DARK_THEME,
+  minimal: MINIMAL_THEME,
+  vibrant: VIBRANT_THEME
+};
+function isThemePreset(value) {
+  return value === "light" || value === "dark" || value === "auto" || value === "minimal" || value === "vibrant";
+}
+function mergeTheme(base, overrides) {
+  if (!overrides) return base;
+  return {
+    colors: {
+      ...base.colors,
+      ...overrides.colors ?? {}
+    },
+    fonts: {
+      ...base.fonts,
+      ...overrides.fonts ?? {}
+    },
+    spacing: {
+      ...base.spacing,
+      ...overrides.spacing ?? {}
+    },
+    radii: {
+      ...base.radii,
+      ...overrides.radii ?? {}
+    },
+    shadows: {
+      ...base.shadows,
+      ...overrides.shadows ?? {}
+    },
+    zIndex: {
+      ...base.zIndex,
+      ...overrides.zIndex ?? {}
+    }
+  };
+}
+function createTheme(overrides, base = LIGHT_THEME) {
+  return mergeTheme(base, overrides);
+}
+function resolveTheme(input = "light", options = {}) {
+  if (isThemePreset(input)) {
+    if (input === "auto") {
+      return options.prefersDark ? DARK_THEME : LIGHT_THEME;
+    }
+    return FEATUREDROP_THEMES[input];
+  }
+  return mergeTheme(LIGHT_THEME, input);
+}
+function applyThemeSection(vars, key, values) {
+  for (const [token, value] of Object.entries(values)) {
+    vars[`--featuredrop-${key}-${token}`] = value;
+  }
+}
+function themeToCSSVariables(theme) {
+  const vars = {};
+  applyThemeSection(vars, "color", theme.colors);
+  applyThemeSection(vars, "font", theme.fonts);
+  applyThemeSection(vars, "space", theme.spacing);
+  applyThemeSection(vars, "radius", theme.radii);
+  applyThemeSection(vars, "shadow", theme.shadows);
+  applyThemeSection(vars, "z", theme.zIndex);
+  vars["--featuredrop-font-family"] = theme.fonts.family;
+  vars["--featuredrop-widget-bg"] = theme.colors.background;
+  vars["--featuredrop-trigger-bg"] = theme.colors.background;
+  vars["--featuredrop-trigger-color"] = theme.colors.text;
+  vars["--featuredrop-entry-title-color"] = theme.colors.text;
+  vars["--featuredrop-entry-desc-color"] = theme.colors.textMuted;
+  vars["--featuredrop-title-color"] = theme.colors.text;
+  vars["--featuredrop-border-color"] = theme.colors.border;
+  vars["--featuredrop-cta-bg"] = theme.colors.primary;
+  vars["--featuredrop-cta-color"] = theme.colors.background;
+  vars["--featuredrop-mark-all-color"] = theme.colors.primary;
+  vars["--featuredrop-widget-shadow"] = theme.shadows.md;
+  vars["--featuredrop-widget-radius"] = theme.radii.lg;
+  vars["--featuredrop-trigger-radius"] = theme.radii.md;
+  vars["--featuredrop-badge-bg"] = theme.colors.warning;
+  vars["--featuredrop-z-index"] = theme.zIndex.base;
+  vars["--featuredrop-toast-z-index"] = theme.zIndex.tooltip;
+  vars["--featuredrop-tour-z-index"] = theme.zIndex.modal;
+  vars["--featuredrop-tour-overlay-z-index"] = theme.zIndex.overlay;
+  return vars;
+}
+
+// src/i18n.ts
+var EN_TRANSLATIONS = {
+  newBadge: "New",
+  whatsNewTitle: "What's New",
+  markAllRead: "Mark all as read",
+  allCaughtUp: "You're all caught up!",
+  close: "Close",
+  changelogTitle: "Changelog",
   searchPlaceholder: "Search updates",
   allCategories: "All categories",
   noUpdatesYet: "No updates yet",
   loadMore: "Load more",
   share: "Share",
   skipToEntries: "Skip to changelog entries",
+  newFeatureCount: (count) => count === 0 ? "No new features" : `${count} new feature${count === 1 ? "" : "s"}`,
   stepOf: (current, total) => `Step ${current} of ${total}`,
   back: "Back",
   next: "Next",
@@ -1030,14 +2579,128 @@ var SIMPLE_TRANSLATIONS = {
     askLater: "\u092C\u093E\u0926 \u092E\u0947\u0902 \u092A\u0942\u091B\u0947\u0902"
   }
 };
+var RTL_LANGUAGES = /* @__PURE__ */ new Set(["ar", "fa", "he", "ur"]);
+var STEP_OF_TRANSLATIONS = {
+  en: EN_TRANSLATIONS.stepOf,
+  es: (current, total) => `Paso ${current} de ${total}`,
+  fr: (current, total) => `Etape ${current} sur ${total}`,
+  de: (current, total) => `Schritt ${current} von ${total}`,
+  pt: (current, total) => `Etapa ${current} de ${total}`,
+  "zh-cn": (current, total) => `\u7B2C ${current} / ${total} \u6B65`,
+  ja: (current, total) => `${total}\u4E2D${current}\u756A\u76EE`,
+  ko: (current, total) => `${total}\uB2E8\uACC4 \uC911 ${current}\uB2E8\uACC4`,
+  ar: (current, total) => `\u0627\u0644\u062E\u0637\u0648\u0629 ${current} \u0645\u0646 ${total}`,
+  hi: (current, total) => `${total} \u092E\u0947\u0902 \u0938\u0947 \u091A\u0930\u0923 ${current}`
+};
+var NEW_FEATURE_COUNT_TRANSLATIONS = {
+  en: EN_TRANSLATIONS.newFeatureCount,
+  es: (count) => count === 0 ? "Sin novedades" : `${count} novedad${count === 1 ? "" : "es"}`,
+  fr: (count) => count === 0 ? "Aucune nouveaute" : `${count} nouveaute${count === 1 ? "" : "s"}`,
+  de: (count) => count === 0 ? "Keine neuen Features" : `${count} ${count === 1 ? "neues Feature" : "neue Features"}`,
+  pt: (count) => count === 0 ? "Sem novidades" : `${count} novidade${count === 1 ? "" : "s"}`,
+  "zh-cn": (count) => count === 0 ? "\u6682\u65E0\u66F4\u65B0" : `${count} \u6761\u65B0\u66F4\u65B0`,
+  ja: (count) => count === 0 ? "\u65B0\u7740\u306F\u3042\u308A\u307E\u305B\u3093" : `\u65B0\u7740 ${count} \u4EF6`,
+  ko: (count) => count === 0 ? "\uC0C8 \uC18C\uC2DD \uC5C6\uC74C" : `\uC0C8 \uC18C\uC2DD ${count}\uAC1C`,
+  ar: (count) => {
+    if (count === 0) return "\u0644\u0627 \u062A\u0648\u062C\u062F \u0645\u064A\u0632\u0627\u062A \u062C\u062F\u064A\u062F\u0629";
+    const category = new Intl.PluralRules("ar").select(count);
+    if (category === "one") return "\u0645\u064A\u0632\u0629 \u062C\u062F\u064A\u062F\u0629 \u0648\u0627\u062D\u062F\u0629";
+    if (category === "two") return "\u0645\u064A\u0632\u062A\u0627\u0646 \u062C\u062F\u064A\u062F\u062A\u0627\u0646";
+    return `${count} \u0645\u064A\u0632\u0627\u062A \u062C\u062F\u064A\u062F\u0629`;
+  },
+  hi: (count) => count === 0 ? "\u0915\u094B\u0908 \u0928\u092F\u093E \u0905\u092A\u0921\u0947\u091F \u0928\u0939\u0940\u0902" : `${count} ${count === 1 ? "\u0928\u092F\u093E \u0905\u092A\u0921\u0947\u091F" : "\u0928\u090F \u0905\u092A\u0921\u0947\u091F"}`
+};
+function resolveLocale(locale) {
+  const normalized = (locale ?? "en").toLowerCase();
+  if (normalized === "en" || normalized.startsWith("en-")) return "en";
+  if (Object.prototype.hasOwnProperty.call(SIMPLE_TRANSLATIONS, normalized)) {
+    return normalized;
+  }
+  const base = normalized.split("-")[0];
+  if (base === "en") return "en";
+  if (Object.prototype.hasOwnProperty.call(SIMPLE_TRANSLATIONS, base)) {
+    return base;
+  }
+  return "en";
+}
+function getLocaleDirection(locale) {
+  const resolved = resolveLocale(locale);
+  const base = resolved.split("-")[0];
+  return RTL_LANGUAGES.has(base) ? "rtl" : "ltr";
+}
+function formatDateForLocale(value, locale, options = {
+  month: "short",
+  day: "numeric",
+  year: "numeric"
+}) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return "";
+  const resolved = resolveLocale(locale);
+  try {
+    return new Intl.DateTimeFormat(resolved, options).format(date);
+  } catch {
+    return date.toLocaleDateString(void 0, options);
+  }
+}
+function formatRelativeTimeForLocale(value, locale, options) {
+  const target = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(target.getTime())) return "";
+  const nowInput = options?.now;
+  const nowDate = nowInput instanceof Date ? nowInput : typeof nowInput !== "undefined" ? new Date(nowInput) : /* @__PURE__ */ new Date();
+  if (Number.isNaN(nowDate.getTime())) return "";
+  const diffMs = target.getTime() - nowDate.getTime();
+  const absDiff = Math.abs(diffMs);
+  const minute = 6e4;
+  const hour = 60 * minute;
+  const day = 24 * hour;
+  const week = 7 * day;
+  const month = 30 * day;
+  const year = 365 * day;
+  let unit = "second";
+  let divisor = 1e3;
+  if (absDiff >= year) {
+    unit = "year";
+    divisor = year;
+  } else if (absDiff >= month) {
+    unit = "month";
+    divisor = month;
+  } else if (absDiff >= week) {
+    unit = "week";
+    divisor = week;
+  } else if (absDiff >= day) {
+    unit = "day";
+    divisor = day;
+  } else if (absDiff >= hour) {
+    unit = "hour";
+    divisor = hour;
+  } else if (absDiff >= minute) {
+    unit = "minute";
+    divisor = minute;
+  }
+  const relativeValue = Math.round(diffMs / divisor);
+  const resolvedLocale = resolveLocale(locale);
+  try {
+    const formatter = new Intl.RelativeTimeFormat(resolvedLocale, {
+      numeric: options?.numeric ?? "auto",
+      style: options?.style ?? "long"
+    });
+    return formatter.format(relativeValue, unit);
+  } catch {
+    const fallback = formatDateForLocale(target, resolvedLocale);
+    return fallback || target.toISOString();
+  }
+}
 function resolveTranslations(locale, overrides) {
-  const normalizedLocale = (locale ?? "en").toLowerCase();
-  const base = SIMPLE_TRANSLATIONS[normalizedLocale] ?? SIMPLE_TRANSLATIONS[normalizedLocale.split("-")[0]] ?? {};
+  const resolvedLocale = resolveLocale(locale);
+  const base = resolvedLocale === "en" ? {} : SIMPLE_TRANSLATIONS[resolvedLocale] ?? {};
+  const stepOf = overrides?.stepOf ?? STEP_OF_TRANSLATIONS[resolvedLocale] ?? STEP_OF_TRANSLATIONS.en;
+  const newFeatureCount = overrides?.newFeatureCount ?? NEW_FEATURE_COUNT_TRANSLATIONS[resolvedLocale] ?? NEW_FEATURE_COUNT_TRANSLATIONS.en;
   return {
     ...EN_TRANSLATIONS,
     ...base,
     ...overrides ?? {},
-    stepOf: overrides?.stepOf ?? EN_TRANSLATIONS.stepOf
+    stepOf,
+    newFeatureCount
   };
 }
 var FEATUREDROP_TRANSLATIONS = {
@@ -1045,38 +2708,71 @@ var FEATUREDROP_TRANSLATIONS = {
   ...SIMPLE_TRANSLATIONS
 };
 
-// src/rss.ts
-function escape(str) {
-  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+// src/animation.ts
+var FEATUREDROP_ANIMATION_PRESETS = [
+  "none",
+  "subtle",
+  "normal",
+  "playful"
+];
+function resolveAnimationPreset(preset = "normal", options) {
+  if (options?.reducedMotion) return "none";
+  return preset;
 }
-function generateRSS(manifest, options) {
-  const title = escape(options?.title ?? "Featuredrop Changelog");
-  const link = escape(options?.link ?? "");
-  const desc = escape(options?.description ?? "Product updates");
-  const items = manifest.slice().sort((a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()).map((item) => {
-    const descriptionHtml = item.description ? parseDescription(item.description) : "";
-    const itemLink = item.url ? escape(item.url) : "";
-    return [
-      "<item>",
-      `<title>${escape(item.label)}</title>`,
-      itemLink ? `<link>${itemLink}</link>` : "",
-      `<guid isPermaLink="false">${escape(item.id)}</guid>`,
-      `<pubDate>${new Date(item.releasedAt).toUTCString()}</pubDate>`,
-      `<description><![CDATA[${descriptionHtml}]]></description>`,
-      "</item>"
-    ].join("");
-  }).join("");
-  return [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<rss version="2.0">',
-    "<channel>",
-    `<title>${title}</title>`,
-    link ? `<link>${link}</link>` : "",
-    `<description>${desc}</description>`,
-    items,
-    "</channel>",
-    "</rss>"
-  ].join("");
+function getEnterAnimation(preset, surface) {
+  if (preset === "none") return void 0;
+  if (preset === "subtle") {
+    if (surface === "panel") return "featuredrop-enter-panel 180ms ease-out";
+    if (surface === "modal") return "featuredrop-enter-scale 180ms ease-out";
+    return "featuredrop-enter-fade-up 170ms ease-out";
+  }
+  if (preset === "playful") {
+    if (surface === "panel") return "featuredrop-enter-panel 320ms cubic-bezier(0.2, 0.9, 0.2, 1)";
+    return "featuredrop-enter-pop 300ms cubic-bezier(0.22, 1.4, 0.36, 1)";
+  }
+  if (surface === "panel") return "featuredrop-enter-panel 240ms cubic-bezier(0.2, 0.9, 0.2, 1)";
+  if (surface === "modal") return "featuredrop-enter-scale 220ms cubic-bezier(0.2, 0.9, 0.2, 1)";
+  return "featuredrop-enter-fade-up 210ms cubic-bezier(0.2, 0.9, 0.2, 1)";
+}
+function getExitAnimation(preset, surface) {
+  if (preset === "none") return void 0;
+  if (preset === "subtle") {
+    if (surface === "panel") return "featuredrop-exit-panel 150ms ease-in forwards";
+    if (surface === "modal") return "featuredrop-exit-scale 150ms ease-in forwards";
+    return "featuredrop-exit-fade-down 140ms ease-in forwards";
+  }
+  if (preset === "playful") {
+    if (surface === "panel") return "featuredrop-exit-panel 260ms ease-in forwards";
+    return "featuredrop-exit-pop 240ms ease-in forwards";
+  }
+  if (surface === "panel") return "featuredrop-exit-panel 200ms ease-in forwards";
+  if (surface === "modal") return "featuredrop-exit-scale 190ms ease-in forwards";
+  return "featuredrop-exit-fade-down 180ms ease-in forwards";
+}
+function getPulseAnimation(preset, surface = "beacon") {
+  if (preset === "none") return void 0;
+  if (surface === "dot") {
+    if (preset === "subtle") return "featuredrop-pulse 2.6s ease-in-out infinite";
+    if (preset === "playful") {
+      return "featuredrop-pulse-playful 1.8s cubic-bezier(0.22, 1.4, 0.36, 1) infinite";
+    }
+    return "featuredrop-pulse 2s ease-in-out infinite";
+  }
+  if (preset === "subtle") return "featuredrop-beacon-pulse 2.6s ease-in-out infinite";
+  if (preset === "playful") {
+    return "featuredrop-beacon-pop-pulse 1.8s cubic-bezier(0.22, 1.4, 0.36, 1) infinite";
+  }
+  return "featuredrop-beacon-pulse 2s ease-in-out infinite";
+}
+function getAnimationDurationMs(preset, surface, phase) {
+  if (preset === "none") return 0;
+  const animation = phase === "enter" ? getEnterAnimation(preset, surface) : getExitAnimation(preset, surface);
+  if (!animation) return 0;
+  const msMatch = animation.match(/(\d+)ms/);
+  if (msMatch?.[1]) return Number(msMatch[1]);
+  const sMatch = animation.match(/(\d+(?:\.\d+)?)s/);
+  if (sMatch?.[1]) return Math.round(Number(sMatch[1]) * 1e3);
+  return 0;
 }
 
 // src/throttle.ts
@@ -1261,170 +2957,66 @@ var SegmentAdapter = class {
       ...event.metadata
     });
   }
-};
-var CustomAdapter = class {
-  constructor(handler) {
-    this.handler = handler;
-  }
-  track(event) {
-    return this.handler(event);
-  }
-};
-function createAdoptionMetrics(events) {
-  const getAdoptionRate = (featureId) => {
-    const seen = events.filter((event) => event.type === "feature_seen" && event.featureId === featureId).length;
-    if (seen === 0) return 0;
-    const clicked = events.filter((event) => event.type === "feature_clicked" && event.featureId === featureId).length;
-    return clicked / seen;
-  };
-  const getTourCompletionRate = (tourId) => {
-    const started = events.filter((event) => event.type === "tour_started" && event.tourId === tourId).length;
-    if (started === 0) return 0;
-    const completed = events.filter((event) => event.type === "tour_completed" && event.tourId === tourId).length;
-    return completed / started;
-  };
-  const getChecklistCompletionRate = (checklistId) => {
-    const taskCompleted = events.filter(
-      (event) => event.type === "checklist_task_completed" && event.metadata?.checklistId === checklistId
-    ).length;
-    if (taskCompleted === 0) return 0;
-    const completed = events.filter(
-      (event) => event.type === "checklist_completed" && event.metadata?.checklistId === checklistId
-    ).length;
-    return completed / taskCompleted;
-  };
-  const getFeatureEngagement = (featureId) => ({
-    seen: events.filter((event) => event.type === "feature_seen" && event.featureId === featureId).length,
-    clicked: events.filter((event) => event.type === "feature_clicked" && event.featureId === featureId).length,
-    dismissed: events.filter((event) => event.type === "feature_dismissed" && event.featureId === featureId).length
-  });
-  const getVariantPerformance = (featureId) => {
-    const byVariant = /* @__PURE__ */ new Map();
-    for (const event of events) {
-      if (event.featureId !== featureId) continue;
-      const variant = event.variant ?? "control";
-      const bucket = byVariant.get(variant) ?? { seen: 0, clicked: 0 };
-      if (event.type === "feature_seen") bucket.seen += 1;
-      if (event.type === "feature_clicked") bucket.clicked += 1;
-      byVariant.set(variant, bucket);
-    }
-    const output = {};
-    for (const [variant, bucket] of byVariant.entries()) {
-      output[variant] = bucket.seen === 0 ? 0 : bucket.clicked / bucket.seen;
-    }
-    return output;
-  };
-  return {
-    getAdoptionRate,
-    getTourCompletionRate,
-    getChecklistCompletionRate,
-    getFeatureEngagement,
-    getVariantPerformance
-  };
-}
-
-// src/dependencies.ts
-function getDirectDependencies(feature) {
-  const dependsOn = feature.dependsOn;
-  if (!dependsOn) return [];
-  const seen = dependsOn.seen ?? [];
-  const clicked = dependsOn.clicked ?? [];
-  const dismissed = dependsOn.dismissed ?? [];
-  const unique = /* @__PURE__ */ new Set();
-  for (const id of [...seen, ...clicked, ...dismissed]) {
-    if (id) unique.add(id);
-  }
-  return Array.from(unique);
-}
-function resolveDependencyOrder(manifest) {
-  const ids = new Set(manifest.map((feature) => feature.id));
-  const outgoing = /* @__PURE__ */ new Map();
-  const indegree = /* @__PURE__ */ new Map();
-  for (const feature of manifest) {
-    outgoing.set(feature.id, /* @__PURE__ */ new Set());
-    indegree.set(feature.id, 0);
-  }
-  for (const feature of manifest) {
-    for (const dependencyId of getDirectDependencies(feature)) {
-      if (!ids.has(dependencyId)) continue;
-      const edges = outgoing.get(dependencyId);
-      if (!edges || edges.has(feature.id)) continue;
-      edges.add(feature.id);
-      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
-    }
-  }
-  const queue = [];
-  for (const feature of manifest) {
-    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
-  }
-  const ordered = [];
-  while (queue.length > 0) {
-    const id = queue.shift();
-    if (!id) continue;
-    ordered.push(id);
-    const edges = outgoing.get(id);
-    if (!edges) continue;
-    for (const nextId of edges) {
-      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
-      indegree.set(nextId, nextDegree);
-      if (nextDegree === 0) queue.push(nextId);
-    }
-  }
-  if (ordered.length < manifest.length) {
-    const included = new Set(ordered);
-    for (const feature of manifest) {
-      if (included.has(feature.id)) continue;
-      ordered.push(feature.id);
-    }
-  }
-  return ordered;
-}
-function hasDependencyCycle(manifest) {
-  const ids = new Set(manifest.map((feature) => feature.id));
-  const outgoing = /* @__PURE__ */ new Map();
-  const indegree = /* @__PURE__ */ new Map();
-  for (const feature of manifest) {
-    outgoing.set(feature.id, /* @__PURE__ */ new Set());
-    indegree.set(feature.id, 0);
-  }
-  for (const feature of manifest) {
-    for (const dependencyId of getDirectDependencies(feature)) {
-      if (!ids.has(dependencyId)) continue;
-      const edges = outgoing.get(dependencyId);
-      if (!edges || edges.has(feature.id)) continue;
-      edges.add(feature.id);
-      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
-    }
-  }
-  const queue = [];
-  for (const feature of manifest) {
-    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+};
+var CustomAdapter = class {
+  constructor(handler) {
+    this.handler = handler;
   }
-  let visited = 0;
-  while (queue.length > 0) {
-    const id = queue.shift();
-    if (!id) continue;
-    visited += 1;
-    const edges = outgoing.get(id);
-    if (!edges) continue;
-    for (const nextId of edges) {
-      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
-      indegree.set(nextId, nextDegree);
-      if (nextDegree === 0) queue.push(nextId);
-    }
+  track(event) {
+    return this.handler(event);
   }
-  return visited !== manifest.length;
-}
-function sortFeaturesByDependencies(features) {
-  if (features.length <= 1) return [...features];
-  const order = resolveDependencyOrder(features);
-  const rank = new Map(order.map((id, index) => [id, index]));
-  return [...features].sort((a, b) => {
-    const ra = rank.get(a.id);
-    const rb = rank.get(b.id);
-    if (ra === void 0 || rb === void 0) return 0;
-    return ra - rb;
+};
+function createAdoptionMetrics(events) {
+  const getAdoptionRate = (featureId) => {
+    const seen = events.filter((event) => event.type === "feature_seen" && event.featureId === featureId).length;
+    if (seen === 0) return 0;
+    const clicked = events.filter((event) => event.type === "feature_clicked" && event.featureId === featureId).length;
+    return clicked / seen;
+  };
+  const getTourCompletionRate = (tourId) => {
+    const started = events.filter((event) => event.type === "tour_started" && event.tourId === tourId).length;
+    if (started === 0) return 0;
+    const completed = events.filter((event) => event.type === "tour_completed" && event.tourId === tourId).length;
+    return completed / started;
+  };
+  const getChecklistCompletionRate = (checklistId) => {
+    const taskCompleted = events.filter(
+      (event) => event.type === "checklist_task_completed" && event.metadata?.checklistId === checklistId
+    ).length;
+    if (taskCompleted === 0) return 0;
+    const completed = events.filter(
+      (event) => event.type === "checklist_completed" && event.metadata?.checklistId === checklistId
+    ).length;
+    return completed / taskCompleted;
+  };
+  const getFeatureEngagement = (featureId) => ({
+    seen: events.filter((event) => event.type === "feature_seen" && event.featureId === featureId).length,
+    clicked: events.filter((event) => event.type === "feature_clicked" && event.featureId === featureId).length,
+    dismissed: events.filter((event) => event.type === "feature_dismissed" && event.featureId === featureId).length
   });
+  const getVariantPerformance = (featureId) => {
+    const byVariant = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      if (event.featureId !== featureId) continue;
+      const variant = event.variant ?? "control";
+      const bucket = byVariant.get(variant) ?? { seen: 0, clicked: 0 };
+      if (event.type === "feature_seen") bucket.seen += 1;
+      if (event.type === "feature_clicked") bucket.clicked += 1;
+      byVariant.set(variant, bucket);
+    }
+    const output = {};
+    for (const [variant, bucket] of byVariant.entries()) {
+      output[variant] = bucket.seen === 0 ? 0 : bucket.clicked / bucket.seen;
+    }
+    return output;
+  };
+  return {
+    getAdoptionRate,
+    getTourCompletionRate,
+    getChecklistCompletionRate,
+    getFeatureEngagement,
+    getVariantPerformance
+  };
 }
 
 // src/variants.ts
@@ -1554,233 +3146,79 @@ function generateMarkdownChangelog(entries) {
     if (entry.type) lines.push(`- **Type**: ${entry.type}`);
     if (entry.category) lines.push(`- **Category**: ${entry.category}`);
     if (entry.showNewUntil) lines.push(`- **Show new until**: ${entry.showNewUntil}`);
-    if (entry.cta) lines.push(`- **CTA**: [${entry.cta.label}](${entry.cta.url})`);
-    if (entry.description) {
-      lines.push("", entry.description.trim());
-    }
-    return lines.join("\n");
-  });
-  return `# Generated Changelog
-
-${sections.join("\n\n---\n\n")}
-`;
-}
-function isIsoWithTimezone(value) {
-  if (!value.includes("T")) return false;
-  if (!(value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value))) return false;
-  return Number.isFinite(new Date(value).getTime());
-}
-function runDoctor(entries, now = /* @__PURE__ */ new Date()) {
-  const checks = [];
-  const warnings = [];
-  const errors = [];
-  checks.push(`Manifest entries loaded: ${entries.length}`);
-  const ids = /* @__PURE__ */ new Set();
-  let duplicateCount = 0;
-  for (const entry of entries) {
-    if (ids.has(entry.id)) duplicateCount += 1;
-    ids.add(entry.id);
-  }
-  if (duplicateCount > 0) {
-    errors.push(`${duplicateCount} duplicate feature id(s) found`);
-  } else {
-    checks.push("No duplicate IDs");
-  }
-  let invalidDateCount = 0;
-  let reversedDateCount = 0;
-  let expiredCount = 0;
-  let scheduledCount = 0;
-  let missingDescriptionCount = 0;
-  for (const entry of entries) {
-    if (!entry.description?.trim()) missingDescriptionCount += 1;
-    if (!isIsoWithTimezone(entry.releasedAt) || !isIsoWithTimezone(entry.showNewUntil)) {
-      invalidDateCount += 1;
-      continue;
-    }
-    const released = new Date(entry.releasedAt).getTime();
-    const showUntil = new Date(entry.showNewUntil).getTime();
-    if (showUntil <= released) reversedDateCount += 1;
-    if (showUntil < now.getTime()) expiredCount += 1;
-    if (entry.publishAt) {
-      const publishMs = new Date(entry.publishAt).getTime();
-      if (Number.isFinite(publishMs) && publishMs > now.getTime()) scheduledCount += 1;
-    }
-  }
-  if (invalidDateCount > 0) {
-    errors.push(`${invalidDateCount} entries have invalid ISO 8601 dates with timezone`);
-  } else {
-    checks.push("All dates are valid ISO 8601 with timezone");
-  }
-  if (reversedDateCount > 0) {
-    errors.push(`${reversedDateCount} entries have showNewUntil before/at releasedAt`);
-  }
-  if (expiredCount > 0) warnings.push(`${expiredCount} entries have showNewUntil in the past`);
-  if (scheduledCount > 0) warnings.push(`${scheduledCount} entries have publishAt in the future`);
-  if (missingDescriptionCount > 0) {
-    errors.push(`${missingDescriptionCount} entries have no description`);
-  } else {
-    checks.push("All entries have descriptions");
-  }
-  if (hasDependencyCycle(entries)) {
-    errors.push("Circular dependsOn relationship detected");
-  } else {
-    checks.push("No circular dependencies in dependsOn chains");
-  }
-  return { checks, warnings, errors };
-}
-var featureEntryJsonSchema = {
-  type: "object",
-  required: ["id", "label", "releasedAt", "showNewUntil"],
-  properties: {
-    id: { type: "string" },
-    label: { type: "string" },
-    description: { type: "string" },
-    releasedAt: { type: "string", format: "date-time" },
-    showNewUntil: { type: "string", format: "date-time" },
-    type: { enum: ["feature", "improvement", "fix", "breaking"] },
-    priority: { enum: ["critical", "normal", "low"] }
-  }
-};
-var featureManifestJsonSchema = {
-  type: "array",
-  items: featureEntryJsonSchema
-};
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isValidDate(value) {
-  return Number.isFinite(new Date(value).getTime());
-}
-var nonEmptyString = zod.z.string().trim().min(1, "must be a non-empty string");
-var isoDateString = nonEmptyString.refine(isValidDate, {
-  message: "must be a valid date",
-  params: { featuredropCode: "invalid_date" }
-});
-var dependsOnSchema = zod.z.object({
-  seen: zod.z.array(zod.z.string()).optional(),
-  clicked: zod.z.array(zod.z.string()).optional(),
-  dismissed: zod.z.array(zod.z.string()).optional()
-}).optional();
-var featureEntrySchema = zod.z.object({
-  id: nonEmptyString,
-  label: nonEmptyString,
-  releasedAt: isoDateString,
-  showNewUntil: isoDateString,
-  description: zod.z.string().optional(),
-  type: zod.z.enum(["feature", "improvement", "fix", "breaking"]).optional(),
-  priority: zod.z.enum(["critical", "normal", "low"]).optional(),
-  dependsOn: dependsOnSchema
-}).passthrough();
-var featureManifestSchema = zod.z.array(featureEntrySchema);
-function toIssuePath(path) {
-  if (path.length === 0) return "$";
-  let output = "";
-  for (const part of path) {
-    if (typeof part === "number") output += `[${part}]`;
-    else output += output ? `.${part}` : part;
-  }
-  return output;
-}
-function mapZodIssue(issue) {
-  const codeParam = issue.params?.featuredropCode;
-  if (codeParam === "invalid_date") {
-    return {
-      path: toIssuePath(issue.path),
-      message: issue.message,
-      code: "invalid_date"
-    };
-  }
-  if (issue.code === "invalid_type") {
-    return {
-      path: toIssuePath(issue.path),
-      message: issue.message,
-      code: issue.received === "undefined" ? "missing_required" : "invalid_type"
-    };
-  }
-  return {
-    path: toIssuePath(issue.path),
-    message: issue.message,
-    code: "invalid_value"
-  };
-}
-function validateFeatureEntry(raw, index) {
-  if (!isRecord(raw)) {
-    return {
-      issues: [
-        {
-          path: `[${index}]`,
-          message: "Feature entry must be an object",
-          code: "invalid_type"
-        }
-      ]
-    };
-  }
-  const parsed = featureEntrySchema.safeParse(raw);
-  if (!parsed.success) {
-    return {
-      issues: parsed.error.issues.map((issue) => ({
-        ...mapZodIssue(issue),
-        path: `[${index}]${issue.path.length > 0 ? `.${toIssuePath(issue.path)}` : ""}`
-      }))
-    };
-  }
-  return {
-    issues: [],
-    entry: parsed.data
-  };
+    if (entry.cta) lines.push(`- **CTA**: [${entry.cta.label}](${entry.cta.url})`);
+    if (entry.description) {
+      lines.push("", entry.description.trim());
+    }
+    return lines.join("\n");
+  });
+  return `# Generated Changelog
+
+${sections.join("\n\n---\n\n")}
+`;
 }
-function validateManifest(data) {
+function isIsoWithTimezone(value) {
+  if (!value.includes("T")) return false;
+  if (!(value.endsWith("Z") || /[+-]\d{2}:\d{2}$/.test(value))) return false;
+  return Number.isFinite(new Date(value).getTime());
+}
+function runDoctor(entries, now = /* @__PURE__ */ new Date()) {
+  const checks = [];
+  const warnings = [];
   const errors = [];
-  if (!Array.isArray(data)) {
-    return {
-      valid: false,
-      errors: [
-        {
-          path: "$",
-          message: "Manifest must be an array",
-          code: "invalid_type"
-        }
-      ]
-    };
+  checks.push(`Manifest entries loaded: ${entries.length}`);
+  const ids = /* @__PURE__ */ new Set();
+  let duplicateCount = 0;
+  for (const entry of entries) {
+    if (ids.has(entry.id)) duplicateCount += 1;
+    ids.add(entry.id);
   }
-  const entries = [];
-  const seenIds = /* @__PURE__ */ new Set();
-  data.forEach((item, index) => {
-    const result = validateFeatureEntry(item, index);
-    errors.push(...result.issues);
-    if (!result.entry) return;
-    if (seenIds.has(result.entry.id)) {
-      errors.push({
-        path: `[${index}].id`,
-        message: `Duplicate feature id "${result.entry.id}"`,
-        code: "duplicate_id"
-      });
-      return;
-    }
-    seenIds.add(result.entry.id);
-    entries.push(result.entry);
-  });
-  if (entries.length > 0 && hasDependencyCycle(entries)) {
-    errors.push({
-      path: "$",
-      message: "Circular dependsOn relationship detected",
-      code: "circular_dependency"
-    });
+  if (duplicateCount > 0) {
+    errors.push(`${duplicateCount} duplicate feature id(s) found`);
+  } else {
+    checks.push("No duplicate IDs");
   }
-  for (let index = 0; index < entries.length; index++) {
-    const entry = entries[index];
-    if (new Date(entry.showNewUntil).getTime() <= new Date(entry.releasedAt).getTime()) {
-      errors.push({
-        path: `[${index}].showNewUntil`,
-        message: "showNewUntil must be after releasedAt",
-        code: "invalid_value"
-      });
+  let invalidDateCount = 0;
+  let reversedDateCount = 0;
+  let expiredCount = 0;
+  let scheduledCount = 0;
+  let missingDescriptionCount = 0;
+  for (const entry of entries) {
+    if (!entry.description?.trim()) missingDescriptionCount += 1;
+    if (!isIsoWithTimezone(entry.releasedAt) || !isIsoWithTimezone(entry.showNewUntil)) {
+      invalidDateCount += 1;
+      continue;
+    }
+    const released = new Date(entry.releasedAt).getTime();
+    const showUntil = new Date(entry.showNewUntil).getTime();
+    if (showUntil <= released) reversedDateCount += 1;
+    if (showUntil < now.getTime()) expiredCount += 1;
+    if (entry.publishAt) {
+      const publishMs = new Date(entry.publishAt).getTime();
+      if (Number.isFinite(publishMs) && publishMs > now.getTime()) scheduledCount += 1;
     }
   }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
+  if (invalidDateCount > 0) {
+    errors.push(`${invalidDateCount} entries have invalid ISO 8601 dates with timezone`);
+  } else {
+    checks.push("All dates are valid ISO 8601 with timezone");
+  }
+  if (reversedDateCount > 0) {
+    errors.push(`${reversedDateCount} entries have showNewUntil before/at releasedAt`);
+  }
+  if (expiredCount > 0) warnings.push(`${expiredCount} entries have showNewUntil in the past`);
+  if (scheduledCount > 0) warnings.push(`${scheduledCount} entries have publishAt in the future`);
+  if (missingDescriptionCount > 0) {
+    errors.push(`${missingDescriptionCount} entries have no description`);
+  } else {
+    checks.push("All entries have descriptions");
+  }
+  if (hasDependencyCycle(entries)) {
+    errors.push("Circular dependsOn relationship detected");
+  } else {
+    checks.push("No circular dependencies in dependsOn chains");
+  }
+  return { checks, warnings, errors };
 }
 
 // src/adapters/local-storage.ts
@@ -1836,6 +3274,319 @@ var LocalStorageAdapter = class {
   }
 };
 
+// src/adapters/indexeddb.ts
+var DISMISSED_SUFFIX2 = ":dismissed";
+var WATERMARK_SUFFIX = ":watermark";
+var QUEUE_SUFFIX = ":queue";
+function canUseLocalStorage() {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+function readLocalStorageState(prefix) {
+  if (!canUseLocalStorage()) {
+    return { watermark: null, dismissed: [], queue: [] };
+  }
+  try {
+    const dismissedRaw = localStorage.getItem(`${prefix}${DISMISSED_SUFFIX2}`);
+    const watermarkRaw = localStorage.getItem(`${prefix}${WATERMARK_SUFFIX}`);
+    const queueRaw = localStorage.getItem(`${prefix}${QUEUE_SUFFIX}`);
+    const dismissedParsed = dismissedRaw ? JSON.parse(dismissedRaw) : [];
+    const queueParsed = queueRaw ? JSON.parse(queueRaw) : [];
+    return {
+      watermark: typeof watermarkRaw === "string" ? watermarkRaw : null,
+      dismissed: Array.isArray(dismissedParsed) ? dismissedParsed.filter((value) => typeof value === "string") : [],
+      queue: normalizeQueue(queueParsed)
+    };
+  } catch {
+    return { watermark: null, dismissed: [], queue: [] };
+  }
+}
+function writeLocalStorageState(prefix, state) {
+  if (!canUseLocalStorage()) return;
+  try {
+    localStorage.setItem(`${prefix}${DISMISSED_SUFFIX2}`, JSON.stringify(state.dismissed));
+    if (state.watermark) {
+      localStorage.setItem(`${prefix}${WATERMARK_SUFFIX}`, state.watermark);
+    } else {
+      localStorage.removeItem(`${prefix}${WATERMARK_SUFFIX}`);
+    }
+    if (state.queue && state.queue.length > 0) {
+      localStorage.setItem(`${prefix}${QUEUE_SUFFIX}`, JSON.stringify(state.queue));
+    } else {
+      localStorage.removeItem(`${prefix}${QUEUE_SUFFIX}`);
+    }
+  } catch {
+  }
+}
+function getIndexedDBFactory() {
+  if (typeof globalThis === "undefined") return null;
+  const candidate = globalThis.indexedDB;
+  return candidate ?? null;
+}
+function normalizeQueue(value) {
+  if (!Array.isArray(value)) return [];
+  const queue = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") continue;
+    const candidate = item;
+    if (candidate.type === "dismiss" && typeof candidate.id === "string") {
+      queue.push({ type: "dismiss", id: candidate.id });
+      continue;
+    }
+    if (candidate.type === "dismissAll" && typeof candidate.watermark === "string") {
+      queue.push({ type: "dismissAll", watermark: candidate.watermark });
+      continue;
+    }
+  }
+  return queue;
+}
+function normalizeDismissedIds(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function parseIso(value) {
+  if (!value) return Number.NaN;
+  return new Date(value).getTime();
+}
+function resolveLatestWatermark(a, b) {
+  if (!a) return b ?? null;
+  if (!b) return a;
+  const aTs = parseIso(a);
+  const bTs = parseIso(b);
+  if (!Number.isFinite(aTs)) return b;
+  if (!Number.isFinite(bTs)) return a;
+  return aTs >= bTs ? a : b;
+}
+var IndexedDBAdapter = class {
+  prefix;
+  dbName;
+  storeName;
+  onDismissAllCallback;
+  onSyncStateCallback;
+  onFlushDismissBatchCallback;
+  onFlushDismissAllCallback;
+  flushDebounceMs;
+  autoSyncOnOnline;
+  watermark;
+  dismissed;
+  queue;
+  hydratePromise;
+  flushTimer = null;
+  flushing = false;
+  boundOnlineHandler;
+  boundVisibilityHandler;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "featuredrop";
+    this.dbName = options.dbName ?? "featuredrop";
+    this.storeName = options.storeName ?? "state";
+    this.onDismissAllCallback = options.onDismissAll;
+    this.onSyncStateCallback = options.onSyncState;
+    this.onFlushDismissBatchCallback = options.onFlushDismissBatch;
+    this.onFlushDismissAllCallback = options.onFlushDismissAll;
+    this.flushDebounceMs = options.flushDebounceMs ?? 500;
+    this.autoSyncOnOnline = options.autoSyncOnOnline ?? true;
+    const localState = readLocalStorageState(this.prefix);
+    this.watermark = options.watermark ?? localState.watermark;
+    this.dismissed = new Set(localState.dismissed);
+    this.queue = localState.queue ?? [];
+    this.hydratePromise = this.hydrateFromIndexedDB();
+    const canAttachListeners = this.autoSyncOnOnline && typeof window !== "undefined";
+    if (canAttachListeners) {
+      this.boundOnlineHandler = () => {
+        void this.syncFromRemote();
+      };
+      this.boundVisibilityHandler = () => {
+        if (document.visibilityState === "visible") {
+          void this.syncFromRemote();
+        }
+      };
+      window.addEventListener("online", this.boundOnlineHandler);
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+    } else {
+      this.boundOnlineHandler = null;
+      this.boundVisibilityHandler = null;
+    }
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissed;
+  }
+  dismiss(id) {
+    if (!id || this.dismissed.has(id)) return;
+    this.dismissed = new Set(this.dismissed).add(id);
+    this.queue.push({ type: "dismiss", id });
+    this.persist();
+    this.scheduleFlush();
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissed = /* @__PURE__ */ new Set();
+    this.queue = [{ type: "dismissAll", watermark: this.watermark }];
+    this.persist();
+    this.scheduleFlush();
+    await this.onDismissAllCallback?.(now);
+  }
+  /** Flush queued dismiss operations to optional remote callbacks. */
+  async flushQueue() {
+    if (this.flushing || this.queue.length === 0) return;
+    if (!this.onFlushDismissBatchCallback && !this.onFlushDismissAllCallback) return;
+    this.flushing = true;
+    try {
+      const operations = [...this.queue];
+      const lastDismissAll = this.getLastDismissAll(operations);
+      const dismissIds = this.collectDismissBatch(operations, !!lastDismissAll);
+      const hasDismissAll = !!lastDismissAll;
+      const needsDismissBatch = dismissIds.length > 0;
+      if (hasDismissAll && !this.onFlushDismissAllCallback) return;
+      if (needsDismissBatch && !this.onFlushDismissBatchCallback) return;
+      if (lastDismissAll && this.onFlushDismissAllCallback) {
+        await this.onFlushDismissAllCallback(lastDismissAll.watermark);
+      }
+      if (dismissIds.length > 0 && this.onFlushDismissBatchCallback) {
+        await this.onFlushDismissBatchCallback(dismissIds);
+      }
+      if (this.queue.length <= operations.length) {
+        this.queue = [];
+      } else {
+        this.queue = this.queue.slice(operations.length);
+      }
+      this.persist();
+    } catch {
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Merge local state with optional remote source, then flush queued writes. */
+  async syncFromRemote() {
+    await this.hydratePromise.catch(() => void 0);
+    if (this.onSyncStateCallback) {
+      try {
+        const remote = await this.onSyncStateCallback();
+        const mergedDismissed = new Set(this.dismissed);
+        for (const id of normalizeDismissedIds(remote.dismissedIds)) {
+          mergedDismissed.add(id);
+        }
+        this.dismissed = mergedDismissed;
+        this.watermark = resolveLatestWatermark(this.watermark, remote.watermark ?? null);
+        this.persist();
+      } catch {
+      }
+    }
+    await this.flushQueue();
+  }
+  /** Cleanup optional browser listeners. */
+  destroy() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.boundOnlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", this.boundOnlineHandler);
+    }
+    if (this.boundVisibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+    }
+  }
+  persist() {
+    const snapshot = {
+      watermark: this.watermark,
+      dismissed: Array.from(this.dismissed),
+      queue: this.queue
+    };
+    writeLocalStorageState(this.prefix, snapshot);
+    void this.writeIndexedDBState(snapshot);
+  }
+  async hydrateFromIndexedDB() {
+    const state = await this.readIndexedDBState();
+    if (!state) return;
+    this.watermark = state.watermark;
+    this.dismissed = new Set(state.dismissed);
+    this.queue = state.queue ?? [];
+    writeLocalStorageState(this.prefix, state);
+  }
+  async readIndexedDBState() {
+    const db = await this.openDb();
+    if (!db) return null;
+    return new Promise((resolve) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.get(this.prefix);
+      request.onsuccess = () => {
+        const value = request.result;
+        if (!value) {
+          resolve(null);
+          return;
+        }
+        resolve({
+          watermark: typeof value.watermark === "string" ? value.watermark : null,
+          dismissed: normalizeDismissedIds(value.dismissed),
+          queue: normalizeQueue(value.queue)
+        });
+      };
+      request.onerror = () => resolve(null);
+    });
+  }
+  async writeIndexedDBState(state) {
+    await this.hydratePromise.catch(() => void 0);
+    const db = await this.openDb();
+    if (!db) return;
+    await new Promise((resolve) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      store.put(state, this.prefix);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+      tx.onabort = () => resolve();
+    });
+  }
+  async openDb() {
+    const factory = getIndexedDBFactory();
+    if (!factory) return null;
+    return new Promise((resolve) => {
+      const request = factory.open(this.dbName, 1);
+      request.onerror = () => resolve(null);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flushQueue();
+    }, this.flushDebounceMs);
+  }
+  getLastDismissAll(operations) {
+    for (let index = operations.length - 1; index >= 0; index--) {
+      const operation = operations[index];
+      if (operation.type === "dismissAll") {
+        return { watermark: operation.watermark };
+      }
+    }
+    return null;
+  }
+  collectDismissBatch(operations, skipBeforeDismissAll) {
+    const startIndex = skipBeforeDismissAll ? operations.reduce(
+      (lastIndex, operation, index) => operation.type === "dismissAll" ? index : lastIndex,
+      -1
+    ) : -1;
+    const batch = /* @__PURE__ */ new Set();
+    for (let index = startIndex + 1; index < operations.length; index++) {
+      const operation = operations[index];
+      if (operation.type === "dismiss") {
+        batch.add(operation.id);
+      }
+    }
+    return Array.from(batch);
+  }
+};
+
 // src/adapters/memory.ts
 var MemoryAdapter = class {
   watermark;
@@ -1875,41 +3626,66 @@ var RemoteAdapter = class {
   watermark = null;
   lastManifest = null;
   lastFetchTs = 0;
+  retryAttempts;
+  retryBaseDelayMs;
+  circuitBreakerThreshold;
+  circuitBreakerCooldownMs;
+  sleep;
+  now;
+  consecutiveFailures = 0;
+  circuitOpenUntil = 0;
   constructor(options) {
     this.baseUrl = options.url.replace(/\/$/, "");
     this.headers = options.headers ?? {};
     this.fetchInterval = options.fetchInterval ?? 5 * 60 * 1e3;
     this.userId = options.userId;
+    this.retryAttempts = options.retryAttempts ?? 3;
+    this.retryBaseDelayMs = options.retryBaseDelayMs ?? 250;
+    this.circuitBreakerThreshold = options.circuitBreakerThreshold ?? 5;
+    this.circuitBreakerCooldownMs = options.circuitBreakerCooldownMs ?? 6e4;
+    this.sleep = options.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+    this.now = options.now ?? (() => Date.now());
   }
   /** Fetch manifest with stale-while-revalidate */
   async fetchManifest(force = false) {
-    const now = Date.now();
+    const now = this.now();
     if (!force && this.lastManifest && now - this.lastFetchTs < this.fetchInterval) {
       return this.lastManifest;
     }
-    const fetchImpl = assertFetch();
-    const res = await fetchImpl(this.baseUrl, {
-      method: "GET",
-      headers: this.headers
-    });
-    if (!res.ok) throw new Error(`RemoteAdapter manifest fetch failed: ${res.status}`);
-    const json = await res.json();
-    this.lastManifest = json;
-    this.lastFetchTs = now;
-    return json;
+    try {
+      const json = await this.withRetry(async () => {
+        const fetchImpl = assertFetch();
+        const res = await fetchImpl(this.baseUrl, {
+          method: "GET",
+          headers: this.headers
+        });
+        if (!res.ok) throw new Error(`RemoteAdapter manifest fetch failed: ${res.status}`);
+        return await res.json();
+      });
+      this.lastManifest = json;
+      this.lastFetchTs = now;
+      return json;
+    } catch {
+      return this.lastManifest ?? [];
+    }
   }
   /** Fetch state (watermark + dismissed IDs) */
   async syncState() {
-    const fetchImpl = assertFetch();
-    const url = this.userId ? `${this.baseUrl}/state?userId=${encodeURIComponent(this.userId)}` : `${this.baseUrl}/state`;
-    const res = await fetchImpl(url, {
-      method: "GET",
-      headers: this.headers
-    });
-    if (!res.ok) return;
-    const json = await res.json();
-    if (json.watermark !== void 0) this.watermark = json.watermark;
-    if (Array.isArray(json.dismissedIds)) this.dismissedIds = new Set(json.dismissedIds);
+    try {
+      const json = await this.withRetry(async () => {
+        const fetchImpl = assertFetch();
+        const url = this.userId ? `${this.baseUrl}/state?userId=${encodeURIComponent(this.userId)}` : `${this.baseUrl}/state`;
+        const res = await fetchImpl(url, {
+          method: "GET",
+          headers: this.headers
+        });
+        if (!res.ok) throw new Error(`RemoteAdapter state sync failed: ${res.status}`);
+        return await res.json();
+      });
+      if (json.watermark !== void 0) this.watermark = json.watermark;
+      if (Array.isArray(json.dismissedIds)) this.dismissedIds = new Set(json.dismissedIds);
+    } catch {
+    }
   }
   getWatermark() {
     return this.watermark;
@@ -1928,26 +3704,82 @@ var RemoteAdapter = class {
     await this.flushDismissAll(now).catch(() => {
     });
   }
+  /** Returns current adapter health; false while circuit breaker is open. */
+  async isHealthy() {
+    if (this.isCircuitOpen()) return false;
+    try {
+      await this.withRetry(async () => {
+        const fetchImpl = assertFetch();
+        const res = await fetchImpl(this.baseUrl, {
+          method: "GET",
+          headers: this.headers
+        });
+        if (!res.ok) throw new Error(`RemoteAdapter health check failed: ${res.status}`);
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
   async flushDismiss(id) {
-    const fetchImpl = assertFetch();
-    await fetchImpl(`${this.baseUrl}/dismiss`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...this.headers },
-      body: JSON.stringify({ featureId: id })
+    await this.withRetry(async () => {
+      const fetchImpl = assertFetch();
+      const res = await fetchImpl(`${this.baseUrl}/dismiss`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...this.headers },
+        body: JSON.stringify({ featureId: id })
+      });
+      if (!res.ok) throw new Error(`RemoteAdapter dismiss failed: ${res.status}`);
     });
   }
   async flushDismissAll(now) {
-    const fetchImpl = assertFetch();
-    await fetchImpl(`${this.baseUrl}/dismiss-all`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", ...this.headers },
-      body: JSON.stringify({ watermark: now.toISOString() })
+    await this.withRetry(async () => {
+      const fetchImpl = assertFetch();
+      const res = await fetchImpl(`${this.baseUrl}/dismiss-all`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...this.headers },
+        body: JSON.stringify({ watermark: now.toISOString() })
+      });
+      if (!res.ok) throw new Error(`RemoteAdapter dismiss-all failed: ${res.status}`);
     });
   }
+  isCircuitOpen() {
+    return this.now() < this.circuitOpenUntil;
+  }
+  markFailure() {
+    this.consecutiveFailures += 1;
+    if (this.consecutiveFailures >= this.circuitBreakerThreshold) {
+      this.circuitOpenUntil = this.now() + this.circuitBreakerCooldownMs;
+    }
+  }
+  markSuccess() {
+    this.consecutiveFailures = 0;
+    this.circuitOpenUntil = 0;
+  }
+  async withRetry(operation) {
+    if (this.isCircuitOpen()) {
+      throw new Error("RemoteAdapter circuit breaker is open");
+    }
+    let lastError = new Error("RemoteAdapter request failed");
+    for (let attempt = 0; attempt <= this.retryAttempts; attempt++) {
+      try {
+        const result = await operation();
+        this.markSuccess();
+        return result;
+      } catch (error) {
+        lastError = error;
+        if (attempt >= this.retryAttempts) break;
+        const delayMs = this.retryBaseDelayMs * 2 ** attempt;
+        await this.sleep(delayMs);
+      }
+    }
+    this.markFailure();
+    throw lastError instanceof Error ? lastError : new Error("RemoteAdapter request failed");
+  }
 };
 
 // src/adapters/postgres.ts
-function normalizeDismissedIds(row) {
+function normalizeDismissedIds2(row) {
   if (!row) return [];
   const ids = row.dismissed_ids ?? row.dismissedIds;
   if (!Array.isArray(ids)) return [];
@@ -2010,7 +3842,7 @@ var PostgresAdapter = class {
     );
     const row = result.rows[0];
     this.watermark = normalizeWatermark(row);
-    this.dismissedIds = new Set(normalizeDismissedIds(row));
+    this.dismissedIds = new Set(normalizeDismissedIds2(row));
   }
   async dismissBatch(ids) {
     if (ids.length === 0) return;
@@ -2057,7 +3889,7 @@ var PostgresAdapter = class {
     for (const row of result.rows) {
       out.set(row.user_id, {
         watermark: normalizeWatermark(row),
-        dismissedIds: normalizeDismissedIds(row),
+        dismissedIds: normalizeDismissedIds2(row),
         lastSeen: normalizeLastSeen(row),
         deviceCount: 1
       });
@@ -2199,11 +4031,47 @@ var HybridAdapter = class {
   local;
   remote;
   syncBeforeWrite;
+  dismissBatchWindowMs;
+  syncIntervalMs;
+  syncOnVisibilityChange;
+  syncOnOnline;
+  pendingDismissIds = /* @__PURE__ */ new Set();
+  dismissTimer = null;
+  syncTimer = null;
+  boundVisibilityHandler;
+  boundOnlineHandler;
   constructor(options) {
     this.local = options.local;
     this.remote = options.remote;
     this.userId = options.remote.userId;
     this.syncBeforeWrite = options.syncBeforeWrite ?? false;
+    this.dismissBatchWindowMs = options.dismissBatchWindowMs ?? 500;
+    this.syncIntervalMs = options.syncIntervalMs ?? 0;
+    this.syncOnVisibilityChange = options.syncOnVisibilityChange ?? true;
+    this.syncOnOnline = options.syncOnOnline ?? true;
+    if (typeof window !== "undefined" && this.syncOnOnline) {
+      this.boundOnlineHandler = () => {
+        void this.sync();
+      };
+      window.addEventListener("online", this.boundOnlineHandler);
+    } else {
+      this.boundOnlineHandler = null;
+    }
+    if (typeof document !== "undefined" && this.syncOnVisibilityChange) {
+      this.boundVisibilityHandler = () => {
+        if (document.visibilityState === "visible") {
+          void this.sync();
+        }
+      };
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+    } else {
+      this.boundVisibilityHandler = null;
+    }
+    if (this.syncIntervalMs > 0) {
+      this.syncTimer = setInterval(() => {
+        void this.sync();
+      }, this.syncIntervalMs);
+    }
   }
   getWatermark() {
     return this.local.getWatermark() ?? this.remote.getWatermark();
@@ -2216,9 +4084,12 @@ var HybridAdapter = class {
   }
   dismiss(id) {
     this.local.dismiss(id);
-    this.remote.dismiss(id);
+    this.pendingDismissIds.add(id);
+    this.scheduleDismissFlush();
   }
   async dismissAll(now) {
+    await this.flushPendingDismisses();
+    this.pendingDismissIds.clear();
     await Promise.all([
       this.local.dismissAll(now),
       this.remote.dismissAll(now)
@@ -2249,8 +4120,44 @@ var HybridAdapter = class {
     return this.remote.isHealthy();
   }
   async destroy() {
+    if (this.dismissTimer) {
+      clearTimeout(this.dismissTimer);
+      this.dismissTimer = null;
+    }
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    if (this.boundOnlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", this.boundOnlineHandler);
+    }
+    if (this.boundVisibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+    }
+    await this.flushPendingDismisses();
     await this.remote.destroy();
   }
+  /** Manually flush queued dismiss operations to the remote adapter. */
+  async flushPendingDismisses() {
+    if (this.pendingDismissIds.size === 0) return;
+    const ids = Array.from(this.pendingDismissIds);
+    this.pendingDismissIds.clear();
+    try {
+      if (this.syncBeforeWrite) {
+        await this.remote.sync();
+      }
+      await this.remote.dismissBatch(ids);
+    } catch {
+      for (const id of ids) this.pendingDismissIds.add(id);
+    }
+  }
+  scheduleDismissFlush() {
+    if (this.dismissTimer) return;
+    this.dismissTimer = setTimeout(() => {
+      this.dismissTimer = null;
+      void this.flushPendingDismisses();
+    }, this.dismissBatchWindowMs);
+  }
 };
 
 // src/adapters/mysql.ts
@@ -2270,7 +4177,7 @@ function parseDismissedIds(value) {
   }
   return [];
 }
-function normalizeDismissedIds2(row) {
+function normalizeDismissedIds3(row) {
   if (!row) return [];
   return parseDismissedIds(row.dismissed_ids ?? row.dismissedIds);
 }
@@ -2328,7 +4235,7 @@ var MySQLAdapter = class {
     );
     const row = result.rows[0];
     this.watermark = normalizeWatermark2(row);
-    this.dismissedIds = new Set(normalizeDismissedIds2(row));
+    this.dismissedIds = new Set(normalizeDismissedIds3(row));
   }
   async dismissBatch(ids) {
     const uniqueIds = Array.from(new Set(ids));
@@ -2369,7 +4276,7 @@ var MySQLAdapter = class {
     for (const row of result.rows) {
       out.set(row.user_id, {
         watermark: normalizeWatermark2(row),
-        dismissedIds: normalizeDismissedIds2(row),
+        dismissedIds: normalizeDismissedIds3(row),
         lastSeen: normalizeLastSeen2(row),
         deviceCount: 1
       });
@@ -2408,7 +4315,7 @@ var MySQLAdapter = class {
 };
 
 // src/adapters/mongo.ts
-function normalizeDismissedIds3(ids) {
+function normalizeDismissedIds4(ids) {
   if (!Array.isArray(ids)) return [];
   return ids.filter((id) => typeof id === "string");
 }
@@ -2463,7 +4370,7 @@ var MongoAdapter = class {
   async sync() {
     const doc = await this.collection.findOne({ userId: this.userId });
     this.watermark = doc?.watermark ?? null;
-    this.dismissedIds = new Set(normalizeDismissedIds3(doc?.dismissedIds));
+    this.dismissedIds = new Set(normalizeDismissedIds4(doc?.dismissedIds));
   }
   async dismissBatch(ids) {
     const unique = Array.from(new Set(ids));
@@ -2493,7 +4400,7 @@ var MongoAdapter = class {
       for (const row of rows) {
         out.set(row.userId, {
           watermark: row.watermark ?? null,
-          dismissedIds: normalizeDismissedIds3(row.dismissedIds),
+          dismissedIds: normalizeDismissedIds4(row.dismissedIds),
           lastSeen: normalizeLastSeen3(row.lastSeen),
           deviceCount: 1
         });
@@ -2506,7 +4413,7 @@ var MongoAdapter = class {
         if (!row) return;
         out.set(userId, {
           watermark: row.watermark ?? null,
-          dismissedIds: normalizeDismissedIds3(row.dismissedIds),
+          dismissedIds: normalizeDismissedIds4(row.dismissedIds),
           lastSeen: normalizeLastSeen3(row.lastSeen),
           deviceCount: 1
         });
@@ -2543,7 +4450,7 @@ function parseDismissedIds2(value) {
   }
   return [];
 }
-function normalizeDismissedIds4(row) {
+function normalizeDismissedIds5(row) {
   if (!row) return [];
   return parseDismissedIds2(row.dismissed_ids ?? row.dismissedIds);
 }
@@ -2602,7 +4509,7 @@ var SQLiteAdapter = class {
     );
     const row = result.rows[0];
     this.watermark = normalizeWatermark3(row);
-    this.dismissedIds = new Set(normalizeDismissedIds4(row));
+    this.dismissedIds = new Set(normalizeDismissedIds5(row));
   }
   async dismissBatch(ids) {
     const uniqueIds = Array.from(new Set(ids));
@@ -2645,7 +4552,7 @@ var SQLiteAdapter = class {
     for (const row of result.rows) {
       out.set(row.user_id, {
         watermark: normalizeWatermark3(row),
-        dismissedIds: normalizeDismissedIds4(row),
+        dismissedIds: normalizeDismissedIds5(row),
         lastSeen: normalizeLastSeen4(row),
         deviceCount: 1
       });
@@ -2684,7 +4591,7 @@ var SQLiteAdapter = class {
 };
 
 // src/adapters/supabase.ts
-function normalizeDismissedIds5(row) {
+function normalizeDismissedIds6(row) {
   if (!row || !Array.isArray(row.dismissed_ids)) return [];
   return row.dismissed_ids.filter((id) => typeof id === "string");
 }
@@ -2746,7 +4653,7 @@ var SupabaseAdapter = class {
     try {
       const row = await this.fetchState(this.userId);
       this.watermark = normalizeWatermark4(row);
-      this.dismissedIds = new Set(normalizeDismissedIds5(row));
+      this.dismissedIds = new Set(normalizeDismissedIds6(row));
     } finally {
       this.syncing = false;
     }
@@ -2782,7 +4689,7 @@ var SupabaseAdapter = class {
         if (!row) return;
         out.set(userId, {
           watermark: normalizeWatermark4(row),
-          dismissedIds: normalizeDismissedIds5(row),
+          dismissedIds: normalizeDismissedIds6(row),
           lastSeen: normalizeLastSeen5(row),
           deviceCount: 1
         });
@@ -2839,55 +4746,87 @@ var SupabaseAdapter = class {
 
 exports.AmplitudeAdapter = AmplitudeAdapter;
 exports.AnalyticsCollector = AnalyticsCollector;
+exports.AudienceBuilder = AudienceBuilder;
+exports.ContentfulAdapter = ContentfulAdapter;
 exports.CustomAdapter = CustomAdapter;
+exports.DiscordBridge = DiscordBridge;
+exports.EmailDigestGenerator = EmailDigestGenerator;
+exports.FEATUREDROP_ANIMATION_PRESETS = FEATUREDROP_ANIMATION_PRESETS;
 exports.FEATUREDROP_THEMES = FEATUREDROP_THEMES;
 exports.FEATUREDROP_TRANSLATIONS = FEATUREDROP_TRANSLATIONS;
 exports.HybridAdapter = HybridAdapter;
+exports.IndexedDBAdapter = IndexedDBAdapter;
+exports.LaunchDarklyBridge = LaunchDarklyBridge;
 exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.ManifestEditor = ManifestEditor;
+exports.MarkdownAdapter = MarkdownAdapter;
 exports.MemoryAdapter = MemoryAdapter;
 exports.MixpanelAdapter = MixpanelAdapter;
 exports.MongoAdapter = MongoAdapter;
 exports.MySQLAdapter = MySQLAdapter;
+exports.NotionAdapter = NotionAdapter;
 exports.PostHogAdapter = PostHogAdapter;
+exports.PostHogBridge = PostHogBridge;
 exports.PostgresAdapter = PostgresAdapter;
+exports.PreviewPanel = PreviewPanel;
+exports.RSSFeedGenerator = RSSFeedGenerator;
 exports.RedisAdapter = RedisAdapter;
 exports.RemoteAdapter = RemoteAdapter;
 exports.SQLiteAdapter = SQLiteAdapter;
+exports.SanityAdapter = SanityAdapter;
+exports.ScheduleCalendar = ScheduleCalendar;
 exports.SegmentAdapter = SegmentAdapter;
+exports.SlackBridge = SlackBridge;
+exports.StrapiAdapter = StrapiAdapter;
 exports.SupabaseAdapter = SupabaseAdapter;
 exports.TriggerEngine = TriggerEngine;
+exports.WebhookBridge = WebhookBridge;
 exports.applyAnnouncementThrottle = applyAnnouncementThrottle;
 exports.applyFeatureVariant = applyFeatureVariant;
 exports.applyFeatureVariants = applyFeatureVariants;
 exports.computeManifestStats = computeManifestStats;
 exports.createAdoptionMetrics = createAdoptionMetrics;
+exports.createChangelogRenderer = createChangelogRenderer;
+exports.createFlagBridge = createFlagBridge;
 exports.createManifest = createManifest;
 exports.createTheme = createTheme;
+exports.diffManifest = diffManifest;
 exports.featureEntryJsonSchema = featureEntryJsonSchema;
 exports.featureEntrySchema = featureEntrySchema;
 exports.featureManifestJsonSchema = featureManifestJsonSchema;
 exports.featureManifestSchema = featureManifestSchema;
+exports.formatDateForLocale = formatDateForLocale;
+exports.formatRelativeTimeForLocale = formatRelativeTimeForLocale;
+exports.generateChangelogDiff = generateChangelogDiff;
 exports.generateMarkdownChangelog = generateMarkdownChangelog;
 exports.generateRSS = generateRSS;
+exports.getAnimationDurationMs = getAnimationDurationMs;
+exports.getEnterAnimation = getEnterAnimation;
+exports.getExitAnimation = getExitAnimation;
 exports.getFeatureById = getFeatureById;
 exports.getFeatureVariantName = getFeatureVariantName;
+exports.getLocaleDirection = getLocaleDirection;
 exports.getNewFeatureCount = getNewFeatureCount;
 exports.getNewFeatures = getNewFeatures;
 exports.getNewFeaturesByCategory = getNewFeaturesByCategory;
 exports.getNewFeaturesSorted = getNewFeaturesSorted;
 exports.getOrCreateVariantKey = getOrCreateVariantKey;
+exports.getPulseAnimation = getPulseAnimation;
 exports.hasDependencyCycle = hasDependencyCycle;
 exports.hasNewFeature = hasNewFeature;
 exports.isNew = isNew;
 exports.isTriggerMatch = isTriggerMatch;
 exports.matchesAudience = matchesAudience;
 exports.parseDescription = parseDescription;
+exports.resolveAnimationPreset = resolveAnimationPreset;
 exports.resolveDependencyOrder = resolveDependencyOrder;
+exports.resolveLocale = resolveLocale;
 exports.resolveTheme = resolveTheme;
 exports.resolveTranslations = resolveTranslations;
 exports.runDoctor = runDoctor;
 exports.sortFeaturesByDependencies = sortFeaturesByDependencies;
 exports.themeToCSSVariables = themeToCSSVariables;
 exports.validateManifest = validateManifest;
+exports.validateManifestForCI = validateManifestForCI;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map