agentic-flow 1.10.0 → 1.10.2

package/dist/utils/connection-pool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection-pool.js","sourceRoot":"","sources":["../../src/utils/connection-pool.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Connection Pool for HTTP/2 and HTTP/3 Proxies\n * Provides connection reuse to reduce latency by 20-30%\n */\n\nimport http2 from 'http2';\nimport { logger } from './logger.js';\n\nexport interface PoolConfig {\n  maxSize: number;\n  maxIdleTime: number;\n  acquireTimeout: number;\n}\n\ninterface PooledConnection {\n  session: http2.ClientHttp2Session;\n  host: string;\n  busy: boolean;\n  createdAt: number;\n  lastUsed: number;\n}\n\nexport class ConnectionPool {\n  private pools: Map<string, PooledConnection[]> = new Map();\n  private config: PoolConfig;\n  private cleanupInterval: NodeJS.Timeout;\n\n  constructor(config: Partial<PoolConfig> = {}) {\n    this.config = {\n      maxSize: config.maxSize || 10,\n      maxIdleTime: config.maxIdleTime || 60000, // 60 seconds\n      acquireTimeout: config.acquireTimeout || 5000 // 5 seconds\n    };\n\n    // Cleanup expired connections every 30 seconds\n    this.cleanupInterval = setInterval(() => {\n      this.cleanup();\n    }, 30000);\n  }\n\n  async acquire(host: string): Promise<http2.ClientHttp2Session> {\n    const pool = this.pools.get(host) || [];\n    const now = Date.now();\n\n    // Find idle, non-expired connection\n    const idle = pool.find(c =>\n      !c.busy &&\n      !this.isExpired(c, now) &&\n      !c.session.closed &&\n      !c.session.destroyed\n    );\n\n    if (idle) {\n      idle.busy = true;\n      idle.lastUsed = now;\n      logger.debug('Reusing pooled connection', { host, poolSize: pool.length });\n      return idle.session;\n    }\n\n    // Create new if under limit\n    if (pool.length < this.config.maxSize) {\n      const session = await this.createConnection(host);\n      const conn: PooledConnection = {\n        session,\n        host,\n        busy: true,\n        createdAt: now,\n        lastUsed: now\n      };\n\n      pool.push(conn);\n      this.pools.set(host, pool);\n\n      logger.debug('Created new pooled connection', {\n        host,\n        poolSize: pool.length,\n        maxSize: this.config.maxSize\n      });\n\n      return session;\n    }\n\n    // Wait for available connection\n    logger.debug('Pool full, waiting for connection', { host, poolSize: pool.length });\n    return this.waitForConnection(host);\n  }\n\n  async release(session: http2.ClientHttp2Session, host: string): Promise<void> {\n    const pool = this.pools.get(host);\n    if (!pool) return;\n\n    const conn = pool.find(c => c.session === session);\n    if (conn) {\n      conn.busy = false;\n      conn.lastUsed = Date.now();\n      logger.debug('Released pooled connection', { host });\n    }\n  }\n\n  private async createConnection(host: string): Promise<http2.ClientHttp2Session> {\n    return new Promise((resolve, reject) => {\n      const session = http2.connect(host, {\n        maxSessionMemory: 10 // 10MB per session\n      });\n\n      session.once('connect', () => {\n        logger.info('HTTP/2 session connected', { host });\n        resolve(session);\n      });\n\n      session.once('error', (error) => {\n        logger.error('HTTP/2 session error', { host, error: error.message });\n        reject(error);\n      });\n\n      // Cleanup on session close\n      session.once('close', () => {\n        this.removeConnection(session, host);\n      });\n    });\n  }\n\n  private async waitForConnection(host: string): Promise<http2.ClientHttp2Session> {\n    const startTime = Date.now();\n\n    return new Promise((resolve, reject) => {\n      const checkInterval = setInterval(() => {\n        const pool = this.pools.get(host);\n        if (!pool) {\n          clearInterval(checkInterval);\n          reject(new Error('Pool disappeared'));\n          return;\n        }\n\n        const now = Date.now();\n        const available = pool.find(c =>\n          !c.busy &&\n          !this.isExpired(c, now) &&\n          !c.session.closed\n        );\n\n        if (available) {\n          clearInterval(checkInterval);\n          available.busy = true;\n          available.lastUsed = now;\n          resolve(available.session);\n          return;\n        }\n\n        if (now - startTime > this.config.acquireTimeout) {\n          clearInterval(checkInterval);\n          reject(new Error('Connection acquire timeout'));\n        }\n      }, 100); // Check every 100ms\n    });\n  }\n\n  private isExpired(conn: PooledConnection, now: number): boolean {\n    return (now - conn.lastUsed) > this.config.maxIdleTime;\n  }\n\n  private removeConnection(session: http2.ClientHttp2Session, host: string): void {\n    const pool = this.pools.get(host);\n    if (!pool) return;\n\n    const index = pool.findIndex(c => c.session === session);\n    if (index !== -1) {\n      pool.splice(index, 1);\n      logger.debug('Removed closed connection from pool', { host, poolSize: pool.length });\n    }\n\n    if (pool.length === 0) {\n      this.pools.delete(host);\n    }\n  }\n\n  private cleanup(): void {\n    const now = Date.now();\n    let removed = 0;\n\n    for (const [host, pool] of this.pools.entries()) {\n      const before = pool.length;\n\n      // Remove expired and closed connections\n      const active = pool.filter(c => {\n        if (this.isExpired(c, now) || c.session.closed || c.session.destroyed) {\n          if (!c.session.closed) {\n            c.session.close();\n          }\n          return false;\n        }\n        return true;\n      });\n\n      removed += before - active.length;\n\n      if (active.length === 0) {\n        this.pools.delete(host);\n      } else {\n        this.pools.set(host, active);\n      }\n    }\n\n    if (removed > 0) {\n      logger.debug('Cleaned up expired connections', { removed });\n    }\n  }\n\n  destroy(): void {\n    clearInterval(this.cleanupInterval);\n\n    for (const [host, pool] of this.pools.entries()) {\n      for (const conn of pool) {\n        if (!conn.session.closed) {\n          conn.session.close();\n        }\n      }\n    }\n\n    this.pools.clear();\n    logger.info('Connection pool destroyed');\n  }\n\n  getStats(): Record<string, { total: number; busy: number; idle: number }> {\n    const stats: Record<string, { total: number; busy: number; idle: number }> = {};\n\n    for (const [host, pool] of this.pools.entries()) {\n      const busy = pool.filter(c => c.busy).length;\n      stats[host] = {\n        total: pool.length,\n        busy,\n        idle: pool.length - busy\n      };\n    }\n\n    return stats;\n  }\n}\n"]}

package/dist/utils/dynamic-compression.js

@@ -0,0 +1,298 @@
+/**
+ * Dynamic Compression based on CPU
+ * Adaptive compression levels based on CPU availability
+ * Phase 3 Optimization
+ */
+import * as zlib from 'zlib';
+import { performance } from 'perf_hooks';
+/**
+ * Compression levels with CPU costs
+ */
+export const COMPRESSION_LEVELS = {
+    gzip: [
+        { level: 1, name: 'fastest', cpuCost: 1, compressionRatio: 3 },
+        { level: 3, name: 'fast', cpuCost: 3, compressionRatio: 5 },
+        { level: 6, name: 'default', cpuCost: 6, compressionRatio: 7 },
+        { level: 9, name: 'best', cpuCost: 10, compressionRatio: 9 }
+    ],
+    brotli: [
+        { level: 1, name: 'fastest', cpuCost: 2, compressionRatio: 4 },
+        { level: 4, name: 'fast', cpuCost: 4, compressionRatio: 6 },
+        { level: 6, name: 'default', cpuCost: 7, compressionRatio: 8 },
+        { level: 11, name: 'best', cpuCost: 10, compressionRatio: 10 }
+    ]
+};
+/**
+ * Dynamic Compression Manager
+ * Adjusts compression levels based on CPU load
+ */
+export class DynamicCompressionManager {
+    config;
+    stats;
+    currentLevelIndex = 1; // Start with 'fast'
+    cpuSamples = [];
+    monitorInterval;
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            minSize: config.minSize || 1024,
+            algorithm: config.algorithm || 'gzip',
+            adaptive: config.adaptive !== false,
+            cpuThresholdHigh: config.cpuThresholdHigh || 70,
+            cpuThresholdLow: config.cpuThresholdLow || 30,
+            checkInterval: config.checkInterval || 5000
+        };
+        this.stats = {
+            totalBytes: 0,
+            compressedBytes: 0,
+            compressionRatio: 1,
+            avgCompressionTime: 0,
+            currentLevel: this.getCurrentLevel().level,
+            levelChanges: 0,
+            cpuAdjustments: 0
+        };
+        if (this.config.adaptive) {
+            this.startCPUMonitoring();
+        }
+    }
+    /**
+     * Compress data with adaptive level
+     */
+    async compress(data) {
+        if (!this.config.enabled || data.length < this.config.minSize) {
+            return data;
+        }
+        const startTime = performance.now();
+        const level = this.getCurrentLevel();
+        let compressed;
+        try {
+            if (this.config.algorithm === 'brotli') {
+                compressed = await this.compressBrotli(data, level.level);
+            }
+            else if (this.config.algorithm === 'deflate') {
+                compressed = await this.compressDeflate(data, level.level);
+            }
+            else {
+                compressed = await this.compressGzip(data, level.level);
+            }
+            // Update statistics
+            const compressionTime = performance.now() - startTime;
+            this.updateStats(data.length, compressed.length, compressionTime);
+            return compressed;
+        }
+        catch (error) {
+            // Fallback to uncompressed
+            return data;
+        }
+    }
+    /**
+     * Compress with gzip
+     */
+    compressGzip(data, level) {
+        return new Promise((resolve, reject) => {
+            zlib.gzip(data, { level }, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    /**
+     * Compress with brotli
+     */
+    compressBrotli(data, level) {
+        return new Promise((resolve, reject) => {
+            zlib.brotliCompress(data, {
+                params: {
+                    [zlib.constants.BROTLI_PARAM_QUALITY]: level
+                }
+            }, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    /**
+     * Compress with deflate
+     */
+    compressDeflate(data, level) {
+        return new Promise((resolve, reject) => {
+            zlib.deflate(data, { level }, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(result);
+            });
+        });
+    }
+    /**
+     * Get current compression level
+     */
+    getCurrentLevel() {
+        const levels = COMPRESSION_LEVELS[this.config.algorithm];
+        return levels[this.currentLevelIndex] || levels[1];
+    }
+    /**
+     * Adjust compression level based on CPU
+     */
+    adjustLevel(cpuUsage) {
+        const levels = COMPRESSION_LEVELS[this.config.algorithm];
+        const oldIndex = this.currentLevelIndex;
+        if (cpuUsage > this.config.cpuThresholdHigh && this.currentLevelIndex > 0) {
+            // CPU high, reduce compression level
+            this.currentLevelIndex--;
+            this.stats.cpuAdjustments++;
+        }
+        else if (cpuUsage < this.config.cpuThresholdLow && this.currentLevelIndex < levels.length - 1) {
+            // CPU low, increase compression level
+            this.currentLevelIndex++;
+            this.stats.cpuAdjustments++;
+        }
+        if (oldIndex !== this.currentLevelIndex) {
+            this.stats.levelChanges++;
+            this.stats.currentLevel = this.getCurrentLevel().level;
+        }
+    }
+    /**
+     * Start CPU monitoring
+     */
+    startCPUMonitoring() {
+        this.monitorInterval = setInterval(() => {
+            const cpuUsage = this.getCPUUsage();
+            this.cpuSamples.push(cpuUsage);
+            // Keep last 10 samples
+            if (this.cpuSamples.length > 10) {
+                this.cpuSamples.shift();
+            }
+            // Calculate average CPU
+            const avgCPU = this.cpuSamples.reduce((a, b) => a + b, 0) / this.cpuSamples.length;
+            // Adjust compression level
+            this.adjustLevel(avgCPU);
+        }, this.config.checkInterval);
+    }
+    /**
+     * Get CPU usage percentage
+     */
+    getCPUUsage() {
+        const cpus = require('os').cpus();
+        let totalIdle = 0;
+        let totalTick = 0;
+        for (const cpu of cpus) {
+            for (const type in cpu.times) {
+                totalTick += cpu.times[type];
+            }
+            totalIdle += cpu.times.idle;
+        }
+        const idle = totalIdle / cpus.length;
+        const total = totalTick / cpus.length;
+        const usage = 100 - ~~(100 * idle / total);
+        return Math.max(0, Math.min(100, usage));
+    }
+    /**
+     * Update statistics
+     */
+    updateStats(originalSize, compressedSize, time) {
+        this.stats.totalBytes += originalSize;
+        this.stats.compressedBytes += compressedSize;
+        this.stats.compressionRatio = this.stats.totalBytes / this.stats.compressedBytes;
+        // Update average compression time
+        const totalCompressions = this.stats.totalBytes / (originalSize || 1);
+        this.stats.avgCompressionTime =
+            (this.stats.avgCompressionTime * (totalCompressions - 1) + time) / totalCompressions;
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const level = this.getCurrentLevel();
+        const avgCPU = this.cpuSamples.length > 0
+            ? this.cpuSamples.reduce((a, b) => a + b, 0) / this.cpuSamples.length
+            : 0;
+        return {
+            ...this.stats,
+            currentLevelName: level.name,
+            cpuUsage: avgCPU
+        };
+    }
+    /**
+     * Get compression savings
+     */
+    getSavings() {
+        const byteSavings = this.stats.totalBytes - this.stats.compressedBytes;
+        const percentSavings = (byteSavings / this.stats.totalBytes) * 100;
+        const mbSaved = byteSavings / (1024 * 1024);
+        return {
+            byteSavings,
+            percentSavings,
+            mbSaved
+        };
+    }
+    /**
+     * Manually set compression level
+     */
+    setLevel(levelName) {
+        const levels = COMPRESSION_LEVELS[this.config.algorithm];
+        const index = levels.findIndex(l => l.name === levelName);
+        if (index !== -1) {
+            this.currentLevelIndex = index;
+            this.stats.currentLevel = levels[index].level;
+            this.stats.levelChanges++;
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Reset statistics
+     */
+    resetStats() {
+        this.stats = {
+            totalBytes: 0,
+            compressedBytes: 0,
+            compressionRatio: 1,
+            avgCompressionTime: 0,
+            currentLevel: this.getCurrentLevel().level,
+            levelChanges: 0,
+            cpuAdjustments: 0
+        };
+    }
+    /**
+     * Stop CPU monitoring
+     */
+    destroy() {
+        if (this.monitorInterval) {
+            clearInterval(this.monitorInterval);
+        }
+    }
+}
+/**
+ * Content-type aware compression
+ */
+export function shouldCompress(contentType, size, minSize = 1024) {
+    if (size < minSize) {
+        return false;
+    }
+    const compressibleTypes = [
+        'text/',
+        'application/json',
+        'application/javascript',
+        'application/xml',
+        'application/x-www-form-urlencoded'
+    ];
+    return compressibleTypes.some(type => contentType.startsWith(type));
+}
+/**
+ * Calculate compression efficiency
+ */
+export function calculateCompressionEfficiency(stats) {
+    const timePerMB = stats.avgCompressionTime / ((stats.totalBytes / (1024 * 1024)) || 1);
+    const ratioScore = Math.min(100, (stats.compressionRatio - 1) * 10);
+    const efficiency = (ratioScore * 0.7) + ((100 - Math.min(100, timePerMB)) * 0.3);
+    return {
+        efficiency,
+        timePerMB,
+        ratioScore
+    };
+}

package/dist/utils/http2-multiplexing.js

@@ -0,0 +1,319 @@
+/**
+ * HTTP/2 Multiplexing Optimization
+ * Stream prioritization and flow control for concurrent request optimization
+ * Phase 2 Optimization
+ */
+/**
+ * HTTP/2 Multiplexing Manager
+ * Manages stream prioritization and concurrent request handling
+ */
+export class HTTP2MultiplexingManager {
+    config;
+    activeStreams = new Map();
+    priorityQueues = new Map();
+    stats;
+    constructor(config) {
+        this.config = {
+            enabled: config.enabled,
+            maxConcurrentStreams: config.maxConcurrentStreams || 100,
+            defaultPriority: config.defaultPriority || 16,
+            enableFlowControl: config.enableFlowControl !== false,
+            initialWindowSize: config.initialWindowSize || 65535
+        };
+        this.stats = {
+            totalStreams: 0,
+            activeStreams: 0,
+            completedStreams: 0,
+            averageDuration: 0,
+            priorityChanges: 0
+        };
+        this.initializePriorityQueues();
+    }
+    /**
+     * Initialize priority queues (1-256)
+     */
+    initializePriorityQueues() {
+        for (let i = 1; i <= 256; i++) {
+            this.priorityQueues.set(i, new Set());
+        }
+    }
+    /**
+     * Register a new stream
+     */
+    registerStream(stream, priority) {
+        if (!this.config.enabled)
+            return;
+        const streamId = stream.id || 0;
+        const streamPriority = priority?.weight || this.config.defaultPriority;
+        const info = {
+            stream,
+            priority: streamPriority,
+            bytesReceived: 0,
+            bytesSent: 0,
+            startTime: Date.now(),
+            state: 'open'
+        };
+        this.activeStreams.set(streamId, info);
+        this.priorityQueues.get(streamPriority)?.add(streamId);
+        this.stats.totalStreams++;
+        this.stats.activeStreams++;
+        // Set stream priority
+        if (priority) {
+            this.setPriority(stream, priority);
+        }
+        // Setup event handlers
+        this.setupStreamHandlers(stream, streamId);
+    }
+    /**
+     * Set stream priority
+     */
+    setPriority(stream, priority) {
+        try {
+            stream.priority(priority);
+            const streamId = stream.id || 0;
+            const info = this.activeStreams.get(streamId);
+            if (info) {
+                // Move to new priority queue
+                const oldPriority = info.priority;
+                const newPriority = priority.weight;
+                this.priorityQueues.get(oldPriority)?.delete(streamId);
+                info.priority = newPriority;
+                this.priorityQueues.get(newPriority)?.add(streamId);
+                this.stats.priorityChanges++;
+            }
+        }
+        catch (error) {
+            // Stream may be closed
+        }
+    }
+    /**
+     * Adjust stream priority based on load
+     */
+    adjustPriority(streamId, adjustment) {
+        const info = this.activeStreams.get(streamId);
+        if (!info)
+            return;
+        const newPriority = Math.max(1, Math.min(256, info.priority + adjustment));
+        this.setPriority(info.stream, {
+            weight: newPriority,
+            exclusive: false
+        });
+    }
+    /**
+     * Get next stream to process based on priority
+     */
+    getNextStream() {
+        // Process highest priority streams first (256 is highest)
+        for (let priority = 256; priority >= 1; priority--) {
+            const queue = this.priorityQueues.get(priority);
+            if (queue && queue.size > 0) {
+                const streamId = queue.values().next().value;
+                if (streamId !== undefined) {
+                    const info = this.activeStreams.get(streamId);
+                    if (info && info.state === 'open') {
+                        return info.stream;
+                    }
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Setup stream event handlers
+     */
+    setupStreamHandlers(stream, streamId) {
+        stream.on('data', (chunk) => {
+            const info = this.activeStreams.get(streamId);
+            if (info) {
+                info.bytesReceived += chunk.length;
+            }
+        });
+        stream.on('end', () => {
+            this.updateStreamState(streamId, 'half-closed');
+        });
+        stream.on('close', () => {
+            this.handleStreamClose(streamId);
+        });
+        stream.on('error', () => {
+            this.handleStreamClose(streamId);
+        });
+    }
+    /**
+     * Update stream state
+     */
+    updateStreamState(streamId, state) {
+        const info = this.activeStreams.get(streamId);
+        if (info) {
+            info.state = state;
+        }
+    }
+    /**
+     * Handle stream closure
+     */
+    handleStreamClose(streamId) {
+        const info = this.activeStreams.get(streamId);
+        if (!info)
+            return;
+        // Remove from priority queue
+        this.priorityQueues.get(info.priority)?.delete(streamId);
+        // Update statistics
+        const duration = Date.now() - info.startTime;
+        this.updateStats(duration);
+        // Remove from active streams
+        this.activeStreams.delete(streamId);
+        this.stats.activeStreams--;
+        this.stats.completedStreams++;
+    }
+    /**
+     * Update statistics
+     */
+    updateStats(duration) {
+        const currentAvg = this.stats.averageDuration;
+        const total = this.stats.completedStreams;
+        this.stats.averageDuration = (currentAvg * (total - 1) + duration) / total;
+    }
+    /**
+     * Get stream statistics
+     */
+    getStreamStats(streamId) {
+        const info = this.activeStreams.get(streamId);
+        if (!info)
+            return null;
+        return {
+            streamId,
+            priority: info.priority,
+            bytesReceived: info.bytesReceived,
+            bytesSent: info.bytesSent,
+            duration: Date.now() - info.startTime,
+            state: info.state
+        };
+    }
+    /**
+     * Get all statistics
+     */
+    getStats() {
+        const priorityDistribution = new Map();
+        for (const [priority, queue] of this.priorityQueues) {
+            if (queue.size > 0) {
+                priorityDistribution.set(priority, queue.size);
+            }
+        }
+        return {
+            ...this.stats,
+            priorityDistribution
+        };
+    }
+    /**
+     * Check if can accept more streams
+     */
+    canAcceptStream() {
+        return this.stats.activeStreams < this.config.maxConcurrentStreams;
+    }
+    /**
+     * Get load percentage
+     */
+    getLoad() {
+        return (this.stats.activeStreams / this.config.maxConcurrentStreams) * 100;
+    }
+}
+/**
+ * Flow Control Manager
+ * Manages HTTP/2 flow control for optimal throughput
+ */
+export class FlowControlManager {
+    windowSizes = new Map();
+    config;
+    constructor(config) {
+        this.config = {
+            initialWindowSize: config?.initialWindowSize || 65535,
+            maxWindowSize: config?.maxWindowSize || 16777215, // 16MB
+            minWindowSize: config?.minWindowSize || 16384 // 16KB
+        };
+    }
+    /**
+     * Initialize window size for a stream
+     */
+    initializeWindow(streamId) {
+        this.windowSizes.set(streamId, this.config.initialWindowSize);
+    }
+    /**
+     * Update window size
+     */
+    updateWindow(streamId, delta) {
+        const current = this.windowSizes.get(streamId) || this.config.initialWindowSize;
+        const newSize = Math.max(this.config.minWindowSize, Math.min(this.config.maxWindowSize, current + delta));
+        this.windowSizes.set(streamId, newSize);
+        return newSize;
+    }
+    /**
+     * Get current window size
+     */
+    getWindowSize(streamId) {
+        return this.windowSizes.get(streamId) || this.config.initialWindowSize;
+    }
+    /**
+     * Calculate optimal window size based on throughput
+     */
+    calculateOptimalWindow(throughputBps, rttMs) {
+        // Bandwidth-Delay Product
+        const bdp = (throughputBps / 8) * (rttMs / 1000);
+        return Math.max(this.config.minWindowSize, Math.min(this.config.maxWindowSize, Math.ceil(bdp * 2)));
+    }
+    /**
+     * Clean up closed stream
+     */
+    cleanup(streamId) {
+        this.windowSizes.delete(streamId);
+    }
+}
+/**
+ * Priority scheduler for optimal stream processing
+ */
+export class PriorityScheduler {
+    queues = new Map();
+    /**
+     * Add stream to priority queue
+     */
+    enqueue(streamId, priority) {
+        if (!this.queues.has(priority)) {
+            this.queues.set(priority, []);
+        }
+        this.queues.get(priority).push(streamId);
+    }
+    /**
+     * Get next stream to process
+     */
+    dequeue() {
+        // Process highest priority first
+        for (let priority = 256; priority >= 1; priority--) {
+            const queue = this.queues.get(priority);
+            if (queue && queue.length > 0) {
+                return queue.shift();
+            }
+        }
+        return null;
+    }
+    /**
+     * Remove stream from all queues
+     */
+    remove(streamId) {
+        for (const queue of this.queues.values()) {
+            const index = queue.indexOf(streamId);
+            if (index !== -1) {
+                queue.splice(index, 1);
+            }
+        }
+    }
+    /**
+     * Get queue sizes
+     */
+    getStats() {
+        const stats = new Map();
+        for (const [priority, queue] of this.queues) {
+            if (queue.length > 0) {
+                stats.set(priority, queue.length);
+            }
+        }
+        return stats;
+    }
+}