@dollhousemcp/mcp-server 1.3.0

package/dist/elements/templates/Template.js

@@ -0,0 +1,673 @@
+/**
+ * Template element class implementing IElement interface.
+ * Represents reusable content structures with variable substitution and dynamic content.
+ *
+ * SECURITY FIXES IMPLEMENTED (Following PR #319 patterns):
+ * 1. CRITICAL: Template injection prevention - no eval() or Function() constructor
+ * 2. CRITICAL: Path traversal prevention for template includes
+ * 3. HIGH: Input validation and sanitization for all template variables
+ * 4. MEDIUM: Memory limits to prevent resource exhaustion (100KB templates, 100 variables)
+ * 5. MEDIUM: Audit logging for all security operations via SecurityMonitor
+ * 6. MEDIUM: Unicode normalization to prevent homograph attacks
+ */
+import { BaseElement } from '../BaseElement.js';
+import { ElementType } from '../../portfolio/types.js';
+import { logger } from '../../utils/logger.js';
+import { sanitizeInput } from '../../security/InputValidator.js';
+import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
+import { SecurityMonitor } from '../../security/securityMonitor.js';
+import * as path from 'path';
+export class Template extends BaseElement {
+    content;
+    compiledTemplate;
+    // SECURITY FIX #4: Memory management constants
+    // Prevents unbounded template size and variable count that could exhaust memory
+    MAX_TEMPLATE_SIZE = 100 * 1024; // 100KB max template size
+    MAX_VARIABLE_COUNT = 100; // Max variables per template
+    MAX_INCLUDE_DEPTH = 5; // Prevent infinite include loops
+    MAX_STRING_LENGTH = 10000; // Max length for string variables
+    constructor(metadata, content = '') {
+        // SECURITY FIX #3 & #6: Validate and sanitize ALL metadata fields
+        // Unicode normalization prevents homograph attacks
+        // Input sanitization prevents XSS and injection attacks
+        const sanitizedMetadata = {
+            ...metadata,
+            name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,
+            description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined,
+            category: metadata.category ? sanitizeInput(UnicodeValidator.normalize(metadata.category).normalizedContent, 50) : undefined,
+            output_format: metadata.output_format ? sanitizeInput(metadata.output_format, 20) : undefined
+        };
+        super(ElementType.TEMPLATE, sanitizedMetadata);
+        // SECURITY FIX #4: Enforce template size limit
+        if (content.length > this.MAX_TEMPLATE_SIZE) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_SIZE_EXCEEDED',
+                severity: 'HIGH',
+                source: 'Template.constructor',
+                details: `Template size ${content.length} exceeds maximum ${this.MAX_TEMPLATE_SIZE}`
+            });
+            throw new Error(`Template content exceeds maximum size of ${this.MAX_TEMPLATE_SIZE} bytes`);
+        }
+        // SECURITY FIX #3: Sanitize template content
+        // Note: We preserve the template syntax but normalize Unicode
+        this.content = UnicodeValidator.normalize(content).normalizedContent;
+        // Ensure template-specific metadata
+        this.metadata = {
+            ...this.metadata,
+            category: sanitizedMetadata.category || 'general',
+            output_format: sanitizedMetadata.output_format || 'markdown',
+            variables: metadata.variables || [],
+            includes: metadata.includes || [],
+            tags: metadata.tags || [],
+            usage_count: metadata.usage_count || 0,
+            examples: metadata.examples || []
+        };
+        // SECURITY FIX #3 & #4: Validate variables
+        if (this.metadata.variables) {
+            if (this.metadata.variables.length > this.MAX_VARIABLE_COUNT) {
+                throw new Error(`Variable count ${this.metadata.variables.length} exceeds maximum ${this.MAX_VARIABLE_COUNT}`);
+            }
+            this.metadata.variables = this.metadata.variables.map(variable => ({
+                ...variable,
+                name: sanitizeInput(UnicodeValidator.normalize(variable.name).normalizedContent, 50),
+                description: variable.description ? sanitizeInput(UnicodeValidator.normalize(variable.description).normalizedContent, 200) : undefined,
+                validation: variable.validation ? sanitizeInput(variable.validation, 200) : undefined
+            }));
+        }
+        // SECURITY FIX #2: Validate include paths
+        if (this.metadata.includes) {
+            this.metadata.includes = this.metadata.includes.map(includePath => {
+                const sanitizedPath = sanitizeInput(includePath, 200);
+                // Prevent path traversal attacks
+                if (!this.isValidIncludePath(sanitizedPath)) {
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'PATH_TRAVERSAL_ATTEMPT',
+                        severity: 'CRITICAL',
+                        source: 'Template.constructor',
+                        details: `Invalid include path: ${sanitizedPath}`
+                    });
+                    throw new Error(`Invalid include path: ${sanitizedPath}`);
+                }
+                return sanitizedPath;
+            });
+        }
+    }
+    /**
+     * Validate include paths to prevent directory traversal
+     * SECURITY FIX #2: Prevents accessing files outside template directory
+     */
+    isValidIncludePath(includePath) {
+        // Normalize the path
+        const normalized = path.normalize(includePath);
+        // Check for path traversal patterns
+        if (normalized.includes('..') || normalized.includes('~') || path.isAbsolute(normalized)) {
+            return false;
+        }
+        // Only allow alphanumeric, dash, underscore, forward slash, backslash (for Windows), and .md extension
+        // Note: We test against the original path to preserve cross-platform compatibility
+        const validPathPattern = /^[a-zA-Z0-9\-_\/\\]+\.md$/;
+        return validPathPattern.test(includePath);
+    }
+    /**
+     * Compile the template for efficient rendering
+     * SECURITY FIX #1: Safe template compilation without eval() or Function()
+     * Uses regex-based token replacement instead of dynamic code execution
+     */
+    compile() {
+        if (this.compiledTemplate) {
+            return this.compiledTemplate;
+        }
+        // Extract all variable tokens from the template
+        const variablePattern = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*\}\}/g;
+        const tokens = [];
+        let match;
+        while ((match = variablePattern.exec(this.content)) !== null) {
+            tokens.push({
+                token: match[0],
+                variable: match[1],
+                position: match.index
+            });
+        }
+        this.compiledTemplate = {
+            content: this.content,
+            tokens,
+            variables: this.metadata.variables || []
+        };
+        return this.compiledTemplate;
+    }
+    /**
+     * Render the template with provided variables
+     * SECURITY FIX #1: Safe rendering without code execution
+     * SECURITY FIX #3: All variables are validated and sanitized
+     * TYPE SAFETY: Strong typing for variables with runtime validation
+     */
+    async render(variables = {}, includeDepth = 0) {
+        // SECURITY FIX #4: Prevent infinite include loops
+        if (includeDepth > this.MAX_INCLUDE_DEPTH) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'INCLUDE_DEPTH_EXCEEDED',
+                severity: 'HIGH',
+                source: 'Template.render',
+                details: `Include depth ${includeDepth} exceeds maximum ${this.MAX_INCLUDE_DEPTH}`
+            });
+            throw new Error('Maximum template include depth exceeded');
+        }
+        // Compile the template
+        const compiled = this.compile();
+        // Validate and sanitize all provided variables
+        const sanitizedVariables = await this.validateAndSanitizeVariables(variables);
+        // Start with the template content
+        let rendered = compiled.content;
+        // Replace tokens in reverse order to maintain positions
+        const sortedTokens = [...compiled.tokens].sort((a, b) => b.position - a.position);
+        for (const token of sortedTokens) {
+            const value = this.resolveVariable(token.variable, sanitizedVariables);
+            const stringValue = this.formatValue(value);
+            // Replace the token with the sanitized value
+            rendered = rendered.substring(0, token.position) +
+                stringValue +
+                rendered.substring(token.position + token.token.length);
+        }
+        // Process includes if any
+        if (this.metadata.includes && this.metadata.includes.length > 0) {
+            rendered = await this.processIncludes(rendered, sanitizedVariables, includeDepth);
+        }
+        // Update usage statistics
+        // NOTE: These updates are not atomic and may have race conditions under concurrent access
+        // This is acceptable for usage statistics which don't require perfect accuracy
+        // For production systems requiring atomic counters, consider using a database or atomic operations
+        this.metadata.usage_count = (this.metadata.usage_count || 0) + 1;
+        this.metadata.last_used = new Date().toISOString();
+        // SECURITY FIX #5: Log template usage for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'TEMPLATE_RENDERED',
+            severity: 'LOW',
+            source: 'Template.render',
+            details: `Template ${this.metadata.name} rendered with ${Object.keys(sanitizedVariables).length} variables`
+        });
+        return rendered;
+    }
+    /**
+     * Validate and sanitize variables according to their definitions
+     * SECURITY FIX #3: Comprehensive validation of all input variables
+     * TYPE SAFETY: Improved type safety for variable validation
+     */
+    async validateAndSanitizeVariables(variables) {
+        const sanitized = {};
+        // Check required variables
+        for (const varDef of this.metadata.variables || []) {
+            if (varDef.required && !(varDef.name in variables)) {
+                if (varDef.default !== undefined) {
+                    sanitized[varDef.name] = varDef.default;
+                }
+                else {
+                    throw new Error(`Required variable '${varDef.name}' not provided`);
+                }
+            }
+        }
+        // Validate and sanitize provided variables
+        for (const [name, value] of Object.entries(variables)) {
+            const varDef = this.metadata.variables?.find(v => v.name === name);
+            if (!varDef) {
+                // Skip unknown variables (they won't be used anyway)
+                logger.warn(`Unknown variable '${name}' provided to template`);
+                continue;
+            }
+            // Type validation and sanitization
+            const sanitizedValue = await this.sanitizeVariableValue(value, varDef);
+            sanitized[name] = sanitizedValue;
+        }
+        // Apply defaults for missing optional variables
+        for (const varDef of this.metadata.variables || []) {
+            if (!varDef.required && !(varDef.name in sanitized) && varDef.default !== undefined) {
+                sanitized[varDef.name] = varDef.default;
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * Sanitize a single variable value according to its definition
+     * SECURITY FIX #3 & #6: Type-specific validation and Unicode normalization
+     */
+    async sanitizeVariableValue(value, varDef) {
+        switch (varDef.type) {
+            case 'string':
+                // SECURITY FIX #6: Unicode normalization
+                const normalized = UnicodeValidator.normalize(String(value));
+                let stringValue = sanitizeInput(normalized.normalizedContent, this.MAX_STRING_LENGTH);
+                // Apply regex validation if specified
+                if (varDef.validation) {
+                    // SECURITY FIX: Validate regex complexity to prevent ReDoS attacks
+                    // Previously: User-provided regex executed without limits
+                    // Now: Check for dangerous patterns and limit execution time
+                    try {
+                        // Check for dangerous regex patterns
+                        if (this.isDangerousRegex(varDef.validation)) {
+                            throw new Error(`Variable '${varDef.name}' has potentially dangerous validation pattern`);
+                        }
+                        const regex = new RegExp(varDef.validation);
+                        // Use a simple timeout mechanism - in production, consider using a worker thread
+                        const startTime = Date.now();
+                        const result = regex.test(stringValue);
+                        const duration = Date.now() - startTime;
+                        // If regex takes too long, it might be malicious
+                        if (duration > 100) { // 100ms threshold
+                            SecurityMonitor.logSecurityEvent({
+                                type: 'CONTENT_INJECTION_ATTEMPT',
+                                severity: 'HIGH',
+                                source: 'Template.sanitizeVariableValue',
+                                details: `Regex validation took ${duration}ms for variable '${varDef.name}', possible ReDoS`
+                            });
+                            throw new Error(`Variable '${varDef.name}' validation pattern is too complex`);
+                        }
+                        if (!result) {
+                            throw new Error(`Variable '${varDef.name}' does not match validation pattern`);
+                        }
+                    }
+                    catch (e) {
+                        if (e instanceof SyntaxError) {
+                            throw new Error(`Variable '${varDef.name}' has invalid validation pattern`);
+                        }
+                        throw e;
+                    }
+                }
+                // Check enum options if specified
+                if (varDef.options && !varDef.options.includes(stringValue)) {
+                    throw new Error(`Variable '${varDef.name}' must be one of: ${varDef.options.join(', ')}`);
+                }
+                return stringValue;
+            case 'number':
+                const num = Number(value);
+                if (isNaN(num)) {
+                    throw new Error(`Variable '${varDef.name}' must be a number`);
+                }
+                return num;
+            case 'boolean':
+                return Boolean(value);
+            case 'date':
+                const date = new Date(value);
+                if (isNaN(date.getTime())) {
+                    throw new Error(`Variable '${varDef.name}' must be a valid date`);
+                }
+                return date;
+            case 'array':
+                if (!Array.isArray(value)) {
+                    throw new Error(`Variable '${varDef.name}' must be an array`);
+                }
+                // SECURITY FIX: Limit array size to prevent memory exhaustion attacks
+                // Previously: No limit on array size could lead to DoS
+                // Now: Enforces reasonable size limit with logging
+                const MAX_ARRAY_SIZE = 1000;
+                if (value.length > MAX_ARRAY_SIZE) {
+                    SecurityMonitor.logSecurityEvent({
+                        type: 'CONTENT_SIZE_EXCEEDED',
+                        severity: 'MEDIUM',
+                        source: 'Template.sanitizeVariableValue',
+                        details: `Array variable '${varDef.name}' has ${value.length} items, limiting to ${MAX_ARRAY_SIZE}`
+                    });
+                    value = value.slice(0, MAX_ARRAY_SIZE);
+                }
+                // Sanitize string elements in arrays
+                return value.map((item) => typeof item === 'string' ? sanitizeInput(item, 1000) : item);
+            case 'object':
+                if (typeof value !== 'object' || value === null) {
+                    throw new Error(`Variable '${varDef.name}' must be an object`);
+                }
+                // Deep sanitize string values in objects
+                return this.sanitizeObject(value);
+            default:
+                return value;
+        }
+    }
+    /**
+     * Recursively sanitize string values in objects
+     * SECURITY FIX: Truncate deep nesting instead of throwing to prevent DoS
+     */
+    sanitizeObject(obj, depth = 0) {
+        // SECURITY FIX: Return safe default instead of throwing to prevent DoS attacks
+        // Previously: Threw error on deep nesting which could be exploited
+        // Now: Returns string representation for excessively nested objects
+        if (depth > 10) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_SIZE_EXCEEDED',
+                severity: 'MEDIUM',
+                source: 'Template.sanitizeObject',
+                details: 'Object nesting depth exceeded, truncating to string representation'
+            });
+            return '[Object too deeply nested]';
+        }
+        if (typeof obj !== 'object' || obj === null) {
+            return obj;
+        }
+        if (Array.isArray(obj)) {
+            // SECURITY FIX: Limit array size to prevent memory exhaustion
+            const MAX_ARRAY_SIZE = 1000;
+            if (obj.length > MAX_ARRAY_SIZE) {
+                SecurityMonitor.logSecurityEvent({
+                    type: 'CONTENT_SIZE_EXCEEDED',
+                    severity: 'MEDIUM',
+                    source: 'Template.sanitizeObject',
+                    details: `Array size ${obj.length} exceeds maximum ${MAX_ARRAY_SIZE}, truncating`
+                });
+                obj = obj.slice(0, MAX_ARRAY_SIZE);
+            }
+            return obj.map((item) => this.sanitizeObject(item, depth + 1));
+        }
+        const sanitized = {};
+        // SECURITY FIX: Limit number of object properties to prevent memory exhaustion
+        const MAX_OBJECT_KEYS = 100;
+        const entries = Object.entries(obj);
+        if (entries.length > MAX_OBJECT_KEYS) {
+            SecurityMonitor.logSecurityEvent({
+                type: 'CONTENT_SIZE_EXCEEDED',
+                severity: 'MEDIUM',
+                source: 'Template.sanitizeObject',
+                details: `Object has ${entries.length} keys, limiting to ${MAX_OBJECT_KEYS}`
+            });
+        }
+        for (let i = 0; i < Math.min(entries.length, MAX_OBJECT_KEYS); i++) {
+            const [key, value] = entries[i];
+            const sanitizedKey = sanitizeInput(key, 50);
+            if (typeof value === 'string') {
+                sanitized[sanitizedKey] = sanitizeInput(value, 1000);
+            }
+            else if (typeof value === 'object') {
+                sanitized[sanitizedKey] = this.sanitizeObject(value, depth + 1);
+            }
+            else {
+                sanitized[sanitizedKey] = value;
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * Resolve nested variable paths (e.g., "user.name")
+     * TYPE SAFETY: Improved type safety for variable resolution
+     */
+    resolveVariable(path, variables) {
+        const parts = path.split('.');
+        let value = variables;
+        for (const part of parts) {
+            if (value && typeof value === 'object' && value !== null && part in value) {
+                // Type assertion with runtime check - safe because we verified the property exists
+                value = value[part];
+            }
+            else {
+                return undefined;
+            }
+        }
+        return value;
+    }
+    /**
+     * Check if a regex pattern is potentially dangerous (ReDoS)
+     * SECURITY FIX: Detect patterns that could cause exponential backtracking
+     */
+    isDangerousRegex(pattern) {
+        // Check for nested quantifiers which can cause exponential backtracking
+        const dangerousPatterns = [
+            /(\+|\*){2,}/, // Multiple quantifiers
+            /\([^)]*\+\)[+*]/, // Quantified groups with quantifiers inside
+            /\[[^\]]*\+\][+*]/, // Quantified character classes with quantifiers
+            /(\\[dws])\1{2,}/, // Repeated character classes
+            /\(\?\<[!=][^)]+\)/, // Complex lookbehinds
+        ];
+        for (const dangerous of dangerousPatterns) {
+            if (dangerous.test(pattern)) {
+                return true;
+            }
+        }
+        // Check for excessive backtracking potential
+        // Count groups and quantifiers
+        const groups = (pattern.match(/\(/g) || []).length;
+        const quantifiers = (pattern.match(/[+*?{]/g) || []).length;
+        // If there are many groups and quantifiers, it's potentially dangerous
+        if (groups > 5 && quantifiers > 5) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Format a value for template output
+     */
+    formatValue(value) {
+        if (value === undefined || value === null) {
+            return '';
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (Array.isArray(value)) {
+            return value.join(', ');
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value, null, 2);
+        }
+        return String(value);
+    }
+    /**
+     * Process template includes
+     * SECURITY FIX #2: Safe include processing with path validation
+     *
+     * TODO: Implement actual include processing functionality
+     * This is currently a placeholder that validates the security model
+     * but does not actually load and render included templates.
+     *
+     * Future implementation should:
+     * 1. Load templates from validated paths
+     * 2. Render them with current variables
+     * 3. Replace include markers in content
+     * 4. Respect includeDepth limit
+     */
+    async processIncludes(content, variables, includeDepth) {
+        // TODO: Implement actual template include processing
+        // Current implementation only validates the security model
+        if (!this.metadata.includes || this.metadata.includes.length === 0) {
+            return content;
+        }
+        // Log security event for audit trail
+        SecurityMonitor.logSecurityEvent({
+            type: 'TEMPLATE_INCLUDE',
+            severity: 'LOW',
+            source: 'Template.processIncludes',
+            details: `Processing ${this.metadata.includes.length} includes at depth ${includeDepth}`
+        });
+        // TODO: Future implementation would:
+        // for (const includePath of this.metadata.includes) {
+        //   const template = await this.loadIncludedTemplate(includePath);
+        //   const rendered = await template.render(variables, includeDepth + 1);
+        //   content = content.replace(`{{include:${includePath}}}`, rendered);
+        // }
+        return content;
+    }
+    /**
+     * Template-specific validation
+     */
+    validate() {
+        const result = super.validate();
+        // Initialize arrays if not present
+        if (!result.errors)
+            result.errors = [];
+        if (!result.warnings)
+            result.warnings = [];
+        // Content validation
+        if (!this.content || this.content.trim().length === 0) {
+            result.errors.push({
+                field: 'content',
+                message: 'Template content cannot be empty',
+                code: 'EMPTY_CONTENT'
+            });
+        }
+        // Check for unmatched tokens
+        const openTokens = (this.content.match(/\{\{/g) || []).length;
+        const closeTokens = (this.content.match(/\}\}/g) || []).length;
+        if (openTokens !== closeTokens) {
+            result.errors.push({
+                field: 'content',
+                message: 'Template has unmatched variable tokens',
+                code: 'UNMATCHED_TOKENS'
+            });
+        }
+        // Validate output format
+        const validFormats = ['markdown', 'html', 'json', 'yaml', 'text', 'xml'];
+        if (this.metadata.output_format && !validFormats.includes(this.metadata.output_format)) {
+            result.warnings.push({
+                field: 'output_format',
+                message: `Unknown output format '${this.metadata.output_format}'. Common formats: ${validFormats.join(', ')}`,
+                severity: 'low'
+            });
+        }
+        // Validate variables
+        if (this.metadata.variables) {
+            const variableNames = new Set();
+            this.metadata.variables.forEach((variable, index) => {
+                // Check for duplicate names
+                if (variableNames.has(variable.name)) {
+                    result.errors.push({
+                        field: `variables[${index}].name`,
+                        message: `Duplicate variable name '${variable.name}'`,
+                        code: 'DUPLICATE_VARIABLE'
+                    });
+                }
+                variableNames.add(variable.name);
+                // Validate regex patterns
+                if (variable.validation) {
+                    try {
+                        new RegExp(variable.validation);
+                    }
+                    catch (e) {
+                        result.errors.push({
+                            field: `variables[${index}].validation`,
+                            message: `Invalid regex pattern: ${e}`,
+                            code: 'INVALID_REGEX'
+                        });
+                    }
+                }
+            });
+        }
+        // Check if all tokens have corresponding variable definitions
+        const compiled = this.compile();
+        const definedVars = new Set(this.metadata.variables?.map(v => v.name) || []);
+        const usedVars = new Set(compiled.tokens.map(t => t.variable.split('.')[0]));
+        usedVars.forEach(varName => {
+            if (!definedVars.has(varName)) {
+                result.warnings.push({
+                    field: 'variables',
+                    message: `Template uses undefined variable '${varName}'`,
+                    severity: 'medium'
+                });
+            }
+        });
+        // Warnings for best practices
+        if (!this.metadata.tags || this.metadata.tags.length === 0) {
+            result.warnings.push({
+                field: 'tags',
+                message: 'Consider adding tags for better searchability',
+                severity: 'low'
+            });
+        }
+        if (!this.metadata.examples || this.metadata.examples.length === 0) {
+            result.warnings.push({
+                field: 'examples',
+                message: 'Adding examples improves template usability',
+                severity: 'medium'
+            });
+        }
+        // Update the valid flag based on final errors
+        result.valid = (result.errors?.length || 0) === 0;
+        return result;
+    }
+    /**
+     * Serialize template to JSON format
+     */
+    serialize() {
+        const data = {
+            id: this.id,
+            type: this.type,
+            version: this.version,
+            metadata: this.metadata,
+            content: this.content,
+            references: this.references,
+            extensions: this.extensions,
+            ratings: this.ratings
+        };
+        return JSON.stringify(data, null, 2);
+    }
+    /**
+     * Deserialize template from JSON format
+     */
+    deserialize(data) {
+        try {
+            const parsed = JSON.parse(data);
+            // Update metadata
+            this.metadata = { ...this.metadata, ...parsed.metadata };
+            // Update content
+            this.content = parsed.content || '';
+            // Update other properties
+            this.references = parsed.references || [];
+            this.extensions = parsed.extensions || {};
+            this.ratings = parsed.ratings || this.ratings;
+            // Update ID and version if provided
+            if (parsed.id)
+                this.id = parsed.id;
+            if (parsed.version)
+                this.version = parsed.version;
+            // Clear compiled template cache
+            this.compiledTemplate = undefined;
+            this._isDirty = true;
+            logger.debug(`Deserialized template: ${this.metadata.name}`);
+        }
+        catch (error) {
+            logger.error(`Failed to deserialize template: ${error}`);
+            throw new Error(`Deserialization failed: ${error}`);
+        }
+    }
+    /**
+     * Get a preview of the template with sample data
+     */
+    async preview() {
+        const sampleVars = {};
+        // Generate sample data for each variable
+        for (const varDef of this.metadata.variables || []) {
+            switch (varDef.type) {
+                case 'string':
+                    sampleVars[varDef.name] = varDef.default || `[${varDef.name}]`;
+                    break;
+                case 'number':
+                    sampleVars[varDef.name] = varDef.default || 42;
+                    break;
+                case 'boolean':
+                    sampleVars[varDef.name] = varDef.default || true;
+                    break;
+                case 'date':
+                    sampleVars[varDef.name] = varDef.default || new Date();
+                    break;
+                case 'array':
+                    sampleVars[varDef.name] = varDef.default || ['item1', 'item2'];
+                    break;
+                case 'object':
+                    sampleVars[varDef.name] = varDef.default || { key: 'value' };
+                    break;
+            }
+        }
+        return this.render(sampleVars);
+    }
+    /**
+     * Template activation lifecycle
+     */
+    async activate() {
+        logger.info(`Activating template: ${this.metadata.name} (${this.id})`);
+        // Compile the template to check for errors
+        this.compile();
+        await super.activate?.();
+    }
+    /**
+     * Template deactivation lifecycle
+     */
+    async deactivate() {
+        logger.info(`Deactivating template: ${this.metadata.name} (${this.id})`);
+        // Clear compiled template cache
+        this.compiledTemplate = undefined;
+        await super.deactivate?.();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Template.js","sourceRoot":"","sources":["../../../src/elements/templates/Template.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Template element class implementing IElement interface.\n * Represents reusable content structures with variable substitution and dynamic content.\n * \n * SECURITY FIXES IMPLEMENTED (Following PR #319 patterns):\n * 1. CRITICAL: Template injection prevention - no eval() or Function() constructor\n * 2. CRITICAL: Path traversal prevention for template includes\n * 3. HIGH: Input validation and sanitization for all template variables\n * 4. MEDIUM: Memory limits to prevent resource exhaustion (100KB templates, 100 variables)\n * 5. MEDIUM: Audit logging for all security operations via SecurityMonitor\n * 6. MEDIUM: Unicode normalization to prevent homograph attacks\n */\n\nimport { BaseElement } from '../BaseElement.js';\nimport { IElement, IElementMetadata, ElementValidationResult } from '../../types/elements/index.js';\nimport { ElementType } from '../../portfolio/types.js';\nimport { logger } from '../../utils/logger.js';\nimport { sanitizeInput, validatePath } from '../../security/InputValidator.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { SecurityMonitor } from '../../security/securityMonitor.js';\nimport * as path from 'path';\n\n// Extend IElementMetadata with template-specific fields\nexport interface TemplateMetadata extends IElementMetadata {\n  category?: string;              // Template category (documents, emails, code, etc.)\n  output_format?: string;         // Output format (markdown, html, json, yaml, etc.)\n  variables?: TemplateVariable[]; // Variable definitions\n  includes?: string[];            // Other templates to include\n  tags?: string[];               // Searchable tags\n  usage_count?: number;          // Track popularity\n  last_used?: string;            // ISO date string\n  examples?: TemplateExample[];   // Usage examples\n}\n\nexport interface TemplateVariable {\n  name: string;                   // Variable name (e.g., \"project_name\")\n  type: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object';\n  description?: string;           // Help text for the variable\n  required?: boolean;             // Is this variable required?\n  default?: unknown;              // Default value if not provided (type-safe)\n  validation?: string;            // Regex pattern for validation (string type only)\n  options?: string[];             // For enum-like strings\n  format?: string;                // Date format string (date type only)\n}\n\nexport interface TemplateExample {\n  title: string;\n  description?: string;\n  variables: Record<string, unknown>;\n  output?: string;\n}\n\nexport class Template extends BaseElement implements IElement {\n  public declare metadata: TemplateMetadata;\n  public content: string;\n  private compiledTemplate?: CompiledTemplate;\n  \n  // SECURITY FIX #4: Memory management constants\n  // Prevents unbounded template size and variable count that could exhaust memory\n  private readonly MAX_TEMPLATE_SIZE = 100 * 1024; // 100KB max template size\n  private readonly MAX_VARIABLE_COUNT = 100;       // Max variables per template\n  private readonly MAX_INCLUDE_DEPTH = 5;          // Prevent infinite include loops\n  private readonly MAX_STRING_LENGTH = 10000;      // Max length for string variables\n\n  constructor(metadata: Partial<TemplateMetadata>, content: string = '') {\n    // SECURITY FIX #3 & #6: Validate and sanitize ALL metadata fields\n    // Unicode normalization prevents homograph attacks\n    // Input sanitization prevents XSS and injection attacks\n    const sanitizedMetadata = {\n      ...metadata,\n      name: metadata.name ? sanitizeInput(UnicodeValidator.normalize(metadata.name).normalizedContent, 100) : undefined,\n      description: metadata.description ? sanitizeInput(UnicodeValidator.normalize(metadata.description).normalizedContent, 500) : undefined,\n      category: metadata.category ? sanitizeInput(UnicodeValidator.normalize(metadata.category).normalizedContent, 50) : undefined,\n      output_format: metadata.output_format ? sanitizeInput(metadata.output_format, 20) : undefined\n    };\n    \n    super(ElementType.TEMPLATE, sanitizedMetadata);\n    \n    // SECURITY FIX #4: Enforce template size limit\n    if (content.length > this.MAX_TEMPLATE_SIZE) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_SIZE_EXCEEDED',\n        severity: 'HIGH',\n        source: 'Template.constructor',\n        details: `Template size ${content.length} exceeds maximum ${this.MAX_TEMPLATE_SIZE}`\n      });\n      throw new Error(`Template content exceeds maximum size of ${this.MAX_TEMPLATE_SIZE} bytes`);\n    }\n    \n    // SECURITY FIX #3: Sanitize template content\n    // Note: We preserve the template syntax but normalize Unicode\n    this.content = UnicodeValidator.normalize(content).normalizedContent;\n    \n    // Ensure template-specific metadata\n    this.metadata = {\n      ...this.metadata,\n      category: sanitizedMetadata.category || 'general',\n      output_format: sanitizedMetadata.output_format || 'markdown',\n      variables: metadata.variables || [],\n      includes: metadata.includes || [],\n      tags: metadata.tags || [],\n      usage_count: metadata.usage_count || 0,\n      examples: metadata.examples || []\n    };\n\n    // SECURITY FIX #3 & #4: Validate variables\n    if (this.metadata.variables) {\n      if (this.metadata.variables.length > this.MAX_VARIABLE_COUNT) {\n        throw new Error(`Variable count ${this.metadata.variables.length} exceeds maximum ${this.MAX_VARIABLE_COUNT}`);\n      }\n      \n      this.metadata.variables = this.metadata.variables.map(variable => ({\n        ...variable,\n        name: sanitizeInput(UnicodeValidator.normalize(variable.name).normalizedContent, 50),\n        description: variable.description ? sanitizeInput(UnicodeValidator.normalize(variable.description).normalizedContent, 200) : undefined,\n        validation: variable.validation ? sanitizeInput(variable.validation, 200) : undefined\n      }));\n    }\n\n    // SECURITY FIX #2: Validate include paths\n    if (this.metadata.includes) {\n      this.metadata.includes = this.metadata.includes.map(includePath => {\n        const sanitizedPath = sanitizeInput(includePath, 200);\n        // Prevent path traversal attacks\n        if (!this.isValidIncludePath(sanitizedPath)) {\n          SecurityMonitor.logSecurityEvent({\n            type: 'PATH_TRAVERSAL_ATTEMPT',\n            severity: 'CRITICAL',\n            source: 'Template.constructor',\n            details: `Invalid include path: ${sanitizedPath}`\n          });\n          throw new Error(`Invalid include path: ${sanitizedPath}`);\n        }\n        return sanitizedPath;\n      });\n    }\n  }\n\n  /**\n   * Validate include paths to prevent directory traversal\n   * SECURITY FIX #2: Prevents accessing files outside template directory\n   */\n  private isValidIncludePath(includePath: string): boolean {\n    // Normalize the path\n    const normalized = path.normalize(includePath);\n    \n    // Check for path traversal patterns\n    if (normalized.includes('..') || normalized.includes('~') || path.isAbsolute(normalized)) {\n      return false;\n    }\n    \n    // Only allow alphanumeric, dash, underscore, forward slash, backslash (for Windows), and .md extension\n    // Note: We test against the original path to preserve cross-platform compatibility\n    const validPathPattern = /^[a-zA-Z0-9\\-_\\/\\\\]+\\.md$/;\n    return validPathPattern.test(includePath);\n  }\n\n  /**\n   * Compile the template for efficient rendering\n   * SECURITY FIX #1: Safe template compilation without eval() or Function()\n   * Uses regex-based token replacement instead of dynamic code execution\n   */\n  private compile(): CompiledTemplate {\n    if (this.compiledTemplate) {\n      return this.compiledTemplate;\n    }\n\n    // Extract all variable tokens from the template\n    const variablePattern = /\\{\\{\\s*([a-zA-Z_][a-zA-Z0-9_]*(?:\\.[a-zA-Z_][a-zA-Z0-9_]*)*)\\s*\\}\\}/g;\n    const tokens: TemplateToken[] = [];\n    let match;\n    \n    while ((match = variablePattern.exec(this.content)) !== null) {\n      tokens.push({\n        token: match[0],\n        variable: match[1],\n        position: match.index\n      });\n    }\n\n    this.compiledTemplate = {\n      content: this.content,\n      tokens,\n      variables: this.metadata.variables || []\n    };\n\n    return this.compiledTemplate;\n  }\n\n  /**\n   * Render the template with provided variables\n   * SECURITY FIX #1: Safe rendering without code execution\n   * SECURITY FIX #3: All variables are validated and sanitized\n   * TYPE SAFETY: Strong typing for variables with runtime validation\n   */\n  async render<T extends Record<string, unknown>>(\n    variables: T = {} as T, \n    includeDepth: number = 0\n  ): Promise<string> {\n    // SECURITY FIX #4: Prevent infinite include loops\n    if (includeDepth > this.MAX_INCLUDE_DEPTH) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'INCLUDE_DEPTH_EXCEEDED',\n        severity: 'HIGH',\n        source: 'Template.render',\n        details: `Include depth ${includeDepth} exceeds maximum ${this.MAX_INCLUDE_DEPTH}`\n      });\n      throw new Error('Maximum template include depth exceeded');\n    }\n\n    // Compile the template\n    const compiled = this.compile();\n    \n    // Validate and sanitize all provided variables\n    const sanitizedVariables = await this.validateAndSanitizeVariables(variables);\n    \n    // Start with the template content\n    let rendered = compiled.content;\n    \n    // Replace tokens in reverse order to maintain positions\n    const sortedTokens = [...compiled.tokens].sort((a, b) => b.position - a.position);\n    \n    for (const token of sortedTokens) {\n      const value = this.resolveVariable(token.variable, sanitizedVariables);\n      const stringValue = this.formatValue(value);\n      \n      // Replace the token with the sanitized value\n      rendered = rendered.substring(0, token.position) + \n                 stringValue + \n                 rendered.substring(token.position + token.token.length);\n    }\n    \n    // Process includes if any\n    if (this.metadata.includes && this.metadata.includes.length > 0) {\n      rendered = await this.processIncludes(rendered, sanitizedVariables, includeDepth);\n    }\n    \n    // Update usage statistics\n    // NOTE: These updates are not atomic and may have race conditions under concurrent access\n    // This is acceptable for usage statistics which don't require perfect accuracy\n    // For production systems requiring atomic counters, consider using a database or atomic operations\n    this.metadata.usage_count = (this.metadata.usage_count || 0) + 1;\n    this.metadata.last_used = new Date().toISOString();\n    \n    // SECURITY FIX #5: Log template usage for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'TEMPLATE_RENDERED',\n      severity: 'LOW',\n      source: 'Template.render',\n      details: `Template ${this.metadata.name} rendered with ${Object.keys(sanitizedVariables).length} variables`\n    });\n    \n    return rendered;\n  }\n\n  /**\n   * Validate and sanitize variables according to their definitions\n   * SECURITY FIX #3: Comprehensive validation of all input variables\n   * TYPE SAFETY: Improved type safety for variable validation\n   */\n  private async validateAndSanitizeVariables(\n    variables: Record<string, unknown>\n  ): Promise<Record<string, unknown>> {\n    const sanitized: Record<string, unknown> = {};\n    \n    // Check required variables\n    for (const varDef of this.metadata.variables || []) {\n      if (varDef.required && !(varDef.name in variables)) {\n        if (varDef.default !== undefined) {\n          sanitized[varDef.name] = varDef.default;\n        } else {\n          throw new Error(`Required variable '${varDef.name}' not provided`);\n        }\n      }\n    }\n    \n    // Validate and sanitize provided variables\n    for (const [name, value] of Object.entries(variables)) {\n      const varDef = this.metadata.variables?.find(v => v.name === name);\n      \n      if (!varDef) {\n        // Skip unknown variables (they won't be used anyway)\n        logger.warn(`Unknown variable '${name}' provided to template`);\n        continue;\n      }\n      \n      // Type validation and sanitization\n      const sanitizedValue = await this.sanitizeVariableValue(value, varDef);\n      sanitized[name] = sanitizedValue;\n    }\n    \n    // Apply defaults for missing optional variables\n    for (const varDef of this.metadata.variables || []) {\n      if (!varDef.required && !(varDef.name in sanitized) && varDef.default !== undefined) {\n        sanitized[varDef.name] = varDef.default;\n      }\n    }\n    \n    return sanitized;\n  }\n\n  /**\n   * Sanitize a single variable value according to its definition\n   * SECURITY FIX #3 & #6: Type-specific validation and Unicode normalization\n   */\n  private async sanitizeVariableValue(value: any, varDef: TemplateVariable): Promise<any> {\n    switch (varDef.type) {\n      case 'string':\n        // SECURITY FIX #6: Unicode normalization\n        const normalized = UnicodeValidator.normalize(String(value));\n        let stringValue = sanitizeInput(normalized.normalizedContent, this.MAX_STRING_LENGTH);\n        \n        // Apply regex validation if specified\n        if (varDef.validation) {\n          // SECURITY FIX: Validate regex complexity to prevent ReDoS attacks\n          // Previously: User-provided regex executed without limits\n          // Now: Check for dangerous patterns and limit execution time\n          try {\n            // Check for dangerous regex patterns\n            if (this.isDangerousRegex(varDef.validation)) {\n              throw new Error(`Variable '${varDef.name}' has potentially dangerous validation pattern`);\n            }\n            \n            const regex = new RegExp(varDef.validation);\n            // Use a simple timeout mechanism - in production, consider using a worker thread\n            const startTime = Date.now();\n            const result = regex.test(stringValue);\n            const duration = Date.now() - startTime;\n            \n            // If regex takes too long, it might be malicious\n            if (duration > 100) { // 100ms threshold\n              SecurityMonitor.logSecurityEvent({\n                type: 'CONTENT_INJECTION_ATTEMPT',\n                severity: 'HIGH',\n                source: 'Template.sanitizeVariableValue',\n                details: `Regex validation took ${duration}ms for variable '${varDef.name}', possible ReDoS`\n              });\n              throw new Error(`Variable '${varDef.name}' validation pattern is too complex`);\n            }\n            \n            if (!result) {\n              throw new Error(`Variable '${varDef.name}' does not match validation pattern`);\n            }\n          } catch (e) {\n            if (e instanceof SyntaxError) {\n              throw new Error(`Variable '${varDef.name}' has invalid validation pattern`);\n            }\n            throw e;\n          }\n        }\n        \n        // Check enum options if specified\n        if (varDef.options && !varDef.options.includes(stringValue)) {\n          throw new Error(`Variable '${varDef.name}' must be one of: ${varDef.options.join(', ')}`);\n        }\n        \n        return stringValue;\n        \n      case 'number':\n        const num = Number(value);\n        if (isNaN(num)) {\n          throw new Error(`Variable '${varDef.name}' must be a number`);\n        }\n        return num;\n        \n      case 'boolean':\n        return Boolean(value);\n        \n      case 'date':\n        const date = new Date(value);\n        if (isNaN(date.getTime())) {\n          throw new Error(`Variable '${varDef.name}' must be a valid date`);\n        }\n        return date;\n        \n      case 'array':\n        if (!Array.isArray(value)) {\n          throw new Error(`Variable '${varDef.name}' must be an array`);\n        }\n        // SECURITY FIX: Limit array size to prevent memory exhaustion attacks\n        // Previously: No limit on array size could lead to DoS\n        // Now: Enforces reasonable size limit with logging\n        const MAX_ARRAY_SIZE = 1000;\n        if (value.length > MAX_ARRAY_SIZE) {\n          SecurityMonitor.logSecurityEvent({\n            type: 'CONTENT_SIZE_EXCEEDED',\n            severity: 'MEDIUM',\n            source: 'Template.sanitizeVariableValue',\n            details: `Array variable '${varDef.name}' has ${value.length} items, limiting to ${MAX_ARRAY_SIZE}`\n          });\n          value = value.slice(0, MAX_ARRAY_SIZE);\n        }\n        // Sanitize string elements in arrays\n        return value.map((item: any) => \n          typeof item === 'string' ? sanitizeInput(item, 1000) : item\n        );\n        \n      case 'object':\n        if (typeof value !== 'object' || value === null) {\n          throw new Error(`Variable '${varDef.name}' must be an object`);\n        }\n        // Deep sanitize string values in objects\n        return this.sanitizeObject(value);\n        \n      default:\n        return value;\n    }\n  }\n\n  /**\n   * Recursively sanitize string values in objects\n   * SECURITY FIX: Truncate deep nesting instead of throwing to prevent DoS\n   */\n  private sanitizeObject(obj: any, depth: number = 0): any {\n    // SECURITY FIX: Return safe default instead of throwing to prevent DoS attacks\n    // Previously: Threw error on deep nesting which could be exploited\n    // Now: Returns string representation for excessively nested objects\n    if (depth > 10) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_SIZE_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'Template.sanitizeObject',\n        details: 'Object nesting depth exceeded, truncating to string representation'\n      });\n      return '[Object too deeply nested]';\n    }\n    \n    if (typeof obj !== 'object' || obj === null) {\n      return obj;\n    }\n    \n    if (Array.isArray(obj)) {\n      // SECURITY FIX: Limit array size to prevent memory exhaustion\n      const MAX_ARRAY_SIZE = 1000;\n      if (obj.length > MAX_ARRAY_SIZE) {\n        SecurityMonitor.logSecurityEvent({\n          type: 'CONTENT_SIZE_EXCEEDED',\n          severity: 'MEDIUM',\n          source: 'Template.sanitizeObject',\n          details: `Array size ${obj.length} exceeds maximum ${MAX_ARRAY_SIZE}, truncating`\n        });\n        obj = obj.slice(0, MAX_ARRAY_SIZE);\n      }\n      return obj.map((item: any) => this.sanitizeObject(item, depth + 1));\n    }\n    \n    const sanitized: Record<string, any> = {};\n    // SECURITY FIX: Limit number of object properties to prevent memory exhaustion\n    const MAX_OBJECT_KEYS = 100;\n    const entries = Object.entries(obj);\n    if (entries.length > MAX_OBJECT_KEYS) {\n      SecurityMonitor.logSecurityEvent({\n        type: 'CONTENT_SIZE_EXCEEDED',\n        severity: 'MEDIUM',\n        source: 'Template.sanitizeObject',\n        details: `Object has ${entries.length} keys, limiting to ${MAX_OBJECT_KEYS}`\n      });\n    }\n    \n    for (let i = 0; i < Math.min(entries.length, MAX_OBJECT_KEYS); i++) {\n      const [key, value] = entries[i];\n      const sanitizedKey = sanitizeInput(key, 50);\n      if (typeof value === 'string') {\n        sanitized[sanitizedKey] = sanitizeInput(value, 1000);\n      } else if (typeof value === 'object') {\n        sanitized[sanitizedKey] = this.sanitizeObject(value, depth + 1);\n      } else {\n        sanitized[sanitizedKey] = value;\n      }\n    }\n    \n    return sanitized;\n  }\n\n  /**\n   * Resolve nested variable paths (e.g., \"user.name\")\n   * TYPE SAFETY: Improved type safety for variable resolution\n   */\n  private resolveVariable(path: string, variables: Record<string, unknown>): unknown {\n    const parts = path.split('.');\n    let value: unknown = variables;\n    \n    for (const part of parts) {\n      if (value && typeof value === 'object' && value !== null && part in value) {\n        // Type assertion with runtime check - safe because we verified the property exists\n        value = (value as Record<string, unknown>)[part];\n      } else {\n        return undefined;\n      }\n    }\n    \n    return value;\n  }\n\n  /**\n   * Check if a regex pattern is potentially dangerous (ReDoS)\n   * SECURITY FIX: Detect patterns that could cause exponential backtracking\n   */\n  private isDangerousRegex(pattern: string): boolean {\n    // Check for nested quantifiers which can cause exponential backtracking\n    const dangerousPatterns = [\n      /(\\+|\\*){2,}/,           // Multiple quantifiers\n      /\\([^)]*\\+\\)[+*]/,       // Quantified groups with quantifiers inside\n      /\\[[^\\]]*\\+\\][+*]/,      // Quantified character classes with quantifiers\n      /(\\\\[dws])\\1{2,}/,       // Repeated character classes\n      /\\(\\?\\<[!=][^)]+\\)/,     // Complex lookbehinds\n    ];\n    \n    for (const dangerous of dangerousPatterns) {\n      if (dangerous.test(pattern)) {\n        return true;\n      }\n    }\n    \n    // Check for excessive backtracking potential\n    // Count groups and quantifiers\n    const groups = (pattern.match(/\\(/g) || []).length;\n    const quantifiers = (pattern.match(/[+*?{]/g) || []).length;\n    \n    // If there are many groups and quantifiers, it's potentially dangerous\n    if (groups > 5 && quantifiers > 5) {\n      return true;\n    }\n    \n    return false;\n  }\n\n  /**\n   * Format a value for template output\n   */\n  private formatValue(value: any): string {\n    if (value === undefined || value === null) {\n      return '';\n    }\n    \n    if (value instanceof Date) {\n      return value.toISOString();\n    }\n    \n    if (Array.isArray(value)) {\n      return value.join(', ');\n    }\n    \n    if (typeof value === 'object') {\n      return JSON.stringify(value, null, 2);\n    }\n    \n    return String(value);\n  }\n\n  /**\n   * Process template includes\n   * SECURITY FIX #2: Safe include processing with path validation\n   * \n   * TODO: Implement actual include processing functionality\n   * This is currently a placeholder that validates the security model\n   * but does not actually load and render included templates.\n   * \n   * Future implementation should:\n   * 1. Load templates from validated paths\n   * 2. Render them with current variables\n   * 3. Replace include markers in content\n   * 4. Respect includeDepth limit\n   */\n  private async processIncludes(\n    content: string, \n    variables: Record<string, unknown>, \n    includeDepth: number\n  ): Promise<string> {\n    // TODO: Implement actual template include processing\n    // Current implementation only validates the security model\n    \n    if (!this.metadata.includes || this.metadata.includes.length === 0) {\n      return content;\n    }\n    \n    // Log security event for audit trail\n    SecurityMonitor.logSecurityEvent({\n      type: 'TEMPLATE_INCLUDE',\n      severity: 'LOW',\n      source: 'Template.processIncludes',\n      details: `Processing ${this.metadata.includes.length} includes at depth ${includeDepth}`\n    });\n    \n    // TODO: Future implementation would:\n    // for (const includePath of this.metadata.includes) {\n    //   const template = await this.loadIncludedTemplate(includePath);\n    //   const rendered = await template.render(variables, includeDepth + 1);\n    //   content = content.replace(`{{include:${includePath}}}`, rendered);\n    // }\n    \n    return content;\n  }\n\n  /**\n   * Template-specific validation\n   */\n  public override validate(): ElementValidationResult {\n    const result = super.validate();\n    \n    // Initialize arrays if not present\n    if (!result.errors) result.errors = [];\n    if (!result.warnings) result.warnings = [];\n    \n    // Content validation\n    if (!this.content || this.content.trim().length === 0) {\n      result.errors.push({\n        field: 'content',\n        message: 'Template content cannot be empty',\n        code: 'EMPTY_CONTENT'\n      });\n    }\n    \n    // Check for unmatched tokens\n    const openTokens = (this.content.match(/\\{\\{/g) || []).length;\n    const closeTokens = (this.content.match(/\\}\\}/g) || []).length;\n    if (openTokens !== closeTokens) {\n      result.errors.push({\n        field: 'content',\n        message: 'Template has unmatched variable tokens',\n        code: 'UNMATCHED_TOKENS'\n      });\n    }\n    \n    // Validate output format\n    const validFormats = ['markdown', 'html', 'json', 'yaml', 'text', 'xml'];\n    if (this.metadata.output_format && !validFormats.includes(this.metadata.output_format)) {\n      result.warnings.push({\n        field: 'output_format',\n        message: `Unknown output format '${this.metadata.output_format}'. Common formats: ${validFormats.join(', ')}`,\n        severity: 'low'\n      });\n    }\n    \n    // Validate variables\n    if (this.metadata.variables) {\n      const variableNames = new Set<string>();\n      \n      this.metadata.variables.forEach((variable, index) => {\n        // Check for duplicate names\n        if (variableNames.has(variable.name)) {\n          result.errors!.push({\n            field: `variables[${index}].name`,\n            message: `Duplicate variable name '${variable.name}'`,\n            code: 'DUPLICATE_VARIABLE'\n          });\n        }\n        variableNames.add(variable.name);\n        \n        // Validate regex patterns\n        if (variable.validation) {\n          try {\n            new RegExp(variable.validation);\n          } catch (e) {\n            result.errors!.push({\n              field: `variables[${index}].validation`,\n              message: `Invalid regex pattern: ${e}`,\n              code: 'INVALID_REGEX'\n            });\n          }\n        }\n      });\n    }\n    \n    // Check if all tokens have corresponding variable definitions\n    const compiled = this.compile();\n    const definedVars = new Set(this.metadata.variables?.map(v => v.name) || []);\n    const usedVars = new Set(compiled.tokens.map(t => t.variable.split('.')[0]));\n    \n    usedVars.forEach(varName => {\n      if (!definedVars.has(varName)) {\n        result.warnings!.push({\n          field: 'variables',\n          message: `Template uses undefined variable '${varName}'`,\n          severity: 'medium'\n        });\n      }\n    });\n    \n    // Warnings for best practices\n    if (!this.metadata.tags || this.metadata.tags.length === 0) {\n      result.warnings!.push({\n        field: 'tags',\n        message: 'Consider adding tags for better searchability',\n        severity: 'low'\n      });\n    }\n    \n    if (!this.metadata.examples || this.metadata.examples.length === 0) {\n      result.warnings!.push({\n        field: 'examples',\n        message: 'Adding examples improves template usability',\n        severity: 'medium'\n      });\n    }\n    \n    // Update the valid flag based on final errors\n    result.valid = (result.errors?.length || 0) === 0;\n    \n    return result;\n  }\n\n  /**\n   * Serialize template to JSON format\n   */\n  public override serialize(): string {\n    const data = {\n      id: this.id,\n      type: this.type,\n      version: this.version,\n      metadata: this.metadata,\n      content: this.content,\n      references: this.references,\n      extensions: this.extensions,\n      ratings: this.ratings\n    };\n\n    return JSON.stringify(data, null, 2);\n  }\n\n  /**\n   * Deserialize template from JSON format\n   */\n  public override deserialize(data: string): void {\n    try {\n      const parsed = JSON.parse(data);\n      \n      // Update metadata\n      this.metadata = { ...this.metadata, ...parsed.metadata };\n      \n      // Update content\n      this.content = parsed.content || '';\n      \n      // Update other properties\n      this.references = parsed.references || [];\n      this.extensions = parsed.extensions || {};\n      this.ratings = parsed.ratings || this.ratings;\n      \n      // Update ID and version if provided\n      if (parsed.id) this.id = parsed.id;\n      if (parsed.version) this.version = parsed.version;\n      \n      // Clear compiled template cache\n      this.compiledTemplate = undefined;\n      \n      this._isDirty = true;\n      logger.debug(`Deserialized template: ${this.metadata.name}`);\n      \n    } catch (error) {\n      logger.error(`Failed to deserialize template: ${error}`);\n      throw new Error(`Deserialization failed: ${error}`);\n    }\n  }\n\n  /**\n   * Get a preview of the template with sample data\n   */\n  async preview(): Promise<string> {\n    const sampleVars: Record<string, any> = {};\n    \n    // Generate sample data for each variable\n    for (const varDef of this.metadata.variables || []) {\n      switch (varDef.type) {\n        case 'string':\n          sampleVars[varDef.name] = varDef.default || `[${varDef.name}]`;\n          break;\n        case 'number':\n          sampleVars[varDef.name] = varDef.default || 42;\n          break;\n        case 'boolean':\n          sampleVars[varDef.name] = varDef.default || true;\n          break;\n        case 'date':\n          sampleVars[varDef.name] = varDef.default || new Date();\n          break;\n        case 'array':\n          sampleVars[varDef.name] = varDef.default || ['item1', 'item2'];\n          break;\n        case 'object':\n          sampleVars[varDef.name] = varDef.default || { key: 'value' };\n          break;\n      }\n    }\n    \n    return this.render(sampleVars);\n  }\n\n  /**\n   * Template activation lifecycle\n   */\n  public override async activate(): Promise<void> {\n    logger.info(`Activating template: ${this.metadata.name} (${this.id})`);\n    \n    // Compile the template to check for errors\n    this.compile();\n    \n    await super.activate?.();\n  }\n\n  /**\n   * Template deactivation lifecycle\n   */\n  public override async deactivate(): Promise<void> {\n    logger.info(`Deactivating template: ${this.metadata.name} (${this.id})`);\n    \n    // Clear compiled template cache\n    this.compiledTemplate = undefined;\n    \n    await super.deactivate?.();\n  }\n}\n\n// Internal types for template compilation\ninterface CompiledTemplate {\n  content: string;\n  tokens: TemplateToken[];\n  variables: TemplateVariable[];\n}\n\ninterface TemplateToken {\n  token: string;      // The full token including braces (e.g., \"{{ name }}\")\n  variable: string;   // The variable path (e.g., \"user.name\")\n  position: number;   // Position in the template string\n}"]}