@revealui/cache 0.0.0-canary-20260409021642

package/dist/index.js

@@ -0,0 +1,926 @@
+// src/cdn-config.ts
+var DEFAULT_CDN_CONFIG = {
+  provider: "vercel",
+  ttl: 31536e3,
+  // 1 year for static assets
+  staleWhileRevalidate: 86400,
+  // 1 day
+  staleIfError: 604800,
+  // 1 week
+  bypassCache: false,
+  cacheKey: ["url", "headers.accept", "headers.accept-encoding"],
+  varyHeaders: ["Accept", "Accept-Encoding"]
+};
+function generateCacheControl(config) {
+  const directives = [];
+  if (config.noStore) {
+    directives.push("no-store");
+    return directives.join(", ");
+  }
+  if (config.noCache) {
+    directives.push("no-cache");
+    return directives.join(", ");
+  }
+  if (config.public) {
+    directives.push("public");
+  } else if (config.private) {
+    directives.push("private");
+  }
+  if (config.maxAge !== void 0) {
+    directives.push(`max-age=${config.maxAge}`);
+  }
+  if (config.sMaxAge !== void 0) {
+    directives.push(`s-maxage=${config.sMaxAge}`);
+  }
+  if (config.staleWhileRevalidate !== void 0) {
+    directives.push(`stale-while-revalidate=${config.staleWhileRevalidate}`);
+  }
+  if (config.staleIfError !== void 0) {
+    directives.push(`stale-if-error=${config.staleIfError}`);
+  }
+  if (config.immutable) {
+    directives.push("immutable");
+  }
+  return directives.join(", ");
+}
+var CDN_CACHE_PRESETS = {
+  // Static assets with hashed filenames (immutable)
+  immutable: {
+    maxAge: 31536e3,
+    // 1 year
+    sMaxAge: 31536e3,
+    public: true,
+    immutable: true
+  },
+  // Static assets (images, fonts)
+  static: {
+    maxAge: 2592e3,
+    // 30 days
+    sMaxAge: 31536e3,
+    // 1 year on CDN
+    staleWhileRevalidate: 86400,
+    // 1 day
+    public: true
+  },
+  // API responses (short-lived)
+  api: {
+    maxAge: 0,
+    sMaxAge: 60,
+    // 1 minute on CDN
+    staleWhileRevalidate: 30,
+    public: true
+  },
+  // HTML pages (dynamic)
+  page: {
+    maxAge: 0,
+    sMaxAge: 300,
+    // 5 minutes on CDN
+    staleWhileRevalidate: 60,
+    public: true
+  },
+  // User-specific data
+  private: {
+    maxAge: 300,
+    // 5 minutes
+    private: true,
+    staleWhileRevalidate: 60
+  },
+  // No caching
+  noCache: {
+    noStore: true
+  },
+  // Revalidate every request
+  revalidate: {
+    maxAge: 0,
+    sMaxAge: 0,
+    noCache: true
+  }
+};
+async function purgeCDNCache(urls, config) {
+  const { provider } = config;
+  switch (provider) {
+    case "cloudflare":
+      return purgeCloudflare(urls, config);
+    case "vercel":
+      return purgeVercel(urls, config);
+    case "fastly":
+      return purgeFastly(urls, config);
+    default:
+      throw new Error(`Unsupported CDN provider: ${provider}`);
+  }
+}
+async function purgeCloudflare(urls, config) {
+  const { apiKey, zoneId } = config;
+  if (!(apiKey && zoneId)) {
+    throw new Error("Cloudflare API key and zone ID required");
+  }
+  try {
+    const response = await fetch(
+      `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ files: urls })
+      }
+    );
+    const data = await response.json();
+    return {
+      success: data.success,
+      purged: urls.length,
+      errors: data.errors
+    };
+  } catch (error) {
+    return {
+      success: false,
+      purged: 0,
+      errors: [error instanceof Error ? error.message : "Unknown error"]
+    };
+  }
+}
+async function purgeVercel(urls, config) {
+  const { apiKey } = config;
+  if (!apiKey) {
+    throw new Error("Vercel API token required");
+  }
+  try {
+    const response = await fetch("https://api.vercel.com/v1/purge", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ urls })
+    });
+    const data = await response.json();
+    return {
+      success: response.ok,
+      purged: urls.length,
+      errors: data.error ? [data.error.message] : void 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      purged: 0,
+      errors: [error instanceof Error ? error.message : "Unknown error"]
+    };
+  }
+}
+async function purgeFastly(urls, config) {
+  const { apiKey } = config;
+  if (!apiKey) {
+    throw new Error("Fastly API key required");
+  }
+  try {
+    const results = await Promise.all(
+      urls.map(async (url) => {
+        const response = await fetch(url, {
+          method: "PURGE",
+          headers: {
+            "Fastly-Key": apiKey
+          }
+        });
+        return response.ok;
+      })
+    );
+    const purged = results.filter(Boolean).length;
+    return {
+      success: purged === urls.length,
+      purged
+    };
+  } catch (error) {
+    return {
+      success: false,
+      purged: 0,
+      errors: [error instanceof Error ? error.message : "Unknown error"]
+    };
+  }
+}
+async function purgeCacheByTag(tags, config) {
+  const { provider, apiKey, zoneId } = config;
+  if (provider === "cloudflare") {
+    if (!(apiKey && zoneId)) {
+      throw new Error("Cloudflare API key and zone ID required");
+    }
+    try {
+      const response = await fetch(
+        `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ tags })
+        }
+      );
+      const data = await response.json();
+      return {
+        success: data.success,
+        purged: tags.length,
+        errors: data.errors
+      };
+    } catch (error) {
+      return {
+        success: false,
+        purged: 0,
+        errors: [error instanceof Error ? error.message : "Unknown error"]
+      };
+    }
+  }
+  throw new Error(`Cache tag purging not supported for ${provider}`);
+}
+async function purgeAllCache(config) {
+  const { provider, apiKey, zoneId } = config;
+  if (provider === "cloudflare") {
+    if (!(apiKey && zoneId)) {
+      throw new Error("Cloudflare API key and zone ID required");
+    }
+    try {
+      const response = await fetch(
+        `https://api.cloudflare.com/client/v4/zones/${zoneId}/purge_cache`,
+        {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ purge_everything: true })
+        }
+      );
+      const data = await response.json();
+      return {
+        success: data.success,
+        errors: data.errors
+      };
+    } catch (error) {
+      return {
+        success: false,
+        errors: [error instanceof Error ? error.message : "Unknown error"]
+      };
+    }
+  }
+  throw new Error(`Purge all not supported for ${provider}`);
+}
+async function warmCDNCache(urls, options = {}) {
+  const { concurrency = 5, headers = {} } = options;
+  const results = [];
+  const chunks = [];
+  for (let i = 0; i < urls.length; i += concurrency) {
+    chunks.push(urls.slice(i, i + concurrency));
+  }
+  for (const chunk of chunks) {
+    const chunkResults = await Promise.all(
+      chunk.map(async (url) => {
+        try {
+          const response = await fetch(url, { headers });
+          return {
+            success: response.ok,
+            error: response.ok ? void 0 : `${response.status} ${response.statusText}`
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      })
+    );
+    results.push(...chunkResults);
+  }
+  const warmed = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+  const errors = results.flatMap((r) => r.error ? [r.error] : []);
+  return { warmed, failed, errors };
+}
+function generateCacheTags(resource) {
+  const tags = [];
+  tags.push(resource.type);
+  if (resource.id) {
+    tags.push(`${resource.type}:${resource.id}`);
+  }
+  if (resource.related) {
+    tags.push(...resource.related);
+  }
+  return tags;
+}
+function generateVercelCacheConfig(preset) {
+  const config = CDN_CACHE_PRESETS[preset];
+  const cacheControl = generateCacheControl(config);
+  return {
+    headers: {
+      "Cache-Control": cacheControl,
+      "CDN-Cache-Control": cacheControl,
+      "Vercel-CDN-Cache-Control": cacheControl
+    }
+  };
+}
+function generateCloudflareConfig(preset, options = {}) {
+  const config = CDN_CACHE_PRESETS[preset];
+  const cacheControl = generateCacheControl(config);
+  const headers = {
+    "Cache-Control": cacheControl
+  };
+  if (options.cacheTags && options.cacheTags.length > 0) {
+    headers["Cache-Tag"] = options.cacheTags.join(",");
+  }
+  if (options.bypassOnCookie) {
+    headers["Cache-Control"] = `${cacheControl}, bypass=${options.bypassOnCookie}`;
+  }
+  return { headers };
+}
+function shouldCacheResponse(status, headers) {
+  if (status >= 400) {
+    return false;
+  }
+  const cacheControl = headers.get("cache-control") || "";
+  if (cacheControl.includes("no-store") || cacheControl.includes("no-cache") || cacheControl.includes("private")) {
+    return false;
+  }
+  return true;
+}
+function getCacheTTL(headers) {
+  const cacheControl = headers.get("cache-control") || "";
+  for (const directive of cacheControl.split(",")) {
+    const trimmed = directive.trim();
+    if (trimmed.startsWith("s-maxage=")) {
+      const val = trimmed.slice("s-maxage=".length);
+      const num = Number.parseInt(val, 10);
+      if (!Number.isNaN(num)) return num;
+    }
+  }
+  for (const directive of cacheControl.split(",")) {
+    const trimmed = directive.trim();
+    if (trimmed.startsWith("max-age=")) {
+      const val = trimmed.slice("max-age=".length);
+      const num = Number.parseInt(val, 10);
+      if (!Number.isNaN(num)) return num;
+    }
+  }
+  const expires = headers.get("expires");
+  if (expires) {
+    const expiresDate = new Date(expires);
+    const now = /* @__PURE__ */ new Date();
+    return Math.max(0, Math.floor((expiresDate.getTime() - now.getTime()) / 1e3));
+  }
+  return 0;
+}
+
+// src/logger.ts
+var cacheLogger = console;
+function configureCacheLogger(logger) {
+  cacheLogger = logger;
+}
+function getCacheLogger() {
+  return cacheLogger;
+}
+
+// src/edge-cache.ts
+var ISR_PRESETS = {
+  // Revalidate every request
+  always: {
+    revalidate: 0
+  },
+  // Revalidate every minute
+  minute: {
+    revalidate: 60
+  },
+  // Revalidate every 5 minutes
+  fiveMinutes: {
+    revalidate: 300
+  },
+  // Revalidate every hour
+  hourly: {
+    revalidate: 3600
+  },
+  // Revalidate daily
+  daily: {
+    revalidate: 86400
+  },
+  // Never revalidate (static)
+  never: {
+    revalidate: false
+  }
+};
+async function generateStaticParams(fetchFn, mapFn) {
+  try {
+    const items = await fetchFn();
+    return items.map(mapFn);
+  } catch (error) {
+    getCacheLogger().error(
+      "Failed to generate static params",
+      error instanceof Error ? error : new Error(String(error))
+    );
+    return [];
+  }
+}
+async function revalidateTag(tag, secret) {
+  const baseUrl = process.env.NEXT_PUBLIC_URL;
+  if (!baseUrl) {
+    getCacheLogger().warn("revalidateTag skipped: NEXT_PUBLIC_URL is not configured", { tag });
+    return { revalidated: false, error: "NEXT_PUBLIC_URL is not configured" };
+  }
+  try {
+    const url = new URL("/api/revalidate", baseUrl);
+    const headers = { "Content-Type": "application/json" };
+    if (secret) {
+      headers["x-revalidate-secret"] = secret;
+    }
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ tag })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      getCacheLogger().warn("revalidateTag failed", {
+        tag,
+        status: response.status,
+        error: data.error
+      });
+    }
+    return {
+      revalidated: response.ok,
+      error: data.error
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    getCacheLogger().warn("revalidateTag error", { tag, error: message });
+    return {
+      revalidated: false,
+      error: message
+    };
+  }
+}
+async function revalidatePath(path, secret) {
+  const baseUrl = process.env.NEXT_PUBLIC_URL;
+  if (!baseUrl) {
+    getCacheLogger().warn("revalidatePath skipped: NEXT_PUBLIC_URL is not configured", { path });
+    return { revalidated: false, error: "NEXT_PUBLIC_URL is not configured" };
+  }
+  try {
+    const url = new URL("/api/revalidate", baseUrl);
+    const headers = { "Content-Type": "application/json" };
+    if (secret) {
+      headers["x-revalidate-secret"] = secret;
+    }
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ path })
+    });
+    const data = await response.json();
+    return {
+      revalidated: response.ok,
+      error: data.error
+    };
+  } catch (error) {
+    return {
+      revalidated: false,
+      error: error instanceof Error ? error.message : "Unknown error"
+    };
+  }
+}
+async function revalidatePaths(paths, secret) {
+  const results = await Promise.allSettled(paths.map((path) => revalidatePath(path, secret)));
+  let revalidated = 0;
+  let failed = 0;
+  const errors = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const path = paths[i];
+    if (!(result && path)) {
+      continue;
+    }
+    if (result.status === "fulfilled" && result.value.revalidated) {
+      revalidated++;
+    } else {
+      failed++;
+      const error = result.status === "fulfilled" ? result.value.error || "Unknown error" : String(result.reason) || "Unknown error";
+      errors.push({ path, error });
+    }
+  }
+  return { revalidated, failed, errors };
+}
+async function revalidateTags(tags, secret) {
+  const results = await Promise.allSettled(tags.map((tag) => revalidateTag(tag, secret)));
+  let revalidated = 0;
+  let failed = 0;
+  const errors = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const tag = tags[i];
+    if (!(result && tag)) {
+      continue;
+    }
+    if (result.status === "fulfilled" && result.value.revalidated) {
+      revalidated++;
+    } else {
+      failed++;
+      const error = result.status === "fulfilled" ? result.value.error || "Unknown error" : String(result.reason) || "Unknown error";
+      errors.push({ tag, error });
+    }
+  }
+  return { revalidated, failed, errors };
+}
+function createEdgeCachedFetch(config = {}) {
+  return async (url, options) => {
+    const fetchOptions = {
+      ...options,
+      ...config,
+      next: {
+        ...options?.next,
+        ...config.next
+      }
+    };
+    const response = await fetch(url, fetchOptions);
+    if (!response.ok) {
+      throw new Error(`Fetch failed: ${response.statusText}`);
+    }
+    return response.json();
+  };
+}
+function createCachedFunction(fn, options = {}) {
+  if (options.revalidate === false) {
+    return fn;
+  }
+  const ttlMs = (options.revalidate ?? 60) * 1e3;
+  const cache = /* @__PURE__ */ new Map();
+  return async (...args) => {
+    const key = JSON.stringify(args);
+    const now = Date.now();
+    const cached = cache.get(key);
+    if (cached && now < cached.expiresAt) {
+      return cached.value;
+    }
+    const value = await fn(...args);
+    cache.set(key, { value, expiresAt: now + ttlMs });
+    return value;
+  };
+}
+var EdgeRateLimiter = class {
+  constructor(config) {
+    this.config = config;
+  }
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Check rate limit
+   */
+  check(request) {
+    const key = this.config.key ? this.config.key(request) : request.headers.get("x-forwarded-for") || "unknown";
+    const now = Date.now();
+    let entry = this.cache.get(key);
+    if (!entry || now > entry.resetTime) {
+      entry = {
+        count: 0,
+        resetTime: now + this.config.window
+      };
+      this.cache.set(key, entry);
+    }
+    entry.count++;
+    const allowed = entry.count <= this.config.limit;
+    const remaining = Math.max(0, this.config.limit - entry.count);
+    return {
+      allowed,
+      limit: this.config.limit,
+      remaining,
+      reset: entry.resetTime
+    };
+  }
+  /**
+   * Clean up expired entries
+   */
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.resetTime) {
+        this.cache.delete(key);
+      }
+    }
+  }
+};
+function getGeoLocation(request) {
+  const country = request.headers.get("x-vercel-ip-country");
+  const region = request.headers.get("x-vercel-ip-country-region");
+  const city = request.headers.get("x-vercel-ip-city");
+  const latitude = request.headers.get("x-vercel-ip-latitude");
+  const longitude = request.headers.get("x-vercel-ip-longitude");
+  if (!country) {
+    const cfCountry = request.headers.get("cf-ipcountry");
+    if (cfCountry) {
+      return {
+        country: cfCountry
+      };
+    }
+    return null;
+  }
+  return {
+    country: country || void 0,
+    region: region || void 0,
+    city: city ? decodeURIComponent(city) : void 0,
+    latitude: latitude ? parseFloat(latitude) : void 0,
+    longitude: longitude ? parseFloat(longitude) : void 0
+  };
+}
+function getABTestVariant(request, testName, variants) {
+  const cookieName = `ab-test-${testName}`;
+  const cookieVariant = request.cookies.get(cookieName)?.value;
+  if (cookieVariant && variants.includes(cookieVariant)) {
+    return cookieVariant;
+  }
+  const ip = request.headers.get("x-forwarded-for") || "unknown";
+  const hash = simpleHash(ip + testName);
+  const variantIndex = hash % variants.length;
+  const variant = variants[variantIndex];
+  if (!variant) {
+    throw new Error("No variant found for A/B test");
+  }
+  return variant;
+}
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function getPersonalizationConfig(request) {
+  const userAgent = request.headers.get("user-agent") || "";
+  const device = getDeviceType(userAgent);
+  const location = getGeoLocation(request);
+  return {
+    userId: request.cookies.get("user-id")?.value,
+    location: location || void 0,
+    device
+  };
+}
+function getDeviceType(userAgent) {
+  const ua = userAgent.toLowerCase();
+  const isTablet = ua.includes("tablet") || ua.includes("ipad");
+  if (isTablet) return "tablet";
+  if (ua.includes("mobile")) return "mobile";
+  return "desktop";
+}
+function setEdgeCacheHeaders(response, config) {
+  const cacheControl = [];
+  if (config.maxAge !== void 0) {
+    cacheControl.push(`max-age=${config.maxAge}`);
+  }
+  if (config.sMaxAge !== void 0) {
+    cacheControl.push(`s-maxage=${config.sMaxAge}`);
+  }
+  if (config.staleWhileRevalidate !== void 0) {
+    cacheControl.push(`stale-while-revalidate=${config.staleWhileRevalidate}`);
+  }
+  if (cacheControl.length > 0) {
+    response.headers.set("Cache-Control", cacheControl.join(", "));
+  }
+  if (config.tags && config.tags.length > 0) {
+    response.headers.set("Cache-Tag", config.tags.join(","));
+  }
+  return response;
+}
+function addPreloadLinks(response, resources) {
+  const links = resources.map((resource) => {
+    const attrs = [`<${resource.href}>`, `rel="preload"`, `as="${resource.as}"`];
+    if (resource.type) {
+      attrs.push(`type="${resource.type}"`);
+    }
+    if (resource.crossorigin) {
+      attrs.push("crossorigin");
+    }
+    return attrs.join("; ");
+  });
+  if (links.length > 0) {
+    response.headers.set("Link", links.join(", "));
+  }
+  return response;
+}
+async function warmISRCache(paths, baseURL = process.env.NEXT_PUBLIC_URL || "http://localhost:3000") {
+  const results = await Promise.allSettled(
+    paths.map(async (path) => {
+      const url = new URL(path, baseURL);
+      const response = await fetch(url.toString());
+      if (!response.ok) {
+        throw new Error(`${response.status} ${response.statusText}`);
+      }
+      return true;
+    })
+  );
+  let warmed = 0;
+  let failed = 0;
+  const errors = [];
+  for (let i = 0; i < results.length; i++) {
+    const result = results[i];
+    const path = paths[i];
+    if (!(result && path)) {
+      continue;
+    }
+    if (result.status === "fulfilled") {
+      warmed++;
+    } else {
+      failed++;
+      errors.push({
+        path,
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason) || "Unknown error"
+      });
+    }
+  }
+  return { warmed, failed, errors };
+}
+
+// src/invalidation-channel.ts
+var CREATE_EVENTS_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS _cache_invalidation_events (
+    id               TEXT PRIMARY KEY,
+    type             TEXT NOT NULL,
+    keys             TEXT[],
+    prefix           TEXT,
+    tags             TEXT[],
+    source_instance  TEXT NOT NULL,
+    created_at       BIGINT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS _cache_inv_created_idx ON _cache_invalidation_events (created_at);
+`;
+var CacheInvalidationChannel = class {
+  db;
+  store;
+  instanceId;
+  pollIntervalMs;
+  eventTtlSeconds;
+  lastSeenTimestamp;
+  /** IDs processed at exactly lastSeenTimestamp (prevents re-processing on >= query). */
+  processedAtBoundary = /* @__PURE__ */ new Set();
+  pollTimer = null;
+  ready;
+  constructor(db, store, options) {
+    this.db = db;
+    this.store = store;
+    this.instanceId = options.instanceId;
+    this.pollIntervalMs = options.pollIntervalMs ?? 5e3;
+    this.eventTtlSeconds = options.eventTtlSeconds ?? 60;
+    this.lastSeenTimestamp = Date.now() - 1;
+    this.ready = this.init();
+  }
+  async init() {
+    await this.db.exec(CREATE_EVENTS_TABLE_SQL);
+  }
+  /** Start polling for invalidation events. */
+  async start() {
+    await this.ready;
+    if (this.pollTimer) return;
+    this.pollTimer = setInterval(() => {
+      void this.poll();
+    }, this.pollIntervalMs);
+    if (this.pollTimer.unref) this.pollTimer.unref();
+  }
+  /** Stop polling. */
+  stop() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+  // ─── Publishing ─────────────────────────────────────────────────────
+  /** Publish a key deletion event. */
+  async publishDelete(...keys) {
+    await this.publish({ type: "delete", keys });
+  }
+  /** Publish a prefix deletion event. */
+  async publishDeletePrefix(prefix) {
+    await this.publish({ type: "delete-prefix", prefix });
+  }
+  /** Publish a tag-based deletion event. */
+  async publishDeleteTags(tags) {
+    await this.publish({ type: "delete-tags", tags });
+  }
+  /** Publish a clear-all event. */
+  async publishClear() {
+    await this.publish({ type: "clear" });
+  }
+  async publish(event) {
+    await this.ready;
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    await this.db.query(
+      `INSERT INTO _cache_invalidation_events (id, type, keys, prefix, tags, source_instance, created_at)
+       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+      [
+        id,
+        event.type,
+        event.keys ?? null,
+        event.prefix ?? null,
+        event.tags ?? null,
+        this.instanceId,
+        now
+      ]
+    );
+  }
+  // ─── Polling ────────────────────────────────────────────────────────
+  /** Poll for new events and apply them to the local cache store. */
+  async poll() {
+    await this.ready;
+    const logger = getCacheLogger();
+    const result = await this.db.query(
+      `SELECT id, type, keys, prefix, tags, source_instance, created_at
+       FROM _cache_invalidation_events
+       WHERE created_at >= $1 AND source_instance != $2
+       ORDER BY created_at ASC`,
+      [this.lastSeenTimestamp, this.instanceId]
+    );
+    let applied = 0;
+    for (const row of result.rows) {
+      if (this.processedAtBoundary.has(row.id)) continue;
+      const createdAt = Number(row.created_at);
+      if (createdAt > this.lastSeenTimestamp) {
+        this.lastSeenTimestamp = createdAt;
+        this.processedAtBoundary.clear();
+      }
+      this.processedAtBoundary.add(row.id);
+      try {
+        await this.applyEvent(row.type, row);
+        applied++;
+      } catch (error) {
+        logger.error(
+          "Failed to apply invalidation event",
+          error instanceof Error ? error : new Error(String(error))
+        );
+      }
+    }
+    await this.prune();
+    return applied;
+  }
+  async applyEvent(type, row) {
+    switch (type) {
+      case "delete":
+        if (row.keys && row.keys.length > 0) {
+          await this.store.delete(...row.keys);
+        }
+        break;
+      case "delete-prefix":
+        if (row.prefix) {
+          await this.store.deleteByPrefix(row.prefix);
+        }
+        break;
+      case "delete-tags":
+        if (row.tags && row.tags.length > 0) {
+          await this.store.deleteByTags(row.tags);
+        }
+        break;
+      case "clear":
+        await this.store.clear();
+        break;
+    }
+  }
+  /** Remove events older than the TTL. */
+  async prune() {
+    const cutoff = Date.now() - this.eventTtlSeconds * 1e3;
+    const result = await this.db.query(
+      `WITH deleted AS (DELETE FROM _cache_invalidation_events WHERE created_at < $1 RETURNING 1)
+       SELECT count(*)::text AS count FROM deleted`,
+      [cutoff]
+    );
+    return Number.parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  /** Release resources. */
+  async close() {
+    this.stop();
+  }
+};
+export {
+  CDN_CACHE_PRESETS,
+  CacheInvalidationChannel,
+  DEFAULT_CDN_CONFIG,
+  EdgeRateLimiter,
+  ISR_PRESETS,
+  addPreloadLinks,
+  configureCacheLogger,
+  createCachedFunction,
+  createEdgeCachedFetch,
+  generateCacheControl,
+  generateCacheTags,
+  generateCloudflareConfig,
+  generateStaticParams,
+  generateVercelCacheConfig,
+  getABTestVariant,
+  getCacheLogger,
+  getCacheTTL,
+  getGeoLocation,
+  getPersonalizationConfig,
+  purgeAllCache,
+  purgeCDNCache,
+  purgeCacheByTag,
+  revalidatePath,
+  revalidatePaths,
+  revalidateTag,
+  revalidateTags,
+  setEdgeCacheHeaders,
+  shouldCacheResponse,
+  warmCDNCache,
+  warmISRCache
+};
+//# sourceMappingURL=index.js.map