@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
344 lines • 45.6 kB
JavaScript
/**
* Constants for Ensemble elements
*
* Defines limits, defaults, and security constants following patterns from other elements
*
* CONFIGURABILITY (Issue #368):
* Limits can be configured via:
* 1. Environment variables (e.g., ENSEMBLE_MAX_ELEMENTS=100)
* 2. Global configuration object (setGlobalEnsembleLimits())
* 3. Per-ensemble overrides via metadata.resourceLimits
*
* Priority: Per-ensemble > Global config > Environment variables > Defaults
*
* @example
* // 1. Environment variables (set before server starts)
* // ENSEMBLE_MAX_ELEMENTS=100
* // ENSEMBLE_MAX_NESTING_DEPTH=3
* // ENSEMBLE_MAX_ACTIVATION_TIME=60000
*
* @example
* // 2. Global configuration (programmatic)
* import { setGlobalEnsembleLimits } from './constants.js';
* setGlobalEnsembleLimits({
* maxElements: 75,
* maxNestingDepth: 4,
* maxActivationTime: 45000
* });
*
* @example
* // 3. Per-ensemble override (in ensemble metadata)
* const ensemble = new Ensemble({
* name: 'my-ensemble',
* resourceLimits: {
* maxActiveElements: 25, // Maps to MAX_ELEMENTS
* maxExecutionTimeMs: 10000 // Maps to MAX_ACTIVATION_TIME
* }
* }, elements, metadataService);
*/
import { logger } from '../../utils/logger.js';
import { parseEnvInt } from '../../config/env-utils.js';
// ==================== HARD LIMITS (Security) ====================
/**
* Absolute maximum values for security - cannot be exceeded even with configuration
* These prevent resource exhaustion and DoS attacks
*/
export const ENSEMBLE_HARD_LIMITS = {
MAX_ELEMENTS: 500, // Absolute max elements (security ceiling)
MAX_NESTING_DEPTH: 10, // Absolute max nesting (prevent stack overflow)
MAX_ACTIVATION_TIME: 300000, // 5 minutes absolute max (300 seconds)
MAX_CONTEXT_SIZE: 10000, // Absolute max context keys
MAX_CONTEXT_VALUE_SIZE: 1048576, // 1MB absolute max per value
MAX_DEPENDENCIES: 50, // Absolute max dependencies per element
MAX_CONDITION_LENGTH: 1000 // Absolute max condition length
};
/**
* Minimum values for safety - configured values cannot go below these
*/
export const ENSEMBLE_MIN_LIMITS = {
MAX_ELEMENTS: 1, // Must allow at least 1 element
MAX_NESTING_DEPTH: 0, // 0 means no nesting allowed
MAX_ACTIVATION_TIME: 1000, // At least 1 second
MAX_CONTEXT_SIZE: 10, // At least 10 context keys
MAX_CONTEXT_VALUE_SIZE: 100, // At least 100 bytes per value
MAX_DEPENDENCIES: 1, // At least 1 dependency allowed
MAX_CONDITION_LENGTH: 10 // At least 10 chars for conditions
};
// Global configuration storage (module-level singleton)
let globalConfig = {};
/**
* Set global ensemble limits configuration
* Values are validated against hard limits
*
* @param config - Configuration object with desired limits
* @example
* setGlobalEnsembleLimits({
* maxElements: 100,
* maxNestingDepth: 3,
* maxActivationTime: 60000
* });
*/
export function setGlobalEnsembleLimits(config) {
const previousConfig = { ...globalConfig };
const previousKeys = Object.keys(previousConfig);
globalConfig = { ...config };
const newKeys = Object.keys(config);
// Determine what changed for the audit trail
const addedKeys = newKeys.filter(k => !previousKeys.includes(k));
const removedKeys = previousKeys.filter(k => !newKeys.includes(k));
const modifiedKeys = newKeys.filter(k => previousKeys.includes(k) &&
previousConfig[k] !== config[k]);
const timestamp = new Date().toISOString();
const summary = `${addedKeys.length} added, ${removedKeys.length} removed, ${modifiedKeys.length} modified`;
// Info level: concise summary for normal operation
logger.info('Global ensemble limits configuration updated', {
timestamp,
summary,
configuredKeys: newKeys
});
// Debug level: complete audit trail for troubleshooting
logger.debug('Global ensemble limits configuration audit trail', {
timestamp,
previousConfig: previousKeys.length > 0 ? previousConfig : '(no previous configuration)',
newConfig: config,
changes: {
added: addedKeys.length > 0 ? addedKeys : undefined,
removed: removedKeys.length > 0 ? removedKeys : undefined,
modified: modifiedKeys.length > 0 ? modifiedKeys.map(k => ({
key: k,
from: previousConfig[k],
to: config[k]
})) : undefined
},
summary,
impact: 'New limits apply to ensembles created or activated after this change. Existing cached limits are not affected until invalidateLimitsCache() is called.'
});
}
/**
* Get current global ensemble limits configuration
* @returns Copy of current global config
*/
export function getGlobalEnsembleLimits() {
return { ...globalConfig };
}
/**
* Reset global ensemble limits to defaults (clears all overrides)
*/
export function resetGlobalEnsembleLimits() {
const previousConfig = { ...globalConfig };
const hadPreviousConfig = Object.keys(previousConfig).length > 0;
globalConfig = {};
const timestamp = new Date().toISOString();
const clearedKeys = hadPreviousConfig ? Object.keys(previousConfig) : [];
// Info level: concise summary for normal operation
logger.info('Global ensemble limits configuration reset to defaults', {
timestamp,
clearedCount: clearedKeys.length
});
// Debug level: complete audit trail for troubleshooting
if (hadPreviousConfig) {
logger.debug('Global ensemble limits reset audit trail', {
timestamp,
previousConfig,
clearedKeys,
newConfig: '(using defaults - environment variables and per-ensemble overrides still apply)',
impact: 'Ensembles will now use environment variables or built-in defaults. Existing cached limits are not affected until invalidateLimitsCache() is called.'
});
}
}
/**
* Get effective limits with proper priority:
* Per-ensemble override > Global config > Environment variable > Default
*
* @param perEnsembleOverrides - Optional per-ensemble limit overrides
* @returns Resolved limits object
*/
export function getEffectiveLimits(perEnsembleOverrides) {
// Helper to resolve a single limit value
const resolveLimit = (key, envVar, defaultVal, minVal, maxVal) => {
// Priority: per-ensemble > global > env > default
let value = defaultVal;
// Check environment variable
const envValue = parseEnvInt(envVar, defaultVal, minVal, maxVal, 'Ensemble limit');
if (process.env[envVar] !== undefined) {
value = envValue;
}
// Check global config
if (globalConfig[key] !== undefined) {
value = Math.max(minVal, Math.min(maxVal, globalConfig[key]));
}
// Check per-ensemble override
if (perEnsembleOverrides?.[key] !== undefined) {
value = Math.max(minVal, Math.min(maxVal, perEnsembleOverrides[key]));
}
return value;
};
return {
MAX_ELEMENTS: resolveLimit('maxElements', 'ENSEMBLE_MAX_ELEMENTS', 50, ENSEMBLE_MIN_LIMITS.MAX_ELEMENTS, ENSEMBLE_HARD_LIMITS.MAX_ELEMENTS),
MAX_NESTING_DEPTH: resolveLimit('maxNestingDepth', 'ENSEMBLE_MAX_NESTING_DEPTH', 5, ENSEMBLE_MIN_LIMITS.MAX_NESTING_DEPTH, ENSEMBLE_HARD_LIMITS.MAX_NESTING_DEPTH),
MAX_ACTIVATION_TIME: resolveLimit('maxActivationTime', 'ENSEMBLE_MAX_ACTIVATION_TIME', 30000, ENSEMBLE_MIN_LIMITS.MAX_ACTIVATION_TIME, ENSEMBLE_HARD_LIMITS.MAX_ACTIVATION_TIME),
MAX_CONTEXT_SIZE: resolveLimit('maxContextSize', 'ENSEMBLE_MAX_CONTEXT_SIZE', 1000, ENSEMBLE_MIN_LIMITS.MAX_CONTEXT_SIZE, ENSEMBLE_HARD_LIMITS.MAX_CONTEXT_SIZE),
MAX_CONTEXT_VALUE_SIZE: resolveLimit('maxContextValueSize', 'ENSEMBLE_MAX_CONTEXT_VALUE_SIZE', 10000, ENSEMBLE_MIN_LIMITS.MAX_CONTEXT_VALUE_SIZE, ENSEMBLE_HARD_LIMITS.MAX_CONTEXT_VALUE_SIZE),
MAX_DEPENDENCIES: resolveLimit('maxDependencies', 'ENSEMBLE_MAX_DEPENDENCIES', 10, ENSEMBLE_MIN_LIMITS.MAX_DEPENDENCIES, ENSEMBLE_HARD_LIMITS.MAX_DEPENDENCIES),
MAX_CONDITION_LENGTH: resolveLimit('maxConditionLength', 'ENSEMBLE_MAX_CONDITION_LENGTH', 200, ENSEMBLE_MIN_LIMITS.MAX_CONDITION_LENGTH, ENSEMBLE_HARD_LIMITS.MAX_CONDITION_LENGTH)
};
}
// ==================== DEFAULT LIMITS (Backwards Compatible) ====================
/**
* Resource limits to prevent DoS attacks and ensure system stability
*
* Note: Rate limiting is not implemented at the Ensemble level because:
* 1. The activationInProgress flag already prevents concurrent activations
* 2. Rate limiting should be handled at the handler/API level, not in the domain model
* 3. Different deployment scenarios may have different rate limiting requirements
*
* CONFIGURABILITY: Use getEffectiveLimits() to get limits that respect
* environment variables, global config, and per-ensemble overrides.
* This constant provides the base defaults for backwards compatibility.
*/
export const ENSEMBLE_LIMITS = {
MAX_ELEMENTS: 50, // Maximum elements in an ensemble
MAX_NESTING_DEPTH: 5, // Maximum depth of nested ensembles
MAX_ACTIVATION_TIME: 30000, // 30 seconds max activation time
MAX_CONTEXT_SIZE: 1000, // Maximum keys in shared context
MAX_CONTEXT_VALUE_SIZE: 10000, // Maximum size of a context value (bytes)
MAX_DEPENDENCIES: 10, // Maximum dependencies per element
MAX_CONDITION_LENGTH: 200 // Maximum length of activation condition
};
/**
* Default values for ensemble configuration
*/
export const ENSEMBLE_DEFAULTS = {
ACTIVATION_STRATEGY: 'sequential',
CONFLICT_RESOLUTION: 'last-write',
ELEMENT_ROLE: 'support',
PRIORITY: 50, // Mid-range priority (0-100)
ALLOW_NESTED: true,
ACTIVATION_TIMEOUT: 5000, // 5 seconds per element
MAX_NESTING_DEPTH: 5,
CONTEXT_SHARING: 'selective'
};
/**
* Supported activation strategies
* Must match ActivationStrategy type in types.ts
*/
export const ACTIVATION_STRATEGIES = [
'all',
'sequential',
'lazy',
'conditional',
'priority'
];
/**
* Supported conflict resolution strategies
*/
export const CONFLICT_STRATEGIES = [
'last-write',
'first-write',
'priority',
'merge',
'error'
];
/**
* Element roles within an ensemble
*/
export const ELEMENT_ROLES = [
'primary',
'support',
'override',
'monitor',
'core' // Legacy alias for 'primary' — accepted for backwards compatibility
];
/**
* Activation modes for elements
*/
export const ACTIVATION_MODES = [
'always',
'on-demand',
'conditional'
];
/**
* Security event types for ensemble operations
* These are logged via SecurityMonitor for audit trails
*/
export const ENSEMBLE_SECURITY_EVENTS = {
CIRCULAR_DEPENDENCY: 'ENSEMBLE_CIRCULAR_DEPENDENCY',
RESOURCE_LIMIT_EXCEEDED: 'ENSEMBLE_RESOURCE_LIMIT_EXCEEDED',
ACTIVATION_TIMEOUT: 'ENSEMBLE_ACTIVATION_TIMEOUT',
ACTIVATION_FAILED: 'ENSEMBLE_ACTIVATION_FAILED',
SUSPICIOUS_CONDITION: 'ENSEMBLE_SUSPICIOUS_CONDITION',
CONDITION_EVALUATION_FAILED: 'ENSEMBLE_CONDITION_EVALUATION_FAILED',
NESTED_DEPTH_EXCEEDED: 'ENSEMBLE_NESTED_DEPTH_EXCEEDED',
CONTEXT_SIZE_EXCEEDED: 'ENSEMBLE_CONTEXT_SIZE_EXCEEDED',
CONTEXT_VALUE_TOO_LARGE: 'ENSEMBLE_CONTEXT_VALUE_TOO_LARGE',
SAVED: 'ENSEMBLE_SAVED',
IMPORTED: 'ENSEMBLE_IMPORTED',
DELETED: 'ENSEMBLE_DELETED',
ACTIVATED: 'ENSEMBLE_ACTIVATED',
DEACTIVATED: 'ENSEMBLE_DEACTIVATED'
};
/**
* Error messages for validation
*/
export const ENSEMBLE_ERRORS = {
TOO_MANY_ELEMENTS: `Ensemble cannot contain more than ${ENSEMBLE_LIMITS.MAX_ELEMENTS} elements`,
NESTING_TOO_DEEP: `Ensemble nesting depth cannot exceed ${ENSEMBLE_LIMITS.MAX_NESTING_DEPTH}`,
CIRCULAR_DEPENDENCY: 'Circular dependency detected in ensemble',
INVALID_STRATEGY: 'Invalid activation strategy',
INVALID_CONFLICT_RESOLUTION: 'Invalid conflict resolution strategy',
INVALID_ELEMENT_ROLE: 'Invalid element role',
INVALID_ACTIVATION_MODE: 'Invalid activation mode',
ELEMENT_NOT_FOUND: 'Element not found in ensemble',
ACTIVATION_TIMEOUT: 'Ensemble activation timed out',
CONTEXT_OVERFLOW: 'Shared context size exceeded limits',
ELEMENT_LOAD_FAILED: 'Failed to load element',
CONDITION_EVALUATION_FAILED: 'Failed to evaluate activation condition'
};
/**
* Regex patterns for validation
*/
export const ENSEMBLE_PATTERNS = {
// Condition pattern - allows safe comparison expressions
// Allows almost any character EXCEPT obviously dangerous ones (backticks, $, braces)
// The real security enforcement happens in:
// 1. DANGEROUS_CONDITION_PATTERNS check (blocks eval, require, etc.)
// 2. VM sandbox execution (prevents code injection)
//
// This pattern just prevents template literals (`), variable interpolation (${}),
// and code blocks ({}). Everything else is allowed and will be safely evaluated in the VM.
CONDITION_PATTERN: /^[^`${}]+$/,
// Element name pattern (alphanumeric, hyphens, underscores)
ELEMENT_NAME_PATTERN: /^[a-zA-Z0-9_-]+$/
};
/**
* Dangerous keywords that should be rejected in conditions
*
* These patterns are checked separately from CONDITION_PATTERN for security.
* Note: We focus on dangerous code execution patterns rather than unsupported
* operators, since condition evaluation isn't implemented yet. When it is
* implemented, the evaluator will handle operator support properly.
*/
export const DANGEROUS_CONDITION_PATTERNS = [
// Function calls and code execution
/\beval\b/i,
/\bFunction\b/i,
/\brequire\b/i,
/\bimport\b/i,
/\bexport\b/i,
// Process and global access
/\bprocess\b/i,
/\bglobal\b/i,
/\bwindow\b/i,
/\bdocument\b/i,
// Prototype pollution
/__proto__/i,
/\bconstructor\b/i,
/\.prototype\b/i,
// Dangerous operators
/[;,?:]/, // Semicolon, comma, ternary
/(?<![=!<>])=(?![=])/, // Assignment (but allow ==, !=, ===, !==, <=, >=)
/\+=|-=|\*=|\/=|%=/, // Compound assignment
// Empty or whitespace only
/^\s*$/
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../../src/elements/ensembles/constants.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Constants for Ensemble elements\n *\n * Defines limits, defaults, and security constants following patterns from other elements\n *\n * CONFIGURABILITY (Issue #368):\n * Limits can be configured via:\n * 1. Environment variables (e.g., ENSEMBLE_MAX_ELEMENTS=100)\n * 2. Global configuration object (setGlobalEnsembleLimits())\n * 3. Per-ensemble overrides via metadata.resourceLimits\n *\n * Priority: Per-ensemble > Global config > Environment variables > Defaults\n *\n * @example\n * // 1. Environment variables (set before server starts)\n * // ENSEMBLE_MAX_ELEMENTS=100\n * // ENSEMBLE_MAX_NESTING_DEPTH=3\n * // ENSEMBLE_MAX_ACTIVATION_TIME=60000\n *\n * @example\n * // 2. Global configuration (programmatic)\n * import { setGlobalEnsembleLimits } from './constants.js';\n * setGlobalEnsembleLimits({\n *   maxElements: 75,\n *   maxNestingDepth: 4,\n *   maxActivationTime: 45000\n * });\n *\n * @example\n * // 3. Per-ensemble override (in ensemble metadata)\n * const ensemble = new Ensemble({\n *   name: 'my-ensemble',\n *   resourceLimits: {\n *     maxActiveElements: 25,      // Maps to MAX_ELEMENTS\n *     maxExecutionTimeMs: 10000   // Maps to MAX_ACTIVATION_TIME\n *   }\n * }, elements, metadataService);\n */\n\nimport { logger } from '../../utils/logger.js';\nimport { parseEnvInt } from '../../config/env-utils.js';\n\n// ==================== HARD LIMITS (Security) ====================\n/**\n * Absolute maximum values for security - cannot be exceeded even with configuration\n * These prevent resource exhaustion and DoS attacks\n */\nexport const ENSEMBLE_HARD_LIMITS = {\n  MAX_ELEMENTS: 500,                   // Absolute max elements (security ceiling)\n  MAX_NESTING_DEPTH: 10,               // Absolute max nesting (prevent stack overflow)\n  MAX_ACTIVATION_TIME: 300000,         // 5 minutes absolute max (300 seconds)\n  MAX_CONTEXT_SIZE: 10000,             // Absolute max context keys\n  MAX_CONTEXT_VALUE_SIZE: 1048576,     // 1MB absolute max per value\n  MAX_DEPENDENCIES: 50,                // Absolute max dependencies per element\n  MAX_CONDITION_LENGTH: 1000           // Absolute max condition length\n} as const;\n\n/**\n * Minimum values for safety - configured values cannot go below these\n */\nexport const ENSEMBLE_MIN_LIMITS = {\n  MAX_ELEMENTS: 1,                     // Must allow at least 1 element\n  MAX_NESTING_DEPTH: 0,                // 0 means no nesting allowed\n  MAX_ACTIVATION_TIME: 1000,           // At least 1 second\n  MAX_CONTEXT_SIZE: 10,                // At least 10 context keys\n  MAX_CONTEXT_VALUE_SIZE: 100,         // At least 100 bytes per value\n  MAX_DEPENDENCIES: 1,                 // At least 1 dependency allowed\n  MAX_CONDITION_LENGTH: 10             // At least 10 chars for conditions\n} as const;\n\n// ==================== GLOBAL CONFIGURATION ====================\n/**\n * Interface for configurable ensemble limits\n * All properties are optional - unset properties use defaults\n */\nexport interface EnsembleLimitsConfig {\n  /** Maximum elements in an ensemble (default: 50, max: 500) */\n  maxElements?: number;\n  /** Maximum depth of nested ensembles (default: 5, max: 10) */\n  maxNestingDepth?: number;\n  /** Maximum activation time in ms (default: 30000, max: 300000) */\n  maxActivationTime?: number;\n  /** Maximum keys in shared context (default: 1000, max: 10000) */\n  maxContextSize?: number;\n  /** Maximum size of a context value in bytes (default: 10000, max: 1048576) */\n  maxContextValueSize?: number;\n  /** Maximum dependencies per element (default: 10, max: 50) */\n  maxDependencies?: number;\n  /** Maximum length of activation condition (default: 200, max: 1000) */\n  maxConditionLength?: number;\n}\n\n// Global configuration storage (module-level singleton)\nlet globalConfig: EnsembleLimitsConfig = {};\n\n/**\n * Set global ensemble limits configuration\n * Values are validated against hard limits\n *\n * @param config - Configuration object with desired limits\n * @example\n * setGlobalEnsembleLimits({\n *   maxElements: 100,\n *   maxNestingDepth: 3,\n *   maxActivationTime: 60000\n * });\n */\nexport function setGlobalEnsembleLimits(config: EnsembleLimitsConfig): void {\n  const previousConfig = { ...globalConfig };\n  const previousKeys = Object.keys(previousConfig);\n  globalConfig = { ...config };\n  const newKeys = Object.keys(config);\n\n  // Determine what changed for the audit trail\n  const addedKeys = newKeys.filter(k => !previousKeys.includes(k));\n  const removedKeys = previousKeys.filter(k => !newKeys.includes(k));\n  const modifiedKeys = newKeys.filter(k =>\n    previousKeys.includes(k) &&\n    previousConfig[k as keyof EnsembleLimitsConfig] !== config[k as keyof EnsembleLimitsConfig]\n  );\n\n  const timestamp = new Date().toISOString();\n  const summary = `${addedKeys.length} added, ${removedKeys.length} removed, ${modifiedKeys.length} modified`;\n\n  // Info level: concise summary for normal operation\n  logger.info('Global ensemble limits configuration updated', {\n    timestamp,\n    summary,\n    configuredKeys: newKeys\n  });\n\n  // Debug level: complete audit trail for troubleshooting\n  logger.debug('Global ensemble limits configuration audit trail', {\n    timestamp,\n    previousConfig: previousKeys.length > 0 ? previousConfig : '(no previous configuration)',\n    newConfig: config,\n    changes: {\n      added: addedKeys.length > 0 ? addedKeys : undefined,\n      removed: removedKeys.length > 0 ? removedKeys : undefined,\n      modified: modifiedKeys.length > 0 ? modifiedKeys.map(k => ({\n        key: k,\n        from: previousConfig[k as keyof EnsembleLimitsConfig],\n        to: config[k as keyof EnsembleLimitsConfig]\n      })) : undefined\n    },\n    summary,\n    impact: 'New limits apply to ensembles created or activated after this change. Existing cached limits are not affected until invalidateLimitsCache() is called.'\n  });\n}\n\n/**\n * Get current global ensemble limits configuration\n * @returns Copy of current global config\n */\nexport function getGlobalEnsembleLimits(): Readonly<EnsembleLimitsConfig> {\n  return { ...globalConfig };\n}\n\n/**\n * Reset global ensemble limits to defaults (clears all overrides)\n */\nexport function resetGlobalEnsembleLimits(): void {\n  const previousConfig = { ...globalConfig };\n  const hadPreviousConfig = Object.keys(previousConfig).length > 0;\n  globalConfig = {};\n\n  const timestamp = new Date().toISOString();\n  const clearedKeys = hadPreviousConfig ? Object.keys(previousConfig) : [];\n\n  // Info level: concise summary for normal operation\n  logger.info('Global ensemble limits configuration reset to defaults', {\n    timestamp,\n    clearedCount: clearedKeys.length\n  });\n\n  // Debug level: complete audit trail for troubleshooting\n  if (hadPreviousConfig) {\n    logger.debug('Global ensemble limits reset audit trail', {\n      timestamp,\n      previousConfig,\n      clearedKeys,\n      newConfig: '(using defaults - environment variables and per-ensemble overrides still apply)',\n      impact: 'Ensembles will now use environment variables or built-in defaults. Existing cached limits are not affected until invalidateLimitsCache() is called.'\n    });\n  }\n}\n\n// ==================== EFFECTIVE LIMITS CALCULATION ====================\n/**\n * Resolved ensemble limits structure\n * Uses number type (not literal types) since values are computed at runtime\n */\nexport interface ResolvedEnsembleLimits {\n  readonly MAX_ELEMENTS: number;\n  readonly MAX_NESTING_DEPTH: number;\n  readonly MAX_ACTIVATION_TIME: number;\n  readonly MAX_CONTEXT_SIZE: number;\n  readonly MAX_CONTEXT_VALUE_SIZE: number;\n  readonly MAX_DEPENDENCIES: number;\n  readonly MAX_CONDITION_LENGTH: number;\n}\n\n/**\n * Get effective limits with proper priority:\n * Per-ensemble override > Global config > Environment variable > Default\n *\n * @param perEnsembleOverrides - Optional per-ensemble limit overrides\n * @returns Resolved limits object\n */\nexport function getEffectiveLimits(perEnsembleOverrides?: Partial<EnsembleLimitsConfig>): ResolvedEnsembleLimits {\n  // Helper to resolve a single limit value\n  const resolveLimit = (\n    key: keyof EnsembleLimitsConfig,\n    envVar: string,\n    defaultVal: number,\n    minVal: number,\n    maxVal: number\n  ): number => {\n    // Priority: per-ensemble > global > env > default\n    let value = defaultVal;\n\n    // Check environment variable\n    const envValue = parseEnvInt(envVar, defaultVal, minVal, maxVal, 'Ensemble limit');\n    if (process.env[envVar] !== undefined) {\n      value = envValue;\n    }\n\n    // Check global config\n    if (globalConfig[key] !== undefined) {\n      value = Math.max(minVal, Math.min(maxVal, globalConfig[key]!));\n    }\n\n    // Check per-ensemble override\n    if (perEnsembleOverrides?.[key] !== undefined) {\n      value = Math.max(minVal, Math.min(maxVal, perEnsembleOverrides[key]!));\n    }\n\n    return value;\n  };\n\n  return {\n    MAX_ELEMENTS: resolveLimit('maxElements', 'ENSEMBLE_MAX_ELEMENTS', 50,\n      ENSEMBLE_MIN_LIMITS.MAX_ELEMENTS, ENSEMBLE_HARD_LIMITS.MAX_ELEMENTS),\n    MAX_NESTING_DEPTH: resolveLimit('maxNestingDepth', 'ENSEMBLE_MAX_NESTING_DEPTH', 5,\n      ENSEMBLE_MIN_LIMITS.MAX_NESTING_DEPTH, ENSEMBLE_HARD_LIMITS.MAX_NESTING_DEPTH),\n    MAX_ACTIVATION_TIME: resolveLimit('maxActivationTime', 'ENSEMBLE_MAX_ACTIVATION_TIME', 30000,\n      ENSEMBLE_MIN_LIMITS.MAX_ACTIVATION_TIME, ENSEMBLE_HARD_LIMITS.MAX_ACTIVATION_TIME),\n    MAX_CONTEXT_SIZE: resolveLimit('maxContextSize', 'ENSEMBLE_MAX_CONTEXT_SIZE', 1000,\n      ENSEMBLE_MIN_LIMITS.MAX_CONTEXT_SIZE, ENSEMBLE_HARD_LIMITS.MAX_CONTEXT_SIZE),\n    MAX_CONTEXT_VALUE_SIZE: resolveLimit('maxContextValueSize', 'ENSEMBLE_MAX_CONTEXT_VALUE_SIZE', 10000,\n      ENSEMBLE_MIN_LIMITS.MAX_CONTEXT_VALUE_SIZE, ENSEMBLE_HARD_LIMITS.MAX_CONTEXT_VALUE_SIZE),\n    MAX_DEPENDENCIES: resolveLimit('maxDependencies', 'ENSEMBLE_MAX_DEPENDENCIES', 10,\n      ENSEMBLE_MIN_LIMITS.MAX_DEPENDENCIES, ENSEMBLE_HARD_LIMITS.MAX_DEPENDENCIES),\n    MAX_CONDITION_LENGTH: resolveLimit('maxConditionLength', 'ENSEMBLE_MAX_CONDITION_LENGTH', 200,\n      ENSEMBLE_MIN_LIMITS.MAX_CONDITION_LENGTH, ENSEMBLE_HARD_LIMITS.MAX_CONDITION_LENGTH)\n  };\n}\n\n// ==================== DEFAULT LIMITS (Backwards Compatible) ====================\n/**\n * Resource limits to prevent DoS attacks and ensure system stability\n *\n * Note: Rate limiting is not implemented at the Ensemble level because:\n * 1. The activationInProgress flag already prevents concurrent activations\n * 2. Rate limiting should be handled at the handler/API level, not in the domain model\n * 3. Different deployment scenarios may have different rate limiting requirements\n *\n * CONFIGURABILITY: Use getEffectiveLimits() to get limits that respect\n * environment variables, global config, and per-ensemble overrides.\n * This constant provides the base defaults for backwards compatibility.\n */\nexport const ENSEMBLE_LIMITS = {\n  MAX_ELEMENTS: 50,                    // Maximum elements in an ensemble\n  MAX_NESTING_DEPTH: 5,                // Maximum depth of nested ensembles\n  MAX_ACTIVATION_TIME: 30000,          // 30 seconds max activation time\n  MAX_CONTEXT_SIZE: 1000,              // Maximum keys in shared context\n  MAX_CONTEXT_VALUE_SIZE: 10000,       // Maximum size of a context value (bytes)\n  MAX_DEPENDENCIES: 10,                // Maximum dependencies per element\n  MAX_CONDITION_LENGTH: 200            // Maximum length of activation condition\n} as const;\n\n/**\n * Default values for ensemble configuration\n */\nexport const ENSEMBLE_DEFAULTS = {\n  ACTIVATION_STRATEGY: 'sequential' as const,\n  CONFLICT_RESOLUTION: 'last-write' as const,\n  ELEMENT_ROLE: 'support' as const,\n  PRIORITY: 50,                        // Mid-range priority (0-100)\n  ALLOW_NESTED: true,\n  ACTIVATION_TIMEOUT: 5000,            // 5 seconds per element\n  MAX_NESTING_DEPTH: 5,\n  CONTEXT_SHARING: 'selective' as const\n} as const;\n\n/**\n * Supported activation strategies\n * Must match ActivationStrategy type in types.ts\n */\nexport const ACTIVATION_STRATEGIES = [\n  'all',\n  'sequential',\n  'lazy',\n  'conditional',\n  'priority'\n] as const;\n\n/**\n * Supported conflict resolution strategies\n */\nexport const CONFLICT_STRATEGIES = [\n  'last-write',\n  'first-write',\n  'priority',\n  'merge',\n  'error'\n] as const;\n\n/**\n * Element roles within an ensemble\n */\nexport const ELEMENT_ROLES = [\n  'primary',\n  'support',\n  'override',\n  'monitor',\n  'core'   // Legacy alias for 'primary' — accepted for backwards compatibility\n] as const;\n\n/**\n * Activation modes for elements\n */\nexport const ACTIVATION_MODES = [\n  'always',\n  'on-demand',\n  'conditional'\n] as const;\n\n/**\n * Security event types for ensemble operations\n * These are logged via SecurityMonitor for audit trails\n */\nexport const ENSEMBLE_SECURITY_EVENTS = {\n  CIRCULAR_DEPENDENCY: 'ENSEMBLE_CIRCULAR_DEPENDENCY',\n  RESOURCE_LIMIT_EXCEEDED: 'ENSEMBLE_RESOURCE_LIMIT_EXCEEDED',\n  ACTIVATION_TIMEOUT: 'ENSEMBLE_ACTIVATION_TIMEOUT',\n  ACTIVATION_FAILED: 'ENSEMBLE_ACTIVATION_FAILED',\n  SUSPICIOUS_CONDITION: 'ENSEMBLE_SUSPICIOUS_CONDITION',\n  CONDITION_EVALUATION_FAILED: 'ENSEMBLE_CONDITION_EVALUATION_FAILED',\n  NESTED_DEPTH_EXCEEDED: 'ENSEMBLE_NESTED_DEPTH_EXCEEDED',\n  CONTEXT_SIZE_EXCEEDED: 'ENSEMBLE_CONTEXT_SIZE_EXCEEDED',\n  CONTEXT_VALUE_TOO_LARGE: 'ENSEMBLE_CONTEXT_VALUE_TOO_LARGE',\n  SAVED: 'ENSEMBLE_SAVED',\n  IMPORTED: 'ENSEMBLE_IMPORTED',\n  DELETED: 'ENSEMBLE_DELETED',\n  ACTIVATED: 'ENSEMBLE_ACTIVATED',\n  DEACTIVATED: 'ENSEMBLE_DEACTIVATED'\n} as const;\n\n/**\n * Error messages for validation\n */\nexport const ENSEMBLE_ERRORS = {\n  TOO_MANY_ELEMENTS: `Ensemble cannot contain more than ${ENSEMBLE_LIMITS.MAX_ELEMENTS} elements`,\n  NESTING_TOO_DEEP: `Ensemble nesting depth cannot exceed ${ENSEMBLE_LIMITS.MAX_NESTING_DEPTH}`,\n  CIRCULAR_DEPENDENCY: 'Circular dependency detected in ensemble',\n  INVALID_STRATEGY: 'Invalid activation strategy',\n  INVALID_CONFLICT_RESOLUTION: 'Invalid conflict resolution strategy',\n  INVALID_ELEMENT_ROLE: 'Invalid element role',\n  INVALID_ACTIVATION_MODE: 'Invalid activation mode',\n  ELEMENT_NOT_FOUND: 'Element not found in ensemble',\n  ACTIVATION_TIMEOUT: 'Ensemble activation timed out',\n  CONTEXT_OVERFLOW: 'Shared context size exceeded limits',\n  ELEMENT_LOAD_FAILED: 'Failed to load element',\n  CONDITION_EVALUATION_FAILED: 'Failed to evaluate activation condition'\n} as const;\n\n/**\n * Regex patterns for validation\n */\nexport const ENSEMBLE_PATTERNS = {\n  // Condition pattern - allows safe comparison expressions\n  // Allows almost any character EXCEPT obviously dangerous ones (backticks, $, braces)\n  // The real security enforcement happens in:\n  // 1. DANGEROUS_CONDITION_PATTERNS check (blocks eval, require, etc.)\n  // 2. VM sandbox execution (prevents code injection)\n  //\n  // This pattern just prevents template literals (`), variable interpolation (${}),\n  // and code blocks ({}). Everything else is allowed and will be safely evaluated in the VM.\n  CONDITION_PATTERN: /^[^`${}]+$/,\n\n  // Element name pattern (alphanumeric, hyphens, underscores)\n  ELEMENT_NAME_PATTERN: /^[a-zA-Z0-9_-]+$/\n} as const;\n\n/**\n * Dangerous keywords that should be rejected in conditions\n *\n * These patterns are checked separately from CONDITION_PATTERN for security.\n * Note: We focus on dangerous code execution patterns rather than unsupported\n * operators, since condition evaluation isn't implemented yet. When it is\n * implemented, the evaluator will handle operator support properly.\n */\nexport const DANGEROUS_CONDITION_PATTERNS = [\n  // Function calls and code execution\n  /\\beval\\b/i,\n  /\\bFunction\\b/i,\n  /\\brequire\\b/i,\n  /\\bimport\\b/i,\n  /\\bexport\\b/i,\n\n  // Process and global access\n  /\\bprocess\\b/i,\n  /\\bglobal\\b/i,\n  /\\bwindow\\b/i,\n  /\\bdocument\\b/i,\n\n  // Prototype pollution\n  /__proto__/i,\n  /\\bconstructor\\b/i,\n  /\\.prototype\\b/i,\n\n  // Dangerous operators\n  /[;,?:]/,                    // Semicolon, comma, ternary\n  /(?<![=!<>])=(?![=])/,       // Assignment (but allow ==, !=, ===, !==, <=, >=)\n  /\\+=|-=|\\*=|\\/=|%=/,         // Compound assignment\n\n  // Empty or whitespace only\n  /^\\s*$/\n] as const;\n"]}