featuredrop 1.3.0 → 2.1.0

package/dist/adapters.js

@@ -0,0 +1,1745 @@
+// src/adapters/local-storage.ts
+var DISMISSED_SUFFIX = ":dismissed";
+var LocalStorageAdapter = class {
+  prefix;
+  watermarkValue;
+  onDismissAllCallback;
+  dismissedKey;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "featuredrop";
+    this.watermarkValue = options.watermark ?? null;
+    this.onDismissAllCallback = options.onDismissAll;
+    this.dismissedKey = `${this.prefix}${DISMISSED_SUFFIX}`;
+  }
+  getWatermark() {
+    return this.watermarkValue;
+  }
+  getDismissedIds() {
+    try {
+      if (typeof window === "undefined") return /* @__PURE__ */ new Set();
+      const raw = localStorage.getItem(this.dismissedKey);
+      if (!raw) return /* @__PURE__ */ new Set();
+      const parsed = JSON.parse(raw);
+      if (Array.isArray(parsed)) return new Set(parsed);
+      return /* @__PURE__ */ new Set();
+    } catch {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  dismiss(id) {
+    try {
+      if (typeof window === "undefined") return;
+      const raw = localStorage.getItem(this.dismissedKey);
+      const existing = raw ? JSON.parse(raw) : [];
+      if (!existing.includes(id)) {
+        existing.push(id);
+        localStorage.setItem(this.dismissedKey, JSON.stringify(existing));
+      }
+    } catch {
+    }
+  }
+  async dismissAll(now) {
+    try {
+      if (typeof window !== "undefined") {
+        localStorage.removeItem(this.dismissedKey);
+      }
+    } catch {
+    }
+    if (this.onDismissAllCallback) {
+      await this.onDismissAllCallback(now);
+    }
+  }
+};
+
+// src/adapters/indexeddb.ts
+var DISMISSED_SUFFIX2 = ":dismissed";
+var WATERMARK_SUFFIX = ":watermark";
+var QUEUE_SUFFIX = ":queue";
+function canUseLocalStorage() {
+  return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
+}
+function readLocalStorageState(prefix) {
+  if (!canUseLocalStorage()) {
+    return { watermark: null, dismissed: [], queue: [] };
+  }
+  try {
+    const dismissedRaw = localStorage.getItem(`${prefix}${DISMISSED_SUFFIX2}`);
+    const watermarkRaw = localStorage.getItem(`${prefix}${WATERMARK_SUFFIX}`);
+    const queueRaw = localStorage.getItem(`${prefix}${QUEUE_SUFFIX}`);
+    const dismissedParsed = dismissedRaw ? JSON.parse(dismissedRaw) : [];
+    const queueParsed = queueRaw ? JSON.parse(queueRaw) : [];
+    return {
+      watermark: typeof watermarkRaw === "string" ? watermarkRaw : null,
+      dismissed: Array.isArray(dismissedParsed) ? dismissedParsed.filter((value) => typeof value === "string") : [],
+      queue: normalizeQueue(queueParsed)
+    };
+  } catch {
+    return { watermark: null, dismissed: [], queue: [] };
+  }
+}
+function writeLocalStorageState(prefix, state) {
+  if (!canUseLocalStorage()) return;
+  try {
+    localStorage.setItem(`${prefix}${DISMISSED_SUFFIX2}`, JSON.stringify(state.dismissed));
+    if (state.watermark) {
+      localStorage.setItem(`${prefix}${WATERMARK_SUFFIX}`, state.watermark);
+    } else {
+      localStorage.removeItem(`${prefix}${WATERMARK_SUFFIX}`);
+    }
+    if (state.queue && state.queue.length > 0) {
+      localStorage.setItem(`${prefix}${QUEUE_SUFFIX}`, JSON.stringify(state.queue));
+    } else {
+      localStorage.removeItem(`${prefix}${QUEUE_SUFFIX}`);
+    }
+  } catch {
+  }
+}
+function getIndexedDBFactory() {
+  if (typeof globalThis === "undefined") return null;
+  const candidate = globalThis.indexedDB;
+  return candidate ?? null;
+}
+function normalizeQueue(value) {
+  if (!Array.isArray(value)) return [];
+  const queue = [];
+  for (const item of value) {
+    if (!item || typeof item !== "object") continue;
+    const candidate = item;
+    if (candidate.type === "dismiss" && typeof candidate.id === "string") {
+      queue.push({ type: "dismiss", id: candidate.id });
+      continue;
+    }
+    if (candidate.type === "dismissAll" && typeof candidate.watermark === "string") {
+      queue.push({ type: "dismissAll", watermark: candidate.watermark });
+      continue;
+    }
+  }
+  return queue;
+}
+function normalizeDismissedIds(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry) => typeof entry === "string");
+}
+function parseIso(value) {
+  if (!value) return Number.NaN;
+  return new Date(value).getTime();
+}
+function resolveLatestWatermark(a, b) {
+  if (!a) return b ?? null;
+  if (!b) return a;
+  const aTs = parseIso(a);
+  const bTs = parseIso(b);
+  if (!Number.isFinite(aTs)) return b;
+  if (!Number.isFinite(bTs)) return a;
+  return aTs >= bTs ? a : b;
+}
+var IndexedDBAdapter = class {
+  prefix;
+  dbName;
+  storeName;
+  onDismissAllCallback;
+  onSyncStateCallback;
+  onFlushDismissBatchCallback;
+  onFlushDismissAllCallback;
+  flushDebounceMs;
+  autoSyncOnOnline;
+  watermark;
+  dismissed;
+  queue;
+  hydratePromise;
+  flushTimer = null;
+  flushing = false;
+  boundOnlineHandler;
+  boundVisibilityHandler;
+  constructor(options = {}) {
+    this.prefix = options.prefix ?? "featuredrop";
+    this.dbName = options.dbName ?? "featuredrop";
+    this.storeName = options.storeName ?? "state";
+    this.onDismissAllCallback = options.onDismissAll;
+    this.onSyncStateCallback = options.onSyncState;
+    this.onFlushDismissBatchCallback = options.onFlushDismissBatch;
+    this.onFlushDismissAllCallback = options.onFlushDismissAll;
+    this.flushDebounceMs = options.flushDebounceMs ?? 500;
+    this.autoSyncOnOnline = options.autoSyncOnOnline ?? true;
+    const localState = readLocalStorageState(this.prefix);
+    this.watermark = options.watermark ?? localState.watermark;
+    this.dismissed = new Set(localState.dismissed);
+    this.queue = localState.queue ?? [];
+    this.hydratePromise = this.hydrateFromIndexedDB();
+    const canAttachListeners = this.autoSyncOnOnline && typeof window !== "undefined";
+    if (canAttachListeners) {
+      this.boundOnlineHandler = () => {
+        void this.syncFromRemote();
+      };
+      this.boundVisibilityHandler = () => {
+        if (document.visibilityState === "visible") {
+          void this.syncFromRemote();
+        }
+      };
+      window.addEventListener("online", this.boundOnlineHandler);
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+    } else {
+      this.boundOnlineHandler = null;
+      this.boundVisibilityHandler = null;
+    }
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissed;
+  }
+  dismiss(id) {
+    if (!id || this.dismissed.has(id)) return;
+    this.dismissed = new Set(this.dismissed).add(id);
+    this.queue.push({ type: "dismiss", id });
+    this.persist();
+    this.scheduleFlush();
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissed = /* @__PURE__ */ new Set();
+    this.queue = [{ type: "dismissAll", watermark: this.watermark }];
+    this.persist();
+    this.scheduleFlush();
+    await this.onDismissAllCallback?.(now);
+  }
+  /** Flush queued dismiss operations to optional remote callbacks. */
+  async flushQueue() {
+    if (this.flushing || this.queue.length === 0) return;
+    if (!this.onFlushDismissBatchCallback && !this.onFlushDismissAllCallback) return;
+    this.flushing = true;
+    try {
+      const operations = [...this.queue];
+      const lastDismissAll = this.getLastDismissAll(operations);
+      const dismissIds = this.collectDismissBatch(operations, !!lastDismissAll);
+      const hasDismissAll = !!lastDismissAll;
+      const needsDismissBatch = dismissIds.length > 0;
+      if (hasDismissAll && !this.onFlushDismissAllCallback) return;
+      if (needsDismissBatch && !this.onFlushDismissBatchCallback) return;
+      if (lastDismissAll && this.onFlushDismissAllCallback) {
+        await this.onFlushDismissAllCallback(lastDismissAll.watermark);
+      }
+      if (dismissIds.length > 0 && this.onFlushDismissBatchCallback) {
+        await this.onFlushDismissBatchCallback(dismissIds);
+      }
+      if (this.queue.length <= operations.length) {
+        this.queue = [];
+      } else {
+        this.queue = this.queue.slice(operations.length);
+      }
+      this.persist();
+    } catch {
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Merge local state with optional remote source, then flush queued writes. */
+  async syncFromRemote() {
+    await this.hydratePromise.catch(() => void 0);
+    if (this.onSyncStateCallback) {
+      try {
+        const remote = await this.onSyncStateCallback();
+        const mergedDismissed = new Set(this.dismissed);
+        for (const id of normalizeDismissedIds(remote.dismissedIds)) {
+          mergedDismissed.add(id);
+        }
+        this.dismissed = mergedDismissed;
+        this.watermark = resolveLatestWatermark(this.watermark, remote.watermark ?? null);
+        this.persist();
+      } catch {
+      }
+    }
+    await this.flushQueue();
+  }
+  /** Cleanup optional browser listeners. */
+  destroy() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.boundOnlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", this.boundOnlineHandler);
+    }
+    if (this.boundVisibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+    }
+  }
+  persist() {
+    const snapshot = {
+      watermark: this.watermark,
+      dismissed: Array.from(this.dismissed),
+      queue: this.queue
+    };
+    writeLocalStorageState(this.prefix, snapshot);
+    void this.writeIndexedDBState(snapshot);
+  }
+  async hydrateFromIndexedDB() {
+    const state = await this.readIndexedDBState();
+    if (!state) return;
+    this.watermark = state.watermark;
+    this.dismissed = new Set(state.dismissed);
+    this.queue = state.queue ?? [];
+    writeLocalStorageState(this.prefix, state);
+  }
+  async readIndexedDBState() {
+    const db = await this.openDb();
+    if (!db) return null;
+    return new Promise((resolve) => {
+      const tx = db.transaction(this.storeName, "readonly");
+      const store = tx.objectStore(this.storeName);
+      const request = store.get(this.prefix);
+      request.onsuccess = () => {
+        const value = request.result;
+        if (!value) {
+          resolve(null);
+          return;
+        }
+        resolve({
+          watermark: typeof value.watermark === "string" ? value.watermark : null,
+          dismissed: normalizeDismissedIds(value.dismissed),
+          queue: normalizeQueue(value.queue)
+        });
+      };
+      request.onerror = () => resolve(null);
+    });
+  }
+  async writeIndexedDBState(state) {
+    await this.hydratePromise.catch(() => void 0);
+    const db = await this.openDb();
+    if (!db) return;
+    await new Promise((resolve) => {
+      const tx = db.transaction(this.storeName, "readwrite");
+      const store = tx.objectStore(this.storeName);
+      store.put(state, this.prefix);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => resolve();
+      tx.onabort = () => resolve();
+    });
+  }
+  async openDb() {
+    const factory = getIndexedDBFactory();
+    if (!factory) return null;
+    return new Promise((resolve) => {
+      const request = factory.open(this.dbName, 1);
+      request.onerror = () => resolve(null);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(this.storeName)) {
+          db.createObjectStore(this.storeName);
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+    });
+  }
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      void this.flushQueue();
+    }, this.flushDebounceMs);
+  }
+  getLastDismissAll(operations) {
+    for (let index = operations.length - 1; index >= 0; index--) {
+      const operation = operations[index];
+      if (operation.type === "dismissAll") {
+        return { watermark: operation.watermark };
+      }
+    }
+    return null;
+  }
+  collectDismissBatch(operations, skipBeforeDismissAll) {
+    const startIndex = skipBeforeDismissAll ? operations.reduce(
+      (lastIndex, operation, index) => operation.type === "dismissAll" ? index : lastIndex,
+      -1
+    ) : -1;
+    const batch = /* @__PURE__ */ new Set();
+    for (let index = startIndex + 1; index < operations.length; index++) {
+      const operation = operations[index];
+      if (operation.type === "dismiss") {
+        batch.add(operation.id);
+      }
+    }
+    return Array.from(batch);
+  }
+};
+
+// src/adapters/memory.ts
+var MemoryAdapter = class {
+  watermark;
+  dismissed;
+  constructor(options = {}) {
+    this.watermark = options.watermark ?? null;
+    this.dismissed = /* @__PURE__ */ new Set();
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissed;
+  }
+  dismiss(id) {
+    this.dismissed.add(id);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissed.clear();
+  }
+};
+
+// src/adapters/remote.ts
+var RemoteHttpError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "RemoteHttpError";
+    this.status = status;
+  }
+};
+function assertFetch() {
+  if (typeof fetch === "undefined") {
+    throw new Error("RemoteAdapter requires global fetch (Node 18+ or polyfill)");
+  }
+  return fetch;
+}
+var RemoteAdapter = class {
+  baseUrl;
+  headers;
+  fetchInterval;
+  userId;
+  dismissedIds = /* @__PURE__ */ new Set();
+  watermark = null;
+  lastManifest = null;
+  lastFetchTs = 0;
+  retryAttempts;
+  retryBaseDelayMs;
+  circuitBreakerThreshold;
+  circuitBreakerCooldownMs;
+  sleep;
+  now;
+  requestTimeoutMs;
+  retryOnStatuses;
+  dismissBatchWindowMs;
+  maxDismissBatchSize;
+  disableDismissBatch;
+  syncOnOnline;
+  syncOnVisibilityChange;
+  syncIntervalMs;
+  onError;
+  consecutiveFailures = 0;
+  circuitOpenUntil = 0;
+  manifestInFlight = null;
+  stateSyncInFlight = null;
+  dismissFlushInFlight = null;
+  dismissFlushTimer = null;
+  syncTimer = null;
+  pendingDismissIds = /* @__PURE__ */ new Set();
+  supportsDismissBatch = true;
+  boundOnlineHandler = null;
+  boundVisibilityHandler = null;
+  constructor(options) {
+    this.baseUrl = options.url.replace(/\/$/, "");
+    this.headers = options.headers ?? {};
+    this.fetchInterval = options.fetchInterval ?? 5 * 60 * 1e3;
+    this.userId = options.userId;
+    this.retryAttempts = options.retryAttempts ?? 3;
+    this.retryBaseDelayMs = options.retryBaseDelayMs ?? 250;
+    this.circuitBreakerThreshold = options.circuitBreakerThreshold ?? 5;
+    this.circuitBreakerCooldownMs = options.circuitBreakerCooldownMs ?? 6e4;
+    this.sleep = options.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
+    this.now = options.now ?? (() => Date.now());
+    this.requestTimeoutMs = options.requestTimeoutMs ?? 1e4;
+    this.retryOnStatuses = new Set(options.retryOnStatuses ?? [408, 429, 500, 502, 503, 504]);
+    this.dismissBatchWindowMs = options.dismissBatchWindowMs ?? 150;
+    this.maxDismissBatchSize = Math.max(1, options.maxDismissBatchSize ?? 100);
+    this.disableDismissBatch = options.disableDismissBatch ?? false;
+    this.syncOnOnline = options.syncOnOnline ?? false;
+    this.syncOnVisibilityChange = options.syncOnVisibilityChange ?? false;
+    this.syncIntervalMs = Math.max(0, options.syncIntervalMs ?? 0);
+    this.onError = options.onError;
+    if (typeof window !== "undefined" && this.syncOnOnline) {
+      this.boundOnlineHandler = () => {
+        void this.runRecoverySync();
+      };
+      window.addEventListener("online", this.boundOnlineHandler);
+    }
+    if (typeof document !== "undefined" && this.syncOnVisibilityChange) {
+      this.boundVisibilityHandler = () => {
+        if (document.visibilityState === "visible") {
+          void this.runRecoverySync();
+        }
+      };
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+    }
+    if (this.syncIntervalMs > 0) {
+      this.syncTimer = setInterval(() => {
+        void this.syncState();
+      }, this.syncIntervalMs);
+    }
+  }
+  /** Fetch manifest with stale-while-revalidate */
+  async fetchManifest(force = false) {
+    const now = this.now();
+    if (!force && this.lastManifest && now - this.lastFetchTs < this.fetchInterval) {
+      return this.lastManifest;
+    }
+    if (this.manifestInFlight) return this.manifestInFlight;
+    const task = (async () => {
+      try {
+        const json = await this.withRetry(
+          "fetchManifest",
+          async () => this.requestJson("", {
+            method: "GET",
+            headers: this.headers
+          })
+        );
+        this.lastManifest = json;
+        this.lastFetchTs = now;
+        return json;
+      } catch {
+        return this.lastManifest ?? [];
+      }
+    })();
+    this.manifestInFlight = task.finally(() => {
+      this.manifestInFlight = null;
+    });
+    return this.manifestInFlight;
+  }
+  /** Fetch state (watermark + dismissed IDs) */
+  async syncState() {
+    if (this.stateSyncInFlight) return this.stateSyncInFlight;
+    const task = (async () => {
+      try {
+        const query = this.userId ? `?userId=${encodeURIComponent(this.userId)}` : "";
+        const json = await this.withRetry(
+          "syncState",
+          async () => this.requestJson(`/state${query}`, {
+            method: "GET",
+            headers: this.headers
+          })
+        );
+        if (json.watermark !== void 0) this.watermark = json.watermark;
+        if (Array.isArray(json.dismissedIds)) this.dismissedIds = new Set(json.dismissedIds);
+      } catch {
+      }
+    })();
+    this.stateSyncInFlight = task.finally(() => {
+      this.stateSyncInFlight = null;
+    });
+    return this.stateSyncInFlight;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    if (!id) return;
+    this.dismissedIds.add(id);
+    this.pendingDismissIds.add(id);
+    this.scheduleDismissFlush();
+  }
+  async dismissAll(now) {
+    await this.flushPendingDismisses().catch(() => {
+    });
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.flushDismissAll(now).catch(() => {
+    });
+  }
+  /** Cleanup timers/listeners and flush any queued dismiss operations. */
+  async destroy() {
+    if (this.dismissFlushTimer) {
+      clearTimeout(this.dismissFlushTimer);
+      this.dismissFlushTimer = null;
+    }
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    if (this.boundOnlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", this.boundOnlineHandler);
+    }
+    if (this.boundVisibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+    }
+    await this.flushPendingDismisses().catch(() => {
+    });
+  }
+  /** Returns current adapter health; false while circuit breaker is open. */
+  async isHealthy() {
+    if (this.isCircuitOpen()) return false;
+    try {
+      await this.withRetry(
+        "isHealthy",
+        async () => this.requestVoid("", {
+          method: "GET",
+          headers: this.headers
+        })
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async flushDismiss(id) {
+    await this.withRetry(
+      "dismiss",
+      async () => this.requestVoid("/dismiss", {
+        method: "POST",
+        jsonBody: { featureId: id }
+      })
+    );
+  }
+  async flushDismissAll(now) {
+    await this.withRetry(
+      "dismissAll",
+      async () => this.requestVoid("/dismiss-all", {
+        method: "POST",
+        jsonBody: { watermark: now.toISOString() }
+      })
+    );
+  }
+  isCircuitOpen() {
+    return this.now() < this.circuitOpenUntil;
+  }
+  markFailure() {
+    this.consecutiveFailures += 1;
+    if (this.consecutiveFailures >= this.circuitBreakerThreshold) {
+      this.circuitOpenUntil = this.now() + this.circuitBreakerCooldownMs;
+    }
+  }
+  markSuccess() {
+    this.consecutiveFailures = 0;
+    this.circuitOpenUntil = 0;
+  }
+  /** Force-flush queued dismiss IDs immediately. */
+  async flushPendingDismisses() {
+    if (this.dismissFlushTimer) {
+      clearTimeout(this.dismissFlushTimer);
+      this.dismissFlushTimer = null;
+    }
+    if (this.dismissFlushInFlight) return this.dismissFlushInFlight;
+    const task = this.flushPendingDismissesInternal();
+    this.dismissFlushInFlight = task.finally(() => {
+      this.dismissFlushInFlight = null;
+    });
+    return this.dismissFlushInFlight;
+  }
+  async flushPendingDismissesInternal() {
+    if (this.pendingDismissIds.size === 0) return;
+    const ids = Array.from(this.pendingDismissIds);
+    this.pendingDismissIds.clear();
+    try {
+      await this.flushDismissBatch(ids);
+    } catch {
+      for (const id of ids) this.pendingDismissIds.add(id);
+      throw new Error("RemoteAdapter dismiss flush failed");
+    }
+  }
+  async flushDismissBatch(ids) {
+    for (let index = 0; index < ids.length; index += this.maxDismissBatchSize) {
+      const chunk = ids.slice(index, index + this.maxDismissBatchSize);
+      if (chunk.length === 1 || this.disableDismissBatch || !this.supportsDismissBatch) {
+        await this.flushDismiss(chunk[0]);
+        continue;
+      }
+      try {
+        await this.withRetry(
+          "dismissBatch",
+          async () => this.requestVoid("/dismiss-batch", {
+            method: "POST",
+            jsonBody: { featureIds: chunk }
+          })
+        );
+      } catch (error) {
+        const status = error instanceof RemoteHttpError ? error.status : void 0;
+        if (status === 404 || status === 405 || status === 501) {
+          this.supportsDismissBatch = false;
+          for (const id of chunk) {
+            await this.flushDismiss(id);
+          }
+          continue;
+        }
+        throw error;
+      }
+    }
+  }
+  scheduleDismissFlush() {
+    if (this.dismissFlushTimer) return;
+    this.dismissFlushTimer = setTimeout(() => {
+      this.dismissFlushTimer = null;
+      void this.flushPendingDismisses().catch(() => {
+        this.scheduleDismissFlush();
+      });
+    }, this.dismissBatchWindowMs);
+  }
+  async runRecoverySync() {
+    await this.flushPendingDismisses().catch(() => {
+    });
+    await this.syncState();
+  }
+  async requestJson(path, init) {
+    const response = await this.request(path, init);
+    return await response.json();
+  }
+  async requestVoid(path, init) {
+    await this.request(path, init);
+  }
+  async request(path, init) {
+    const fetchImpl = assertFetch();
+    const controller = new AbortController();
+    const timeoutId = this.requestTimeoutMs > 0 ? setTimeout(() => {
+      controller.abort();
+    }, this.requestTimeoutMs) : null;
+    try {
+      const res = await fetchImpl(`${this.baseUrl}${path}`, {
+        method: init.method,
+        headers: {
+          ...init.jsonBody ? { "Content-Type": "application/json" } : {},
+          ...this.headers,
+          ...init.headers ?? {}
+        },
+        body: init.jsonBody === void 0 ? void 0 : JSON.stringify(init.jsonBody),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new RemoteHttpError(
+          `RemoteAdapter request failed (${res.status}) for ${path || "/"}`,
+          res.status
+        );
+      }
+      return res;
+    } catch (error) {
+      const name = error instanceof DOMException ? error.name : error && typeof error === "object" && "name" in error ? String(error.name) : "";
+      if (name === "AbortError") {
+        throw new Error(`RemoteAdapter request timed out after ${this.requestTimeoutMs}ms`);
+      }
+      throw error;
+    } finally {
+      if (timeoutId) clearTimeout(timeoutId);
+    }
+  }
+  shouldRetry(error) {
+    if (error instanceof RemoteHttpError) {
+      return this.retryOnStatuses.has(error.status);
+    }
+    const message = error instanceof Error ? error.message : "";
+    if (message.includes("circuit breaker is open")) return false;
+    return true;
+  }
+  async withRetry(operationName, operation) {
+    if (this.isCircuitOpen()) {
+      throw new Error("RemoteAdapter circuit breaker is open");
+    }
+    let lastError = new Error("RemoteAdapter request failed");
+    for (let attempt = 0; attempt <= this.retryAttempts; attempt++) {
+      try {
+        const result = await operation();
+        this.markSuccess();
+        return result;
+      } catch (error) {
+        lastError = error;
+        this.onError?.(error, { operation: operationName, attempt });
+        if (attempt >= this.retryAttempts || !this.shouldRetry(error)) break;
+        const delayMs = this.retryBaseDelayMs * 2 ** attempt;
+        await this.sleep(delayMs);
+      }
+    }
+    this.markFailure();
+    throw lastError instanceof Error ? lastError : new Error("RemoteAdapter request failed");
+  }
+};
+
+// src/adapters/postgres.ts
+function normalizeDismissedIds2(row) {
+  if (!row) return [];
+  const ids = row.dismissed_ids ?? row.dismissedIds;
+  if (!Array.isArray(ids)) return [];
+  return ids.filter((id) => typeof id === "string");
+}
+function normalizeWatermark(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? row.lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var PostgresAdapter = class {
+  userId;
+  query;
+  tableName;
+  autoMigrate;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("PostgresAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.query = options.query;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.autoMigrate = options.autoMigrate ?? true;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.ensureReady();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES ($1, $2, '{}', NOW(), NOW(), NOW())
+       ON CONFLICT (user_id)
+       DO UPDATE SET watermark = EXCLUDED.watermark, dismissed_ids = '{}', last_seen = NOW(), updated_at = NOW()`,
+      [this.userId, this.watermark]
+    );
+  }
+  async sync() {
+    await this.ensureReady();
+    const result = await this.query(
+      `SELECT watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id = $1`,
+      [this.userId]
+    );
+    const row = result.rows[0];
+    this.watermark = normalizeWatermark(row);
+    this.dismissedIds = new Set(normalizeDismissedIds2(row));
+  }
+  async dismissBatch(ids) {
+    if (ids.length === 0) return;
+    await this.ensureReady();
+    const uniqueIds = Array.from(new Set(ids));
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES ($1, NULL, $2::text[], NOW(), NOW(), NOW())
+       ON CONFLICT (user_id)
+       DO UPDATE SET
+         dismissed_ids = (
+           SELECT ARRAY(
+             SELECT DISTINCT x FROM UNNEST(
+               COALESCE(${this.tableName}.dismissed_ids, '{}') || EXCLUDED.dismissed_ids
+             ) AS x
+           )
+         ),
+         last_seen = NOW(),
+         updated_at = NOW()`,
+      [this.userId, uniqueIds]
+    );
+  }
+  async resetUser(userId) {
+    await this.ensureReady();
+    await this.query(
+      `DELETE FROM ${this.tableName} WHERE user_id = $1`,
+      [userId]
+    );
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    await this.ensureReady();
+    if (userIds.length === 0) return /* @__PURE__ */ new Map();
+    const result = await this.query(
+      `SELECT user_id, watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id = ANY($1::text[])`,
+      [userIds]
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      out.set(row.user_id, {
+        watermark: normalizeWatermark(row),
+        dismissedIds: normalizeDismissedIds2(row),
+        lastSeen: normalizeLastSeen(row),
+        deviceCount: 1
+      });
+    }
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+  async ensureReady() {
+    if (this.initialized) return;
+    if (this.autoMigrate) {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          user_id TEXT PRIMARY KEY,
+          watermark TIMESTAMPTZ,
+          dismissed_ids TEXT[] DEFAULT '{}',
+          last_seen TIMESTAMPTZ DEFAULT NOW(),
+          created_at TIMESTAMPTZ DEFAULT NOW(),
+          updated_at TIMESTAMPTZ DEFAULT NOW()
+        )`
+      );
+      await this.query(
+        `CREATE INDEX IF NOT EXISTS idx_${this.tableName}_last_seen ON ${this.tableName}(last_seen)`
+      );
+    }
+    this.initialized = true;
+  }
+};
+
+// src/adapters/redis.ts
+var RedisAdapter = class {
+  userId;
+  client;
+  keyPrefix;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("RedisAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "fd:";
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.client.sadd(this.dismissedKey(this.userId), id);
+    void this.client.set(this.lastSeenKey(this.userId), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.client.multi().set(this.watermarkKey(this.userId), this.watermark).del(this.dismissedKey(this.userId)).set(this.lastSeenKey(this.userId), now.toISOString()).exec();
+  }
+  async sync() {
+    const [watermark, dismissedIds] = await Promise.all([
+      this.client.get(this.watermarkKey(this.userId)),
+      this.client.smembers(this.dismissedKey(this.userId))
+    ]);
+    this.watermark = watermark;
+    this.dismissedIds = new Set(dismissedIds);
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    this.dismissedIds = /* @__PURE__ */ new Set([...this.dismissedIds, ...uniqueIds]);
+    await this.client.sadd(this.dismissedKey(this.userId), ...uniqueIds);
+    await this.client.set(this.lastSeenKey(this.userId), (/* @__PURE__ */ new Date()).toISOString());
+  }
+  async resetUser(userId) {
+    await this.client.multi().del(this.watermarkKey(userId)).del(this.dismissedKey(userId)).del(this.lastSeenKey(userId)).exec();
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    const map = /* @__PURE__ */ new Map();
+    await Promise.all(
+      userIds.map(async (userId) => {
+        const [watermark, dismissedIds, lastSeen] = await Promise.all([
+          this.client.get(this.watermarkKey(userId)),
+          this.client.smembers(this.dismissedKey(userId)),
+          this.client.get(this.lastSeenKey(userId))
+        ]);
+        map.set(userId, {
+          watermark,
+          dismissedIds,
+          lastSeen: lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+          deviceCount: 1
+        });
+      })
+    );
+    return map;
+  }
+  async isHealthy() {
+    try {
+      const response = await this.client.ping();
+      return response.toUpperCase() === "PONG";
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+    if (this.client.quit) {
+      await this.client.quit();
+      return;
+    }
+    this.client.disconnect?.();
+  }
+  watermarkKey(userId) {
+    return `${this.keyPrefix}${userId}:watermark`;
+  }
+  dismissedKey(userId) {
+    return `${this.keyPrefix}${userId}:dismissed`;
+  }
+  lastSeenKey(userId) {
+    return `${this.keyPrefix}${userId}:last_seen`;
+  }
+};
+
+// src/adapters/hybrid.ts
+var HybridAdapter = class {
+  userId;
+  local;
+  remote;
+  syncBeforeWrite;
+  dismissBatchWindowMs;
+  syncIntervalMs;
+  syncOnVisibilityChange;
+  syncOnOnline;
+  pendingDismissIds = /* @__PURE__ */ new Set();
+  dismissTimer = null;
+  syncTimer = null;
+  flushInFlight = null;
+  syncInFlight = null;
+  boundVisibilityHandler;
+  boundOnlineHandler;
+  constructor(options) {
+    this.local = options.local;
+    this.remote = options.remote;
+    this.userId = options.remote.userId;
+    this.syncBeforeWrite = options.syncBeforeWrite ?? false;
+    this.dismissBatchWindowMs = options.dismissBatchWindowMs ?? 500;
+    this.syncIntervalMs = options.syncIntervalMs ?? 0;
+    this.syncOnVisibilityChange = options.syncOnVisibilityChange ?? true;
+    this.syncOnOnline = options.syncOnOnline ?? true;
+    if (typeof window !== "undefined" && this.syncOnOnline) {
+      this.boundOnlineHandler = () => {
+        void this.sync();
+      };
+      window.addEventListener("online", this.boundOnlineHandler);
+    } else {
+      this.boundOnlineHandler = null;
+    }
+    if (typeof document !== "undefined" && this.syncOnVisibilityChange) {
+      this.boundVisibilityHandler = () => {
+        if (document.visibilityState === "visible") {
+          void this.sync();
+        }
+      };
+      document.addEventListener("visibilitychange", this.boundVisibilityHandler);
+    } else {
+      this.boundVisibilityHandler = null;
+    }
+    if (this.syncIntervalMs > 0) {
+      this.syncTimer = setInterval(() => {
+        void this.sync();
+      }, this.syncIntervalMs);
+    }
+  }
+  getWatermark() {
+    return this.local.getWatermark() ?? this.remote.getWatermark();
+  }
+  getDismissedIds() {
+    const merged = /* @__PURE__ */ new Set();
+    for (const id of this.local.getDismissedIds()) merged.add(id);
+    for (const id of this.remote.getDismissedIds()) merged.add(id);
+    return merged;
+  }
+  dismiss(id) {
+    this.local.dismiss(id);
+    this.pendingDismissIds.add(id);
+    this.scheduleDismissFlush();
+  }
+  async dismissAll(now) {
+    await this.flushPendingDismisses();
+    this.pendingDismissIds.clear();
+    await Promise.all([
+      this.local.dismissAll(now),
+      this.remote.dismissAll(now)
+    ]);
+  }
+  async sync() {
+    if (this.syncInFlight) return this.syncInFlight;
+    const syncTask = (async () => {
+      await this.remote.sync();
+      await this.flushPendingDismissesInternal(true);
+    })();
+    const inFlight = syncTask.finally(() => {
+      if (this.syncInFlight === inFlight) this.syncInFlight = null;
+    });
+    this.syncInFlight = inFlight;
+    return inFlight;
+  }
+  async dismissBatch(ids) {
+    if (this.syncBeforeWrite) {
+      await this.remote.sync();
+    }
+    for (const id of ids) {
+      this.local.dismiss(id);
+    }
+    await this.remote.dismissBatch(ids);
+  }
+  async resetUser(userId) {
+    await this.remote.resetUser(userId);
+    if (userId === this.userId) {
+      await this.local.dismissAll(/* @__PURE__ */ new Date(0));
+    }
+  }
+  async getBulkState(userIds) {
+    return this.remote.getBulkState(userIds);
+  }
+  async isHealthy() {
+    return this.remote.isHealthy();
+  }
+  async destroy() {
+    if (this.dismissTimer) {
+      clearTimeout(this.dismissTimer);
+      this.dismissTimer = null;
+    }
+    if (this.syncTimer) {
+      clearInterval(this.syncTimer);
+      this.syncTimer = null;
+    }
+    if (this.boundOnlineHandler && typeof window !== "undefined") {
+      window.removeEventListener("online", this.boundOnlineHandler);
+    }
+    if (this.boundVisibilityHandler && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", this.boundVisibilityHandler);
+    }
+    await this.flushPendingDismisses();
+    await this.remote.destroy();
+  }
+  /** Manually flush queued dismiss operations to the remote adapter. */
+  async flushPendingDismisses() {
+    if (this.flushInFlight) return this.flushInFlight;
+    const flushTask = this.flushPendingDismissesInternal(false);
+    const inFlight = flushTask.finally(() => {
+      if (this.flushInFlight === inFlight) this.flushInFlight = null;
+    });
+    this.flushInFlight = inFlight;
+    return inFlight;
+  }
+  async flushPendingDismissesInternal(skipSyncBeforeWrite) {
+    while (this.pendingDismissIds.size > 0) {
+      const ids = Array.from(this.pendingDismissIds);
+      this.pendingDismissIds.clear();
+      try {
+        if (this.syncBeforeWrite && !skipSyncBeforeWrite) {
+          await this.remote.sync();
+        }
+        await this.remote.dismissBatch(ids);
+      } catch {
+        for (const id of ids) this.pendingDismissIds.add(id);
+        return;
+      }
+    }
+  }
+  scheduleDismissFlush() {
+    if (this.dismissTimer) return;
+    this.dismissTimer = setTimeout(() => {
+      this.dismissTimer = null;
+      void this.flushPendingDismisses();
+    }, this.dismissBatchWindowMs);
+  }
+};
+
+// src/adapters/mysql.ts
+function parseDismissedIds(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string");
+  }
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((item) => typeof item === "string");
+      }
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function normalizeDismissedIds3(row) {
+  if (!row) return [];
+  return parseDismissedIds(row.dismissed_ids ?? row.dismissedIds);
+}
+function normalizeWatermark2(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen2(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? row.lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var MySQLAdapter = class {
+  userId;
+  query;
+  tableName;
+  autoMigrate;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("MySQLAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.query = options.query;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.autoMigrate = options.autoMigrate ?? true;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.ensureReady();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, NOW(3), NOW(3), NOW(3))
+       ON DUPLICATE KEY UPDATE watermark = VALUES(watermark), dismissed_ids = VALUES(dismissed_ids), last_seen = NOW(3), updated_at = NOW(3)`,
+      [this.userId, this.watermark, JSON.stringify([])]
+    );
+  }
+  async sync() {
+    await this.ensureReady();
+    const result = await this.query(
+      `SELECT watermark, dismissed_ids, last_seen FROM ${this.tableName} WHERE user_id = ? LIMIT 1`,
+      [this.userId]
+    );
+    const row = result.rows[0];
+    this.watermark = normalizeWatermark2(row);
+    this.dismissedIds = new Set(normalizeDismissedIds3(row));
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    await this.ensureReady();
+    const merged = /* @__PURE__ */ new Set([
+      ...Array.from(this.dismissedIds),
+      ...uniqueIds
+    ]);
+    const mergedArray = Array.from(merged);
+    this.dismissedIds = merged;
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, NOW(3), NOW(3), NOW(3))
+       ON DUPLICATE KEY UPDATE dismissed_ids = VALUES(dismissed_ids), last_seen = NOW(3), updated_at = NOW(3)`,
+      [this.userId, this.watermark, JSON.stringify(mergedArray)]
+    );
+  }
+  async resetUser(userId) {
+    await this.ensureReady();
+    await this.query(`DELETE FROM ${this.tableName} WHERE user_id = ?`, [userId]);
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    await this.ensureReady();
+    if (userIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = userIds.map(() => "?").join(", ");
+    const result = await this.query(
+      `SELECT user_id, watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id IN (${placeholders})`,
+      userIds
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      out.set(row.user_id, {
+        watermark: normalizeWatermark2(row),
+        dismissedIds: normalizeDismissedIds3(row),
+        lastSeen: normalizeLastSeen2(row),
+        deviceCount: 1
+      });
+    }
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+  async ensureReady() {
+    if (this.initialized) return;
+    if (this.autoMigrate) {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          user_id VARCHAR(255) PRIMARY KEY,
+          watermark DATETIME(3) NULL,
+          dismissed_ids JSON NOT NULL,
+          last_seen DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+          created_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3),
+          updated_at DATETIME(3) NOT NULL DEFAULT CURRENT_TIMESTAMP(3) ON UPDATE CURRENT_TIMESTAMP(3)
+        )`
+      );
+      await this.query(
+        `CREATE INDEX idx_${this.tableName}_last_seen ON ${this.tableName}(last_seen)`
+      );
+    }
+    this.initialized = true;
+  }
+};
+
+// src/adapters/mongo.ts
+function normalizeDismissedIds4(ids) {
+  if (!Array.isArray(ids)) return [];
+  return ids.filter((id) => typeof id === "string");
+}
+function normalizeLastSeen3(value) {
+  return typeof value === "string" && value ? value : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var MongoAdapter = class {
+  userId;
+  collection;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("MongoAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.collection = options.collection;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.collection.updateOne(
+      { userId: this.userId },
+      {
+        $addToSet: { dismissedIds: id },
+        $set: { lastSeen: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      { upsert: true }
+    );
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.collection.updateOne(
+      { userId: this.userId },
+      {
+        $set: {
+          userId: this.userId,
+          watermark: this.watermark,
+          dismissedIds: [],
+          lastSeen: this.watermark
+        }
+      },
+      { upsert: true }
+    );
+  }
+  async sync() {
+    const doc = await this.collection.findOne({ userId: this.userId });
+    this.watermark = doc?.watermark ?? null;
+    this.dismissedIds = new Set(normalizeDismissedIds4(doc?.dismissedIds));
+  }
+  async dismissBatch(ids) {
+    const unique = Array.from(new Set(ids));
+    if (unique.length === 0) return;
+    this.dismissedIds = /* @__PURE__ */ new Set([...this.dismissedIds, ...unique]);
+    await this.collection.updateOne(
+      { userId: this.userId },
+      {
+        $addToSet: { dismissedIds: { $each: unique } },
+        $set: { lastSeen: (/* @__PURE__ */ new Date()).toISOString() }
+      },
+      { upsert: true }
+    );
+  }
+  async resetUser(userId) {
+    await this.collection.deleteOne({ userId });
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    const out = /* @__PURE__ */ new Map();
+    if (userIds.length === 0) return out;
+    if (this.collection.find) {
+      const rows = await this.collection.find({ userId: { $in: userIds } }).toArray();
+      for (const row of rows) {
+        out.set(row.userId, {
+          watermark: row.watermark ?? null,
+          dismissedIds: normalizeDismissedIds4(row.dismissedIds),
+          lastSeen: normalizeLastSeen3(row.lastSeen),
+          deviceCount: 1
+        });
+      }
+      return out;
+    }
+    await Promise.all(
+      userIds.map(async (userId) => {
+        const row = await this.collection.findOne({ userId });
+        if (!row) return;
+        out.set(userId, {
+          watermark: row.watermark ?? null,
+          dismissedIds: normalizeDismissedIds4(row.dismissedIds),
+          lastSeen: normalizeLastSeen3(row.lastSeen),
+          deviceCount: 1
+        });
+      })
+    );
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.collection.findOne({});
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+};
+
+// src/adapters/sqlite.ts
+function parseDismissedIds2(value) {
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string");
+  }
+  if (typeof value === "string" && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) {
+        return parsed.filter((item) => typeof item === "string");
+      }
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+function normalizeDismissedIds5(row) {
+  if (!row) return [];
+  return parseDismissedIds2(row.dismissed_ids ?? row.dismissedIds);
+}
+function normalizeWatermark3(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen4(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? row.lastSeen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+var SQLiteAdapter = class {
+  userId;
+  query;
+  tableName;
+  autoMigrate;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  initialized = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("SQLiteAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.query = options.query;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.autoMigrate = options.autoMigrate ?? true;
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.ensureReady();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(user_id)
+       DO UPDATE SET watermark = excluded.watermark, dismissed_ids = excluded.dismissed_ids, last_seen = excluded.last_seen, updated_at = excluded.updated_at`,
+      [this.userId, this.watermark, JSON.stringify([]), this.watermark, this.watermark, this.watermark]
+    );
+  }
+  async sync() {
+    await this.ensureReady();
+    const result = await this.query(
+      `SELECT watermark, dismissed_ids, last_seen FROM ${this.tableName} WHERE user_id = ? LIMIT 1`,
+      [this.userId]
+    );
+    const row = result.rows[0];
+    this.watermark = normalizeWatermark3(row);
+    this.dismissedIds = new Set(normalizeDismissedIds5(row));
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    await this.ensureReady();
+    const merged = /* @__PURE__ */ new Set([
+      ...Array.from(this.dismissedIds),
+      ...uniqueIds
+    ]);
+    const mergedArray = Array.from(merged);
+    this.dismissedIds = merged;
+    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+    await this.query(
+      `INSERT INTO ${this.tableName} (user_id, watermark, dismissed_ids, last_seen, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(user_id)
+       DO UPDATE SET dismissed_ids = excluded.dismissed_ids, last_seen = excluded.last_seen, updated_at = excluded.updated_at`,
+      [this.userId, this.watermark, JSON.stringify(mergedArray), nowIso, nowIso, nowIso]
+    );
+  }
+  async resetUser(userId) {
+    await this.ensureReady();
+    await this.query(`DELETE FROM ${this.tableName} WHERE user_id = ?`, [userId]);
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    await this.ensureReady();
+    if (userIds.length === 0) return /* @__PURE__ */ new Map();
+    const placeholders = userIds.map(() => "?").join(", ");
+    const result = await this.query(
+      `SELECT user_id, watermark, dismissed_ids, last_seen
+       FROM ${this.tableName}
+       WHERE user_id IN (${placeholders})`,
+      userIds
+    );
+    const out = /* @__PURE__ */ new Map();
+    for (const row of result.rows) {
+      out.set(row.user_id, {
+        watermark: normalizeWatermark3(row),
+        dismissedIds: normalizeDismissedIds5(row),
+        lastSeen: normalizeLastSeen4(row),
+        deviceCount: 1
+      });
+    }
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.query("SELECT 1");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+  }
+  async ensureReady() {
+    if (this.initialized) return;
+    if (this.autoMigrate) {
+      await this.query(
+        `CREATE TABLE IF NOT EXISTS ${this.tableName} (
+          user_id TEXT PRIMARY KEY,
+          watermark TEXT,
+          dismissed_ids TEXT NOT NULL,
+          last_seen TEXT NOT NULL,
+          created_at TEXT NOT NULL,
+          updated_at TEXT NOT NULL
+        )`
+      );
+      await this.query(
+        `CREATE INDEX IF NOT EXISTS idx_${this.tableName}_last_seen ON ${this.tableName}(last_seen)`
+      );
+    }
+    this.initialized = true;
+  }
+};
+
+// src/adapters/supabase.ts
+function normalizeDismissedIds6(row) {
+  if (!row || !Array.isArray(row.dismissed_ids)) return [];
+  return row.dismissed_ids.filter((id) => typeof id === "string");
+}
+function normalizeWatermark4(row) {
+  if (!row) return null;
+  return row.watermark ?? null;
+}
+function normalizeLastSeen5(row) {
+  if (!row) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return row.last_seen ?? (/* @__PURE__ */ new Date(0)).toISOString();
+}
+function throwOnError(error) {
+  if (!error) return;
+  throw new Error(`SupabaseAdapter: ${error.message ?? "unknown error"}`);
+}
+var SupabaseAdapter = class {
+  userId;
+  client;
+  tableName;
+  realtime;
+  watermark = null;
+  dismissedIds = /* @__PURE__ */ new Set();
+  realtimeChannel = null;
+  syncing = false;
+  constructor(options) {
+    if (!options.userId) {
+      throw new Error("SupabaseAdapter: userId is required");
+    }
+    this.userId = options.userId;
+    this.client = options.client;
+    this.tableName = options.tableName ?? "featuredrop_state";
+    this.realtime = options.realtime ?? false;
+    if (this.realtime && this.client.channel) {
+      this.setupRealtime();
+    }
+  }
+  getWatermark() {
+    return this.watermark;
+  }
+  getDismissedIds() {
+    return this.dismissedIds;
+  }
+  dismiss(id) {
+    this.dismissedIds.add(id);
+    void this.dismissBatch([id]);
+  }
+  async dismissAll(now) {
+    this.watermark = now.toISOString();
+    this.dismissedIds.clear();
+    await this.upsertState({
+      watermark: this.watermark,
+      dismissed_ids: [],
+      last_seen: this.watermark
+    });
+  }
+  async sync() {
+    if (this.syncing) return;
+    this.syncing = true;
+    try {
+      const row = await this.fetchState(this.userId);
+      this.watermark = normalizeWatermark4(row);
+      this.dismissedIds = new Set(normalizeDismissedIds6(row));
+    } finally {
+      this.syncing = false;
+    }
+  }
+  async dismissBatch(ids) {
+    const uniqueIds = Array.from(new Set(ids));
+    if (uniqueIds.length === 0) return;
+    const merged = /* @__PURE__ */ new Set([
+      ...Array.from(this.dismissedIds),
+      ...uniqueIds
+    ]);
+    this.dismissedIds = merged;
+    await this.upsertState({
+      watermark: this.watermark,
+      dismissed_ids: Array.from(merged),
+      last_seen: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  async resetUser(userId) {
+    const result = await this.client.from(this.tableName).delete().eq("user_id", userId);
+    throwOnError(result.error);
+    if (userId === this.userId) {
+      this.watermark = null;
+      this.dismissedIds.clear();
+    }
+  }
+  async getBulkState(userIds) {
+    const out = /* @__PURE__ */ new Map();
+    if (userIds.length === 0) return out;
+    await Promise.all(
+      userIds.map(async (userId) => {
+        const row = await this.fetchState(userId);
+        if (!row) return;
+        out.set(userId, {
+          watermark: normalizeWatermark4(row),
+          dismissedIds: normalizeDismissedIds6(row),
+          lastSeen: normalizeLastSeen5(row),
+          deviceCount: 1
+        });
+      })
+    );
+    return out;
+  }
+  async isHealthy() {
+    try {
+      await this.client.from(this.tableName).select("user_id").eq("user_id", this.userId).maybeSingle();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async destroy() {
+    if (this.realtimeChannel && this.client.removeChannel) {
+      await this.client.removeChannel(this.realtimeChannel);
+    }
+    this.realtimeChannel = null;
+  }
+  async fetchState(userId) {
+    const result = await this.client.from(this.tableName).select("user_id, watermark, dismissed_ids, last_seen").eq("user_id", userId).maybeSingle();
+    throwOnError(result.error);
+    return result.data;
+  }
+  async upsertState(state) {
+    const payload = {
+      user_id: this.userId,
+      watermark: state.watermark,
+      dismissed_ids: state.dismissed_ids,
+      last_seen: state.last_seen
+    };
+    const result = await this.client.from(this.tableName).upsert(payload);
+    throwOnError(result.error);
+  }
+  setupRealtime() {
+    const channelFactory = this.client.channel;
+    if (!channelFactory) return;
+    this.realtimeChannel = channelFactory(`featuredrop:${this.tableName}:${this.userId}`).on(
+      "postgres_changes",
+      {
+        event: "*",
+        schema: "public",
+        table: this.tableName,
+        filter: `user_id=eq.${this.userId}`
+      },
+      () => {
+        void this.sync();
+      }
+    ).subscribe();
+  }
+};
+
+export { HybridAdapter, IndexedDBAdapter, LocalStorageAdapter, MemoryAdapter, MongoAdapter, MySQLAdapter, PostgresAdapter, RedisAdapter, RemoteAdapter, SQLiteAdapter, SupabaseAdapter };
+//# sourceMappingURL=adapters.js.map
+//# sourceMappingURL=adapters.js.map