@dollhousemcp/mcp-server 1.5.2 → 1.6.0

package/dist/portfolio/DefaultElementProvider.js

@@ -6,6 +6,7 @@
  * It ensures users have example content to work with immediately after installation.
  */
 import * as fs from 'fs/promises';
+import * as fsSync from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
@@ -13,6 +14,7 @@ import { logger } from '../utils/logger.js';
 import { ElementType } from './types.js';
 import { UnicodeValidator } from '../security/validators/unicodeValidator.js';
 import { SecurityMonitor } from '../security/securityMonitor.js';
+import { SecureYamlParser } from '../security/secureYamlParser.js';
 // File operation constants
 export const FILE_CONSTANTS = {
     ELEMENT_EXTENSION: '.md',
@@ -24,6 +26,18 @@ export const FILE_CONSTANTS = {
     FILE_PERMISSIONS: 0o644,
     CHUNK_SIZE: 64 * 1024 // 64KB chunks for reading large files
 };
+// Development mode detection
+// When running from a git clone, we don't want to auto-load test data
+const IS_DEVELOPMENT_MODE = (() => {
+    try {
+        // Check if we're in a git repository (development mode)
+        const gitDir = path.join(process.cwd(), '.git');
+        return fsSync.existsSync(gitDir);
+    }
+    catch {
+        return false;
+    }
+})();
 // Internal constants
 const DATA_DIR_CACHE_KEY = 'dollhouse_data_dir';
 const COPY_RETRY_ATTEMPTS = 3;
@@ -33,13 +47,66 @@ export class DefaultElementProvider {
     static cachedDataDir = null;
     static populateInProgress = new Map();
     config;
+    // PERFORMANCE OPTIMIZATION: Cache metadata with file mtime for invalidation
+    static metadataCache = new Map();
+    static MAX_CACHE_SIZE = 20; // MEMORY LEAK FIX: Further reduced cache size to prevent accumulation during performance tests
     constructor(config) {
         const __filename = fileURLToPath(import.meta.url);
         this.__dirname = path.dirname(__filename);
+        // Check environment variable for test data loading
+        const envLoadTestData = process.env.DOLLHOUSE_LOAD_TEST_DATA;
+        const loadTestDataFromEnv = envLoadTestData === 'true' || envLoadTestData === '1';
+        const disableTestDataFromEnv = envLoadTestData === 'false' || envLoadTestData === '0';
+        // Check if we're in development mode (with respect to FORCE_PRODUCTION_MODE override)
+        const isDevMode = (() => {
+            // Respect FORCE_PRODUCTION_MODE override first
+            if (process.env.FORCE_PRODUCTION_MODE === 'true') {
+                return false; // Force production mode
+            }
+            if (process.env.FORCE_PRODUCTION_MODE === 'false') {
+                return true; // Force development mode
+            }
+            // Fall back to git detection
+            return IS_DEVELOPMENT_MODE;
+        })();
+        // Determine loadTestData value
+        let computedLoadTestData;
+        if (loadTestDataFromEnv) {
+            // Environment explicitly enables test data
+            computedLoadTestData = true;
+        }
+        else if (disableTestDataFromEnv) {
+            // Environment explicitly disables test data
+            computedLoadTestData = false;
+        }
+        else {
+            // Default logic: enable in production, disable in development unless config overrides
+            computedLoadTestData = !isDevMode && (config?.loadTestData ?? true);
+        }
         this.config = {
             useDefaultPaths: true,
-            ...config
+            ...config,
+            // Apply final loadTestData logic - environment variables and development mode take precedence
+            loadTestData: loadTestDataFromEnv ? true : disableTestDataFromEnv ? false : computedLoadTestData
         };
+        if (isDevMode && !this.config.loadTestData) {
+            logger.info('[DefaultElementProvider] Development mode detected - test data loading disabled');
+            logger.info('[DefaultElementProvider] To enable test data, set DOLLHOUSE_LOAD_TEST_DATA=true');
+        }
+    }
+    /**
+     * Get the current loadTestData configuration value
+     * @returns Whether test data loading is enabled
+     */
+    get isTestDataLoadingEnabled() {
+        return this.config.loadTestData ?? false;
+    }
+    /**
+     * Get whether the system is in development mode
+     * @returns Whether running in development mode
+     */
+    get isDevelopmentMode() {
+        return IS_DEVELOPMENT_MODE;
     }
     /**
      * Search paths for bundled data directory
@@ -53,9 +120,15 @@ export class DefaultElementProvider {
         }
         // Add default paths if enabled
         if (this.config.useDefaultPaths !== false) {
+            // Skip development/repository data paths unless test data loading is enabled
+            if (this.config.loadTestData) {
+                // Development/Git installation (relative to this file)
+                paths.push(path.join(this.__dirname, '../../data'), path.join(this.__dirname, '../../../data'), 
+                // Current working directory (last resort)
+                path.join(process.cwd(), 'data'));
+            }
+            // Always include NPM installation paths (these would have production data)
             paths.push(
-            // Development/Git installation (relative to this file)
-            path.join(this.__dirname, '../../data'), path.join(this.__dirname, '../../../data'), 
             // NPM installations - macOS Homebrew
             '/opt/homebrew/lib/node_modules/@dollhousemcp/mcp-server/data', 
             // NPM installations - standard Unix/Linux
@@ -63,9 +136,7 @@ export class DefaultElementProvider {
             // NPM installations - Windows
             'C:\\Program Files\\nodejs\\node_modules\\@dollhousemcp\\mcp-server\\data', 'C:\\Program Files (x86)\\nodejs\\node_modules\\@dollhousemcp\\mcp-server\\data', 
             // NPM installations - Windows with nvm
-            path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data'), 
-            // Current working directory (last resort)
-            path.join(process.cwd(), 'data'));
+            path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data'));
         }
         return paths;
     }
@@ -122,6 +193,380 @@ export class DefaultElementProvider {
             return false;
         }
     }
+    /**
+     * Validate file path to prevent path traversal attacks
+     * SECURITY FIX: Added file path validation to prevent directory traversal
+     * Previously: File paths were used without validation, allowing potential ../../../ attacks
+     * Now: Strict validation ensures paths stay within allowed directories
+     * @param filePath The file path to validate
+     * @param allowedBasePaths Array of allowed base paths (optional)
+     * @returns true if path is safe, false otherwise
+     */
+    validateFilePath(filePath, allowedBasePaths) {
+        try {
+            // SECURITY: Normalize path to prevent traversal attempts
+            const normalizedPath = path.normalize(filePath);
+            // SECURITY: Reject paths containing traversal patterns
+            if (normalizedPath.includes('..')) {
+                logger.warn(`[DefaultElementProvider] Path traversal attempt blocked: ${filePath}`);
+                return false;
+            }
+            // SECURITY: Check for home directory expansion attempts, but allow Windows 8.3 short path names
+            // Windows short path names use ~ followed by a digit (e.g., RUNNER~1), which should be allowed
+            // Only block ~ followed by / or \ (home directory expansion patterns)
+            if (normalizedPath.includes('~/') || normalizedPath.includes('~\\')) {
+                logger.warn(`[DefaultElementProvider] Home directory expansion attempt blocked: ${filePath}`);
+                return false;
+            }
+            // SECURITY: Reject absolute paths outside allowed directories
+            if (path.isAbsolute(normalizedPath) && allowedBasePaths) {
+                const isAllowed = allowedBasePaths.some(basePath => {
+                    const normalizedBase = path.normalize(basePath);
+                    return normalizedPath.startsWith(normalizedBase);
+                });
+                if (!isAllowed) {
+                    logger.warn(`[DefaultElementProvider] Absolute path outside allowed directories: ${filePath}`);
+                    return false;
+                }
+            }
+            // SECURITY: Reject null bytes and other dangerous characters
+            if (normalizedPath.includes('\0') || normalizedPath.includes('\x00')) {
+                logger.warn(`[DefaultElementProvider] Null byte in path blocked: ${filePath}`);
+                return false;
+            }
+            return true;
+        }
+        catch (error) {
+            logger.warn(`[DefaultElementProvider] Path validation error: ${error}`);
+            return false;
+        }
+    }
+    // DEPRECATED: Commented out filename pattern detection - replaced with metadata-based detection
+    /**
+     * Cached compiled regex patterns for performance optimization
+     * @deprecated Use metadata-based detection instead
+     */
+    // private static compiledTestPatterns: RegExp[] | null = null;
+    /**
+     * Get compiled test patterns with caching for better performance
+     * @deprecated Use metadata-based detection instead
+     * @returns Array of compiled regex patterns
+     */
+    // private getCompiledTestPatterns(): RegExp[] {
+    //   // Use cached patterns if available
+    //   if (DefaultElementProvider.compiledTestPatterns) {
+    //     return DefaultElementProvider.compiledTestPatterns;
+    //   }
+    //   
+    //   // Compile and cache patterns on first use
+    //   // CRITICAL FIX: Removed overly broad /^test-/i pattern that was blocking legitimate use
+    //   // Users should be able to create personas like "test-driven-developer" or "test-automation-expert"
+    //   // We only block specific test patterns that are clearly from our test suite
+    //   DefaultElementProvider.compiledTestPatterns = [
+    //     /^testpersona/i,              // Our test suite pattern
+    //     /^yamltest/i,                 // Security test pattern
+    //     /^yamlbomb/i,                 // Security test pattern
+    //     /^memory-test-/i,             // Performance test pattern
+    //     /^perf-test-/i,               // Performance test pattern
+    //     /^test-fixture-/i,            // Test fixture pattern (more specific)
+    //     /^test-data-/i,               // Test data pattern (more specific)
+    //     /bin-sh|rm-rf|pwned/i,        // Malicious patterns
+    //     /concurrent-\d+/i,            // Concurrent test pattern
+    //     /legacy\.md$/i,               // Legacy test pattern
+    //     /performance-test/i,          // Performance test pattern
+    //     /-\d{13}-[a-z0-9]+\.md$/i,    // Timestamp-based test files
+    //     /^unittest-/i,                // Unit test pattern
+    //     /^integrationtest-/i,         // Integration test pattern
+    //   ];
+    //   
+    //   return DefaultElementProvider.compiledTestPatterns;
+    // }
+    /**
+     * Check if a filename matches test data patterns that should never be copied to production
+     * @deprecated Use isDollhouseMCPTestElement() for metadata-based detection instead
+     * @param filename The filename to check
+     * @returns true if the filename matches test patterns that should be blocked
+     */
+    // private isTestDataPattern(filename: string): boolean {
+    //   const patterns = this.getCompiledTestPatterns();
+    //   return patterns.some(pattern => pattern.test(filename));
+    // }
+    /**
+     * Read metadata from YAML frontmatter only (never reads content body)
+     * Uses a small buffer to safely extract only the frontmatter between --- markers
+     * @param filePath Path to the file to read metadata from
+     * @returns Parsed metadata object or null if no frontmatter found
+     */
+    // PERFORMANCE OPTIMIZATION: Reusable buffer pool to reduce allocations
+    static bufferPool = [];
+    static MAX_POOL_SIZE = 20; // MEMORY LEAK FIX: Reduced buffer pool size to match cache size for consistent memory management
+    static bufferPoolStats = { hits: 0, misses: 0, created: 0 };
+    getBuffer() {
+        // PERFORMANCE: Track buffer pool usage for optimization monitoring
+        let buffer = DefaultElementProvider.bufferPool.pop();
+        if (buffer) {
+            DefaultElementProvider.bufferPoolStats.hits++;
+            return buffer;
+        }
+        else {
+            DefaultElementProvider.bufferPoolStats.misses++;
+            DefaultElementProvider.bufferPoolStats.created++;
+            buffer = Buffer.alloc(4096);
+            logger.debug(`[DefaultElementProvider] Created new buffer (pool empty), total created: ${DefaultElementProvider.bufferPoolStats.created}`);
+            return buffer;
+        }
+    }
+    releaseBuffer(buffer) {
+        // CRITICAL FIX: Always attempt to return buffer to pool for reuse
+        if (DefaultElementProvider.bufferPool.length < DefaultElementProvider.MAX_POOL_SIZE) {
+            buffer.fill(0); // SECURITY: Clear buffer before reuse to prevent data leakage
+            DefaultElementProvider.bufferPool.push(buffer);
+        }
+        else {
+            // PERFORMANCE: If pool is full, clear the buffer to help GC
+            buffer.fill(0);
+            logger.debug('[DefaultElementProvider] Buffer pool full, discarding buffer');
+        }
+    }
+    /**
+     * Clean up buffer pool and cache to free memory
+     * PERFORMANCE FIX: Added cleanup method to prevent memory leaks
+     * This should be called during application shutdown or periodic cleanup
+     */
+    static cleanup() {
+        // Clear buffer pool
+        DefaultElementProvider.bufferPool.length = 0;
+        // Clear metadata cache
+        DefaultElementProvider.metadataCache.clear();
+        // Clear cached data directory
+        DefaultElementProvider.cachedDataDir = null;
+        // Clear population promises
+        DefaultElementProvider.populateInProgress.clear();
+        logger.info('[DefaultElementProvider] Memory cleanup completed', {
+            bufferStats: DefaultElementProvider.bufferPoolStats,
+            cacheCleared: true
+        });
+        // Reset stats
+        DefaultElementProvider.bufferPoolStats = { hits: 0, misses: 0, created: 0 };
+    }
+    /**
+     * Get performance statistics for monitoring
+     * PERFORMANCE MONITORING: Added statistics method for performance tracking
+     * This provides insights into buffer pool efficiency and cache performance
+     * @returns Object containing performance metrics
+     */
+    static getPerformanceStats() {
+        const bufferHits = DefaultElementProvider.bufferPoolStats.hits;
+        const bufferMisses = DefaultElementProvider.bufferPoolStats.misses;
+        const totalRequests = bufferHits + bufferMisses;
+        return {
+            bufferPool: {
+                hits: bufferHits,
+                misses: bufferMisses,
+                created: DefaultElementProvider.bufferPoolStats.created,
+                hitRate: totalRequests > 0 ? bufferHits / totalRequests : 0,
+                poolSize: DefaultElementProvider.bufferPool.length,
+                maxPoolSize: DefaultElementProvider.MAX_POOL_SIZE
+            },
+            metadataCache: {
+                size: DefaultElementProvider.metadataCache.size,
+                maxSize: DefaultElementProvider.MAX_CACHE_SIZE
+            }
+        };
+    }
+    async readMetadataOnly(filePath, retries = 2) {
+        // PERFORMANCE: Check cache first before reading file
+        try {
+            const stats = await fs.stat(filePath);
+            const cacheKey = filePath;
+            const cached = DefaultElementProvider.metadataCache.get(cacheKey);
+            // Return cached metadata if file hasn't changed 
+            // CRITICAL FIX: Use integer mtime comparison to avoid floating-point precision issues
+            if (cached && Math.floor(cached.mtime) === Math.floor(stats.mtimeMs) && cached.size === stats.size) {
+                logger.debug(`[DefaultElementProvider] Cache hit for ${filePath}`);
+                return cached.metadata;
+            }
+        }
+        catch {
+            // File doesn't exist, proceed with normal flow
+        }
+        try {
+            // Open file and read only first 4KB to avoid reading dangerous content
+            const fd = await fs.open(filePath, 'r');
+            // PERFORMANCE: Use buffer pool instead of allocating new buffer each time
+            const buffer = this.getBuffer();
+            try {
+                const result = await fd.read(buffer, 0, 4096, 0);
+                const header = buffer.subarray(0, result.bytesRead).toString('utf-8');
+                // Look for YAML frontmatter between --- markers
+                // Support both Unix (\n) and Windows (\r\n) line endings
+                const match = header.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+                if (!match) {
+                    return null; // No frontmatter found
+                }
+                // Parse the YAML frontmatter safely
+                try {
+                    // SECURITY FIX: Replace direct YAML parsing function with SecureYamlParser for enhanced security
+                    // SecureYamlParser provides additional validation, injection prevention, and content sanitization
+                    // It expects full YAML with --- markers, so we reconstruct the frontmatter block
+                    // We disable specific field validation as this is general metadata parsing, not persona-specific
+                    const fullYaml = `---\n${match[1]}\n---`;
+                    const parseResult = SecureYamlParser.parse(fullYaml, {
+                        validateContent: false,
+                        validateFields: false
+                    });
+                    const metadata = parseResult.data;
+                    // PERFORMANCE: Cache the metadata with file stats for future reads
+                    if (typeof metadata === 'object' && metadata !== null) {
+                        try {
+                            const stats = await fs.stat(filePath);
+                            const cacheEntry = {
+                                metadata,
+                                mtime: stats.mtimeMs,
+                                size: stats.size
+                            };
+                            // CRITICAL MEMORY LEAK FIX: More aggressive cache management to prevent unbounded growth
+                            // Check if this entry already exists and just update it instead of adding new
+                            if (DefaultElementProvider.metadataCache.has(filePath)) {
+                                // Update existing entry - no eviction needed
+                                DefaultElementProvider.metadataCache.set(filePath, cacheEntry);
+                                logger.debug(`[DefaultElementProvider] Updated existing cache entry for ${filePath}`);
+                            }
+                            else {
+                                // New entry - check if we need to evict first
+                                // Use > instead of >= to ensure we never exceed MAX_CACHE_SIZE
+                                if (DefaultElementProvider.metadataCache.size >= DefaultElementProvider.MAX_CACHE_SIZE) {
+                                    // More aggressive eviction: remove enough entries to stay well under limit
+                                    const entriesToEvict = Math.max(1, Math.floor(DefaultElementProvider.MAX_CACHE_SIZE * 0.4));
+                                    const keysToEvict = Array.from(DefaultElementProvider.metadataCache.keys()).slice(0, entriesToEvict);
+                                    for (const key of keysToEvict) {
+                                        DefaultElementProvider.metadataCache.delete(key);
+                                    }
+                                    logger.debug(`[DefaultElementProvider] Evicted ${keysToEvict.length} cache entries to manage memory (cache size was ${DefaultElementProvider.metadataCache.size + keysToEvict.length})`);
+                                }
+                                DefaultElementProvider.metadataCache.set(filePath, cacheEntry);
+                                logger.debug(`[DefaultElementProvider] Added new cache entry for ${filePath} (cache size now: ${DefaultElementProvider.metadataCache.size})`);
+                            }
+                        }
+                        catch {
+                            // Ignore cache errors, return metadata anyway
+                        }
+                        return metadata;
+                    }
+                    return null;
+                }
+                catch (yamlError) {
+                    // Invalid YAML, return null
+                    // ENHANCEMENT: Include error type for better debugging
+                    const yamlErrorType = yamlError?.constructor?.name || 'YAMLError';
+                    logger.debug(`[DefaultElementProvider] Invalid YAML in ${filePath}: ${yamlErrorType} - ${yamlError}`);
+                    return null;
+                }
+            }
+            finally {
+                // CRITICAL FIX: Ensure file descriptor is closed and buffer is released in ALL paths
+                try {
+                    await fd.close();
+                }
+                catch (closeError) {
+                    logger.debug(`[DefaultElementProvider] Error closing file descriptor for ${filePath}: ${closeError}`);
+                }
+                // PERFORMANCE: Return buffer to pool for reuse
+                this.releaseBuffer(buffer);
+            }
+        }
+        catch (error) {
+            // ENHANCEMENT: Include error type in debug logs for better debugging
+            const errorType = error?.constructor?.name || 'UnknownError';
+            const errorCode = error?.code || 'NO_CODE';
+            // RELIABILITY: Add retry logic for transient failures
+            if (retries > 0 && (errorCode === 'EBUSY' || errorCode === 'EAGAIN')) {
+                logger.debug(`[DefaultElementProvider] Retrying read for ${filePath} after ${errorType}:${errorCode}`);
+                await new Promise(resolve => setTimeout(resolve, 50)); // Brief delay before retry
+                return this.readMetadataOnly(filePath, retries - 1);
+            }
+            logger.debug(`[DefaultElementProvider] Could not read metadata from ${filePath}: ${errorType}:${errorCode} - ${error?.message || error}`);
+            return null;
+        }
+    }
+    /**
+     * Check if a file is a DollhouseMCP test element based on metadata
+     * This replaces filename pattern detection with accurate metadata-based detection
+     * @param filePath Path to the file to check
+     * @returns true if the file contains _dollhouseMCPTest: true metadata
+     */
+    async isDollhouseMCPTestElement(filePath) {
+        try {
+            const metadata = await this.readMetadataOnly(filePath);
+            const isTest = !!(metadata && metadata._dollhouseMCPTest === true);
+            return isTest;
+        }
+        catch (error) {
+            // If we can't read the metadata, assume it's not a test file
+            logger.debug(`[DefaultElementProvider] Error checking test metadata for ${filePath}: ${error}`);
+            return false;
+        }
+    }
+    /**
+     * Detect if we're in a production environment by checking for production indicators
+     * Uses a confidence-based approach requiring multiple indicators for better accuracy
+     * @returns true if this appears to be a production environment
+     */
+    isProductionEnvironment() {
+        // Allow tests to explicitly override production mode detection
+        if (process.env.FORCE_PRODUCTION_MODE === 'true') {
+            return true;
+        }
+        if (process.env.FORCE_PRODUCTION_MODE === 'false') {
+            return false;
+        }
+        // Weighted indicators for production detection
+        const indicators = {
+            // Strong indicators (weight: 2)
+            hasUserHomeDir: (process.env.HOME && (process.env.HOME.includes('/Users/') || process.env.HOME.includes('/home/'))) ||
+                !!process.env.USERPROFILE,
+            isProductionNode: process.env.NODE_ENV === 'production',
+            notInTestDir: (() => {
+                const cwd = process.cwd().toLowerCase();
+                // Normalize path separators for cross-platform checking (Windows uses \ but checks use /)
+                const normalizedCwd = cwd.replace(/\\/g, '/');
+                return !normalizedCwd.includes('/test') &&
+                    !normalizedCwd.includes('/__tests__') &&
+                    !normalizedCwd.includes('/temp') &&
+                    !normalizedCwd.includes('/dist/test');
+            })(),
+            // Moderate indicators (weight: 1)
+            notInCI: !process.env.CI,
+            noTestEnv: process.env.NODE_ENV !== 'test',
+            noDevEnv: process.env.NODE_ENV !== 'development',
+        };
+        // Calculate weighted score
+        let score = 0;
+        if (indicators.hasUserHomeDir)
+            score += 2;
+        if (indicators.isProductionNode)
+            score += 2;
+        if (indicators.notInTestDir)
+            score += 2;
+        if (indicators.notInCI)
+            score += 1;
+        if (indicators.noTestEnv)
+            score += 1;
+        if (indicators.noDevEnv)
+            score += 1;
+        // Log detection details for debugging
+        const activeIndicators = Object.entries(indicators)
+            .filter(([_, value]) => value)
+            .map(([key]) => key);
+        // TYPESCRIPT FIX: Removed logger.isDebugEnabled() check as this method doesn't exist on MCPLogger
+        // The logger already handles debug level internally, so we can call debug() directly
+        if (score >= 3) {
+            logger.debug('[DefaultElementProvider] Production environment detected', { score, activeIndicators, forceMode: 'not set' });
+        }
+        // Require a score of at least 3 for production detection (more confident)
+        // This prevents false positives in edge cases while maintaining security
+        return score >= 3;
+    }
     /**
      * Copy all files from source directory to destination directory
      * Skips files that already exist to preserve user modifications
@@ -146,6 +591,40 @@ export class DefaultElementProvider {
                 }
                 const sourcePath = path.join(sourceDir, normalizedFile.normalizedContent);
                 const destPath = path.join(destDir, normalizedFile.normalizedContent);
+                // SECURITY FIX: Validate file paths to prevent path traversal attacks
+                // This prevents malicious files from escaping the intended directory structure
+                const sourceValid = this.validateFilePath(sourcePath, [sourceDir]);
+                const destValid = this.validateFilePath(destPath, [destDir]);
+                if (!sourceValid || !destValid) {
+                    logger.warn(`[DefaultElementProvider] Skipping file with invalid path: ${normalizedFile.normalizedContent}`, { sourcePath, destPath, elementType });
+                    continue;
+                }
+                // Production safety check: Block DollhouseMCP test elements in production environments
+                // Skip this check if loadTestData is explicitly enabled (for testing scenarios)
+                if (!this.config.loadTestData && this.isProductionEnvironment()) {
+                    const isDollhouseTest = await this.isDollhouseMCPTestElement(sourcePath);
+                    if (isDollhouseTest) {
+                        logger.warn(`[DefaultElementProvider] SECURITY: Blocking DollhouseMCP test element in production: ${normalizedFile.normalizedContent}`, {
+                            file: normalizedFile.normalizedContent,
+                            reason: 'DollhouseMCP test element detected in production environment',
+                            elementType
+                        });
+                        // Log security event for blocked test data
+                        SecurityMonitor.logSecurityEvent({
+                            type: 'TEST_DATA_BLOCKED',
+                            severity: 'MEDIUM',
+                            source: 'DefaultElementProvider.copyElementFiles',
+                            details: `Blocked DollhouseMCP test element in production: ${normalizedFile.normalizedContent}`,
+                            metadata: {
+                                filename: normalizedFile.normalizedContent,
+                                elementType,
+                                reason: 'DollhouseMCP test element detected in production environment',
+                                detectionMethod: 'metadata-based'
+                            }
+                        });
+                        continue;
+                    }
+                }
                 try {
                     // Check if destination file already exists
                     await fs.access(destPath);
@@ -322,6 +801,19 @@ export class DefaultElementProvider {
      * @param portfolioBaseDir Base directory of the portfolio
      */
     async performPopulation(portfolioBaseDir) {
+        // Check if test data loading is disabled
+        // Note: This check is needed even though constructor sets config, because
+        // config can be overridden after construction
+        // Use production environment detection that respects FORCE_PRODUCTION_MODE
+        const isDevelopmentMode = !this.isProductionEnvironment();
+        if (isDevelopmentMode && !this.config.loadTestData) {
+            logger.info('[DefaultElementProvider] Skipping default element population in development mode', {
+                portfolioBaseDir,
+                reason: 'Test data loading disabled',
+                enableWith: 'Set DOLLHOUSE_LOAD_TEST_DATA=true to enable'
+            });
+            return;
+        }
         logger.info('[DefaultElementProvider] Starting default element population', { portfolioBaseDir });
         // Log security event for portfolio initialization
         SecurityMonitor.logSecurityEvent({
@@ -383,4 +875,4 @@ export class DefaultElementProvider {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DefaultElementProvider.js","sourceRoot":"","sources":["../../src/portfolio/DefaultElementProvider.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * DefaultElementProvider - Populates portfolio with default elements from bundled data\n * \n * This class handles copying default personas, skills, templates, and other elements\n * from the NPM package or Git repository to the user's portfolio on first run.\n * It ensures users have example content to work with immediately after installation.\n */\n\nimport * as fs from 'fs/promises';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { createHash } from 'crypto';\nimport { logger } from '../utils/logger.js';\nimport { ElementType } from './types.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\n\n// File operation constants\nexport const FILE_CONSTANTS = {\n  ELEMENT_EXTENSION: '.md',\n  YAML_EXTENSION: '.yaml',\n  YML_EXTENSION: '.yml',\n  JSON_EXTENSION: '.json',\n  MAX_FILE_SIZE: 10 * 1024 * 1024, // 10MB max file size for safety\n  CHECKSUM_ALGORITHM: 'sha256',\n  FILE_PERMISSIONS: 0o644,\n  CHUNK_SIZE: 64 * 1024 // 64KB chunks for reading large files\n} as const;\n\n// Internal constants\nconst DATA_DIR_CACHE_KEY = 'dollhouse_data_dir';\nconst COPY_RETRY_ATTEMPTS = 3;\nconst COPY_RETRY_DELAY = 100; // ms\n\nexport interface DefaultElementProviderConfig {\n  /** Custom data directory paths to search (checked before default paths) */\n  customDataPaths?: string[];\n  /** Whether to use default search paths after custom paths */\n  useDefaultPaths?: boolean;\n}\n\nexport class DefaultElementProvider {\n  private readonly __dirname: string;\n  private static cachedDataDir: string | null = null;\n  private static populateInProgress: Map<string, Promise<void>> = new Map();\n  private readonly config: DefaultElementProviderConfig;\n  \n  constructor(config?: DefaultElementProviderConfig) {\n    const __filename = fileURLToPath(import.meta.url);\n    this.__dirname = path.dirname(__filename);\n    this.config = {\n      useDefaultPaths: true,\n      ...config\n    };\n  }\n  \n  /**\n   * Search paths for bundled data directory\n   * Ordered by priority - custom paths first, then development/git, then NPM locations\n   */\n  private get dataSearchPaths(): string[] {\n    const paths: string[] = [];\n    \n    // Add custom paths first (highest priority)\n    if (this.config.customDataPaths) {\n      paths.push(...this.config.customDataPaths);\n    }\n    \n    // Add default paths if enabled\n    if (this.config.useDefaultPaths !== false) {\n      paths.push(\n        // Development/Git installation (relative to this file)\n        path.join(this.__dirname, '../../data'),\n        path.join(this.__dirname, '../../../data'),\n        \n        // NPM installations - macOS Homebrew\n        '/opt/homebrew/lib/node_modules/@dollhousemcp/mcp-server/data',\n        \n        // NPM installations - standard Unix/Linux\n        '/usr/local/lib/node_modules/@dollhousemcp/mcp-server/data',\n        '/usr/lib/node_modules/@dollhousemcp/mcp-server/data',\n        \n        // NPM installations - Windows\n        'C:\\\\Program Files\\\\nodejs\\\\node_modules\\\\@dollhousemcp\\\\mcp-server\\\\data',\n        'C:\\\\Program Files (x86)\\\\nodejs\\\\node_modules\\\\@dollhousemcp\\\\mcp-server\\\\data',\n        \n        // NPM installations - Windows with nvm\n        path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data'),\n        \n        // Current working directory (last resort)\n        path.join(process.cwd(), 'data')\n      );\n    }\n    \n    return paths;\n  }\n  \n  /**\n   * Find the bundled data directory by checking each search path\n   * Uses Promise.allSettled for better performance and caches the result\n   */\n  private async findDataDirectory(): Promise<string | null> {\n    // Return cached value if available\n    if (DefaultElementProvider.cachedDataDir !== null) {\n      return DefaultElementProvider.cachedDataDir;\n    }\n    \n    // Check all paths in parallel for better performance\n    const checkPromises = this.dataSearchPaths.map(async (searchPath) => {\n      try {\n        const stats = await fs.stat(searchPath);\n        if (stats.isDirectory()) {\n          // Verify it contains expected subdirectories\n          const hasPersonas = await this.directoryExists(path.join(searchPath, 'personas'));\n          const hasSkills = await this.directoryExists(path.join(searchPath, 'skills'));\n          if (hasPersonas || hasSkills) {\n            return searchPath;\n          }\n        }\n      } catch (error) {\n        // Directory doesn't exist or can't be accessed\n        return null;\n      }\n      return null;\n    });\n    \n    const results = await Promise.allSettled(checkPromises);\n    \n    // Find the first successful result\n    for (const result of results) {\n      if (result.status === 'fulfilled' && result.value !== null) {\n        logger.info(`[DefaultElementProvider] Found data directory at: ${result.value}`);\n        // Cache the result\n        DefaultElementProvider.cachedDataDir = result.value;\n        return result.value;\n      }\n    }\n    \n    logger.warn('[DefaultElementProvider] No bundled data directory found in any search path');\n    return null;\n  }\n  \n  /**\n   * Helper to check if a directory exists\n   */\n  private async directoryExists(dirPath: string): Promise<boolean> {\n    try {\n      const stats = await fs.stat(dirPath);\n      return stats.isDirectory();\n    } catch {\n      return false;\n    }\n  }\n  \n  /**\n   * Copy all files from source directory to destination directory\n   * Skips files that already exist to preserve user modifications\n   */\n  private async copyElementFiles(sourceDir: string, destDir: string, elementType: string): Promise<number> {\n    let copiedCount = 0;\n    \n    try {\n      // Ensure destination directory exists\n      await fs.mkdir(destDir, { recursive: true });\n      \n      // Read source directory\n      const files = await fs.readdir(sourceDir);\n      \n      for (const file of files) {\n        // Only copy markdown files\n        if (!file.endsWith(FILE_CONSTANTS.ELEMENT_EXTENSION)) {\n          continue;\n        }\n        \n        // Normalize filename for security\n        const normalizedFile = UnicodeValidator.normalize(file);\n        if (!normalizedFile.isValid) {\n          logger.warn(`[DefaultElementProvider] Skipping file with invalid Unicode: ${file}`);\n          continue;\n        }\n        \n        const sourcePath = path.join(sourceDir, normalizedFile.normalizedContent);\n        const destPath = path.join(destDir, normalizedFile.normalizedContent);\n        \n        try {\n          // Check if destination file already exists\n          await fs.access(destPath);\n          logger.debug(`[DefaultElementProvider] Skipping existing file: ${normalizedFile.normalizedContent}`);\n          continue;\n        } catch {\n          // File doesn't exist, proceed with copy\n        }\n        \n        try {\n          // Validate source file before copying\n          const sourceStats = await fs.stat(sourcePath);\n          \n          // Check file size limit\n          if (sourceStats.size > FILE_CONSTANTS.MAX_FILE_SIZE) {\n            logger.warn(\n              `[DefaultElementProvider] Skipping oversized file ${normalizedFile.normalizedContent}: ` +\n              `${sourceStats.size} bytes (max: ${FILE_CONSTANTS.MAX_FILE_SIZE} bytes)`,\n              { \n                file: normalizedFile.normalizedContent, \n                size: sourceStats.size,\n                maxSize: FILE_CONSTANTS.MAX_FILE_SIZE,\n                elementType \n              }\n            );\n            continue;\n          }\n          \n          // Copy the file with verification\n          await this.copyFileWithVerification(sourcePath, destPath);\n          copiedCount++;\n          logger.debug(`[DefaultElementProvider] Copied ${elementType}: ${normalizedFile.normalizedContent}`);\n          \n          // Log security event for each file copied\n          SecurityMonitor.logSecurityEvent({\n            type: 'FILE_COPIED',\n            severity: 'LOW',\n            source: 'DefaultElementProvider.copyElementFiles',\n            details: `Copied default ${elementType} file: ${normalizedFile.normalizedContent}`,\n            metadata: {\n              sourcePath,\n              destPath,\n              elementType,\n              fileSize: (await fs.stat(destPath)).size\n            }\n          });\n        } catch (error) {\n          const err = error as Error;\n          logger.error(\n            `[DefaultElementProvider] Failed to copy ${normalizedFile.normalizedContent}`,\n            { \n              error: err.message,\n              stack: err.stack,\n              sourcePath,\n              destPath,\n              elementType\n            }\n          );\n          // Continue with other files instead of failing completely\n        }\n      }\n      \n      if (copiedCount > 0) {\n        logger.info(`[DefaultElementProvider] Copied ${copiedCount} ${elementType} file(s)`);\n      }\n      \n    } catch (error) {\n      logger.error(`[DefaultElementProvider] Error copying ${elementType} files:`, error);\n    }\n    \n    return copiedCount;\n  }\n  \n  /**\n   * Copy a file with integrity verification\n   * Ensures the file was copied correctly by comparing sizes\n   */\n  /**\n   * Calculate checksum of a file for integrity verification\n   * @param filePath Path to the file\n   * @returns Hex-encoded checksum\n   */\n  private async calculateChecksum(filePath: string): Promise<string> {\n    const hash = createHash(FILE_CONSTANTS.CHECKSUM_ALGORITHM);\n    const stream = await fs.open(filePath, 'r');\n    \n    try {\n      const buffer = Buffer.alloc(FILE_CONSTANTS.CHUNK_SIZE);\n      let bytesRead: number;\n      \n      do {\n        const result = await stream.read(buffer, 0, FILE_CONSTANTS.CHUNK_SIZE);\n        bytesRead = result.bytesRead;\n        \n        if (bytesRead > 0) {\n          hash.update(buffer.subarray(0, bytesRead));\n        }\n      } while (bytesRead > 0);\n      \n      return hash.digest('hex');\n    } finally {\n      await stream.close();\n    }\n  }\n\n  /**\n   * Copy file with integrity verification and retry logic\n   * @param sourcePath Source file path\n   * @param destPath Destination file path\n   * @throws Error if copy fails after all retry attempts\n   */\n  private async copyFileWithVerification(sourcePath: string, destPath: string): Promise<void> {\n    let lastError: Error | null = null;\n    \n    for (let attempt = 1; attempt <= COPY_RETRY_ATTEMPTS; attempt++) {\n      try {\n        // Copy the file\n        await fs.copyFile(sourcePath, destPath);\n        \n        // Verify size matches\n        const [sourceStats, destStats] = await Promise.all([\n          fs.stat(sourcePath),\n          fs.stat(destPath)\n        ]);\n        \n        if (sourceStats.size !== destStats.size) {\n          throw new Error(\n            `Size mismatch after copy - source: ${sourceStats.size} bytes, ` +\n            `destination: ${destStats.size} bytes`\n          );\n        }\n        \n        // Verify checksum matches for complete integrity\n        const [sourceChecksum, destChecksum] = await Promise.all([\n          this.calculateChecksum(sourcePath),\n          this.calculateChecksum(destPath)\n        ]);\n        \n        if (sourceChecksum !== destChecksum) {\n          throw new Error(\n            `Checksum mismatch after copy - source: ${sourceChecksum}, ` +\n            `destination: ${destChecksum}`\n          );\n        }\n        \n        // Set proper permissions\n        try {\n          await fs.chmod(destPath, FILE_CONSTANTS.FILE_PERMISSIONS);\n        } catch (error) {\n          logger.debug(\n            `[DefaultElementProvider] Could not set permissions on ${destPath}: ${error}`,\n            { sourcePath, destPath, attempt }\n          );\n        }\n        \n        // Success - file copied and verified\n        logger.debug(\n          `[DefaultElementProvider] Successfully copied and verified: ${path.basename(sourcePath)}`,\n          { size: sourceStats.size, checksum: sourceChecksum.substring(0, 8) }\n        );\n        return;\n        \n      } catch (error) {\n        lastError = error as Error;\n        \n        // Clean up failed copy\n        try {\n          await fs.unlink(destPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        \n        if (attempt < COPY_RETRY_ATTEMPTS) {\n          logger.debug(\n            `[DefaultElementProvider] Copy attempt ${attempt} failed, retrying...`,\n            { error: lastError.message, sourcePath, destPath }\n          );\n          await new Promise(resolve => setTimeout(resolve, COPY_RETRY_DELAY * attempt));\n        }\n      }\n    }\n    \n    // All attempts failed\n    throw new Error(\n      `Failed to copy ${path.basename(sourcePath)} after ${COPY_RETRY_ATTEMPTS} attempts: ` +\n      `${lastError?.message || 'Unknown error'}`\n    );\n  }\n  \n  /**\n   * Populate the portfolio with default elements from bundled data\n   * This is called during portfolio initialization for new installations\n   * Protected against concurrent calls to prevent race conditions\n   */\n  public async populateDefaults(portfolioBaseDir: string): Promise<void> {\n    // Check if population is already in progress for this portfolio\n    const existingPopulation = DefaultElementProvider.populateInProgress.get(portfolioBaseDir);\n    if (existingPopulation) {\n      logger.debug(\n        '[DefaultElementProvider] Population already in progress for portfolio, waiting...',\n        { portfolioBaseDir }\n      );\n      return existingPopulation;\n    }\n    \n    // Create new population promise\n    const populationPromise = this.performPopulation(portfolioBaseDir)\n      .finally(() => {\n        // Clean up when done\n        DefaultElementProvider.populateInProgress.delete(portfolioBaseDir);\n      });\n    \n    DefaultElementProvider.populateInProgress.set(portfolioBaseDir, populationPromise);\n    return populationPromise;\n  }\n  \n  /**\n   * Perform the actual population of default elements\n   * @param portfolioBaseDir Base directory of the portfolio\n   */\n  private async performPopulation(portfolioBaseDir: string): Promise<void> {\n    logger.info(\n      '[DefaultElementProvider] Starting default element population',\n      { portfolioBaseDir }\n    );\n    \n    // Log security event for portfolio initialization\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_INITIALIZATION',\n      severity: 'LOW',\n      source: 'DefaultElementProvider.performPopulation',\n      details: `Starting default element population for portfolio: ${portfolioBaseDir}`\n    });\n    \n    // Find the bundled data directory\n    const dataDir = await this.findDataDirectory();\n    if (!dataDir) {\n      logger.warn(\n        '[DefaultElementProvider] No bundled data directory found - portfolio will start empty',\n        { \n          searchPaths: this.dataSearchPaths.slice(0, 3), // Log first few paths for debugging\n          cwd: process.cwd(),\n          dirname: this.__dirname\n        }\n      );\n      return;\n    }\n    \n    // Track total files copied\n    let totalCopied = 0;\n    const copiedCounts: Record<string, number> = {};\n    \n    // Copy each element type - directories now match enum values (all plural)\n    for (const elementType of Object.values(ElementType)) {\n      const sourceDir = path.join(dataDir, elementType);\n      const destDir = path.join(portfolioBaseDir, elementType);\n      \n      try {\n        // Check if source directory exists\n        await fs.access(sourceDir);\n        const copiedCount = await this.copyElementFiles(sourceDir, destDir, elementType);\n        copiedCounts[elementType] = copiedCount;\n        totalCopied += copiedCount;\n      } catch (error) {\n        // Source directory doesn't exist, skip\n        logger.debug(`[DefaultElementProvider] No ${elementType} directory in bundled data`);\n      }\n    }\n    \n    if (totalCopied > 0) {\n      logger.info(\n        `[DefaultElementProvider] Successfully populated portfolio with ${totalCopied} default element(s)`,\n        {\n          portfolioBaseDir,\n          dataDir,\n          breakdown: copiedCounts\n        }\n      );\n      \n      // Log security event for successful population\n      SecurityMonitor.logSecurityEvent({\n        type: 'PORTFOLIO_POPULATED',\n        severity: 'LOW',\n        source: 'DefaultElementProvider.performPopulation',\n        details: `Successfully populated portfolio with ${totalCopied} default elements`,\n        metadata: {\n          portfolioBaseDir,\n          dataDir,\n          copiedCounts\n        }\n      });\n    } else {\n      logger.info('[DefaultElementProvider] No new elements to copy - portfolio may already have content');\n    }\n  }\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DefaultElementProvider.js","sourceRoot":"","sources":["../../src/portfolio/DefaultElementProvider.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,MAAM,aAAa,CAAC;AAClC,OAAO,KAAK,MAAM,MAAM,IAAI,CAAC;AAC7B,OAAO,KAAK,IAAI,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,MAAM,KAAK,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpC,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,4CAA4C,CAAC;AAC9E,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEnE,2BAA2B;AAC3B,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,iBAAiB,EAAE,KAAK;IACxB,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,MAAM;IACrB,cAAc,EAAE,OAAO;IACvB,aAAa,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,gCAAgC;IACjE,kBAAkB,EAAE,QAAQ;IAC5B,gBAAgB,EAAE,KAAK;IACvB,UAAU,EAAE,EAAE,GAAG,IAAI,CAAC,sCAAsC;CACpD,CAAC;AAEX,6BAA6B;AAC7B,sEAAsE;AACtE,MAAM,mBAAmB,GAAG,CAAC,GAAG,EAAE;IAChC,IAAI,CAAC;QACH,wDAAwD;QACxD,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;QAChD,OAAO,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC,CAAC,EAAE,CAAC;AAEL,qBAAqB;AACrB,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAChD,MAAM,mBAAmB,GAAG,CAAC,CAAC;AAC9B,MAAM,gBAAgB,GAAG,GAAG,CAAC,CAAC,KAAK;AAkBnC,MAAM,OAAO,sBAAsB;IAChB,SAAS,CAAS;IAC3B,MAAM,CAAC,aAAa,GAAkB,IAAI,CAAC;IAC3C,MAAM,CAAC,kBAAkB,GAA+B,IAAI,GAAG,EAAE,CAAC;IACzD,MAAM,CAA+B;IAEtD,4EAA4E;IACpE,MAAM,CAAC,aAAa,GAAoC,IAAI,GAAG,EAAE,CAAC;IAClE,MAAM,CAAU,cAAc,GAAG,EAAE,CAAC,CAAC,+FAA+F;IAE5I,YAAY,MAAqC;QAC/C,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAE1C,mDAAmD;QACnD,MAAM,eAAe,GAAG,OAAO,CAAC,GAAG,CAAC,wBAAwB,CAAC;QAC7D,MAAM,mBAAmB,GAAG,eAAe,KAAK,MAAM,IAAI,eAAe,KAAK,GAAG,CAAC;QAClF,MAAM,sBAAsB,GAAG,eAAe,KAAK,OAAO,IAAI,eAAe,KAAK,GAAG,CAAC;QAEtF,sFAAsF;QACtF,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE;YACtB,+CAA+C;YAC/C,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,MAAM,EAAE,CAAC;gBACjD,OAAO,KAAK,CAAC,CAAC,wBAAwB;YACxC,CAAC;YACD,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,OAAO,EAAE,CAAC;gBAClD,OAAO,IAAI,CAAC,CAAC,yBAAyB;YACxC,CAAC;YACD,6BAA6B;YAC7B,OAAO,mBAAmB,CAAC;QAC7B,CAAC,CAAC,EAAE,CAAC;QAEL,+BAA+B;QAC/B,IAAI,oBAA6B,CAAC;QAClC,IAAI,mBAAmB,EAAE,CAAC;YACxB,2CAA2C;YAC3C,oBAAoB,GAAG,IAAI,CAAC;QAC9B,CAAC;aAAM,IAAI,sBAAsB,EAAE,CAAC;YAClC,4CAA4C;YAC5C,oBAAoB,GAAG,KAAK,CAAC;QAC/B,CAAC;aAAM,CAAC;YACN,sFAAsF;YACtF,oBAAoB,GAAG,CAAC,SAAS,IAAI,CAAC,MAAM,EAAE,YAAY,IAAI,IAAI,CAAC,CAAC;QACtE,CAAC;QAED,IAAI,CAAC,MAAM,GAAG;YACZ,eAAe,EAAE,IAAI;YACrB,GAAG,MAAM;YACT,8FAA8F;YAC9F,YAAY,EAAE,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,oBAAoB;SACjG,CAAC;QAEF,IAAI,SAAS,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YAC3C,MAAM,CAAC,IAAI,CAAC,iFAAiF,CAAC,CAAC;YAC/F,MAAM,CAAC,IAAI,CAAC,iFAAiF,CAAC,CAAC;QACjG,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,IAAW,wBAAwB;QACjC,OAAO,IAAI,CAAC,MAAM,CAAC,YAAY,IAAI,KAAK,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACH,IAAW,iBAAiB;QAC1B,OAAO,mBAAmB,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACH,IAAY,eAAe;QACzB,MAAM,KAAK,GAAa,EAAE,CAAC;QAE3B,4CAA4C;QAC5C,IAAI,IAAI,CAAC,MAAM,CAAC,eAAe,EAAE,CAAC;YAChC,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;QAC7C,CAAC;QAED,+BAA+B;QAC/B,IAAI,IAAI,CAAC,MAAM,CAAC,eAAe,KAAK,KAAK,EAAE,CAAC;YAC1C,6EAA6E;YAC7E,IAAI,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;gBAC7B,uDAAuD;gBACvD,KAAK,CAAC,IAAI,CACR,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,YAAY,CAAC,EACvC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,eAAe,CAAC;gBAC1C,0CAA0C;gBAC1C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CACjC,CAAC;YACJ,CAAC;YAED,2EAA2E;YAC3E,KAAK,CAAC,IAAI;YACR,qCAAqC;YACrC,8DAA8D;YAE9D,0CAA0C;YAC1C,2DAA2D,EAC3D,qDAAqD;YAErD,8BAA8B;YAC9B,0EAA0E,EAC1E,gFAAgF;YAEhF,uCAAuC;YACvC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,OAAO,IAAI,EAAE,EAAE,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,CAAC,CACnG,CAAC;QACJ,CAAC;QAED,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,iBAAiB;QAC7B,mCAAmC;QACnC,IAAI,sBAAsB,CAAC,aAAa,KAAK,IAAI,EAAE,CAAC;YAClD,OAAO,sBAAsB,CAAC,aAAa,CAAC;QAC9C,CAAC;QAED,qDAAqD;QACrD,MAAM,aAAa,GAAG,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,EAAE;YAClE,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBACxC,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;oBACxB,6CAA6C;oBAC7C,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;oBAClF,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC;oBAC9E,IAAI,WAAW,IAAI,SAAS,EAAE,CAAC;wBAC7B,OAAO,UAAU,CAAC;oBACpB,CAAC;gBACH,CAAC;YACH,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,+CAA+C;gBAC/C,OAAO,IAAI,CAAC;YACd,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC,CAAC,CAAC;QAEH,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;QAExD,mCAAmC;QACnC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,MAAM,CAAC,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;gBAC3D,MAAM,CAAC,IAAI,CAAC,qDAAqD,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC;gBACjF,mBAAmB;gBACnB,sBAAsB,CAAC,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC;gBACpD,OAAO,MAAM,CAAC,KAAK,CAAC;YACtB,CAAC;QACH,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,6EAA6E,CAAC,CAAC;QAC3F,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,eAAe,CAAC,OAAe;QAC3C,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrC,OAAO,KAAK,CAAC,WAAW,EAAE,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACK,gBAAgB,CAAC,QAAgB,EAAE,gBAA2B;QACpE,IAAI,CAAC;YACH,yDAAyD;YACzD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;YAEhD,uDAAuD;YACvD,IAAI,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;gBAClC,MAAM,CAAC,IAAI,CAAC,4DAA4D,QAAQ,EAAE,CAAC,CAAC;gBACpF,OAAO,KAAK,CAAC;YACf,CAAC;YAED,gGAAgG;YAChG,+FAA+F;YAC/F,sEAAsE;YACtE,IAAI,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBACpE,MAAM,CAAC,IAAI,CAAC,sEAAsE,QAAQ,EAAE,CAAC,CAAC;gBAC9F,OAAO,KAAK,CAAC;YACf,CAAC;YAED,8DAA8D;YAC9D,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,IAAI,gBAAgB,EAAE,CAAC;gBACxD,MAAM,SAAS,GAAG,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;oBACjD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;oBAChD,OAAO,cAAc,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;gBACnD,CAAC,CAAC,CAAC;gBAEH,IAAI,CAAC,SAAS,EAAE,CAAC;oBACf,MAAM,CAAC,IAAI,CAAC,uEAAuE,QAAQ,EAAE,CAAC,CAAC;oBAC/F,OAAO,KAAK,CAAC;gBACf,CAAC;YACH,CAAC;YAED,6DAA6D;YAC7D,IAAI,cAAc,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;gBACrE,MAAM,CAAC,IAAI,CAAC,uDAAuD,QAAQ,EAAE,CAAC,CAAC;gBAC/E,OAAO,KAAK,CAAC;YACf,CAAC;YAED,OAAO,IAAI,CAAC;QACd,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,IAAI,CAAC,mDAAmD,KAAK,EAAE,CAAC,CAAC;YACxE,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED,gGAAgG;IAChG;;;OAGG;IACH,+DAA+D;IAE/D;;;;OAIG;IACH,gDAAgD;IAChD,wCAAwC;IACxC,uDAAuD;IACvD,0DAA0D;IAC1D,MAAM;IACN,KAAK;IACL,+CAA+C;IAC/C,6FAA6F;IAC7F,wGAAwG;IACxG,iFAAiF;IACjF,oDAAoD;IACpD,8DAA8D;IAC9D,6DAA6D;IAC7D,6DAA6D;IAC7D,gEAAgE;IAChE,gEAAgE;IAChE,4EAA4E;IAC5E,yEAAyE;IACzE,0DAA0D;IAC1D,+DAA+D;IAC/D,2DAA2D;IAC3D,gEAAgE;IAChE,kEAAkE;IAClE,yDAAyD;IACzD,gEAAgE;IAChE,OAAO;IACP,KAAK;IACL,wDAAwD;IACxD,IAAI;IAEJ;;;;;OAKG;IACH,yDAAyD;IACzD,qDAAqD;IACrD,6DAA6D;IAC7D,IAAI;IAEJ;;;;;OAKG;IACH,uEAAuE;IAC/D,MAAM,CAAU,UAAU,GAAa,EAAE,CAAC;IAC1C,MAAM,CAAU,aAAa,GAAG,EAAE,CAAC,CAAC,iGAAiG;IACrI,MAAM,CAAC,eAAe,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAE5D,SAAS;QACf,mEAAmE;QACnE,IAAI,MAAM,GAAG,sBAAsB,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC;QACrD,IAAI,MAAM,EAAE,CAAC;YACX,sBAAsB,CAAC,eAAe,CAAC,IAAI,EAAE,CAAC;YAC9C,OAAO,MAAM,CAAC;QAChB,CAAC;aAAM,CAAC;YACN,sBAAsB,CAAC,eAAe,CAAC,MAAM,EAAE,CAAC;YAChD,sBAAsB,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC;YACjD,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC5B,MAAM,CAAC,KAAK,CAAC,4EAA4E,sBAAsB,CAAC,eAAe,CAAC,OAAO,EAAE,CAAC,CAAC;YAC3I,OAAO,MAAM,CAAC;QAChB,CAAC;IACH,CAAC;IAEO,aAAa,CAAC,MAAc;QAClC,kEAAkE;QAClE,IAAI,sBAAsB,CAAC,UAAU,CAAC,MAAM,GAAG,sBAAsB,CAAC,aAAa,EAAE,CAAC;YACpF,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,8DAA8D;YAC9E,sBAAsB,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACjD,CAAC;aAAM,CAAC;YACN,4DAA4D;YAC5D,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,8DAA8D,CAAC,CAAC;QAC/E,CAAC;IACH,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,OAAO;QACnB,oBAAoB;QACpB,sBAAsB,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;QAE7C,uBAAuB;QACvB,sBAAsB,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAE7C,8BAA8B;QAC9B,sBAAsB,CAAC,aAAa,GAAG,IAAI,CAAC;QAE5C,4BAA4B;QAC5B,sBAAsB,CAAC,kBAAkB,CAAC,KAAK,EAAE,CAAC;QAElD,MAAM,CAAC,IAAI,CAAC,mDAAmD,EAAE;YAC/D,WAAW,EAAE,sBAAsB,CAAC,eAAe;YACnD,YAAY,EAAE,IAAI;SACnB,CAAC,CAAC;QAEH,cAAc;QACd,sBAAsB,CAAC,eAAe,GAAG,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC;IAC9E,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,mBAAmB;QAc/B,MAAM,UAAU,GAAG,sBAAsB,CAAC,eAAe,CAAC,IAAI,CAAC;QAC/D,MAAM,YAAY,GAAG,sBAAsB,CAAC,eAAe,CAAC,MAAM,CAAC;QACnE,MAAM,aAAa,GAAG,UAAU,GAAG,YAAY,CAAC;QAEhD,OAAO;YACL,UAAU,EAAE;gBACV,IAAI,EAAE,UAAU;gBAChB,MAAM,EAAE,YAAY;gBACpB,OAAO,EAAE,sBAAsB,CAAC,eAAe,CAAC,OAAO;gBACvD,OAAO,EAAE,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,aAAa,CAAC,CAAC,CAAC,CAAC;gBAC3D,QAAQ,EAAE,sBAAsB,CAAC,UAAU,CAAC,MAAM;gBAClD,WAAW,EAAE,sBAAsB,CAAC,aAAa;aAClD;YACD,aAAa,EAAE;gBACb,IAAI,EAAE,sBAAsB,CAAC,aAAa,CAAC,IAAI;gBAC/C,OAAO,EAAE,sBAAsB,CAAC,cAAc;aAC/C;SACF,CAAC;IACJ,CAAC;IAEO,KAAK,CAAC,gBAAgB,CAAC,QAAgB,EAAE,OAAO,GAAG,CAAC;QAC1D,qDAAqD;QACrD,IAAI,CAAC;YACH,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtC,MAAM,QAAQ,GAAG,QAAQ,CAAC;YAC1B,MAAM,MAAM,GAAG,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YAElE,iDAAiD;YACjD,sFAAsF;YACtF,IAAI,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;gBACnG,MAAM,CAAC,KAAK,CAAC,0CAA0C,QAAQ,EAAE,CAAC,CAAC;gBACnE,OAAO,MAAM,CAAC,QAAQ,CAAC;YACzB,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,+CAA+C;QACjD,CAAC;QAED,IAAI,CAAC;YACH,uEAAuE;YACvE,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YACxC,0EAA0E;YAC1E,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAEhC,IAAI,CAAC;gBACH,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;gBACjD,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;gBAEtE,gDAAgD;gBAChD,yDAAyD;gBACzD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,6BAA6B,CAAC,CAAC;gBAC1D,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,OAAO,IAAI,CAAC,CAAC,uBAAuB;gBACtC,CAAC;gBAED,oCAAoC;gBACpC,IAAI,CAAC;oBACH,iGAAiG;oBACjG,kGAAkG;oBAClG,iFAAiF;oBACjF,iGAAiG;oBACjG,MAAM,QAAQ,GAAG,QAAQ,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC;oBACzC,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,QAAQ,EAAE;wBACnD,eAAe,EAAE,KAAK;wBACtB,cAAc,EAAE,KAAK;qBACtB,CAAC,CAAC;oBACH,MAAM,QAAQ,GAAG,WAAW,CAAC,IAAI,CAAC;oBAElC,mEAAmE;oBACnE,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;wBACtD,IAAI,CAAC;4BACH,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;4BACtC,MAAM,UAAU,GAAuB;gCACrC,QAAQ;gCACR,KAAK,EAAE,KAAK,CAAC,OAAO;gCACpB,IAAI,EAAE,KAAK,CAAC,IAAI;6BACjB,CAAC;4BAEF,yFAAyF;4BACzF,8EAA8E;4BAC9E,IAAI,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gCACvD,6CAA6C;gCAC7C,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;gCAC/D,MAAM,CAAC,KAAK,CAAC,6DAA6D,QAAQ,EAAE,CAAC,CAAC;4BACxF,CAAC;iCAAM,CAAC;gCACN,8CAA8C;gCAC9C,+DAA+D;gCAC/D,IAAI,sBAAsB,CAAC,aAAa,CAAC,IAAI,IAAI,sBAAsB,CAAC,cAAc,EAAE,CAAC;oCACvF,2EAA2E;oCAC3E,MAAM,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,sBAAsB,CAAC,cAAc,GAAG,GAAG,CAAC,CAAC,CAAC;oCAC5F,MAAM,WAAW,GAAG,KAAK,CAAC,IAAI,CAAC,sBAAsB,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC;oCACrG,KAAK,MAAM,GAAG,IAAI,WAAW,EAAE,CAAC;wCAC9B,sBAAsB,CAAC,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;oCACnD,CAAC;oCACD,MAAM,CAAC,KAAK,CAAC,oCAAoC,WAAW,CAAC,MAAM,mDAAmD,sBAAsB,CAAC,aAAa,CAAC,IAAI,GAAG,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC;gCAC3L,CAAC;gCAED,sBAAsB,CAAC,aAAa,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;gCAC/D,MAAM,CAAC,KAAK,CAAC,sDAAsD,QAAQ,qBAAqB,sBAAsB,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,CAAC;4BAChJ,CAAC;wBACH,CAAC;wBAAC,MAAM,CAAC;4BACP,8CAA8C;wBAChD,CAAC;wBACD,OAAO,QAAQ,CAAC;oBAClB,CAAC;oBACD,OAAO,IAAI,CAAC;gBACd,CAAC;gBAAC,OAAO,SAAS,EAAE,CAAC;oBACnB,4BAA4B;oBAC5B,uDAAuD;oBACvD,MAAM,aAAa,GAAI,SAAiB,EAAE,WAAW,EAAE,IAAI,IAAI,WAAW,CAAC;oBAC3E,MAAM,CAAC,KAAK,CAAC,4CAA4C,QAAQ,KAAK,aAAa,MAAM,SAAS,EAAE,CAAC,CAAC;oBACtG,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;oBAAS,CAAC;gBACT,qFAAqF;gBACrF,IAAI,CAAC;oBACH,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC;gBACnB,CAAC;gBAAC,OAAO,UAAU,EAAE,CAAC;oBACpB,MAAM,CAAC,KAAK,CAAC,8DAA8D,QAAQ,KAAK,UAAU,EAAE,CAAC,CAAC;gBACxG,CAAC;gBACD,+CAA+C;gBAC/C,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,qEAAqE;YACrE,MAAM,SAAS,GAAG,KAAK,EAAE,WAAW,EAAE,IAAI,IAAI,cAAc,CAAC;YAC7D,MAAM,SAAS,GAAG,KAAK,EAAE,IAAI,IAAI,SAAS,CAAC;YAE3C,sDAAsD;YACtD,IAAI,OAAO,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,OAAO,IAAI,SAAS,KAAK,QAAQ,CAAC,EAAE,CAAC;gBACrE,MAAM,CAAC,KAAK,CAAC,8CAA8C,QAAQ,UAAU,SAAS,IAAI,SAAS,EAAE,CAAC,CAAC;gBACvG,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,2BAA2B;gBAClF,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,OAAO,GAAG,CAAC,CAAC,CAAC;YACtD,CAAC;YAED,MAAM,CAAC,KAAK,CAAC,yDAAyD,QAAQ,KAAK,SAAS,IAAI,SAAS,MAAM,KAAK,EAAE,OAAO,IAAI,KAAK,EAAE,CAAC,CAAC;YAC1I,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,yBAAyB,CAAC,QAAgB;QACtD,IAAI,CAAC;YACH,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC;YACvD,MAAM,MAAM,GAAG,CAAC,CAAC,CAAC,QAAQ,IAAI,QAAQ,CAAC,iBAAiB,KAAK,IAAI,CAAC,CAAC;YAGnE,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,6DAA6D;YAC7D,MAAM,CAAC,KAAK,CAAC,6DAA6D,QAAQ,KAAK,KAAK,EAAE,CAAC,CAAC;YAChG,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,uBAAuB;QAC7B,+DAA+D;QAC/D,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,MAAM,EAAE,CAAC;YACjD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,OAAO,CAAC,GAAG,CAAC,qBAAqB,KAAK,OAAO,EAAE,CAAC;YAClD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,+CAA+C;QAC/C,MAAM,UAAU,GAAG;YACjB,gCAAgC;YAChC,cAAc,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC;gBACnG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,WAAW;YACzC,gBAAgB,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,YAAY;YACvD,YAAY,EAAE,CAAC,GAAG,EAAE;gBAClB,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC;gBACxC,0FAA0F;gBAC1F,MAAM,aAAa,GAAG,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;gBAC9C,OAAO,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAChC,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC;oBACrC,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAChC,CAAC,aAAa,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC;YAC/C,CAAC,CAAC,EAAE;YAEJ,kCAAkC;YAClC,OAAO,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE;YACxB,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,MAAM;YAC1C,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,QAAQ,KAAK,aAAa;SACjD,CAAC;QAEF,2BAA2B;QAC3B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,IAAI,UAAU,CAAC,cAAc;YAAE,KAAK,IAAI,CAAC,CAAC;QAC1C,IAAI,UAAU,CAAC,gBAAgB;YAAE,KAAK,IAAI,CAAC,CAAC;QAC5C,IAAI,UAAU,CAAC,YAAY;YAAE,KAAK,IAAI,CAAC,CAAC;QACxC,IAAI,UAAU,CAAC,OAAO;YAAE,KAAK,IAAI,CAAC,CAAC;QACnC,IAAI,UAAU,CAAC,SAAS;YAAE,KAAK,IAAI,CAAC,CAAC;QACrC,IAAI,UAAU,CAAC,QAAQ;YAAE,KAAK,IAAI,CAAC,CAAC;QAEpC,sCAAsC;QACtC,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC;aAChD,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC;aAC7B,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC;QAEvB,kGAAkG;QAClG,qFAAqF;QACrF,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CACV,0DAA0D,EAC1D,EAAE,KAAK,EAAE,gBAAgB,EAAE,SAAS,EAAE,SAAS,EAAE,CAClD,CAAC;QACJ,CAAC;QAED,0EAA0E;QAC1E,yEAAyE;QACzE,OAAO,KAAK,IAAI,CAAC,CAAC;IACpB,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,gBAAgB,CAAC,SAAiB,EAAE,OAAe,EAAE,WAAmB;QACpF,IAAI,WAAW,GAAG,CAAC,CAAC;QAGpB,IAAI,CAAC;YACH,sCAAsC;YACtC,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAE7C,wBAAwB;YACxB,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAG1C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;gBAEzB,2BAA2B;gBAC3B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC,iBAAiB,CAAC,EAAE,CAAC;oBACrD,SAAS;gBACX,CAAC;gBAED,kCAAkC;gBAClC,MAAM,cAAc,GAAG,gBAAgB,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;gBACxD,IAAI,CAAC,cAAc,CAAC,OAAO,EAAE,CAAC;oBAC5B,MAAM,CAAC,IAAI,CAAC,gEAAgE,IAAI,EAAE,CAAC,CAAC;oBACpF,SAAS;gBACX,CAAC;gBAED,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;gBAC1E,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,iBAAiB,CAAC,CAAC;gBAGtE,sEAAsE;gBACtE,+EAA+E;gBAC/E,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,UAAU,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC;gBACnE,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;gBAE7D,IAAI,CAAC,WAAW,IAAI,CAAC,SAAS,EAAE,CAAC;oBAC/B,MAAM,CAAC,IAAI,CACT,6DAA6D,cAAc,CAAC,iBAAiB,EAAE,EAC/F,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,CACtC,CAAC;oBACF,SAAS;gBACX,CAAC;gBAED,uFAAuF;gBACvF,gFAAgF;gBAChF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,IAAI,IAAI,CAAC,uBAAuB,EAAE,EAAE,CAAC;oBAChE,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;oBAEzE,IAAI,eAAe,EAAE,CAAC;wBACpB,MAAM,CAAC,IAAI,CACT,wFAAwF,cAAc,CAAC,iBAAiB,EAAE,EAC1H;4BACE,IAAI,EAAE,cAAc,CAAC,iBAAiB;4BACtC,MAAM,EAAE,8DAA8D;4BACtE,WAAW;yBACZ,CACF,CAAC;wBAEF,2CAA2C;wBAC3C,eAAe,CAAC,gBAAgB,CAAC;4BAC/B,IAAI,EAAE,mBAAmB;4BACzB,QAAQ,EAAE,QAAQ;4BAClB,MAAM,EAAE,yCAAyC;4BACjD,OAAO,EAAE,oDAAoD,cAAc,CAAC,iBAAiB,EAAE;4BAC/F,QAAQ,EAAE;gCACR,QAAQ,EAAE,cAAc,CAAC,iBAAiB;gCAC1C,WAAW;gCACX,MAAM,EAAE,8DAA8D;gCACtE,eAAe,EAAE,gBAAgB;6BAClC;yBACF,CAAC,CAAC;wBAEH,SAAS;oBACX,CAAC;gBACH,CAAC;gBAED,IAAI,CAAC;oBACH,2CAA2C;oBAC3C,MAAM,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;oBAC1B,MAAM,CAAC,KAAK,CAAC,oDAAoD,cAAc,CAAC,iBAAiB,EAAE,CAAC,CAAC;oBACrG,SAAS;gBACX,CAAC;gBAAC,MAAM,CAAC;oBACP,wCAAwC;gBAC1C,CAAC;gBAED,IAAI,CAAC;oBACH,sCAAsC;oBACtC,MAAM,WAAW,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;oBAE9C,wBAAwB;oBACxB,IAAI,WAAW,CAAC,IAAI,GAAG,cAAc,CAAC,aAAa,EAAE,CAAC;wBACpD,MAAM,CAAC,IAAI,CACT,oDAAoD,cAAc,CAAC,iBAAiB,IAAI;4BACxF,GAAG,WAAW,CAAC,IAAI,gBAAgB,cAAc,CAAC,aAAa,SAAS,EACxE;4BACE,IAAI,EAAE,cAAc,CAAC,iBAAiB;4BACtC,IAAI,EAAE,WAAW,CAAC,IAAI;4BACtB,OAAO,EAAE,cAAc,CAAC,aAAa;4BACrC,WAAW;yBACZ,CACF,CAAC;wBACF,SAAS;oBACX,CAAC;oBAED,kCAAkC;oBAElC,MAAM,IAAI,CAAC,wBAAwB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;oBAC1D,WAAW,EAAE,CAAC;oBAEd,MAAM,CAAC,KAAK,CAAC,mCAAmC,WAAW,KAAK,cAAc,CAAC,iBAAiB,EAAE,CAAC,CAAC;oBAEpG,0CAA0C;oBAC1C,eAAe,CAAC,gBAAgB,CAAC;wBAC/B,IAAI,EAAE,aAAa;wBACnB,QAAQ,EAAE,KAAK;wBACf,MAAM,EAAE,yCAAyC;wBACjD,OAAO,EAAE,kBAAkB,WAAW,UAAU,cAAc,CAAC,iBAAiB,EAAE;wBAClF,QAAQ,EAAE;4BACR,UAAU;4BACV,QAAQ;4BACR,WAAW;4BACX,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI;yBACzC;qBACF,CAAC,CAAC;gBACL,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,GAAG,GAAG,KAAc,CAAC;oBAC3B,MAAM,CAAC,KAAK,CACV,2CAA2C,cAAc,CAAC,iBAAiB,EAAE,EAC7E;wBACE,KAAK,EAAE,GAAG,CAAC,OAAO;wBAClB,KAAK,EAAE,GAAG,CAAC,KAAK;wBAChB,UAAU;wBACV,QAAQ;wBACR,WAAW;qBACZ,CACF,CAAC;oBACF,0DAA0D;gBAC5D,CAAC;YACH,CAAC;YAED,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;gBACpB,MAAM,CAAC,IAAI,CAAC,mCAAmC,WAAW,IAAI,WAAW,UAAU,CAAC,CAAC;YACvF,CAAC;QAEH,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,CAAC,KAAK,CAAC,0CAA0C,WAAW,SAAS,EAAE,KAAK,CAAC,CAAC;QACtF,CAAC;QAED,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH;;;;OAIG;IACK,KAAK,CAAC,iBAAiB,CAAC,QAAgB;QAC9C,MAAM,IAAI,GAAG,UAAU,CAAC,cAAc,CAAC,kBAAkB,CAAC,CAAC;QAC3D,MAAM,MAAM,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAE5C,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;YACvD,IAAI,SAAiB,CAAC;YAEtB,GAAG,CAAC;gBACF,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,cAAc,CAAC,UAAU,CAAC,CAAC;gBACvE,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;gBAE7B,IAAI,SAAS,GAAG,CAAC,EAAE,CAAC;oBAClB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;gBAC7C,CAAC;YACH,CAAC,QAAQ,SAAS,GAAG,CAAC,EAAE;YAExB,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;gBAAS,CAAC;YACT,MAAM,MAAM,CAAC,KAAK,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,KAAK,CAAC,wBAAwB,CAAC,UAAkB,EAAE,QAAgB;QACzE,IAAI,SAAS,GAAiB,IAAI,CAAC;QAEnC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,mBAAmB,EAAE,OAAO,EAAE,EAAE,CAAC;YAChE,IAAI,CAAC;gBACH,gBAAgB;gBAChB,MAAM,EAAE,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gBAExC,sBAAsB;gBACtB,MAAM,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;oBACjD,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;oBACnB,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC;iBAClB,CAAC,CAAC;gBAEH,IAAI,WAAW,CAAC,IAAI,KAAK,SAAS,CAAC,IAAI,EAAE,CAAC;oBACxC,MAAM,IAAI,KAAK,CACb,sCAAsC,WAAW,CAAC,IAAI,UAAU;wBAChE,gBAAgB,SAAS,CAAC,IAAI,QAAQ,CACvC,CAAC;gBACJ,CAAC;gBAED,iDAAiD;gBACjD,MAAM,CAAC,cAAc,EAAE,YAAY,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;oBACvD,IAAI,CAAC,iBAAiB,CAAC,UAAU,CAAC;oBAClC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC;iBACjC,CAAC,CAAC;gBAEH,IAAI,cAAc,KAAK,YAAY,EAAE,CAAC;oBACpC,MAAM,IAAI,KAAK,CACb,0CAA0C,cAAc,IAAI;wBAC5D,gBAAgB,YAAY,EAAE,CAC/B,CAAC;gBACJ,CAAC;gBAED,yBAAyB;gBACzB,IAAI,CAAC;oBACH,MAAM,EAAE,CAAC,KAAK,CAAC,QAAQ,EAAE,cAAc,CAAC,gBAAgB,CAAC,CAAC;gBAC5D,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAM,CAAC,KAAK,CACV,yDAAyD,QAAQ,KAAK,KAAK,EAAE,EAC7E,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,CAClC,CAAC;gBACJ,CAAC;gBAED,qCAAqC;gBACrC,MAAM,CAAC,KAAK,CACV,8DAA8D,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,EACzF,EAAE,IAAI,EAAE,WAAW,CAAC,IAAI,EAAE,QAAQ,EAAE,cAAc,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CACrE,CAAC;gBACF,OAAO;YAET,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,SAAS,GAAG,KAAc,CAAC;gBAE3B,uBAAuB;gBACvB,IAAI,CAAC;oBACH,MAAM,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;gBAC5B,CAAC;gBAAC,MAAM,CAAC;oBACP,wBAAwB;gBAC1B,CAAC;gBAED,IAAI,OAAO,GAAG,mBAAmB,EAAE,CAAC;oBAClC,MAAM,CAAC,KAAK,CACV,yCAAyC,OAAO,sBAAsB,EACtE,EAAE,KAAK,EAAE,SAAS,CAAC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,CACnD,CAAC;oBACF,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,CAAC,CAAC;gBAChF,CAAC;YACH,CAAC;QACH,CAAC;QAED,sBAAsB;QACtB,MAAM,IAAI,KAAK,CACb,kBAAkB,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,UAAU,mBAAmB,aAAa;YACrF,GAAG,SAAS,EAAE,OAAO,IAAI,eAAe,EAAE,CAC3C,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,gBAAgB,CAAC,gBAAwB;QACpD,gEAAgE;QAChE,MAAM,kBAAkB,GAAG,sBAAsB,CAAC,kBAAkB,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QAC3F,IAAI,kBAAkB,EAAE,CAAC;YACvB,MAAM,CAAC,KAAK,CACV,mFAAmF,EACnF,EAAE,gBAAgB,EAAE,CACrB,CAAC;YACF,OAAO,kBAAkB,CAAC;QAC5B,CAAC;QAED,gCAAgC;QAChC,MAAM,iBAAiB,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC;aAC/D,OAAO,CAAC,GAAG,EAAE;YACZ,qBAAqB;YACrB,sBAAsB,CAAC,kBAAkB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;QACrE,CAAC,CAAC,CAAC;QAEL,sBAAsB,CAAC,kBAAkB,CAAC,GAAG,CAAC,gBAAgB,EAAE,iBAAiB,CAAC,CAAC;QACnF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED;;;OAGG;IACK,KAAK,CAAC,iBAAiB,CAAC,gBAAwB;QACtD,yCAAyC;QACzC,0EAA0E;QAC1E,8CAA8C;QAE9C,2EAA2E;QAC3E,MAAM,iBAAiB,GAAG,CAAC,IAAI,CAAC,uBAAuB,EAAE,CAAC;QAE1D,IAAI,iBAAiB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;YACnD,MAAM,CAAC,IAAI,CACT,kFAAkF,EAClF;gBACE,gBAAgB;gBAChB,MAAM,EAAE,4BAA4B;gBACpC,UAAU,EAAE,6CAA6C;aAC1D,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,CAAC,IAAI,CACT,8DAA8D,EAC9D,EAAE,gBAAgB,EAAE,CACrB,CAAC;QAEF,kDAAkD;QAClD,eAAe,CAAC,gBAAgB,CAAC;YAC/B,IAAI,EAAE,0BAA0B;YAChC,QAAQ,EAAE,KAAK;YACf,MAAM,EAAE,0CAA0C;YAClD,OAAO,EAAE,sDAAsD,gBAAgB,EAAE;SAClF,CAAC,CAAC;QAEH,kCAAkC;QAClC,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC/C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CACT,uFAAuF,EACvF;gBACE,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,oCAAoC;gBACnF,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;gBAClB,OAAO,EAAE,IAAI,CAAC,SAAS;aACxB,CACF,CAAC;YACF,OAAO;QACT,CAAC;QAED,2BAA2B;QAC3B,IAAI,WAAW,GAAG,CAAC,CAAC;QACpB,MAAM,YAAY,GAA2B,EAAE,CAAC;QAEhD,0EAA0E;QAC1E,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC;YACrD,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;YAClD,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,WAAW,CAAC,CAAC;YAEzD,IAAI,CAAC;gBACH,mCAAmC;gBACnC,MAAM,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;gBAC3B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,SAAS,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;gBACjF,YAAY,CAAC,WAAW,CAAC,GAAG,WAAW,CAAC;gBACxC,WAAW,IAAI,WAAW,CAAC;YAC7B,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,uCAAuC;gBACvC,MAAM,CAAC,KAAK,CAAC,+BAA+B,WAAW,4BAA4B,CAAC,CAAC;YACvF,CAAC;QACH,CAAC;QAED,IAAI,WAAW,GAAG,CAAC,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CACT,kEAAkE,WAAW,qBAAqB,EAClG;gBACE,gBAAgB;gBAChB,OAAO;gBACP,SAAS,EAAE,YAAY;aACxB,CACF,CAAC;YAEF,+CAA+C;YAC/C,eAAe,CAAC,gBAAgB,CAAC;gBAC/B,IAAI,EAAE,qBAAqB;gBAC3B,QAAQ,EAAE,KAAK;gBACf,MAAM,EAAE,0CAA0C;gBAClD,OAAO,EAAE,yCAAyC,WAAW,mBAAmB;gBAChF,QAAQ,EAAE;oBACR,gBAAgB;oBAChB,OAAO;oBACP,YAAY;iBACb;aACF,CAAC,CAAC;QACL,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,uFAAuF,CAAC,CAAC;QACvG,CAAC;IACH,CAAC","sourcesContent":["/**\n * DefaultElementProvider - Populates portfolio with default elements from bundled data\n * \n * This class handles copying default personas, skills, templates, and other elements\n * from the NPM package or Git repository to the user's portfolio on first run.\n * It ensures users have example content to work with immediately after installation.\n */\n\nimport * as fs from 'fs/promises';\nimport * as fsSync from 'fs';\nimport * as path from 'path';\nimport { fileURLToPath } from 'url';\nimport { createHash } from 'crypto';\nimport * as yaml from 'js-yaml';\nimport { logger } from '../utils/logger.js';\nimport { ElementType } from './types.js';\nimport { UnicodeValidator } from '../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../security/securityMonitor.js';\nimport { SecureYamlParser } from '../security/secureYamlParser.js';\n\n// File operation constants\nexport const FILE_CONSTANTS = {\n  ELEMENT_EXTENSION: '.md',\n  YAML_EXTENSION: '.yaml',\n  YML_EXTENSION: '.yml',\n  JSON_EXTENSION: '.json',\n  MAX_FILE_SIZE: 10 * 1024 * 1024, // 10MB max file size for safety\n  CHECKSUM_ALGORITHM: 'sha256',\n  FILE_PERMISSIONS: 0o644,\n  CHUNK_SIZE: 64 * 1024 // 64KB chunks for reading large files\n} as const;\n\n// Development mode detection\n// When running from a git clone, we don't want to auto-load test data\nconst IS_DEVELOPMENT_MODE = (() => {\n  try {\n    // Check if we're in a git repository (development mode)\n    const gitDir = path.join(process.cwd(), '.git');\n    return fsSync.existsSync(gitDir);\n  } catch {\n    return false;\n  }\n})();\n\n// Internal constants\nconst DATA_DIR_CACHE_KEY = 'dollhouse_data_dir';\nconst COPY_RETRY_ATTEMPTS = 3;\nconst COPY_RETRY_DELAY = 100; // ms\n\nexport interface DefaultElementProviderConfig {\n  /** Custom data directory paths to search (checked before default paths) */\n  customDataPaths?: string[];\n  /** Whether to use default search paths after custom paths */\n  useDefaultPaths?: boolean;\n  /** Whether to load test/example data from repository (default: false in dev mode) */\n  loadTestData?: boolean;\n}\n\n// PERFORMANCE: Metadata cache with mtime-based invalidation\ninterface MetadataCacheEntry {\n  metadata: any;\n  mtime: number;\n  size: number;\n}\n\nexport class DefaultElementProvider {\n  private readonly __dirname: string;\n  private static cachedDataDir: string | null = null;\n  private static populateInProgress: Map<string, Promise<void>> = new Map();\n  private readonly config: DefaultElementProviderConfig;\n  \n  // PERFORMANCE OPTIMIZATION: Cache metadata with file mtime for invalidation\n  private static metadataCache: Map<string, MetadataCacheEntry> = new Map();\n  private static readonly MAX_CACHE_SIZE = 20; // MEMORY LEAK FIX: Further reduced cache size to prevent accumulation during performance tests\n  \n  constructor(config?: DefaultElementProviderConfig) {\n    const __filename = fileURLToPath(import.meta.url);\n    this.__dirname = path.dirname(__filename);\n    \n    // Check environment variable for test data loading\n    const envLoadTestData = process.env.DOLLHOUSE_LOAD_TEST_DATA;\n    const loadTestDataFromEnv = envLoadTestData === 'true' || envLoadTestData === '1';\n    const disableTestDataFromEnv = envLoadTestData === 'false' || envLoadTestData === '0';\n    \n    // Check if we're in development mode (with respect to FORCE_PRODUCTION_MODE override)\n    const isDevMode = (() => {\n      // Respect FORCE_PRODUCTION_MODE override first\n      if (process.env.FORCE_PRODUCTION_MODE === 'true') {\n        return false; // Force production mode\n      }\n      if (process.env.FORCE_PRODUCTION_MODE === 'false') {\n        return true; // Force development mode\n      }\n      // Fall back to git detection\n      return IS_DEVELOPMENT_MODE;\n    })();\n    \n    // Determine loadTestData value\n    let computedLoadTestData: boolean;\n    if (loadTestDataFromEnv) {\n      // Environment explicitly enables test data\n      computedLoadTestData = true;\n    } else if (disableTestDataFromEnv) {\n      // Environment explicitly disables test data\n      computedLoadTestData = false;\n    } else {\n      // Default logic: enable in production, disable in development unless config overrides\n      computedLoadTestData = !isDevMode && (config?.loadTestData ?? true);\n    }\n    \n    this.config = {\n      useDefaultPaths: true,\n      ...config,\n      // Apply final loadTestData logic - environment variables and development mode take precedence\n      loadTestData: loadTestDataFromEnv ? true : disableTestDataFromEnv ? false : computedLoadTestData\n    };\n    \n    if (isDevMode && !this.config.loadTestData) {\n      logger.info('[DefaultElementProvider] Development mode detected - test data loading disabled');\n      logger.info('[DefaultElementProvider] To enable test data, set DOLLHOUSE_LOAD_TEST_DATA=true');\n    }\n  }\n  \n  /**\n   * Get the current loadTestData configuration value\n   * @returns Whether test data loading is enabled\n   */\n  public get isTestDataLoadingEnabled(): boolean {\n    return this.config.loadTestData ?? false;\n  }\n  \n  /**\n   * Get whether the system is in development mode\n   * @returns Whether running in development mode\n   */\n  public get isDevelopmentMode(): boolean {\n    return IS_DEVELOPMENT_MODE;\n  }\n  \n  /**\n   * Search paths for bundled data directory\n   * Ordered by priority - custom paths first, then development/git, then NPM locations\n   */\n  private get dataSearchPaths(): string[] {\n    const paths: string[] = [];\n    \n    // Add custom paths first (highest priority)\n    if (this.config.customDataPaths) {\n      paths.push(...this.config.customDataPaths);\n    }\n    \n    // Add default paths if enabled\n    if (this.config.useDefaultPaths !== false) {\n      // Skip development/repository data paths unless test data loading is enabled\n      if (this.config.loadTestData) {\n        // Development/Git installation (relative to this file)\n        paths.push(\n          path.join(this.__dirname, '../../data'),\n          path.join(this.__dirname, '../../../data'),\n          // Current working directory (last resort)\n          path.join(process.cwd(), 'data')\n        );\n      }\n      \n      // Always include NPM installation paths (these would have production data)\n      paths.push(\n        // NPM installations - macOS Homebrew\n        '/opt/homebrew/lib/node_modules/@dollhousemcp/mcp-server/data',\n        \n        // NPM installations - standard Unix/Linux\n        '/usr/local/lib/node_modules/@dollhousemcp/mcp-server/data',\n        '/usr/lib/node_modules/@dollhousemcp/mcp-server/data',\n        \n        // NPM installations - Windows\n        'C:\\\\Program Files\\\\nodejs\\\\node_modules\\\\@dollhousemcp\\\\mcp-server\\\\data',\n        'C:\\\\Program Files (x86)\\\\nodejs\\\\node_modules\\\\@dollhousemcp\\\\mcp-server\\\\data',\n        \n        // NPM installations - Windows with nvm\n        path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@dollhousemcp', 'mcp-server', 'data')\n      );\n    }\n    \n    return paths;\n  }\n  \n  /**\n   * Find the bundled data directory by checking each search path\n   * Uses Promise.allSettled for better performance and caches the result\n   */\n  private async findDataDirectory(): Promise<string | null> {\n    // Return cached value if available\n    if (DefaultElementProvider.cachedDataDir !== null) {\n      return DefaultElementProvider.cachedDataDir;\n    }\n    \n    // Check all paths in parallel for better performance\n    const checkPromises = this.dataSearchPaths.map(async (searchPath) => {\n      try {\n        const stats = await fs.stat(searchPath);\n        if (stats.isDirectory()) {\n          // Verify it contains expected subdirectories\n          const hasPersonas = await this.directoryExists(path.join(searchPath, 'personas'));\n          const hasSkills = await this.directoryExists(path.join(searchPath, 'skills'));\n          if (hasPersonas || hasSkills) {\n            return searchPath;\n          }\n        }\n      } catch (error) {\n        // Directory doesn't exist or can't be accessed\n        return null;\n      }\n      return null;\n    });\n    \n    const results = await Promise.allSettled(checkPromises);\n    \n    // Find the first successful result\n    for (const result of results) {\n      if (result.status === 'fulfilled' && result.value !== null) {\n        logger.info(`[DefaultElementProvider] Found data directory at: ${result.value}`);\n        // Cache the result\n        DefaultElementProvider.cachedDataDir = result.value;\n        return result.value;\n      }\n    }\n    \n    logger.warn('[DefaultElementProvider] No bundled data directory found in any search path');\n    return null;\n  }\n  \n  /**\n   * Helper to check if a directory exists\n   */\n  private async directoryExists(dirPath: string): Promise<boolean> {\n    try {\n      const stats = await fs.stat(dirPath);\n      return stats.isDirectory();\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Validate file path to prevent path traversal attacks\n   * SECURITY FIX: Added file path validation to prevent directory traversal\n   * Previously: File paths were used without validation, allowing potential ../../../ attacks\n   * Now: Strict validation ensures paths stay within allowed directories\n   * @param filePath The file path to validate\n   * @param allowedBasePaths Array of allowed base paths (optional)\n   * @returns true if path is safe, false otherwise\n   */\n  private validateFilePath(filePath: string, allowedBasePaths?: string[]): boolean {\n    try {\n      // SECURITY: Normalize path to prevent traversal attempts\n      const normalizedPath = path.normalize(filePath);\n      \n      // SECURITY: Reject paths containing traversal patterns\n      if (normalizedPath.includes('..')) {\n        logger.warn(`[DefaultElementProvider] Path traversal attempt blocked: ${filePath}`);\n        return false;\n      }\n      \n      // SECURITY: Check for home directory expansion attempts, but allow Windows 8.3 short path names\n      // Windows short path names use ~ followed by a digit (e.g., RUNNER~1), which should be allowed\n      // Only block ~ followed by / or \\ (home directory expansion patterns)\n      if (normalizedPath.includes('~/') || normalizedPath.includes('~\\\\')) {\n        logger.warn(`[DefaultElementProvider] Home directory expansion attempt blocked: ${filePath}`);\n        return false;\n      }\n      \n      // SECURITY: Reject absolute paths outside allowed directories\n      if (path.isAbsolute(normalizedPath) && allowedBasePaths) {\n        const isAllowed = allowedBasePaths.some(basePath => {\n          const normalizedBase = path.normalize(basePath);\n          return normalizedPath.startsWith(normalizedBase);\n        });\n        \n        if (!isAllowed) {\n          logger.warn(`[DefaultElementProvider] Absolute path outside allowed directories: ${filePath}`);\n          return false;\n        }\n      }\n      \n      // SECURITY: Reject null bytes and other dangerous characters\n      if (normalizedPath.includes('\\0') || normalizedPath.includes('\\x00')) {\n        logger.warn(`[DefaultElementProvider] Null byte in path blocked: ${filePath}`);\n        return false;\n      }\n      \n      return true;\n    } catch (error) {\n      logger.warn(`[DefaultElementProvider] Path validation error: ${error}`);\n      return false;\n    }\n  }\n\n  // DEPRECATED: Commented out filename pattern detection - replaced with metadata-based detection\n  /**\n   * Cached compiled regex patterns for performance optimization\n   * @deprecated Use metadata-based detection instead\n   */\n  // private static compiledTestPatterns: RegExp[] | null = null;\n\n  /**\n   * Get compiled test patterns with caching for better performance\n   * @deprecated Use metadata-based detection instead\n   * @returns Array of compiled regex patterns\n   */\n  // private getCompiledTestPatterns(): RegExp[] {\n  //   // Use cached patterns if available\n  //   if (DefaultElementProvider.compiledTestPatterns) {\n  //     return DefaultElementProvider.compiledTestPatterns;\n  //   }\n  //   \n  //   // Compile and cache patterns on first use\n  //   // CRITICAL FIX: Removed overly broad /^test-/i pattern that was blocking legitimate use\n  //   // Users should be able to create personas like \"test-driven-developer\" or \"test-automation-expert\"\n  //   // We only block specific test patterns that are clearly from our test suite\n  //   DefaultElementProvider.compiledTestPatterns = [\n  //     /^testpersona/i,              // Our test suite pattern\n  //     /^yamltest/i,                 // Security test pattern\n  //     /^yamlbomb/i,                 // Security test pattern\n  //     /^memory-test-/i,             // Performance test pattern\n  //     /^perf-test-/i,               // Performance test pattern\n  //     /^test-fixture-/i,            // Test fixture pattern (more specific)\n  //     /^test-data-/i,               // Test data pattern (more specific)\n  //     /bin-sh|rm-rf|pwned/i,        // Malicious patterns\n  //     /concurrent-\\d+/i,            // Concurrent test pattern\n  //     /legacy\\.md$/i,               // Legacy test pattern\n  //     /performance-test/i,          // Performance test pattern\n  //     /-\\d{13}-[a-z0-9]+\\.md$/i,    // Timestamp-based test files\n  //     /^unittest-/i,                // Unit test pattern\n  //     /^integrationtest-/i,         // Integration test pattern\n  //   ];\n  //   \n  //   return DefaultElementProvider.compiledTestPatterns;\n  // }\n\n  /**\n   * Check if a filename matches test data patterns that should never be copied to production\n   * @deprecated Use isDollhouseMCPTestElement() for metadata-based detection instead\n   * @param filename The filename to check\n   * @returns true if the filename matches test patterns that should be blocked\n   */\n  // private isTestDataPattern(filename: string): boolean {\n  //   const patterns = this.getCompiledTestPatterns();\n  //   return patterns.some(pattern => pattern.test(filename));\n  // }\n\n  /**\n   * Read metadata from YAML frontmatter only (never reads content body)\n   * Uses a small buffer to safely extract only the frontmatter between --- markers\n   * @param filePath Path to the file to read metadata from\n   * @returns Parsed metadata object or null if no frontmatter found\n   */\n  // PERFORMANCE OPTIMIZATION: Reusable buffer pool to reduce allocations\n  private static readonly bufferPool: Buffer[] = [];\n  private static readonly MAX_POOL_SIZE = 20; // MEMORY LEAK FIX: Reduced buffer pool size to match cache size for consistent memory management\n  private static bufferPoolStats = { hits: 0, misses: 0, created: 0 };\n  \n  private getBuffer(): Buffer {\n    // PERFORMANCE: Track buffer pool usage for optimization monitoring\n    let buffer = DefaultElementProvider.bufferPool.pop();\n    if (buffer) {\n      DefaultElementProvider.bufferPoolStats.hits++;\n      return buffer;\n    } else {\n      DefaultElementProvider.bufferPoolStats.misses++;\n      DefaultElementProvider.bufferPoolStats.created++;\n      buffer = Buffer.alloc(4096);\n      logger.debug(`[DefaultElementProvider] Created new buffer (pool empty), total created: ${DefaultElementProvider.bufferPoolStats.created}`);\n      return buffer;\n    }\n  }\n  \n  private releaseBuffer(buffer: Buffer): void {\n    // CRITICAL FIX: Always attempt to return buffer to pool for reuse\n    if (DefaultElementProvider.bufferPool.length < DefaultElementProvider.MAX_POOL_SIZE) {\n      buffer.fill(0); // SECURITY: Clear buffer before reuse to prevent data leakage\n      DefaultElementProvider.bufferPool.push(buffer);\n    } else {\n      // PERFORMANCE: If pool is full, clear the buffer to help GC\n      buffer.fill(0);\n      logger.debug('[DefaultElementProvider] Buffer pool full, discarding buffer');\n    }\n  }\n\n  /**\n   * Clean up buffer pool and cache to free memory\n   * PERFORMANCE FIX: Added cleanup method to prevent memory leaks\n   * This should be called during application shutdown or periodic cleanup\n   */\n  public static cleanup(): void {\n    // Clear buffer pool\n    DefaultElementProvider.bufferPool.length = 0;\n    \n    // Clear metadata cache\n    DefaultElementProvider.metadataCache.clear();\n    \n    // Clear cached data directory\n    DefaultElementProvider.cachedDataDir = null;\n    \n    // Clear population promises\n    DefaultElementProvider.populateInProgress.clear();\n    \n    logger.info('[DefaultElementProvider] Memory cleanup completed', {\n      bufferStats: DefaultElementProvider.bufferPoolStats,\n      cacheCleared: true\n    });\n    \n    // Reset stats\n    DefaultElementProvider.bufferPoolStats = { hits: 0, misses: 0, created: 0 };\n  }\n\n  /**\n   * Get performance statistics for monitoring\n   * PERFORMANCE MONITORING: Added statistics method for performance tracking\n   * This provides insights into buffer pool efficiency and cache performance\n   * @returns Object containing performance metrics\n   */\n  public static getPerformanceStats(): {\n    bufferPool: {\n      hits: number;\n      misses: number; \n      created: number;\n      hitRate: number;\n      poolSize: number;\n      maxPoolSize: number;\n    };\n    metadataCache: {\n      size: number;\n      maxSize: number;\n    };\n  } {\n    const bufferHits = DefaultElementProvider.bufferPoolStats.hits;\n    const bufferMisses = DefaultElementProvider.bufferPoolStats.misses;\n    const totalRequests = bufferHits + bufferMisses;\n    \n    return {\n      bufferPool: {\n        hits: bufferHits,\n        misses: bufferMisses,\n        created: DefaultElementProvider.bufferPoolStats.created,\n        hitRate: totalRequests > 0 ? bufferHits / totalRequests : 0,\n        poolSize: DefaultElementProvider.bufferPool.length,\n        maxPoolSize: DefaultElementProvider.MAX_POOL_SIZE\n      },\n      metadataCache: {\n        size: DefaultElementProvider.metadataCache.size,\n        maxSize: DefaultElementProvider.MAX_CACHE_SIZE\n      }\n    };\n  }\n\n  private async readMetadataOnly(filePath: string, retries = 2): Promise<any | null> {\n    // PERFORMANCE: Check cache first before reading file\n    try {\n      const stats = await fs.stat(filePath);\n      const cacheKey = filePath;\n      const cached = DefaultElementProvider.metadataCache.get(cacheKey);\n      \n      // Return cached metadata if file hasn't changed \n      // CRITICAL FIX: Use integer mtime comparison to avoid floating-point precision issues\n      if (cached && Math.floor(cached.mtime) === Math.floor(stats.mtimeMs) && cached.size === stats.size) {\n        logger.debug(`[DefaultElementProvider] Cache hit for ${filePath}`);\n        return cached.metadata;\n      }\n    } catch {\n      // File doesn't exist, proceed with normal flow\n    }\n    \n    try {\n      // Open file and read only first 4KB to avoid reading dangerous content\n      const fd = await fs.open(filePath, 'r');\n      // PERFORMANCE: Use buffer pool instead of allocating new buffer each time\n      const buffer = this.getBuffer();\n      \n      try {\n        const result = await fd.read(buffer, 0, 4096, 0);\n        const header = buffer.subarray(0, result.bytesRead).toString('utf-8');\n        \n        // Look for YAML frontmatter between --- markers\n        // Support both Unix (\\n) and Windows (\\r\\n) line endings\n        const match = header.match(/^---\\r?\\n([\\s\\S]*?)\\r?\\n---/);\n        if (!match) {\n          return null; // No frontmatter found\n        }\n        \n        // Parse the YAML frontmatter safely\n        try {\n          // SECURITY FIX: Replace direct YAML parsing function with SecureYamlParser for enhanced security\n          // SecureYamlParser provides additional validation, injection prevention, and content sanitization\n          // It expects full YAML with --- markers, so we reconstruct the frontmatter block\n          // We disable specific field validation as this is general metadata parsing, not persona-specific\n          const fullYaml = `---\\n${match[1]}\\n---`;\n          const parseResult = SecureYamlParser.parse(fullYaml, { \n            validateContent: false, \n            validateFields: false \n          });\n          const metadata = parseResult.data;\n          \n          // PERFORMANCE: Cache the metadata with file stats for future reads\n          if (typeof metadata === 'object' && metadata !== null) {\n            try {\n              const stats = await fs.stat(filePath);\n              const cacheEntry: MetadataCacheEntry = {\n                metadata,\n                mtime: stats.mtimeMs,\n                size: stats.size\n              };\n              \n              // CRITICAL MEMORY LEAK FIX: More aggressive cache management to prevent unbounded growth\n              // Check if this entry already exists and just update it instead of adding new\n              if (DefaultElementProvider.metadataCache.has(filePath)) {\n                // Update existing entry - no eviction needed\n                DefaultElementProvider.metadataCache.set(filePath, cacheEntry);\n                logger.debug(`[DefaultElementProvider] Updated existing cache entry for ${filePath}`);\n              } else {\n                // New entry - check if we need to evict first\n                // Use > instead of >= to ensure we never exceed MAX_CACHE_SIZE\n                if (DefaultElementProvider.metadataCache.size >= DefaultElementProvider.MAX_CACHE_SIZE) {\n                  // More aggressive eviction: remove enough entries to stay well under limit\n                  const entriesToEvict = Math.max(1, Math.floor(DefaultElementProvider.MAX_CACHE_SIZE * 0.4));\n                  const keysToEvict = Array.from(DefaultElementProvider.metadataCache.keys()).slice(0, entriesToEvict);\n                  for (const key of keysToEvict) {\n                    DefaultElementProvider.metadataCache.delete(key);\n                  }\n                  logger.debug(`[DefaultElementProvider] Evicted ${keysToEvict.length} cache entries to manage memory (cache size was ${DefaultElementProvider.metadataCache.size + keysToEvict.length})`);\n                }\n                \n                DefaultElementProvider.metadataCache.set(filePath, cacheEntry);\n                logger.debug(`[DefaultElementProvider] Added new cache entry for ${filePath} (cache size now: ${DefaultElementProvider.metadataCache.size})`);\n              }\n            } catch {\n              // Ignore cache errors, return metadata anyway\n            }\n            return metadata;\n          }\n          return null;\n        } catch (yamlError) {\n          // Invalid YAML, return null\n          // ENHANCEMENT: Include error type for better debugging\n          const yamlErrorType = (yamlError as any)?.constructor?.name || 'YAMLError';\n          logger.debug(`[DefaultElementProvider] Invalid YAML in ${filePath}: ${yamlErrorType} - ${yamlError}`);\n          return null;\n        }\n      } finally {\n        // CRITICAL FIX: Ensure file descriptor is closed and buffer is released in ALL paths\n        try {\n          await fd.close();\n        } catch (closeError) {\n          logger.debug(`[DefaultElementProvider] Error closing file descriptor for ${filePath}: ${closeError}`);\n        }\n        // PERFORMANCE: Return buffer to pool for reuse\n        this.releaseBuffer(buffer);\n      }\n    } catch (error: any) {\n      // ENHANCEMENT: Include error type in debug logs for better debugging\n      const errorType = error?.constructor?.name || 'UnknownError';\n      const errorCode = error?.code || 'NO_CODE';\n      \n      // RELIABILITY: Add retry logic for transient failures\n      if (retries > 0 && (errorCode === 'EBUSY' || errorCode === 'EAGAIN')) {\n        logger.debug(`[DefaultElementProvider] Retrying read for ${filePath} after ${errorType}:${errorCode}`);\n        await new Promise(resolve => setTimeout(resolve, 50)); // Brief delay before retry\n        return this.readMetadataOnly(filePath, retries - 1);\n      }\n      \n      logger.debug(`[DefaultElementProvider] Could not read metadata from ${filePath}: ${errorType}:${errorCode} - ${error?.message || error}`);\n      return null;\n    }\n  }\n\n  /**\n   * Check if a file is a DollhouseMCP test element based on metadata\n   * This replaces filename pattern detection with accurate metadata-based detection\n   * @param filePath Path to the file to check\n   * @returns true if the file contains _dollhouseMCPTest: true metadata\n   */\n  private async isDollhouseMCPTestElement(filePath: string): Promise<boolean> {\n    try {\n      const metadata = await this.readMetadataOnly(filePath);\n      const isTest = !!(metadata && metadata._dollhouseMCPTest === true);\n      \n      \n      return isTest;\n    } catch (error) {\n      // If we can't read the metadata, assume it's not a test file\n      logger.debug(`[DefaultElementProvider] Error checking test metadata for ${filePath}: ${error}`);\n      return false;\n    }\n  }\n\n  /**\n   * Detect if we're in a production environment by checking for production indicators\n   * Uses a confidence-based approach requiring multiple indicators for better accuracy\n   * @returns true if this appears to be a production environment\n   */\n  private isProductionEnvironment(): boolean {\n    // Allow tests to explicitly override production mode detection\n    if (process.env.FORCE_PRODUCTION_MODE === 'true') {\n      return true;\n    }\n    if (process.env.FORCE_PRODUCTION_MODE === 'false') {\n      return false;\n    }\n    \n    // Weighted indicators for production detection\n    const indicators = {\n      // Strong indicators (weight: 2)\n      hasUserHomeDir: (process.env.HOME && (process.env.HOME.includes('/Users/') || process.env.HOME.includes('/home/'))) || \n                      !!process.env.USERPROFILE,\n      isProductionNode: process.env.NODE_ENV === 'production',\n      notInTestDir: (() => {\n        const cwd = process.cwd().toLowerCase();\n        // Normalize path separators for cross-platform checking (Windows uses \\ but checks use /)\n        const normalizedCwd = cwd.replace(/\\\\/g, '/');\n        return !normalizedCwd.includes('/test') && \n               !normalizedCwd.includes('/__tests__') && \n               !normalizedCwd.includes('/temp') &&\n               !normalizedCwd.includes('/dist/test');\n      })(),\n      \n      // Moderate indicators (weight: 1)\n      notInCI: !process.env.CI,\n      noTestEnv: process.env.NODE_ENV !== 'test',\n      noDevEnv: process.env.NODE_ENV !== 'development',\n    };\n    \n    // Calculate weighted score\n    let score = 0;\n    if (indicators.hasUserHomeDir) score += 2;\n    if (indicators.isProductionNode) score += 2;\n    if (indicators.notInTestDir) score += 2;\n    if (indicators.notInCI) score += 1;\n    if (indicators.noTestEnv) score += 1;\n    if (indicators.noDevEnv) score += 1;\n    \n    // Log detection details for debugging\n    const activeIndicators = Object.entries(indicators)\n      .filter(([_, value]) => value)\n      .map(([key]) => key);\n    \n    // TYPESCRIPT FIX: Removed logger.isDebugEnabled() check as this method doesn't exist on MCPLogger\n    // The logger already handles debug level internally, so we can call debug() directly\n    if (score >= 3) {\n      logger.debug(\n        '[DefaultElementProvider] Production environment detected',\n        { score, activeIndicators, forceMode: 'not set' }\n      );\n    }\n    \n    // Require a score of at least 3 for production detection (more confident)\n    // This prevents false positives in edge cases while maintaining security\n    return score >= 3;\n  }\n  \n  /**\n   * Copy all files from source directory to destination directory\n   * Skips files that already exist to preserve user modifications\n   */\n  private async copyElementFiles(sourceDir: string, destDir: string, elementType: string): Promise<number> {\n    let copiedCount = 0;\n    \n    \n    try {\n      // Ensure destination directory exists\n      await fs.mkdir(destDir, { recursive: true });\n      \n      // Read source directory\n      const files = await fs.readdir(sourceDir);\n      \n      \n      for (const file of files) {\n        \n        // Only copy markdown files\n        if (!file.endsWith(FILE_CONSTANTS.ELEMENT_EXTENSION)) {\n          continue;\n        }\n        \n        // Normalize filename for security\n        const normalizedFile = UnicodeValidator.normalize(file);\n        if (!normalizedFile.isValid) {\n          logger.warn(`[DefaultElementProvider] Skipping file with invalid Unicode: ${file}`);\n          continue;\n        }\n\n        const sourcePath = path.join(sourceDir, normalizedFile.normalizedContent);\n        const destPath = path.join(destDir, normalizedFile.normalizedContent);\n        \n        \n        // SECURITY FIX: Validate file paths to prevent path traversal attacks\n        // This prevents malicious files from escaping the intended directory structure\n        const sourceValid = this.validateFilePath(sourcePath, [sourceDir]);\n        const destValid = this.validateFilePath(destPath, [destDir]);\n        \n        if (!sourceValid || !destValid) {\n          logger.warn(\n            `[DefaultElementProvider] Skipping file with invalid path: ${normalizedFile.normalizedContent}`,\n            { sourcePath, destPath, elementType }\n          );\n          continue;\n        }\n        \n        // Production safety check: Block DollhouseMCP test elements in production environments\n        // Skip this check if loadTestData is explicitly enabled (for testing scenarios)\n        if (!this.config.loadTestData && this.isProductionEnvironment()) {\n          const isDollhouseTest = await this.isDollhouseMCPTestElement(sourcePath);\n          \n          if (isDollhouseTest) {\n            logger.warn(\n              `[DefaultElementProvider] SECURITY: Blocking DollhouseMCP test element in production: ${normalizedFile.normalizedContent}`,\n              { \n                file: normalizedFile.normalizedContent,\n                reason: 'DollhouseMCP test element detected in production environment',\n                elementType\n              }\n            );\n            \n            // Log security event for blocked test data\n            SecurityMonitor.logSecurityEvent({\n              type: 'TEST_DATA_BLOCKED',\n              severity: 'MEDIUM',\n              source: 'DefaultElementProvider.copyElementFiles',\n              details: `Blocked DollhouseMCP test element in production: ${normalizedFile.normalizedContent}`,\n              metadata: {\n                filename: normalizedFile.normalizedContent,\n                elementType,\n                reason: 'DollhouseMCP test element detected in production environment',\n                detectionMethod: 'metadata-based'\n              }\n            });\n            \n            continue;\n          }\n        }\n        \n        try {\n          // Check if destination file already exists\n          await fs.access(destPath);\n          logger.debug(`[DefaultElementProvider] Skipping existing file: ${normalizedFile.normalizedContent}`);\n          continue;\n        } catch {\n          // File doesn't exist, proceed with copy\n        }\n        \n        try {\n          // Validate source file before copying\n          const sourceStats = await fs.stat(sourcePath);\n          \n          // Check file size limit\n          if (sourceStats.size > FILE_CONSTANTS.MAX_FILE_SIZE) {\n            logger.warn(\n              `[DefaultElementProvider] Skipping oversized file ${normalizedFile.normalizedContent}: ` +\n              `${sourceStats.size} bytes (max: ${FILE_CONSTANTS.MAX_FILE_SIZE} bytes)`,\n              { \n                file: normalizedFile.normalizedContent, \n                size: sourceStats.size,\n                maxSize: FILE_CONSTANTS.MAX_FILE_SIZE,\n                elementType \n              }\n            );\n            continue;\n          }\n          \n          // Copy the file with verification\n          \n          await this.copyFileWithVerification(sourcePath, destPath);\n          copiedCount++;\n          \n          logger.debug(`[DefaultElementProvider] Copied ${elementType}: ${normalizedFile.normalizedContent}`);\n          \n          // Log security event for each file copied\n          SecurityMonitor.logSecurityEvent({\n            type: 'FILE_COPIED',\n            severity: 'LOW',\n            source: 'DefaultElementProvider.copyElementFiles',\n            details: `Copied default ${elementType} file: ${normalizedFile.normalizedContent}`,\n            metadata: {\n              sourcePath,\n              destPath,\n              elementType,\n              fileSize: (await fs.stat(destPath)).size\n            }\n          });\n        } catch (error) {\n          const err = error as Error;\n          logger.error(\n            `[DefaultElementProvider] Failed to copy ${normalizedFile.normalizedContent}`,\n            { \n              error: err.message,\n              stack: err.stack,\n              sourcePath,\n              destPath,\n              elementType\n            }\n          );\n          // Continue with other files instead of failing completely\n        }\n      }\n      \n      if (copiedCount > 0) {\n        logger.info(`[DefaultElementProvider] Copied ${copiedCount} ${elementType} file(s)`);\n      }\n      \n    } catch (error) {\n      logger.error(`[DefaultElementProvider] Error copying ${elementType} files:`, error);\n    }\n    \n    return copiedCount;\n  }\n  \n  /**\n   * Copy a file with integrity verification\n   * Ensures the file was copied correctly by comparing sizes\n   */\n  /**\n   * Calculate checksum of a file for integrity verification\n   * @param filePath Path to the file\n   * @returns Hex-encoded checksum\n   */\n  private async calculateChecksum(filePath: string): Promise<string> {\n    const hash = createHash(FILE_CONSTANTS.CHECKSUM_ALGORITHM);\n    const stream = await fs.open(filePath, 'r');\n    \n    try {\n      const buffer = Buffer.alloc(FILE_CONSTANTS.CHUNK_SIZE);\n      let bytesRead: number;\n      \n      do {\n        const result = await stream.read(buffer, 0, FILE_CONSTANTS.CHUNK_SIZE);\n        bytesRead = result.bytesRead;\n        \n        if (bytesRead > 0) {\n          hash.update(buffer.subarray(0, bytesRead));\n        }\n      } while (bytesRead > 0);\n      \n      return hash.digest('hex');\n    } finally {\n      await stream.close();\n    }\n  }\n\n  /**\n   * Copy file with integrity verification and retry logic\n   * @param sourcePath Source file path\n   * @param destPath Destination file path\n   * @throws Error if copy fails after all retry attempts\n   */\n  private async copyFileWithVerification(sourcePath: string, destPath: string): Promise<void> {\n    let lastError: Error | null = null;\n    \n    for (let attempt = 1; attempt <= COPY_RETRY_ATTEMPTS; attempt++) {\n      try {\n        // Copy the file\n        await fs.copyFile(sourcePath, destPath);\n        \n        // Verify size matches\n        const [sourceStats, destStats] = await Promise.all([\n          fs.stat(sourcePath),\n          fs.stat(destPath)\n        ]);\n        \n        if (sourceStats.size !== destStats.size) {\n          throw new Error(\n            `Size mismatch after copy - source: ${sourceStats.size} bytes, ` +\n            `destination: ${destStats.size} bytes`\n          );\n        }\n        \n        // Verify checksum matches for complete integrity\n        const [sourceChecksum, destChecksum] = await Promise.all([\n          this.calculateChecksum(sourcePath),\n          this.calculateChecksum(destPath)\n        ]);\n        \n        if (sourceChecksum !== destChecksum) {\n          throw new Error(\n            `Checksum mismatch after copy - source: ${sourceChecksum}, ` +\n            `destination: ${destChecksum}`\n          );\n        }\n        \n        // Set proper permissions\n        try {\n          await fs.chmod(destPath, FILE_CONSTANTS.FILE_PERMISSIONS);\n        } catch (error) {\n          logger.debug(\n            `[DefaultElementProvider] Could not set permissions on ${destPath}: ${error}`,\n            { sourcePath, destPath, attempt }\n          );\n        }\n        \n        // Success - file copied and verified\n        logger.debug(\n          `[DefaultElementProvider] Successfully copied and verified: ${path.basename(sourcePath)}`,\n          { size: sourceStats.size, checksum: sourceChecksum.substring(0, 8) }\n        );\n        return;\n        \n      } catch (error) {\n        lastError = error as Error;\n        \n        // Clean up failed copy\n        try {\n          await fs.unlink(destPath);\n        } catch {\n          // Ignore cleanup errors\n        }\n        \n        if (attempt < COPY_RETRY_ATTEMPTS) {\n          logger.debug(\n            `[DefaultElementProvider] Copy attempt ${attempt} failed, retrying...`,\n            { error: lastError.message, sourcePath, destPath }\n          );\n          await new Promise(resolve => setTimeout(resolve, COPY_RETRY_DELAY * attempt));\n        }\n      }\n    }\n    \n    // All attempts failed\n    throw new Error(\n      `Failed to copy ${path.basename(sourcePath)} after ${COPY_RETRY_ATTEMPTS} attempts: ` +\n      `${lastError?.message || 'Unknown error'}`\n    );\n  }\n  \n  /**\n   * Populate the portfolio with default elements from bundled data\n   * This is called during portfolio initialization for new installations\n   * Protected against concurrent calls to prevent race conditions\n   */\n  public async populateDefaults(portfolioBaseDir: string): Promise<void> {\n    // Check if population is already in progress for this portfolio\n    const existingPopulation = DefaultElementProvider.populateInProgress.get(portfolioBaseDir);\n    if (existingPopulation) {\n      logger.debug(\n        '[DefaultElementProvider] Population already in progress for portfolio, waiting...',\n        { portfolioBaseDir }\n      );\n      return existingPopulation;\n    }\n    \n    // Create new population promise\n    const populationPromise = this.performPopulation(portfolioBaseDir)\n      .finally(() => {\n        // Clean up when done\n        DefaultElementProvider.populateInProgress.delete(portfolioBaseDir);\n      });\n    \n    DefaultElementProvider.populateInProgress.set(portfolioBaseDir, populationPromise);\n    return populationPromise;\n  }\n  \n  /**\n   * Perform the actual population of default elements\n   * @param portfolioBaseDir Base directory of the portfolio\n   */\n  private async performPopulation(portfolioBaseDir: string): Promise<void> {\n    // Check if test data loading is disabled\n    // Note: This check is needed even though constructor sets config, because\n    // config can be overridden after construction\n    \n    // Use production environment detection that respects FORCE_PRODUCTION_MODE\n    const isDevelopmentMode = !this.isProductionEnvironment();\n    \n    if (isDevelopmentMode && !this.config.loadTestData) {\n      logger.info(\n        '[DefaultElementProvider] Skipping default element population in development mode',\n        { \n          portfolioBaseDir,\n          reason: 'Test data loading disabled',\n          enableWith: 'Set DOLLHOUSE_LOAD_TEST_DATA=true to enable'\n        }\n      );\n      return;\n    }\n    \n    logger.info(\n      '[DefaultElementProvider] Starting default element population',\n      { portfolioBaseDir }\n    );\n    \n    // Log security event for portfolio initialization\n    SecurityMonitor.logSecurityEvent({\n      type: 'PORTFOLIO_INITIALIZATION',\n      severity: 'LOW',\n      source: 'DefaultElementProvider.performPopulation',\n      details: `Starting default element population for portfolio: ${portfolioBaseDir}`\n    });\n    \n    // Find the bundled data directory\n    const dataDir = await this.findDataDirectory();\n    if (!dataDir) {\n      logger.warn(\n        '[DefaultElementProvider] No bundled data directory found - portfolio will start empty',\n        { \n          searchPaths: this.dataSearchPaths.slice(0, 3), // Log first few paths for debugging\n          cwd: process.cwd(),\n          dirname: this.__dirname\n        }\n      );\n      return;\n    }\n    \n    // Track total files copied\n    let totalCopied = 0;\n    const copiedCounts: Record<string, number> = {};\n    \n    // Copy each element type - directories now match enum values (all plural)\n    for (const elementType of Object.values(ElementType)) {\n      const sourceDir = path.join(dataDir, elementType);\n      const destDir = path.join(portfolioBaseDir, elementType);\n      \n      try {\n        // Check if source directory exists\n        await fs.access(sourceDir);\n        const copiedCount = await this.copyElementFiles(sourceDir, destDir, elementType);\n        copiedCounts[elementType] = copiedCount;\n        totalCopied += copiedCount;\n      } catch (error) {\n        // Source directory doesn't exist, skip\n        logger.debug(`[DefaultElementProvider] No ${elementType} directory in bundled data`);\n      }\n    }\n    \n    if (totalCopied > 0) {\n      logger.info(\n        `[DefaultElementProvider] Successfully populated portfolio with ${totalCopied} default element(s)`,\n        {\n          portfolioBaseDir,\n          dataDir,\n          breakdown: copiedCounts\n        }\n      );\n      \n      // Log security event for successful population\n      SecurityMonitor.logSecurityEvent({\n        type: 'PORTFOLIO_POPULATED',\n        severity: 'LOW',\n        source: 'DefaultElementProvider.performPopulation',\n        details: `Successfully populated portfolio with ${totalCopied} default elements`,\n        metadata: {\n          portfolioBaseDir,\n          dataDir,\n          copiedCounts\n        }\n      });\n    } else {\n      logger.info('[DefaultElementProvider] No new elements to copy - portfolio may already have content');\n    }\n  }\n}"]}