@bitclaw/sqlite 1.1.0

package/dist/src/pool.js

@@ -0,0 +1,331 @@
+// packages/sqlite/src/pool.ts
+// SQLite Connection Pool with Worker Threads
+import { EventEmitter } from 'node:events';
+import { createRequire } from 'node:module';
+import { Worker } from 'node:worker_threads';
+// Use require.resolve to find worker.js from the package exports
+// This works correctly in both development and when bundled
+const require = createRequire(import.meta.url);
+class SQLiteConnectionPool extends EventEmitter {
+    workers = [];
+    maxWorkers;
+    workerTimeout;
+    databasePath;
+    pendingOperations = new Map();
+    nextWorkerIndex = 0;
+    isShuttingDown = false;
+    metrics = {
+        totalQueries: 0,
+        activeQueries: 0,
+        totalDuration: 0,
+        errors: 0,
+        workerStats: {}
+    };
+    constructor(config) {
+        super();
+        // Configuration from environment or config
+        this.maxWorkers =
+            config?.poolSize ??
+                Number.parseInt(process.env.SQLITE_POOL_SIZE ?? '4', 10);
+        this.workerTimeout =
+            config?.timeout ??
+                Number.parseInt(process.env.SQLITE_WORKER_TIMEOUT ?? '30000', 10);
+        this.databasePath = config?.databasePath;
+        this.initializePool();
+    }
+    initializePool() {
+        // Resolve worker path from package exports - works in both dev and bundled production
+        const workerPath = require.resolve('@bitclaw/sqlite/worker');
+        for (let i = 0; i < this.maxWorkers; i += 1) {
+            try {
+                const worker = new Worker(workerPath, {
+                    workerData: { databasePath: this.databasePath }
+                });
+                worker.on('message', this.handleWorkerMessage.bind(this));
+                worker.on('error', this.handleWorkerError.bind(this));
+                worker.on('exit', this.handleWorkerExit.bind(this, i));
+                this.workers.push(worker);
+            }
+            catch (error) {
+                console.error(`[pool] Failed to create worker ${i}:`, error);
+                throw error;
+            }
+        }
+    }
+    handleWorkerMessage(response) {
+        // Ignore shutdown responses
+        if (response.id.startsWith('shutdown-')) {
+            return;
+        }
+        const operation = this.pendingOperations.get(response.id);
+        if (!operation) {
+            console.warn(`[pool] Received response for unknown operation: ${response.id}`);
+            return;
+        }
+        // Clear timeout
+        clearTimeout(operation.timeout);
+        this.pendingOperations.delete(response.id);
+        // Update metrics
+        this.metrics.activeQueries -= 1;
+        const duration = Number(process.hrtime.bigint() - operation.startTime) / 1_000_000;
+        this.metrics.totalDuration += duration;
+        if (response.workerId) {
+            if (!this.metrics.workerStats[response.workerId]) {
+                this.metrics.workerStats[response.workerId] = {
+                    queries: 0,
+                    errors: 0,
+                    totalDuration: 0
+                };
+            }
+            const workerStat = this.metrics.workerStats[response.workerId];
+            workerStat.queries += 1;
+            workerStat.totalDuration += duration;
+        }
+        // Handle response
+        if (response.success && !response.error) {
+            operation.resolve(response.result);
+        }
+        else {
+            this.metrics.errors += 1;
+            if (response.workerId) {
+                this.metrics.workerStats[response.workerId].errors += 1;
+            }
+            const error = Object.assign(new Error(response.error?.message || 'Unknown SQLite error'), { code: response.error?.code, errno: response.error?.errno });
+            operation.reject(error);
+        }
+        // Emit metrics update
+        this.emit('metrics', this.getMetrics());
+    }
+    handleWorkerError(error) {
+        console.error('[pool] Worker error:', error);
+        this.metrics.errors += 1;
+        this.emit('error', error);
+    }
+    handleWorkerExit(workerIndex, code) {
+        if (this.isShuttingDown)
+            return;
+        console.warn(`[pool] Worker ${workerIndex} exited with code ${code}`);
+        this.emit('workerExit', { workerIndex, code });
+    }
+    /**
+     * Execute SQL query with parameters
+     */
+    async exec(sql, params = []) {
+        if (this.isShuttingDown) {
+            throw new Error('Connection pool is shutting down');
+        }
+        const id = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        const startTime = process.hrtime.bigint();
+        // Update metrics
+        this.metrics.totalQueries += 1;
+        this.metrics.activeQueries += 1;
+        return new Promise((resolve, reject) => {
+            // Set up timeout
+            const timeout = setTimeout(() => {
+                this.pendingOperations.delete(id);
+                this.metrics.activeQueries -= 1;
+                this.metrics.errors += 1;
+                reject(new Error(`SQLite operation timed out after ${this.workerTimeout}ms`));
+            }, this.workerTimeout);
+            // Store operation (cast resolve since the map is non-generic)
+            this.pendingOperations.set(id, {
+                resolve: resolve,
+                reject,
+                timeout,
+                sql,
+                startTime
+            });
+            // Send to worker using round-robin
+            const worker = this.workers[this.nextWorkerIndex];
+            this.nextWorkerIndex = (this.nextWorkerIndex + 1) % this.workers.length;
+            const message = { id, sql, params };
+            worker.postMessage(message);
+        });
+    }
+    /**
+     * Execute operations on a specific worker (for transactions)
+     */
+    async execOnWorker(workerIndex, sql, params = []) {
+        if (this.isShuttingDown) {
+            throw new Error('Connection pool is shutting down');
+        }
+        if (workerIndex >= this.workers.length) {
+            throw new Error(`Invalid worker index: ${workerIndex}`);
+        }
+        const id = `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+        const startTime = process.hrtime.bigint();
+        // Update metrics
+        this.metrics.totalQueries += 1;
+        this.metrics.activeQueries += 1;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingOperations.delete(id);
+                this.metrics.activeQueries -= 1;
+                this.metrics.errors += 1;
+                reject(new Error(`SQLite operation timed out after ${this.workerTimeout}ms`));
+            }, this.workerTimeout);
+            this.pendingOperations.set(id, {
+                resolve: resolve,
+                reject,
+                timeout,
+                sql,
+                startTime
+            });
+            // Send to specific worker
+            const worker = this.workers[workerIndex];
+            const message = { id, sql, params };
+            worker.postMessage(message);
+        });
+    }
+    /**
+     * Get current pool metrics
+     */
+    getMetrics() {
+        return {
+            ...this.metrics,
+            workerStats: { ...this.metrics.workerStats }
+        };
+    }
+    /**
+     * Get pool status for health checks
+     */
+    getStatus() {
+        return {
+            workers: this.workers.length,
+            activeQueries: this.metrics.activeQueries,
+            isShuttingDown: this.isShuttingDown,
+            totalQueries: this.metrics.totalQueries,
+            errorRate: this.metrics.totalQueries > 0
+                ? (this.metrics.errors / this.metrics.totalQueries) * 100
+                : 0,
+            avgDuration: this.metrics.totalQueries > 0
+                ? this.metrics.totalDuration / this.metrics.totalQueries
+                : 0
+        };
+    }
+    /**
+     * Graceful shutdown of the connection pool
+     */
+    async shutdown(timeoutMs = 5000) {
+        if (this.isShuttingDown)
+            return;
+        this.isShuttingDown = true;
+        // Wait for pending operations
+        const startTime = Date.now();
+        const checkPending = () => this.pendingOperations.size === 0;
+        while (!checkPending() && Date.now() - startTime < timeoutMs) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        // Send shutdown messages to workers
+        for (let i = 0; i < this.workers.length; i++) {
+            const worker = this.workers[i];
+            if (worker) {
+                const shutdownMessage = {
+                    id: `shutdown-${Date.now()}-${i}`,
+                    sql: '__SHUTDOWN__',
+                    params: []
+                };
+                try {
+                    worker.postMessage(shutdownMessage);
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                    await worker.terminate();
+                }
+                catch (error) {
+                    console.warn(`[pool] Error shutting down worker ${i}:`, error);
+                    await worker.terminate();
+                }
+            }
+        }
+        this.workers = [];
+        this.nextWorkerIndex = 0;
+        this.pendingOperations.clear();
+    }
+}
+// Singleton instance
+let pool = null;
+/**
+ * Create a new connection pool instance
+ */
+export function createPool(config) {
+    if (pool) {
+        throw new Error('Pool already exists. Call getPool() to retrieve it or shutdown() first.');
+    }
+    pool = new SQLiteConnectionPool(config);
+    return pool;
+}
+/**
+ * Get the singleton connection pool instance
+ */
+export function getPool() {
+    if (!pool) {
+        pool = new SQLiteConnectionPool();
+    }
+    return pool;
+}
+/**
+ * Execute SQL query using the connection pool
+ */
+export async function exec(sql, params = []) {
+    return getPool().exec(sql, params);
+}
+/**
+ * Get pool metrics for monitoring
+ */
+export function getPoolMetrics() {
+    return getPool().getMetrics();
+}
+/**
+ * Get pool status for health checks
+ */
+export function getPoolStatus() {
+    return getPool().getStatus();
+}
+/**
+ * Shutdown the connection pool
+ */
+export async function shutdownPool(timeoutMs) {
+    if (pool) {
+        if (!pool.getStatus().isShuttingDown) {
+            try {
+                await exec('PRAGMA wal_checkpoint(TRUNCATE)');
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.warn('[pool] WAL checkpoint skipped:', errorMessage);
+            }
+        }
+        await pool.shutdown(timeoutMs);
+        pool = null;
+    }
+}
+/**
+ * Execute multiple operations atomically on a single worker
+ */
+export async function withTransaction(operation) {
+    // Use first worker for all transaction operations
+    const workerIndex = 0;
+    const poolInstance = getPool();
+    // Create a transaction-scoped execute function
+    const executeInTransaction = async (sql, params = []) => {
+        return poolInstance.execOnWorker(workerIndex, sql, params);
+    };
+    let success = false;
+    try {
+        await executeInTransaction('BEGIN IMMEDIATE');
+        const result = await operation(executeInTransaction);
+        await executeInTransaction('COMMIT');
+        success = true;
+        return result;
+    }
+    catch (error) {
+        if (!success) {
+            try {
+                await executeInTransaction('ROLLBACK');
+            }
+            catch (rollbackError) {
+                console.error('[tx] Rollback failed:', rollbackError);
+            }
+        }
+        throw error;
+    }
+}

package/dist/src/prisma-immediate-tx.d.ts

@@ -0,0 +1,23 @@
+type PrismaClientLike = {
+    $executeRawUnsafe: (sql: string) => Promise<number>;
+    $queryRawUnsafe: (sql: string) => Promise<unknown>;
+};
+/**
+ * Execute a Prisma callback within a BEGIN IMMEDIATE transaction.
+ *
+ * The libsql adapter uses a single connection per PrismaClient, so raw SQL
+ * (BEGIN/COMMIT/ROLLBACK) participates in the same connection state as
+ * Prisma's query builder. This means we can safely mix raw transaction
+ * control with Prisma model operations.
+ *
+ * @example
+ * ```typescript
+ * const [response] = await immediateTransaction(prisma, async () => [
+ *   await prisma.gptResponse.create({ data: { userId, content } }),
+ *   await prisma.user.update({ where: { id: userId }, data: { credits: { decrement: 1 } } }),
+ * ]);
+ * ```
+ */
+export declare function immediateTransaction<T>(client: PrismaClientLike, fn: () => Promise<T>): Promise<T>;
+export {};
+//# sourceMappingURL=prisma-immediate-tx.d.ts.map

package/dist/src/prisma-immediate-tx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prisma-immediate-tx.d.ts","sourceRoot":"","sources":["../../src/prisma-immediate-tx.ts"],"names":[],"mappings":"AAUA,KAAK,gBAAgB,GAAG;IACtB,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IACpD,eAAe,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACpD,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,MAAM,EAAE,gBAAgB,EACxB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAeZ"}

package/dist/src/prisma-immediate-tx.js

@@ -0,0 +1,42 @@
+// packages/sqlite/src/prisma-immediate-tx.ts
+// BEGIN IMMEDIATE transaction wrapper for Prisma with libsql adapter
+//
+// Prisma's $transaction() uses BEGIN DEFERRED by default. When a deferred
+// transaction tries to upgrade from read to write lock, SQLite returns
+// SQLITE_BUSY *immediately* — bypassing busy_timeout entirely.
+//
+// This helper wraps writes in BEGIN IMMEDIATE via $executeRawUnsafe,
+// which acquires the write lock upfront and respects busy_timeout.
+/**
+ * Execute a Prisma callback within a BEGIN IMMEDIATE transaction.
+ *
+ * The libsql adapter uses a single connection per PrismaClient, so raw SQL
+ * (BEGIN/COMMIT/ROLLBACK) participates in the same connection state as
+ * Prisma's query builder. This means we can safely mix raw transaction
+ * control with Prisma model operations.
+ *
+ * @example
+ * ```typescript
+ * const [response] = await immediateTransaction(prisma, async () => [
+ *   await prisma.gptResponse.create({ data: { userId, content } }),
+ *   await prisma.user.update({ where: { id: userId }, data: { credits: { decrement: 1 } } }),
+ * ]);
+ * ```
+ */
+export async function immediateTransaction(client, fn) {
+    await client.$executeRawUnsafe('BEGIN IMMEDIATE');
+    try {
+        const result = await fn();
+        await client.$executeRawUnsafe('COMMIT');
+        return result;
+    }
+    catch (error) {
+        try {
+            await client.$executeRawUnsafe('ROLLBACK');
+        }
+        catch {
+            // Rollback may fail if the connection is already aborted
+        }
+        throw error;
+    }
+}

package/dist/src/query-logger.d.ts

@@ -0,0 +1,21 @@
+import type { Database } from 'bun:sqlite';
+export type QueryLoggerOptions = {
+    /** Label shown in log output, e.g. workspace ID or database name. */
+    label?: string;
+};
+/**
+ * Wrap a bun:sqlite Database with query logging.
+ *
+ * In development, every `query()`, `prepare()`, `run()`, and `exec()` call
+ * logs the SQL to stdout in a format consistent with Prisma's `prisma:query`:
+ *
+ *   sqlite:query [label] SELECT * FROM servers WHERE id = ?
+ *
+ * In production, returns the database unchanged (zero overhead).
+ *
+ * Usage — always wrap, logging auto-enables in dev:
+ *
+ *   const db = wrapWithQueryLogging(new Database(path), { label: 'ws:abc123' });
+ */
+export declare function wrapWithQueryLogging<T extends Database>(db: T, options?: QueryLoggerOptions): T;
+//# sourceMappingURL=query-logger.d.ts.map

package/dist/src/query-logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-logger.d.ts","sourceRoot":"","sources":["../../src/query-logger.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAaF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EACrD,EAAE,EAAE,CAAC,EACL,OAAO,GAAE,kBAAuB,GAC/B,CAAC,CAsCH"}

package/dist/src/query-logger.js

@@ -0,0 +1,60 @@
+// packages/sqlite/src/query-logger.ts
+// Dev-mode query logging for bun:sqlite — mirrors Prisma's `prisma:query` output.
+// Wraps a Database with a transparent Proxy that logs SQL on query/run/exec/prepare.
+// Zero overhead in production: returns the database as-is when NODE_ENV !== 'development'.
+// biome-ignore lint/suspicious/noConsole: intentional dev-mode query logging (mirrors Prisma's log: ['query'])
+const log = console.log;
+const isDev = process.env.NODE_ENV === 'development';
+// ANSI green for the prefix — contrasts with Prisma's blue `prisma:query`
+const GREEN = '\x1b[32m';
+const RESET = '\x1b[0m';
+const formatSql = (sql) => sql.replace(/\s+/g, ' ').trim();
+/**
+ * Wrap a bun:sqlite Database with query logging.
+ *
+ * In development, every `query()`, `prepare()`, `run()`, and `exec()` call
+ * logs the SQL to stdout in a format consistent with Prisma's `prisma:query`:
+ *
+ *   sqlite:query [label] SELECT * FROM servers WHERE id = ?
+ *
+ * In production, returns the database unchanged (zero overhead).
+ *
+ * Usage — always wrap, logging auto-enables in dev:
+ *
+ *   const db = wrapWithQueryLogging(new Database(path), { label: 'ws:abc123' });
+ */
+export function wrapWithQueryLogging(db, options = {}) {
+    if (!isDev)
+        return db;
+    const { label } = options;
+    const prefix = label
+        ? `${GREEN}sqlite:query${RESET} [${label}]`
+        : `${GREEN}sqlite:query${RESET}`;
+    return new Proxy(db, {
+        get(target, prop, receiver) {
+            const value = Reflect.get(target, prop, receiver);
+            if (typeof value !== 'function')
+                return value;
+            if (prop === 'query' || prop === 'prepare') {
+                return (sql) => {
+                    log(`${prefix} ${formatSql(sql)}`);
+                    return value.call(target, sql);
+                };
+            }
+            if (prop === 'run') {
+                return (sql, ...params) => {
+                    log(`${prefix} ${formatSql(sql)}`);
+                    return value.call(target, sql, ...params);
+                };
+            }
+            if (prop === 'exec') {
+                return (sql) => {
+                    log(`${prefix} ${formatSql(sql)}`);
+                    return value.call(target, sql);
+                };
+            }
+            // Bind all other methods to the real target
+            return value.bind(target);
+        }
+    });
+}

package/dist/src/retry.d.ts

@@ -0,0 +1,14 @@
+type RetryOptions = {
+    maxAttempts?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+};
+declare const isBusyError: (error: unknown) => boolean;
+/**
+ * Execute a function with retry logic for SQLITE_BUSY errors.
+ * Uses exponential backoff with jitter to avoid thundering herd.
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+export type { RetryOptions };
+export { isBusyError };
+//# sourceMappingURL=retry.d.ts.map

package/dist/src/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/retry.ts"],"names":[],"mappings":"AAGA,KAAK,YAAY,GAAG;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAQF,QAAA,MAAM,WAAW,GAAI,OAAO,OAAO,KAAG,OAQrC,CAAC;AAeF;;;GAGG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,CAAC,CAAC,CA4BZ;AAED,YAAY,EAAE,YAAY,EAAE,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/src/retry.js

@@ -0,0 +1,49 @@
+// packages/sqlite/src/retry.ts
+// Retry with exponential backoff for SQLITE_BUSY errors
+const DEFAULT_OPTIONS = {
+    maxAttempts: 3,
+    baseDelayMs: 100,
+    maxDelayMs: 2000
+};
+const isBusyError = (error) => {
+    if (!(error instanceof Error))
+        return false;
+    const message = error.message.toLowerCase();
+    return (message.includes('database is locked') ||
+        message.includes('sqlite_busy') ||
+        ('code' in error && error.code === 'SQLITE_BUSY'));
+};
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+const calculateDelay = (attempt, baseDelayMs, maxDelayMs) => {
+    const exponentialDelay = baseDelayMs * 2 ** attempt;
+    const jitter = Math.random() * baseDelayMs;
+    return Math.min(exponentialDelay + jitter, maxDelayMs);
+};
+/**
+ * Execute a function with retry logic for SQLITE_BUSY errors.
+ * Uses exponential backoff with jitter to avoid thundering herd.
+ */
+export async function withRetry(fn, options) {
+    const { maxAttempts, baseDelayMs, maxDelayMs } = {
+        ...DEFAULT_OPTIONS,
+        ...options
+    };
+    let lastError;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (!isBusyError(error) || attempt === maxAttempts - 1) {
+                throw error;
+            }
+            const delay = calculateDelay(attempt, baseDelayMs, maxDelayMs);
+            console.warn(`[sqlite] SQLITE_BUSY on attempt ${attempt + 1}/${maxAttempts}, retrying in ${Math.round(delay)}ms`);
+            await sleep(delay);
+        }
+    }
+    // Should never reach here, but TypeScript needs it
+    throw lastError;
+}
+export { isBusyError };

package/dist/src/ttl-cache.d.ts

@@ -0,0 +1,57 @@
+export type TTLCacheOptions = {
+    /** Time-to-live in milliseconds. Default: 30_000 (30s). */
+    ttl?: number;
+    /** Maximum entries before auto-pruning expired items. Default: 100. */
+    maxSize?: number;
+};
+/**
+ * In-memory TTL cache backed by a Map.
+ *
+ * Designed for server-side deduplication of expensive lookups (auth sessions,
+ * membership checks, bootstrap data) across HTTP requests. Entries expire
+ * after `ttl` milliseconds and are automatically pruned when the map exceeds
+ * `maxSize`.
+ *
+ * Unlike WeakMap per-request caching (which deduplicates within a single
+ * request), TTLCache deduplicates across requests — e.g. when TanStack
+ * Router replays `beforeLoad` on client hydration, the server returns the
+ * cached result instantly (0 DB queries).
+ *
+ * @example
+ * ```typescript
+ * import { TTLCache } from '@bitclaw/sqlite/ttl-cache';
+ *
+ * type BootstrapData = { user: User; workspaces: Workspace[] };
+ *
+ * const bootstrapCache = new TTLCache<BootstrapData>({ ttl: 30_000 });
+ *
+ * // In your server function:
+ * const cached = bootstrapCache.get(sessionId);
+ * if (cached) return cached;
+ *
+ * const data = await expensiveQuery();
+ * bootstrapCache.set(sessionId, data);
+ * return data;
+ * ```
+ */
+export declare class TTLCache<T> {
+    private cache;
+    private ttl;
+    private maxSize;
+    constructor(options?: TTLCacheOptions);
+    /** Get a cached value if it exists and hasn't expired. */
+    get(key: string): T | undefined;
+    /** Check if a non-expired entry exists for the given key. */
+    has(key: string): boolean;
+    /** Store a value with the configured TTL. Auto-prunes if maxSize exceeded. */
+    set(key: string, value: T): void;
+    /** Remove a specific entry. */
+    delete(key: string): boolean;
+    /** Remove all entries. */
+    clear(): void;
+    /** Number of entries (including potentially expired ones). */
+    get size(): number;
+    /** Remove all expired entries. */
+    prune(): number;
+}
+//# sourceMappingURL=ttl-cache.d.ts.map

package/dist/src/ttl-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttl-cache.d.ts","sourceRoot":"","sources":["../../src/ttl-cache.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,eAAe,GAAG;IAC5B,2DAA2D;IAC3D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,CAAC,KAAK,CAAoC;IACjD,OAAO,CAAC,GAAG,CAAS;IACpB,OAAO,CAAC,OAAO,CAAS;gBAEZ,OAAO,GAAE,eAAoB;IAKzC,0DAA0D;IAC1D,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAU/B,6DAA6D;IAC7D,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,8EAA8E;IAC9E,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAWhC,+BAA+B;IAC/B,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAI5B,0BAA0B;IAC1B,KAAK,IAAI,IAAI;IAIb,8DAA8D;IAC9D,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,kCAAkC;IAClC,KAAK,IAAI,MAAM;CAWhB"}