@pioneer-platform/pioneer-cache 1.21.0 → 1.22.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @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

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

@@ -45,6 +45,11 @@ export declare class CacheManager {
      * 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

@@ -104,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
      */
@@ -111,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) {

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
@@ -121,8 +123,7 @@ class BalanceCache extends base_cache_1.BaseCache {
                 // 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,
@@ -135,10 +136,8 @@ class BalanceCache extends base_cache_1.BaseCache {
                 };
             }
             // 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) {
@@ -196,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);
@@ -238,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 {
@@ -356,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.21.0",
+  "version": "1.22.0",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -15,6 +15,8 @@
   "license": "MIT",
   "dependencies": {
     "@pioneer-platform/loggerdog": "8.11.0",
+    "@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"
   },

package/src/core/cache-manager.ts

@@ -149,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
      */
@@ -158,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>>();
 

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')();
 
@@ -163,8 +165,7 @@ export class BalanceCache extends BaseCache<BalanceData> {
                 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,
@@ -179,10 +180,7 @@ export class BalanceCache extends BaseCache<BalanceData> {
             }
 
             // 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
@@ -241,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
@@ -288,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();
 
@@ -421,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/tsconfig.json

@@ -2,7 +2,10 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "commonjs",
-    "lib": ["ES2020", "DOM"],
+    "lib": [
+      "ES2020",
+      "DOM"
+    ],
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",
@@ -10,8 +13,15 @@
     "esModuleInterop": 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"
+  ]
 }