featuredrop 1.0.1 → 1.2.0

package/dist/index.cjs

@@ -1,9 +1,265 @@
 'use strict';
 
+var module$1 = require('module');
+var zod = require('zod');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// 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 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) {
   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 (!isTriggerMatch(feature.trigger, triggerContext)) return false;
   const nowMs = now.getTime();
+  if (feature.publishAt) {
+    const publishMs = new Date(feature.publishAt).getTime();
+    if (nowMs < publishMs) return false;
+  }
   const showUntilMs = new Date(feature.showNewUntil).getTime();
   if (nowMs >= showUntilMs) return false;
   if (watermark) {
@@ -13,19 +269,70 @@ 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) {
   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
+    )
+  );
 }
-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) {
+  return getNewFeatures(
+    manifest,
+    storage,
+    now,
+    userContext,
+    matchAudience,
+    appVersion,
+    dependencyState,
+    triggerContext
+  ).length;
 }
-function hasNewFeature(manifest, sidebarKey, storage, now = /* @__PURE__ */ new Date()) {
+function hasNewFeature(manifest, sidebarKey, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
   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
+    )
+  );
+}
+function getNewFeaturesSorted(manifest, storage, now = /* @__PURE__ */ new Date(), userContext, matchAudience, appVersion, dependencyState, triggerContext) {
+  const priorityOrder = { critical: 0, normal: 1, low: 2 };
+  return getNewFeatures(
+    manifest,
+    storage,
+    now,
+    userContext,
+    matchAudience,
+    appVersion,
+    dependencyState,
+    triggerContext
+  ).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();
+    }
   );
 }
 
@@ -36,13 +343,1445 @@ 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)
   );
 }
+var dynamicRequire = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+var 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;
+  }
+}
+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 {
+      const rendered = shiki.codeToHtml(code, { lang: language || "text", theme: "github-dark" });
+      if (typeof rendered === "string") return rendered;
+    } catch {
+    }
+  }
+  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 = [];
+      }
+      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>`);
+  }
+  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 {
+      const rendered = renderWithMarked(markdown, marked);
+      if (rendered) {
+        const sanitized2 = sanitizeHtml(rendered);
+        const decoded2 = decodeAllowedEntities(sanitized2);
+        return sanitizeHtml(decoded2);
+      }
+    } catch {
+    }
+  }
+  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/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",
+  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"
+  }
+};
+function resolveTranslations(locale, overrides) {
+  const normalizedLocale = (locale ?? "en").toLowerCase();
+  const base = SIMPLE_TRANSLATIONS[normalizedLocale] ?? SIMPLE_TRANSLATIONS[normalizedLocale.split("-")[0]] ?? {};
+  return {
+    ...EN_TRANSLATIONS,
+    ...base,
+    ...overrides ?? {},
+    stepOf: overrides?.stepOf ?? EN_TRANSLATIONS.stepOf
+  };
+}
+var FEATUREDROP_TRANSLATIONS = {
+  en: EN_TRANSLATIONS,
+  ...SIMPLE_TRANSLATIONS
+};
+
+// 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/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/dependencies.ts
+function getDirectDependencies(feature) {
+  const dependsOn = feature.dependsOn;
+  if (!dependsOn) return [];
+  const seen = dependsOn.seen ?? [];
+  const clicked = dependsOn.clicked ?? [];
+  const dismissed = dependsOn.dismissed ?? [];
+  const unique = /* @__PURE__ */ new Set();
+  for (const id of [...seen, ...clicked, ...dismissed]) {
+    if (id) unique.add(id);
+  }
+  return Array.from(unique);
+}
+function resolveDependencyOrder(manifest) {
+  const ids = new Set(manifest.map((feature) => feature.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = /* @__PURE__ */ new Map();
+  for (const feature of manifest) {
+    outgoing.set(feature.id, /* @__PURE__ */ new Set());
+    indegree.set(feature.id, 0);
+  }
+  for (const feature of manifest) {
+    for (const dependencyId of getDirectDependencies(feature)) {
+      if (!ids.has(dependencyId)) continue;
+      const edges = outgoing.get(dependencyId);
+      if (!edges || edges.has(feature.id)) continue;
+      edges.add(feature.id);
+      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+  }
+  const ordered = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id) continue;
+    ordered.push(id);
+    const edges = outgoing.get(id);
+    if (!edges) continue;
+    for (const nextId of edges) {
+      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, nextDegree);
+      if (nextDegree === 0) queue.push(nextId);
+    }
+  }
+  if (ordered.length < manifest.length) {
+    const included = new Set(ordered);
+    for (const feature of manifest) {
+      if (included.has(feature.id)) continue;
+      ordered.push(feature.id);
+    }
+  }
+  return ordered;
+}
+function hasDependencyCycle(manifest) {
+  const ids = new Set(manifest.map((feature) => feature.id));
+  const outgoing = /* @__PURE__ */ new Map();
+  const indegree = /* @__PURE__ */ new Map();
+  for (const feature of manifest) {
+    outgoing.set(feature.id, /* @__PURE__ */ new Set());
+    indegree.set(feature.id, 0);
+  }
+  for (const feature of manifest) {
+    for (const dependencyId of getDirectDependencies(feature)) {
+      if (!ids.has(dependencyId)) continue;
+      const edges = outgoing.get(dependencyId);
+      if (!edges || edges.has(feature.id)) continue;
+      edges.add(feature.id);
+      indegree.set(feature.id, (indegree.get(feature.id) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const feature of manifest) {
+    if ((indegree.get(feature.id) ?? 0) === 0) queue.push(feature.id);
+  }
+  let visited = 0;
+  while (queue.length > 0) {
+    const id = queue.shift();
+    if (!id) continue;
+    visited += 1;
+    const edges = outgoing.get(id);
+    if (!edges) continue;
+    for (const nextId of edges) {
+      const nextDegree = (indegree.get(nextId) ?? 0) - 1;
+      indegree.set(nextId, nextDegree);
+      if (nextDegree === 0) queue.push(nextId);
+    }
+  }
+  return visited !== manifest.length;
+}
+function sortFeaturesByDependencies(features) {
+  if (features.length <= 1) return [...features];
+  const order = resolveDependencyOrder(features);
+  const rank = new Map(order.map((id, index) => [id, index]));
+  return [...features].sort((a, b) => {
+    const ra = rank.get(a.id);
+    const rb = rank.get(b.id);
+    if (ra === void 0 || rb === void 0) return 0;
+    return ra - rb;
+  });
+}
+
+// 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 };
+}
+var featureEntryJsonSchema = {
+  type: "object",
+  required: ["id", "label", "releasedAt", "showNewUntil"],
+  properties: {
+    id: { type: "string" },
+    label: { type: "string" },
+    description: { type: "string" },
+    releasedAt: { type: "string", format: "date-time" },
+    showNewUntil: { type: "string", format: "date-time" },
+    type: { enum: ["feature", "improvement", "fix", "breaking"] },
+    priority: { enum: ["critical", "normal", "low"] }
+  }
+};
+var featureManifestJsonSchema = {
+  type: "array",
+  items: featureEntryJsonSchema
+};
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isValidDate(value) {
+  return Number.isFinite(new Date(value).getTime());
+}
+var nonEmptyString = zod.z.string().trim().min(1, "must be a non-empty string");
+var isoDateString = nonEmptyString.refine(isValidDate, {
+  message: "must be a valid date",
+  params: { featuredropCode: "invalid_date" }
+});
+var dependsOnSchema = zod.z.object({
+  seen: zod.z.array(zod.z.string()).optional(),
+  clicked: zod.z.array(zod.z.string()).optional(),
+  dismissed: zod.z.array(zod.z.string()).optional()
+}).optional();
+var featureEntrySchema = zod.z.object({
+  id: nonEmptyString,
+  label: nonEmptyString,
+  releasedAt: isoDateString,
+  showNewUntil: isoDateString,
+  description: zod.z.string().optional(),
+  type: zod.z.enum(["feature", "improvement", "fix", "breaking"]).optional(),
+  priority: zod.z.enum(["critical", "normal", "low"]).optional(),
+  dependsOn: dependsOnSchema
+}).passthrough();
+var featureManifestSchema = zod.z.array(featureEntrySchema);
+function toIssuePath(path) {
+  if (path.length === 0) return "$";
+  let output = "";
+  for (const part of path) {
+    if (typeof part === "number") output += `[${part}]`;
+    else output += output ? `.${part}` : part;
+  }
+  return output;
+}
+function mapZodIssue(issue) {
+  const codeParam = issue.params?.featuredropCode;
+  if (codeParam === "invalid_date") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: "invalid_date"
+    };
+  }
+  if (issue.code === "invalid_type") {
+    return {
+      path: toIssuePath(issue.path),
+      message: issue.message,
+      code: issue.received === "undefined" ? "missing_required" : "invalid_type"
+    };
+  }
+  return {
+    path: toIssuePath(issue.path),
+    message: issue.message,
+    code: "invalid_value"
+  };
+}
+function validateFeatureEntry(raw, index) {
+  if (!isRecord(raw)) {
+    return {
+      issues: [
+        {
+          path: `[${index}]`,
+          message: "Feature entry must be an object",
+          code: "invalid_type"
+        }
+      ]
+    };
+  }
+  const parsed = featureEntrySchema.safeParse(raw);
+  if (!parsed.success) {
+    return {
+      issues: parsed.error.issues.map((issue) => ({
+        ...mapZodIssue(issue),
+        path: `[${index}]${issue.path.length > 0 ? `.${toIssuePath(issue.path)}` : ""}`
+      }))
+    };
+  }
+  return {
+    issues: [],
+    entry: parsed.data
+  };
+}
+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"
+      });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
 
 // src/adapters/local-storage.ts
 var DISMISSED_SUFFIX = ":dismissed";
@@ -120,14 +1859,1035 @@ var MemoryAdapter = class {
   }
 };
 
+// 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;
+  constructor(options) {
+    this.baseUrl = options.url.replace(/\/$/, "");
+    this.headers = options.headers ?? {};
+    this.fetchInterval = options.fetchInterval ?? 5 * 60 * 1e3;
+    this.userId = options.userId;
+  }
+  /** Fetch manifest with stale-while-revalidate */
+  async fetchManifest(force = false) {
+    const now = Date.now();
+    if (!force && this.lastManifest && now - this.lastFetchTs < this.fetchInterval) {
+      return this.lastManifest;
+    }
+    const fetchImpl = assertFetch();
+    const res = await fetchImpl(this.baseUrl, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!res.ok) throw new Error(`RemoteAdapter manifest fetch failed: ${res.status}`);
+    const json = await res.json();
+    this.lastManifest = json;
+    this.lastFetchTs = now;
+    return json;
+  }
+  /** Fetch state (watermark + dismissed IDs) */
+  async syncState() {
+    const fetchImpl = assertFetch();
+    const url = this.userId ? `${this.baseUrl}/state?userId=${encodeURIComponent(this.userId)}` : `${this.baseUrl}/state`;
+    const res = await fetchImpl(url, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!res.ok) return;
+    const json = await res.json();
+    if (json.watermark !== void 0) this.watermark = json.watermark;
+    if (Array.isArray(json.dismissedIds)) this.dismissedIds = new Set(json.dismissedIds);
+  }
+  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(() => {
+    });
+  }
+  async flushDismiss(id) {
+    const fetchImpl = assertFetch();
+    await fetchImpl(`${this.baseUrl}/dismiss`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.headers },
+      body: JSON.stringify({ featureId: id })
+    });
+  }
+  async flushDismissAll(now) {
+    const fetchImpl = assertFetch();
+    await fetchImpl(`${this.baseUrl}/dismiss-all`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...this.headers },
+      body: JSON.stringify({ watermark: now.toISOString() })
+    });
+  }
+};
+
+// src/adapters/postgres.ts
+function normalizeDismissedIds(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(normalizeDismissedIds(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: normalizeDismissedIds(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;
+  constructor(options) {
+    this.local = options.local;
+    this.remote = options.remote;
+    this.userId = options.remote.userId;
+    this.syncBeforeWrite = options.syncBeforeWrite ?? false;
+  }
+  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.remote.dismiss(id);
+  }
+  async dismissAll(now) {
+    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() {
+    await this.remote.destroy();
+  }
+};
+
+// 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 normalizeDismissedIds2(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(normalizeDismissedIds2(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: normalizeDismissedIds2(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 normalizeDismissedIds3(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(normalizeDismissedIds3(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: normalizeDismissedIds3(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: normalizeDismissedIds3(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 normalizeDismissedIds4(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(normalizeDismissedIds4(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: normalizeDismissedIds4(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 normalizeDismissedIds5(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(normalizeDismissedIds5(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: normalizeDismissedIds5(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();
+  }
+};
+
+exports.AmplitudeAdapter = AmplitudeAdapter;
+exports.AnalyticsCollector = AnalyticsCollector;
+exports.CustomAdapter = CustomAdapter;
+exports.FEATUREDROP_THEMES = FEATUREDROP_THEMES;
+exports.FEATUREDROP_TRANSLATIONS = FEATUREDROP_TRANSLATIONS;
+exports.HybridAdapter = HybridAdapter;
 exports.LocalStorageAdapter = LocalStorageAdapter;
 exports.MemoryAdapter = MemoryAdapter;
+exports.MixpanelAdapter = MixpanelAdapter;
+exports.MongoAdapter = MongoAdapter;
+exports.MySQLAdapter = MySQLAdapter;
+exports.PostHogAdapter = PostHogAdapter;
+exports.PostgresAdapter = PostgresAdapter;
+exports.RedisAdapter = RedisAdapter;
+exports.RemoteAdapter = RemoteAdapter;
+exports.SQLiteAdapter = SQLiteAdapter;
+exports.SegmentAdapter = SegmentAdapter;
+exports.SupabaseAdapter = SupabaseAdapter;
+exports.TriggerEngine = TriggerEngine;
+exports.applyAnnouncementThrottle = applyAnnouncementThrottle;
+exports.applyFeatureVariant = applyFeatureVariant;
+exports.applyFeatureVariants = applyFeatureVariants;
+exports.computeManifestStats = computeManifestStats;
+exports.createAdoptionMetrics = createAdoptionMetrics;
 exports.createManifest = createManifest;
+exports.createTheme = createTheme;
+exports.featureEntryJsonSchema = featureEntryJsonSchema;
+exports.featureEntrySchema = featureEntrySchema;
+exports.featureManifestJsonSchema = featureManifestJsonSchema;
+exports.featureManifestSchema = featureManifestSchema;
+exports.generateMarkdownChangelog = generateMarkdownChangelog;
+exports.generateRSS = generateRSS;
 exports.getFeatureById = getFeatureById;
+exports.getFeatureVariantName = getFeatureVariantName;
 exports.getNewFeatureCount = getNewFeatureCount;
 exports.getNewFeatures = getNewFeatures;
 exports.getNewFeaturesByCategory = getNewFeaturesByCategory;
+exports.getNewFeaturesSorted = getNewFeaturesSorted;
+exports.getOrCreateVariantKey = getOrCreateVariantKey;
+exports.hasDependencyCycle = hasDependencyCycle;
 exports.hasNewFeature = hasNewFeature;
 exports.isNew = isNew;
+exports.isTriggerMatch = isTriggerMatch;
+exports.matchesAudience = matchesAudience;
+exports.parseDescription = parseDescription;
+exports.resolveDependencyOrder = resolveDependencyOrder;
+exports.resolveTheme = resolveTheme;
+exports.resolveTranslations = resolveTranslations;
+exports.runDoctor = runDoctor;
+exports.sortFeaturesByDependencies = sortFeaturesByDependencies;
+exports.themeToCSSVariables = themeToCSSVariables;
+exports.validateManifest = validateManifest;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map