@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/collection/CollectionIndexManager.js

@@ -0,0 +1,499 @@
+/**
+ * Collection Index Manager with Background Refresh and Robust Caching
+ *
+ * This manager implements:
+ * - 1-hour TTL with local file caching
+ * - Background refresh without blocking operations
+ * - Exponential backoff retry logic
+ * - Configurable timeouts via environment variables
+ * - Return stale cache while refreshing in background
+ * - Comprehensive error handling for production use
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { logger } from '../utils/logger.js';
+export class CollectionIndexManager {
+    INDEX_URL = 'https://raw.githubusercontent.com/DollhouseMCP/collection/main/public/collection-index.json';
+    TTL_MS;
+    FETCH_TIMEOUT_MS;
+    MAX_RETRIES;
+    BASE_RETRY_DELAY_MS;
+    MAX_RETRY_DELAY_MS;
+    CACHE_FILE;
+    cachedIndex = null;
+    backgroundRefreshPromise = null;
+    isRefreshing = false;
+    circuitBreakerFailures = 0;
+    circuitBreakerLastFailure = 0;
+    CIRCUIT_BREAKER_THRESHOLD = 5;
+    CIRCUIT_BREAKER_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+    REFRESH_THRESHOLD = 0.8; // Refresh when 80% of TTL has passed
+    JITTER_FACTOR = 0.25; // ±25% randomness for jitter
+    // Default configuration constants
+    DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour
+    DEFAULT_MAX_RETRIES = 3;
+    DEFAULT_BASE_RETRY_DELAY_MS = 1000;
+    DEFAULT_MAX_RETRY_DELAY_MS = 30000;
+    DEFAULT_FETCH_TIMEOUT_MS = 5000; // 5 seconds
+    CHECKSUM_LENGTH = 8;
+    JSON_INDENT = 2;
+    constructor(config = {}) {
+        // Configuration with environment variable overrides
+        this.TTL_MS = config.ttlMs || this.DEFAULT_TTL_MS;
+        this.FETCH_TIMEOUT_MS = this.parseFetchTimeout(config.fetchTimeoutMs);
+        this.MAX_RETRIES = config.maxRetries || this.DEFAULT_MAX_RETRIES;
+        this.BASE_RETRY_DELAY_MS = config.baseRetryDelayMs || this.DEFAULT_BASE_RETRY_DELAY_MS;
+        this.MAX_RETRY_DELAY_MS = config.maxRetryDelayMs || this.DEFAULT_MAX_RETRY_DELAY_MS;
+        // Cache directory - use ~/.dollhouse/cache/collection-index.json as specified
+        const cacheDir = config.cacheDir || path.join(os.homedir(), '.dollhouse', 'cache');
+        this.CACHE_FILE = path.join(cacheDir, 'collection-index.json');
+        logger.debug('CollectionIndexManager initialized', {
+            ttlMs: this.TTL_MS,
+            fetchTimeoutMs: this.FETCH_TIMEOUT_MS,
+            cacheFile: this.CACHE_FILE,
+            maxRetries: this.MAX_RETRIES
+        });
+    }
+    /**
+     * Parse fetch timeout from config or environment variable
+     */
+    parseFetchTimeout(configValue) {
+        // Check environment variable first
+        const envTimeout = process.env.COLLECTION_FETCH_TIMEOUT;
+        if (envTimeout) {
+            const parsed = parseInt(envTimeout, 10);
+            if (!isNaN(parsed) && parsed > 0) {
+                logger.debug(`Using COLLECTION_FETCH_TIMEOUT from environment: ${parsed}ms`);
+                return parsed;
+            }
+            logger.warn(`Invalid COLLECTION_FETCH_TIMEOUT value: ${envTimeout}, using default`);
+        }
+        // Fall back to config value or default
+        return configValue || this.DEFAULT_FETCH_TIMEOUT_MS;
+    }
+    /**
+     * Get collection index with stale-while-revalidate pattern
+     * Returns cached data immediately if available, refreshes in background
+     */
+    async getIndex() {
+        try {
+            // Load from memory cache first
+            if (!this.cachedIndex) {
+                await this.loadFromDisk();
+            }
+            // Check if we should return stale cache while refreshing
+            const shouldRefresh = this.shouldRefreshCache();
+            if (this.cachedIndex && !this.isCacheExpired()) {
+                // Cache is valid, return immediately
+                logger.debug('Returning valid cached collection index');
+                // Start background refresh if needed but not already running
+                if (shouldRefresh && !this.isRefreshing) {
+                    this.startBackgroundRefresh();
+                }
+                return this.cachedIndex.data;
+            }
+            // If we have stale cache, return it while refreshing in background
+            if (this.cachedIndex && this.isCacheExpired()) {
+                logger.debug('Returning stale cache while refreshing in background');
+                // Start background refresh if not already running
+                if (!this.isRefreshing) {
+                    this.startBackgroundRefresh();
+                }
+                return this.cachedIndex.data;
+            }
+            // No cache available, must fetch synchronously
+            logger.debug('No cache available, fetching collection index synchronously');
+            const freshIndex = await this.fetchWithRetry();
+            await this.updateCache(freshIndex);
+            return freshIndex.data;
+        }
+        catch (error) {
+            logger.error('Failed to get collection index', { error: this.getErrorMessage(error) });
+            // If we have any cached data (even expired), return it as last resort
+            if (this.cachedIndex) {
+                logger.warn('Returning expired cache as last resort');
+                return this.cachedIndex.data;
+            }
+            throw new Error(`Collection index not available: ${this.getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * Force refresh the collection index
+     */
+    async forceRefresh() {
+        logger.debug('Force refreshing collection index');
+        try {
+            const freshIndex = await this.fetchWithRetry();
+            await this.updateCache(freshIndex);
+            return freshIndex.data;
+        }
+        catch (error) {
+            logger.error('Force refresh failed', { error: this.getErrorMessage(error) });
+            // If we have cached data, return it
+            if (this.cachedIndex) {
+                logger.warn('Force refresh failed, returning cached data');
+                return this.cachedIndex.data;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check if cache should be refreshed (within TTL but getting close to expiry)
+     */
+    shouldRefreshCache() {
+        if (!this.cachedIndex)
+            return true;
+        const age = Date.now() - this.cachedIndex.timestamp;
+        const refreshThreshold = this.TTL_MS * this.REFRESH_THRESHOLD;
+        return age > refreshThreshold;
+    }
+    /**
+     * Check if cache is expired
+     */
+    isCacheExpired() {
+        if (!this.cachedIndex)
+            return true;
+        const age = Date.now() - this.cachedIndex.timestamp;
+        return age > this.TTL_MS;
+    }
+    /**
+     * Start background refresh without blocking
+     */
+    startBackgroundRefresh() {
+        if (this.isRefreshing) {
+            logger.debug('Background refresh already in progress');
+            return;
+        }
+        // Check circuit breaker
+        if (this.isCircuitBreakerOpen()) {
+            logger.debug('Circuit breaker open, skipping background refresh');
+            return;
+        }
+        this.isRefreshing = true;
+        this.backgroundRefreshPromise = this.performBackgroundRefresh()
+            .catch(error => {
+            logger.debug('Background refresh failed', { error: this.getErrorMessage(error) });
+            this.recordCircuitBreakerFailure();
+        })
+            .finally(() => {
+            this.isRefreshing = false;
+            this.backgroundRefreshPromise = null;
+        });
+    }
+    /**
+     * Perform background refresh
+     */
+    async performBackgroundRefresh() {
+        logger.debug('Starting background refresh of collection index');
+        try {
+            const freshIndex = await this.fetchWithRetry();
+            await this.updateCache(freshIndex);
+            // Reset circuit breaker on success
+            this.circuitBreakerFailures = 0;
+            logger.debug('Background refresh completed successfully');
+        }
+        catch (error) {
+            logger.debug('Background refresh failed', { error: this.getErrorMessage(error) });
+            throw error;
+        }
+    }
+    /**
+     * Fetch collection index with retry logic and exponential backoff
+     */
+    async fetchWithRetry() {
+        let lastError = null;
+        for (let attempt = 0; attempt <= this.MAX_RETRIES; attempt++) {
+            try {
+                if (attempt > 0) {
+                    const delay = this.calculateRetryDelay(attempt);
+                    logger.debug(`Retrying fetch in ${delay}ms (attempt ${attempt + 1}/${this.MAX_RETRIES + 1})`);
+                    await this.sleep(delay);
+                }
+                return await this.fetchCollectionIndex();
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                logger.debug(`Fetch attempt ${attempt + 1} failed`, {
+                    error: this.getErrorMessage(lastError),
+                    willRetry: attempt < this.MAX_RETRIES
+                });
+            }
+        }
+        throw lastError || new Error('All fetch attempts failed');
+    }
+    /**
+     * Calculate retry delay with exponential backoff and jitter
+     */
+    calculateRetryDelay(attempt) {
+        // Exponential backoff: baseDelay * (2 ^ attempt)
+        const exponentialDelay = this.BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);
+        // Cap at maximum delay
+        const cappedDelay = Math.min(exponentialDelay, this.MAX_RETRY_DELAY_MS);
+        // Add jitter to prevent thundering herd
+        return this.addJitter(cappedDelay);
+    }
+    /**
+     * Add jitter (±25% randomness) to a delay to prevent thundering herd problems
+     */
+    addJitter(delay) {
+        const jitter = delay * this.JITTER_FACTOR * (Math.random() - 0.5);
+        return Math.max(0, delay + jitter);
+    }
+    /**
+     * Fetch collection index from GitHub
+     */
+    async fetchCollectionIndex() {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.FETCH_TIMEOUT_MS);
+        try {
+            // Build headers for conditional requests
+            const headers = {
+                'Accept': 'application/json',
+                'User-Agent': 'DollhouseMCP/1.0',
+                'Cache-Control': 'no-cache'
+            };
+            // Add conditional headers if we have cached data
+            if (this.cachedIndex?.etag) {
+                headers['If-None-Match'] = this.cachedIndex.etag;
+            }
+            if (this.cachedIndex?.lastModified) {
+                headers['If-Modified-Since'] = this.cachedIndex.lastModified;
+            }
+            logger.debug('Fetching collection index', {
+                url: this.INDEX_URL,
+                timeout: this.FETCH_TIMEOUT_MS,
+                hasEtag: !!this.cachedIndex?.etag
+            });
+            const response = await fetch(this.INDEX_URL, {
+                headers,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            // Handle 304 Not Modified
+            if (response.status === 304 && this.cachedIndex) {
+                logger.debug('Collection index not modified (304), updating cache timestamp');
+                this.cachedIndex.timestamp = Date.now();
+                await this.saveToDisk();
+                return {
+                    data: this.cachedIndex.data,
+                    etag: this.cachedIndex.etag,
+                    lastModified: this.cachedIndex.lastModified
+                };
+            }
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const indexData = await response.json();
+            // Validate the index structure
+            this.validateIndexStructure(indexData);
+            const etag = response.headers.get('etag') || undefined;
+            const lastModified = response.headers.get('last-modified') || undefined;
+            logger.debug('Collection index fetched successfully', {
+                totalElements: indexData.total_elements,
+                version: indexData.version,
+                hasEtag: !!etag
+            });
+            return { data: indexData, etag, lastModified };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === 'AbortError') {
+                throw new Error(`Fetch timeout after ${this.FETCH_TIMEOUT_MS}ms`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Validate collection index structure
+     */
+    validateIndexStructure(index) {
+        if (!index || typeof index !== 'object') {
+            throw new Error('Invalid index: not an object');
+        }
+        if (typeof index.version !== 'string') {
+            throw new Error('Invalid index: missing or invalid version');
+        }
+        if (typeof index.generated !== 'string') {
+            throw new Error('Invalid index: missing or invalid generated timestamp');
+        }
+        if (typeof index.total_elements !== 'number') {
+            throw new Error('Invalid index: missing or invalid total_elements');
+        }
+        if (!index.index || typeof index.index !== 'object') {
+            throw new Error('Invalid index: missing or invalid index object');
+        }
+        if (!index.metadata || typeof index.metadata !== 'object') {
+            throw new Error('Invalid index: missing or invalid metadata');
+        }
+    }
+    /**
+     * Update cache with new data
+     */
+    async updateCache(fetchResult) {
+        const checksum = this.calculateChecksum(fetchResult.data);
+        this.cachedIndex = {
+            data: fetchResult.data,
+            timestamp: Date.now(),
+            etag: fetchResult.etag,
+            lastModified: fetchResult.lastModified,
+            version: fetchResult.data.version,
+            checksum
+        };
+        await this.saveToDisk();
+        logger.debug('Collection index cache updated', {
+            version: fetchResult.data.version,
+            totalElements: fetchResult.data.total_elements,
+            checksum
+        });
+    }
+    /**
+     * Calculate checksum for data integrity verification
+     */
+    calculateChecksum(data) {
+        // Simple checksum based on key properties
+        const checksumData = {
+            version: data.version,
+            generated: data.generated,
+            total_elements: data.total_elements
+        };
+        return Buffer.from(JSON.stringify(checksumData)).toString('base64').substring(0, this.CHECKSUM_LENGTH);
+    }
+    /**
+     * Load cache from disk
+     */
+    async loadFromDisk() {
+        try {
+            const data = await fs.readFile(this.CACHE_FILE, 'utf8');
+            const cached = JSON.parse(data);
+            // Validate cache structure
+            if (!cached.data || !cached.timestamp || !cached.version) {
+                logger.debug('Invalid cache structure, ignoring');
+                return;
+            }
+            // Verify checksum if available
+            if (cached.checksum) {
+                const expectedChecksum = this.calculateChecksum(cached.data);
+                if (cached.checksum !== expectedChecksum) {
+                    logger.debug('Cache checksum mismatch, ignoring cached data');
+                    return;
+                }
+            }
+            this.cachedIndex = cached;
+            const age = Date.now() - cached.timestamp;
+            const isExpired = age > this.TTL_MS;
+            logger.debug('Loaded collection index from disk cache', {
+                version: cached.version,
+                age: Math.round(age / 1000),
+                isExpired,
+                totalElements: cached.data.total_elements
+            });
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to load cache from disk', { error: this.getErrorMessage(error) });
+            }
+        }
+    }
+    /**
+     * Save cache to disk
+     */
+    async saveToDisk() {
+        if (!this.cachedIndex)
+            return;
+        try {
+            // Ensure cache directory exists
+            await fs.mkdir(path.dirname(this.CACHE_FILE), { recursive: true });
+            const cacheData = JSON.stringify(this.cachedIndex, null, this.JSON_INDENT);
+            await fs.writeFile(this.CACHE_FILE, cacheData, 'utf8');
+            logger.debug('Collection index cache saved to disk');
+        }
+        catch (error) {
+            logger.debug('Failed to save cache to disk', { error: this.getErrorMessage(error) });
+            // Don't throw - cache persistence failures shouldn't break functionality
+        }
+    }
+    /**
+     * Circuit breaker logic
+     */
+    isCircuitBreakerOpen() {
+        if (this.circuitBreakerFailures < this.CIRCUIT_BREAKER_THRESHOLD) {
+            return false;
+        }
+        const timeSinceLastFailure = Date.now() - this.circuitBreakerLastFailure;
+        return timeSinceLastFailure < this.CIRCUIT_BREAKER_TIMEOUT_MS;
+    }
+    recordCircuitBreakerFailure() {
+        this.circuitBreakerFailures++;
+        this.circuitBreakerLastFailure = Date.now();
+        if (this.circuitBreakerFailures >= this.CIRCUIT_BREAKER_THRESHOLD) {
+            logger.warn('Circuit breaker opened due to repeated failures', {
+                failures: this.circuitBreakerFailures,
+                timeoutMs: this.CIRCUIT_BREAKER_TIMEOUT_MS
+            });
+        }
+    }
+    /**
+     * Utility methods
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return String(error);
+    }
+    /**
+     * Get cache statistics for monitoring
+     */
+    getCacheStats() {
+        if (!this.cachedIndex) {
+            return {
+                isValid: false,
+                age: 0,
+                hasCache: false,
+                isRefreshing: this.isRefreshing,
+                circuitBreakerFailures: this.circuitBreakerFailures,
+                circuitBreakerOpen: this.isCircuitBreakerOpen()
+            };
+        }
+        const age = Date.now() - this.cachedIndex.timestamp;
+        return {
+            isValid: !this.isCacheExpired(),
+            age: Math.round(age / 1000), // age in seconds
+            hasCache: true,
+            version: this.cachedIndex.version,
+            totalElements: this.cachedIndex.data.total_elements,
+            isRefreshing: this.isRefreshing,
+            circuitBreakerFailures: this.circuitBreakerFailures,
+            circuitBreakerOpen: this.isCircuitBreakerOpen()
+        };
+    }
+    /**
+     * Clear all cache data
+     */
+    async clearCache() {
+        this.cachedIndex = null;
+        this.circuitBreakerFailures = 0;
+        try {
+            await fs.unlink(this.CACHE_FILE);
+            logger.debug('Collection index cache file deleted');
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                logger.debug('Failed to delete cache file', { error: this.getErrorMessage(error) });
+            }
+        }
+    }
+    /**
+     * Wait for any ongoing background refresh to complete
+     */
+    async waitForBackgroundRefresh() {
+        if (this.backgroundRefreshPromise) {
+            await this.backgroundRefreshPromise;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CollectionIndexManager.js","sourceRoot":"","sources":["../../src/collection/CollectionIndexManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,IAAI,CAAC;AAEzB,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAoB5C,MAAM,OAAO,sBAAsB;IAChB,SAAS,GAAG,6FAA6F,CAAC;IAC1G,MAAM,CAAS;IACf,gBAAgB,CAAS;IACzB,WAAW,CAAS;IACpB,mBAAmB,CAAS;IAC5B,kBAAkB,CAAS;IAC3B,UAAU,CAAS;IAE5B,WAAW,GAAqC,IAAI,CAAC;IACrD,wBAAwB,GAAyB,IAAI,CAAC;IACtD,YAAY,GAAG,KAAK,CAAC;IACrB,sBAAsB,GAAG,CAAC,CAAC;IAC3B,yBAAyB,GAAG,CAAC,CAAC;IACrB,yBAAyB,GAAG,CAAC,CAAC;IAC9B,0BAA0B,GAAG,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,YAAY;IACxD,iBAAiB,GAAG,GAAG,CAAC,CAAC,qCAAqC;IAC9D,aAAa,GAAG,IAAI,CAAC,CAAC,6BAA6B;IAEpE,kCAAkC;IACjB,cAAc,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC,SAAS;IAC1C,mBAAmB,GAAG,CAAC,CAAC;IACxB,2BAA2B,GAAG,IAAI,CAAC;IACnC,0BAA0B,GAAG,KAAK,CAAC;IACnC,wBAAwB,GAAG,IAAI,CAAC,CAAC,YAAY;IAC7C,eAAe,GAAG,CAAC,CAAC;IACpB,WAAW,GAAG,CAAC,CAAC;IAEjC,YAAY,SAAuC,EAAE;QACnD,oDAAoD;QACpD,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,IAAI,IAAI,CAAC,cAAc,CAAC;QAClD,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;QACtE,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,UAAU,IAAI,IAAI,CAAC,mBAAmB,CAAC;QACjE,IAAI,CAAC,mBAAmB,GAAG,MAAM,CAAC,gBAAgB,IAAI,IAAI,CAAC,2BAA2B,CAAC;QACvF,IAAI,CAAC,kBAAkB,GAAG,MAAM,CAAC,eAAe,IAAI,IAAI,CAAC,0BAA0B,CAAC;QAEpF,8EAA8E;QAC9E,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,YAAY,EAAE,OAAO,CAAC,CAAC;QACnF,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,uBAAuB,CAAC,CAAC;QAE/D,MAAM,CAAC,KAAK,CAAC,oCAAoC,EAAE;YACjD,KAAK,EAAE,IAAI,CAAC,MAAM;YAClB,cAAc,EAAE,IAAI,CAAC,gBAAgB;YACrC,SAAS,EAAE,IAAI,CAAC,UAAU;YAC1B,UAAU,EAAE,IAAI,CAAC,WAAW;SAC7B,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,WAAoB;QAC5C,mCAAmC;QACnC,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC;QACxD,IAAI,UAAU,EAAE,CAAC;YACf,MAAM,MAAM,GAAG,QAAQ,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;YACxC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;gBACjC,MAAM,CAAC,KAAK,CAAC,oDAAoD,MAAM,IAAI,CAAC,CAAC;gBAC7E,OAAO,MAAM,CAAC;YAChB,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,2CAA2C,UAAU,iBAAiB,CAAC,CAAC;QACtF,CAAC;QAED,uCAAuC;QACvC,OAAO,WAAW,IAAI,IAAI,CAAC,wBAAwB,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,QAAQ;QACZ,IAAI,CAAC;YACH,+BAA+B;YAC/B,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;gBACtB,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;YAC5B,CAAC;YAED,yDAAyD;YACzD,MAAM,aAAa,GAAG,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAEhD,IAAI,IAAI,CAAC,WAAW,IAAI,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC/C,qCAAqC;gBACrC,MAAM,CAAC,KAAK,CAAC,yCAAyC,CAAC,CAAC;gBAExD,6DAA6D;gBAC7D,IAAI,aAAa,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;oBACxC,IAAI,CAAC,sBAAsB,EAAE,CAAC;gBAChC,CAAC;gBAED,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YAC/B,CAAC;YAED,mEAAmE;YACnE,IAAI,IAAI,CAAC,WAAW,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;gBAC9C,MAAM,CAAC,KAAK,CAAC,sDAAsD,CAAC,CAAC;gBAErE,kDAAkD;gBAClD,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;oBACvB,IAAI,CAAC,sBAAsB,EAAE,CAAC;gBAChC,CAAC;gBAED,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YAC/B,CAAC;YAED,+CAA+C;YAC/C,MAAM,CAAC,KAAK,CAAC,6DAA6D,CAAC,CAAC;YAC5E,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAC/C,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;YACnC,OAAO,UAAU,CAAC,IAAI,CAAC;QAEzB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAEvF,sEAAsE;YACtE,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,MAAM,CAAC,IAAI,CAAC,wCAAwC,CAAC,CAAC;gBACtD,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YAC/B,CAAC;YAED,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QACpF,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,YAAY;QAChB,MAAM,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAC;QAElD,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAC/C,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;YACnC,OAAO,UAAU,CAAC,IAAI,CAAC;QACzB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,sBAAsB,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAE7E,oCAAoC;YACpC,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBACrB,MAAM,CAAC,IAAI,CAAC,6CAA6C,CAAC,CAAC;gBAC3D,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YAC/B,CAAC;YAED,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,kBAAkB;QACxB,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QAEnC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;QACpD,MAAM,gBAAgB,GAAG,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,iBAAiB,CAAC;QAE9D,OAAO,GAAG,GAAG,gBAAgB,CAAC;IAChC,CAAC;IAED;;OAEG;IACK,cAAc;QACpB,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO,IAAI,CAAC;QAEnC,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;QACpD,OAAO,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC;IAC3B,CAAC;IAED;;OAEG;IACK,sBAAsB;QAC5B,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;YACtB,MAAM,CAAC,KAAK,CAAC,wCAAwC,CAAC,CAAC;YACvD,OAAO;QACT,CAAC;QAED,wBAAwB;QACxB,IAAI,IAAI,CAAC,oBAAoB,EAAE,EAAE,CAAC;YAChC,MAAM,CAAC,KAAK,CAAC,mDAAmD,CAAC,CAAC;YAClE,OAAO;QACT,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC;QAEzB,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,wBAAwB,EAAE;aAC5D,KAAK,CAAC,KAAK,CAAC,EAAE;YACb,MAAM,CAAC,KAAK,CAAC,2BAA2B,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAClF,IAAI,CAAC,2BAA2B,EAAE,CAAC;QACrC,CAAC,CAAC;aACD,OAAO,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC;YAC1B,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC;QACvC,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,wBAAwB;QACpC,MAAM,CAAC,KAAK,CAAC,iDAAiD,CAAC,CAAC;QAEhE,IAAI,CAAC;YACH,MAAM,UAAU,GAAG,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAC/C,MAAM,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;YAEnC,mCAAmC;YACnC,IAAI,CAAC,sBAAsB,GAAG,CAAC,CAAC;YAEhC,MAAM,CAAC,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC5D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,2BAA2B,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAClF,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,cAAc;QAC1B,IAAI,SAAS,GAAiB,IAAI,CAAC;QAEnC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,EAAE,CAAC;YAC7D,IAAI,CAAC;gBACH,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;oBAChB,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;oBAChD,MAAM,CAAC,KAAK,CAAC,qBAAqB,KAAK,eAAe,OAAO,GAAG,CAAC,IAAI,IAAI,CAAC,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC;oBAC9F,MAAM,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC1B,CAAC;gBAED,OAAO,MAAM,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC3C,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;gBACtE,MAAM,CAAC,KAAK,CAAC,iBAAiB,OAAO,GAAG,CAAC,SAAS,EAAE;oBAClD,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC;oBACtC,SAAS,EAAE,OAAO,GAAG,IAAI,CAAC,WAAW;iBACtC,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,MAAM,SAAS,IAAI,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;IAC5D,CAAC;IAED;;OAEG;IACK,mBAAmB,CAAC,OAAe;QACzC,iDAAiD;QACjD,MAAM,gBAAgB,GAAG,IAAI,CAAC,mBAAmB,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;QAE7E,uBAAuB;QACvB,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,gBAAgB,EAAE,IAAI,CAAC,kBAAkB,CAAC,CAAC;QAExE,wCAAwC;QACxC,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACK,SAAS,CAAC,KAAa;QAC7B,MAAM,MAAM,GAAG,KAAK,GAAG,IAAI,CAAC,aAAa,GAAG,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,GAAG,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,oBAAoB;QAChC,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;QACzC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAE9E,IAAI,CAAC;YACH,yCAAyC;YACzC,MAAM,OAAO,GAA2B;gBACtC,QAAQ,EAAE,kBAAkB;gBAC5B,YAAY,EAAE,kBAAkB;gBAChC,eAAe,EAAE,UAAU;aAC5B,CAAC;YAEF,iDAAiD;YACjD,IAAI,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,CAAC;gBAC3B,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;YACnD,CAAC;YACD,IAAI,IAAI,CAAC,WAAW,EAAE,YAAY,EAAE,CAAC;gBACnC,OAAO,CAAC,mBAAmB,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC;YAC/D,CAAC;YAED,MAAM,CAAC,KAAK,CAAC,2BAA2B,EAAE;gBACxC,GAAG,EAAE,IAAI,CAAC,SAAS;gBACnB,OAAO,EAAE,IAAI,CAAC,gBAAgB;gBAC9B,OAAO,EAAE,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI;aAClC,CAAC,CAAC;YAEH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,SAAS,EAAE;gBAC3C,OAAO;gBACP,MAAM,EAAE,UAAU,CAAC,MAAM;aAC1B,CAAC,CAAC;YAEH,YAAY,CAAC,SAAS,CAAC,CAAC;YAExB,0BAA0B;YAC1B,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC;gBAChD,MAAM,CAAC,KAAK,CAAC,+DAA+D,CAAC,CAAC;gBAC9E,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBACxC,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;gBACxB,OAAO;oBACL,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;oBAC3B,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI;oBAC3B,YAAY,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY;iBAC5C,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,MAAM,IAAI,KAAK,CAAC,QAAQ,QAAQ,CAAC,MAAM,KAAK,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC;YACrE,CAAC;YAED,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAqB,CAAC;YAE3D,+BAA+B;YAC/B,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;YAEvC,MAAM,IAAI,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC;YACvD,MAAM,YAAY,GAAG,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,IAAI,SAAS,CAAC;YAExE,MAAM,CAAC,KAAK,CAAC,uCAAuC,EAAE;gBACpD,aAAa,EAAE,SAAS,CAAC,cAAc;gBACvC,OAAO,EAAE,SAAS,CAAC,OAAO;gBAC1B,OAAO,EAAE,CAAC,CAAC,IAAI;aAChB,CAAC,CAAC;YAEH,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC;QAEjD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,YAAY,CAAC,SAAS,CAAC,CAAC;YAExB,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBAC1D,MAAM,IAAI,KAAK,CAAC,uBAAuB,IAAI,CAAC,gBAAgB,IAAI,CAAC,CAAC;YACpE,CAAC;YAED,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAED;;OAEG;IACK,sBAAsB,CAAC,KAAU;QACvC,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QAED,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YACtC,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,OAAO,KAAK,CAAC,SAAS,KAAK,QAAQ,EAAE,CAAC;YACxC,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QAED,IAAI,OAAO,KAAK,CAAC,cAAc,KAAK,QAAQ,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAC;QACpE,CAAC;QAED,IAAI,CAAC,KAAK,CAAC,QAAQ,IAAI,OAAO,KAAK,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QAChE,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,WAAW,CAAC,WAA4E;QACpG,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAE1D,IAAI,CAAC,WAAW,GAAG;YACjB,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,YAAY,EAAE,WAAW,CAAC,YAAY;YACtC,OAAO,EAAE,WAAW,CAAC,IAAI,CAAC,OAAO;YACjC,QAAQ;SACT,CAAC;QAEF,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QAExB,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE;YAC7C,OAAO,EAAE,WAAW,CAAC,IAAI,CAAC,OAAO;YACjC,aAAa,EAAE,WAAW,CAAC,IAAI,CAAC,cAAc;YAC9C,QAAQ;SACT,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACK,iBAAiB,CAAC,IAAqB;QAC7C,0CAA0C;QAC1C,MAAM,YAAY,GAAG;YACnB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,cAAc,EAAE,IAAI,CAAC,cAAc;SACpC,CAAC;QACF,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACzG,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YACxD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAA8B,CAAC;YAE7D,2BAA2B;YAC3B,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;gBACzD,MAAM,CAAC,KAAK,CAAC,mCAAmC,CAAC,CAAC;gBAClD,OAAO;YACT,CAAC;YAED,+BAA+B;YAC/B,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;gBACpB,MAAM,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAC7D,IAAI,MAAM,CAAC,QAAQ,KAAK,gBAAgB,EAAE,CAAC;oBACzC,MAAM,CAAC,KAAK,CAAC,+CAA+C,CAAC,CAAC;oBAC9D,OAAO;gBACT,CAAC;YACH,CAAC;YAED,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;YAE1B,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC,SAAS,CAAC;YAC1C,MAAM,SAAS,GAAG,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC;YAEpC,MAAM,CAAC,KAAK,CAAC,yCAAyC,EAAE;gBACtD,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC;gBAC3B,SAAS;gBACT,aAAa,EAAE,MAAM,CAAC,IAAI,CAAC,cAAc;aAC1C,CAAC,CAAC;QAEL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAAa,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrC,MAAM,CAAC,KAAK,CAAC,gCAAgC,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACzF,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,UAAU;QACtB,IAAI,CAAC,IAAI,CAAC,WAAW;YAAE,OAAO;QAE9B,IAAI,CAAC;YACH,gCAAgC;YAChC,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAEnE,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;YAC3E,MAAM,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;YAEvD,MAAM,CAAC,KAAK,CAAC,sCAAsC,CAAC,CAAC;QACvD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,8BAA8B,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACrF,yEAAyE;QAC3E,CAAC;IACH,CAAC;IAED;;OAEG;IACK,oBAAoB;QAC1B,IAAI,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC,yBAAyB,EAAE,CAAC;YACjE,OAAO,KAAK,CAAC;QACf,CAAC;QAED,MAAM,oBAAoB,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,yBAAyB,CAAC;QACzE,OAAO,oBAAoB,GAAG,IAAI,CAAC,0BAA0B,CAAC;IAChE,CAAC;IAEO,2BAA2B;QACjC,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAC9B,IAAI,CAAC,yBAAyB,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAE5C,IAAI,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,yBAAyB,EAAE,CAAC;YAClE,MAAM,CAAC,IAAI,CAAC,iDAAiD,EAAE;gBAC7D,QAAQ,EAAE,IAAI,CAAC,sBAAsB;gBACrC,SAAS,EAAE,IAAI,CAAC,0BAA0B;aAC3C,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,EAAU;QACtB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;IACzD,CAAC;IAEO,eAAe,CAAC,KAAc;QACpC,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,OAAO,KAAK,CAAC,OAAO,CAAC;QACvB,CAAC;QACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;IAED;;OAEG;IACH,aAAa;QAUX,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC;YACtB,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,GAAG,EAAE,CAAC;gBACN,QAAQ,EAAE,KAAK;gBACf,YAAY,EAAE,IAAI,CAAC,YAAY;gBAC/B,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;gBACnD,kBAAkB,EAAE,IAAI,CAAC,oBAAoB,EAAE;aAChD,CAAC;QACJ,CAAC;QAED,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;QAEpD,OAAO;YACL,OAAO,EAAE,CAAC,IAAI,CAAC,cAAc,EAAE;YAC/B,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,GAAG,IAAI,CAAC,EAAE,iBAAiB;YAC9C,QAAQ,EAAE,IAAI;YACd,OAAO,EAAE,IAAI,CAAC,WAAW,CAAC,OAAO;YACjC,aAAa,EAAE,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,cAAc;YACnD,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,sBAAsB,EAAE,IAAI,CAAC,sBAAsB;YACnD,kBAAkB,EAAE,IAAI,CAAC,oBAAoB,EAAE;SAChD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU;QACd,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,sBAAsB,GAAG,CAAC,CAAC;QAEhC,IAAI,CAAC;YACH,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YACjC,MAAM,CAAC,KAAK,CAAC,qCAAqC,CAAC,CAAC;QACtD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAAa,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACrC,MAAM,CAAC,KAAK,CAAC,6BAA6B,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YACtF,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,wBAAwB;QAC5B,IAAI,IAAI,CAAC,wBAAwB,EAAE,CAAC;YAClC,MAAM,IAAI,CAAC,wBAAwB,CAAC;QACtC,CAAC;IACH,CAAC;CACF","sourcesContent":["/**\n * Collection Index Manager with Background Refresh and Robust Caching\n * \n * This manager implements:\n * - 1-hour TTL with local file caching\n * - Background refresh without blocking operations\n * - Exponential backoff retry logic\n * - Configurable timeouts via environment variables\n * - Return stale cache while refreshing in background\n * - Comprehensive error handling for production use\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport * as os from 'os';\nimport { CollectionIndex } from '../types/collection';\nimport { logger } from '../utils/logger.js';\n\nexport interface CollectionIndexCacheEntry {\n  data: CollectionIndex;\n  timestamp: number;\n  etag?: string;\n  lastModified?: string;\n  version: string;\n  checksum: string;\n}\n\nexport interface CollectionIndexManagerConfig {\n  ttlMs?: number;\n  fetchTimeoutMs?: number;\n  maxRetries?: number;\n  baseRetryDelayMs?: number;\n  maxRetryDelayMs?: number;\n  cacheDir?: string;\n}\n\nexport class CollectionIndexManager {\n  private readonly INDEX_URL = 'https://raw.githubusercontent.com/DollhouseMCP/collection/main/public/collection-index.json';\n  private readonly TTL_MS: number;\n  private readonly FETCH_TIMEOUT_MS: number;\n  private readonly MAX_RETRIES: number;\n  private readonly BASE_RETRY_DELAY_MS: number;\n  private readonly MAX_RETRY_DELAY_MS: number;\n  private readonly CACHE_FILE: string;\n  \n  private cachedIndex: CollectionIndexCacheEntry | null = null;\n  private backgroundRefreshPromise: Promise<void> | null = null;\n  private isRefreshing = false;\n  private circuitBreakerFailures = 0;\n  private circuitBreakerLastFailure = 0;\n  private readonly CIRCUIT_BREAKER_THRESHOLD = 5;\n  private readonly CIRCUIT_BREAKER_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes\n  private readonly REFRESH_THRESHOLD = 0.8; // Refresh when 80% of TTL has passed\n  private readonly JITTER_FACTOR = 0.25; // ±25% randomness for jitter\n  \n  // Default configuration constants\n  private readonly DEFAULT_TTL_MS = 60 * 60 * 1000; // 1 hour\n  private readonly DEFAULT_MAX_RETRIES = 3;\n  private readonly DEFAULT_BASE_RETRY_DELAY_MS = 1000;\n  private readonly DEFAULT_MAX_RETRY_DELAY_MS = 30000;\n  private readonly DEFAULT_FETCH_TIMEOUT_MS = 5000; // 5 seconds\n  private readonly CHECKSUM_LENGTH = 8;\n  private readonly JSON_INDENT = 2;\n  \n  constructor(config: CollectionIndexManagerConfig = {}) {\n    // Configuration with environment variable overrides\n    this.TTL_MS = config.ttlMs || this.DEFAULT_TTL_MS;\n    this.FETCH_TIMEOUT_MS = this.parseFetchTimeout(config.fetchTimeoutMs);\n    this.MAX_RETRIES = config.maxRetries || this.DEFAULT_MAX_RETRIES;\n    this.BASE_RETRY_DELAY_MS = config.baseRetryDelayMs || this.DEFAULT_BASE_RETRY_DELAY_MS;\n    this.MAX_RETRY_DELAY_MS = config.maxRetryDelayMs || this.DEFAULT_MAX_RETRY_DELAY_MS;\n    \n    // Cache directory - use ~/.dollhouse/cache/collection-index.json as specified\n    const cacheDir = config.cacheDir || path.join(os.homedir(), '.dollhouse', 'cache');\n    this.CACHE_FILE = path.join(cacheDir, 'collection-index.json');\n    \n    logger.debug('CollectionIndexManager initialized', {\n      ttlMs: this.TTL_MS,\n      fetchTimeoutMs: this.FETCH_TIMEOUT_MS,\n      cacheFile: this.CACHE_FILE,\n      maxRetries: this.MAX_RETRIES\n    });\n  }\n  \n  /**\n   * Parse fetch timeout from config or environment variable\n   */\n  private parseFetchTimeout(configValue?: number): number {\n    // Check environment variable first\n    const envTimeout = process.env.COLLECTION_FETCH_TIMEOUT;\n    if (envTimeout) {\n      const parsed = parseInt(envTimeout, 10);\n      if (!isNaN(parsed) && parsed > 0) {\n        logger.debug(`Using COLLECTION_FETCH_TIMEOUT from environment: ${parsed}ms`);\n        return parsed;\n      }\n      logger.warn(`Invalid COLLECTION_FETCH_TIMEOUT value: ${envTimeout}, using default`);\n    }\n    \n    // Fall back to config value or default\n    return configValue || this.DEFAULT_FETCH_TIMEOUT_MS;\n  }\n  \n  /**\n   * Get collection index with stale-while-revalidate pattern\n   * Returns cached data immediately if available, refreshes in background\n   */\n  async getIndex(): Promise<CollectionIndex> {\n    try {\n      // Load from memory cache first\n      if (!this.cachedIndex) {\n        await this.loadFromDisk();\n      }\n      \n      // Check if we should return stale cache while refreshing\n      const shouldRefresh = this.shouldRefreshCache();\n      \n      if (this.cachedIndex && !this.isCacheExpired()) {\n        // Cache is valid, return immediately\n        logger.debug('Returning valid cached collection index');\n        \n        // Start background refresh if needed but not already running\n        if (shouldRefresh && !this.isRefreshing) {\n          this.startBackgroundRefresh();\n        }\n        \n        return this.cachedIndex.data;\n      }\n      \n      // If we have stale cache, return it while refreshing in background\n      if (this.cachedIndex && this.isCacheExpired()) {\n        logger.debug('Returning stale cache while refreshing in background');\n        \n        // Start background refresh if not already running\n        if (!this.isRefreshing) {\n          this.startBackgroundRefresh();\n        }\n        \n        return this.cachedIndex.data;\n      }\n      \n      // No cache available, must fetch synchronously\n      logger.debug('No cache available, fetching collection index synchronously');\n      const freshIndex = await this.fetchWithRetry();\n      await this.updateCache(freshIndex);\n      return freshIndex.data;\n      \n    } catch (error) {\n      logger.error('Failed to get collection index', { error: this.getErrorMessage(error) });\n      \n      // If we have any cached data (even expired), return it as last resort\n      if (this.cachedIndex) {\n        logger.warn('Returning expired cache as last resort');\n        return this.cachedIndex.data;\n      }\n      \n      throw new Error(`Collection index not available: ${this.getErrorMessage(error)}`);\n    }\n  }\n  \n  /**\n   * Force refresh the collection index\n   */\n  async forceRefresh(): Promise<CollectionIndex> {\n    logger.debug('Force refreshing collection index');\n    \n    try {\n      const freshIndex = await this.fetchWithRetry();\n      await this.updateCache(freshIndex);\n      return freshIndex.data;\n    } catch (error) {\n      logger.error('Force refresh failed', { error: this.getErrorMessage(error) });\n      \n      // If we have cached data, return it\n      if (this.cachedIndex) {\n        logger.warn('Force refresh failed, returning cached data');\n        return this.cachedIndex.data;\n      }\n      \n      throw error;\n    }\n  }\n  \n  /**\n   * Check if cache should be refreshed (within TTL but getting close to expiry)\n   */\n  private shouldRefreshCache(): boolean {\n    if (!this.cachedIndex) return true;\n    \n    const age = Date.now() - this.cachedIndex.timestamp;\n    const refreshThreshold = this.TTL_MS * this.REFRESH_THRESHOLD;\n    \n    return age > refreshThreshold;\n  }\n  \n  /**\n   * Check if cache is expired\n   */\n  private isCacheExpired(): boolean {\n    if (!this.cachedIndex) return true;\n    \n    const age = Date.now() - this.cachedIndex.timestamp;\n    return age > this.TTL_MS;\n  }\n  \n  /**\n   * Start background refresh without blocking\n   */\n  private startBackgroundRefresh(): void {\n    if (this.isRefreshing) {\n      logger.debug('Background refresh already in progress');\n      return;\n    }\n    \n    // Check circuit breaker\n    if (this.isCircuitBreakerOpen()) {\n      logger.debug('Circuit breaker open, skipping background refresh');\n      return;\n    }\n    \n    this.isRefreshing = true;\n    \n    this.backgroundRefreshPromise = this.performBackgroundRefresh()\n      .catch(error => {\n        logger.debug('Background refresh failed', { error: this.getErrorMessage(error) });\n        this.recordCircuitBreakerFailure();\n      })\n      .finally(() => {\n        this.isRefreshing = false;\n        this.backgroundRefreshPromise = null;\n      });\n  }\n  \n  /**\n   * Perform background refresh\n   */\n  private async performBackgroundRefresh(): Promise<void> {\n    logger.debug('Starting background refresh of collection index');\n    \n    try {\n      const freshIndex = await this.fetchWithRetry();\n      await this.updateCache(freshIndex);\n      \n      // Reset circuit breaker on success\n      this.circuitBreakerFailures = 0;\n      \n      logger.debug('Background refresh completed successfully');\n    } catch (error) {\n      logger.debug('Background refresh failed', { error: this.getErrorMessage(error) });\n      throw error;\n    }\n  }\n  \n  /**\n   * Fetch collection index with retry logic and exponential backoff\n   */\n  private async fetchWithRetry(): Promise<{ data: CollectionIndex; etag?: string; lastModified?: string }> {\n    let lastError: Error | null = null;\n    \n    for (let attempt = 0; attempt <= this.MAX_RETRIES; attempt++) {\n      try {\n        if (attempt > 0) {\n          const delay = this.calculateRetryDelay(attempt);\n          logger.debug(`Retrying fetch in ${delay}ms (attempt ${attempt + 1}/${this.MAX_RETRIES + 1})`);\n          await this.sleep(delay);\n        }\n        \n        return await this.fetchCollectionIndex();\n      } catch (error) {\n        lastError = error instanceof Error ? error : new Error(String(error));\n        logger.debug(`Fetch attempt ${attempt + 1} failed`, { \n          error: this.getErrorMessage(lastError),\n          willRetry: attempt < this.MAX_RETRIES\n        });\n      }\n    }\n    \n    throw lastError || new Error('All fetch attempts failed');\n  }\n  \n  /**\n   * Calculate retry delay with exponential backoff and jitter\n   */\n  private calculateRetryDelay(attempt: number): number {\n    // Exponential backoff: baseDelay * (2 ^ attempt)\n    const exponentialDelay = this.BASE_RETRY_DELAY_MS * Math.pow(2, attempt - 1);\n    \n    // Cap at maximum delay\n    const cappedDelay = Math.min(exponentialDelay, this.MAX_RETRY_DELAY_MS);\n    \n    // Add jitter to prevent thundering herd\n    return this.addJitter(cappedDelay);\n  }\n  \n  /**\n   * Add jitter (±25% randomness) to a delay to prevent thundering herd problems\n   */\n  private addJitter(delay: number): number {\n    const jitter = delay * this.JITTER_FACTOR * (Math.random() - 0.5);\n    return Math.max(0, delay + jitter);\n  }\n  \n  /**\n   * Fetch collection index from GitHub\n   */\n  private async fetchCollectionIndex(): Promise<{ data: CollectionIndex; etag?: string; lastModified?: string }> {\n    const controller = new AbortController();\n    const timeoutId = setTimeout(() => controller.abort(), this.FETCH_TIMEOUT_MS);\n    \n    try {\n      // Build headers for conditional requests\n      const headers: Record<string, string> = {\n        'Accept': 'application/json',\n        'User-Agent': 'DollhouseMCP/1.0',\n        'Cache-Control': 'no-cache'\n      };\n      \n      // Add conditional headers if we have cached data\n      if (this.cachedIndex?.etag) {\n        headers['If-None-Match'] = this.cachedIndex.etag;\n      }\n      if (this.cachedIndex?.lastModified) {\n        headers['If-Modified-Since'] = this.cachedIndex.lastModified;\n      }\n      \n      logger.debug('Fetching collection index', { \n        url: this.INDEX_URL,\n        timeout: this.FETCH_TIMEOUT_MS,\n        hasEtag: !!this.cachedIndex?.etag\n      });\n      \n      const response = await fetch(this.INDEX_URL, {\n        headers,\n        signal: controller.signal\n      });\n      \n      clearTimeout(timeoutId);\n      \n      // Handle 304 Not Modified\n      if (response.status === 304 && this.cachedIndex) {\n        logger.debug('Collection index not modified (304), updating cache timestamp');\n        this.cachedIndex.timestamp = Date.now();\n        await this.saveToDisk();\n        return {\n          data: this.cachedIndex.data,\n          etag: this.cachedIndex.etag,\n          lastModified: this.cachedIndex.lastModified\n        };\n      }\n      \n      if (!response.ok) {\n        throw new Error(`HTTP ${response.status}: ${response.statusText}`);\n      }\n      \n      const indexData = await response.json() as CollectionIndex;\n      \n      // Validate the index structure\n      this.validateIndexStructure(indexData);\n      \n      const etag = response.headers.get('etag') || undefined;\n      const lastModified = response.headers.get('last-modified') || undefined;\n      \n      logger.debug('Collection index fetched successfully', {\n        totalElements: indexData.total_elements,\n        version: indexData.version,\n        hasEtag: !!etag\n      });\n      \n      return { data: indexData, etag, lastModified };\n      \n    } catch (error) {\n      clearTimeout(timeoutId);\n      \n      if (error instanceof Error && error.name === 'AbortError') {\n        throw new Error(`Fetch timeout after ${this.FETCH_TIMEOUT_MS}ms`);\n      }\n      \n      throw error;\n    }\n  }\n  \n  /**\n   * Validate collection index structure\n   */\n  private validateIndexStructure(index: any): asserts index is CollectionIndex {\n    if (!index || typeof index !== 'object') {\n      throw new Error('Invalid index: not an object');\n    }\n    \n    if (typeof index.version !== 'string') {\n      throw new Error('Invalid index: missing or invalid version');\n    }\n    \n    if (typeof index.generated !== 'string') {\n      throw new Error('Invalid index: missing or invalid generated timestamp');\n    }\n    \n    if (typeof index.total_elements !== 'number') {\n      throw new Error('Invalid index: missing or invalid total_elements');\n    }\n    \n    if (!index.index || typeof index.index !== 'object') {\n      throw new Error('Invalid index: missing or invalid index object');\n    }\n    \n    if (!index.metadata || typeof index.metadata !== 'object') {\n      throw new Error('Invalid index: missing or invalid metadata');\n    }\n  }\n  \n  /**\n   * Update cache with new data\n   */\n  private async updateCache(fetchResult: { data: CollectionIndex; etag?: string; lastModified?: string }): Promise<void> {\n    const checksum = this.calculateChecksum(fetchResult.data);\n    \n    this.cachedIndex = {\n      data: fetchResult.data,\n      timestamp: Date.now(),\n      etag: fetchResult.etag,\n      lastModified: fetchResult.lastModified,\n      version: fetchResult.data.version,\n      checksum\n    };\n    \n    await this.saveToDisk();\n    \n    logger.debug('Collection index cache updated', {\n      version: fetchResult.data.version,\n      totalElements: fetchResult.data.total_elements,\n      checksum\n    });\n  }\n  \n  /**\n   * Calculate checksum for data integrity verification\n   */\n  private calculateChecksum(data: CollectionIndex): string {\n    // Simple checksum based on key properties\n    const checksumData = {\n      version: data.version,\n      generated: data.generated,\n      total_elements: data.total_elements\n    };\n    return Buffer.from(JSON.stringify(checksumData)).toString('base64').substring(0, this.CHECKSUM_LENGTH);\n  }\n  \n  /**\n   * Load cache from disk\n   */\n  private async loadFromDisk(): Promise<void> {\n    try {\n      const data = await fs.readFile(this.CACHE_FILE, 'utf8');\n      const cached = JSON.parse(data) as CollectionIndexCacheEntry;\n      \n      // Validate cache structure\n      if (!cached.data || !cached.timestamp || !cached.version) {\n        logger.debug('Invalid cache structure, ignoring');\n        return;\n      }\n      \n      // Verify checksum if available\n      if (cached.checksum) {\n        const expectedChecksum = this.calculateChecksum(cached.data);\n        if (cached.checksum !== expectedChecksum) {\n          logger.debug('Cache checksum mismatch, ignoring cached data');\n          return;\n        }\n      }\n      \n      this.cachedIndex = cached;\n      \n      const age = Date.now() - cached.timestamp;\n      const isExpired = age > this.TTL_MS;\n      \n      logger.debug('Loaded collection index from disk cache', {\n        version: cached.version,\n        age: Math.round(age / 1000),\n        isExpired,\n        totalElements: cached.data.total_elements\n      });\n      \n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug('Failed to load cache from disk', { error: this.getErrorMessage(error) });\n      }\n    }\n  }\n  \n  /**\n   * Save cache to disk\n   */\n  private async saveToDisk(): Promise<void> {\n    if (!this.cachedIndex) return;\n    \n    try {\n      // Ensure cache directory exists\n      await fs.mkdir(path.dirname(this.CACHE_FILE), { recursive: true });\n      \n      const cacheData = JSON.stringify(this.cachedIndex, null, this.JSON_INDENT);\n      await fs.writeFile(this.CACHE_FILE, cacheData, 'utf8');\n      \n      logger.debug('Collection index cache saved to disk');\n    } catch (error) {\n      logger.debug('Failed to save cache to disk', { error: this.getErrorMessage(error) });\n      // Don't throw - cache persistence failures shouldn't break functionality\n    }\n  }\n  \n  /**\n   * Circuit breaker logic\n   */\n  private isCircuitBreakerOpen(): boolean {\n    if (this.circuitBreakerFailures < this.CIRCUIT_BREAKER_THRESHOLD) {\n      return false;\n    }\n    \n    const timeSinceLastFailure = Date.now() - this.circuitBreakerLastFailure;\n    return timeSinceLastFailure < this.CIRCUIT_BREAKER_TIMEOUT_MS;\n  }\n  \n  private recordCircuitBreakerFailure(): void {\n    this.circuitBreakerFailures++;\n    this.circuitBreakerLastFailure = Date.now();\n    \n    if (this.circuitBreakerFailures >= this.CIRCUIT_BREAKER_THRESHOLD) {\n      logger.warn('Circuit breaker opened due to repeated failures', {\n        failures: this.circuitBreakerFailures,\n        timeoutMs: this.CIRCUIT_BREAKER_TIMEOUT_MS\n      });\n    }\n  }\n  \n  /**\n   * Utility methods\n   */\n  private sleep(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n  \n  private getErrorMessage(error: unknown): string {\n    if (error instanceof Error) {\n      return error.message;\n    }\n    return String(error);\n  }\n  \n  /**\n   * Get cache statistics for monitoring\n   */\n  getCacheStats(): {\n    isValid: boolean;\n    age: number;\n    hasCache: boolean;\n    version?: string;\n    totalElements?: number;\n    isRefreshing: boolean;\n    circuitBreakerFailures: number;\n    circuitBreakerOpen: boolean;\n  } {\n    if (!this.cachedIndex) {\n      return {\n        isValid: false,\n        age: 0,\n        hasCache: false,\n        isRefreshing: this.isRefreshing,\n        circuitBreakerFailures: this.circuitBreakerFailures,\n        circuitBreakerOpen: this.isCircuitBreakerOpen()\n      };\n    }\n    \n    const age = Date.now() - this.cachedIndex.timestamp;\n    \n    return {\n      isValid: !this.isCacheExpired(),\n      age: Math.round(age / 1000), // age in seconds\n      hasCache: true,\n      version: this.cachedIndex.version,\n      totalElements: this.cachedIndex.data.total_elements,\n      isRefreshing: this.isRefreshing,\n      circuitBreakerFailures: this.circuitBreakerFailures,\n      circuitBreakerOpen: this.isCircuitBreakerOpen()\n    };\n  }\n  \n  /**\n   * Clear all cache data\n   */\n  async clearCache(): Promise<void> {\n    this.cachedIndex = null;\n    this.circuitBreakerFailures = 0;\n    \n    try {\n      await fs.unlink(this.CACHE_FILE);\n      logger.debug('Collection index cache file deleted');\n    } catch (error) {\n      if ((error as any).code !== 'ENOENT') {\n        logger.debug('Failed to delete cache file', { error: this.getErrorMessage(error) });\n      }\n    }\n  }\n  \n  /**\n   * Wait for any ongoing background refresh to complete\n   */\n  async waitForBackgroundRefresh(): Promise<void> {\n    if (this.backgroundRefreshPromise) {\n      await this.backgroundRefreshPromise;\n    }\n  }\n}"]}

package/dist/collection/CollectionSearch.d.ts

@@ -3,11 +3,18 @@
  */
 import { GitHubClient } from './GitHubClient.js';
 import { CollectionCache } from '../cache/CollectionCache.js';
+import { SearchResults, SearchOptions } from '../types/collection.js';
 export declare class CollectionSearch {
     private githubClient;
     private collectionCache;
+    private indexCache;
     private searchBaseUrl;
     constructor(githubClient: GitHubClient, collectionCache?: CollectionCache);
+    /**
+     * Enhanced search using collection index with pagination and filtering
+     * Falls back to API search and cache when index is unavailable
+     */
+    searchCollectionWithOptions(query: string, options?: SearchOptions): Promise<SearchResults>;
     /**
      * Search collection for content matching query
      * Falls back to cached data when GitHub API is not available or not authenticated
@@ -21,6 +28,10 @@ export declare class CollectionSearch {
      * Search seed data for matching items with fuzzy matching
      */
     private searchSeedData;
+    /**
+     * Fuzzy matching algorithm for partial string matches
+     */
+    private fuzzyMatch;
     /**
      * Convert cache items to GitHub API format for consistent response structure
      */
@@ -33,5 +44,49 @@ export declare class CollectionSearch {
      * Format search results
      */
     formatSearchResults(items: any[], query: string, personaIndicator?: string): string;
+    /**
+     * Search from collection index with full featured search and pagination
+     */
+    private searchFromIndex;
+    /**
+     * Flatten index entries from all categories into a single array
+     */
+    private flattenIndexEntries;
+    /**
+     * Perform search matching on index entries
+     */
+    private performIndexSearch;
+    /**
+     * Sort search results by relevance, name, or date
+     */
+    private sortSearchResults;
+    /**
+     * Calculate relevance score for search results
+     */
+    private calculateRelevanceScore;
+    /**
+     * Convert legacy search results to new SearchResults format
+     */
+    private convertLegacyResults;
+    /**
+     * Extract element type from file path
+     */
+    private extractTypeFromPath;
+    /**
+     * Extract category from file path
+     */
+    private extractCategoryFromPath;
+    /**
+     * Create empty search results for error cases
+     */
+    private createEmptySearchResults;
+    /**
+     * Enhanced format for search results with pagination info
+     */
+    formatSearchResultsWithPagination(results: SearchResults, personaIndicator?: string): string;
+    /**
+     * Get cache statistics for debugging
+     */
+    getCacheStats(): Promise<any>;
 }
 //# sourceMappingURL=CollectionSearch.d.ts.map