xypriss 1.1.3 → 1.2.0

package/README.md

@@ -54,7 +54,7 @@ npm i --save-dev @types/express
 import { createServer } from "xypriss";
 
 // Create a new XyPriss server
-const server = createServer({
+const app = createServer({
     server: {
         port: 3000,
         host: "localhost",
@@ -71,18 +71,20 @@ const server = createServer({
 });
 
 // Define routes using standard Express.js syntax
-server.get("/", (req, res) => {
+app.get("/", (req, res) => {
     res.json({ message: "Hello from XyPriss!" });
 });
 
-server.get("/api/users/:id", (req, res) => {
+app.get("/api/users/:id", (req, res) => {
     const userId = req.params.id;
     res.json({ userId, data: "User data" });
 });
 
 // Start the server
-server.listen(3000, () => {
-    console.log("XyPriss server running on port 3000");
+app.start(undefined, () => {
+    console.log(
+        "Secure XyPriss server running at http://localhost:" + app.getPort()
+    );
 });
 ```
 
@@ -152,7 +154,7 @@ const server = createServer({
 
 ```typescript
 import { createServer } from "xypriss";
-import { XyPrissSecurity, fString, fArray } from "xypriss-security";
+import { XyPrissSecurity as security, fString, fArray } from "xypriss-security";
 
 const server = createServer({
     server: {
@@ -161,9 +163,6 @@ const server = createServer({
     },
 });
 
-// Initialize security module
-const security = new XyPrissSecurity();
-
 // Secure route with encryption
 server.post("/api/secure-data", async (req, res) => {
     try {
@@ -190,8 +189,10 @@ server.post("/api/secure-data", async (req, res) => {
     }
 });
 
-server.listen(3000, () => {
-    console.log("Secure XyPriss server running");
+server.start(undefined, () => {
+    console.log(
+        "Secure XyPriss server running at http://localhost:" + server.getPort()
+    );
 });
 ```
 
@@ -219,7 +220,7 @@ XyPriss integrates with the XyPriss Security toolkit, providing:
 ```typescript
 import { createServer } from "xypriss";
 import {
-    XyPrissSecurity,
+    XyPrissSecurity as security, // or just import XyPriss
     fArray,
     fString,
     fObject,
@@ -230,7 +231,6 @@ import {
 const server = createServer({
     /* config */
 });
-const security = new XyPrissSecurity();
 ```
 
 ## Documentation

package/dist/cjs/mods/security/src/index.js

@@ -2,18 +2,18 @@
 
 var types = require('./types.js');
 var hashCore = require('./core/hash/hash-core.js');
-require('./core/hash/hash-types.js');
+var hashTypes = require('./core/hash/hash-types.js');
 require('crypto');
-require('./core/hash/hash-security.js');
-require('./core/hash/hash-advanced.js');
-require('./algorithms/hash-algorithms.js');
+var hashSecurity = require('./core/hash/hash-security.js');
+var hashAdvanced = require('./core/hash/hash-advanced.js');
+var hashAlgorithms = require('./algorithms/hash-algorithms.js');
 require('./core/keys/keys-types.js');
 require('./core/keys/keys-logger.js');
 require('./core/keys/keys-utils.js');
 require('./core/keys/algorithms/mods/PBKDF2Algo.js');
 var randomCore = require('./core/random/random-core.js');
-require('./core/random/random-types.js');
-require('./core/random/random-sources.js');
+var randomTypes = require('./core/random/random-types.js');
+var randomSources = require('./core/random/random-sources.js');
 require('nehonix-uri-processor');
 require('./utils/memory/index.js');
 require('argon2');
@@ -25,10 +25,10 @@ var tamperEvidentLogging = require('./components/tamper-evident-logging.js');
 require('./components/secure-string/advanced/entropy-analyzer.js');
 require('./components/secure-string/advanced/quantum-safe.js');
 require('./components/secure-string/advanced/performance-monitor.js');
-var index$1 = require('./components/secure-object/index.js');
+var index$2 = require('./components/secure-object/index.js');
 require('./components/secure-array/utils/id-generator.js');
 var passwordTypes = require('./core/password/password-types.js');
-require('./core/password/index.js');
+var index$1 = require('./core/password/index.js');
 require('./components/fortified-function/core/fortified-function-core.js');
 require('./components/fortified-function/core/fortified-config.js');
 require('./components/fortified-function/core/fortified-logger.js');
@@ -40,7 +40,7 @@ require('./components/fortified-function/UFA/ultra-fast-allocator.js');
 var passwordCore = require('./core/password/password-core.js');
 
 /***************************************************************************
- * XyPrissSecurity - Ex xypriss2-js is an Advanced JavaScript Security Library designed for XyPriss
+ * XyPrissSecurity - Ex fortify2-js is an Advanced JavaScript Security Library designed for XyPriss
  *
  * This file contains the main entry point for the XyPrissSecurity library.
  *
@@ -117,7 +117,11 @@ var passwordCore = require('./core/password/password-core.js');
  * console.log(apiKey); // "aK7mN9pQ2rS8tU3vW6xY1zB4cD5eF7gH"
  *
  * // Quick token generation
- * const sessionToken = generateSecureToken(64, "base64url");
+ * const sessionToken = generateSecureToken({
+    length: 32,
+    entropy: "maximum",
+
+});
  * ```
  *
  * ### Secure Data Structures
@@ -369,7 +373,7 @@ passwordCore.PasswordManager.getInstance();
  * @since 1.0.0
  */
 function fObject(...args) {
-    return index$1.createSecureObject(...args);
+    return index$2.createSecureObject(...args);
 }
 
 Object.defineProperty(exports, 'EntropySource', {
@@ -393,7 +397,24 @@ Object.defineProperty(exports, 'TokenType', {
     get: function () { return types.TokenType; }
 });
 exports.Hash = hashCore.Hash;
+Object.defineProperty(exports, 'HashStrength', {
+    enumerable: true,
+    get: function () { return hashTypes.HashStrength; }
+});
+exports.HashSecurity = hashSecurity.HashSecurity;
+exports.HashAdvanced = hashAdvanced.HashAdvanced;
+exports.HashAlgorithms = hashAlgorithms.HashAlgorithms;
 exports.Random = randomCore.SecureRandom;
+exports.SecureRandom = randomCore.SecureRandom;
+Object.defineProperty(exports, 'EntropyQuality', {
+    enumerable: true,
+    get: function () { return randomTypes.EntropyQuality; }
+});
+Object.defineProperty(exports, 'RNGState', {
+    enumerable: true,
+    get: function () { return randomTypes.RNGState; }
+});
+exports.RandomSources = randomSources.RandomSources;
 Object.defineProperty(exports, 'SecurityIssueType', {
     enumerable: true,
     get: function () { return runtimeVerification.SecurityIssueType; }
@@ -404,7 +425,7 @@ Object.defineProperty(exports, 'LogLevel', {
     get: function () { return tamperEvidentLogging.LogLevel; }
 });
 exports.TamperEvidentLogger = tamperEvidentLogging.TamperEvidentLogger;
-exports.createSecureObject = index$1.createSecureObject;
+exports.createSecureObject = index$2.createSecureObject;
 Object.defineProperty(exports, 'PasswordAlgorithm', {
     enumerable: true,
     get: function () { return passwordTypes.PasswordAlgorithm; }
@@ -413,6 +434,8 @@ Object.defineProperty(exports, 'PasswordSecurityLevel', {
     enumerable: true,
     get: function () { return passwordTypes.PasswordSecurityLevel; }
 });
+exports.getDefaultPasswordPolicy = index$1.getDefaultPasswordPolicy;
+exports.getRecommendedConfig = index$1.getRecommendedConfig;
 exports.PasswordManager = passwordCore.PasswordManager;
 exports.fObject = fObject;
 //# sourceMappingURL=index.js.map

package/dist/cjs/mods/security/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../../../../mods/security/src/index.ts"],"sourcesContent":[null],"names":["SecureRandom","Hash","PasswordManager","fObjectUtils.createSecureObject"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4JG;AAkgBH;;;;;;;;;;;;;;;AAeG;AAEH;AAC8BA,uBAAY,CAAC,eAAe;AAE1D;AACkCA,uBAAY,CAAC,mBAAmB;AAmBlE;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AAEH;AACgCC,aAAI,CAAC,iBAAiB;AAEtD;AACgCA,aAAI,CAAC,iBAAiB;AAEtD;AAC0BA,aAAI,CAAC,WAAW;AAyL1C;;;;;;;;;;;;;;;;;;;;AAoBG;AACeC,4BAAe,CAAC,WAAW,GAAG;AA0EhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEG;AACa,SAAA,OAAO,CACnB,GAAG,IAA2D,EAAA;AAE9D,IAAA,OAAOC,0BAA+B,CAAI,GAAG,IAAI,CAAC,CAAC;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":["../../../../../mods/security/src/index.ts"],"sourcesContent":[null],"names":["SecureRandom","Hash","PasswordManager","fObjectUtils.createSecureObject"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BiF;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgKG;AAogBH;;;;;;;;;;;;;;;AAeG;AAEH;AAC8BA,uBAAY,CAAC,eAAe;AAE1D;AACkCA,uBAAY,CAAC,mBAAmB;AAmBlE;;;;;;;;;;;;;;;;;;;;;;;;AAwBG;AAEH;AACgCC,aAAI,CAAC,iBAAiB;AAEtD;AACgCA,aAAI,CAAC,iBAAiB;AAEtD;AAC0BA,aAAI,CAAC,WAAW;AAyL1C;;;;;;;;;;;;;;;;;;;;AAoBG;AACeC,4BAAe,CAAC,WAAW,GAAG;AA0EhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEG;AACa,SAAA,OAAO,CACnB,GAAG,IAA2D,EAAA;AAE9D,IAAA,OAAOC,0BAA+B,CAAI,GAAG,IAAI,CAAC,CAAC;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/src/index.js

@@ -6,6 +6,7 @@ var CacheFactory = require('./cache/CacheFactory.js');
 var securityMiddleware = require('./middleware/security-middleware.js');
 var performanceMonitor = require('./server/optimization/performance-monitor.js');
 var index = require('./cluster/index.js');
+var index$1 = require('./plugins/modules/index.js');
 var quickStart = require('./quick-start.js');
 var safeJsonMiddleware = require('./middleware/safe-json-middleware.js');
 var safeSerializer = require('../mods/security/src/components/fortified-function/serializer/safe-serializer.js');
@@ -18,6 +19,23 @@ var IPCManager = require('./cluster/modules/IPCManager.js');
 var MetricsCollector = require('./cluster/modules/MetricsCollector.js');
 var AutoScaler = require('./cluster/modules/AutoScaler.js');
 var ClusterFactory = require('./cluster/modules/ClusterFactory.js');
+var PluginRegistry = require('./plugins/modules/PluginRegistry.js');
+var PluginEngine = require('./plugins/modules/PluginEngine.js');
+var PluginTypes = require('./plugins/modules/types/PluginTypes.js');
+var SecurityPlugin = require('./plugins/modules/core/SecurityPlugin.js');
+var PerformancePlugin = require('./plugins/modules/core/PerformancePlugin.js');
+var CachePlugin = require('./plugins/modules/core/CachePlugin.js');
+var JWTAuthPlugin = require('./plugins/modules/builtin/JWTAuthPlugin.js');
+var ResponseTimePlugin = require('./plugins/modules/builtin/ResponseTimePlugin.js');
+var SmartCachePlugin = require('./plugins/modules/builtin/SmartCachePlugin.js');
+var NetworkPlugin = require('./plugins/modules/network/core/NetworkPlugin.js');
+var ConnectionPlugin = require('./plugins/modules/network/builtin/ConnectionPlugin.js');
+var CompressionPlugin = require('./plugins/modules/network/builtin/CompressionPlugin.js');
+var ProxyPlugin = require('./plugins/modules/network/builtin/ProxyPlugin.js');
+var RateLimitPlugin = require('./plugins/modules/network/builtin/RateLimitPlugin.js');
+var NetworkTypes = require('./plugins/modules/network/types/NetworkTypes.js');
+var NetworkPluginFactory = require('./plugins/modules/network/core/NetworkPluginFactory.js');
+var NetworkPluginUtils = require('./plugins/modules/network/utils/NetworkPluginUtils.js');
 
 
 
@@ -43,6 +61,13 @@ exports.mergeClusterConfigs = index.mergeClusterConfigs;
 exports.setClusterDefaults = index.setClusterDefaults;
 exports.validateClusterConfig = index.validateClusterConfig;
 exports.withClusterSupport = index.withClusterSupport;
+exports.DEFAULT_PLUGIN_CONFIG = index$1.DEFAULT_PLUGIN_CONFIG;
+exports.PERFORMANCE_TARGETS = index$1.PERFORMANCE_TARGETS;
+exports.PLUGIN_SYSTEM_NAME = index$1.PLUGIN_SYSTEM_NAME;
+exports.PLUGIN_SYSTEM_VERSION = index$1.PLUGIN_SYSTEM_VERSION;
+exports.PluginDevelopmentHelpers = index$1.PluginDevelopmentHelpers;
+exports.PluginSystemFactory = index$1.PluginSystemFactory;
+exports.PluginSystemUtils = index$1.PluginSystemUtils;
 exports.quickServer = quickStart.quickServer;
 exports.createCircularRefDebugger = safeJsonMiddleware.createCircularRefDebugger;
 exports.createSafeJsonMiddleware = safeJsonMiddleware.createSafeJsonMiddleware;
@@ -71,4 +96,35 @@ exports.clusterBuilderFactory = ClusterFactory.clusterBuilderFactory;
 exports.clusterFactory = ClusterFactory.clusterFactory;
 exports.createCluster = ClusterFactory.createCluster;
 exports.createClusterForEnvironment = ClusterFactory.createClusterForEnvironment;
+exports.PluginRegistry = PluginRegistry.PluginRegistry;
+exports.PluginEngine = PluginEngine.PluginEngine;
+Object.defineProperty(exports, 'PluginEventType', {
+	enumerable: true,
+	get: function () { return PluginTypes.PluginEventType; }
+});
+Object.defineProperty(exports, 'PluginPriority', {
+	enumerable: true,
+	get: function () { return PluginTypes.PluginPriority; }
+});
+Object.defineProperty(exports, 'PluginType', {
+	enumerable: true,
+	get: function () { return PluginTypes.PluginType; }
+});
+exports.SecurityPluginBase = SecurityPlugin.SecurityPlugin;
+exports.PerformancePluginBase = PerformancePlugin.PerformancePlugin;
+exports.CachePluginBase = CachePlugin.CachePlugin;
+exports.JWTAuthPlugin = JWTAuthPlugin.JWTAuthPlugin;
+exports.ResponseTimePlugin = ResponseTimePlugin.ResponseTimePlugin;
+exports.SmartCachePlugin = SmartCachePlugin.SmartCachePlugin;
+exports.NetworkPlugin = NetworkPlugin.NetworkPlugin;
+exports.ConnectionPlugin = ConnectionPlugin.ConnectionPlugin;
+exports.CompressionPlugin = CompressionPlugin.CompressionPlugin;
+exports.ProxyPlugin = ProxyPlugin.ProxyPlugin;
+exports.RateLimitPlugin = RateLimitPlugin.RateLimitPlugin;
+Object.defineProperty(exports, 'NetworkCategory', {
+	enumerable: true,
+	get: function () { return NetworkTypes.NetworkCategory; }
+});
+exports.NetworkPluginFactory = NetworkPluginFactory.NetworkPluginFactory;
+exports.NetworkPluginUtils = NetworkPluginUtils.NetworkPluginUtils;
 //# sourceMappingURL=index.js.map

package/dist/cjs/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/src/plugins/modules/PluginEngine.js

@@ -0,0 +1,378 @@
+'use strict';
+
+var events = require('events');
+var nehoid = require('nehoid');
+var PluginTypes = require('./types/PluginTypes.js');
+
+/**
+ * Ultra-Fast Plugin Execution Engine
+ *
+ * High-performance plugin execution engine designed to achieve <1ms overhead
+ * while maintaining security and comprehensive error handling.
+ */
+/**
+ * Ultra-fast plugin execution engine with intelligent optimization
+ */
+class PluginEngine extends events.EventEmitter {
+    constructor(registry, cache, cluster) {
+        super();
+        this.executionPool = new Map();
+        this.warmupCache = new Map();
+        // Performance optimization: Object pooling for contexts
+        this.contextPool = [];
+        this.MAX_POOL_SIZE = 100;
+        // Circuit breaker for failing plugins
+        this.circuitBreakers = new Map();
+        this.registry = registry;
+        this.cache = cache;
+        this.cluster = cluster;
+        // Listen to registry events
+        this.setupRegistryEventHandlers();
+    }
+    /**
+     * Execute plugins for a specific type with ultra-fast performance
+     */
+    async executePlugins(type, req, res, next) {
+        const startTime = performance.now();
+        const executionId = nehoid.NehoID.generate({ prefix: "plug.exec", size: 8 });
+        try {
+            // Get plugins for this type (pre-sorted by priority)
+            const plugins = this.registry.getPluginsByType(type);
+            if (plugins.length === 0) {
+                return true; // Continue execution if no plugins
+            }
+            // Create or reuse execution context
+            const context = this.createExecutionContext(req, res, next, executionId, startTime);
+            // Execute plugins based on type strategy
+            const success = await this.executePluginChain(plugins, context);
+            // Update performance metrics
+            const totalExecutionTime = performance.now() - startTime;
+            this.updatePerformanceMetrics(type, totalExecutionTime, success);
+            // Return context to pool
+            this.returnContextToPool(context);
+            return success;
+        }
+        catch (error) {
+            const executionTime = performance.now() - startTime;
+            this.handleExecutionError(type, executionId, error, executionTime);
+            return false;
+        }
+    }
+    /**
+     * Execute a single plugin with comprehensive error handling
+     */
+    async executePlugin(plugin, context) {
+        const startTime = performance.now();
+        try {
+            // Check circuit breaker
+            if (this.isCircuitBreakerOpen(plugin.id)) {
+                return {
+                    success: false,
+                    executionTime: 0,
+                    error: new Error(`Circuit breaker open for plugin ${plugin.id}`),
+                    shouldContinue: true,
+                };
+            }
+            // Warm up plugin if needed
+            await this.warmupPlugin(plugin, context);
+            // Execute plugin with timeout
+            const result = await this.executeWithTimeout(plugin, context);
+            const executionTime = performance.now() - startTime;
+            result.executionTime = executionTime;
+            // Update plugin statistics
+            this.registry.updateStats(plugin.id, executionTime, result.success);
+            // Reset circuit breaker on success
+            if (result.success) {
+                this.resetCircuitBreaker(plugin.id);
+            }
+            else {
+                this.updateCircuitBreaker(plugin.id);
+            }
+            // Emit execution event
+            this.emitPluginEvent(PluginTypes.PluginEventType.PLUGIN_EXECUTED, plugin.id, {
+                executionTime,
+                success: result.success,
+                type: plugin.type,
+            });
+            return result;
+        }
+        catch (error) {
+            const executionTime = performance.now() - startTime;
+            // Update circuit breaker
+            this.updateCircuitBreaker(plugin.id);
+            // Update error statistics
+            this.registry.updateStats(plugin.id, executionTime, false);
+            // Emit error event
+            this.emitPluginEvent(PluginTypes.PluginEventType.PLUGIN_ERROR, plugin.id, {
+                error: error.message,
+                executionTime,
+                type: plugin.type,
+            });
+            return {
+                success: false,
+                executionTime,
+                error,
+                shouldContinue: true,
+            };
+        }
+    }
+    /**
+     * Execute plugin chain with intelligent optimization
+     */
+    async executePluginChain(plugins, context) {
+        // For critical performance plugins, execute in parallel
+        if (plugins.length > 0 && plugins[0].type === PluginTypes.PluginType.PERFORMANCE) {
+            return await this.executePluginsParallel(plugins, context);
+        }
+        // For security and cache plugins, execute sequentially
+        return await this.executePluginsSequential(plugins, context);
+    }
+    /**
+     * Execute plugins sequentially (for security, cache operations)
+     */
+    async executePluginsSequential(plugins, context) {
+        for (const plugin of plugins) {
+            const result = await this.executePlugin(plugin, context);
+            if (!result.success && plugin.type === PluginTypes.PluginType.SECURITY) {
+                // Security plugins must succeed
+                return false;
+            }
+            if (!result.shouldContinue) {
+                // Plugin requested to stop execution
+                return false;
+            }
+            // Store plugin result data
+            if (result.data) {
+                context.pluginData.set(plugin.id, result.data);
+            }
+            // Handle cache data
+            if (result.cacheData) {
+                await this.cache.set(result.cacheData.key, result.cacheData.value, { ttl: result.cacheData.ttl });
+            }
+        }
+        return true;
+    }
+    /**
+     * Execute plugins in parallel (for performance monitoring)
+     */
+    async executePluginsParallel(plugins, context) {
+        const promises = plugins.map((plugin) => this.executePlugin(plugin, context));
+        const results = await Promise.allSettled(promises);
+        let allSuccessful = true;
+        results.forEach((result, index) => {
+            if (result.status === "fulfilled") {
+                const pluginResult = result.value;
+                if (!pluginResult.success) {
+                    allSuccessful = false;
+                }
+                // Store plugin result data
+                if (pluginResult.data) {
+                    context.pluginData.set(plugins[index].id, pluginResult.data);
+                }
+            }
+            else {
+                allSuccessful = false;
+            }
+        });
+        return allSuccessful;
+    }
+    /**
+     * Execute plugin with timeout protection
+     */
+    async executeWithTimeout(plugin, context) {
+        const timeoutMs = plugin.maxExecutionTime;
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.emitPluginEvent(PluginTypes.PluginEventType.PLUGIN_TIMEOUT, plugin.id, {
+                    timeout: timeoutMs,
+                    type: plugin.type,
+                });
+                reject(new Error(`Plugin ${plugin.id} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            // Execute plugin
+            const execution = plugin.isAsync
+                ? plugin.execute(context)
+                : Promise.resolve(plugin.execute(context));
+            execution
+                .then((result) => {
+                clearTimeout(timeout);
+                resolve(result);
+            })
+                .catch((error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    }
+    /**
+     * Create optimized execution context with object pooling
+     */
+    createExecutionContext(req, res, next, executionId, startTime) {
+        // Try to reuse context from pool
+        let context = this.contextPool.pop();
+        if (!context) {
+            context = {
+                req,
+                res,
+                next,
+                startTime,
+                executionId,
+                cache: this.cache,
+                cluster: this.cluster,
+                pluginData: new Map(),
+                security: {
+                    isAuthenticated: false,
+                    roles: [],
+                    permissions: [],
+                },
+                metrics: {
+                    requestStartTime: startTime,
+                    pluginExecutionTimes: new Map(),
+                    cacheHits: 0,
+                    cacheMisses: 0,
+                },
+            };
+        }
+        else {
+            // Reset reused context
+            context.req = req;
+            context.res = res;
+            context.next = next;
+            context.startTime = startTime;
+            context.executionId = executionId;
+            context.pluginData.clear();
+            context.metrics.pluginExecutionTimes.clear();
+            context.metrics.requestStartTime = startTime;
+            context.metrics.cacheHits = 0;
+            context.metrics.cacheMisses = 0;
+        }
+        return context;
+    }
+    /**
+     * Return context to pool for reuse
+     */
+    returnContextToPool(context) {
+        if (this.contextPool.length < this.MAX_POOL_SIZE) {
+            // Clear sensitive data before returning to pool
+            context.pluginData.clear();
+            context.metrics.pluginExecutionTimes.clear();
+            this.contextPool.push(context);
+        }
+    }
+    /**
+     * Warm up plugin for optimal performance
+     */
+    async warmupPlugin(plugin, context) {
+        if (this.warmupCache.has(plugin.id)) {
+            return; // Already warmed up
+        }
+        if (plugin.warmup) {
+            try {
+                await plugin.warmup(context);
+                this.warmupCache.set(plugin.id, true);
+            }
+            catch (error) {
+                // Warmup failure is not critical
+                console.warn(`Plugin ${plugin.id} warmup failed:`, error);
+            }
+        }
+    }
+    /**
+     * Circuit breaker management
+     */
+    isCircuitBreakerOpen(pluginId) {
+        const breaker = this.circuitBreakers.get(pluginId);
+        if (!breaker)
+            return false;
+        // Reset circuit breaker after 60 seconds
+        if (breaker.isOpen && Date.now() - breaker.lastFailure > 60000) {
+            breaker.isOpen = false;
+            breaker.failures = 0;
+        }
+        return breaker.isOpen;
+    }
+    updateCircuitBreaker(pluginId) {
+        const breaker = this.circuitBreakers.get(pluginId) || {
+            failures: 0,
+            lastFailure: 0,
+            isOpen: false,
+        };
+        breaker.failures++;
+        breaker.lastFailure = Date.now();
+        // Open circuit breaker after 5 failures
+        if (breaker.failures >= 5) {
+            breaker.isOpen = true;
+        }
+        this.circuitBreakers.set(pluginId, breaker);
+    }
+    resetCircuitBreaker(pluginId) {
+        this.circuitBreakers.delete(pluginId);
+    }
+    /**
+     * Setup registry event handlers
+     */
+    setupRegistryEventHandlers() {
+        this.registry.on(PluginTypes.PluginEventType.PLUGIN_UNREGISTERED, (event) => {
+            // Clean up plugin-specific data
+            this.circuitBreakers.delete(event.pluginId);
+            this.warmupCache.delete(event.pluginId);
+        });
+    }
+    /**
+     * Update performance metrics
+     */
+    updatePerformanceMetrics(type, executionTime, success) {
+        // Emit performance metrics for monitoring
+        this.emit("performance", {
+            type,
+            executionTime,
+            success,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Handle execution errors
+     */
+    handleExecutionError(type, executionId, error, executionTime) {
+        console.error(`Plugin execution error [${type}] [${executionId}]:`, error);
+        this.emit("error", {
+            type,
+            executionId,
+            error,
+            executionTime,
+            timestamp: Date.now(),
+        });
+    }
+    /**
+     * Emit plugin event
+     */
+    emitPluginEvent(type, pluginId, data) {
+        const event = {
+            type,
+            pluginId,
+            timestamp: new Date(),
+            data,
+        };
+        this.emit(type, event);
+    }
+    /**
+     * Get engine statistics (ultra-fast optimized)
+     */
+    getEngineStats() {
+        // Ultra-fast: Count open circuit breakers without creating arrays
+        let circuitBreakersOpen = 0;
+        this.circuitBreakers.forEach((breaker) => {
+            if (breaker.isOpen)
+                circuitBreakersOpen++;
+        });
+        return {
+            contextPoolSize: this.contextPool.length,
+            circuitBreakersOpen,
+            warmedUpPlugins: this.warmupCache.size,
+            activeExecutions: this.executionPool.size,
+        };
+    }
+}
+
+exports.PluginEngine = PluginEngine;
+//# sourceMappingURL=PluginEngine.js.map