@ogxjs/core 0.1.2 → 0.2.0-alpha.1

package/dist/cache/hash.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @ogxjs/core - Fast Hash Functions
+ * High-performance sync hashing for cache keys
+ *
+ * @description
+ * SHA-256 is secure but slow (~200μs per hash).
+ * For cache keys where collision resistance is less critical,
+ * we use faster algorithms:
+ * - FNV-1a: ~10μs per hash (20x faster)
+ * - xxHash-inspired: ~5μs per hash (40x faster)
+ *
+ * @version 0.2.0 "Turbo"
+ */
+/**
+ * FNV-1a hash algorithm (32-bit)
+ *
+ * Fast, simple, good distribution for short strings.
+ * Collision probability: ~1 in 4 billion for random inputs.
+ *
+ * @param str - String to hash
+ * @returns 32-bit hash as unsigned integer
+ *
+ * @example
+ * ```ts
+ * fnv1a("hello") // → 1335831723
+ * fnv1a("hello world") // → 3582672807
+ * ```
+ */
+export declare function fnv1a(str: string): number;
+/**
+ * FNV-1a hash with hex string output
+ *
+ * @param str - String to hash
+ * @returns Hash as 8-character hex string
+ */
+export declare function fnv1aHex(str: string): string;
+/**
+ * xxHash-inspired fast hash (32-bit)
+ *
+ * Even faster than FNV-1a for longer strings.
+ * Processes 4 bytes at a time when possible.
+ *
+ * @param str - String to hash
+ * @param seed - Optional seed value (default: 0)
+ * @returns 32-bit hash as unsigned integer
+ */
+export declare function fastHash(str: string, seed?: number): number;
+/**
+ * Fast hash with hex string output
+ */
+export declare function fastHashHex(str: string, seed?: number): string;
+/**
+ * Hash a configuration object
+ *
+ * Serializes the object to JSON and hashes it.
+ * Excludes functions and debug flags.
+ *
+ * @param obj - Object to hash
+ * @returns Hash string
+ */
+export declare function hashObject(obj: unknown): string;
+/**
+ * Create a composite hash from multiple values
+ */
+export declare function hashComposite(...values: unknown[]): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/cache/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/cache/hash.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAUzC;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5C;AAID;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,MAAM,CA8DtD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,MAAM,CAEzD;AA2BD;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAQ/C;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,CAM1D"}

package/dist/cache/hash.js

@@ -0,0 +1,161 @@
+/**
+ * @ogxjs/core - Fast Hash Functions
+ * High-performance sync hashing for cache keys
+ *
+ * @description
+ * SHA-256 is secure but slow (~200μs per hash).
+ * For cache keys where collision resistance is less critical,
+ * we use faster algorithms:
+ * - FNV-1a: ~10μs per hash (20x faster)
+ * - xxHash-inspired: ~5μs per hash (40x faster)
+ *
+ * @version 0.2.0 "Turbo"
+ */
+// FNV-1A HASH
+/**
+ * FNV-1a hash algorithm (32-bit)
+ *
+ * Fast, simple, good distribution for short strings.
+ * Collision probability: ~1 in 4 billion for random inputs.
+ *
+ * @param str - String to hash
+ * @returns 32-bit hash as unsigned integer
+ *
+ * @example
+ * ```ts
+ * fnv1a("hello") // → 1335831723
+ * fnv1a("hello world") // → 3582672807
+ * ```
+ */
+export function fnv1a(str) {
+    let hash = 2166136261; // FNV offset basis
+    for (let i = 0; i < str.length; i++) {
+        hash ^= str.charCodeAt(i);
+        // FNV prime multiplication (using Math.imul for 32-bit overflow)
+        hash = Math.imul(hash, 16777619);
+    }
+    return hash >>> 0; // Ensure unsigned
+}
+/**
+ * FNV-1a hash with hex string output
+ *
+ * @param str - String to hash
+ * @returns Hash as 8-character hex string
+ */
+export function fnv1aHex(str) {
+    return fnv1a(str).toString(16).padStart(8, "0");
+}
+// XXHASH-INSPIRED HASH
+/**
+ * xxHash-inspired fast hash (32-bit)
+ *
+ * Even faster than FNV-1a for longer strings.
+ * Processes 4 bytes at a time when possible.
+ *
+ * @param str - String to hash
+ * @param seed - Optional seed value (default: 0)
+ * @returns 32-bit hash as unsigned integer
+ */
+export function fastHash(str, seed = 0) {
+    const PRIME1 = 2654435761;
+    const PRIME2 = 2246822519;
+    const PRIME3 = 3266489917;
+    const PRIME4 = 668265263;
+    const PRIME5 = 374761393;
+    let h32;
+    const len = str.length;
+    if (len >= 16) {
+        // Process in 16-byte blocks
+        let v1 = (seed + PRIME1 + PRIME2) | 0;
+        let v2 = (seed + PRIME2) | 0;
+        let v3 = seed | 0;
+        let v4 = (seed - PRIME1) | 0;
+        let i = 0;
+        const limit = len - 16;
+        while (i <= limit) {
+            v1 = Math.imul(rotl(v1 + Math.imul(read32(str, i), PRIME2), 13), PRIME1);
+            i += 4;
+            v2 = Math.imul(rotl(v2 + Math.imul(read32(str, i), PRIME2), 13), PRIME1);
+            i += 4;
+            v3 = Math.imul(rotl(v3 + Math.imul(read32(str, i), PRIME2), 13), PRIME1);
+            i += 4;
+            v4 = Math.imul(rotl(v4 + Math.imul(read32(str, i), PRIME2), 13), PRIME1);
+            i += 4;
+        }
+        h32 = rotl(v1, 1) + rotl(v2, 7) + rotl(v3, 12) + rotl(v4, 18);
+    }
+    else {
+        h32 = seed + PRIME5;
+    }
+    h32 += len;
+    // Process remaining bytes
+    let i = len >= 16 ? len - (len % 16) : 0;
+    while (i <= len - 4) {
+        h32 = Math.imul(rotl(h32 + Math.imul(read32(str, i), PRIME3), 17), PRIME4);
+        i += 4;
+    }
+    while (i < len) {
+        h32 = Math.imul(rotl(h32 + Math.imul(str.charCodeAt(i), PRIME5), 11), PRIME1);
+        i++;
+    }
+    // Final mix
+    h32 ^= h32 >>> 15;
+    h32 = Math.imul(h32, PRIME2);
+    h32 ^= h32 >>> 13;
+    h32 = Math.imul(h32, PRIME3);
+    h32 ^= h32 >>> 16;
+    return h32 >>> 0;
+}
+/**
+ * Fast hash with hex string output
+ */
+export function fastHashHex(str, seed = 0) {
+    return fastHash(str, seed).toString(16).padStart(8, "0");
+}
+// HELPERS
+/**
+ * Rotate left (32-bit)
+ */
+function rotl(x, r) {
+    return (x << r) | (x >>> (32 - r));
+}
+/**
+ * Read 4 characters as a 32-bit value
+ * Safely handles bounds by returning 0 for out-of-bounds indices
+ */
+function read32(str, i) {
+    const len = str.length;
+    return ((i < len ? str.charCodeAt(i) : 0) |
+        ((i + 1 < len ? str.charCodeAt(i + 1) : 0) << 8) |
+        ((i + 2 < len ? str.charCodeAt(i + 2) : 0) << 16) |
+        ((i + 3 < len ? str.charCodeAt(i + 3) : 0) << 24));
+}
+// OBJECT HASHING
+/**
+ * Hash a configuration object
+ *
+ * Serializes the object to JSON and hashes it.
+ * Excludes functions and debug flags.
+ *
+ * @param obj - Object to hash
+ * @returns Hash string
+ */
+export function hashObject(obj) {
+    const str = JSON.stringify(obj, (key, value) => {
+        if (typeof value === "function")
+            return undefined;
+        if (key === "debug")
+            return undefined;
+        return value;
+    });
+    return fastHashHex(str);
+}
+/**
+ * Create a composite hash from multiple values
+ */
+export function hashComposite(...values) {
+    const combined = values
+        .map((v) => (typeof v === "string" ? v : JSON.stringify(v)))
+        .join("|");
+    return fastHashHex(combined);
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @ogxjs/core - Cache Module
+ * High-performance caching system
+ *
+ * @version 0.2.0 "Turbo"
+ */
+export { fastHash, fastHashHex, fnv1a, fnv1aHex, hashComposite, hashObject, } from "./hash";
+export { createLargeCache, createMediumCache, createSmallCache, LRUCache, type LRUCacheOptions, type LRUCacheStats, } from "./lru";
+export { configureSnapshotCache, getSnapshotCache, type SnapshotCacheOptions, type SnapshotCacheStats, SnapshotCacheV2, snapshotCache, } from "./snapshot";
+//# sourceMappingURL=index.d.ts.map

package/dist/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EACN,QAAQ,EACR,WAAW,EACX,KAAK,EACL,QAAQ,EACR,aAAa,EACb,UAAU,GACV,MAAM,QAAQ,CAAC;AAGhB,OAAO,EACN,gBAAgB,EAChB,iBAAiB,EACjB,gBAAgB,EAChB,QAAQ,EACR,KAAK,eAAe,EACpB,KAAK,aAAa,GAClB,MAAM,OAAO,CAAC;AAGf,OAAO,EACN,sBAAsB,EACtB,gBAAgB,EAChB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,eAAe,EACf,aAAa,GACb,MAAM,YAAY,CAAC"}

package/dist/cache/index.js

@@ -0,0 +1,12 @@
+/**
+ * @ogxjs/core - Cache Module
+ * High-performance caching system
+ *
+ * @version 0.2.0 "Turbo"
+ */
+// Hash functions
+export { fastHash, fastHashHex, fnv1a, fnv1aHex, hashComposite, hashObject, } from "./hash";
+// LRU Cache
+export { createLargeCache, createMediumCache, createSmallCache, LRUCache, } from "./lru";
+// Snapshot Cache
+export { configureSnapshotCache, getSnapshotCache, SnapshotCacheV2, snapshotCache, } from "./snapshot";

package/dist/cache/lru.d.ts

@@ -0,0 +1,122 @@
+/**
+ * @ogxjs/core - LRU Cache Implementation
+ * Least Recently Used cache with O(1) operations
+ *
+ * @description
+ * High-performance LRU cache using Map + doubly-linked list.
+ * - O(1) get, set, delete
+ * - Automatic eviction when max size reached
+ * - Optional TTL (time-to-live) support
+ * - Memory-bounded
+ *
+ * @version 0.2.0 "Turbo"
+ */
+export interface LRUCacheOptions<K = unknown, V = unknown> {
+    /** Maximum number of items in cache */
+    maxSize?: number;
+    /** Time-to-live in milliseconds (0 = no expiration) */
+    ttl?: number;
+    /** Callback when an item is evicted */
+    onEvict?: (key: K, value: V) => void;
+}
+export interface LRUCacheStats {
+    size: number;
+    maxSize: number;
+    hits: number;
+    misses: number;
+    hitRate: number;
+    evictions: number;
+}
+/**
+ * LRU Cache with O(1) operations
+ *
+ * @example
+ * ```ts
+ * const cache = new LRUCache<string, Buffer>({ maxSize: 100, ttl: 60000 });
+ *
+ * cache.set("image-1", buffer);
+ * const result = cache.get("image-1"); // → buffer
+ *
+ * console.log(cache.stats); // { size: 1, hits: 1, ... }
+ * ```
+ */
+export declare class LRUCache<K, V> {
+    private cache;
+    private head;
+    private tail;
+    private readonly maxSize;
+    private readonly ttl;
+    private readonly onEvict?;
+    private _hits;
+    private _misses;
+    private _evictions;
+    constructor(options?: LRUCacheOptions<K, V>);
+    /**
+     * Get a value from the cache
+     * Moves the item to the front (most recently used)
+     */
+    get(key: K): V | undefined;
+    /**
+     * Set a value in the cache
+     * Evicts least recently used item if at capacity
+     */
+    set(key: K, value: V): void;
+    /**
+     * Check if a key exists (without updating LRU order)
+     */
+    has(key: K): boolean;
+    /**
+     * Delete a key from the cache
+     */
+    delete(key: K): boolean;
+    /**
+     * Clear the entire cache
+     */
+    clear(): void;
+    /**
+     * Get cache size
+     */
+    get size(): number;
+    /**
+     * Get cache statistics
+     */
+    get stats(): LRUCacheStats;
+    /**
+     * Get all keys (in LRU order, most recent first)
+     */
+    keys(): K[];
+    /**
+     * Iterate over entries (in LRU order)
+     */
+    entries(): Generator<[K, V]>;
+    /**
+     * Prune expired entries (if TTL is set)
+     * Call periodically for long-running processes
+     */
+    prune(): number;
+    /**
+     * Move a node to the front (most recently used)
+     */
+    private moveToFront;
+    /**
+     * Remove a node from the linked list (but not from Map)
+     */
+    private removeNode;
+    /**
+     * Evict the least recently used item
+     */
+    private evictLRU;
+}
+/**
+ * Create a small LRU cache (100 items)
+ */
+export declare function createSmallCache<K, V>(ttl?: number): LRUCache<K, V>;
+/**
+ * Create a medium LRU cache (1000 items)
+ */
+export declare function createMediumCache<K, V>(ttl?: number): LRUCache<K, V>;
+/**
+ * Create a large LRU cache (10000 items)
+ */
+export declare function createLargeCache<K, V>(ttl?: number): LRUCache<K, V>;
+//# sourceMappingURL=lru.d.ts.map

package/dist/cache/lru.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru.d.ts","sourceRoot":"","sources":["../../src/cache/lru.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAYH,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACxD,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uDAAuD;IACvD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uCAAuC;IACvC,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;CACrC;AAED,MAAM,WAAW,aAAa;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CAClB;AAID;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC;IACzB,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,IAAI,CAAgC;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA6B;IAGtD,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,UAAU,CAAK;gBAEX,OAAO,GAAE,eAAe,CAAC,CAAC,EAAE,CAAC,CAAM;IAM/C;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAsB1B;;;OAGG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAsC3B;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAapB;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAUvB;;OAEG;IACH,KAAK,IAAI,IAAI;IASb;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,KAAK,IAAI,aAAa,CAUzB;IAED;;OAEG;IACH,IAAI,IAAI,CAAC,EAAE;IAUX;;OAEG;IACF,OAAO,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQ7B;;;OAGG;IACH,KAAK,IAAI,MAAM;IAoBf;;OAEG;IACH,OAAO,CAAC,WAAW;IAoBnB;;OAEG;IACH,OAAO,CAAC,UAAU;IAclB;;OAEG;IACH,OAAO,CAAC,QAAQ;CAehB;AAID;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,SAAI,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAE9D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,SAAI,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAE/D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,SAAI,GAAG,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAE9D"}

package/dist/cache/lru.js

@@ -0,0 +1,269 @@
+/**
+ * @ogxjs/core - LRU Cache Implementation
+ * Least Recently Used cache with O(1) operations
+ *
+ * @description
+ * High-performance LRU cache using Map + doubly-linked list.
+ * - O(1) get, set, delete
+ * - Automatic eviction when max size reached
+ * - Optional TTL (time-to-live) support
+ * - Memory-bounded
+ *
+ * @version 0.2.0 "Turbo"
+ */
+// LRU CACHE CLASS
+/**
+ * LRU Cache with O(1) operations
+ *
+ * @example
+ * ```ts
+ * const cache = new LRUCache<string, Buffer>({ maxSize: 100, ttl: 60000 });
+ *
+ * cache.set("image-1", buffer);
+ * const result = cache.get("image-1"); // → buffer
+ *
+ * console.log(cache.stats); // { size: 1, hits: 1, ... }
+ * ```
+ */
+export class LRUCache {
+    cache = new Map();
+    head = null;
+    tail = null;
+    maxSize;
+    ttl;
+    onEvict;
+    // Stats
+    _hits = 0;
+    _misses = 0;
+    _evictions = 0;
+    constructor(options = {}) {
+        this.maxSize = options.maxSize ?? 1000;
+        this.ttl = options.ttl ?? 0;
+        this.onEvict = options.onEvict;
+    }
+    /**
+     * Get a value from the cache
+     * Moves the item to the front (most recently used)
+     */
+    get(key) {
+        const node = this.cache.get(key);
+        if (!node) {
+            this._misses++;
+            return undefined;
+        }
+        // Check TTL
+        if (this.ttl > 0 && Date.now() - node.timestamp > this.ttl) {
+            this.delete(key);
+            this._misses++;
+            return undefined;
+        }
+        // Move to front
+        this.moveToFront(node);
+        this._hits++;
+        return node.value;
+    }
+    /**
+     * Set a value in the cache
+     * Evicts least recently used item if at capacity
+     */
+    set(key, value) {
+        const existing = this.cache.get(key);
+        if (existing) {
+            // Update existing
+            existing.value = value;
+            existing.timestamp = Date.now();
+            this.moveToFront(existing);
+            return;
+        }
+        // Evict if at capacity
+        if (this.cache.size >= this.maxSize) {
+            this.evictLRU();
+        }
+        // Create new node
+        const node = {
+            key,
+            value,
+            timestamp: Date.now(),
+            prev: null,
+            next: this.head,
+        };
+        // Update links
+        if (this.head) {
+            this.head.prev = node;
+        }
+        this.head = node;
+        if (!this.tail) {
+            this.tail = node;
+        }
+        this.cache.set(key, node);
+    }
+    /**
+     * Check if a key exists (without updating LRU order)
+     */
+    has(key) {
+        const node = this.cache.get(key);
+        if (!node)
+            return false;
+        // Check TTL
+        if (this.ttl > 0 && Date.now() - node.timestamp > this.ttl) {
+            this.delete(key);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Delete a key from the cache
+     */
+    delete(key) {
+        const node = this.cache.get(key);
+        if (!node)
+            return false;
+        this.removeNode(node);
+        this.cache.delete(key);
+        return true;
+    }
+    /**
+     * Clear the entire cache
+     */
+    clear() {
+        this.cache.clear();
+        this.head = null;
+        this.tail = null;
+        this._hits = 0;
+        this._misses = 0;
+        this._evictions = 0;
+    }
+    /**
+     * Get cache size
+     */
+    get size() {
+        return this.cache.size;
+    }
+    /**
+     * Get cache statistics
+     */
+    get stats() {
+        const total = this._hits + this._misses;
+        return {
+            size: this.cache.size,
+            maxSize: this.maxSize,
+            hits: this._hits,
+            misses: this._misses,
+            hitRate: total > 0 ? this._hits / total : 0,
+            evictions: this._evictions,
+        };
+    }
+    /**
+     * Get all keys (in LRU order, most recent first)
+     */
+    keys() {
+        const result = [];
+        let node = this.head;
+        while (node) {
+            result.push(node.key);
+            node = node.next;
+        }
+        return result;
+    }
+    /**
+     * Iterate over entries (in LRU order)
+     */
+    *entries() {
+        let node = this.head;
+        while (node) {
+            yield [node.key, node.value];
+            node = node.next;
+        }
+    }
+    /**
+     * Prune expired entries (if TTL is set)
+     * Call periodically for long-running processes
+     */
+    prune() {
+        if (this.ttl === 0)
+            return 0;
+        const now = Date.now();
+        let pruned = 0;
+        for (const [key, node] of this.cache) {
+            if (now - node.timestamp > this.ttl) {
+                this.delete(key);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    // ═══════════════════════════════════════════════════════════════════════
+    // PRIVATE METHODS
+    // ═══════════════════════════════════════════════════════════════════════
+    /**
+     * Move a node to the front (most recently used)
+     */
+    moveToFront(node) {
+        if (node === this.head)
+            return;
+        // Remove from current position
+        this.removeNode(node);
+        // Add to front
+        node.prev = null;
+        node.next = this.head;
+        if (this.head) {
+            this.head.prev = node;
+        }
+        this.head = node;
+        if (!this.tail) {
+            this.tail = node;
+        }
+    }
+    /**
+     * Remove a node from the linked list (but not from Map)
+     */
+    removeNode(node) {
+        if (node.prev) {
+            node.prev.next = node.next;
+        }
+        else {
+            this.head = node.next;
+        }
+        if (node.next) {
+            node.next.prev = node.prev;
+        }
+        else {
+            this.tail = node.prev;
+        }
+    }
+    /**
+     * Evict the least recently used item
+     */
+    evictLRU() {
+        if (!this.tail)
+            return;
+        const evicted = this.tail;
+        // Call eviction callback
+        if (this.onEvict) {
+            this.onEvict(evicted.key, evicted.value);
+        }
+        // Remove from list
+        this.removeNode(evicted);
+        this.cache.delete(evicted.key);
+        this._evictions++;
+    }
+}
+// CONVENIENCE FACTORIES
+/**
+ * Create a small LRU cache (100 items)
+ */
+export function createSmallCache(ttl = 0) {
+    return new LRUCache({ maxSize: 100, ttl });
+}
+/**
+ * Create a medium LRU cache (1000 items)
+ */
+export function createMediumCache(ttl = 0) {
+    return new LRUCache({ maxSize: 1000, ttl });
+}
+/**
+ * Create a large LRU cache (10000 items)
+ */
+export function createLargeCache(ttl = 0) {
+    return new LRUCache({ maxSize: 10000, ttl });
+}