@pioneer-platform/pioneer-cache 1.19.3 → 1.22.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> @pioneer-platform/pioneer-cache@1.19.3 build /Users/highlander/WebstormProjects/keepkey-stack/projects/pioneer/modules/pioneer/pioneer-cache
+> @pioneer-platform/pioneer-cache@1.21.0 build /Users/highlander/WebstormProjects/keepkey-stack/projects/pioneer/modules/pioneer/pioneer-cache
 > tsc
 

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @pioneer-platform/pioneer-cache
 
+## 1.22.0
+
+### Minor Changes
+
+- chore: feat(e2e): add blue API support to swap roundtrip tests
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/pioneer-discovery@8.44.0
+
+## 1.21.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @pioneer-platform/pioneer-discovery@8.43.0
+
+## 1.21.0
+
+### Minor Changes
+
+- feat(monorepo): production release preparation with strict TypeScript and enhanced swap functionality
+
+## 1.20.0
+
+### Minor Changes
+
+- feat(pioneer-client): add client-side host override for staging/blue testing
+
 ## 1.19.3
 
 ### Patch Changes

package/dist/core/cache-manager.d.ts

@@ -38,12 +38,18 @@ export declare class CacheManager {
     private stakingCache?;
     private zapperCache?;
     private workers;
+    private staleScanner?;
     constructor(config: CacheManagerConfig);
     /**
      * Purge all pending jobs from the cache refresh queue
      * Used in local dev to clear stale jobs on startup
      */
     purgeQueue(queueName?: string): Promise<void>;
+    /**
+     * Purge unsupported job types from the queue
+     * Scans the queue and removes jobs for cache types that aren't enabled
+     */
+    purgeUnsupportedJobs(queueName?: string): Promise<void>;
     /**
      * Start background refresh workers for all caches
      */

package/dist/core/cache-manager.js

@@ -14,6 +14,7 @@ const transaction_cache_1 = require("../stores/transaction-cache");
 const staking_cache_1 = require("../stores/staking-cache");
 const zapper_cache_1 = require("../stores/zapper-cache");
 const refresh_worker_1 = require("../workers/refresh-worker");
+const stale_balance_scanner_1 = require("../workers/stale-balance-scanner");
 const log = require('@pioneer-platform/loggerdog')();
 const TAG = ' | CacheManager | ';
 /**
@@ -103,6 +104,73 @@ class CacheManager {
             throw error;
         }
     }
+    /**
+     * Purge unsupported job types from the queue
+     * Scans the queue and removes jobs for cache types that aren't enabled
+     */
+    async purgeUnsupportedJobs(queueName = 'cache-refresh') {
+        const tag = TAG + 'purgeUnsupportedJobs | ';
+        try {
+            const redisQueue = this.redisQueue;
+            let purgedCount = 0;
+            let scannedCount = 0;
+            log.info(tag, `Scanning queue for unsupported job types...`);
+            // Get enabled cache types
+            const enabledCaches = new Set();
+            if (this.balanceCache)
+                enabledCaches.add('balance');
+            if (this.priceCache)
+                enabledCaches.add('price');
+            if (this.portfolioCache)
+                enabledCaches.add('portfolio');
+            if (this.transactionCache)
+                enabledCaches.add('transaction');
+            if (this.stakingCache)
+                enabledCaches.add('staking');
+            if (this.zapperCache)
+                enabledCaches.add('zapper');
+            log.info(tag, `Enabled caches: ${Array.from(enabledCaches).join(', ') || 'NONE'}`);
+            // Get queue length
+            const queueLength = await redisQueue.count(queueName);
+            if (queueLength === 0) {
+                log.info(tag, '✅ Queue is empty, no jobs to purge');
+                return;
+            }
+            log.info(tag, `Found ${queueLength} jobs in queue`);
+            // Scan all jobs
+            const tempJobs = [];
+            for (let i = 0; i < queueLength; i++) {
+                const job = await redisQueue.getWork(queueName, 1);
+                if (!job)
+                    break;
+                scannedCount++;
+                const jobType = job.type || '';
+                const cacheName = jobType.replace('REFRESH_', '').toLowerCase();
+                if (!enabledCaches.has(cacheName)) {
+                    purgedCount++;
+                    log.warn(tag, `   Purged unsupported job: ${jobType} (cache "${cacheName}" not enabled)`);
+                }
+                else {
+                    // Keep supported jobs - we'll re-queue them
+                    tempJobs.push(job);
+                }
+            }
+            // Re-queue supported jobs
+            for (const job of tempJobs) {
+                await redisQueue.createWork(queueName, job);
+            }
+            if (purgedCount > 0) {
+                log.info(tag, `✅ Purged ${purgedCount} unsupported jobs (scanned ${scannedCount})`);
+            }
+            else {
+                log.info(tag, `✅ No unsupported jobs found (scanned ${scannedCount})`);
+            }
+        }
+        catch (error) {
+            log.error(tag, '⚠️ Error during unsupported job purge (non-fatal):', error);
+            // Don't throw - purge failure shouldn't prevent system from starting
+        }
+    }
     /**
      * Start background refresh workers for all caches
      */
@@ -110,6 +178,8 @@ class CacheManager {
         const tag = TAG + 'startWorkers | ';
         try {
             log.info(tag, 'Starting refresh workers...');
+            // FIX: Purge unsupported job types before starting workers
+            await this.purgeUnsupportedJobs('cache-refresh');
             // Create cache registry for workers
             const cacheRegistry = new Map();
             if (this.balanceCache) {
@@ -139,6 +209,17 @@ class CacheManager {
                 this.workers.push(worker);
                 log.info(tag, '✅ Refresh worker started for all caches');
             }
+            // Start stale balance scanner if balance cache is enabled
+            if (this.balanceCache) {
+                this.staleScanner = new stale_balance_scanner_1.StaleBalanceScanner(this.redis, this.balanceCache, {
+                    staleThresholdMs: 60 * 60 * 1000, // 1 hour (more aggressive than the 5min reactive threshold)
+                    scanIntervalMs: 10 * 60 * 1000, // Scan every 10 minutes
+                    batchSize: 100,
+                    maxRefreshPerScan: 50
+                });
+                await this.staleScanner.start();
+                log.info(tag, '✅ Stale balance scanner started');
+            }
         }
         catch (error) {
             log.error(tag, '❌ Failed to start workers:', error);
@@ -155,6 +236,10 @@ class CacheManager {
             for (const worker of this.workers) {
                 await worker.stop();
             }
+            if (this.staleScanner) {
+                await this.staleScanner.stop();
+                this.staleScanner = undefined;
+            }
             this.workers = [];
             log.info(tag, '✅ All workers stopped');
         }

package/dist/stores/balance-cache.d.ts

@@ -58,9 +58,12 @@ export declare class BalanceCache extends BaseCache<BalanceData> {
      *
      * CRITICAL FIX: When waitForFresh=true (forceRefresh), bypass cache entirely
      * and fetch fresh blockchain data for ALL items, not just cache misses
+     *
+     * PERFORMANCE FIX: When skipAsyncRefresh=true, disable background refresh jobs
+     * to prevent 50+ individual refresh jobs from being queued
      */
     getBatchBalances(items: Array<{
         caip: string;
         pubkey: string;
-    }>, waitForFresh?: boolean): Promise<BalanceData[]>;
+    }>, waitForFresh?: boolean, skipAsyncRefresh?: boolean): Promise<BalanceData[]>;
 }

package/dist/stores/balance-cache.js

@@ -12,6 +12,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BalanceCache = void 0;
 const base_cache_1 = require("../core/base-cache");
 const crypto_1 = __importDefault(require("crypto"));
+const pioneer_discovery_1 = require("@pioneer-platform/pioneer-discovery");
+const pioneer_caip_1 = require("@pioneer-platform/pioneer-caip");
 const log = require('@pioneer-platform/loggerdog')();
 /**
  * Hash pubkey/xpub for privacy-protecting cache keys
@@ -110,11 +112,18 @@ class BalanceCache extends base_cache_1.BaseCache {
             const owner = { pubkey };
             const balanceInfo = await this.balanceModule.getBalance(asset, owner);
             if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
+                // CRITICAL FIX: Distinguish between legitimate zero balance and failed API call
+                // Failed API calls should NOT be cached as valid "0" balance
+                const errorMsg = balanceInfo?.error || 'No balance data returned';
+                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)} - ${errorMsg}`);
+                // If balanceInfo explicitly indicates an error, throw it instead of caching "0"
+                if (balanceInfo?.error || balanceInfo === null || balanceInfo === undefined) {
+                    throw new Error(`Failed to fetch balance for ${caip}: ${errorMsg}`);
+                }
+                // Otherwise, this is a legitimate zero balance (balanceInfo exists but balance is falsy)
                 const now = Date.now();
                 // Get asset metadata even for zero balances
-                const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-                const assetInfo = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()] || {};
+                const assetInfo = pioneer_discovery_1.assetData[caip.toUpperCase()] || pioneer_discovery_1.assetData[caip.toLowerCase()] || {};
                 return {
                     caip,
                     pubkey,
@@ -122,14 +131,13 @@ class BalanceCache extends base_cache_1.BaseCache {
                     decimals: assetInfo.decimals,
                     precision: assetInfo.decimals, // Set precision to decimals for compatibility
                     fetchedAt: now,
-                    fetchedAtISO: new Date(now).toISOString()
+                    fetchedAtISO: new Date(now).toISOString(),
+                    dataSource: 'Zero balance (legitimate)'
                 };
             }
             // Get asset metadata
-            const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-            const { caipToNetworkId } = require('@pioneer-platform/pioneer-caip');
-            const assetInfo = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()] || {};
-            const networkId = caipToNetworkId(caip);
+            const assetInfo = pioneer_discovery_1.assetData[caip.toUpperCase()] || pioneer_discovery_1.assetData[caip.toLowerCase()] || {};
+            const networkId = (0, pioneer_caip_1.caipToNetworkId)(caip);
             // Use actual node URL if available, otherwise construct generic description
             let dataSource = 'Unknown';
             if (balanceInfo.nodeUrl) {
@@ -187,8 +195,7 @@ class BalanceCache extends base_cache_1.BaseCache {
         const tag = this.TAG + 'getLegacyCached | ';
         try {
             const { caip, pubkey } = params;
-            const { caipToNetworkId } = require('@pioneer-platform/pioneer-caip');
-            const networkId = caipToNetworkId(caip);
+            const networkId = (0, pioneer_caip_1.caipToNetworkId)(caip);
             // Try legacy format: cache:balance:pubkey:asset
             const legacyKey = `cache:balance:${pubkey}:${networkId}`;
             const legacyData = await this.redis.get(legacyKey);
@@ -229,8 +236,11 @@ class BalanceCache extends base_cache_1.BaseCache {
      *
      * CRITICAL FIX: When waitForFresh=true (forceRefresh), bypass cache entirely
      * and fetch fresh blockchain data for ALL items, not just cache misses
+     *
+     * PERFORMANCE FIX: When skipAsyncRefresh=true, disable background refresh jobs
+     * to prevent 50+ individual refresh jobs from being queued
      */
-    async getBatchBalances(items, waitForFresh) {
+    async getBatchBalances(items, waitForFresh, skipAsyncRefresh) {
         const tag = this.TAG + 'getBatchBalances | ';
         const startTime = Date.now();
         try {
@@ -347,12 +357,17 @@ class BalanceCache extends base_cache_1.BaseCache {
                     await Promise.all(fetchPromises);
                     log.info(tag, `Fetched ${missedItems.length} misses in ${Date.now() - fetchStart}ms`);
                 }
-                else {
-                    // Non-blocking: trigger background refresh for misses
+                else if (!skipAsyncRefresh) {
+                    // Non-blocking: trigger background refresh for misses (unless disabled)
+                    log.info(tag, `📋 Queueing ${missedItems.length} background refresh jobs for cache misses`);
                     missedItems.forEach(item => {
                         this.triggerAsyncRefresh({ caip: item.caip, pubkey: item.pubkey }, 'high');
                     });
                 }
+                else {
+                    // Background refresh disabled for performance
+                    log.info(tag, `⚡ PERFORMANCE MODE: Skipping ${missedItems.length} background refresh jobs (skipAsyncRefresh=true)`);
+                }
             }
             return results;
         }

package/dist/workers/refresh-worker.d.ts

@@ -29,6 +29,11 @@ export declare class RefreshWorker {
      * Start processing jobs from the queue
      */
     start(): Promise<void>;
+    /**
+     * Purge stale jobs from queue on startup
+     * Scans queue and removes jobs older than 1 hour
+     */
+    private purgeStaleJobsOnStartup;
     /**
      * Stop the worker gracefully
      */

package/dist/workers/refresh-worker.js

@@ -49,10 +49,66 @@ class RefreshWorker {
         }
         log.info(tag, `🚀 Starting refresh worker for queue: ${this.config.queueName}`);
         log.info(tag, `Registered caches: ${Array.from(this.cacheRegistry.keys()).join(', ')}`);
+        // FIX #3: Purge stale jobs at startup
+        await this.purgeStaleJobsOnStartup();
         this.isRunning = true;
         this.poll();
         log.info(tag, '✅ Refresh worker started successfully');
     }
+    /**
+     * Purge stale jobs from queue on startup
+     * Scans queue and removes jobs older than 1 hour
+     */
+    async purgeStaleJobsOnStartup() {
+        const tag = TAG + 'purgeStaleJobsOnStartup | ';
+        try {
+            const MAX_JOB_AGE_MS = 60 * 60 * 1000; // 1 hour
+            const now = Date.now();
+            let purgedCount = 0;
+            let scannedCount = 0;
+            log.info(tag, `Scanning queue for stale jobs (age > ${MAX_JOB_AGE_MS / 1000}s)...`);
+            // Get queue length
+            const queueLength = await this.redisQueue.count(this.config.queueName);
+            if (queueLength === 0) {
+                log.info(tag, '✅ Queue is empty, no stale jobs to purge');
+                return;
+            }
+            log.info(tag, `Found ${queueLength} jobs in queue, checking for stale jobs...`);
+            // Scan up to 100 jobs to find stale ones
+            const MAX_SCAN = Math.min(queueLength, 100);
+            const tempJobs = [];
+            for (let i = 0; i < MAX_SCAN; i++) {
+                const job = await this.redisQueue.getWork(this.config.queueName, 1);
+                if (!job)
+                    break;
+                scannedCount++;
+                const jobTimestamp = job.timestamp || 0;
+                const jobAge = jobTimestamp > 0 ? now - jobTimestamp : 0;
+                if (jobAge > MAX_JOB_AGE_MS) {
+                    purgedCount++;
+                    log.warn(tag, `   Purged stale job: ${job.type} (age: ${Math.round(jobAge / 1000)}s)`);
+                }
+                else {
+                    // Keep fresh jobs - we'll re-queue them
+                    tempJobs.push(job);
+                }
+            }
+            // Re-queue fresh jobs
+            for (const job of tempJobs) {
+                await this.redisQueue.createWork(this.config.queueName, job);
+            }
+            if (purgedCount > 0) {
+                log.info(tag, `✅ Purged ${purgedCount} stale jobs (scanned ${scannedCount})`);
+            }
+            else {
+                log.info(tag, `✅ No stale jobs found (scanned ${scannedCount})`);
+            }
+        }
+        catch (error) {
+            log.error(tag, '⚠️ Error during startup purge (non-fatal):', error);
+            // Don't throw - startup purge failure shouldn't prevent worker from starting
+        }
+    }
     /**
      * Stop the worker gracefully
      */
@@ -130,12 +186,30 @@ class RefreshWorker {
         try {
             const { type, key, params, retryCount = 0 } = job;
             log.info(tag, `Processing ${type} for ${key} (retry: ${retryCount})`);
+            // FIX #1: Check job age and drop if too old (>1 hour)
+            const MAX_JOB_AGE_MS = 60 * 60 * 1000; // 1 hour
+            const jobAge = Date.now() - startTime;
+            const jobTimestamp = job.timestamp || 0;
+            if (jobTimestamp > 0) {
+                const actualJobAge = Date.now() - jobTimestamp;
+                if (actualJobAge > MAX_JOB_AGE_MS) {
+                    log.error(tag, `⚠️ DROPPING STALE JOB: ${type} (age: ${Math.round(actualJobAge / 1000)}s, max: ${MAX_JOB_AGE_MS / 1000}s)`);
+                    log.error(tag, `   Job key: ${key}`);
+                    log.error(tag, `   Job has been removed from queue and will not be retried`);
+                    return;
+                }
+            }
             // Extract cache name from job type (e.g., "REFRESH_BALANCE" -> "balance")
             const cacheName = type.replace('REFRESH_', '').toLowerCase();
             // Get the appropriate cache instance
             const cache = this.cacheRegistry.get(cacheName);
+            // FIX #2: Drop unsupported job types with clear error message
             if (!cache) {
-                log.error(tag, `No cache registered for type: ${type}`);
+                log.error(tag, `❌ DROPPING UNSUPPORTED JOB: ${type}`);
+                log.error(tag, `   Cache type "${cacheName}" is not registered in this worker`);
+                log.error(tag, `   Registered caches: ${Array.from(this.cacheRegistry.keys()).join(', ') || 'NONE'}`);
+                log.error(tag, `   Job key: ${key}`);
+                log.error(tag, `   Job has been removed from queue and will not be retried`);
                 return;
             }
             // Fetch fresh data using the cache's fetchFresh method

package/dist/workers/stale-balance-scanner.d.ts

@@ -0,0 +1,35 @@
+import type { BalanceCache } from '../stores/balance-cache';
+export interface StaleScannerConfig {
+    staleThresholdMs: number;
+    scanIntervalMs: number;
+    batchSize: number;
+    maxRefreshPerScan: number;
+}
+export declare class StaleBalanceScanner {
+    private redis;
+    private balanceCache;
+    private config;
+    private isRunning;
+    private scanTimer?;
+    constructor(redis: any, balanceCache: BalanceCache, config?: Partial<StaleScannerConfig>);
+    /**
+     * Start the scanner
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scanner
+     */
+    stop(): Promise<void>;
+    /**
+     * Schedule next scan
+     */
+    private scheduleNextScan;
+    /**
+     * Scan for stale balances and queue refreshes
+     */
+    private scan;
+    /**
+     * Get scanner statistics
+     */
+    getStats(): any;
+}

package/dist/workers/stale-balance-scanner.js

@@ -0,0 +1,180 @@
+"use strict";
+/*
+    Stale Balance Scanner
+
+    Proactively scans for stale balance cache entries and queues them for refresh.
+    This ensures balances that aren't actively accessed still get refreshed.
+
+    Prevents the issue where stale balances sit for days/weeks without being updated.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleBalanceScanner = void 0;
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | StaleBalanceScanner | ';
+class StaleBalanceScanner {
+    constructor(redis, balanceCache, config) {
+        this.isRunning = false;
+        this.redis = redis;
+        this.balanceCache = balanceCache;
+        this.config = {
+            staleThresholdMs: config?.staleThresholdMs || 60 * 60 * 1000, // 1 hour
+            scanIntervalMs: config?.scanIntervalMs || 5 * 60 * 1000, // 5 minutes
+            batchSize: config?.batchSize || 100,
+            maxRefreshPerScan: config?.maxRefreshPerScan || 50
+        };
+        log.info(TAG, 'Stale balance scanner initialized', {
+            staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+            scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60)
+        });
+    }
+    /**
+     * Start the scanner
+     */
+    async start() {
+        const tag = TAG + 'start | ';
+        if (this.isRunning) {
+            log.warn(tag, 'Scanner already running');
+            return;
+        }
+        this.isRunning = true;
+        log.info(tag, '🔍 Starting stale balance scanner');
+        // Run first scan immediately, then schedule recurring
+        await this.scan();
+        this.scheduleNextScan();
+    }
+    /**
+     * Stop the scanner
+     */
+    async stop() {
+        const tag = TAG + 'stop | ';
+        log.info(tag, 'Stopping stale balance scanner');
+        this.isRunning = false;
+        if (this.scanTimer) {
+            clearTimeout(this.scanTimer);
+            this.scanTimer = undefined;
+        }
+        log.info(tag, '✅ Scanner stopped');
+    }
+    /**
+     * Schedule next scan
+     */
+    scheduleNextScan() {
+        if (!this.isRunning)
+            return;
+        this.scanTimer = setTimeout(async () => {
+            await this.scan();
+            this.scheduleNextScan();
+        }, this.config.scanIntervalMs);
+    }
+    /**
+     * Scan for stale balances and queue refreshes
+     */
+    async scan() {
+        const tag = TAG + 'scan | ';
+        const startTime = Date.now();
+        try {
+            log.info(tag, 'Starting stale balance scan...');
+            // Scan balance_v2:* keys in batches
+            const pattern = 'balance_v2:*';
+            const staleKeys = [];
+            const now = Date.now();
+            let cursor = '0';
+            let totalScanned = 0;
+            let refreshCount = 0;
+            do {
+                // SCAN with COUNT for batching
+                const [nextCursor, keys] = await this.redis.scan(cursor, 'MATCH', pattern, 'COUNT', this.config.batchSize);
+                cursor = nextCursor;
+                totalScanned += keys.length;
+                // Check each key for staleness
+                for (const key of keys) {
+                    try {
+                        const cached = await this.redis.get(key);
+                        if (!cached)
+                            continue;
+                        const parsed = JSON.parse(cached);
+                        const age = now - (parsed.timestamp || 0);
+                        // Check if stale
+                        if (age > this.config.staleThresholdMs) {
+                            staleKeys.push(key);
+                            // Stop if we've hit max refresh limit
+                            if (staleKeys.length >= this.config.maxRefreshPerScan) {
+                                log.info(tag, `Reached max refresh limit (${this.config.maxRefreshPerScan}), stopping scan`);
+                                cursor = '0'; // Force exit
+                                break;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        log.error(tag, `Error checking key ${key}:`, error);
+                    }
+                }
+            } while (cursor !== '0' && this.isRunning);
+            // Queue refresh for stale balances
+            if (staleKeys.length > 0) {
+                log.info(tag, `Found ${staleKeys.length} stale balances out of ${totalScanned} scanned`);
+                for (const key of staleKeys) {
+                    try {
+                        // Extract CAIP and pubkey hash from key
+                        // Key format: balance_v2:caip:hashedPubkey
+                        // IMPORTANT: CAIP itself contains colons (e.g., ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144)
+                        // So we must split from the right to get hashedPubkey, then everything else is the CAIP
+                        const withoutPrefix = key.replace('balance_v2:', '');
+                        const lastColonIndex = withoutPrefix.lastIndexOf(':');
+                        if (lastColonIndex === -1)
+                            continue;
+                        const caip = withoutPrefix.substring(0, lastColonIndex);
+                        const pubkeyHash = withoutPrefix.substring(lastColonIndex + 1);
+                        // We need the original pubkey to refresh, but it's hashed in the key
+                        // So we need to get it from the cached value
+                        const cached = await this.redis.get(key);
+                        if (!cached)
+                            continue;
+                        const parsed = JSON.parse(cached);
+                        const pubkey = parsed.value?.pubkey;
+                        if (!pubkey) {
+                            log.warn(tag, `No pubkey found in cache for ${key}, skipping`);
+                            continue;
+                        }
+                        // Trigger refresh by calling getBalance with waitForFresh=true
+                        // This will queue a background refresh job
+                        log.debug(tag, `Queueing refresh for ${caip} (age: ${Math.round((now - parsed.timestamp) / 1000 / 60)}min)`);
+                        // Use setImmediate to avoid blocking the scan
+                        setImmediate(async () => {
+                            try {
+                                await this.balanceCache.getBalance(caip, pubkey, true);
+                                refreshCount++;
+                            }
+                            catch (error) {
+                                log.error(tag, `Failed to refresh ${caip}/${pubkey}:`, error);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        log.error(tag, `Error queueing refresh for ${key}:`, error);
+                    }
+                }
+            }
+            const scanTime = Date.now() - startTime;
+            log.info(tag, `✅ Scan complete: ${totalScanned} scanned, ${staleKeys.length} stale, ${refreshCount} queued in ${scanTime}ms`);
+        }
+        catch (error) {
+            log.error(tag, 'Error during scan:', error);
+        }
+    }
+    /**
+     * Get scanner statistics
+     */
+    getStats() {
+        return {
+            isRunning: this.isRunning,
+            config: {
+                staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+                scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60),
+                batchSize: this.config.batchSize,
+                maxRefreshPerScan: this.config.maxRefreshPerScan
+            }
+        };
+    }
+}
+exports.StaleBalanceScanner = StaleBalanceScanner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.19.3",
+  "version": "1.22.0",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -15,8 +15,10 @@
   "license": "MIT",
   "dependencies": {
     "@pioneer-platform/loggerdog": "8.11.0",
-    "@pioneer-platform/redis-queue": "8.12.17",
-    "@pioneer-platform/default-redis": "8.11.7"
+    "@pioneer-platform/pioneer-discovery": "8.44.0",
+    "@pioneer-platform/pioneer-caip": "9.21.0",
+    "@pioneer-platform/default-redis": "8.11.7",
+    "@pioneer-platform/redis-queue": "8.12.17"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",

package/src/core/cache-manager.ts

@@ -12,6 +12,7 @@ import { TransactionCache } from '../stores/transaction-cache';
 import { StakingCache } from '../stores/staking-cache';
 import { ZapperCache } from '../stores/zapper-cache';
 import { RefreshWorker, startUnifiedWorker } from '../workers/refresh-worker';
+import { StaleBalanceScanner } from '../workers/stale-balance-scanner';
 import type { BaseCache } from './base-cache';
 import type { HealthCheckResult } from '../types';
 
@@ -53,6 +54,7 @@ export class CacheManager {
     private stakingCache?: StakingCache;
     private zapperCache?: ZapperCache;
     private workers: RefreshWorker[] = [];
+    private staleScanner?: StaleBalanceScanner;
 
     constructor(config: CacheManagerConfig) {
         this.redis = config.redis;
@@ -147,6 +149,79 @@ export class CacheManager {
         }
     }
 
+    /**
+     * Purge unsupported job types from the queue
+     * Scans the queue and removes jobs for cache types that aren't enabled
+     */
+    async purgeUnsupportedJobs(queueName: string = 'cache-refresh'): Promise<void> {
+        const tag = TAG + 'purgeUnsupportedJobs | ';
+
+        try {
+            const redisQueue = this.redisQueue;
+            let purgedCount = 0;
+            let scannedCount = 0;
+
+            log.info(tag, `Scanning queue for unsupported job types...`);
+
+            // Get enabled cache types
+            const enabledCaches = new Set<string>();
+            if (this.balanceCache) enabledCaches.add('balance');
+            if (this.priceCache) enabledCaches.add('price');
+            if (this.portfolioCache) enabledCaches.add('portfolio');
+            if (this.transactionCache) enabledCaches.add('transaction');
+            if (this.stakingCache) enabledCaches.add('staking');
+            if (this.zapperCache) enabledCaches.add('zapper');
+
+            log.info(tag, `Enabled caches: ${Array.from(enabledCaches).join(', ') || 'NONE'}`);
+
+            // Get queue length
+            const queueLength = await redisQueue.count(queueName);
+
+            if (queueLength === 0) {
+                log.info(tag, '✅ Queue is empty, no jobs to purge');
+                return;
+            }
+
+            log.info(tag, `Found ${queueLength} jobs in queue`);
+
+            // Scan all jobs
+            const tempJobs: any[] = [];
+
+            for (let i = 0; i < queueLength; i++) {
+                const job = await redisQueue.getWork(queueName, 1);
+
+                if (!job) break;
+
+                scannedCount++;
+                const jobType = job.type || '';
+                const cacheName = jobType.replace('REFRESH_', '').toLowerCase();
+
+                if (!enabledCaches.has(cacheName)) {
+                    purgedCount++;
+                    log.warn(tag, `   Purged unsupported job: ${jobType} (cache "${cacheName}" not enabled)`);
+                } else {
+                    // Keep supported jobs - we'll re-queue them
+                    tempJobs.push(job);
+                }
+            }
+
+            // Re-queue supported jobs
+            for (const job of tempJobs) {
+                await redisQueue.createWork(queueName, job);
+            }
+
+            if (purgedCount > 0) {
+                log.info(tag, `✅ Purged ${purgedCount} unsupported jobs (scanned ${scannedCount})`);
+            } else {
+                log.info(tag, `✅ No unsupported jobs found (scanned ${scannedCount})`);
+            }
+
+        } catch (error) {
+            log.error(tag, '⚠️ Error during unsupported job purge (non-fatal):', error);
+            // Don't throw - purge failure shouldn't prevent system from starting
+        }
+    }
+
     /**
      * Start background refresh workers for all caches
      */
@@ -156,6 +231,9 @@ export class CacheManager {
         try {
             log.info(tag, 'Starting refresh workers...');
 
+            // FIX: Purge unsupported job types before starting workers
+            await this.purgeUnsupportedJobs('cache-refresh');
+
             // Create cache registry for workers
             const cacheRegistry = new Map<string, BaseCache<any>>();
 
@@ -196,6 +274,19 @@ export class CacheManager {
                 log.info(tag, '✅ Refresh worker started for all caches');
             }
 
+            // Start stale balance scanner if balance cache is enabled
+            if (this.balanceCache) {
+                this.staleScanner = new StaleBalanceScanner(this.redis, this.balanceCache, {
+                    staleThresholdMs: 60 * 60 * 1000,      // 1 hour (more aggressive than the 5min reactive threshold)
+                    scanIntervalMs: 10 * 60 * 1000,        // Scan every 10 minutes
+                    batchSize: 100,
+                    maxRefreshPerScan: 50
+                });
+
+                await this.staleScanner.start();
+                log.info(tag, '✅ Stale balance scanner started');
+            }
+
         } catch (error) {
             log.error(tag, '❌ Failed to start workers:', error);
             throw error;
@@ -215,6 +306,11 @@ export class CacheManager {
                 await worker.stop();
             }
 
+            if (this.staleScanner) {
+                await this.staleScanner.stop();
+                this.staleScanner = undefined;
+            }
+
             this.workers = [];
             log.info(tag, '✅ All workers stopped');
 

package/src/stores/balance-cache.ts

@@ -8,6 +8,8 @@
 import { BaseCache } from '../core/base-cache';
 import type { CacheConfig } from '../types';
 import crypto from 'crypto';
+import { assetData } from '@pioneer-platform/pioneer-discovery';
+import { caipToNetworkId } from '@pioneer-platform/pioneer-caip';
 
 const log = require('@pioneer-platform/loggerdog')();
 
@@ -148,12 +150,22 @@ export class BalanceCache extends BaseCache<BalanceData> {
             const balanceInfo = await this.balanceModule.getBalance(asset, owner);
 
             if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
+                // CRITICAL FIX: Distinguish between legitimate zero balance and failed API call
+                // Failed API calls should NOT be cached as valid "0" balance
+                const errorMsg = balanceInfo?.error || 'No balance data returned';
+
+                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)} - ${errorMsg}`);
+
+                // If balanceInfo explicitly indicates an error, throw it instead of caching "0"
+                if (balanceInfo?.error || balanceInfo === null || balanceInfo === undefined) {
+                    throw new Error(`Failed to fetch balance for ${caip}: ${errorMsg}`);
+                }
+
+                // Otherwise, this is a legitimate zero balance (balanceInfo exists but balance is falsy)
                 const now = Date.now();
 
                 // Get asset metadata even for zero balances
-                const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-                const assetInfo = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()] || {};
+                const assetInfo = (assetData as any)[caip.toUpperCase()] || (assetData as any)[caip.toLowerCase()] || {};
 
                 return {
                     caip,
@@ -162,15 +174,13 @@ export class BalanceCache extends BaseCache<BalanceData> {
                     decimals: assetInfo.decimals,
                     precision: assetInfo.decimals,  // Set precision to decimals for compatibility
                     fetchedAt: now,
-                    fetchedAtISO: new Date(now).toISOString()
+                    fetchedAtISO: new Date(now).toISOString(),
+                    dataSource: 'Zero balance (legitimate)'
                 };
             }
 
             // Get asset metadata
-            const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-            const { caipToNetworkId } = require('@pioneer-platform/pioneer-caip');
-
-            const assetInfo = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()] || {};
+            const assetInfo = (assetData as any)[caip.toUpperCase()] || (assetData as any)[caip.toLowerCase()] || {};
             const networkId = caipToNetworkId(caip);
 
             // Use actual node URL if available, otherwise construct generic description
@@ -229,7 +239,6 @@ export class BalanceCache extends BaseCache<BalanceData> {
 
         try {
             const { caip, pubkey } = params;
-            const { caipToNetworkId } = require('@pioneer-platform/pioneer-caip');
             const networkId = caipToNetworkId(caip);
 
             // Try legacy format: cache:balance:pubkey:asset
@@ -276,8 +285,15 @@ export class BalanceCache extends BaseCache<BalanceData> {
      * 
      * CRITICAL FIX: When waitForFresh=true (forceRefresh), bypass cache entirely
      * and fetch fresh blockchain data for ALL items, not just cache misses
+     * 
+     * PERFORMANCE FIX: When skipAsyncRefresh=true, disable background refresh jobs
+     * to prevent 50+ individual refresh jobs from being queued
      */
-    async getBatchBalances(items: Array<{ caip: string; pubkey: string }>, waitForFresh?: boolean): Promise<BalanceData[]> {
+    async getBatchBalances(
+        items: Array<{ caip: string; pubkey: string }>, 
+        waitForFresh?: boolean,
+        skipAsyncRefresh?: boolean
+    ): Promise<BalanceData[]> {
         const tag = this.TAG + 'getBatchBalances | ';
         const startTime = Date.now();
 
@@ -409,11 +425,15 @@ export class BalanceCache extends BaseCache<BalanceData> {
                     
                     await Promise.all(fetchPromises);
                     log.info(tag, `Fetched ${missedItems.length} misses in ${Date.now() - fetchStart}ms`);
-                } else {
-                    // Non-blocking: trigger background refresh for misses
+                } else if (!skipAsyncRefresh) {
+                    // Non-blocking: trigger background refresh for misses (unless disabled)
+                    log.info(tag, `📋 Queueing ${missedItems.length} background refresh jobs for cache misses`);
                     missedItems.forEach(item => {
                         this.triggerAsyncRefresh({ caip: item.caip, pubkey: item.pubkey }, 'high');
                     });
+                } else {
+                    // Background refresh disabled for performance
+                    log.info(tag, `⚡ PERFORMANCE MODE: Skipping ${missedItems.length} background refresh jobs (skipAsyncRefresh=true)`);
                 }
             }
 

package/src/workers/refresh-worker.ts

@@ -69,12 +69,79 @@ export class RefreshWorker {
         log.info(tag, `🚀 Starting refresh worker for queue: ${this.config.queueName}`);
         log.info(tag, `Registered caches: ${Array.from(this.cacheRegistry.keys()).join(', ')}`);
 
+        // FIX #3: Purge stale jobs at startup
+        await this.purgeStaleJobsOnStartup();
+
         this.isRunning = true;
         this.poll();
 
         log.info(tag, '✅ Refresh worker started successfully');
     }
 
+    /**
+     * Purge stale jobs from queue on startup
+     * Scans queue and removes jobs older than 1 hour
+     */
+    private async purgeStaleJobsOnStartup(): Promise<void> {
+        const tag = TAG + 'purgeStaleJobsOnStartup | ';
+
+        try {
+            const MAX_JOB_AGE_MS = 60 * 60 * 1000; // 1 hour
+            const now = Date.now();
+            let purgedCount = 0;
+            let scannedCount = 0;
+
+            log.info(tag, `Scanning queue for stale jobs (age > ${MAX_JOB_AGE_MS / 1000}s)...`);
+
+            // Get queue length
+            const queueLength = await this.redisQueue.count(this.config.queueName);
+
+            if (queueLength === 0) {
+                log.info(tag, '✅ Queue is empty, no stale jobs to purge');
+                return;
+            }
+
+            log.info(tag, `Found ${queueLength} jobs in queue, checking for stale jobs...`);
+
+            // Scan up to 100 jobs to find stale ones
+            const MAX_SCAN = Math.min(queueLength, 100);
+            const tempJobs: RefreshJob[] = [];
+
+            for (let i = 0; i < MAX_SCAN; i++) {
+                const job = await this.redisQueue.getWork(this.config.queueName, 1);
+
+                if (!job) break;
+
+                scannedCount++;
+                const jobTimestamp = (job as any).timestamp || 0;
+                const jobAge = jobTimestamp > 0 ? now - jobTimestamp : 0;
+
+                if (jobAge > MAX_JOB_AGE_MS) {
+                    purgedCount++;
+                    log.warn(tag, `   Purged stale job: ${job.type} (age: ${Math.round(jobAge / 1000)}s)`);
+                } else {
+                    // Keep fresh jobs - we'll re-queue them
+                    tempJobs.push(job);
+                }
+            }
+
+            // Re-queue fresh jobs
+            for (const job of tempJobs) {
+                await this.redisQueue.createWork(this.config.queueName, job);
+            }
+
+            if (purgedCount > 0) {
+                log.info(tag, `✅ Purged ${purgedCount} stale jobs (scanned ${scannedCount})`);
+            } else {
+                log.info(tag, `✅ No stale jobs found (scanned ${scannedCount})`);
+            }
+
+        } catch (error) {
+            log.error(tag, '⚠️ Error during startup purge (non-fatal):', error);
+            // Don't throw - startup purge failure shouldn't prevent worker from starting
+        }
+    }
+
     /**
      * Stop the worker gracefully
      */
@@ -166,14 +233,34 @@ export class RefreshWorker {
 
             log.info(tag, `Processing ${type} for ${key} (retry: ${retryCount})`);
 
+            // FIX #1: Check job age and drop if too old (>1 hour)
+            const MAX_JOB_AGE_MS = 60 * 60 * 1000; // 1 hour
+            const jobAge = Date.now() - startTime;
+            const jobTimestamp = (job as any).timestamp || 0;
+
+            if (jobTimestamp > 0) {
+                const actualJobAge = Date.now() - jobTimestamp;
+                if (actualJobAge > MAX_JOB_AGE_MS) {
+                    log.error(tag, `⚠️ DROPPING STALE JOB: ${type} (age: ${Math.round(actualJobAge / 1000)}s, max: ${MAX_JOB_AGE_MS / 1000}s)`);
+                    log.error(tag, `   Job key: ${key}`);
+                    log.error(tag, `   Job has been removed from queue and will not be retried`);
+                    return;
+                }
+            }
+
             // Extract cache name from job type (e.g., "REFRESH_BALANCE" -> "balance")
             const cacheName = type.replace('REFRESH_', '').toLowerCase();
 
             // Get the appropriate cache instance
             const cache = this.cacheRegistry.get(cacheName);
 
+            // FIX #2: Drop unsupported job types with clear error message
             if (!cache) {
-                log.error(tag, `No cache registered for type: ${type}`);
+                log.error(tag, `❌ DROPPING UNSUPPORTED JOB: ${type}`);
+                log.error(tag, `   Cache type "${cacheName}" is not registered in this worker`);
+                log.error(tag, `   Registered caches: ${Array.from(this.cacheRegistry.keys()).join(', ') || 'NONE'}`);
+                log.error(tag, `   Job key: ${key}`);
+                log.error(tag, `   Job has been removed from queue and will not be retried`);
                 return;
             }
 

package/src/workers/stale-balance-scanner.ts

@@ -0,0 +1,223 @@
+/*
+    Stale Balance Scanner
+
+    Proactively scans for stale balance cache entries and queues them for refresh.
+    This ensures balances that aren't actively accessed still get refreshed.
+
+    Prevents the issue where stale balances sit for days/weeks without being updated.
+*/
+
+import type { BalanceCache } from '../stores/balance-cache';
+
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | StaleBalanceScanner | ';
+
+export interface StaleScannerConfig {
+    staleThresholdMs: number;      // Refresh balances older than this (default: 1 hour)
+    scanIntervalMs: number;        // How often to scan (default: 5 minutes)
+    batchSize: number;             // How many keys to scan per batch (default: 100)
+    maxRefreshPerScan: number;     // Max balances to refresh per scan (default: 50)
+}
+
+export class StaleBalanceScanner {
+    private redis: any;
+    private balanceCache: BalanceCache;
+    private config: StaleScannerConfig;
+    private isRunning: boolean = false;
+    private scanTimer?: NodeJS.Timeout;
+
+    constructor(redis: any, balanceCache: BalanceCache, config?: Partial<StaleScannerConfig>) {
+        this.redis = redis;
+        this.balanceCache = balanceCache;
+
+        this.config = {
+            staleThresholdMs: config?.staleThresholdMs || 60 * 60 * 1000,      // 1 hour
+            scanIntervalMs: config?.scanIntervalMs || 5 * 60 * 1000,            // 5 minutes
+            batchSize: config?.batchSize || 100,
+            maxRefreshPerScan: config?.maxRefreshPerScan || 50
+        };
+
+        log.info(TAG, 'Stale balance scanner initialized', {
+            staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+            scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60)
+        });
+    }
+
+    /**
+     * Start the scanner
+     */
+    async start(): Promise<void> {
+        const tag = TAG + 'start | ';
+
+        if (this.isRunning) {
+            log.warn(tag, 'Scanner already running');
+            return;
+        }
+
+        this.isRunning = true;
+        log.info(tag, '🔍 Starting stale balance scanner');
+
+        // Run first scan immediately, then schedule recurring
+        await this.scan();
+        this.scheduleNextScan();
+    }
+
+    /**
+     * Stop the scanner
+     */
+    async stop(): Promise<void> {
+        const tag = TAG + 'stop | ';
+
+        log.info(tag, 'Stopping stale balance scanner');
+        this.isRunning = false;
+
+        if (this.scanTimer) {
+            clearTimeout(this.scanTimer);
+            this.scanTimer = undefined;
+        }
+
+        log.info(tag, '✅ Scanner stopped');
+    }
+
+    /**
+     * Schedule next scan
+     */
+    private scheduleNextScan(): void {
+        if (!this.isRunning) return;
+
+        this.scanTimer = setTimeout(async () => {
+            await this.scan();
+            this.scheduleNextScan();
+        }, this.config.scanIntervalMs);
+    }
+
+    /**
+     * Scan for stale balances and queue refreshes
+     */
+    private async scan(): Promise<void> {
+        const tag = TAG + 'scan | ';
+        const startTime = Date.now();
+
+        try {
+            log.info(tag, 'Starting stale balance scan...');
+
+            // Scan balance_v2:* keys in batches
+            const pattern = 'balance_v2:*';
+            const staleKeys: string[] = [];
+            const now = Date.now();
+
+            let cursor = '0';
+            let totalScanned = 0;
+            let refreshCount = 0;
+
+            do {
+                // SCAN with COUNT for batching
+                const [nextCursor, keys] = await this.redis.scan(
+                    cursor,
+                    'MATCH', pattern,
+                    'COUNT', this.config.batchSize
+                );
+
+                cursor = nextCursor;
+                totalScanned += keys.length;
+
+                // Check each key for staleness
+                for (const key of keys) {
+                    try {
+                        const cached = await this.redis.get(key);
+                        if (!cached) continue;
+
+                        const parsed = JSON.parse(cached);
+                        const age = now - (parsed.timestamp || 0);
+
+                        // Check if stale
+                        if (age > this.config.staleThresholdMs) {
+                            staleKeys.push(key);
+
+                            // Stop if we've hit max refresh limit
+                            if (staleKeys.length >= this.config.maxRefreshPerScan) {
+                                log.info(tag, `Reached max refresh limit (${this.config.maxRefreshPerScan}), stopping scan`);
+                                cursor = '0'; // Force exit
+                                break;
+                            }
+                        }
+                    } catch (error) {
+                        log.error(tag, `Error checking key ${key}:`, error);
+                    }
+                }
+
+            } while (cursor !== '0' && this.isRunning);
+
+            // Queue refresh for stale balances
+            if (staleKeys.length > 0) {
+                log.info(tag, `Found ${staleKeys.length} stale balances out of ${totalScanned} scanned`);
+
+                for (const key of staleKeys) {
+                    try {
+                        // Extract CAIP and pubkey hash from key
+                        // Key format: balance_v2:caip:hashedPubkey
+                        // IMPORTANT: CAIP itself contains colons (e.g., ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144)
+                        // So we must split from the right to get hashedPubkey, then everything else is the CAIP
+                        const withoutPrefix = key.replace('balance_v2:', '');
+                        const lastColonIndex = withoutPrefix.lastIndexOf(':');
+                        if (lastColonIndex === -1) continue;
+
+                        const caip = withoutPrefix.substring(0, lastColonIndex);
+                        const pubkeyHash = withoutPrefix.substring(lastColonIndex + 1);
+
+                        // We need the original pubkey to refresh, but it's hashed in the key
+                        // So we need to get it from the cached value
+                        const cached = await this.redis.get(key);
+                        if (!cached) continue;
+
+                        const parsed = JSON.parse(cached);
+                        const pubkey = parsed.value?.pubkey;
+
+                        if (!pubkey) {
+                            log.warn(tag, `No pubkey found in cache for ${key}, skipping`);
+                            continue;
+                        }
+
+                        // Trigger refresh by calling getBalance with waitForFresh=true
+                        // This will queue a background refresh job
+                        log.debug(tag, `Queueing refresh for ${caip} (age: ${Math.round((now - parsed.timestamp) / 1000 / 60)}min)`);
+
+                        // Use setImmediate to avoid blocking the scan
+                        setImmediate(async () => {
+                            try {
+                                await this.balanceCache.getBalance(caip, pubkey, true);
+                                refreshCount++;
+                            } catch (error) {
+                                log.error(tag, `Failed to refresh ${caip}/${pubkey}:`, error);
+                            }
+                        });
+
+                    } catch (error) {
+                        log.error(tag, `Error queueing refresh for ${key}:`, error);
+                    }
+                }
+            }
+
+            const scanTime = Date.now() - startTime;
+            log.info(tag, `✅ Scan complete: ${totalScanned} scanned, ${staleKeys.length} stale, ${refreshCount} queued in ${scanTime}ms`);
+
+        } catch (error) {
+            log.error(tag, 'Error during scan:', error);
+        }
+    }
+
+    /**
+     * Get scanner statistics
+     */
+    getStats(): any {
+        return {
+            isRunning: this.isRunning,
+            config: {
+                staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+                scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60),
+                batchSize: this.config.batchSize,
+                maxRefreshPerScan: this.config.maxRefreshPerScan
+            }
+        };
+    }
+}

package/tsconfig.json

@@ -2,17 +2,26 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "commonjs",
-    "lib": ["ES2020"],
+    "lib": [
+      "ES2020",
+      "DOM"
+    ],
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
-    "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
-    "moduleResolution": "node"
+    "moduleResolution": "node",
+    "skipLibCheck": true
   },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts"
+  ]
 }