@revealui/cache 0.2.0 → 0.2.1

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { NextRequest, NextResponse } from 'next/server';
+import { C as CacheStore } from './types-CmU1eRbl.js';
+export { a as CacheEntry } from './types-CmU1eRbl.js';
 
 /**
  * CDN Configuration and Cache Management
@@ -158,14 +159,47 @@ declare function getCacheTTL(headers: Headers): number;
 /**
  * Edge Caching and ISR (Incremental Static Regeneration)
  *
- * Utilities for Next.js edge caching, ISR, and on-demand revalidation
+ * Framework-agnostic helpers for edge caching, ISR-style revalidation, edge
+ * rate limiting, geolocation, A/B testing, personalization, and CDN cache
+ * headers. Works in any runtime that exposes Web-standard `Request` /
+ * `Response` — NextRequest/NextResponse pass via structural typing, Hono's
+ * `c.req.raw` / `c.res` pass directly, Cloudflare Workers Request/Response
+ * pass directly, etc. The package no longer carries a `next` peer dep.
+ */
+/**
+ * Framework-agnostic request shape for edge-cache helpers — compatible with
+ * NextRequest, Hono `c.req.raw`, Cloudflare Workers Request, and any other
+ * Web-standard `Request` subclass that exposes a NextRequest-style `cookies`
+ * map. Narrowed to the read-only subset we actually consume.
+ *
+ * Consumers using a bare Web `Request` (no `cookies` field — e.g., plain
+ * `fetch` requests) must wrap it before calling helpers that read cookies
+ * (`getABTestVariant`, `getPersonalizationConfig`). Helpers that only read
+ * headers (`getGeoLocation`, `EdgeRateLimiter.check` with default key) work
+ * with bare `Request` directly via subtype compatibility.
+ */
+interface CacheRequest extends Request {
+    readonly cookies: {
+        get(name: string): {
+            readonly value: string;
+        } | undefined;
+    };
+}
+/**
+ * Framework-agnostic response shape for edge-cache helpers — compatible with
+ * NextResponse, Hono `c.res`, Cloudflare Workers Response, and any other
+ * Web-standard `Response` subclass. Helpers in this file only consume the
+ * standard `headers.set()` surface.
  */
-
+type CacheResponse = Response;
 /**
- * Next.js extends the standard RequestInit with a `next` property
- * for ISR revalidation and cache tags.
+ * Framework-agnostic ISR-style fetch options. Extends Web-standard
+ * `RequestInit` with a `next` property that mirrors Next.js's ISR
+ * revalidation + cache-tag shape. Runtimes that don't honor the `next`
+ * field (anything outside Next.js) ignore it silently — the helper still
+ * works as a plain `fetch` wrapper.
  */
-interface NextFetchRequestInit extends RequestInit {
+interface CachedFetchRequestInit extends RequestInit {
     next?: {
         revalidate?: number | false;
         tags?: string[];
@@ -252,9 +286,11 @@ interface EdgeCacheConfig {
 /**
  * Create edge cached fetch
  */
-declare function createEdgeCachedFetch(config?: EdgeCacheConfig): <T>(url: string, options?: NextFetchRequestInit) => Promise<T>;
+declare function createEdgeCachedFetch(config?: EdgeCacheConfig): <T>(url: string, options?: CachedFetchRequestInit) => Promise<T>;
 /**
- * Unstable cache wrapper (Next.js 14+)
+ * Memoizing cache wrapper for any async function. TTL-based eviction.
+ * Framework-agnostic — does NOT use Next.js's `unstable_cache`; this is
+ * a plain in-memory wrapper that works in any runtime.
  */
 declare function createCachedFunction<TArgs extends unknown[], TReturn>(fn: (...args: TArgs) => Promise<TReturn>, options?: {
     tags?: string[];
@@ -266,7 +302,7 @@ declare function createCachedFunction<TArgs extends unknown[], TReturn>(fn: (...
 interface EdgeRateLimitConfig {
     limit: number;
     window: number;
-    key?: (request: NextRequest) => string;
+    key?: (request: CacheRequest) => string;
 }
 declare class EdgeRateLimiter {
     private config;
@@ -275,7 +311,7 @@ declare class EdgeRateLimiter {
     /**
      * Check rate limit
      */
-    check(request: NextRequest): {
+    check(request: CacheRequest): {
         allowed: boolean;
         limit: number;
         remaining: number;
@@ -296,11 +332,11 @@ interface GeoLocation {
     latitude?: number;
     longitude?: number;
 }
-declare function getGeoLocation(request: NextRequest): GeoLocation | null;
+declare function getGeoLocation(request: CacheRequest): GeoLocation | null;
 /**
  * Edge A/B testing with cache
  */
-declare function getABTestVariant(request: NextRequest, testName: string, variants: string[]): string;
+declare function getABTestVariant(request: CacheRequest, testName: string, variants: string[]): string;
 /**
  * Edge personalization cache
  */
@@ -311,25 +347,25 @@ interface PersonalizationConfig {
     device?: 'mobile' | 'tablet' | 'desktop';
     variant?: string;
 }
-declare function getPersonalizationConfig(request: NextRequest): PersonalizationConfig;
+declare function getPersonalizationConfig(request: CacheRequest): PersonalizationConfig;
 /**
  * Edge cache headers helper
  */
-declare function setEdgeCacheHeaders(response: NextResponse, config: {
+declare function setEdgeCacheHeaders(response: CacheResponse, config: {
     maxAge?: number;
     sMaxAge?: number;
     staleWhileRevalidate?: number;
     tags?: string[];
-}): NextResponse;
+}): CacheResponse;
 /**
  * Preload links for critical resources
  */
-declare function addPreloadLinks(response: NextResponse, resources: Array<{
+declare function addPreloadLinks(response: CacheResponse, resources: Array<{
     href: string;
     as: string;
     type?: string;
     crossorigin?: boolean;
-}>): NextResponse;
+}>): CacheResponse;
 /**
  * Cache warming for ISR pages
  */
@@ -342,6 +378,86 @@ declare function warmISRCache(paths: string[], baseURL?: string): Promise<{
     }>;
 }>;
 
+/**
+ * Cache Invalidation Channel
+ *
+ * Coordinates cache invalidation across instances using a shared database table.
+ * Events are written to `_cache_invalidation_events` and consumed by polling.
+ *
+ * Architecture:
+ *   - Publisher: writes invalidation event to shared PGlite/PostgreSQL table
+ *   - Subscriber: polls the table for new events and forwards to local CacheStore
+ *   - Events auto-expire after TTL to prevent unbounded table growth
+ *
+ * Future: Replace polling with ElectricSQL shape subscriptions or LISTEN/NOTIFY
+ * for real-time push-based invalidation (Phase 5.10C/E).
+ */
+
+type InvalidationEventType = 'delete' | 'delete-prefix' | 'delete-tags' | 'clear';
+interface InvalidationEvent {
+    id: string;
+    type: InvalidationEventType;
+    /** Cache keys to delete (for 'delete' type). */
+    keys?: string[];
+    /** Prefix to match (for 'delete-prefix' type). */
+    prefix?: string;
+    /** Tags to match (for 'delete-tags' type). */
+    tags?: string[];
+    /** Instance ID that published the event (for deduplication). */
+    sourceInstance: string;
+    /** Timestamp when the event was created. */
+    createdAt: number;
+}
+interface InvalidationChannelOptions {
+    /** Unique instance identifier (used to skip self-published events). */
+    instanceId: string;
+    /** Poll interval in milliseconds (default: 5000). */
+    pollIntervalMs?: number;
+    /** Event TTL in seconds  -  events older than this are pruned (default: 60). */
+    eventTtlSeconds?: number;
+}
+interface PGliteInstance {
+    exec(query: string): Promise<unknown>;
+    query<T = Record<string, unknown>>(query: string, params?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    close(): Promise<void>;
+}
+declare class CacheInvalidationChannel {
+    private db;
+    private store;
+    private instanceId;
+    private pollIntervalMs;
+    private eventTtlSeconds;
+    private lastSeenTimestamp;
+    /** IDs processed at exactly lastSeenTimestamp (prevents re-processing on >= query). */
+    private processedAtBoundary;
+    private pollTimer;
+    private ready;
+    constructor(db: PGliteInstance, store: CacheStore, options: InvalidationChannelOptions);
+    private init;
+    /** Start polling for invalidation events. */
+    start(): Promise<void>;
+    /** Stop polling. */
+    stop(): void;
+    /** Publish a key deletion event. */
+    publishDelete(...keys: string[]): Promise<void>;
+    /** Publish a prefix deletion event. */
+    publishDeletePrefix(prefix: string): Promise<void>;
+    /** Publish a tag-based deletion event. */
+    publishDeleteTags(tags: string[]): Promise<void>;
+    /** Publish a clear-all event. */
+    publishClear(): Promise<void>;
+    private publish;
+    /** Poll for new events and apply them to the local cache store. */
+    poll(): Promise<number>;
+    private applyEvent;
+    /** Remove events older than the TTL. */
+    private prune;
+    /** Release resources. */
+    close(): Promise<void>;
+}
+
 /**
  * Internal logger for @revealui/cache.
  *
@@ -363,4 +479,4 @@ declare function configureCacheLogger(logger: CacheLogger): void;
  */
 declare function getCacheLogger(): CacheLogger;
 
-export { type CDNCacheConfig, type CDNPurgeConfig, CDN_CACHE_PRESETS, type CacheLogger, DEFAULT_CDN_CONFIG, type EdgeCacheConfig, type EdgeRateLimitConfig, EdgeRateLimiter, type GeoLocation, type ISRConfig, ISR_PRESETS, type PersonalizationConfig, 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 };
+export { type CDNCacheConfig, type CDNPurgeConfig, CDN_CACHE_PRESETS, CacheInvalidationChannel, type CacheLogger, type CacheRequest, type CacheResponse, CacheStore, DEFAULT_CDN_CONFIG, type EdgeCacheConfig, type EdgeRateLimitConfig, EdgeRateLimiter, type GeoLocation, type ISRConfig, ISR_PRESETS, type InvalidationChannelOptions, type InvalidationEvent, type InvalidationEventType, type PersonalizationConfig, 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 };

package/dist/index.js

@@ -120,7 +120,6 @@ async function purgeCloudflare(urls, config) {
       {
         method: "POST",
         headers: {
-          // biome-ignore lint/style/useNamingConvention: HTTP header convention
           Authorization: `Bearer ${apiKey}`,
           "Content-Type": "application/json"
         },
@@ -150,7 +149,6 @@ async function purgeVercel(urls, config) {
     const response = await fetch("https://api.vercel.com/v1/purge", {
       method: "POST",
       headers: {
-        // biome-ignore lint/style/useNamingConvention: HTTP header convention
         Authorization: `Bearer ${apiKey}`,
         "Content-Type": "application/json"
       },
@@ -212,7 +210,6 @@ async function purgeCacheByTag(tags, config) {
         {
           method: "POST",
           headers: {
-            // biome-ignore lint/style/useNamingConvention: HTTP header convention
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json"
           },
@@ -247,7 +244,6 @@ async function purgeAllCache(config) {
         {
           method: "POST",
           headers: {
-            // biome-ignore lint/style/useNamingConvention: HTTP header convention
             Authorization: `Bearer ${apiKey}`,
             "Content-Type": "application/json"
           },
@@ -347,13 +343,21 @@ function shouldCacheResponse(status, headers) {
 }
 function getCacheTTL(headers) {
   const cacheControl = headers.get("cache-control") || "";
-  const sMaxAgeMatch = cacheControl.match(/s-maxage=(\d+)/);
-  if (sMaxAgeMatch?.[1]) {
-    return parseInt(sMaxAgeMatch[1], 10);
+  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;
+    }
   }
-  const maxAgeMatch = cacheControl.match(/max-age=(\d+)/);
-  if (maxAgeMatch?.[1]) {
-    return parseInt(maxAgeMatch[1], 10);
+  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) {
@@ -364,6 +368,9 @@ function getCacheTTL(headers) {
   return 0;
 }
 
+// src/edge-cache.ts
+import { getClientIp } from "@revealui/security";
+
 // src/logger.ts
 var cacheLogger = console;
 function configureCacheLogger(logger) {
@@ -560,12 +567,13 @@ var EdgeRateLimiter = class {
   constructor(config) {
     this.config = 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 key = this.config.key ? this.config.key(request) : getClientIp(request);
     const now = Date.now();
     let entry = this.cache.get(key);
     if (!entry || now > entry.resetTime) {
@@ -626,7 +634,7 @@ function getABTestVariant(request, testName, variants) {
   if (cookieVariant && variants.includes(cookieVariant)) {
     return cookieVariant;
   }
-  const ip = request.headers.get("x-forwarded-for") || "unknown";
+  const ip = getClientIp(request);
   const hash = simpleHash(ip + testName);
   const variantIndex = hash % variants.length;
   const variant = variants[variantIndex];
@@ -655,12 +663,10 @@ function getPersonalizationConfig(request) {
   };
 }
 function getDeviceType(userAgent) {
-  if (/mobile/i.test(userAgent) && !/tablet|ipad/i.test(userAgent)) {
-    return "mobile";
-  }
-  if (/tablet|ipad/i.test(userAgent)) {
-    return "tablet";
-  }
+  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) {
@@ -730,8 +736,168 @@ async function warmISRCache(paths, baseURL = process.env.NEXT_PUBLIC_URL || "htt
   }
   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,
@@ -761,4 +927,3 @@ export {
   warmCDNCache,
   warmISRCache
 };
-//# sourceMappingURL=index.js.map

package/dist/types-CmU1eRbl.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Cache Store Adapter Interface
+ *
+ * Unified interface for pluggable cache backends.
+ * Implementations: InMemoryCacheStore (Map), PGliteCacheStore (PostgreSQL-compatible).
+ */
+interface CacheEntry<T = unknown> {
+    key: string;
+    value: T;
+    expiresAt: number;
+    tags?: string[];
+}
+interface CacheStore {
+    /** Get a cached value by key. Returns null if missing or expired. */
+    get<T = unknown>(key: string): Promise<T | null>;
+    /** Set a value with TTL in seconds. Overwrites existing entries. */
+    set<T = unknown>(key: string, value: T, ttlSeconds: number, tags?: string[]): Promise<void>;
+    /** Delete one or more keys. Returns count of deleted entries. */
+    delete(...keys: string[]): Promise<number>;
+    /** Delete all entries whose key starts with the given prefix. */
+    deleteByPrefix(prefix: string): Promise<number>;
+    /** Delete all entries tagged with any of the given tags. */
+    deleteByTags(tags: string[]): Promise<number>;
+    /** Remove all entries from the store. */
+    clear(): Promise<void>;
+    /** Return approximate number of live (non-expired) entries. */
+    size(): Promise<number>;
+    /** Clean up expired entries. Called periodically or on demand. */
+    prune(): Promise<number>;
+    /** Tear down the store (close connections, free resources). */
+    close(): Promise<void>;
+}
+
+export type { CacheStore as C, CacheEntry as a };

package/package.json

@@ -1,23 +1,18 @@
 {
   "name": "@revealui/cache",
-  "version": "0.2.0",
-  "description": "Caching infrastructure for RevealUI - CDN config, edge cache, ISR presets, revalidation",
+  "version": "0.2.1",
+  "description": "Framework-agnostic CDN config, edge cache, ISR-style presets, and revalidation helpers. Compatible with NextRequest/NextResponse, Hono, and Cloudflare Workers via structural typing — no `next` peer dep.",
   "license": "MIT",
-  "dependencies": {},
+  "dependencies": {
+    "@revealui/security": "0.4.0"
+  },
   "devDependencies": {
-    "@types/node": "^25.3.0",
+    "@electric-sql/pglite": "^0.4.5",
+    "@types/node": "^25.6.0",
     "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18",
-    "dev": "0.0.1"
-  },
-  "peerDependencies": {
-    "next": "^14.0.0 || ^15.0.0 || ^16.0.0"
-  },
-  "peerDependenciesMeta": {
-    "next": {
-      "optional": true
-    }
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5",
+    "@revealui/dev": "0.1.0"
   },
   "engines": {
     "node": ">=24.13.0"
@@ -26,6 +21,10 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./adapters": {
+      "types": "./dist/adapters/index.d.ts",
+      "import": "./dist/adapters/index.js"
     }
   },
   "files": [
@@ -38,14 +37,32 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RevealUIStudio/revealui.git",
+    "directory": "packages/cache"
+  },
+  "homepage": "https://revealui.com",
+  "author": "RevealUI Studio <founder@revealui.com>",
+  "bugs": {
+    "url": "https://github.com/RevealUIStudio/revealui/issues"
+  },
+  "keywords": [
+    "revealui",
+    "cache",
+    "cdn",
+    "edge-cache",
+    "isr",
+    "revalidation"
+  ],
   "scripts": {
     "build": "tsup",
     "clean": "rm -rf dist",
     "dev": "tsup --watch",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
-    "test": "vitest run --passWithNoTests",
-    "test:coverage": "vitest run --coverage --coverage.reporter=json-summary --coverage.reporter=html --coverage.reporter=text --passWithNoTests",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage --coverage.reporter=json-summary --coverage.reporter=html --coverage.reporter=text",
     "test:watch": "vitest",
     "typecheck": "tsc --noEmit"
   }