@wenathlan/saddle 1.8.17 → 2.0.2

package/docs/plans/24.research.memory.persistence.md

@@ -1,1979 +0,0 @@
-# Pesquisa: Memory e Persistence Patterns (2026)
-
-> Padrões de armazenamento em memória, browser storage, server storage, edge KV, request deduplication, e persistência de estado para scraping.
-
----
-
-## 1. In-Memory Storage
-
-### 1.1. Map (nativo)
-
-```typescript
-// Map simples — bom para uso básico
-const cache = new Map<string, unknown>();
-
-cache.set('key', { data: 'value' });
-cache.get('key');        // { data: 'value' }
-cache.has('key');        // true
-cache.delete('key');     // true
-cache.size;              // 0
-
-// Iterar
-for (const [key, value] of cache) {
-  console.log(key, value);
-}
-
-// Limitação: sem TTL, sem maxSize, sem cleanup automático
-```
-
-### 1.2. WeakMap (metadata, sem memory leak)
-
-```typescript
-// WeakMap — keys devem ser objects, garbage collected automaticamente
-const metadata = new WeakMap<object, {
-  scrapedAt: Date;
-  accessCount: number;
-  lastAccess: Date;
-}>();
-
-const pageData = { html: '<p>content</p>' };
-metadata.set(pageData, {
-  scrapedAt: new Date(),
-  accessCount: 0,
-  lastAccess: new Date(),
-});
-
-// Quando pageData for GC'd, o metadata entry também é removido
-// Ideal para: metadata associada a objects que podem ser liberados
-```
-
-### 1.3. lru-cache v11 (bounded, TTL, fetchMethod)
-
-```typescript
-import { LRUCache } from 'lru-cache';
-
-// Cache com limite de tamanho e TTL
-const cache = new LRUCache<string, unknown>({
-  max: 500,                    // Máximo 500 entries
-  ttl: 1000 * 60 * 5,         // TTL: 5 minutos
-  updateAgeOnGet: true,        // Reset TTL ao acessar
-  updateAgeOnHas: true,        // Reset TTL ao verificar
-
-  // fetchMethod: busca automática com cache
-  fetchMethod: async (key: string) => {
-    const response = await fetch(`https://api.example.com/data/${key}`);
-    return response.json();
-  },
-});
-
-// Uso com fetchMethod — busca e cacheia automaticamente
-const data = await cache.fetch('my-key');
-// Segunda vez: retorna do cache (sem fetch)
-
-// Operações básicas
-cache.set('key', 'value', { ttl: 1000 * 60 });  // TTL customizado
-cache.get('key');                                  // 'value'
-cache.has('key');                                  // true
-cache.delete('key');                               // true
-cache.clear();                                     // Limpa tudo
-
-// Estatísticas
-cache.size;                                        // Entries atuais
-cache.calculatedSize;                              // Tamanho estimado em bytes
-cache.dump();                                      // Serializar todo o cache
-cache.load(dumped);                                // Restaurar cache
-
-// Iterator
-for (const [key, value] of cache.entries()) {
-  console.log(key, value);
-}
-
-// Cleanup periódico
-const interval = setInterval(() => {
-  cache.purgeStale();  // Remove entries expiradas
-}, 60_000);
-```
-
-**Exemplo: Cache de scraping com lru-cache**
-
-```typescript
-interface ScrapeCacheEntry {
-  html: string;
-  markdown: string;
-  metadata: Record<string, unknown>;
-  scrapedAt: number;
-}
-
-const scrapeCache = new LRUCache<string, ScrapeCacheEntry>({
-  max: 1000,
-  ttl: 1000 * 60 * 30,  // 30 minutos
-  updateAgeOnGet: true,
-  fetchMethod: async (url: string) => {
-    console.log(`Fetching: ${url}`);
-    const result = await scrape(url);
-    return {
-      html: result.content,
-      markdown: result.text,
-      metadata: result.metadata,
-      scrapedAt: Date.now(),
-    };
-  },
-});
-
-// Transparent cache — busca se não existe
-const cached = await scrapeCache.fetch('https://example.com');
-// Segunda vez: retorna do cache instantaneamente
-```
-
-### 1.4. @keyv/bigmap (20M+ entries)
-
-```typescript
-import { KeyvBigMap } from '@keyv/bigmap';
-
-// Para caches enormes — suporta 20M+ entries
-const bigCache = new KeyvBigMap({
-  maxSize: 50_000_000,  // 50M entries
-  ttl: 1000 * 60 * 60, // 1 hora
-});
-
-await bigCache.set('key-1', { data: 'large payload' });
-const value = await bigCache.get('key-1');
-
-// Mais eficiente que Map para grandes volumes
-// Usa WeakRef para memória eficiente
-```
-
----
-
-## 2. Browser Storage
-
-### 2.1. localStorage (5-10MB, síncrono)
-
-```typescript
-// Limite: 5-10MB por origin
-// Síncrono: bloqueia a thread principal
-// Sem TTL nativo
-
-interface StoredItem<T> {
-  value: T;
-  timestamp: number;
-  expires?: number;
-}
-
-class LocalStorageAdapter<T = unknown> {
-  private prefix: string;
-
-  constructor(prefix = 'ws_') {
-    this.prefix = prefix;
-  }
-
-  set(key: string, value: T, ttlMs?: number): void {
-    const item: StoredItem<T> = {
-      value,
-      timestamp: Date.now(),
-      expires: ttlMs ? Date.now() + ttlMs : undefined,
-    };
-    localStorage.setItem(this.prefix + key, JSON.stringify(item));
-  }
-
-  get(key: string): T | null {
-    const raw = localStorage.getItem(this.prefix + key);
-    if (!raw) return null;
-
-    try {
-      const item: StoredItem<T> = JSON.parse(raw);
-      if (item.expires && Date.now() > item.expires) {
-        this.delete(key);
-        return null;
-      }
-      return item.value;
-    } catch {
-      this.delete(key);
-      return null;
-    }
-  }
-
-  has(key: string): boolean {
-    return this.get(key) !== null;
-  }
-
-  delete(key: string): void {
-    localStorage.removeItem(this.prefix + key);
-  }
-
-  clear(): void {
-    const keys = Object.keys(localStorage)
-      .filter(k => k.startsWith(this.prefix));
-    keys.forEach(k => localStorage.removeItem(k));
-  }
-
-  get size(): number {
-    let count = 0;
-    for (let i = 0; i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (key?.startsWith(this.prefix)) count++;
-    }
-    return count;
-  }
-}
-```
-
-### 2.2. sessionStorage (tab-scoped)
-
-```typescript
-// Mesmo API que localStorage, mas:
-// - Dados persistem só durante a sessão da tab
-// - Tab != Window (abrir link em nova tab = novo sessionStorage)
-// - Útil para: estado temporário de uma sessão de scraping
-
-const session = new LocalStorageAdapter('session_');
-// Mesmo adapter, diferente prefix e lifecycle
-```
-
-### 2.3. IndexedDB (async, large)
-
-```typescript
-// Async, grande capacidade (GBs), estruturado
-// Não bloqueia a thread principal
-
-interface IDBConfig {
-  dbName: string;
-  version?: number;
-  storeName: string;
-}
-
-class IndexedDBAdapter<T = unknown> {
-  private db: IDBDatabase | null = null;
-  private config: IDBConfig;
-
-  constructor(config: IDBConfig) {
-    this.config = { version: 1, ...config };
-  }
-
-  async init(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(
-        this.config.dbName,
-        this.config.version
-      );
-
-      request.onupgradeneeded = (event) => {
-        const db = (event.target as IDBOpenDBRequest).result;
-        if (!db.objectStoreNames.contains(this.config.storeName)) {
-          db.createObjectStore(this.config.storeName, { keyPath: 'id' });
-        }
-      };
-
-      request.onsuccess = (event) => {
-        this.db = (event.target as IDBOpenDBRequest).result;
-        resolve();
-      };
-
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async set(key: string, value: T): Promise<void> {
-    if (!this.db) throw new Error('DB not initialized');
-
-    return new Promise((resolve, reject) => {
-      const tx = this.db!.transaction(this.config.storeName, 'readwrite');
-      const store = tx.objectStore(this.config.storeName);
-      const request = store.put({ id: key, value, timestamp: Date.now() });
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async get(key: string): Promise<T | null> {
-    if (!this.db) throw new Error('DB not initialized');
-
-    return new Promise((resolve, reject) => {
-      const tx = this.db!.transaction(this.config.storeName, 'readonly');
-      const store = tx.objectStore(this.config.storeName);
-      const request = store.get(key);
-
-      request.onsuccess = () => {
-        const result = request.result;
-        resolve(result?.value ?? null);
-      };
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async delete(key: string): Promise<void> {
-    if (!this.db) throw new Error('DB not initialized');
-
-    return new Promise((resolve, reject) => {
-      const tx = this.db!.transaction(this.config.storeName, 'readwrite');
-      const store = tx.objectStore(this.config.storeName);
-      const request = store.delete(key);
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async getAll(): Promise<Map<string, T>> {
-    if (!this.db) throw new Error('DB not initialized');
-
-    return new Promise((resolve, reject) => {
-      const tx = this.db!.transaction(this.config.storeName, 'readonly');
-      const store = tx.objectStore(this.config.storeName);
-      const request = store.openCursor();
-
-      const map = new Map<string, T>();
-
-      request.onsuccess = () => {
-        const cursor = request.result;
-        if (cursor) {
-          map.set(cursor.key as string, cursor.value.value);
-          cursor.continue();
-        } else {
-          resolve(map);
-        }
-      };
-      request.onerror = () => reject(request.error);
-    });
-  }
-}
-```
-
-### 2.4. store2 2.14.3 (wrapper cross-browser)
-
-```typescript
-import store from 'store2';
-
-// Abstração unificada sobre localStorage/sessionStorage/IndexedDB
-store.namespace('webscrape_');  // Prefix automático
-
-store.set('key', { data: 'value' });       // Auto-JSON
-store.get('key');                           // { data: 'value' }
-store.has('key');                           // true
-store.remove('key');                        // true
-
-// TTL manual (store2 não tem nativo)
-store.set('key', 'value', { expire: 3600 });  // Não funciona nativamente
-
-// Área de session (sessionStorage)
-store.session.set('key', 'value');
-store.session.get('key');
-
-// Área de area (IndexedDB)
-store.area.set('key', 'value');
-store.area.get('key');
-
-// Limits
-store.set('key', 'value', false);  // Não pode ser sobrescrito
-store.has('key');                    // true
-// store.set('key', 'other');       // Silenciosamente falha
-
-// Callbacks
-store.on('set', (key: string, value: unknown) => {
-  console.log(`Stored: ${key}`);
-});
-
-// Serialização customizada
-store.defaults({
-  serialize: JSON.stringify,
-  deserialize: JSON.parse,
-});
-```
-
----
-
-## 3. Server Storage
-
-### 3.1. better-sqlite3 (síncrono, rápido)
-
-```typescript
-import Database from 'better-sqlite3';
-
-const db = new Database(':memory:');  // Ou './data.db'
-
-// Criar tabela
-db.exec(`
-  CREATE TABLE IF NOT EXISTS cache (
-    key TEXT PRIMARY KEY,
-    value TEXT NOT NULL,
-    created_at INTEGER DEFAULT (unixepoch()),
-    expires_at INTEGER,
-    access_count INTEGER DEFAULT 0
-  )
-`);
-
-// Inserir
-const insert = db.prepare(
-  'INSERT OR REPLACE INTO cache (key, value, expires_at) VALUES (?, ?, ?)'
-);
-insert.run('url:https://example.com', JSON.stringify({ html: '...' }), Date.now() + 300_000);
-
-// Buscar com TTL check
-const find = db.prepare(
-  'SELECT value FROM cache WHERE key = ? AND (expires_at IS NULL OR expires_at > ?)'
-);
-const row = find.get('url:https://example.com', Date.now()) as { value: string } | undefined;
-const data = row ? JSON.parse(row.value) : null;
-
-// Batch operations (transação)
-const insertMany = db.transaction((entries: [string, string, number][]) => {
-  for (const [key, value, expires] of entries) {
-    insert.run(key, value, expires);
-  }
-});
-
-insertMany([
-  ['url:https://a.com', '{"html":"..."}', Date.now() + 300_000],
-  ['url:https://b.com', '{"html":"..."}', Date.now() + 300_000],
-]);
-
-// Cleanup de entries expiradas
-const cleanup = db.prepare(
-  'DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at < ?'
-);
-cleanup.run(Date.now());
-
-// Estatísticas
-const count = db.prepare('SELECT COUNT(*) as count FROM cache').get();
-console.log(`Cache size: ${count.count}`);
-```
-
-### 3.2. @keyv/sqlite
-
-```typescript
-import Keyv from 'keyv';
-import KeyvSqlite from '@keyv/sqlite';
-
-const keyv = new Keyv({
-  store: new KeyvSqlite({
-    uri: 'sqlite://./data.sqlite',
-    busyTimeout: 5000,
-  }),
-  ttl: 1000 * 60 * 30,  // 30 minutos
-});
-
-await keyv.set('key', { data: 'value' });
-await keyv.get('key');     // { data: 'value' }
-await keyv.has('key');     // true
-await keyv.delete('key');  // true
-
-// Iterator
-for await (const [key, value] of keyv.iterator()) {
-  console.log(key, value);
-}
-
-// Namespace
-const keyvA = new Keyv({ namespace: 'a' });
-const keyvB = new Keyv({ namespace: 'b' });
-// keyvA e keyvB são independentes
-```
-
-### 3.3. @keyv/redis / ioredis
-
-```typescript
-import Keyv from 'keyv';
-import KeyvRedis from '@keyv/redis';
-
-// Keyv com Redis adapter
-const keyv = new Keyv({
-  store: new KeyvRedis('redis://localhost:6379'),
-  ttl: 1000 * 60 * 60,  // 1 hora
-});
-
-await keyv.set('session:abc', { userId: 123, role: 'admin' });
-await keyv.get('session:abc');
-
-// ioredis direto (mais controle)
-import Redis from 'ioredis';
-
-const redis = new Redis({
-  host: 'localhost',
-  port: 6379,
-  maxRetriesPerRequest: 3,
-  retryStrategy(times) {
-    return Math.min(times * 50, 2000);
-  },
-});
-
-// Comandos básicos
-await redis.set('key', JSON.stringify({ data: 'value' }), 'EX', 300);  // TTL 5min
-const value = JSON.parse((await redis.get('key')) ?? 'null');
-await redis.del('key');
-
-// Pipeline (batch)
-const pipeline = redis.pipeline();
-pipeline.set('key1', 'value1', 'EX', 60);
-pipeline.set('key2', 'value2', 'EX', 60);
-pipeline.get('key1');
-const results = await pipeline.exec();
-
-// Pub/Sub para invalidation
-const subscriber = new Redis('redis://localhost:6379');
-const publisher = new Redis('redis://localhost:6379');
-
-subscriber.subscribe('cache:invalidate');
-subscriber.on('message', (channel, key) => {
-  if (channel === 'cache:invalidate') {
-    console.log(`Invalidating: ${key}`);
-  }
-});
-
-publisher.publish('cache:invalidate', 'url:https://example.com');
-```
-
----
-
-## 4. Cross-Runtime KV: keyv 5.6.0
-
-### Por que keyv?
-
-- **104M+ weekly downloads** — padrão de facto
-- **Pluggable adapters** — in-memory, SQLite, Redis, PostgreSQL, MongoDB
-- **TTL nativo** — suporte a expiração
-- **Iterator** — percorre todas as entries
-- **Namespace** — multi-tenant no mesmo store
-- **Universal** — funciona em Node, Deno, Bun, browsers
-
-```typescript
-import Keyv from 'keyv';
-
-// Store padrão (in-memory com Map)
-const keyv = new Keyv();
-await keyv.set('key', 'value', 5000);  // TTL 5s
-await keyv.get('key');  // 'value'
-
-// Com adapter Redis
-import KeyvRedis from '@keyv/redis';
-const redisKeyv = new Keyv({ store: new KeyvRedis('redis://localhost') });
-
-// Com adapter SQLite
-import KeyvSqlite from '@keyv/sqlite';
-const sqliteKeyv = new Keyv({ store: new KeyvSqlite('sqlite://data.db') });
-
-// Namespace
-const sessions = new Keyv({ namespace: 'sessions' });
-const cache = new Keyv({ namespace: 'cache' });
-
-// Multiple namespaces no mesmo Redis
-const keyvA = new Keyv({ store: new KeyvRedis('redis://localhost'), namespace: 'a' });
-const keyvB = new Keyv({ store: new KeyvRedis('redis://localhost'), namespace: 'b' });
-```
-
-### keyv patterns para scraping
-
-```typescript
-// Pattern 1: Request cache
-const requestCache = new Keyv({
-  namespace: 'requests',
-  ttl: 1000 * 60 * 10,  // 10 minutos
-});
-
-async function cachedFetch(url: string): Promise<Response> {
-  const cached = await requestCache.get(url);
-  if (cached) return new Response(cached.body, cached);
-
-  const response = await fetch(url);
-  if (response.ok) {
-    const clone = response.clone();
-    const body = await clone.text();
-    await requestCache.set(url, {
-      body,
-      status: response.status,
-      headers: Object.fromEntries(response.headers.entries()),
-    });
-  }
-
-  return response;
-}
-
-// Pattern 2: Rate limiting
-const rateLimiter = new Keyv({
-  namespace: 'ratelimit',
-  ttl: 1000 * 60,  // 1 minuto window
-});
-
-async function isRateLimited(domain: string, maxRequests = 10): Promise<boolean> {
-  const count = (await rateLimiter.get(domain)) ?? 0;
-  if (count >= maxRequests) return true;
-  await rateLimiter.set(domain, count + 1);
-  return false;
-}
-
-// Pattern 3: Deduplicação
-const dedup = new Keyv({
-  namespace: 'dedup',
-  ttl: 1000 * 60 * 60,  // 1 hora
-});
-
-async function isDuplicate(content: string): Promise<boolean> {
-  const hash = await contentHash(content);
-  if (await dedup.has(hash)) return true;
-  await dedup.set(hash, true);
-  return false;
-}
-```
-
----
-
-## 5. Edge Runtime Storage
-
-### 5.1. Cloudflare Workers KV
-
-```typescript
-// Cloudflare Workers KV
-// API global em workers, TTL mínimo 60s
-
-export default {
-  async fetch(request: Request, env: Env): Promise<Response> {
-    const url = new URL(request.url);
-    const key = url.pathname.slice(1);
-
-    if (request.method === 'GET') {
-      const value = await env.KV.get(key, 'json');
-      if (!value) return new Response('Not found', { status: 404 });
-      return Response.json(value);
-    }
-
-    if (request.method === 'PUT') {
-      const body = await request.json();
-      await env.KV.put(key, JSON.stringify(body), {
-        expirationTtl: 3600,  // 1 hora (mínimo 60s)
-      });
-      return new Response('OK');
-    }
-
-    return new Response('Method not allowed', { status: 405);
-  },
-};
-
-// Interface
-interface Env {
-  KV: KVNamespace;
-}
-
-// Batch operations
-async function batchGet(keys: string[], env: Env): Promise<Map<string, unknown>> {
-  const results = new Map<string, unknown>();
-
-  // KV não tem batch get nativo — fazer parallel
-  await Promise.all(keys.map(async (key) => {
-    const value = await env.KV.get(key, 'json');
-    if (value) results.set(key, value);
-  }));
-
-  return results;
-}
-
-// List with prefix
-async function listByPrefix(prefix: string, env: Env): Promise<string[]> {
-  const list = await env.KV.list({ prefix });
-  return list.keys.map(k => k.name);
-}
-```
-
-### 5.2. Upstash Redis
-
-```typescript
-import { Redis } from '@upstash/redis';
-
-const redis = new Redis({
-  url: process.env.UPSTASH_REDIS_REST_URL!,
-  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
-});
-
-// Operações básicas
-await redis.set('key', { data: 'value' }, { ex: 300 });  // TTL 5min
-await redis.get('key');
-await redis.del('key');
-
-// Rate limiting
-async function upstashRateLimit(
-  key: string,
-  limit: number,
-  windowSec: number
-): Promise<{ allowed: boolean; remaining: number }> {
-  const now = Date.now();
-  const windowStart = now - windowSec * 1000;
-
-  const pipeline = redis.pipeline();
-  pipeline.zremrangebyscore(key, 0, windowStart);
-  pipeline.zadd(key, { score: now, member: now.toString() });
-  pipeline.zcard(key);
-  pipeline.expire(key, windowSec);
-
-  const results = await pipeline.exec();
-  const count = results[2] as number;
-
-  return {
-    allowed: count <= limit,
-    remaining: Math.max(0, limit - count),
-  };
-}
-
-// Caching com TTL
-async function cached<T>(
-  key: string,
-  fn: () => Promise<T>,
-  ttlSec = 300
-): Promise<T> {
-  const cached = await redis.get<T>(key);
-  if (cached) return cached;
-
-  const value = await fn();
-  await redis.set(key, JSON.stringify(value), { ex: ttlSec });
-  return value;
-}
-```
-
-### 5.3. Deno KV
-
-```typescript
-// Deno KV — built-in no Deno 2.x
-const kv = await Deno.openKv();
-
-// Operações básicas
-await kv.set(['cache', 'url', 'https://example.com'], { html: '...' }, {
-  expireIn: 1000 * 60 * 30,  // 30 minutos
-});
-
-const entry = await kv.get(['cache', 'url', 'https://example.com']);
-if (entry.value) {
-  console.log(entry.value);
-}
-
-// Delete
-await kv.delete(['cache', 'url', 'https://example.com']);
-
-// List com prefix
-const entries = await kv.list({ prefix: ['cache', 'url'] });
-for await (const entry of entries) {
-  console.log(entry.key, entry.value);
-}
-
-// Atomic operations
-const res = await kv.atomic()
-  .check({ key: ['counter'], versionstamp: null })
-  .sum(['counter'], 1n)
-  .commit();
-
-if (!res.ok) {
-  console.log('Atomic operation failed');
-}
-
-// Transactions
-async function atomicCacheUpdate(
-  key: string[],
-  value: unknown,
-  ttl: number
-): Promise<boolean> {
-  const result = await kv.atomic()
-    .set(key, value, { expireIn: ttl })
-    .commit();
-  return result.ok;
-}
-```
-
----
-
-## 6. Request Deduplication
-
-### 6.1. Keyv com TTL
-
-```typescript
-import Keyv from 'keyv';
-
-const dedupStore = new Keyv({
-  namespace: 'request-dedup',
-  ttl: 1000 * 60 * 5,  // 5 minutos
-});
-
-async function deduplicatedFetch(url: string): Promise<Response> {
-  const key = `req:${url}`;
-
-  // Verificar se já está em andamento
-  if (await dedupStore.has(key)) {
-    // Retornar do cache ou aguardar
-    return cachedResponse(url);
-  }
-
-  // Marcar como em andamento
-  await dedupStore.set(key, { status: 'pending', started: Date.now() });
-
-  try {
-    const response = await fetch(url);
-    const body = await response.text();
-
-    // Cache a resposta
-    await dedupStore.set(key, {
-      status: 'done',
-      body,
-      status_code: response.status,
-      headers: Object.fromEntries(response.headers.entries()),
-    });
-
-    return new Response(body, {
-      status: response.status,
-      headers: response.headers,
-    });
-  } catch (error) {
-    await dedupStore.delete(key);
-    throw error;
-  }
-}
-```
-
-### 6.2. Bloom Filter
-
-```typescript
-// Bloom filter — probabilidade controlada de falsos positivos
-// Não tem falsos negativos — eficiente em memória
-
-class BloomFilter {
-  private bits: Uint8Array;
-  private size: number;
-  private hashes: number;
-
-  constructor(expectedItems: number, falsePositiveRate = 0.01) {
-    // Calcular tamanho ótimo
-    this.size = Math.ceil(
-      -(expectedItems * Math.log(falsePositiveRate)) / (Math.log(2) ** 2)
-    );
-    this.hashes = Math.ceil((this.size / expectedItems) * Math.log(2));
-    this.bits = new Uint8Array(Math.ceil(this.size / 8));
-  }
-
-  private hash(value: string, seed: number): number {
-    let hash = 0;
-    for (let i = 0; i < value.length; i++) {
-      hash = ((hash << 5) - hash + value.charCodeAt(i) + seed) | 0;
-    }
-    return Math.abs(hash) % this.size;
-  }
-
-  add(value: string): void {
-    for (let i = 0; i < this.hashes; i++) {
-      const pos = this.hash(value, i);
-      this.bits[Math.floor(pos / 8)] |= 1 << (pos % 8);
-    }
-  }
-
-  mightContain(value: string): boolean {
-    for (let i = 0; i < this.hashes; i++) {
-      const pos = this.hash(value, i);
-      if (!(this.bits[Math.floor(pos / 8)] & (1 << (pos % 8)))) {
-        return false;
-      }
-    }
-    return true;
-  }
-
-  // Serializar para armazenamento
-  serialize(): Uint8Array {
-    return this.bits;
-  }
-
-  // Restaurar de armazenamento
-  static deserialize(data: Uint8Array, size: number, hashes: number): BloomFilter {
-    const filter = new BloomFilter(1);
-    filter.bits = data;
-    filter.size = size;
-    filter.hashes = hashes;
-    return filter;
-  }
-}
-
-// Uso
-const urlsSeen = new BloomFilter(100_000);  // 100K URLs, 1% FPR
-
-async function shouldScrape(url: string): Promise<boolean> {
-  if (urlsSeen.mightContain(url)) {
-    console.log(`Probably seen: ${url}`);
-    return false;  // Pode ser falso positivo
-  }
-  urlsSeen.add(url);
-  return true;
-}
-```
-
-### 6.3. ETag Conditional Requests
-
-```typescript
-interface ETagCache {
-  get(url: string): Promise<{ etag: string; lastModified: string } | null>;
-  set(url: string, etag: string, lastModified: string): Promise<void>;
-}
-
-async function conditionalFetch(
-  url: string,
-  cache: ETagCache
-): Promise<{ data: string; fromCache: boolean }> {
-  const cached = await cache.get(url);
-
-  const headers: Record<string, string> = {};
-  if (cached?.etag) headers['If-None-Match'] = cached.etag;
-  if (cached?.lastModified) headers['If-Modified-Since'] = cached.lastModified;
-
-  const response = await fetch(url, { headers });
-
-  if (response.status === 304) {
-    // Não modificado — usar cache
-    return { data: '', fromCache: true };
-  }
-
-  // Atualizar cache
-  const etag = response.headers.get('etag');
-  const lastModified = response.headers.get('last-modified');
-  if (etag) await cache.set(url, etag, lastModified ?? '');
-
-  const data = await response.text();
-  return { data, fromCache: false };
-}
-
-// Implementação com Keyv
-class KeyvETagCache implements ETagCache {
-  private store: Keyv;
-
-  constructor() {
-    this.store = new Keyv({ namespace: 'etag', ttl: 1000 * 60 * 60 * 24 });
-  }
-
-  async get(url: string) {
-    return this.store.get(url) ?? null;
-  }
-
-  async set(url: string, etag: string, lastModified: string) {
-    await this.store.set(url, { etag, lastModified });
-  }
-}
-```
-
----
-
-## 7. Persistindo Estado
-
-### 7.1. Cookies
-
-```typescript
-// Cookies — persists across requests, limited to ~4KB
-
-// Definir cookie
-document.cookie = 'session=abc123; path=/; max-age=3600; SameSite=Lax; Secure';
-
-// Ler cookie
-function getCookie(name: string): string | null {
-  const match = document.cookie.match(new RegExp(`(?:^|; )${name}=([^;]*)`));
-  return match ? decodeURIComponent(match[1]) : null;
-}
-
-// Server-side (Set-Cookie header)
-// res.setHeader('Set-Cookie', 'session=abc123; Path=/; Max-Age=3600; HttpOnly; Secure');
-
-// Em fetch (não funciona cross-origin por padrão)
-await fetch(url, {
-  credentials: 'include',  // Enviar cookies
-});
-```
-
-### 7.2. Auth Tokens
-
-```typescript
-interface AuthState {
-  accessToken: string;
-  refreshToken: string;
-  expiresAt: number;
-}
-
-class AuthManager {
-  private storage: Keyv<AuthState>;
-
-  constructor() {
-    this.storage = new Keyv({ namespace: 'auth', ttl: 1000 * 60 * 60 * 24 });
-  }
-
-  async saveTokens(url: string, tokens: AuthState): Promise<void> {
-    await this.storage.set(this.key(url), tokens);
-  }
-
-  async getValidToken(url: string): Promise<string | null> {
-    const tokens = await this.storage.get(this.key(url));
-    if (!tokens) return null;
-
-    // Verificar se expirou
-    if (Date.now() > tokens.expiresAt) {
-      // Tentar refresh
-      const refreshed = await this.refresh(tokens.refreshToken);
-      if (refreshed) {
-        await this.saveTokens(url, refreshed);
-        return refreshed.accessToken;
-      }
-      await this.storage.delete(this.key(url));
-      return null;
-    }
-
-    return tokens.accessToken;
-  }
-
-  private key(url: string): string {
-    return new URL(url).origin;
-  }
-
-  private async refresh(refreshToken: string): Promise<AuthState | null> {
-    try {
-      const response = await fetch('/auth/refresh', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ refreshToken }),
-      });
-      return response.json();
-    } catch {
-      return null;
-    }
-  }
-}
-```
-
-### 7.3. Browser Fingerprints
-
-```typescript
-interface BrowserFingerprint {
-  canvas: string;
-  webgl: string;
-  audio: string;
-  fonts: string[];
-  screen: { width: number; height: number; colorDepth: number };
-  timezone: string;
-  language: string;
-  platform: string;
-  hash: string;
-}
-
-async function generateFingerprint(): Promise<BrowserFingerprint> {
-  const components: string[] = [];
-
-  // Canvas fingerprint
-  const canvas = document.createElement('canvas');
-  const ctx = canvas.getContext('2d')!;
-  ctx.textBaseline = 'top';
-  ctx.font = '14px Arial';
-  ctx.fillText('fingerprint', 2, 2);
-  const canvasHash = await hashString(canvas.toDataURL());
-  components.push(canvasHash);
-
-  // WebGL fingerprint
-  const gl = document.createElement('canvas').getContext('webgl')!;
-  const debugInfo = gl.getExtension('WEBGL_debug_renderer_info');
-  const gpu = debugInfo
-    ? gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL)
-    : 'unknown';
-  const webglHash = await hashString(gpu);
-  components.push(webglHash);
-
-  // Audio fingerprint
-  const audioCtx = new AudioContext();
-  const oscillator = audioCtx.createOscillator();
-  const analyser = audioCtx.createAnalyser();
-  const gain = audioCtx.createGain();
-  const scriptProcessor = audioCtx.createScriptProcessor(4096, 1, 1);
-
-  oscillator.type = 'triangle';
-  oscillator.frequency.value = 10000;
-
-  const buffer = new Float32Array(analyser.frequencyBinCount);
-  // ... coletar audio data
-  const audioHash = await hashString(buffer.toString());
-  components.push(audioHash);
-
-  // Screen info
-  const screenInfo = `${screen.width}x${screen.height}x${screen.colorDepth}`;
-  components.push(screenInfo);
-
-  // Timezone
-  const timezone = Intl.DateTimeFormat().resolvedOptions().timeZone;
-  components.push(timezone);
-
-  // Hash final
-  const hash = await hashString(components.join('|||'));
-
-  return {
-    canvas: canvasHash,
-    webgl: webglHash,
-    audio: audioHash,
-    fonts: [],
-    screen: { width: screen.width, height: screen.height, colorDepth: screen.colorDepth },
-    timezone,
-    language: navigator.language,
-    platform: navigator.platform,
-    hash,
-  };
-}
-
-async function hashString(str: string): Promise<string> {
-  const encoder = new TextEncoder();
-  const data = encoder.encode(str);
-  const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-  return Array.from(new Uint8Array(hashBuffer))
-    .map(b => b.toString(16).padStart(2, '0'))
-    .join('');
-}
-
-// Persistir fingerprint
-class FingerprintManager {
-  private storage: Keyv<BrowserFingerprint>;
-
-  constructor() {
-    this.storage = new Keyv({ namespace: 'fingerprint' });
-  }
-
-  async getOrCreate(): Promise<BrowserFingerprint> {
-    const existing = await this.storage.get('current');
-    if (existing) return existing;
-
-    const fp = await generateFingerprint();
-    await this.storage.set('current', fp);
-    return fp;
-  }
-
-  async hasChanged(): Promise<boolean> {
-    const current = await this.storage.get('current');
-    if (!current) return false;
-
-    const newFp = await generateFingerprint();
-    return current.hash !== newFp.hash;
-  }
-}
-```
-
-### 7.4. Checkpoints (resume scraping)
-
-```typescript
-interface ScrapeCheckpoint {
-  url: string;
-  pagesScraped: number;
-  lastPage: string;
-  extractedData: unknown[];
-  errors: string[];
-  timestamp: number;
-}
-
-class CheckpointManager {
-  private storage: Keyv<ScrapeCheckpoint>;
-
-  constructor() {
-    this.storage = new Keyv({
-      namespace: 'checkpoints',
-      ttl: 1000 * 60 * 60 * 24 * 7,  // 7 dias
-    });
-  }
-
-  async save(jobId: string, checkpoint: ScrapeCheckpoint): Promise<void> {
-    await this.storage.set(jobId, {
-      ...checkpoint,
-      timestamp: Date.now(),
-    });
-    console.log(`Checkpoint saved: ${checkpoint.pagesScraped} pages`);
-  }
-
-  async resume(jobId: string): Promise<ScrapeCheckpoint | null> {
-    return this.storage.get(jobId) ?? null;
-  }
-
-  async list(): Promise<ScrapeCheckpoint[]> {
-    const checkpoints: ScrapeCheckpoint[] = [];
-    for await (const [, value] of this.storage.iterator()) {
-      checkpoints.push(value);
-    }
-    return checkpoints.sort((a, b) => b.timestamp - a.timestamp);
-  }
-
-  async delete(jobId: string): Promise<void> {
-    await this.storage.delete(jobId);
-  }
-}
-
-// Uso: scraping com resume
-async function scrapeWithResume(urls: string[]): Promise<void> {
-  const jobId = await hashString(urls.join('\n'));
-  const checkpointMgr = new CheckpointManager();
-
-  // Tentar retomar de checkpoint
-  let checkpoint = await checkpointMgr.resume(jobId);
-  const startIdx = checkpoint?.pagesScraped ?? 0;
-  const data = checkpoint?.extractedData ?? [];
-
-  for (let i = startIdx; i < urls.length; i++) {
-    try {
-      const result = await scrape(urls[i]);
-      data.push(result);
-
-      // Save checkpoint a cada 10 páginas
-      if ((i + 1) % 10 === 0) {
-        await checkpointMgr.save(jobId, {
-          url: urls[i],
-          pagesScraped: i + 1,
-          lastPage: urls[i],
-          extractedData: data,
-          errors: checkpoint?.errors ?? [],
-          timestamp: Date.now(),
-        });
-      }
-    } catch (error) {
-      checkpoint = checkpoint ?? {
-        url: urls[i],
-        pagesScraped: i,
-        lastPage: urls[i],
-        extractedData: data,
-        errors: [],
-        timestamp: Date.now(),
-      };
-      checkpoint.errors.push(`${urls[i]}: ${error}`);
-    }
-  }
-
-  // Limpar checkpoint após conclusão
-  await checkpointMgr.delete(jobId);
-  console.log(`Done! Scraped ${data.length} pages`);
-}
-```
-
----
-
-## 8. Browser-Compatible Storage Layer
-
-### Runtime detection com fallback chain
-
-```typescript
-type StorageBackend = 'indexeddb' | 'localstorage' | 'memory';
-
-function detectStorageBackend(): StorageBackend {
-  // 1. IndexedDB (melhor para browsers)
-  if (typeof indexedDB !== 'undefined') return 'indexeddb';
-
-  // 2. localStorage (fallback browsers)
-  if (typeof localStorage !== 'undefined') return 'localstorage';
-
-  // 3. Memory (fallback universal)
-  return 'memory';
-}
-
-// Universal storage interface
-interface UniversalStorage {
-  get<T>(key: string): Promise<T | null>;
-  set<T>(key: string, value: T, ttlMs?: number): Promise<void>;
-  delete(key: string): Promise<void>;
-  has(key: string): Promise<boolean>;
-  clear(): Promise<void>;
-}
-
-// Factory
-function createStorage(namespace?: string): UniversalStorage {
-  const backend = detectStorageBackend();
-
-  switch (backend) {
-    case 'indexeddb':
-      return new IndexedDBStorage(namespace ?? 'webscrape');
-    case 'localstorage':
-      return new LocalStorageStorage(namespace ?? 'ws_');
-    case 'memory':
-      return new MemoryStorage();
-  }
-}
-
-// Memory storage
-class MemoryStorage implements UniversalStorage {
-  private store = new Map<string, { value: unknown; expires?: number }>();
-
-  async get<T>(key: string): Promise<T | null> {
-    const entry = this.store.get(key);
-    if (!entry) return null;
-    if (entry.expires && Date.now() > entry.expires) {
-      this.store.delete(key);
-      return null;
-    }
-    return entry.value as T;
-  }
-
-  async set<T>(key: string, value: T, ttlMs?: number): Promise<void> {
-    this.store.set(key, {
-      value,
-      expires: ttlMs ? Date.now() + ttlMs : undefined,
-    });
-  }
-
-  async delete(key: string): Promise<void> {
-    this.store.delete(key);
-  }
-
-  async has(key: string): Promise<boolean> {
-    return (await this.get(key)) !== null;
-  }
-
-  async clear(): Promise<void> {
-    this.store.clear();
-  }
-}
-
-// LocalStorage storage
-class LocalStorageStorage implements UniversalStorage {
-  private prefix: string;
-
-  constructor(prefix: string) {
-    this.prefix = prefix;
-  }
-
-  async get<T>(key: string): Promise<T | null> {
-    const raw = localStorage.getItem(this.prefix + key);
-    if (!raw) return null;
-    try {
-      const item = JSON.parse(raw);
-      if (item.expires && Date.now() > item.expires) {
-        this.delete(key);
-        return null;
-      }
-      return item.value;
-    } catch {
-      return null;
-    }
-  }
-
-  async set<T>(key: string, value: T, ttlMs?: number): Promise<void> {
-    localStorage.setItem(this.prefix + key, JSON.stringify({
-      value,
-      expires: ttlMs ? Date.now() + ttlMs : undefined,
-    }));
-  }
-
-  async delete(key: string): Promise<void> {
-    localStorage.removeItem(this.prefix + key);
-  }
-
-  async has(key: string): Promise<boolean> {
-    return (await this.get(key)) !== null;
-  }
-
-  async clear(): Promise<void> {
-    const keys = Object.keys(localStorage)
-      .filter(k => k.startsWith(this.prefix));
-    keys.forEach(k => localStorage.removeItem(k));
-  }
-}
-
-// IndexedDB storage
-class IndexedDBStorage implements UniversalStorage {
-  private dbName: string;
-  private db: IDBDatabase | null = null;
-
-  constructor(dbName: string) {
-    this.dbName = dbName;
-  }
-
-  private async init(): Promise<IDBDatabase> {
-    if (this.db) return this.db;
-
-    return new Promise((resolve, reject) => {
-      const request = indexedDB.open(this.dbName, 1);
-
-      request.onupgradeneeded = () => {
-        const db = request.result;
-        if (!db.objectStoreNames.contains('store')) {
-          db.createObjectStore('store', { keyPath: 'key' });
-        }
-      };
-
-      request.onsuccess = () => {
-        this.db = request.result;
-        resolve(this.db);
-      };
-
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async get<T>(key: string): Promise<T | null> {
-    const db = await this.init();
-    return new Promise((resolve) => {
-      const tx = db.transaction('store', 'readonly');
-      const store = tx.objectStore('store');
-      const request = store.get(key);
-
-      request.onsuccess = () => {
-        const result = request.result;
-        if (!result) return resolve(null);
-        if (result.expires && Date.now() > result.expires) {
-          this.delete(key);
-          return resolve(null);
-        }
-        resolve(result.value);
-      };
-
-      request.onerror = () => resolve(null);
-    });
-  }
-
-  async set<T>(key: string, value: T, ttlMs?: number): Promise<void> {
-    const db = await this.init();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction('store', 'readwrite');
-      const store = tx.objectStore('store');
-      const request = store.put({
-        key,
-        value,
-        expires: ttlMs ? Date.now() + ttlMs : undefined,
-      });
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async delete(key: string): Promise<void> {
-    const db = await this.init();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction('store', 'readwrite');
-      const store = tx.objectStore('store');
-      const request = store.delete(key);
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  }
-
-  async has(key: string): Promise<boolean> {
-    return (await this.get(key)) !== null;
-  }
-
-  async clear(): Promise<void> {
-    const db = await this.init();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction('store', 'readwrite');
-      const store = tx.objectStore('store');
-      const request = store.clear();
-
-      request.onsuccess = () => resolve();
-      request.onerror = () => reject(request.error);
-    });
-  }
-}
-```
-
----
-
-## 9. Storage Lifecycle
-
-### 9.1. TTL Strategies
-
-#### Eager eviction (remove on access)
-
-```typescript
-// Remove item imediatamente quando expirado
-class EagerTTLCache<T> {
-  private store = new Map<string, { value: T; expires: number }>();
-
-  get(key: string): T | null {
-    const entry = this.store.get(key);
-    if (!entry) return null;
-
-    if (Date.now() > entry.expires) {
-      this.store.delete(key);  // Eager: remove agora
-      return null;
-    }
-
-    return entry.value;
-  }
-
-  set(key: string, value: T, ttlMs: number): void {
-    this.store.set(key, {
-      value,
-      expires: Date.now() + ttlMs,
-    });
-  }
-}
-```
-
-#### Lazy eviction (remove in background)
-
-```typescript
-// Remove expiradas em background interval
-class LazyTTLCache<T> {
-  private store = new Map<string, { value: T; expires: number }>();
-  private cleanupInterval: ReturnType<typeof setInterval>;
-
-  constructor(cleanupMs = 60_000) {
-    this.cleanupInterval = setInterval(() => {
-      this.cleanup();
-    }, cleanupMs);
-  }
-
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.store) {
-      if (now > entry.expires) {
-        this.store.delete(key);
-      }
-    }
-  }
-
-  destroy(): void {
-    clearInterval(this.cleanupInterval);
-  }
-
-  get(key: string): T | null {
-    const entry = this.store.get(key);
-    return entry?.value ?? null;
-  }
-
-  set(key: string, value: T, ttlMs: number): void {
-    this.store.set(key, {
-      value,
-      expires: Date.now() + ttlMs,
-    });
-  }
-}
-```
-
-#### Scheduled eviction (event-driven)
-
-```typescript
-// Agenda limpeza baseada no próximo item que expira
-class ScheduledTTLCache<T> {
-  private store = new Map<string, { value: T; expires: number }>();
-  private nextCleanup: ReturnType<typeof setTimeout> | null = null;
-
-  set(key: string, value: T, ttlMs: number): void {
-    const expires = Date.now() + ttlMs;
-    this.store.set(key, { value, expires });
-
-    // Agendar cleanup se este expira antes do próximo
-    if (!this.nextCleanup || expires < this.nextCleanupAt) {
-      this.scheduleCleanup(expires);
-    }
-  }
-
-  get(key: string): T | null {
-    return this.store.get(key)?.value ?? null;
-  }
-
-  private nextCleanupAt = 0;
-
-  private scheduleCleanup(at: number): void {
-    if (this.nextCleanup) clearTimeout(this.nextCleanup);
-    this.nextCleanupAt = at;
-    this.nextCleanup = setTimeout(() => {
-      this.cleanup();
-    }, Math.max(0, at - Date.now()));
-  }
-
-  private cleanup(): void {
-    const now = Date.now();
-    for (const [key, entry] of this.store) {
-      if (now > entry.expires) {
-        this.store.delete(key);
-      }
-    }
-
-    // Reagendar baseado no próximo item
-    let nextExpiry = Infinity;
-    for (const entry of this.store.values()) {
-      if (entry.expires < nextExpiry) {
-        nextExpiry = entry.expires;
-      }
-    }
-    if (nextExpiry < Infinity) {
-      this.scheduleCleanup(nextExpiry);
-    }
-  }
-}
-```
-
-### 9.2. Eviction Strategies
-
-```typescript
-// LRU — Least Recently Used
-class LRUCache<T> {
-  private store = new Map<string, { value: T; lastAccess: number }>();
-  private maxSize: number;
-
-  constructor(maxSize = 100) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: string): T | null {
-    const entry = this.store.get(key);
-    if (!entry) return null;
-    entry.lastAccess = Date.now();
-    return entry.value;
-  }
-
-  set(key: string, value: T): void {
-    if (this.store.size >= this.maxSize) {
-      this.evict();
-    }
-    this.store.set(key, { value, lastAccess: Date.now() });
-  }
-
-  private evict(): void {
-    let oldest: string | null = null;
-    let oldestTime = Infinity;
-
-    for (const [key, entry] of this.store) {
-      if (entry.lastAccess < oldestTime) {
-        oldestTime = entry.lastAccess;
-        oldest = key;
-      }
-    }
-
-    if (oldest) this.store.delete(oldest);
-  }
-}
-
-// LFU — Least Frequently Used
-class LFUCache<T> {
-  private store = new Map<string, { value: T; count: number }>();
-  private maxSize: number;
-
-  constructor(maxSize = 100) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: string): T | null {
-    const entry = this.store.get(key);
-    if (!entry) return null;
-    entry.count++;
-    return entry.value;
-  }
-
-  set(key: string, value: T): void {
-    if (this.store.size >= this.maxSize) {
-      this.evict();
-    }
-    this.store.set(key, { value, count: 0 });
-  }
-
-  private evict(): void {
-    let leastUsed: string | null = null;
-    let minCount = Infinity;
-
-    for (const [key, entry] of this.store) {
-      if (entry.count < minCount) {
-        minCount = entry.count;
-        leastUsed = key;
-      }
-    }
-
-    if (leastUsed) this.store.delete(leastUsed);
-  }
-}
-
-// FIFO — First In First Out
-class FIFOCache<T> {
-  private store = new Map<string, T>();
-  private maxSize: number;
-
-  constructor(maxSize = 100) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: string): T | null {
-    return this.store.get(key) ?? null;
-  }
-
-  set(key: string, value: T): void {
-    if (this.store.size >= this.maxSize) {
-      // Remove a primeira entrada (mais antiga)
-      const firstKey = this.store.keys().next().value;
-      if (firstKey) this.store.delete(firstKey);
-    }
-    this.store.set(key, value);
-  }
-}
-
-// Size-based eviction
-class SizeBasedCache<T> {
-  private store = new Map<string, { value: T; size: number }>();
-  private maxSize: number;
-  private currentSize = 0;
-
-  constructor(maxSize: number) {
-    this.maxSize = maxSize;
-  }
-
-  get(key: string): T | null {
-    return this.store.get(key)?.value ?? null;
-  }
-
-  set(key: string, value: T, sizeFn: (v: T) => number): void {
-    const size = sizeFn(value);
-
-    // Remove entradas até caber
-    while (this.currentSize + size > this.maxSize && this.store.size > 0) {
-      const firstKey = this.store.keys().next().value;
-      if (firstKey) {
-        this.currentSize -= this.store.get(firstKey)!.size;
-        this.store.delete(firstKey);
-      }
-    }
-
-    this.store.set(key, { value, size });
-    this.currentSize += size;
-  }
-}
-```
-
----
-
-## 10. Best Practices
-
-### Separar stores por volatilidade
-
-```
-Cache Architecture:
-├── Hot Cache (in-memory, LRU, 1K items, TTL 5min)
-│   └── Requisições frequentes, dados que mudam rápido
-├── Warm Cache (SQLite/Redis, 100K items, TTL 1 hora)
-│   └── Dados semi-estáveis, sessões de usuário
-├── Cold Cache (IndexedDB/KV, unlimited, TTL 7 dias)
-│   └── Dados estáticos, checkpoints, logs
-└── Archive (Disk, unlimited, sem TTL)
-    └── Resultados de scraping permanentes
-```
-
-### Compression
-
-```typescript
-// Comprimir dados grandes antes de armazenar
-async function compress(data: string): Promise<Uint8Array> {
-  const stream = new Blob([data]).stream();
-  const compressed = stream.pipeThrough(new CompressionStream('gzip'));
-  return new Uint8Array(await new Response(compressed).arrayBuffer());
-}
-
-async function decompress(data: Uint8Array): Promise<string> {
-  const stream = new Blob([data]).stream();
-  const decompressed = stream.pipeThrough(new DecompressionStream('gzip'));
-  return new Response(decompressed).text();
-}
-
-// Uso
-const largeData = JSON.stringify(bigObject);
-const compressed = await compress(largeData);
-await keyv.set('key', compressed);
-// Reduz 60-80% do tamanho
-```
-
-### Atomic writes
-
-```typescript
-// Usar transações para writes atômicos
-async function atomicWrite<T>(
-  key: string,
-  value: T,
-  storage: UniversalStorage
-): Promise<void> {
-  // Write temporário
-  const tempKey = `${key}:temp:${Date.now()}`;
-  await storage.set(tempKey, value);
-
-  // Rename atômico (não existe em todos os storages)
-  // Para Keyv: usar transação do adapter
-  const existing = await storage.get(key);
-  try {
-    await storage.set(key, value);
-    await storage.delete(tempKey);
-  } catch (error) {
-    // Rollback
-    if (existing) await storage.set(key, existing);
-    await storage.delete(tempKey);
-    throw error;
-  }
-}
-```
-
-### Graceful degradation
-
-```typescript
-async function resilientGet<T>(key: string): Promise<T | null> {
-  const stores: UniversalStorage[] = [
-    memoryCache,     // Rápido, volatile
-    sqliteCache,     // Persistente, síncrono
-    redisCache,      // Persistente, async
-  ];
-
-  for (const store of stores) {
-    try {
-      const value = await store.get<T>(key);
-      if (value !== null) return value;
-    } catch (error) {
-      console.warn(`Storage ${store.constructor.name} failed:`, error);
-      continue;
-    }
-  }
-
-  return null;
-}
-
-async function resilientSet<T>(key: string, value: T, ttlMs?: number): Promise<void> {
-  const stores: UniversalStorage[] = [
-    memoryCache,
-    sqliteCache,
-    redisCache,
-  ];
-
-  for (const store of stores) {
-    try {
-      await store.set(key, value, ttlMs);
-    } catch (error) {
-      console.warn(`Storage ${store.constructor.name} write failed:`, error);
-      continue;
-    }
-  }
-}
-```
-
----
-
-## 11. Exemplos Completos
-
-### 11.1. Multi-tier scraping cache
-
-```typescript
-class MultiTierCache<T> {
-  private hot: LRUCache<T>;
-  private warm: Keyv<T>;
-  private cold: UniversalStorage;
-
-  constructor() {
-    this.hot = new LRUCache<T>({ max: 1000, ttl: 1000 * 60 * 5 });
-    this.warm = new Keyv({
-      namespace: 'warm',
-      ttl: 1000 * 60 * 60,
-    });
-    this.cold = createStorage('cold');
-  }
-
-  async get(key: string): Promise<T | null> {
-    // Hot
-    const hotValue = this.hot.get(key);
-    if (hotValue) return hotValue;
-
-    // Warm
-    const warmValue = await this.warm.get(key);
-    if (warmValue) {
-      this.hot.set(key, warmValue);
-      return warmValue;
-    }
-
-    // Cold
-    const coldValue = await this.cold.get<T>(key);
-    if (coldValue) {
-      this.hot.set(key, coldValue);
-      await this.warm.set(key, coldValue);
-      return coldValue;
-    }
-
-    return null;
-  }
-
-  async set(key: string, value: T): Promise<void> {
-    this.hot.set(key, value);
-    await this.warm.set(key, value);
-    await this.cold.set(key, value);
-  }
-
-  async invalidate(key: string): Promise<void> {
-    this.hot.delete(key);
-    await this.warm.delete(key);
-    await this.cold.delete(key);
-  }
-}
-```
-
-### 11.2. Persistent scraping session
-
-```typescript
-class ScrapingSession {
-  private checkpointMgr: CheckpointManager;
-  private authMgr: AuthManager;
-  private cache: MultiTierCache<unknown>;
-
-  constructor() {
-    this.checkpointMgr = new CheckpointManager();
-    this.authMgr = new AuthManager();
-    this.cache = new MultiTierCache();
-  }
-
-  async scrape(urls: string[]): Promise<void> {
-    const jobId = await this.generateJobId(urls);
-
-    // Restaurar de checkpoint
-    const checkpoint = await this.checkpointMgr.resume(jobId);
-    const startIdx = checkpoint?.pagesScraped ?? 0;
-
-    for (let i = startIdx; i < urls.length; i++) {
-      const url = urls[i];
-
-      // Verificar cache
-      const cached = await this.cache.get(`scrape:${url}`);
-      if (cached) {
-        console.log(`Cache hit: ${url}`);
-        continue;
-      }
-
-      // Obter auth se necessário
-      const token = await this.authMgr.getValidToken(url);
-
-      // Scrape
-      try {
-        const result = await fetch(url, {
-          headers: token ? { Authorization: `Bearer ${token}` } : {},
-        });
-
-        const data = await result.json();
-        await this.cache.set(`scrape:${url}`, data);
-
-        // Checkpoint a cada 10 páginas
-        if ((i + 1) % 10 === 0) {
-          await this.checkpointMgr.save(jobId, {
-            url,
-            pagesScraped: i + 1,
-            lastPage: url,
-            extractedData: [],
-            errors: [],
-            timestamp: Date.now(),
-          });
-        }
-      } catch (error) {
-        console.error(`Failed: ${url}`, error);
-      }
-    }
-  }
-
-  private async generateJobId(urls: string[]): Promise<string> {
-    return crypto.subtle
-      .digest('SHA-256', new TextEncoder().encode(urls.join('\n')))
-      .then(buf => Array.from(new Uint8Array(buf))
-        .map(b => b.toString(16).padStart(2, '0'))
-        .join('')
-        .slice(0, 16));
-  }
-}
-```
-
----
-
-## 12. Checklist
-
-- [ ] Usar Map para caches simples, lru-cache para bounded
-- [ ] WeakMap para metadata associada a objects
-- [ ] Browser: IndexedDB para dados grandes, localStorage para pequenos
-- [ ] Server: better-sqlite3 para síncrono, Redis para distribuído
-- [ ] Cross-runtime: keyv 5.6.0 com adapters pluggable
-- [ ] Edge: Cloudflare KV, Upstash Redis, Deno KV
-- [ ] Request dedup com Keyv TTL ou Bloom filter
-- [ ] ETag conditional requests para freshness
-- [ ] Persistir: auth tokens, checkpoints, fingerprints
-- [ ] Separar stores por volatilidade (hot/warm/cold)
-- [ ] TTL: eager para hot, lazy para warm, scheduled para cold
-- [ ] Eviction: LRU para hot, size-based para warm
-- [ ] Compression para dados > 10KB
-- [ ] Graceful degradation: memory → SQLite → Redis
-- [ ] Atomic writes para consistência