xypriss 1.1.0 → 1.1.2

package/dist/cjs/mods/toolkit/src/utils/memory/memory-manager.js

@@ -1,888 +0,0 @@
-'use strict';
-
-var global$1 = require('../../types/global.js');
-var types = require('./types.js');
-var eventManager = require('./event-manager.js');
-var configManager = require('./config-manager.js');
-var referenceTracker = require('./reference-tracker.js');
-var memoryPool = require('./memory-pool.js');
-
-/***************************************************************************
- * XyPrissSecurity - Secure Array Types
- *
- * This file contains type definitions for the SecureArray modular architecture
- *
- * @author Nehonix
- *
- * @license MIT
- *
- * Copyright (c) 2025 Nehonix. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- ***************************************************************************** */
-// Initialize polyfills for WeakRef and FinalizationRegistry
-global$1.initializePolyfills();
-/**
- * Advanced Memory Manager
- *
- * Main orchestrator for the memory management system with all components
- */
-class AdvancedMemoryManager {
-    constructor(config = {}) {
-        this.pools = new Map();
-        // Object collection tracking
-        this.objectTracker = new Map();
-        this.collectionHistory = [];
-        // Initialize state
-        this.state = {
-            isRunning: false,
-            lastGC: Date.now(),
-            nextScheduledGC: 0,
-            activeMonitors: 0,
-            errorCount: 0,
-            uptime: Date.now(),
-        };
-        // Initialize stats
-        this.stats = {
-            totalAllocated: 0,
-            totalFreed: 0,
-            currentUsage: 0,
-            peakUsage: 0,
-            gcCount: 0,
-            leakCount: 0,
-            pressure: 0,
-            poolStats: [],
-            trackedObjects: 0,
-            lastGC: Date.now(),
-            averageGCTime: 0,
-        };
-        // Initialize performance metrics
-        this.performanceMetrics = {
-            averageGCTime: 0,
-            gcFrequency: 0,
-            memoryEfficiency: 0,
-            poolHitRates: {},
-            leakDetectionAccuracy: 0,
-            systemLoad: 0,
-        };
-        // Initialize components in order
-        this.eventManager = new eventManager.MemoryEventManager(this.getDefaultConfig());
-        this.configManager = new configManager.ConfigurationManager(config, this.eventManager);
-        this.referenceTracker = new referenceTracker.AdvancedReferenceTracker(this.eventManager, this.configManager.getConfig());
-        // Initialize object collection tracking
-        this.initializeObjectTracking();
-        // Start the memory manager
-        this.start();
-    }
-    /**
-     * Get singleton instance
-     */
-    static getInstance(config) {
-        if (!AdvancedMemoryManager.instance) {
-            AdvancedMemoryManager.instance = new AdvancedMemoryManager(config);
-        }
-        return AdvancedMemoryManager.instance;
-    }
-    /**
-     * Get default configuration
-     */
-    getDefaultConfig() {
-        return {
-            maxMemory: 100 * 1024 * 1024, // 100MB
-            gcThreshold: 0.8,
-            gcInterval: 30000, // 30 seconds
-            enableLeakDetection: true,
-            enablePerformanceMonitoring: true,
-            enableEventLogging: false,
-            autoCleanupInterval: 60000, // 1 minute
-            maxPoolAge: 300000, // 5 minutes
-            leakDetectionThreshold: 300000, // 5 minutes
-            maxEventHistory: 1000,
-        };
-    }
-    /**
-     * Start the memory manager
-     */
-    start() {
-        if (this.state.isRunning) {
-            return;
-        }
-        this.state.isRunning = true;
-        this.state.uptime = Date.now();
-        const config = this.configManager.getConfig();
-        // Start garbage collection monitoring
-        this.startGCMonitoring();
-        // Start performance monitoring if enabled
-        if (config.enablePerformanceMonitoring) {
-            this.startPerformanceMonitoring();
-        }
-        // Start cleanup monitoring
-        this.startCleanupMonitoring();
-        this.eventManager.emit(types.MemoryEventType.CONFIG_UPDATED, {
-            action: "started",
-            config: config,
-        });
-    }
-    /**
-     * Start garbage collection monitoring
-     */
-    startGCMonitoring() {
-        const config = this.configManager.getConfig();
-        if (this.gcInterval) {
-            clearInterval(this.gcInterval);
-        }
-        this.gcInterval = setInterval(() => {
-            this.checkMemoryPressure();
-        }, config.gcInterval);
-        this.state.nextScheduledGC = Date.now() + config.gcInterval;
-    }
-    /**
-     * Start performance monitoring
-     */
-    startPerformanceMonitoring() {
-        if (this.monitoringInterval) {
-            clearInterval(this.monitoringInterval);
-        }
-        this.monitoringInterval = setInterval(() => {
-            this.updatePerformanceMetrics();
-            this.updateMemoryStats();
-        }, 5000); // Update every 5 seconds
-        this.state.activeMonitors++;
-    }
-    /**
-     * Start cleanup monitoring
-     */
-    startCleanupMonitoring() {
-        const config = this.configManager.getConfig();
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-        }
-        this.cleanupInterval = setInterval(() => {
-            this.performCleanup();
-        }, config.autoCleanupInterval);
-        this.state.activeMonitors++;
-    }
-    /**
-     * Check memory pressure and trigger GC if needed
-     */
-    checkMemoryPressure() {
-        try {
-            const usage = this.getCurrentMemoryUsage();
-            const config = this.configManager.getConfig();
-            this.stats.currentUsage = usage.estimatedSize;
-            this.stats.pressure = usage.estimatedSize / config.maxMemory;
-            const pressureInfo = this.getMemoryPressureInfo();
-            if (pressureInfo.shouldTriggerGC) {
-                this.triggerGarbageCollection();
-            }
-            // Emit memory pressure event if significant
-            if (pressureInfo.level !== types.MemoryPressureLevel.LOW) {
-                this.eventManager.emit(types.MemoryEventType.MEMORY_PRESSURE, pressureInfo);
-            }
-        }
-        catch (error) {
-            this.handleError("checkMemoryPressure", error);
-        }
-    }
-    /**
-     * Get current memory usage estimation
-     */
-    getCurrentMemoryUsage() {
-        // Try Node.js process.memoryUsage first
-        if (typeof process !== "undefined" && process.memoryUsage) {
-            const usage = process.memoryUsage();
-            return {
-                estimatedSize: usage.heapUsed,
-                confidence: 0.95,
-                method: "node",
-                breakdown: {
-                    heap: usage.heapUsed,
-                    external: usage.external,
-                },
-            };
-        }
-        // Browser fallback - estimate based on tracked objects
-        const trackerStats = this.referenceTracker.getStats();
-        return {
-            estimatedSize: trackerStats.totalEstimatedSize || 0,
-            confidence: 0.6,
-            method: "browser",
-            breakdown: {
-                tracked: trackerStats.totalEstimatedSize || 0,
-            },
-        };
-    }
-    /**
-     * Get memory pressure information
-     */
-    getMemoryPressureInfo() {
-        const config = this.configManager.getConfig();
-        const pressure = this.stats.pressure;
-        let level;
-        let recommendation;
-        let shouldTriggerGC;
-        if (pressure < 0.5) {
-            level = types.MemoryPressureLevel.LOW;
-            recommendation = "Memory usage is optimal";
-            shouldTriggerGC = false;
-        }
-        else if (pressure < config.gcThreshold) {
-            level = types.MemoryPressureLevel.MEDIUM;
-            recommendation = "Monitor memory usage";
-            shouldTriggerGC = false;
-        }
-        else if (pressure < 0.95) {
-            level = types.MemoryPressureLevel.HIGH;
-            recommendation = "Consider triggering garbage collection";
-            shouldTriggerGC = true;
-        }
-        else {
-            level = types.MemoryPressureLevel.CRITICAL;
-            recommendation = "Immediate garbage collection required";
-            shouldTriggerGC = true;
-        }
-        // Also check time since last GC
-        const timeSinceLastGC = Date.now() - this.state.lastGC;
-        if (timeSinceLastGC >= config.gcInterval) {
-            shouldTriggerGC = true;
-        }
-        return {
-            level,
-            pressure,
-            recommendation,
-            shouldTriggerGC,
-        };
-    }
-    /**
-     * Trigger garbage collection
-     */
-    triggerGarbageCollection() {
-        const startTime = Date.now();
-        const beforeUsage = this.stats.currentUsage;
-        this.eventManager.emit(types.MemoryEventType.GC_TRIGGERED, {
-            beforeUsage,
-            pressure: this.stats.pressure,
-            trigger: "automatic",
-        });
-        try {
-            // Clean up dead references
-            this.referenceTracker.cleanup();
-            // Clean up memory pools
-            let poolsCleanedUp = 0;
-            for (const pool of this.pools.values()) {
-                // Remove old items from pools
-                const sizeBefore = pool.size;
-                // Pool cleanup is handled internally
-                if (pool.size < sizeBefore) {
-                    poolsCleanedUp++;
-                }
-            }
-            // Force GC if available (Node.js)
-            if (typeof global !== "undefined" && global.gc) {
-                global.gc();
-            }
-            // Update stats
-            const afterUsage = this.getCurrentMemoryUsage().estimatedSize;
-            const duration = Date.now() - startTime;
-            const freedMemory = Math.max(0, beforeUsage - afterUsage);
-            this.stats.totalFreed += freedMemory;
-            this.stats.gcCount++;
-            this.stats.lastGC = Date.now();
-            this.state.lastGC = Date.now();
-            // Update average GC time
-            this.stats.averageGCTime =
-                (this.stats.averageGCTime * (this.stats.gcCount - 1) +
-                    duration) /
-                    this.stats.gcCount;
-            // Perform sophisticated object collection tracking
-            const objectsCollected = this.trackObjectCollection(beforeUsage, afterUsage);
-            const result = {
-                beforeUsage,
-                afterUsage,
-                freedMemory,
-                duration,
-                objectsCollected,
-                poolsCleanedUp,
-                success: true,
-            };
-            this.eventManager.emit(types.MemoryEventType.GC_COMPLETED, result);
-            return result;
-        }
-        catch (error) {
-            const result = {
-                beforeUsage,
-                afterUsage: beforeUsage,
-                freedMemory: 0,
-                duration: Date.now() - startTime,
-                objectsCollected: 0,
-                poolsCleanedUp: 0,
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-            this.handleError("triggerGarbageCollection", error);
-            return result;
-        }
-    }
-    /**
-     * Perform routine cleanup
-     */
-    performCleanup() {
-        try {
-            // Clean up reference tracker
-            this.referenceTracker.cleanup();
-            // Detect memory leaks if enabled
-            const config = this.configManager.getConfig();
-            if (config.enableLeakDetection) {
-                const leaks = this.referenceTracker.detectLeaks();
-                this.stats.leakCount = leaks.length;
-            }
-            // Update tracked objects count
-            this.stats.trackedObjects =
-                this.referenceTracker.getTrackedObjects().length;
-        }
-        catch (error) {
-            this.handleError("performCleanup", error);
-        }
-    }
-    /**
-     * Update performance metrics
-     */
-    updatePerformanceMetrics() {
-        try {
-            // Update pool hit rates
-            const poolHitRates = {};
-            for (const [name, pool] of this.pools.entries()) {
-                const stats = pool.getStats();
-                poolHitRates[name] = stats.hitRate;
-            }
-            this.performanceMetrics.poolHitRates = poolHitRates;
-            // Calculate GC frequency (GCs per hour)
-            const uptime = Date.now() - this.state.uptime;
-            this.performanceMetrics.gcFrequency =
-                (this.stats.gcCount / uptime) * 3600000;
-            // Calculate memory efficiency
-            const config = this.configManager.getConfig();
-            this.performanceMetrics.memoryEfficiency =
-                1 - this.stats.currentUsage / config.maxMemory;
-            // Update average GC time
-            this.performanceMetrics.averageGCTime = this.stats.averageGCTime;
-        }
-        catch (error) {
-            this.handleError("updatePerformanceMetrics", error);
-        }
-    }
-    /**
-     * Update memory statistics
-     */
-    updateMemoryStats() {
-        try {
-            const usage = this.getCurrentMemoryUsage();
-            this.stats.currentUsage = usage.estimatedSize;
-            this.stats.peakUsage = Math.max(this.stats.peakUsage, usage.estimatedSize);
-            const config = this.configManager.getConfig();
-            this.stats.pressure = usage.estimatedSize / config.maxMemory;
-            // Update pool stats
-            this.stats.poolStats = Array.from(this.pools.values()).map((pool) => pool.getStats());
-        }
-        catch (error) {
-            this.handleError("updateMemoryStats", error);
-        }
-    }
-    /**
-     * Handle errors with proper logging and recovery
-     */
-    handleError(operation, error) {
-        this.state.errorCount++;
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`Memory Manager Error in ${operation}:`, errorMessage);
-        this.eventManager.emit(types.MemoryEventType.ERROR_OCCURRED, {
-            operation,
-            error: errorMessage,
-            timestamp: Date.now(),
-            errorCount: this.state.errorCount,
-        });
-    }
-    // Public API methods
-    /**
-     * Register an object for memory tracking
-     */
-    registerObject(obj, id) {
-        try {
-            this.referenceTracker.addReference(obj, id);
-            this.stats.totalAllocated += this.estimateObjectSize(obj);
-        }
-        catch (error) {
-            this.handleError("registerObject", error);
-        }
-    }
-    /**
-     * Unregister an object from memory tracking
-     */
-    unregisterObject(id) {
-        try {
-            this.referenceTracker.removeReference(id);
-            this.stats.trackedObjects = Math.max(0, this.stats.trackedObjects - 1);
-        }
-        catch (error) {
-            this.handleError("unregisterObject", error);
-        }
-    }
-    /**
-     * Add reference to an object
-     */
-    addReference(id) {
-        try {
-            this.referenceTracker.addReference({}, id); // This needs to be fixed in the interface
-        }
-        catch (error) {
-            this.handleError("addReference", error);
-        }
-    }
-    /**
-     * Remove reference from an object
-     */
-    removeReference(id) {
-        try {
-            this.referenceTracker.removeReference(id);
-        }
-        catch (error) {
-            this.handleError("removeReference", error);
-        }
-    }
-    /**
-     * Create a memory pool for object reuse
-     */
-    createPool(config) {
-        try {
-            if (this.pools.has(config.name)) {
-                throw new Error(`Pool with name '${config.name}' already exists`);
-            }
-            const pool = new memoryPool.AdvancedMemoryPool(config, this.eventManager);
-            this.pools.set(config.name, pool);
-            return pool;
-        }
-        catch (error) {
-            this.handleError("createPool", error);
-            throw error;
-        }
-    }
-    /**
-     * Get memory pool by name
-     */
-    getPool(name) {
-        return this.pools.get(name);
-    }
-    /**
-     * Remove a memory pool
-     */
-    removePool(name) {
-        const pool = this.pools.get(name);
-        if (pool && "destroy" in pool && typeof pool.destroy === "function") {
-            pool.destroy();
-        }
-        return this.pools.delete(name);
-    }
-    /**
-     * Get current memory statistics
-     */
-    getStats() {
-        this.updateMemoryStats();
-        return { ...this.stats };
-    }
-    /**
-     * Get performance metrics
-     */
-    getPerformanceMetrics() {
-        this.updatePerformanceMetrics();
-        return { ...this.performanceMetrics };
-    }
-    /**
-     * Get memory manager state
-     */
-    getState() {
-        return { ...this.state };
-    }
-    /**
-     * Set memory limits
-     */
-    setLimits(maxMemory, gcThreshold = 0.8) {
-        try {
-            this.configManager.updateConfig({ maxMemory, gcThreshold });
-            // Restart monitoring with new configuration
-            this.startGCMonitoring();
-        }
-        catch (error) {
-            this.handleError("setLimits", error);
-            throw error;
-        }
-    }
-    /**
-     * Force garbage collection
-     */
-    forceGC() {
-        this.eventManager.emit(types.MemoryEventType.GC_TRIGGERED, {
-            trigger: "manual",
-            timestamp: Date.now(),
-        });
-        return this.triggerGarbageCollection();
-    }
-    /**
-     * Estimate object size in bytes
-     */
-    estimateObjectSize(obj) {
-        if (obj === null || obj === undefined)
-            return 0;
-        const type = typeof obj;
-        switch (type) {
-            case "boolean":
-                return 4;
-            case "number":
-                return 8;
-            case "string":
-                return obj.length * 2; // UTF-16
-            case "object":
-                if (obj instanceof ArrayBuffer)
-                    return obj.byteLength;
-                if (obj instanceof Uint8Array)
-                    return obj.byteLength;
-                if (Array.isArray(obj)) {
-                    return obj.reduce((sum, item) => sum + this.estimateObjectSize(item), 0);
-                }
-                return Object.keys(obj).length * 64; // Rough estimate
-            default:
-                return 64; // Default estimate
-        }
-    }
-    /**
-     * Get memory usage report
-     */
-    getMemoryReport() {
-        const stats = this.getStats();
-        const state = this.getState();
-        const config = this.configManager.getConfig();
-        return `
-Memory Manager Report:
-=====================
-Current Usage: ${this.formatBytes(stats.currentUsage)}
-Peak Usage: ${this.formatBytes(stats.peakUsage)}
-Total Allocated: ${this.formatBytes(stats.totalAllocated)}
-Total Freed: ${this.formatBytes(stats.totalFreed)}
-Memory Pressure: ${(stats.pressure * 100).toFixed(1)}%
-GC Count: ${stats.gcCount}
-Average GC Time: ${stats.averageGCTime.toFixed(2)}ms
-Tracked Objects: ${stats.trackedObjects}
-Memory Pools: ${this.pools.size}
-Leak Count: ${stats.leakCount}
-
-Configuration:
-- Max Memory: ${this.formatBytes(config.maxMemory)}
-- GC Threshold: ${(config.gcThreshold * 100).toFixed(1)}%
-- GC Interval: ${(config.gcInterval / 1000).toFixed(1)}s
-- Leak Detection: ${config.enableLeakDetection ? "Enabled" : "Disabled"}
-- Performance Monitoring: ${config.enablePerformanceMonitoring ? "Enabled" : "Disabled"}
-
-State:
-- Running: ${state.isRunning}
-- Uptime: ${this.formatDuration(Date.now() - state.uptime)}
-- Active Monitors: ${state.activeMonitors}
-- Error Count: ${state.errorCount}
-        `.trim();
-    }
-    /**
-     * Format bytes for human-readable output
-     */
-    formatBytes(bytes) {
-        const units = ["B", "KB", "MB", "GB"];
-        let size = bytes;
-        let unitIndex = 0;
-        while (size >= 1024 && unitIndex < units.length - 1) {
-            size /= 1024;
-            unitIndex++;
-        }
-        return `${size.toFixed(2)} ${units[unitIndex]}`;
-    }
-    /**
-     * Format duration for human-readable output
-     */
-    formatDuration(ms) {
-        const seconds = Math.floor(ms / 1000);
-        const minutes = Math.floor(seconds / 60);
-        const hours = Math.floor(minutes / 60);
-        const days = Math.floor(hours / 24);
-        if (days > 0)
-            return `${days}d ${hours % 24}h ${minutes % 60}m`;
-        if (hours > 0)
-            return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
-        if (minutes > 0)
-            return `${minutes}m ${seconds % 60}s`;
-        return `${seconds}s`;
-    }
-    /**
-     * Update configuration
-     */
-    updateConfig(updates) {
-        try {
-            this.configManager.updateConfig(updates);
-            // Update components with new configuration
-            const newConfig = this.configManager.getConfig();
-            this.referenceTracker.updateConfig(newConfig);
-            this.eventManager.updateConfig(newConfig);
-            // Restart monitoring if intervals changed
-            if (updates.gcInterval !== undefined) {
-                this.startGCMonitoring();
-            }
-            if (updates.autoCleanupInterval !== undefined) {
-                this.startCleanupMonitoring();
-            }
-        }
-        catch (error) {
-            this.handleError("updateConfig", error);
-            throw error;
-        }
-    }
-    /**
-     * Get configuration
-     */
-    getConfig() {
-        return this.configManager.getConfig();
-    }
-    /**
-     * Add event listener
-     */
-    on(type, listener) {
-        this.eventManager.on(type, listener);
-    }
-    /**
-     * Remove event listener
-     */
-    off(type, listener) {
-        this.eventManager.off(type, listener);
-    }
-    /**
-     * Stop the memory manager
-     */
-    stop() {
-        if (!this.state.isRunning) {
-            return;
-        }
-        this.state.isRunning = false;
-        // Clear all intervals
-        if (this.gcInterval) {
-            clearInterval(this.gcInterval);
-            this.gcInterval = undefined;
-        }
-        if (this.monitoringInterval) {
-            clearInterval(this.monitoringInterval);
-            this.monitoringInterval = undefined;
-        }
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-            this.cleanupInterval = undefined;
-        }
-        this.state.activeMonitors = 0;
-        this.eventManager.emit(types.MemoryEventType.CONFIG_UPDATED, {
-            action: "stopped",
-            timestamp: Date.now(),
-        });
-    }
-    /**
-     * Restart the memory manager
-     */
-    restart() {
-        this.stop();
-        this.start();
-    }
-    /**
-     * Destroy the memory manager and clean up all resources
-     */
-    destroy() {
-        this.stop();
-        // Destroy all pools
-        for (const [, pool] of this.pools.entries()) {
-            if ("destroy" in pool && typeof pool.destroy === "function") {
-                pool.destroy();
-            }
-        }
-        this.pools.clear();
-        // Destroy components
-        this.referenceTracker.destroy();
-        this.eventManager.destroy();
-        // Reset singleton instance
-        AdvancedMemoryManager.instance = null;
-    }
-    /**
-     * Initialize object collection tracking system
-     */
-    initializeObjectTracking() {
-        // Initialize FinalizationRegistry if available
-        if (typeof FinalizationRegistry !== "undefined") {
-            this.finalizationRegistry = new FinalizationRegistry((objectId) => {
-                this.handleObjectFinalization(objectId);
-            });
-        }
-        // Set up periodic object tracking cleanup
-        setInterval(() => {
-            this.cleanupObjectTracker();
-        }, 60000); // Every minute
-    }
-    /**
-     * Track object collection during garbage collection
-     */
-    trackObjectCollection(beforeUsage, afterUsage) {
-        const memoryFreed = beforeUsage - afterUsage;
-        const gcStartTime = Date.now();
-        // Count objects that are no longer reachable
-        let objectsCollected = 0;
-        const typesCollected = new Map();
-        // Check weak references to see which objects were collected
-        for (const [objectId, tracker] of this.objectTracker.entries()) {
-            let collectedCount = 0;
-            // Filter out collected weak references
-            tracker.weakRefs = tracker.weakRefs.filter((weakRef) => {
-                const obj = weakRef.deref();
-                if (obj === undefined) {
-                    collectedCount++;
-                    return false;
-                }
-                return true;
-            });
-            if (collectedCount > 0) {
-                objectsCollected += collectedCount;
-                tracker.count -= collectedCount;
-                // Track by type
-                const currentTypeCount = typesCollected.get(tracker.type) || 0;
-                typesCollected.set(tracker.type, currentTypeCount + collectedCount);
-                // Remove tracker if no objects remain
-                if (tracker.count <= 0) {
-                    this.objectTracker.delete(objectId);
-                }
-            }
-        }
-        // Estimate objects collected based on memory freed if no direct tracking
-        if (objectsCollected === 0 && memoryFreed > 0) {
-            // Rough estimate: assume average object size of 1KB
-            objectsCollected = Math.floor(memoryFreed / 1024);
-        }
-        // Record collection history
-        const gcDuration = Date.now() - gcStartTime;
-        this.collectionHistory.push({
-            timestamp: Date.now(),
-            objectsCollected,
-            typesCollected,
-            memoryFreed,
-            gcDuration,
-        });
-        // Limit history size
-        if (this.collectionHistory.length > 100) {
-            this.collectionHistory.shift();
-        }
-        return objectsCollected;
-    }
-    /**
-     * Register an object for tracking
-     */
-    trackObject(obj, type = "unknown", estimatedSize = 0) {
-        const objectId = this.generateObjectId();
-        let tracker = this.objectTracker.get(type);
-        if (!tracker) {
-            tracker = {
-                count: 0,
-                totalSize: 0,
-                lastSeen: Date.now(),
-                type,
-                weakRefs: [],
-            };
-            this.objectTracker.set(type, tracker);
-        }
-        // Create weak reference to track the object
-        const weakRef = new WeakRef(obj);
-        tracker.weakRefs.push(weakRef);
-        tracker.count++;
-        tracker.totalSize += estimatedSize;
-        tracker.lastSeen = Date.now();
-        // Register with FinalizationRegistry if available
-        if (this.finalizationRegistry) {
-            this.finalizationRegistry.register(obj, objectId);
-        }
-        return objectId;
-    }
-    /**
-     * Handle object finalization
-     */
-    handleObjectFinalization(objectId) {
-        // This is called when an object is finalized by the garbage collector
-        // We can use this to get more accurate collection statistics
-        console.debug(`Object finalized: ${objectId}`);
-    }
-    /**
-     * Clean up object tracker by removing stale entries
-     */
-    cleanupObjectTracker() {
-        const now = Date.now();
-        const staleThreshold = 300000; // 5 minutes
-        for (const [type, tracker] of this.objectTracker.entries()) {
-            // Remove stale weak references
-            tracker.weakRefs = tracker.weakRefs.filter((weakRef) => {
-                return weakRef.deref() !== undefined;
-            });
-            // Update count based on remaining weak references
-            tracker.count = tracker.weakRefs.length;
-            // Remove tracker if no objects remain and it's stale
-            if (tracker.count === 0 &&
-                now - tracker.lastSeen > staleThreshold) {
-                this.objectTracker.delete(type);
-            }
-        }
-    }
-    /**
-     * Generate unique object ID
-     */
-    generateObjectId() {
-        return `obj_${Date.now()}_${Math.random()
-            .toString(36)
-            .substring(2, 11)}`;
-    }
-    /**
-     * Get object collection statistics
-     */
-    getObjectCollectionStats() {
-        const totalTracked = Array.from(this.objectTracker.values()).reduce((sum, tracker) => sum + tracker.count, 0);
-        const byType = new Map();
-        for (const [type, tracker] of this.objectTracker.entries()) {
-            byType.set(type, {
-                count: tracker.count,
-                totalSize: tracker.totalSize,
-            });
-        }
-        // Calculate average collection rate from recent history
-        const recentCollections = this.collectionHistory.slice(-10);
-        const averageCollectionRate = recentCollections.length > 0
-            ? recentCollections.reduce((sum, entry) => sum + entry.objectsCollected, 0) / recentCollections.length
-            : 0;
-        return {
-            totalTracked,
-            byType,
-            recentCollections: this.collectionHistory.slice(-20), // Last 20 collections
-            averageCollectionRate,
-        };
-    }
-}
-
-exports.AdvancedMemoryManager = AdvancedMemoryManager;
-//# sourceMappingURL=memory-manager.js.map