@revealui/cache 0.2.0 → 0.2.2

package/LICENSE.commercial

@@ -1,112 +1,90 @@
-RevealUI Commercial License
-Version 1.0, February 2026
+RevealUI Studio — Commercial Licensing for Pro Packages
 
-Copyright (c) 2025-2026 RevealUI Studio (founder@revealui.com)
+This file is an explainer for the dual-license structure of this repository.
+It is NOT a standalone license document; the canonical license terms for
+each Pro package live in that package's own LICENSE file.
 
-TERMS AND CONDITIONS
+## Repository Licensing Overview
 
-1. DEFINITIONS
+Most of this repository (the OSS packages, apps, scripts, docs, and tooling)
+is licensed under the MIT License. See LICENSE in the repository root for
+those terms.
 
-"Software" means the RevealUI source code, documentation, and associated
-files contained in directories and packages designated as commercial,
-including but not limited to: packages/ai, packages/mcp, packages/editors,
-packages/services, packages/harnesses, and any directory named "ee" within
-the repository.
+A small number of "Pro" packages are licensed under the Functional Source
+License v1.1 with MIT Future License (FSL-1.1-MIT) instead of MIT. Those
+packages each carry their own LICENSE file containing the canonical FSL
+terms; this file documents which packages are covered and what FSL-1.1-MIT
+permits and restricts.
 
-"License Key" means a valid RevealUI license key obtained through an active
-paid subscription at https://revealui.com.
+## Pro Packages Covered
 
-"Licensee" means the individual or organization that holds a valid License
-Key through an active subscription.
+The following packages distributed in this repository are licensed under
+FSL-1.1-MIT, not MIT:
 
-"Production Use" means any use of the Software beyond local development and
-evaluation, including but not limited to: deploying the Software to serve
-end users, integrating the Software into a product or service, or using the
-Software in a revenue-generating capacity.
+- @revealui/ai          (see packages/ai/LICENSE)
+- @revealui/harnesses   (see packages/harnesses/LICENSE)
 
-2. GRANT OF RIGHTS
+Additional Pro packages may be added in future. The presence of a LICENSE
+file inside a package directory containing the FSL-1.1-MIT text is the
+authoritative signal that the package is governed by FSL terms rather than
+the root MIT LICENSE.
 
-Subject to the terms of this License and a valid License Key, the Licensee
-is granted a non-exclusive, non-transferable, revocable license to:
+## What FSL-1.1-MIT Permits
 
-  (a) Use the Software for internal development and Production Use.
-  (b) Modify the Software for internal use.
-  (c) Deploy the Software on infrastructure controlled by the Licensee.
+Source code for Pro packages is publicly available. You may:
 
-Enterprise License holders are additionally granted the right to:
+- Use the package internally for any purpose, including commercial use
+- Modify the package and distribute derivative works under the same terms
+- Inspect, audit, and debug the source
+- Depend on the package from your own software
 
-  (d) Deploy the Software in a self-hosted environment.
-  (e) Remove or replace RevealUI branding (white-label).
-  (f) Use the Software for multiple tenants within the Licensee's
-      organization or customer base.
+## What FSL-1.1-MIT Restricts
 
-3. RESTRICTIONS
+You may NOT make the functionality of a Pro package available to third
+parties as a service that competes with RevealUI Studio's commercial
+offerings. The full restriction text in each per-package LICENSE controls;
+in plain language, prohibited uses include:
 
-The Licensee SHALL NOT:
+- Hosting the package as part of a SaaS that primarily delivers the
+  package's functionality
+- Offering a service whose value derives entirely or primarily from the
+  package
+- Repackaging the functionality for redistribution as a competing service
 
-  (a) Provide the Software, or any portion of it, to third parties as a
-      hosted or managed service that competes with RevealUI.
-  (b) Redistribute, sublicense, sell, or otherwise transfer the Software
-      or any portion of it to third parties.
-  (c) Remove, alter, or circumvent the license key verification
-      functionality of the Software.
-  (d) Use the Software in Production without a valid License Key.
-  (e) Share, publish, or make the License Key available to unauthorized
-      parties.
+If you are unsure whether your intended use is restricted, contact
+founder@revealui.com before relying on the package.
 
-4. EVALUATION
+## Change Date and MIT Conversion
 
-The Software may be used for evaluation and local development purposes
-without a License Key. Evaluation use does not grant any rights to
-Production Use.
+Each Pro package's LICENSE file specifies a Change Date. On the earlier of
+that date or the fourth anniversary of the first publicly-available
+distribution of a specific version of the package under FSL, the package
+automatically converts to the MIT License (the "Change License"). After
+conversion, all FSL restrictions are removed for the version in question
+and going forward.
 
-5. SUBSCRIPTION AND PAYMENT
+This means every Pro package in this repository will eventually become MIT;
+FSL-1.1-MIT is a time-limited restriction, not a permanent one.
 
-This License is valid only during the term of an active paid subscription.
-Upon cancellation or expiration of the subscription:
+## Commercial Licensing Alternatives
 
-  (a) The License terminates automatically.
-  (b) A grace period of fourteen (14) days is provided for the Licensee
-      to transition away from Production Use.
-  (c) After the grace period, the Licensee must cease all Production Use
-      of the Software.
+If FSL-1.1-MIT terms do not fit your use case (for example, you are
+building a service that the FSL would prohibit, or you need contractual
+guarantees beyond what an open license provides), commercial licensing is
+available.
 
-6. INTELLECTUAL PROPERTY
+Contact: founder@revealui.com
 
-The Software is and remains the intellectual property of RevealUI Studio.
-This License does not grant any ownership rights. Contributions to
-commercial portions of the Software require a Contributor License Agreement.
+## Canonical FSL-1.1-MIT Text
 
-7. OPEN SOURCE COMPONENTS
+The Functional Source License v1.1 with MIT Future License is published at:
 
-This License applies only to files and directories designated as commercial.
-Files under the MIT License (as indicated in the root LICENSE file) are not
-subject to this commercial license and may be used freely under MIT terms.
+  https://fsl.software/FSL-1.1-MIT.template.md
 
-8. DISCLAIMER OF WARRANTY
+The full canonical text is reproduced verbatim in each Pro package's
+LICENSE file. If there is any conflict between this explainer and a
+per-package LICENSE file, the per-package LICENSE file controls.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+---
 
-9. LIMITATION OF LIABILITY
-
-IN NO EVENT SHALL REVEALUI STUDIO BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE, EXCEEDING THE AMOUNT PAID BY THE LICENSEE IN
-THE TWELVE (12) MONTHS PRECEDING THE CLAIM.
-
-10. GOVERNING LAW
-
-This License shall be governed by the laws of the State of California,
-United States of America, without regard to its conflict of law provisions.
-
-11. ENTIRE AGREEMENT
-
-This License constitutes the entire agreement between the parties with
-respect to the commercial portions of the Software and supersedes all
-prior agreements, understandings, and communications.
-
-For licensing inquiries: founder@revealui.com
-For pricing and subscriptions: https://revealui.com/pricing
+Copyright (c) 2025-2026 RevealUI Studio

package/README.md

@@ -0,0 +1,109 @@
+---
+title: "@revealui/cache"
+description: "Caching infrastructure for RevealUI applications. Provides CDN cache configuration, edge cache helpers, ISR presets, tag-based revalidation, and rate limiting at the edge."
+visibility: public
+status: verified
+audience: user
+---
+
+# @revealui/cache
+
+Caching infrastructure for RevealUI applications. Provides CDN cache configuration, edge cache helpers, ISR presets, tag-based revalidation, and rate limiting at the edge.
+
+## When to Use This
+
+- You need Cache-Control headers for CDN responses (Vercel, Cloudflare)
+- You want ISR presets for Next.js pages (static, dynamic, real-time)
+- You need tag-based cache invalidation when content changes
+- You want edge-level rate limiting or A/B test variant assignment
+- You need cache warming for static paths
+
+If you're caching in-memory data within a single request, use standard `Map` or LRU  -  this package is for HTTP-layer and CDN caching.
+
+## Installation
+
+```bash
+pnpm add @revealui/cache
+```
+
+No peer dependencies. ISR helpers use structural typing compatible with `NextRequest`/`NextResponse`, Hono, and Cloudflare Workers  -  no `next` package required.
+
+## API Reference
+
+### CDN Configuration
+
+| Export | Type | Purpose |
+|--------|------|---------|
+| `generateCacheControl` | Function | Build Cache-Control header string from config |
+| `getCacheTTL` | Function | Get TTL for a content type |
+| `CDN_CACHE_PRESETS` | Object | Pre-built configs (static, api, dynamic, immutable) |
+| `DEFAULT_CDN_CONFIG` | Object | Default CDN configuration |
+| `generateCacheTags` | Function | Generate cache tags for content-based invalidation |
+| `generateVercelCacheConfig` | Function | Vercel-specific cache headers |
+| `generateCloudflareConfig` | Function | Cloudflare-specific cache config |
+| `shouldCacheResponse` | Function | Determine if a response should be cached |
+
+### CDN Purge
+
+| Export | Type | Purpose |
+|--------|------|---------|
+| `purgeCDNCache` | Function | Purge CDN cache by URL patterns |
+| `purgeCacheByTag` | Function | Purge by cache tag (content-type based) |
+| `purgeAllCache` | Function | Full CDN cache purge |
+| `warmCDNCache` | Function | Pre-warm cache for a list of URLs |
+
+### Edge Cache & ISR
+
+| Export | Type | Purpose |
+|--------|------|---------|
+| `ISR_PRESETS` | Object | Next.js ISR configs (static: 1h, dynamic: 60s, realtime: 10s, immutable: 1y) |
+| `revalidatePath` | Function | Revalidate a single Next.js path |
+| `revalidatePaths` | Function | Batch path revalidation |
+| `revalidateTag` | Function | Revalidate by cache tag |
+| `revalidateTags` | Function | Batch tag revalidation |
+| `generateStaticParams` | Function | Helper for Next.js static generation |
+| `setEdgeCacheHeaders` | Function | Set edge-specific cache headers on response |
+| `createEdgeCachedFetch` | Function | Fetch wrapper with edge caching |
+| `createCachedFunction` | Function | Memoize an async function with TTL |
+| `warmISRCache` | Function | Pre-warm ISR cache for static paths |
+| `addPreloadLinks` | Function | Add `Link: <url>; rel=preload` headers |
+
+### Edge Utilities
+
+| Export | Type | Purpose |
+|--------|------|---------|
+| `EdgeRateLimiter` | Class | Token bucket rate limiter for edge functions |
+| `getGeoLocation` | Function | Extract geo data from edge request headers |
+| `getABTestVariant` | Function | Deterministic A/B test variant assignment |
+| `getPersonalizationConfig` | Function | Edge personalization based on geo/device |
+
+### Invalidation Channel
+
+| Export | Type | Purpose |
+|--------|------|---------|
+| `CacheInvalidationChannel` | Class | Distributed cache busting via pub/sub channel |
+
+### Configuration
+
+| Export | Type | Purpose |
+|--------|------|---------|
+| `configureCacheLogger` | Function | Set custom logger (defaults to console) |
+
+### Subpath Exports
+
+| Subpath | Contents |
+|---------|----------|
+| `@revealui/cache` | All cache utilities |
+| `@revealui/cache/adapters` | `CacheStore` interface + implementations (for custom backends) |
+
+## Design Principles
+
+- **Adaptive**: ISR presets scale from real-time (10s) to immutable (1y) based on content volatility
+- **Unified**: Cache tags follow the same taxonomy as CMS collections  -  invalidation is automatic
+- **Orthogonal**: Caching is a separate concern from content serving  -  swap CDN providers without changing business logic
+
+## Related Packages
+
+- `apps/server`  -  Applies cache headers to REST responses
+- `apps/marketing`  -  Uses ISR presets for marketing pages
+- `@revealui/core`  -  Triggers cache invalidation on content changes

package/dist/adapters/index.d.ts

@@ -0,0 +1,126 @@
+import { C as CacheStore } from '../types-CmU1eRbl.js';
+export { a as CacheEntry } from '../types-CmU1eRbl.js';
+
+/**
+ * Browser PGlite Cache Store
+ *
+ * Creates a PGlite WASM instance in the browser backed by IndexedDB,
+ * then wraps it with PGliteCacheStore for SQL-powered client-side caching.
+ *
+ * Benefits over localStorage:
+ * - SQL queries for filtering cached data
+ * - Tag-based and prefix-based invalidation
+ * - IndexedDB storage (much larger than localStorage's ~5MB)
+ * - Shared CacheStore interface with server-side cache
+ *
+ * Usage:
+ *   const cache = await createBrowserCache();
+ *   await cache.set('posts:123', postData, 3600, ['posts']);
+ *   const data = await cache.get('posts:123');
+ *   await cache.close(); // on unmount
+ */
+
+interface BrowserCacheOptions {
+    /** IndexedDB database name for persistence (default: 'revealui-cache') */
+    dbName?: string;
+}
+/**
+ * Create a browser-compatible PGlite cache store.
+ *
+ * Dynamically imports @electric-sql/pglite (WASM) to avoid bundling
+ * it in server builds. The PGlite instance uses IndexedDB for persistence
+ * so cached data survives page reloads.
+ */
+declare function createBrowserCache(options?: BrowserCacheOptions): Promise<CacheStore>;
+
+/**
+ * In-Memory Cache Store
+ *
+ * Map-backed cache store. Fast, zero-dependency, single-instance only.
+ * Use for development, testing, or when distributed state isn't needed.
+ */
+
+declare class InMemoryCacheStore implements CacheStore {
+    private store;
+    private maxEntries;
+    constructor(options?: {
+        maxEntries?: number;
+    });
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttlSeconds: number, tags?: string[]): Promise<void>;
+    delete(...keys: string[]): Promise<number>;
+    deleteByPrefix(prefix: string): Promise<number>;
+    deleteByTags(tags: string[]): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+    prune(): Promise<number>;
+    close(): Promise<void>;
+}
+
+/**
+ * PGlite Cache Store
+ *
+ * PostgreSQL-compatible cache store backed by PGlite (in-memory or file-based).
+ * Provides the same CacheStore interface as InMemoryCacheStore but uses SQL
+ * for persistence and querying  -  enabling distributed invalidation via
+ * ElectricSQL shape subscriptions in Phase 5.10C.
+ *
+ * Table schema is auto-created on first use (no external migrations needed).
+ */
+
+/** Minimal PGlite interface  -  avoids importing the full @electric-sql/pglite package. */
+interface PGliteInstance {
+    exec(query: string): Promise<unknown>;
+    query<T = Record<string, unknown>>(query: string, params?: unknown[]): Promise<{
+        rows: T[];
+    }>;
+    close(): Promise<void>;
+}
+interface PGliteCacheStoreOptions {
+    /** PGlite instance (caller owns lifecycle unless closeOnDestroy is true). */
+    db: PGliteInstance;
+    /** Table name prefix to avoid collisions (default: none). */
+    tablePrefix?: string;
+    /** Close the PGlite instance when close() is called (default: false). */
+    closeOnDestroy?: boolean;
+}
+declare class PGliteCacheStore implements CacheStore {
+    private db;
+    private ready;
+    private closeOnDestroy;
+    constructor(options: PGliteCacheStoreOptions);
+    private init;
+    get<T = unknown>(key: string): Promise<T | null>;
+    set<T = unknown>(key: string, value: T, ttlSeconds: number, tags?: string[]): Promise<void>;
+    delete(...keys: string[]): Promise<number>;
+    deleteByPrefix(prefix: string): Promise<number>;
+    deleteByTags(tags: string[]): Promise<number>;
+    clear(): Promise<void>;
+    size(): Promise<number>;
+    prune(): Promise<number>;
+    close(): Promise<void>;
+}
+
+interface UseBrowserCacheResult {
+    /** The PGlite-backed CacheStore instance. Null while initializing. */
+    cache: CacheStore | null;
+    /** Whether the cache is still being initialized. */
+    loading: boolean;
+    /** Initialization error, if any. */
+    error: Error | null;
+}
+/**
+ * Access the browser-side PGlite cache store.
+ *
+ * Returns a shared singleton CacheStore. Multiple components can
+ * use this hook without creating duplicate PGlite instances.
+ *
+ * Example:
+ *   const { cache, loading } = useBrowserCache();
+ *   if (!loading && cache) {
+ *     const data = await cache.get('posts:recent');
+ *   }
+ */
+declare function useBrowserCache(): UseBrowserCacheResult;
+
+export { CacheStore, InMemoryCacheStore, PGliteCacheStore, createBrowserCache, useBrowserCache };

package/dist/adapters/index.js

@@ -0,0 +1,144 @@
+import {
+  PGliteCacheStore,
+  createBrowserCache
+} from "../chunk-EPAGOXMX.js";
+
+// src/adapters/memory.ts
+var InMemoryCacheStore = class {
+  store = /* @__PURE__ */ new Map();
+  maxEntries;
+  constructor(options) {
+    this.maxEntries = options?.maxEntries ?? 1e4;
+  }
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    if (Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return JSON.parse(entry.value);
+  }
+  async set(key, value, ttlSeconds, tags) {
+    if (this.store.size >= this.maxEntries && !this.store.has(key)) {
+      const firstKey = this.store.keys().next().value;
+      if (firstKey !== void 0) {
+        this.store.delete(firstKey);
+      }
+    }
+    this.store.set(key, {
+      value: JSON.stringify(value),
+      expiresAt: Date.now() + ttlSeconds * 1e3,
+      tags: tags ?? []
+    });
+  }
+  async delete(...keys) {
+    let count = 0;
+    for (const key of keys) {
+      if (this.store.delete(key)) count++;
+    }
+    return count;
+  }
+  async deleteByPrefix(prefix) {
+    let count = 0;
+    for (const key of this.store.keys()) {
+      if (key.startsWith(prefix)) {
+        this.store.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async deleteByTags(tags) {
+    const tagSet = new Set(tags);
+    let count = 0;
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.tags.some((t) => tagSet.has(t))) {
+        this.store.delete(key);
+        count++;
+      }
+    }
+    return count;
+  }
+  async clear() {
+    this.store.clear();
+  }
+  async size() {
+    const now = Date.now();
+    let count = 0;
+    for (const entry of this.store.values()) {
+      if (entry.expiresAt > now) count++;
+    }
+    return count;
+  }
+  async prune() {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt <= now) {
+        this.store.delete(key);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+  async close() {
+    this.store.clear();
+  }
+};
+
+// src/adapters/use-browser-cache.ts
+import { useEffect, useRef, useState } from "react";
+var sharedCache = null;
+var initPromise = null;
+var refCount = 0;
+async function getOrCreateCache() {
+  if (sharedCache) return sharedCache;
+  if (initPromise) return initPromise;
+  initPromise = import("../browser-7BTPENLH.js").then(async (mod) => {
+    const cache = await mod.createBrowserCache();
+    sharedCache = cache;
+    return cache;
+  });
+  return initPromise;
+}
+function useBrowserCache() {
+  const [cache, setCache] = useState(sharedCache);
+  const [loading, setLoading] = useState(!sharedCache);
+  const [error, setError] = useState(null);
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    refCount++;
+    if (!sharedCache) {
+      getOrCreateCache().then((c) => {
+        if (mounted.current) {
+          setCache(c);
+          setLoading(false);
+        }
+      }).catch((err) => {
+        if (mounted.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+          setLoading(false);
+        }
+      });
+    }
+    return () => {
+      mounted.current = false;
+      refCount--;
+      if (refCount === 0 && sharedCache) {
+        sharedCache.close().catch(() => {
+        });
+        sharedCache = null;
+        initPromise = null;
+      }
+    };
+  }, []);
+  return { cache, loading, error };
+}
+export {
+  InMemoryCacheStore,
+  PGliteCacheStore,
+  createBrowserCache,
+  useBrowserCache
+};

package/dist/browser-7BTPENLH.js

@@ -0,0 +1,6 @@
+import {
+  createBrowserCache
+} from "./chunk-EPAGOXMX.js";
+export {
+  createBrowserCache
+};

package/dist/chunk-EPAGOXMX.js

@@ -0,0 +1,123 @@
+// src/adapters/pglite.ts
+var CREATE_TABLE_SQL = `
+  CREATE TABLE IF NOT EXISTS _cache_entries (
+    key       TEXT PRIMARY KEY,
+    value     TEXT NOT NULL,
+    expires_at BIGINT NOT NULL,
+    tags      TEXT[] NOT NULL DEFAULT '{}'
+  );
+  CREATE INDEX IF NOT EXISTS _cache_entries_expires_idx ON _cache_entries (expires_at);
+`;
+var PGliteCacheStore = class {
+  db;
+  ready;
+  closeOnDestroy;
+  constructor(options) {
+    this.db = options.db;
+    this.closeOnDestroy = options.closeOnDestroy ?? false;
+    this.ready = this.init();
+  }
+  async init() {
+    await this.db.exec(CREATE_TABLE_SQL);
+  }
+  async get(key) {
+    await this.ready;
+    const now = Date.now();
+    const result = await this.db.query(
+      "SELECT value FROM _cache_entries WHERE key = $1 AND expires_at > $2",
+      [key, now]
+    );
+    const row = result.rows[0];
+    if (!row) return null;
+    return JSON.parse(row.value);
+  }
+  async set(key, value, ttlSeconds, tags) {
+    await this.ready;
+    const expiresAt = Date.now() + ttlSeconds * 1e3;
+    const serialized = JSON.stringify(value);
+    const tagArray = tags ?? [];
+    await this.db.query(
+      `INSERT INTO _cache_entries (key, value, expires_at, tags)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (key) DO UPDATE
+       SET value = EXCLUDED.value, expires_at = EXCLUDED.expires_at, tags = EXCLUDED.tags`,
+      [key, serialized, expiresAt, tagArray]
+    );
+  }
+  async delete(...keys) {
+    await this.ready;
+    if (keys.length === 0) return 0;
+    const placeholders = keys.map((_, i) => `$${i + 1}`).join(", ");
+    const result = await this.db.query(
+      `WITH deleted AS (DELETE FROM _cache_entries WHERE key IN (${placeholders}) RETURNING 1)
+       SELECT count(*)::text AS count FROM deleted`,
+      keys
+    );
+    return Number.parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async deleteByPrefix(prefix) {
+    await this.ready;
+    const escaped = prefix.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_");
+    const result = await this.db.query(
+      `WITH deleted AS (DELETE FROM _cache_entries WHERE key LIKE $1 ESCAPE '\\' RETURNING 1)
+       SELECT count(*)::text AS count FROM deleted`,
+      [`${escaped}%`]
+    );
+    return Number.parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async deleteByTags(tags) {
+    await this.ready;
+    if (tags.length === 0) return 0;
+    const result = await this.db.query(
+      `WITH deleted AS (DELETE FROM _cache_entries WHERE tags && $1 RETURNING 1)
+       SELECT count(*)::text AS count FROM deleted`,
+      [tags]
+    );
+    return Number.parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async clear() {
+    await this.ready;
+    await this.db.exec("DELETE FROM _cache_entries");
+  }
+  async size() {
+    await this.ready;
+    const now = Date.now();
+    const result = await this.db.query(
+      "SELECT count(*)::text AS count FROM _cache_entries WHERE expires_at > $1",
+      [now]
+    );
+    return Number.parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async prune() {
+    await this.ready;
+    const now = Date.now();
+    const result = await this.db.query(
+      `WITH deleted AS (DELETE FROM _cache_entries WHERE expires_at <= $1 RETURNING 1)
+       SELECT count(*)::text AS count FROM deleted`,
+      [now]
+    );
+    return Number.parseInt(result.rows[0]?.count ?? "0", 10);
+  }
+  async close() {
+    if (this.closeOnDestroy) {
+      await this.db.close();
+    }
+  }
+};
+
+// src/adapters/browser.ts
+async function createBrowserCache(options) {
+  const dbName = options?.dbName ?? "revealui-cache";
+  const { PGlite } = await import("@electric-sql/pglite");
+  const db = new PGlite(`idb://${dbName}`);
+  await db.waitReady;
+  return new PGliteCacheStore({
+    db,
+    closeOnDestroy: true
+  });
+}
+
+export {
+  PGliteCacheStore,
+  createBrowserCache
+};