featuredrop 1.1.0 → 1.3.0

package/dist/index.js

@@ -1,6 +1,277 @@
+import { createRequire } from 'module';
+import { z } from 'zod';
+import { useState, useMemo } from 'react';
+import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
+import { stat, readFile, writeFile, readdir } from 'fs/promises';
+import { join, relative, sep } from 'path';
+
+// src/semver.ts
+var SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/;
+function parseSemver(input) {
+  const match = input.trim().match(SEMVER_REGEX);
+  if (!match) return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    prerelease: match[4] ? match[4].split(".") : []
+  };
+}
+function compareSemver(a, b) {
+  const pa = parseSemver(a);
+  const pb = parseSemver(b);
+  if (!pa || !pb) return 0;
+  for (const key of ["major", "minor", "patch"]) {
+    if (pa[key] !== pb[key]) return pa[key] - pb[key];
+  }
+  const aPre = pa.prerelease;
+  const bPre = pb.prerelease;
+  if (aPre.length === 0 && bPre.length === 0) return 0;
+  if (aPre.length === 0) return 1;
+  if (bPre.length === 0) return -1;
+  const len = Math.max(aPre.length, bPre.length);
+  for (let i = 0; i < len; i++) {
+    const ai = aPre[i];
+    const bi = bPre[i];
+    if (ai === void 0) return -1;
+    if (bi === void 0) return 1;
+    const aNum = Number(ai);
+    const bNum = Number(bi);
+    const aIsNum = Number.isInteger(aNum);
+    const bIsNum = Number.isInteger(bNum);
+    if (aIsNum && bIsNum && aNum !== bNum) return aNum - bNum;
+    if (aIsNum !== bIsNum) return aIsNum ? -1 : 1;
+    if (ai !== bi) return ai < bi ? -1 : 1;
+  }
+  return 0;
+}
+function parseComparator(comp) {
+  const match = comp.trim().match(/^(>=|<=|>|<|=)?\\s*(.+)$/);
+  if (!match) return null;
+  const op = match[1] || ">=";
+  const version = match[2];
+  if (!parseSemver(version)) return null;
+  return { op, version };
+}
+function satisfiesComparator(version, comp) {
+  const diff = compareSemver(version, comp.version);
+  switch (comp.op) {
+    case ">":
+      return diff > 0;
+    case ">=":
+      return diff >= 0;
+    case "<":
+      return diff < 0;
+    case "<=":
+      return diff <= 0;
+    case "=":
+      return diff === 0;
+    default:
+      return false;
+  }
+}
+function satisfiesRange(version, range) {
+  const parts = range.split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return true;
+  for (const part of parts) {
+    const comp = parseComparator(part);
+    if (!comp) return false;
+    if (!satisfiesComparator(version, comp)) return false;
+  }
+  return true;
+}
+
+// src/triggers.ts
+function wildcardToRegExp(value) {
+  const escaped = value.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = `^${escaped.replace(/\*/g, ".*")}$`;
+  return new RegExp(pattern);
+}
+function matchPath(path, pattern) {
+  if (pattern instanceof RegExp) return pattern.test(path);
+  if (!pattern) return false;
+  if (pattern.includes("*")) return wildcardToRegExp(pattern).test(path);
+  return path === pattern || path.startsWith(pattern);
+}
+function isTriggerMatch(trigger, context) {
+  if (!trigger) return true;
+  if (!context) return false;
+  if (trigger.type === "page") {
+    const path = context.path;
+    if (!path) return false;
+    return matchPath(path, trigger.match);
+  }
+  if (trigger.type === "usage") {
+    const usage = context.usage ?? {};
+    const count = usage[trigger.event] ?? 0;
+    return count >= (trigger.minActions ?? 1);
+  }
+  if (trigger.type === "time") {
+    const elapsedMs = context.elapsedMs ?? 0;
+    return elapsedMs >= trigger.minSeconds * 1e3;
+  }
+  if (trigger.type === "milestone") {
+    return context.milestones?.has(trigger.event) ?? false;
+  }
+  if (trigger.type === "frustration") {
+    const usage = context.usage ?? {};
+    const count = usage[trigger.pattern] ?? 0;
+    return count >= (trigger.threshold ?? 1);
+  }
+  if (trigger.type === "scroll") {
+    return (context.scrollPercent ?? 0) >= (trigger.minPercent ?? 50);
+  }
+  try {
+    return trigger.evaluate(context);
+  } catch {
+    return false;
+  }
+}
+var TriggerEngine = class {
+  context;
+  constructor(initial) {
+    this.context = {
+      path: initial?.path,
+      events: new Set(initial?.events ?? []),
+      milestones: new Set(initial?.milestones ?? []),
+      usage: { ...initial?.usage ?? {} },
+      elapsedMs: initial?.elapsedMs ?? 0,
+      scrollPercent: initial?.scrollPercent ?? 0,
+      metadata: { ...initial?.metadata ?? {} }
+    };
+  }
+  setPath(path) {
+    this.context.path = path;
+  }
+  trackEvent(event) {
+    const next = new Set(this.context.events ?? /* @__PURE__ */ new Set());
+    next.add(event);
+    this.context.events = next;
+  }
+  trackUsage(event, delta = 1) {
+    const usage = { ...this.context.usage ?? {} };
+    usage[event] = (usage[event] ?? 0) + Math.max(1, delta);
+    this.context.usage = usage;
+  }
+  trackMilestone(event) {
+    const next = new Set(this.context.milestones ?? /* @__PURE__ */ new Set());
+    next.add(event);
+    this.context.milestones = next;
+  }
+  setElapsedMs(elapsedMs) {
+    this.context.elapsedMs = Math.max(0, elapsedMs);
+  }
+  setScrollPercent(scrollPercent) {
+    const clamped = Math.max(0, Math.min(100, scrollPercent));
+    this.context.scrollPercent = clamped;
+  }
+  setMetadata(next) {
+    this.context.metadata = { ...next };
+  }
+  getContext() {
+    return {
+      path: this.context.path,
+      events: new Set(this.context.events ?? []),
+      milestones: new Set(this.context.milestones ?? []),
+      usage: { ...this.context.usage ?? {} },
+      elapsedMs: this.context.elapsedMs,
+      scrollPercent: this.context.scrollPercent,
+      metadata: { ...this.context.metadata ?? {} }
+    };
+  }
+  evaluate(trigger) {
+    return isTriggerMatch(trigger, this.context);
+  }
+  evaluateFeature(feature) {
+    return this.evaluate(feature.trigger);
+  }
+};
+
 // src/core.ts
-function isNew(feature, watermark, dismissedIds, now = /* @__PURE__ */ new Date()) {
+function matchesAudience(audience, userContext) {
+  if (audience.plan && audience.plan.length > 0) {
+    if (!userContext.plan || !audience.plan.includes(userContext.plan)) {
+      return false;
+    }
+  }
+  if (audience.role && audience.role.length > 0) {
+    if (!userContext.role || !audience.role.includes(userContext.role)) {
+      return false;
+    }
+  }
+  if (audience.region && audience.region.length > 0) {
+    if (!userContext.region || !audience.region.includes(userContext.region)) {
+      return false;
+    }
+  }
+  return true;
+}
+function isAudienceMatch(feature, userContext, matchFn) {
+  if (!feature.audience) return true;
+  const { plan, role, region, custom } = feature.audience;
+  const hasRules = plan && plan.length > 0 || role && role.length > 0 || region && region.length > 0 || custom && Object.keys(custom).length > 0;
+  if (!hasRules) return true;
+  if (!userContext) return false;
+  if (matchFn) return matchFn(feature.audience, userContext);
+  return matchesAudience(feature.audience, userContext);
+}
+function isVersionMatch(feature, appVersion) {
+  const v = feature.version;
+  if (!v || typeof v === "string") return true;
+  if (!appVersion) return false;
+  if (!v.introduced && !v.showNewUntil && !v.deprecatedAt && !v.showIn) return true;
+  if (v.showIn && !satisfiesRange(appVersion, v.showIn)) return false;
+  if (v.introduced && compareSemver(appVersion, v.introduced) < 0) return false;
+  if (v.deprecatedAt && compareSemver(appVersion, v.deprecatedAt) >= 0) return false;
+  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;
+  const seenIds = dependencyState?.seenIds;
+  const clickedIds = dependencyState?.clickedIds;
+  const dismissedDependencyIds = dependencyState?.dismissedIds ?? dismissedIds;
+  if (dependsOn.seen && dependsOn.seen.length > 0) {
+    for (const id of dependsOn.seen) {
+      const seen = seenIds?.has(id) ?? false;
+      if (!seen && !dismissedDependencyIds.has(id)) return false;
+    }
+  }
+  if (dependsOn.clicked && dependsOn.clicked.length > 0) {
+    for (const id of dependsOn.clicked) {
+      if (!(clickedIds?.has(id) ?? false)) return false;
+    }
+  }
+  if (dependsOn.dismissed && dependsOn.dismissed.length > 0) {
+    for (const id of dependsOn.dismissed) {
+      if (!dismissedDependencyIds.has(id)) return false;
+    }
+  }
+  return true;
+}
+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) {
     const publishMs = new Date(feature.publishAt).getTime();
@@ -15,29 +286,79 @@ function isNew(feature, watermark, dismissedIds, now = /* @__PURE__ */ new Date(
   }
   return true;
 }
-function getNewFeatures(manifest, storage, now = /* @__PURE__ */ new Date()) {
+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((f) => isNew(f, watermark, dismissedIds, now));
+  return manifest.filter(
+    (f) => isNew(
+      f,
+      watermark,
+      dismissedIds,
+      now,
+      userContext,
+      matchAudience,
+      appVersion,
+      dependencyState,
+      triggerContext,
+      flagBridge,
+      product
+    )
+  );
 }
-function getNewFeatureCount(manifest, storage, now = /* @__PURE__ */ new Date()) {
-  return getNewFeatures(manifest, storage, now).length;
+function getNewFeatureCount(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext, flagBridge, product) {
+  return getNewFeatures(
+    manifest,
+    storage,
+    now,
+    userContext,
+    matchAudience,
+    appVersion,
+    dependencyState,
+    triggerContext,
+    flagBridge,
+    product
+  ).length;
 }
-function hasNewFeature(manifest, sidebarKey, storage, now = /* @__PURE__ */ new Date()) {
+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(
-    (f) => f.sidebarKey === sidebarKey && isNew(f, watermark, dismissedIds, now)
+    (f) => f.sidebarKey === sidebarKey && isNew(
+      f,
+      watermark,
+      dismissedIds,
+      now,
+      userContext,
+      matchAudience,
+      appVersion,
+      dependencyState,
+      triggerContext,
+      flagBridge,
+      product
+    )
   );
 }
-function getNewFeaturesSorted(manifest, storage, now = /* @__PURE__ */ new Date()) {
+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, storage, now).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();
-  });
+  return getNewFeatures(
+    manifest,
+    storage,
+    now,
+    userContext,
+    matchAudience,
+    appVersion,
+    dependencyState,
+    triggerContext,
+    flagBridge,
+    product
+  ).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();
+    }
+  );
 }
 
 // src/helpers.ts
@@ -47,90 +368,4358 @@ function createManifest(entries) {
 function getFeatureById(manifest, id) {
   return manifest.find((f) => f.id === id);
 }
-function getNewFeaturesByCategory(manifest, category, storage, now = /* @__PURE__ */ new Date()) {
+function getNewFeaturesByCategory(manifest, category, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion) {
   const watermark = storage.getWatermark();
   const dismissedIds = storage.getDismissedIds();
   return manifest.filter(
-    (f) => f.category === category && isNew(f, watermark, dismissedIds, now)
+    (f) => f.category === category && isNew(f, watermark, dismissedIds, now, userContext, matchAudience, appVersion)
   );
 }
-
-// src/adapters/local-storage.ts
-var DISMISSED_SUFFIX = ":dismissed";
-var LocalStorageAdapter = class {
-  prefix;
-  watermarkValue;
-  onDismissAllCallback;
-  dismissedKey;
-  constructor(options = {}) {
-    this.prefix = options.prefix ?? "featuredrop";
-    this.watermarkValue = options.watermark ?? null;
-    this.onDismissAllCallback = options.onDismissAll;
-    this.dismissedKey = `${this.prefix}${DISMISSED_SUFFIX}`;
-  }
-  getWatermark() {
-    return this.watermarkValue;
+var dynamicRequire = createRequire(import.meta.url);
+var cachedMarked = null;
+var cachedShiki = null;
+function optionalRequire(name) {
+  try {
+    return dynamicRequire(name);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "MODULE_NOT_FOUND") {
+      return null;
+    }
+    return null;
   }
-  getDismissedIds() {
+}
+function getMarked() {
+  if (cachedMarked !== null) return cachedMarked || null;
+  cachedMarked = optionalRequire("marked") ?? false;
+  return cachedMarked || null;
+}
+function getShiki() {
+  if (cachedShiki !== null) return cachedShiki || null;
+  cachedShiki = optionalRequire("shiki") ?? false;
+  return cachedShiki || null;
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeUrl(url) {
+  if (!url) return null;
+  const trimmed = url.trim();
+  if (!trimmed) return null;
+  const lower = trimmed.toLowerCase();
+  if (lower.startsWith("javascript:")) return null;
+  if (lower.startsWith("data:")) return null;
+  if (lower.startsWith("vbscript:")) return null;
+  if (/['"<>\s]/.test(trimmed)) return null;
+  return trimmed;
+}
+function sanitizeHtml(html) {
+  return html.replace(/<script[\s\S]*?>[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?>[\s\S]*?<\/style>/gi, "").replace(/\s+on[a-z]+\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/gi, "").replace(/\s+(?:href|src|xlink:href)\s*=\s*("|')(?:javascript:|data:)[^"']*\1/gi, "");
+}
+function decodeAllowedEntities(html) {
+  const allowTags = [
+    "p",
+    "strong",
+    "em",
+    "a",
+    "code",
+    "pre",
+    "img",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "br"
+  ];
+  return html.replace(/&lt;(\/?)([a-z0-9]+)([^>]*)&gt;/gi, (match, slash, tag, rest) => {
+    if (!allowTags.includes(tag.toLowerCase())) return match;
+    const decodedRest = rest.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+    return `<${slash}${tag}${decodedRest}>`;
+  });
+}
+function renderCodeBlock(code, language) {
+  const shiki = getShiki();
+  if (shiki?.codeToHtml) {
     try {
-      if (typeof window === "undefined") return /* @__PURE__ */ new Set();
-      const raw = localStorage.getItem(this.dismissedKey);
-      if (!raw) return /* @__PURE__ */ new Set();
-      const parsed = JSON.parse(raw);
-      if (Array.isArray(parsed)) return new Set(parsed);
-      return /* @__PURE__ */ new Set();
+      const rendered = shiki.codeToHtml(code, { lang: language || "text", theme: "github-dark" });
+      if (typeof rendered === "string") return rendered;
     } catch {
-      return /* @__PURE__ */ new Set();
     }
   }
-  dismiss(id) {
-    try {
-      if (typeof window === "undefined") return;
-      const raw = localStorage.getItem(this.dismissedKey);
-      const existing = raw ? JSON.parse(raw) : [];
-      if (!existing.includes(id)) {
-        existing.push(id);
-        localStorage.setItem(this.dismissedKey, JSON.stringify(existing));
+  const langAttr = language ? ` class="language-${escapeHtml(language)}"` : "";
+  return `<pre><code${langAttr}>${escapeHtml(code)}</code></pre>`;
+}
+function inlineMarkdown(text) {
+  let result = escapeHtml(text);
+  const codeSpans = [];
+  result = result.replace(/`([^`]+)`/g, (_match, code) => {
+    const idx = codeSpans.length;
+    codeSpans.push(`<code>${escapeHtml(code)}</code>`);
+    return `\xA7\xA7CODE${idx}\xA7\xA7`;
+  });
+  result = result.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_match, alt, url) => {
+    const safeUrl = sanitizeUrl(url);
+    const safeAlt = escapeHtml(alt ?? "");
+    if (!safeUrl) return safeAlt;
+    return `<img src="${escapeHtml(safeUrl)}" alt="${safeAlt}" />`;
+  });
+  result = result.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_match, label, url) => {
+    const safeUrl = sanitizeUrl(url);
+    const safeLabel = escapeHtml(label ?? "");
+    if (!safeUrl) return safeLabel;
+    return `<a href="${escapeHtml(safeUrl)}" target="_blank" rel="noopener noreferrer">${safeLabel}</a>`;
+  });
+  result = result.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  result = result.replace(/\*([^*]+)\*/g, "<em>$1</em>");
+  result = result.replace(/§§CODE(\d+)§§/g, (_m, idx) => codeSpans[Number(idx)] ?? "");
+  return result;
+}
+function fallbackParse(markdown) {
+  const lines = markdown.split(/\r?\n/);
+  const blocks = [];
+  let listBuffer = null;
+  let quoteBuffer = null;
+  let inCodeBlock = false;
+  let codeLang;
+  let codeLines = [];
+  const flushList = () => {
+    if (!listBuffer) return;
+    blocks.push(`<ul>${listBuffer.map((item) => `<li>${item}</li>`).join("")}</ul>`);
+    listBuffer = null;
+  };
+  const flushQuote = () => {
+    if (!quoteBuffer) return;
+    const content = quoteBuffer.map((line) => inlineMarkdown(line.trim())).join("<br>");
+    blocks.push(`<blockquote>${content}</blockquote>`);
+    quoteBuffer = null;
+  };
+  const flushCode = () => {
+    if (!inCodeBlock) return;
+    blocks.push(renderCodeBlock(codeLines.join("\n"), codeLang));
+    codeLines = [];
+    codeLang = void 0;
+    inCodeBlock = false;
+  };
+  for (const rawLine of lines) {
+    const line = rawLine.replace(/\s+$/, "");
+    const codeFence = line.match(/^```(.*)$/);
+    if (codeFence) {
+      if (inCodeBlock) {
+        flushCode();
+      } else {
+        flushList();
+        flushQuote();
+        inCodeBlock = true;
+        codeLang = codeFence[1]?.trim() || void 0;
+        codeLines = [];
       }
-    } catch {
+      continue;
+    }
+    if (inCodeBlock) {
+      codeLines.push(rawLine);
+      continue;
+    }
+    const listMatch = line.match(/^\s*[-*+]\s+(.*)$/);
+    if (listMatch) {
+      flushQuote();
+      listBuffer = listBuffer ?? [];
+      listBuffer.push(inlineMarkdown(listMatch[1].trim()));
+      continue;
+    }
+    if (listBuffer) flushList();
+    const headingMatch = line.match(/^(#{1,6})\s+(.*)$/);
+    if (headingMatch) {
+      flushQuote();
+      const level = headingMatch[1].length;
+      const content = inlineMarkdown(headingMatch[2].trim());
+      blocks.push(`<h${level}>${content}</h${level}>`);
+      continue;
     }
+    const quoteMatch = line.match(/^>\s?(.*)$/);
+    if (quoteMatch) {
+      quoteBuffer = quoteBuffer ?? [];
+      quoteBuffer.push(quoteMatch[1]);
+      continue;
+    }
+    if (quoteBuffer) flushQuote();
+    if (!line.trim()) {
+      continue;
+    }
+    blocks.push(`<p>${inlineMarkdown(line.trim())}</p>`);
   }
-  async dismissAll(now) {
+  flushList();
+  flushQuote();
+  flushCode();
+  return blocks.join("\n");
+}
+function renderWithMarked(markdown, marked) {
+  if (!marked.parse) return null;
+  const renderer = marked.Renderer ? new marked.Renderer() : void 0;
+  if (renderer) {
+    renderer.link = (href, _title, text) => {
+      const safeUrl = sanitizeUrl(href);
+      if (!safeUrl) return escapeHtml(text);
+      return `<a href="${escapeHtml(safeUrl)}" target="_blank" rel="noopener noreferrer">${text}</a>`;
+    };
+    renderer.image = (href, _title, text) => {
+      const safeUrl = sanitizeUrl(href);
+      const safeAlt = escapeHtml(text ?? "");
+      if (!safeUrl) return safeAlt;
+      return `<img src="${escapeHtml(safeUrl)}" alt="${safeAlt}" />`;
+    };
+  }
+  const output = marked.parse(markdown, renderer ? { renderer } : void 0);
+  if (typeof output === "string") return output;
+  return output ? String(output) : null;
+}
+function parseDescription(markdown) {
+  if (!markdown) return "";
+  const marked = getMarked();
+  if (marked) {
     try {
-      if (typeof window !== "undefined") {
-        localStorage.removeItem(this.dismissedKey);
+      const rendered = renderWithMarked(markdown, marked);
+      if (rendered) {
+        const sanitized2 = sanitizeHtml(rendered);
+        const decoded2 = decodeAllowedEntities(sanitized2);
+        return sanitizeHtml(decoded2);
       }
     } catch {
     }
-    if (this.onDismissAllCallback) {
-      await this.onDismissAllCallback(now);
+  }
+  if (/<[^>]+>/.test(markdown)) {
+    const sanitized2 = sanitizeHtml(markdown);
+    const decoded2 = decodeAllowedEntities(sanitized2);
+    return sanitizeHtml(decoded2);
+  }
+  const fallback = fallbackParse(markdown);
+  const sanitized = sanitizeHtml(fallback);
+  const decoded = decodeAllowedEntities(sanitized);
+  return sanitizeHtml(decoded);
+}
+
+// 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 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 {
+    get state() {
+      return state;
+    },
+    actions: {
+      refresh,
+      dismiss,
+      dismissAll,
+      setManifest,
+      setUserContext,
+      setAppVersion,
+      setAudienceMatcher,
+      setFlagBridge,
+      setProduct
+    },
+    computed: {
+      isNew: isNew2,
+      getFeature,
+      getFeatureById: getFeatureById2,
+      getFeaturesByCategory
+    },
+    subscribe
+  };
+}
+
+// src/rss.ts
+function escape(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+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("");
+}
+
+// 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 formatFeatureLine(feature) {
+  const released = new Date(feature.releasedAt).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+  return `${feature.label} (${released})`;
+}
+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/adapters/memory.ts
-var MemoryAdapter = class {
-  watermark;
-  dismissed;
-  constructor(options = {}) {
-    this.watermark = options.watermark ?? null;
-    this.dismissed = /* @__PURE__ */ new Set();
+// 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);
   }
-  getWatermark() {
-    return this.watermark;
+  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);
   }
-  getDismissedIds() {
-    return this.dismissed;
+  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);
+    }
   }
-  dismiss(id) {
-    this.dismissed.add(id);
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
   }
-  async dismissAll(now) {
-    this.watermark = now.toISOString();
-    this.dismissed.clear();
+  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 = 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 = z.object({
+  seen: z.array(z.string()).optional(),
+  clicked: z.array(z.string()).optional(),
+  dismissed: z.array(z.string()).optional()
+}).optional();
+var ctaSchema = z.object({
+  label: nonEmptyString,
+  url: nonEmptyString
+}).optional();
+var featureEntrySchema = z.object({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  releasedAt: isoDateString,
+  showNewUntil: isoDateString,
+  description: z.string().optional(),
+  flagKey: z.string().optional(),
+  product: z.string().optional(),
+  url: z.string().optional(),
+  image: z.string().optional(),
+  type: z.enum(["feature", "improvement", "fix", "breaking"]).optional(),
+  priority: z.enum(["critical", "normal", "low"]).optional(),
+  cta: ctaSchema,
+  meta: z.record(z.unknown()).optional(),
+  dependsOn: dependsOnSchema
+}).passthrough();
+var featureManifestSchema = 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] = useState(() => JSON.stringify(features, null, 2));
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState("");
+  const parsed = 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__ */ jsx(Fragment, { children });
+  return /* @__PURE__ */ jsxs("section", { "data-featuredrop-admin-manifest-editor": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsx("p", { style: headingStyles, children: "Manifest Editor" }),
+    /* @__PURE__ */ 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__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: "8px", marginTop: "8px" }, children: [
+      /* @__PURE__ */ jsx("button", { type: "button", onClick: save, disabled: readOnly || !parsed, children: "Save" }),
+      /* @__PURE__ */ jsx("span", { "aria-live": "polite", children: status }),
+      !parsed && /* @__PURE__ */ jsx("span", { style: { color: "#dc2626" }, children: "Invalid JSON" }),
+      error && /* @__PURE__ */ jsx("span", { style: { color: "#dc2626" }, children: error })
+    ] })
+  ] });
+}
+function ScheduleCalendar({ features, onSchedule }) {
+  const [values, setValues] = useState({});
+  return /* @__PURE__ */ jsxs("section", { "data-featuredrop-admin-schedule-calendar": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsx("p", { style: headingStyles, children: "Schedule Calendar" }),
+    /* @__PURE__ */ jsx("ul", { style: { margin: 0, padding: 0, listStyle: "none", display: "grid", gap: "10px" }, children: features.map((feature) => /* @__PURE__ */ jsxs(
+      "li",
+      {
+        style: {
+          border: "1px solid #e5e7eb",
+          borderRadius: "8px",
+          padding: "10px",
+          display: "grid",
+          gap: "6px"
+        },
+        children: [
+          /* @__PURE__ */ jsx("strong", { children: feature.label }),
+          /* @__PURE__ */ jsxs("label", { style: { display: "grid", gap: "4px" }, children: [
+            "Publish at",
+            /* @__PURE__ */ jsx(
+              "input",
+              {
+                type: "datetime-local",
+                value: values[feature.id] ?? "",
+                onChange: (event) => {
+                  const value = event.target.value;
+                  setValues((previous) => ({ ...previous, [feature.id]: value }));
+                }
+              }
+            )
+          ] }),
+          /* @__PURE__ */ 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__ */ jsxs("section", { "data-featuredrop-admin-preview-panel": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsx("p", { style: headingStyles, children: "Preview Panel" }),
+    !feature ? /* @__PURE__ */ jsx("p", { style: { margin: 0, color: "#6b7280" }, children: "Select a feature to preview." }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx("p", { style: { margin: "0 0 6px", fontWeight: 600 }, children: feature.label }),
+      /* @__PURE__ */ jsx("p", { style: { margin: "0 0 8px", color: "#6b7280" }, children: feature.description ?? "No description" }),
+      /* @__PURE__ */ jsx("div", { style: { display: "flex", flexWrap: "wrap", gap: "6px" }, children: components.map((component) => /* @__PURE__ */ 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] = useState({
+    plan: value?.plan ?? [],
+    role: value?.role ?? [],
+    region: value?.region ?? []
+  });
+  const updateAudience = (next) => {
+    setAudience(next);
+    onChange?.(next);
+  };
+  const section = (title, values, selected, onToggle) => /* @__PURE__ */ jsxs("fieldset", { style: { border: "none", margin: 0, padding: 0 }, children: [
+    /* @__PURE__ */ jsx("legend", { style: { fontWeight: 600, marginBottom: "4px" }, children: title }),
+    /* @__PURE__ */ jsx("div", { style: { display: "flex", flexWrap: "wrap", gap: "8px" }, children: values.map((item) => /* @__PURE__ */ jsxs("label", { style: { display: "inline-flex", alignItems: "center", gap: "6px" }, children: [
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          type: "checkbox",
+          checked: Boolean(selected?.includes(item)),
+          onChange: () => onToggle(item)
+        }
+      ),
+      item
+    ] }, item)) })
+  ] });
+  return /* @__PURE__ */ jsxs("section", { "data-featuredrop-admin-audience-builder": true, style: panelStyles, children: [
+    /* @__PURE__ */ jsx("p", { style: headingStyles, children: "Audience Builder" }),
+    /* @__PURE__ */ 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__ */ 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 readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = 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 = join(cwd, baseDir);
+  const stats = await 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 readFile(file, "utf8");
+    const source = relative(cwd, file).split(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 = join(cwd, options.outFile);
+    await 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",
+  skip: "Skip",
+  finish: "Finish",
+  gotIt: "Got it",
+  announcement: "Announcement",
+  feedbackTitle: "Share feedback",
+  feedbackTrigger: "Feedback",
+  feedbackSubmitted: "Thanks for the feedback.",
+  submit: "Submit",
+  cancel: "Cancel",
+  askLater: "Ask me later"
+};
+var SIMPLE_TRANSLATIONS = {
+  es: {
+    newBadge: "Nuevo",
+    whatsNewTitle: "Novedades",
+    markAllRead: "Marcar todo como le\xEDdo",
+    allCaughtUp: "Est\xE1s al d\xEDa.",
+    close: "Cerrar",
+    changelogTitle: "Registro de cambios",
+    searchPlaceholder: "Buscar actualizaciones",
+    allCategories: "Todas las categor\xEDas",
+    noUpdatesYet: "A\xFAn no hay actualizaciones",
+    loadMore: "Cargar m\xE1s",
+    share: "Compartir",
+    skipToEntries: "Saltar a las entradas del changelog",
+    back: "Atr\xE1s",
+    next: "Siguiente",
+    skip: "Saltar",
+    finish: "Finalizar",
+    gotIt: "Entendido",
+    announcement: "Anuncio",
+    feedbackTitle: "Enviar comentarios",
+    feedbackTrigger: "Comentarios",
+    feedbackSubmitted: "Gracias por tus comentarios.",
+    submit: "Enviar",
+    cancel: "Cancelar",
+    askLater: "Preguntar m\xE1s tarde"
+  },
+  fr: {
+    newBadge: "Nouveau",
+    whatsNewTitle: "Nouveaut\xE9s",
+    markAllRead: "Tout marquer comme lu",
+    allCaughtUp: "Vous \xEAtes \xE0 jour.",
+    close: "Fermer",
+    changelogTitle: "Journal des changements",
+    searchPlaceholder: "Rechercher des mises \xE0 jour",
+    allCategories: "Toutes les cat\xE9gories",
+    noUpdatesYet: "Aucune mise \xE0 jour",
+    loadMore: "Charger plus",
+    share: "Partager",
+    skipToEntries: "Aller aux entr\xE9es du changelog",
+    back: "Retour",
+    next: "Suivant",
+    skip: "Passer",
+    finish: "Terminer",
+    gotIt: "Compris",
+    announcement: "Annonce",
+    feedbackTitle: "Partager un avis",
+    feedbackTrigger: "Avis",
+    feedbackSubmitted: "Merci pour votre avis.",
+    submit: "Envoyer",
+    cancel: "Annuler",
+    askLater: "Demander plus tard"
+  },
+  de: {
+    newBadge: "Neu",
+    whatsNewTitle: "Neuigkeiten",
+    markAllRead: "Alles als gelesen markieren",
+    allCaughtUp: "Alles erledigt.",
+    close: "Schlie\xDFen",
+    changelogTitle: "\xC4nderungsprotokoll",
+    searchPlaceholder: "Updates suchen",
+    allCategories: "Alle Kategorien",
+    noUpdatesYet: "Noch keine Updates",
+    loadMore: "Mehr laden",
+    share: "Teilen",
+    skipToEntries: "Zu den Eintr\xE4gen springen",
+    back: "Zur\xFCck",
+    next: "Weiter",
+    skip: "\xDCberspringen",
+    finish: "Fertig",
+    gotIt: "Verstanden",
+    announcement: "Ank\xFCndigung",
+    feedbackTitle: "Feedback teilen",
+    feedbackTrigger: "Feedback",
+    feedbackSubmitted: "Danke f\xFCr dein Feedback.",
+    submit: "Senden",
+    cancel: "Abbrechen",
+    askLater: "Sp\xE4ter fragen"
+  },
+  pt: {
+    newBadge: "Novo",
+    whatsNewTitle: "Novidades",
+    markAllRead: "Marcar tudo como lido",
+    allCaughtUp: "Tudo em dia.",
+    close: "Fechar",
+    changelogTitle: "Hist\xF3rico de mudan\xE7as",
+    searchPlaceholder: "Buscar atualiza\xE7\xF5es",
+    allCategories: "Todas as categorias",
+    noUpdatesYet: "Sem atualiza\xE7\xF5es ainda",
+    loadMore: "Carregar mais",
+    share: "Compartilhar",
+    skipToEntries: "Ir para entradas do changelog",
+    back: "Voltar",
+    next: "Pr\xF3ximo",
+    skip: "Pular",
+    finish: "Concluir",
+    gotIt: "Entendi",
+    announcement: "An\xFAncio",
+    feedbackTitle: "Enviar feedback",
+    feedbackTrigger: "Feedback",
+    feedbackSubmitted: "Obrigado pelo feedback.",
+    submit: "Enviar",
+    cancel: "Cancelar",
+    askLater: "Perguntar depois"
+  },
+  "zh-cn": {
+    newBadge: "\u65B0",
+    whatsNewTitle: "\u6700\u65B0\u52A8\u6001",
+    markAllRead: "\u5168\u90E8\u6807\u8BB0\u4E3A\u5DF2\u8BFB",
+    allCaughtUp: "\u4F60\u5DF2\u67E5\u770B\u5168\u90E8\u66F4\u65B0\u3002",
+    close: "\u5173\u95ED",
+    changelogTitle: "\u66F4\u65B0\u65E5\u5FD7",
+    searchPlaceholder: "\u641C\u7D22\u66F4\u65B0",
+    allCategories: "\u5168\u90E8\u5206\u7C7B",
+    noUpdatesYet: "\u6682\u65E0\u66F4\u65B0",
+    loadMore: "\u52A0\u8F7D\u66F4\u591A",
+    share: "\u5206\u4EAB",
+    skipToEntries: "\u8DF3\u8F6C\u5230\u66F4\u65B0\u6761\u76EE",
+    back: "\u8FD4\u56DE",
+    next: "\u4E0B\u4E00\u6B65",
+    skip: "\u8DF3\u8FC7",
+    finish: "\u5B8C\u6210",
+    gotIt: "\u77E5\u9053\u4E86",
+    announcement: "\u516C\u544A",
+    feedbackTitle: "\u63D0\u4EA4\u53CD\u9988",
+    feedbackTrigger: "\u53CD\u9988",
+    feedbackSubmitted: "\u611F\u8C22\u4F60\u7684\u53CD\u9988\u3002",
+    submit: "\u63D0\u4EA4",
+    cancel: "\u53D6\u6D88",
+    askLater: "\u7A0D\u540E\u8BE2\u95EE"
+  },
+  ja: {
+    newBadge: "\u65B0\u7740",
+    whatsNewTitle: "\u65B0\u6A5F\u80FD",
+    markAllRead: "\u3059\u3079\u3066\u65E2\u8AAD\u306B\u3059\u308B",
+    allCaughtUp: "\u3059\u3079\u3066\u78BA\u8A8D\u6E08\u307F\u3067\u3059\u3002",
+    close: "\u9589\u3058\u308B",
+    changelogTitle: "\u5909\u66F4\u5C65\u6B74",
+    searchPlaceholder: "\u66F4\u65B0\u3092\u691C\u7D22",
+    allCategories: "\u3059\u3079\u3066\u306E\u30AB\u30C6\u30B4\u30EA",
+    noUpdatesYet: "\u66F4\u65B0\u306F\u3042\u308A\u307E\u305B\u3093",
+    loadMore: "\u3055\u3089\u306B\u8868\u793A",
+    share: "\u5171\u6709",
+    skipToEntries: "\u5909\u66F4\u5C65\u6B74\u3078\u79FB\u52D5",
+    back: "\u623B\u308B",
+    next: "\u6B21\u3078",
+    skip: "\u30B9\u30AD\u30C3\u30D7",
+    finish: "\u5B8C\u4E86",
+    gotIt: "\u4E86\u89E3",
+    announcement: "\u304A\u77E5\u3089\u305B",
+    feedbackTitle: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u3092\u9001\u4FE1",
+    feedbackTrigger: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF",
+    feedbackSubmitted: "\u30D5\u30A3\u30FC\u30C9\u30D0\u30C3\u30AF\u3042\u308A\u304C\u3068\u3046\u3054\u3056\u3044\u307E\u3059\u3002",
+    submit: "\u9001\u4FE1",
+    cancel: "\u30AD\u30E3\u30F3\u30BB\u30EB",
+    askLater: "\u5F8C\u3067\u805E\u304F"
+  },
+  ko: {
+    newBadge: "\uC0C8\uB85C\uC6C0",
+    whatsNewTitle: "\uC0C8 \uC18C\uC2DD",
+    markAllRead: "\uBAA8\uB450 \uC77D\uC74C \uCC98\uB9AC",
+    allCaughtUp: "\uBAA8\uB4E0 \uC5C5\uB370\uC774\uD2B8\uB97C \uD655\uC778\uD588\uC2B5\uB2C8\uB2E4.",
+    close: "\uB2EB\uAE30",
+    changelogTitle: "\uBCC0\uACBD \uB85C\uADF8",
+    searchPlaceholder: "\uC5C5\uB370\uC774\uD2B8 \uAC80\uC0C9",
+    allCategories: "\uC804\uCCB4 \uCE74\uD14C\uACE0\uB9AC",
+    noUpdatesYet: "\uC5C5\uB370\uC774\uD2B8\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4",
+    loadMore: "\uB354 \uBCF4\uAE30",
+    share: "\uACF5\uC720",
+    skipToEntries: "\uBCC0\uACBD \uD56D\uBAA9\uC73C\uB85C \uC774\uB3D9",
+    back: "\uB4A4\uB85C",
+    next: "\uB2E4\uC74C",
+    skip: "\uAC74\uB108\uB6F0\uAE30",
+    finish: "\uC644\uB8CC",
+    gotIt: "\uD655\uC778",
+    announcement: "\uACF5\uC9C0",
+    feedbackTitle: "\uD53C\uB4DC\uBC31 \uBCF4\uB0B4\uAE30",
+    feedbackTrigger: "\uD53C\uB4DC\uBC31",
+    feedbackSubmitted: "\uD53C\uB4DC\uBC31 \uAC10\uC0AC\uD569\uB2C8\uB2E4.",
+    submit: "\uC81C\uCD9C",
+    cancel: "\uCDE8\uC18C",
+    askLater: "\uB098\uC911\uC5D0 \uBB3B\uAE30"
+  },
+  ar: {
+    newBadge: "\u062C\u062F\u064A\u062F",
+    whatsNewTitle: "\u0645\u0627 \u0627\u0644\u062C\u062F\u064A\u062F",
+    markAllRead: "\u062A\u062D\u062F\u064A\u062F \u0627\u0644\u0643\u0644 \u0643\u0645\u0642\u0631\u0648\u0621",
+    allCaughtUp: "\u062A\u0645\u062A \u0645\u062A\u0627\u0628\u0639\u0629 \u0643\u0644 \u0627\u0644\u062A\u062D\u062F\u064A\u062B\u0627\u062A.",
+    close: "\u0625\u063A\u0644\u0627\u0642",
+    changelogTitle: "\u0633\u062C\u0644 \u0627\u0644\u062A\u063A\u064A\u064A\u0631\u0627\u062A",
+    searchPlaceholder: "\u0627\u0628\u062D\u062B \u0641\u064A \u0627\u0644\u062A\u062D\u062F\u064A\u062B\u0627\u062A",
+    allCategories: "\u0643\u0644 \u0627\u0644\u0641\u0626\u0627\u062A",
+    noUpdatesYet: "\u0644\u0627 \u062A\u0648\u062C\u062F \u062A\u062D\u062F\u064A\u062B\u0627\u062A \u0628\u0639\u062F",
+    loadMore: "\u062A\u062D\u0645\u064A\u0644 \u0627\u0644\u0645\u0632\u064A\u062F",
+    share: "\u0645\u0634\u0627\u0631\u0643\u0629",
+    skipToEntries: "\u062A\u062E\u0637\u064A \u0625\u0644\u0649 \u0639\u0646\u0627\u0635\u0631 \u0627\u0644\u0633\u062C\u0644",
+    back: "\u0631\u062C\u0648\u0639",
+    next: "\u0627\u0644\u062A\u0627\u0644\u064A",
+    skip: "\u062A\u062E\u0637\u064A",
+    finish: "\u0625\u0646\u0647\u0627\u0621",
+    gotIt: "\u062A\u0645",
+    announcement: "\u0625\u0639\u0644\u0627\u0646",
+    feedbackTitle: "\u0634\u0627\u0631\u0643 \u0645\u0644\u0627\u062D\u0638\u0627\u062A\u0643",
+    feedbackTrigger: "\u0645\u0644\u0627\u062D\u0638\u0627\u062A",
+    feedbackSubmitted: "\u0634\u0643\u0631\u064B\u0627 \u0639\u0644\u0649 \u0645\u0644\u0627\u062D\u0638\u0627\u062A\u0643.",
+    submit: "\u0625\u0631\u0633\u0627\u0644",
+    cancel: "\u0625\u0644\u063A\u0627\u0621",
+    askLater: "\u0627\u0633\u0623\u0644\u0646\u064A \u0644\u0627\u062D\u0642\u064B\u0627"
+  },
+  hi: {
+    newBadge: "\u0928\u092F\u093E",
+    whatsNewTitle: "\u0928\u092F\u093E \u0915\u094D\u092F\u093E \u0939\u0948",
+    markAllRead: "\u0938\u092D\u0940 \u0915\u094B \u092A\u0922\u093C\u093E \u0939\u0941\u0906 \u091A\u093F\u0939\u094D\u0928\u093F\u0924 \u0915\u0930\u0947\u0902",
+    allCaughtUp: "\u0906\u092A\u0928\u0947 \u0938\u092D\u0940 \u0905\u092A\u0921\u0947\u091F \u0926\u0947\u0916 \u0932\u093F\u090F \u0939\u0948\u0902\u0964",
+    close: "\u092C\u0902\u0926 \u0915\u0930\u0947\u0902",
+    changelogTitle: "\u092A\u0930\u093F\u0935\u0930\u094D\u0924\u0928 \u0938\u0942\u091A\u0940",
+    searchPlaceholder: "\u0905\u092A\u0921\u0947\u091F \u0916\u094B\u091C\u0947\u0902",
+    allCategories: "\u0938\u092D\u0940 \u0936\u094D\u0930\u0947\u0923\u093F\u092F\u093E\u0902",
+    noUpdatesYet: "\u0905\u092D\u0940 \u0915\u094B\u0908 \u0905\u092A\u0921\u0947\u091F \u0928\u0939\u0940\u0902",
+    loadMore: "\u0914\u0930 \u0932\u094B\u0921 \u0915\u0930\u0947\u0902",
+    share: "\u0938\u093E\u091D\u093E \u0915\u0930\u0947\u0902",
+    skipToEntries: "\u091A\u0947\u0902\u091C\u0932\u0949\u0917 \u092A\u094D\u0930\u0935\u093F\u0937\u094D\u091F\u093F\u092F\u094B\u0902 \u092A\u0930 \u091C\u093E\u090F\u0902",
+    back: "\u0935\u093E\u092A\u0938",
+    next: "\u0905\u0917\u0932\u093E",
+    skip: "\u091B\u094B\u0921\u093C\u0947\u0902",
+    finish: "\u0938\u092E\u093E\u092A\u094D\u0924",
+    gotIt: "\u0920\u0940\u0915 \u0939\u0948",
+    announcement: "\u0918\u094B\u0937\u0923\u093E",
+    feedbackTitle: "\u092B\u0940\u0921\u092C\u0948\u0915 \u0938\u093E\u091D\u093E \u0915\u0930\u0947\u0902",
+    feedbackTrigger: "\u092B\u0940\u0921\u092C\u0948\u0915",
+    feedbackSubmitted: "\u092B\u0940\u0921\u092C\u0948\u0915 \u0915\u0947 \u0932\u093F\u090F \u0927\u0928\u094D\u092F\u0935\u093E\u0926\u0964",
+    submit: "\u091C\u092E\u093E \u0915\u0930\u0947\u0902",
+    cancel: "\u0930\u0926\u094D\u0926 \u0915\u0930\u0947\u0902",
+    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 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,
+    newFeatureCount
+  };
+}
+var FEATUREDROP_TRANSLATIONS = {
+  en: EN_TRANSLATIONS,
+  ...SIMPLE_TRANSLATIONS
+};
+
+// src/animation.ts
+var FEATUREDROP_ANIMATION_PRESETS = [
+  "none",
+  "subtle",
+  "normal",
+  "playful"
+];
+function resolveAnimationPreset(preset = "normal", options) {
+  if (options?.reducedMotion) return "none";
+  return preset;
+}
+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
+function sortByPriorityAndRecency(features) {
+  const priorityWeight = { critical: 3, normal: 2, low: 1 };
+  return [...features].sort((a, b) => {
+    const scoreA = priorityWeight[a.priority ?? "normal"];
+    const scoreB = priorityWeight[b.priority ?? "normal"];
+    if (scoreA !== scoreB) return scoreB - scoreA;
+    return new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime();
+  });
+}
+function applyAnnouncementThrottle(features, options, state, now = Date.now()) {
+  const sorted = sortByPriorityAndRecency(features);
+  if (sorted.length === 0) {
+    return { visible: [], queued: [] };
+  }
+  if (options?.sessionCooldown && options.sessionCooldown > 0) {
+    const elapsed = now - state.sessionStartedAt;
+    if (elapsed < options.sessionCooldown) {
+      return { visible: [], queued: sorted };
+    }
+  }
+  if (options?.respectDoNotDisturb && state.quietMode) {
+    const visible = sorted.filter((feature) => feature.priority === "critical");
+    const queued = sorted.filter((feature) => feature.priority !== "critical");
+    return { visible, queued };
+  }
+  const maxVisible = options?.maxSimultaneousBadges;
+  if (!maxVisible || !Number.isFinite(maxVisible) || maxVisible < 1) {
+    return { visible: sorted, queued: [] };
+  }
+  return {
+    visible: sorted.slice(0, maxVisible),
+    queued: sorted.slice(maxVisible)
+  };
+}
+
+// src/analytics.ts
+var AnalyticsCollector = class {
+  adapter;
+  queue = [];
+  batchSize;
+  flushInterval;
+  sampleRate;
+  enabled;
+  now;
+  random;
+  sessionId;
+  userId;
+  timer = null;
+  flushing = false;
+  constructor(options) {
+    this.adapter = options.adapter;
+    this.batchSize = options.batchSize ?? 20;
+    this.flushInterval = options.flushInterval ?? 1e4;
+    this.sampleRate = options.sampleRate ?? 1;
+    this.enabled = options.enabled ?? true;
+    this.sessionId = options.sessionId;
+    this.userId = options.userId;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.random = options.random ?? Math.random;
+    this.startTimer();
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  setContext(context) {
+    if (context.sessionId !== void 0) this.sessionId = context.sessionId;
+    if (context.userId !== void 0) this.userId = context.userId;
+  }
+  getQueueSize() {
+    return this.queue.length;
+  }
+  track(event) {
+    if (!this.enabled) return;
+    if (this.sampleRate < 1 && this.random() > this.sampleRate) return;
+    const normalized = {
+      ...event,
+      timestamp: event.timestamp ?? this.now().toISOString(),
+      sessionId: event.sessionId ?? this.sessionId,
+      userId: event.userId ?? this.userId
+    };
+    this.queue.push(normalized);
+    if (this.queue.length >= this.batchSize) {
+      void this.flush();
+    }
+  }
+  async flush() {
+    if (this.flushing) return;
+    if (this.queue.length === 0) return;
+    this.flushing = true;
+    const batch = this.queue.splice(0, this.queue.length);
+    try {
+      if (this.adapter.trackBatch) {
+        await this.adapter.trackBatch(batch);
+      } else {
+        for (const event of batch) {
+          await this.adapter.track(event);
+        }
+      }
+    } catch {
+      this.queue = [...batch, ...this.queue];
+    } finally {
+      this.flushing = false;
+    }
+  }
+  async destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  startTimer() {
+    if (this.flushInterval <= 0) return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.flushInterval);
+  }
+};
+var PostHogAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  track(event) {
+    this.client.capture(event.type, {
+      featureId: event.featureId,
+      tourId: event.tourId,
+      variant: event.variant,
+      timestamp: event.timestamp,
+      sessionId: event.sessionId,
+      userId: event.userId,
+      ...event.metadata
+    });
+  }
+};
+var AmplitudeAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  track(event) {
+    this.client.track(event.type, {
+      featureId: event.featureId,
+      tourId: event.tourId,
+      variant: event.variant,
+      timestamp: event.timestamp,
+      sessionId: event.sessionId,
+      userId: event.userId,
+      ...event.metadata
+    });
+  }
+};
+var MixpanelAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  track(event) {
+    this.client.track(event.type, {
+      featureId: event.featureId,
+      tourId: event.tourId,
+      variant: event.variant,
+      timestamp: event.timestamp,
+      sessionId: event.sessionId,
+      userId: event.userId,
+      ...event.metadata
+    });
+  }
+};
+var SegmentAdapter = class {
+  constructor(client) {
+    this.client = client;
+  }
+  track(event) {
+    this.client.track(event.type, {
+      featureId: event.featureId,
+      tourId: event.tourId,
+      variant: event.variant,
+      timestamp: event.timestamp,
+      sessionId: event.sessionId,
+      userId: event.userId,
+      ...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/variants.ts
+var VARIANT_META_KEY = "featuredropVariant";
+var VARIANT_KEY_STORAGE = "featuredrop:variant-key";
+function readStorageValue(key) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.getItem !== "function") return null;
+  try {
+    return storage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function writeStorageValue(key, value) {
+  const storage = globalThis.localStorage;
+  if (!storage || typeof storage.setItem !== "function") return;
+  try {
+    storage.setItem(key, value);
+  } catch {
+  }
+}
+function hashToPercent(value) {
+  let hash = 2166136261;
+  for (let i = 0; i < value.length; i += 1) {
+    hash ^= value.charCodeAt(i);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) % 100;
+}
+function normalizeSplit(count, split) {
+  if (!split || split.length !== count) {
+    return Array.from({ length: count }, () => 100 / count);
+  }
+  const cleaned = split.map((value) => Number.isFinite(value) && value > 0 ? value : 0);
+  const total = cleaned.reduce((sum, value) => sum + value, 0);
+  if (total <= 0) {
+    return Array.from({ length: count }, () => 100 / count);
+  }
+  return cleaned.map((value) => value / total * 100);
+}
+function pickVariantName(feature, variantKey) {
+  const variants = feature.variants;
+  if (!variants) return null;
+  const names = Object.keys(variants);
+  if (names.length === 0) return null;
+  if (names.length === 1) return names[0];
+  const split = normalizeSplit(names.length, feature.variantSplit);
+  const bucket = hashToPercent(`${feature.id}:${variantKey}`);
+  let cumulative = 0;
+  for (let i = 0; i < names.length; i += 1) {
+    cumulative += split[i];
+    if (bucket < cumulative) return names[i];
+  }
+  return names[names.length - 1];
+}
+function getFeatureVariantName(feature) {
+  const raw = feature.meta?.[VARIANT_META_KEY];
+  return typeof raw === "string" ? raw : void 0;
+}
+function applyFeatureVariant(feature, variantKey) {
+  const variantName = pickVariantName(feature, variantKey);
+  if (!variantName) return feature;
+  const variant = feature.variants?.[variantName];
+  if (!variant) return feature;
+  return {
+    ...feature,
+    label: variant.label ?? feature.label,
+    description: variant.description ?? feature.description,
+    image: variant.image ?? feature.image,
+    cta: variant.cta ?? feature.cta,
+    meta: {
+      ...feature.meta ?? {},
+      ...variant.meta ?? {},
+      [VARIANT_META_KEY]: variantName
+    }
+  };
+}
+function applyFeatureVariants(manifest, variantKey) {
+  return manifest.map((feature) => applyFeatureVariant(feature, variantKey));
+}
+function createRandomKey() {
+  return Math.random().toString(36).slice(2, 12);
+}
+function getOrCreateVariantKey(explicitKey) {
+  if (explicitKey) return explicitKey;
+  const existing = readStorageValue(VARIANT_KEY_STORAGE);
+  if (existing) return existing;
+  const next = createRandomKey();
+  writeStorageValue(VARIANT_KEY_STORAGE, next);
+  return next;
+}
+
+// src/cli-utils.ts
+function computeManifestStats(entries) {
+  const byType = {};
+  const byCategory = {};
+  for (const entry of entries) {
+    const type = entry.type ?? "feature";
+    byType[type] = (byType[type] ?? 0) + 1;
+    if (entry.category) {
+      byCategory[entry.category] = (byCategory[entry.category] ?? 0) + 1;
+    }
+  }
+  const sortedByDate = [...entries].sort(
+    (a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()
+  );
+  return {
+    total: entries.length,
+    byType,
+    byCategory,
+    newestRelease: sortedByDate[0]?.releasedAt ?? null,
+    oldestRelease: sortedByDate[sortedByDate.length - 1]?.releasedAt ?? null
+  };
+}
+function generateMarkdownChangelog(entries) {
+  const sorted = [...entries].sort(
+    (a, b) => new Date(b.releasedAt).getTime() - new Date(a.releasedAt).getTime()
+  );
+  const sections = sorted.map((entry) => {
+    const lines = [
+      `## ${entry.label}`,
+      "",
+      `- **ID**: \`${entry.id}\``,
+      `- **Released**: ${entry.releasedAt}`
+    ];
+    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 };
+}
+
+// src/adapters/local-storage.ts
+var DISMISSED_SUFFIX = ":dismissed";
+var LocalStorageAdapter = class {
+  prefix;
+  watermarkValue;
+  onDismissAllCallback;
+  dismissedKey;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "featuredrop";
+    this.watermarkValue = options.watermark ?? null;
+    this.onDismissAllCallback = options.onDismissAll;
+    this.dismissedKey = `${this.prefix}${DISMISSED_SUFFIX}`;
+  }
+  getWatermark() {
+    return this.watermarkValue;
+  }
+  getDismissedIds() {
+    try {
+      if (typeof window === "undefined") return /* @__PURE__ */ new Set();
+      const raw = localStorage.getItem(this.dismissedKey);
+      if (!raw) return /* @__PURE__ */ new Set();
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return new Set(parsed);
+      return /* @__PURE__ */ new Set();
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  dismiss(id) {
+    try {
+      if (typeof window === "undefined") return;
+      const raw = localStorage.getItem(this.dismissedKey);
+      const existing = raw ? JSON.parse(raw) : [];
+      if (!existing.includes(id)) {
+        existing.push(id);
+        localStorage.setItem(this.dismissedKey, JSON.stringify(existing));
+      }
+    } catch {
+    }
+  }
+  async dismissAll(now) {
+    try {
+      if (typeof window !== "undefined") {
+        localStorage.removeItem(this.dismissedKey);
+      }
+    } catch {
+    }
+    if (this.onDismissAllCallback) {
+      await this.onDismissAllCallback(now);
+    }
+  }
+};
+
+// 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;
+  dismissed;
+  constructor(options = {}) {
+    this.watermark = options.watermark ?? null;
+    this.dismissed = /* @__PURE__ */ new Set();
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissed;
+  }
+  dismiss(id) {
+    this.dismissed.add(id);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissed.clear();
+  }
+};
+
+// src/adapters/remote.ts
+function assertFetch() {
+  if (typeof fetch === "undefined") {
+    throw new Error("RemoteAdapter requires global fetch (Node 18+ or polyfill)");
+  }
+  return fetch;
+}
+var RemoteAdapter = class {
+  baseUrl;
+  headers;
+  fetchInterval;
+  userId;
+  dismissedIds = /* @__PURE__ */ new Set();
+  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 = this.now();
+    if (!force && this.lastManifest && now - this.lastFetchTs < this.fetchInterval) {
+      return this.lastManifest;
+    }
+    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() {
+    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;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    this.flushDismiss(id).catch(() => {
+    });
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    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) {
+    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) {
+    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 normalizeDismissedIds2(row) {
+  if (!row) return [];
+  const ids = row.dismissed_ids ?? row.dismissedIds;
+  if (!Array.isArray(ids)) return [];
+  return ids.filter((id) => typeof id === "string");
+}
+function normalizeWatermark(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? row.lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var PostgresAdapter = class {
+  userId;
+  query;
+  tableName;
+  autoMigrate;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("PostgresAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.query = options.query;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.autoMigrate = options.autoMigrate ?? true;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.ensureReady();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES ($1, $2, '{}', NOW(), NOW(), NOW())
+       ON CONFLICT (user_id)
+       DO UPDATE SET watermark = EXCLUDED.watermark, dismissed_ids = '{}', last_seen = NOW(), updated_at = NOW()`,
+      [this.userId, this.watermark]
+    );
+  }
+  async sync() {
+    await this.ensureReady();
+    const result = await this.query(
+      `SELECT watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id = $1`,
+      [this.userId]
+    );
+    const row = result.rows[0];
+    this.watermark = normalizeWatermark(row);
+    this.dismissedIds = new Set(normalizeDismissedIds2(row));
+  }
+  async dismissBatch(ids) {
+    if (ids.length === 0) return;
+    await this.ensureReady();
+    const uniqueIds = Array.from(new Set(ids));
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES ($1, NULL, $2::text[], NOW(), NOW(), NOW())
+       ON CONFLICT (user_id)
+       DO UPDATE SET
+         dismissed_ids = (
+           SELECT ARRAY(
+             SELECT DISTINCT x FROM UNNEST(
+               COALESCE(${this.tableName}.dismissed_ids, '{}') || EXCLUDED.dismissed_ids
+             ) AS x
+           )
+         ),
+         last_seen = NOW(),
+         updated_at = NOW()`,
+      [this.userId, uniqueIds]
+    );
+  }
+  async resetUser(userId) {
+    await this.ensureReady();
+    await this.query(
+      `DELETE FROM ${this.tableName} WHERE user_id = $1`,
+      [userId]
+    );
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    await this.ensureReady();
+    if (userIds.length === 0) return /* @__PURE__ */ new Map();
+    const result = await this.query(
+      `SELECT user_id, watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id = ANY($1::text[])`,
+      [userIds]
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      out.set(row.user_id, {
+        watermark: normalizeWatermark(row),
+        dismissedIds: normalizeDismissedIds2(row),
+        lastSeen: normalizeLastSeen(row),
+        deviceCount: 1
+      });
+    }
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+  async ensureReady() {
+    if (this.initialized) return;
+    if (this.autoMigrate) {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          user_id TEXT PRIMARY KEY,
+          watermark TIMESTAMPTZ,
+          dismissed_ids TEXT[] DEFAULT '{}',
+          last_seen TIMESTAMPTZ DEFAULT NOW(),
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          updated_at TIMESTAMPTZ DEFAULT NOW()
+        )`
+      );
+      await this.query(
+        `CREATE INDEX IF NOT EXISTS idx_${this.tableName}_last_seen ON ${this.tableName}(last_seen)`
+      );
+    }
+    this.initialized = true;
+  }
+};
+
+// src/adapters/redis.ts
+var RedisAdapter = class {
+  userId;
+  client;
+  keyPrefix;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("RedisAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "fd:";
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.client.sadd(this.dismissedKey(this.userId), id);
+    void this.client.set(this.lastSeenKey(this.userId), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.client.multi().set(this.watermarkKey(this.userId), this.watermark).del(this.dismissedKey(this.userId)).set(this.lastSeenKey(this.userId), now.toISOString()).exec();
+  }
+  async sync() {
+    const [watermark, dismissedIds] = await Promise.all([
+      this.client.get(this.watermarkKey(this.userId)),
+      this.client.smembers(this.dismissedKey(this.userId))
+    ]);
+    this.watermark = watermark;
+    this.dismissedIds = new Set(dismissedIds);
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    this.dismissedIds = /* @__PURE__ */ new Set([...this.dismissedIds, ...uniqueIds]);
+    await this.client.sadd(this.dismissedKey(this.userId), ...uniqueIds);
+    await this.client.set(this.lastSeenKey(this.userId), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async resetUser(userId) {
+    await this.client.multi().del(this.watermarkKey(userId)).del(this.dismissedKey(userId)).del(this.lastSeenKey(userId)).exec();
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    const map = /* @__PURE__ */ new Map();
+    await Promise.all(
+      userIds.map(async (userId) => {
+        const [watermark, dismissedIds, lastSeen] = await Promise.all([
+          this.client.get(this.watermarkKey(userId)),
+          this.client.smembers(this.dismissedKey(userId)),
+          this.client.get(this.lastSeenKey(userId))
+        ]);
+        map.set(userId, {
+          watermark,
+          dismissedIds,
+          lastSeen: lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+          deviceCount: 1
+        });
+      })
+    );
+    return map;
+  }
+  async isHealthy() {
+    try {
+      const response = await this.client.ping();
+      return response.toUpperCase() === "PONG";
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+    if (this.client.quit) {
+      await this.client.quit();
+      return;
+    }
+    this.client.disconnect?.();
+  }
+  watermarkKey(userId) {
+    return `${this.keyPrefix}${userId}:watermark`;
+  }
+  dismissedKey(userId) {
+    return `${this.keyPrefix}${userId}:dismissed`;
+  }
+  lastSeenKey(userId) {
+    return `${this.keyPrefix}${userId}:last_seen`;
+  }
+};
+
+// src/adapters/hybrid.ts
+var HybridAdapter = class {
+  userId;
+  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();
+  }
+  getDismissedIds() {
+    const merged = /* @__PURE__ */ new Set();
+    for (const id of this.local.getDismissedIds()) merged.add(id);
+    for (const id of this.remote.getDismissedIds()) merged.add(id);
+    return merged;
+  }
+  dismiss(id) {
+    this.local.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)
+    ]);
+  }
+  async sync() {
+    await this.remote.sync();
+  }
+  async dismissBatch(ids) {
+    if (this.syncBeforeWrite) {
+      await this.remote.sync();
+    }
+    for (const id of ids) {
+      this.local.dismiss(id);
+    }
+    await this.remote.dismissBatch(ids);
+  }
+  async resetUser(userId) {
+    await this.remote.resetUser(userId);
+    if (userId === this.userId) {
+      await this.local.dismissAll(/* @__PURE__ */ new Date(0));
+    }
+  }
+  async getBulkState(userIds) {
+    return this.remote.getBulkState(userIds);
+  }
+  async isHealthy() {
+    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
+function parseDismissedIds(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string");
+  }
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((item) => typeof item === "string");
+      }
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function normalizeDismissedIds3(row) {
+  if (!row) return [];
+  return parseDismissedIds(row.dismissed_ids ?? row.dismissedIds);
+}
+function normalizeWatermark2(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen2(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? row.lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var MySQLAdapter = class {
+  userId;
+  query;
+  tableName;
+  autoMigrate;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("MySQLAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.query = options.query;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.autoMigrate = options.autoMigrate ?? true;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.ensureReady();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, NOW(3), NOW(3), NOW(3))
+       ON DUPLICATE KEY UPDATE watermark = VALUES(watermark), dismissed_ids = VALUES(dismissed_ids), last_seen = NOW(3), updated_at = NOW(3)`,
+      [this.userId, this.watermark, JSON.stringify([])]
+    );
+  }
+  async sync() {
+    await this.ensureReady();
+    const result = await this.query(
+      `SELECT watermark, dismissed_ids, last_seen FROM ${this.tableName} WHERE user_id = ? LIMIT 1`,
+      [this.userId]
+    );
+    const row = result.rows[0];
+    this.watermark = normalizeWatermark2(row);
+    this.dismissedIds = new Set(normalizeDismissedIds3(row));
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    await this.ensureReady();
+    const merged = /* @__PURE__ */ new Set([
+      ...Array.from(this.dismissedIds),
+      ...uniqueIds
+    ]);
+    const mergedArray = Array.from(merged);
+    this.dismissedIds = merged;
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, NOW(3), NOW(3), NOW(3))
+       ON DUPLICATE KEY UPDATE dismissed_ids = VALUES(dismissed_ids), last_seen = NOW(3), updated_at = NOW(3)`,
+      [this.userId, this.watermark, JSON.stringify(mergedArray)]
+    );
+  }
+  async resetUser(userId) {
+    await this.ensureReady();
+    await this.query(`DELETE FROM ${this.tableName} WHERE user_id = ?`, [userId]);
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    await this.ensureReady();
+    if (userIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = userIds.map(() => "?").join(", ");
+    const result = await this.query(
+      `SELECT user_id, watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id IN (${placeholders})`,
+      userIds
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      out.set(row.user_id, {
+        watermark: normalizeWatermark2(row),
+        dismissedIds: normalizeDismissedIds3(row),
+        lastSeen: normalizeLastSeen2(row),
+        deviceCount: 1
+      });
+    }
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+  async ensureReady() {
+    if (this.initialized) return;
+    if (this.autoMigrate) {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          user_id VARCHAR(255) PRIMARY KEY,
+          watermark DATETIME(3) NULL,
+          dismissed_ids JSON NOT NULL,
+          last_seen DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+          created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+          updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3)
+        )`
+      );
+      await this.query(
+        `CREATE INDEX idx_${this.tableName}_last_seen ON ${this.tableName}(last_seen)`
+      );
+    }
+    this.initialized = true;
+  }
+};
+
+// src/adapters/mongo.ts
+function normalizeDismissedIds4(ids) {
+  if (!Array.isArray(ids)) return [];
+  return ids.filter((id) => typeof id === "string");
+}
+function normalizeLastSeen3(value) {
+  return typeof value === "string" && value ? value : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var MongoAdapter = class {
+  userId;
+  collection;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("MongoAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.collection = options.collection;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.collection.updateOne(
+      { userId: this.userId },
+      {
+        $addToSet: { dismissedIds: id },
+        $set: { lastSeen: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      { upsert: true }
+    );
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.collection.updateOne(
+      { userId: this.userId },
+      {
+        $set: {
+          userId: this.userId,
+          watermark: this.watermark,
+          dismissedIds: [],
+          lastSeen: this.watermark
+        }
+      },
+      { upsert: true }
+    );
+  }
+  async sync() {
+    const doc = await this.collection.findOne({ userId: this.userId });
+    this.watermark = doc?.watermark ?? null;
+    this.dismissedIds = new Set(normalizeDismissedIds4(doc?.dismissedIds));
+  }
+  async dismissBatch(ids) {
+    const unique = Array.from(new Set(ids));
+    if (unique.length === 0) return;
+    this.dismissedIds = /* @__PURE__ */ new Set([...this.dismissedIds, ...unique]);
+    await this.collection.updateOne(
+      { userId: this.userId },
+      {
+        $addToSet: { dismissedIds: { $each: unique } },
+        $set: { lastSeen: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      { upsert: true }
+    );
+  }
+  async resetUser(userId) {
+    await this.collection.deleteOne({ userId });
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    const out = /* @__PURE__ */ new Map();
+    if (userIds.length === 0) return out;
+    if (this.collection.find) {
+      const rows = await this.collection.find({ userId: { $in: userIds } }).toArray();
+      for (const row of rows) {
+        out.set(row.userId, {
+          watermark: row.watermark ?? null,
+          dismissedIds: normalizeDismissedIds4(row.dismissedIds),
+          lastSeen: normalizeLastSeen3(row.lastSeen),
+          deviceCount: 1
+        });
+      }
+      return out;
+    }
+    await Promise.all(
+      userIds.map(async (userId) => {
+        const row = await this.collection.findOne({ userId });
+        if (!row) return;
+        out.set(userId, {
+          watermark: row.watermark ?? null,
+          dismissedIds: normalizeDismissedIds4(row.dismissedIds),
+          lastSeen: normalizeLastSeen3(row.lastSeen),
+          deviceCount: 1
+        });
+      })
+    );
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.collection.findOne({});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+};
+
+// src/adapters/sqlite.ts
+function parseDismissedIds2(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string");
+  }
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((item) => typeof item === "string");
+      }
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function normalizeDismissedIds5(row) {
+  if (!row) return [];
+  return parseDismissedIds2(row.dismissed_ids ?? row.dismissedIds);
+}
+function normalizeWatermark3(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen4(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? row.lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var SQLiteAdapter = class {
+  userId;
+  query;
+  tableName;
+  autoMigrate;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("SQLiteAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.query = options.query;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.autoMigrate = options.autoMigrate ?? true;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.ensureReady();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(user_id)
+       DO UPDATE SET watermark = excluded.watermark, dismissed_ids = excluded.dismissed_ids, last_seen = excluded.last_seen, updated_at = excluded.updated_at`,
+      [this.userId, this.watermark, JSON.stringify([]), this.watermark, this.watermark, this.watermark]
+    );
+  }
+  async sync() {
+    await this.ensureReady();
+    const result = await this.query(
+      `SELECT watermark, dismissed_ids, last_seen FROM ${this.tableName} WHERE user_id = ? LIMIT 1`,
+      [this.userId]
+    );
+    const row = result.rows[0];
+    this.watermark = normalizeWatermark3(row);
+    this.dismissedIds = new Set(normalizeDismissedIds5(row));
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    await this.ensureReady();
+    const merged = /* @__PURE__ */ new Set([
+      ...Array.from(this.dismissedIds),
+      ...uniqueIds
+    ]);
+    const mergedArray = Array.from(merged);
+    this.dismissedIds = merged;
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(user_id)
+       DO UPDATE SET dismissed_ids = excluded.dismissed_ids, last_seen = excluded.last_seen, updated_at = excluded.updated_at`,
+      [this.userId, this.watermark, JSON.stringify(mergedArray), nowIso, nowIso, nowIso]
+    );
+  }
+  async resetUser(userId) {
+    await this.ensureReady();
+    await this.query(`DELETE FROM ${this.tableName} WHERE user_id = ?`, [userId]);
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    await this.ensureReady();
+    if (userIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = userIds.map(() => "?").join(", ");
+    const result = await this.query(
+      `SELECT user_id, watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id IN (${placeholders})`,
+      userIds
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      out.set(row.user_id, {
+        watermark: normalizeWatermark3(row),
+        dismissedIds: normalizeDismissedIds5(row),
+        lastSeen: normalizeLastSeen4(row),
+        deviceCount: 1
+      });
+    }
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+  async ensureReady() {
+    if (this.initialized) return;
+    if (this.autoMigrate) {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          user_id TEXT PRIMARY KEY,
+          watermark TEXT,
+          dismissed_ids TEXT NOT NULL,
+          last_seen TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )`
+      );
+      await this.query(
+        `CREATE INDEX IF NOT EXISTS idx_${this.tableName}_last_seen ON ${this.tableName}(last_seen)`
+      );
+    }
+    this.initialized = true;
+  }
+};
+
+// src/adapters/supabase.ts
+function normalizeDismissedIds6(row) {
+  if (!row || !Array.isArray(row.dismissed_ids)) return [];
+  return row.dismissed_ids.filter((id) => typeof id === "string");
+}
+function normalizeWatermark4(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen5(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+function throwOnError(error) {
+  if (!error) return;
+  throw new Error(`SupabaseAdapter: ${error.message ?? "unknown error"}`);
+}
+var SupabaseAdapter = class {
+  userId;
+  client;
+  tableName;
+  realtime;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  realtimeChannel = null;
+  syncing = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("SupabaseAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.client = options.client;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.realtime = options.realtime ?? false;
+    if (this.realtime && this.client.channel) {
+      this.setupRealtime();
+    }
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.upsertState({
+      watermark: this.watermark,
+      dismissed_ids: [],
+      last_seen: this.watermark
+    });
+  }
+  async sync() {
+    if (this.syncing) return;
+    this.syncing = true;
+    try {
+      const row = await this.fetchState(this.userId);
+      this.watermark = normalizeWatermark4(row);
+      this.dismissedIds = new Set(normalizeDismissedIds6(row));
+    } finally {
+      this.syncing = false;
+    }
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    const merged = /* @__PURE__ */ new Set([
+      ...Array.from(this.dismissedIds),
+      ...uniqueIds
+    ]);
+    this.dismissedIds = merged;
+    await this.upsertState({
+      watermark: this.watermark,
+      dismissed_ids: Array.from(merged),
+      last_seen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async resetUser(userId) {
+    const result = await this.client.from(this.tableName).delete().eq("user_id", userId);
+    throwOnError(result.error);
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    const out = /* @__PURE__ */ new Map();
+    if (userIds.length === 0) return out;
+    await Promise.all(
+      userIds.map(async (userId) => {
+        const row = await this.fetchState(userId);
+        if (!row) return;
+        out.set(userId, {
+          watermark: normalizeWatermark4(row),
+          dismissedIds: normalizeDismissedIds6(row),
+          lastSeen: normalizeLastSeen5(row),
+          deviceCount: 1
+        });
+      })
+    );
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.client.from(this.tableName).select("user_id").eq("user_id", this.userId).maybeSingle();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+    if (this.realtimeChannel && this.client.removeChannel) {
+      await this.client.removeChannel(this.realtimeChannel);
+    }
+    this.realtimeChannel = null;
+  }
+  async fetchState(userId) {
+    const result = await this.client.from(this.tableName).select("user_id, watermark, dismissed_ids, last_seen").eq("user_id", userId).maybeSingle();
+    throwOnError(result.error);
+    return result.data;
+  }
+  async upsertState(state) {
+    const payload = {
+      user_id: this.userId,
+      watermark: state.watermark,
+      dismissed_ids: state.dismissed_ids,
+      last_seen: state.last_seen
+    };
+    const result = await this.client.from(this.tableName).upsert(payload);
+    throwOnError(result.error);
+  }
+  setupRealtime() {
+    const channelFactory = this.client.channel;
+    if (!channelFactory) return;
+    this.realtimeChannel = channelFactory(`featuredrop:${this.tableName}:${this.userId}`).on(
+      "postgres_changes",
+      {
+        event: "*",
+        schema: "public",
+        table: this.tableName,
+        filter: `user_id=eq.${this.userId}`
+      },
+      () => {
+        void this.sync();
+      }
+    ).subscribe();
   }
 };
 
-export { LocalStorageAdapter, MemoryAdapter, createManifest, getFeatureById, getNewFeatureCount, getNewFeatures, getNewFeaturesByCategory, getNewFeaturesSorted, hasNewFeature, isNew };
+export { AmplitudeAdapter, AnalyticsCollector, AudienceBuilder, ContentfulAdapter, CustomAdapter, DiscordBridge, EmailDigestGenerator, FEATUREDROP_ANIMATION_PRESETS, FEATUREDROP_THEMES, FEATUREDROP_TRANSLATIONS, HybridAdapter, IndexedDBAdapter, LaunchDarklyBridge, LocalStorageAdapter, ManifestEditor, MarkdownAdapter, MemoryAdapter, MixpanelAdapter, MongoAdapter, MySQLAdapter, NotionAdapter, PostHogAdapter, PostHogBridge, PostgresAdapter, PreviewPanel, RSSFeedGenerator, RedisAdapter, RemoteAdapter, SQLiteAdapter, SanityAdapter, ScheduleCalendar, SegmentAdapter, SlackBridge, StrapiAdapter, SupabaseAdapter, TriggerEngine, WebhookBridge, applyAnnouncementThrottle, applyFeatureVariant, applyFeatureVariants, computeManifestStats, createAdoptionMetrics, createChangelogRenderer, createFlagBridge, createManifest, createTheme, diffManifest, featureEntryJsonSchema, featureEntrySchema, featureManifestJsonSchema, featureManifestSchema, formatDateForLocale, formatRelativeTimeForLocale, generateChangelogDiff, generateMarkdownChangelog, generateRSS, getAnimationDurationMs, getEnterAnimation, getExitAnimation, getFeatureById, getFeatureVariantName, getLocaleDirection, getNewFeatureCount, getNewFeatures, getNewFeaturesByCategory, getNewFeaturesSorted, getOrCreateVariantKey, getPulseAnimation, hasDependencyCycle, hasNewFeature, isNew, isTriggerMatch, matchesAudience, parseDescription, resolveAnimationPreset, resolveDependencyOrder, resolveLocale, resolveTheme, resolveTranslations, runDoctor, sortFeaturesByDependencies, themeToCSSVariables, validateManifest, validateManifestForCI };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map