@od-oneapp/config 2026.2.2001-canary.1

package/typescript/dist/src/server/advanced-memory-monitor.js

@@ -0,0 +1,718 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { freemem, totalmem } from 'node:os';
+import { performance, PerformanceObserver } from 'node:perf_hooks';
+import { scheduler } from 'node:timers/promises';
+import { logDebug, logError, logWarn } from '@repo/shared/logs/client/next';
+import { ErrorPatterns } from './error-handling';
+import { ok, runTool } from './tool-helpers';
+class WeakRefObjectTracker {
+    trackedObjects = new Map();
+    weakRefs = new Map();
+    finalizationRegistry;
+    cleanupCallbacks = new Map();
+    cleanupInterval = null;
+    constructor() {
+        this.finalizationRegistry = new FinalizationRegistry((objectId) => {
+            this.handleObjectFinalization(objectId);
+        });
+        this.cleanupInterval = setInterval(() => {
+            this.performPeriodicCleanup();
+        }, 30000);
+        this.cleanupInterval.unref();
+    }
+    trackObject(obj, type, metadata = {}, cleanupCallback) {
+        const id = `${type}-${Date.now()}-${crypto.randomUUID().substring(0, 8)}`;
+        const stackTrace = this.captureStackTrace();
+        const trackedObj = {
+            id,
+            type,
+            createdAt: Date.now(),
+            lastAccessed: Date.now(),
+            size: this.estimateObjectSize(obj),
+            metadata,
+            stackTrace,
+        };
+        this.trackedObjects.set(id, trackedObj);
+        this.weakRefs.set(id, new WeakRef(obj));
+        if (cleanupCallback) {
+            this.cleanupCallbacks.set(id, cleanupCallback);
+        }
+        this.finalizationRegistry.register(obj, id, obj);
+        return id;
+    }
+    touchObject(id) {
+        const tracked = this.trackedObjects.get(id);
+        if (tracked) {
+            tracked.lastAccessed = Date.now();
+        }
+    }
+    detectLeakedObjects(ageThresholdMs = 300000) {
+        const now = Date.now();
+        const leaks = [];
+        for (const [id, tracked] of this.trackedObjects.entries()) {
+            const age = now - tracked.createdAt;
+            const timeSinceAccess = now - tracked.lastAccessed;
+            const weakRef = this.weakRefs.get(id);
+            const isAlive = weakRef?.deref() !== undefined;
+            if (isAlive && age > ageThresholdMs && timeSinceAccess > ageThresholdMs) {
+                const severity = this.calculateLeakSeverity(tracked, age, timeSinceAccess);
+                leaks.push({
+                    leakId: id,
+                    objectType: tracked.type,
+                    creationTime: tracked.createdAt,
+                    suspectedLeakTime: tracked.lastAccessed,
+                    estimatedSize: tracked.size,
+                    suspectedCause: this.determineSuspectedCause(tracked, age, timeSinceAccess),
+                    stackTrace: tracked.stackTrace,
+                    severity,
+                });
+            }
+        }
+        return leaks;
+    }
+    forceCleanup(id) {
+        const cleanup = this.cleanupCallbacks.get(id);
+        if (cleanup) {
+            try {
+                cleanup();
+            }
+            catch (error) {
+                logWarn(`Cleanup callback failed for ${id}`, { error, id });
+            }
+        }
+        const removed = this.trackedObjects.delete(id) &&
+            this.weakRefs.delete(id) &&
+            this.cleanupCallbacks.delete(id);
+        return removed;
+    }
+    handleObjectFinalization(objectId) {
+        this.forceCleanup(objectId);
+    }
+    performPeriodicCleanup() {
+        for (const [id, weakRef] of this.weakRefs.entries()) {
+            if (weakRef.deref() === undefined) {
+                this.forceCleanup(id);
+            }
+        }
+    }
+    captureStackTrace() {
+        const error = new Error();
+        return error.stack?.split('\n').slice(2, 10).join('\n') ?? 'No stack trace available';
+    }
+    estimateObjectSize(obj) {
+        try {
+            const jsonStr = JSON.stringify(obj);
+            return jsonStr.length * 2;
+        }
+        catch {
+            return 0;
+        }
+    }
+    calculateLeakSeverity(tracked, age, timeSinceAccess) {
+        const sizeScore = tracked.size > 1000000 ? 3 : tracked.size > 100000 ? 2 : 1;
+        const ageScore = age > 1800000 ? 3 : age > 900000 ? 2 : 1;
+        const accessScore = timeSinceAccess > 1200000 ? 3 : timeSinceAccess > 600000 ? 2 : 1;
+        const totalScore = sizeScore + ageScore + accessScore;
+        if (totalScore >= 8)
+            return 'critical';
+        if (totalScore >= 6)
+            return 'high';
+        if (totalScore >= 4)
+            return 'medium';
+        return 'low';
+    }
+    determineSuspectedCause(tracked, age, timeSinceAccess) {
+        if (timeSinceAccess > age * 0.8) {
+            return 'Object created but never accessed - possible unused allocation';
+        }
+        if (tracked.type.includes('cache') || tracked.type.includes('Cache')) {
+            return 'Cache entry not properly evicted';
+        }
+        if (tracked.type.includes('event') || tracked.type.includes('Event')) {
+            return 'Event listener or handler not properly cleaned up';
+        }
+        if (tracked.type.includes('stream') || tracked.type.includes('Stream')) {
+            return 'Stream not properly closed or destroyed';
+        }
+        return 'Long-lived object with infrequent access - potential memory leak';
+    }
+    dispose() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        this.trackedObjects.clear();
+        this.weakRefs.clear();
+        this.cleanupCallbacks.clear();
+    }
+    getStats() {
+        let aliveCount = 0;
+        let deadCount = 0;
+        let oldestTime = null;
+        let largestSize = 0;
+        const typeDistribution = {};
+        for (const [id, tracked] of this.trackedObjects.entries()) {
+            const weakRef = this.weakRefs.get(id);
+            const isAlive = weakRef?.deref() !== undefined;
+            if (isAlive) {
+                aliveCount++;
+                if (oldestTime === null || tracked.createdAt < oldestTime) {
+                    oldestTime = tracked.createdAt;
+                }
+                if (tracked.size > largestSize) {
+                    largestSize = tracked.size;
+                }
+            }
+            else {
+                deadCount++;
+            }
+            typeDistribution[tracked.type] = (typeDistribution[tracked.type] || 0) + 1;
+        }
+        return {
+            totalTracked: this.trackedObjects.size,
+            aliveObjects: aliveCount,
+            deadReferences: deadCount,
+            oldestObject: oldestTime,
+            largestObject: largestSize,
+            typeDistribution,
+        };
+    }
+}
+export class AdvancedMemoryMonitor {
+    objectTracker = new WeakRefObjectTracker();
+    gcObserver = null;
+    gcMetrics = [];
+    memorySnapshots = [];
+    v8Stats = null;
+    heapProfiler = null;
+    monitoringInterval = null;
+    isMonitoring = false;
+    memoryMeasurement = null;
+    asyncLocalStorage = new AsyncLocalStorage();
+    constructor() {
+        void this.initializeV8Features();
+        this.setupGCObserver();
+    }
+    async initializeV8Features() {
+        try {
+            const v8 = await import('node:v8');
+            this.v8Stats = v8;
+            if (typeof v8.writeHeapSnapshot === 'function') {
+                this.heapProfiler = v8;
+            }
+            try {
+                if (typeof performance.measureUserAgentSpecificMemory === 'function') {
+                    this.memoryMeasurement = performance;
+                }
+            }
+            catch {
+            }
+        }
+        catch (error) {
+            logDebug('V8 advanced features not available', { error });
+        }
+    }
+    setupGCObserver() {
+        try {
+            this.gcObserver = new PerformanceObserver(list => {
+                for (const entry of list.getEntries()) {
+                    if (entry.entryType === 'gc') {
+                        this.recordGCMetrics(entry);
+                    }
+                }
+            });
+            this.gcObserver.observe({ entryTypes: ['gc'] });
+        }
+        catch (error) {
+            logDebug('GC observation not available', { error });
+        }
+    }
+    recordGCMetrics(entry) {
+        const beforeUsage = entry.detail?.before || process.memoryUsage();
+        const afterUsage = process.memoryUsage();
+        const gcMetric = {
+            gcType: entry.detail?.kind ?? 'unknown',
+            duration: entry.duration,
+            heapBefore: beforeUsage.heapUsed,
+            heapAfter: afterUsage.heapUsed,
+            memoryFreed: beforeUsage.heapUsed - afterUsage.heapUsed,
+            efficiency: beforeUsage.heapUsed > 0
+                ? ((beforeUsage.heapUsed - afterUsage.heapUsed) / beforeUsage.heapUsed) * 100
+                : 0,
+            timestamp: Date.now(),
+        };
+        this.gcMetrics.push(gcMetric);
+        if (this.gcMetrics.length > 100) {
+            this.gcMetrics.splice(0, this.gcMetrics.length - 100);
+        }
+    }
+    startMonitoring(intervalMs = 30000) {
+        if (this.isMonitoring)
+            return;
+        this.isMonitoring = true;
+        this.monitoringInterval = setInterval(() => {
+            this.performMemorySnapshot();
+            this.detectMemoryAnomalies();
+        }, intervalMs);
+        this.monitoringInterval.unref();
+        logDebug('Advanced memory monitoring started');
+    }
+    stopMonitoring() {
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+            this.monitoringInterval = null;
+        }
+        this.isMonitoring = false;
+    }
+    trackObject(obj, type, metadata = {}, cleanupCallback) {
+        return this.objectTracker.trackObject(obj, type, metadata, cleanupCallback);
+    }
+    getMemoryPressure() {
+        const usage = process.memoryUsage();
+        const systemTotal = totalmem();
+        const systemFree = freemem();
+        const heapUsage = usage.heapUsed / 1024 / 1024;
+        const heapUtilization = (usage.heapUsed / usage.heapTotal) * 100;
+        const externalMemory = usage.external / 1024 / 1024;
+        const rssMemory = usage.rss / 1024 / 1024;
+        const systemMemoryPressure = ((systemTotal - systemFree) / systemTotal) * 100;
+        let level = 'optimal';
+        let recommendation = 'Memory usage is healthy';
+        let actionRequired = false;
+        const pressureScore = this.calculatePressureScore(heapUtilization, systemMemoryPressure, heapUsage, externalMemory);
+        if (pressureScore >= 90) {
+            level = 'emergency';
+            recommendation = 'EMERGENCY: Immediate memory cleanup and optimization required';
+            actionRequired = true;
+        }
+        else if (pressureScore >= 80) {
+            level = 'critical';
+            recommendation = 'Critical memory pressure - immediate action required';
+            actionRequired = true;
+        }
+        else if (pressureScore >= 65) {
+            level = 'high';
+            recommendation = 'High memory usage - optimization recommended';
+            actionRequired = true;
+        }
+        else if (pressureScore >= 40) {
+            level = 'elevated';
+            recommendation = 'Elevated memory usage - monitor closely';
+            actionRequired = false;
+        }
+        return {
+            level,
+            heapUsage,
+            heapUtilization,
+            externalMemory,
+            rssMemory,
+            systemMemoryPressure,
+            recommendation,
+            actionRequired,
+        };
+    }
+    calculatePressureScore(heapUtilization, systemPressure, heapUsage, externalMemory) {
+        const heapScore = Math.min(heapUtilization * 0.4, 40);
+        const systemScore = Math.min(systemPressure * 0.3, 30);
+        const sizeScore = Math.min((heapUsage / 500) * 20, 20);
+        const externalScore = Math.min((externalMemory / 100) * 10, 10);
+        return heapScore + systemScore + sizeScore + externalScore;
+    }
+    async detectMemoryLeaks(ageThresholdMs = 300000) {
+        const leaks = this.objectTracker.detectLeakedObjects(ageThresholdMs);
+        if (leaks.length > 0) {
+            const heapAnalysis = await this.analyzeHeap();
+            for (const leak of leaks) {
+                const heapRetainer = heapAnalysis.largestRetainers.find(r => r.type.toLowerCase().includes(leak.objectType.toLowerCase()));
+                if (heapRetainer) {
+                    leak.retentionPath = [
+                        `Heap retainer: ${heapRetainer.type} (${heapRetainer.count} instances)`,
+                    ];
+                }
+            }
+        }
+        return leaks;
+    }
+    async analyzeHeap() {
+        if (!this.v8Stats) {
+            return {
+                totalObjects: 0,
+                leakyObjects: 0,
+                cycleDetected: false,
+                fragmentationLevel: 0,
+                largestRetainers: [],
+                recommendations: ['V8 heap analysis not available'],
+            };
+        }
+        try {
+            const heapStats = this.v8Stats.getHeapStatistics();
+            const heapSpaceStats = this.v8Stats.getHeapSpaceStatistics();
+            const fragmentationLevel = this.calculateFragmentation(heapStats, heapSpaceStats);
+            const largestRetainers = this.identifyLargestRetainers(heapSpaceStats);
+            const recommendations = [];
+            if (fragmentationLevel > 30) {
+                recommendations.push('High heap fragmentation detected - consider forced GC');
+            }
+            if (heapStats.used_heap_size > heapStats.heap_size_limit * 0.8) {
+                recommendations.push('Heap usage approaching limit - increase heap size or optimize memory usage');
+            }
+            const largestRetainer = largestRetainers[0];
+            if (largestRetainer && largestRetainer.size > 50 * 1024 * 1024) {
+                recommendations.push(`Large memory retainer detected: ${largestRetainer.type} (${Math.round(largestRetainer.size / 1024 / 1024)}MB)`);
+            }
+            return {
+                totalObjects: heapStats.number_of_native_contexts + heapStats.number_of_detached_contexts,
+                leakyObjects: 0,
+                cycleDetected: false,
+                fragmentationLevel,
+                largestRetainers,
+                recommendations: recommendations.length > 0 ? recommendations : ['Heap analysis looks healthy'],
+            };
+        }
+        catch (error) {
+            return {
+                totalObjects: 0,
+                leakyObjects: 0,
+                cycleDetected: false,
+                fragmentationLevel: 0,
+                largestRetainers: [],
+                recommendations: [
+                    `Heap analysis failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                ],
+            };
+        }
+    }
+    calculateFragmentation(heapStats, _heapSpaceStats) {
+        const totalUsed = heapStats.used_heap_size;
+        const totalCommitted = heapStats.total_heap_size;
+        if (totalCommitted === 0)
+            return 0;
+        const fragmentation = ((totalCommitted - totalUsed) / totalCommitted) * 100;
+        return Math.min(Math.max(fragmentation, 0), 100);
+    }
+    identifyLargestRetainers(heapSpaceStats) {
+        const retainers = heapSpaceStats
+            .map(space => ({
+            type: space.space_name,
+            size: space.space_used_size,
+            count: 1,
+        }))
+            .filter(retainer => retainer.size > 1024 * 1024)
+            .sort((a, b) => b.size - a.size)
+            .slice(0, 5);
+        return retainers;
+    }
+    performMemorySnapshot() {
+        const usage = process.memoryUsage();
+        const pressure = this.getMemoryPressure();
+        this.memorySnapshots.push({
+            timestamp: Date.now(),
+            usage,
+            pressure,
+        });
+        if (this.memorySnapshots.length > 100) {
+            this.memorySnapshots.splice(0, this.memorySnapshots.length - 100);
+        }
+    }
+    detectMemoryAnomalies() {
+        if (this.memorySnapshots.length < 2)
+            return;
+        const current = this.memorySnapshots[this.memorySnapshots.length - 1];
+        const previous = this.memorySnapshots[this.memorySnapshots.length - 2];
+        if (!current || !previous)
+            return;
+        const heapGrowth = current.usage.heapUsed - previous.usage.heapUsed;
+        const timeElapsed = current.timestamp - previous.timestamp;
+        const growthRate = heapGrowth / timeElapsed;
+        if (growthRate > 1000) {
+            logWarn(`Rapid memory growth detected: ${Math.round(growthRate)}KB/s`, { growthRate });
+        }
+        const pressureLevels = ['optimal', 'elevated', 'high', 'critical', 'emergency'];
+        const currentLevel = pressureLevels.indexOf(current.pressure.level);
+        const previousLevel = pressureLevels.indexOf(previous.pressure.level);
+        if (currentLevel > previousLevel + 1) {
+            logWarn(`Memory pressure escalation detected: ${previous.pressure.level} → ${current.pressure.level}`, { previousLevel: previous.pressure.level, currentLevel: current.pressure.level });
+        }
+    }
+    async performIntelligentGC(options = {}) {
+        const { forceFullGC = false, waitForCompletion = true, maxWaitMs = 5000 } = options;
+        const beforeUsage = process.memoryUsage();
+        const startTime = performance.now();
+        let gcPerformed = false;
+        let error;
+        try {
+            if (global.gc) {
+                const passes = forceFullGC ? 3 : 1;
+                for (let i = 0; i < passes; i++) {
+                    global.gc();
+                    gcPerformed = true;
+                    if (waitForCompletion && i < passes - 1) {
+                        await scheduler.wait(Math.min(500, maxWaitMs / passes));
+                    }
+                }
+                if (waitForCompletion) {
+                    await scheduler.wait(100);
+                }
+            }
+            else {
+                error = 'Garbage collection not available (run with --expose-gc)';
+            }
+        }
+        catch (err) {
+            error = `GC error: ${err instanceof Error ? err.message : 'Unknown error'}`;
+        }
+        const endTime = performance.now();
+        const afterUsage = process.memoryUsage();
+        const memoryFreed = beforeUsage.heapUsed - afterUsage.heapUsed;
+        const duration = endTime - startTime;
+        const efficiency = beforeUsage.heapUsed > 0 ? (memoryFreed / beforeUsage.heapUsed) * 100 : 0;
+        return {
+            gcPerformed,
+            memoryFreed,
+            duration,
+            efficiency,
+            error,
+        };
+    }
+    getStats() {
+        return this.objectTracker.getStats();
+    }
+    async getMemoryReport() {
+        const pressure = this.getMemoryPressure();
+        const leaks = await this.detectMemoryLeaks();
+        const heapAnalysis = await this.analyzeHeap();
+        const tracking = this.objectTracker.getStats();
+        const recentGCs = this.gcMetrics.slice(-10);
+        const averageEfficiency = recentGCs.length > 0
+            ? recentGCs.reduce((sum, gc) => sum + gc.efficiency, 0) / recentGCs.length
+            : 0;
+        const totalMemoryFreed = recentGCs.reduce((sum, gc) => sum + gc.memoryFreed, 0);
+        const recommendations = [];
+        if (pressure.actionRequired) {
+            recommendations.push(pressure.recommendation);
+        }
+        if (leaks.length > 0) {
+            const criticalLeaks = leaks.filter(l => l.severity === 'critical').length;
+            if (criticalLeaks > 0) {
+                recommendations.push(`${criticalLeaks} critical memory leaks detected - immediate investigation required`);
+            }
+        }
+        if (averageEfficiency < 20 && recentGCs.length >= 3) {
+            recommendations.push('Low GC efficiency detected - review memory allocation patterns');
+        }
+        if (tracking.deadReferences > tracking.aliveObjects * 0.5) {
+            recommendations.push('Many dead references detected - improve object lifecycle management');
+        }
+        recommendations.push(...heapAnalysis.recommendations);
+        return {
+            pressure,
+            leaks,
+            heapAnalysis,
+            gcMetrics: {
+                recentGCs,
+                averageEfficiency,
+                totalMemoryFreed,
+            },
+            tracking,
+            recommendations: Array.from(new Set(recommendations)),
+        };
+    }
+    async cleanupLeakedObjects(maxAge = 300000) {
+        const leaks = await this.detectMemoryLeaks(maxAge);
+        const beforeUsage = process.memoryUsage();
+        let cleaned = 0;
+        let failed = 0;
+        for (const leak of leaks) {
+            const success = this.objectTracker.forceCleanup(leak.leakId);
+            if (success) {
+                cleaned++;
+            }
+            else {
+                failed++;
+            }
+        }
+        await this.performIntelligentGC({ forceFullGC: true });
+        const afterUsage = process.memoryUsage();
+        const memoryFreed = beforeUsage.heapUsed - afterUsage.heapUsed;
+        return {
+            cleaned,
+            failed,
+            memoryFreed,
+        };
+    }
+    async generateHeapSnapshot(filename) {
+        if (!this.heapProfiler) {
+            return null;
+        }
+        let snapshotFile;
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            snapshotFile = filename || `heap-snapshot-${timestamp}.heapsnapshot`;
+            this.heapProfiler.writeHeapSnapshot(snapshotFile);
+            return snapshotFile;
+        }
+        catch (error) {
+            logError('Failed to generate heap snapshot', { error, snapshotFile });
+            return null;
+        }
+    }
+    dispose() {
+        this.stopMonitoring();
+        if (this.gcObserver) {
+            this.gcObserver.disconnect();
+            this.gcObserver = null;
+        }
+        this.objectTracker.dispose();
+        this.gcMetrics.length = 0;
+        this.memorySnapshots.length = 0;
+        this.v8Stats = null;
+        this.heapProfiler = null;
+        this.memoryMeasurement = null;
+        logDebug('Advanced memory monitor disposed');
+    }
+}
+export const globalAdvancedMemoryMonitor = new AdvancedMemoryMonitor();
+export const advancedMemoryMonitorTool = {
+    name: 'advanced_memory_monitor',
+    description: 'Advanced memory leak detection and management with Node.js 22+ optimizations',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                enum: [
+                    'startMonitoring',
+                    'stopMonitoring',
+                    'getMemoryPressure',
+                    'detectLeaks',
+                    'analyzeHeap',
+                    'performGC',
+                    'generateReport',
+                    'cleanupLeaks',
+                    'generateSnapshot',
+                    'trackObject',
+                ],
+                description: 'Action to perform',
+            },
+            intervalMs: {
+                type: 'number',
+                description: 'Monitoring interval in milliseconds (default: 30000)',
+            },
+            ageThresholdMs: {
+                type: 'number',
+                description: 'Age threshold for leak detection in milliseconds (default: 300000)',
+            },
+            forceFullGC: {
+                type: 'boolean',
+                description: 'Force full garbage collection (default: false)',
+            },
+            objectType: {
+                type: 'string',
+                description: 'Type of object to track',
+            },
+            objectMetadata: {
+                type: 'object',
+                description: 'Metadata for tracked object',
+            },
+            filename: {
+                type: 'string',
+                description: 'Filename for heap snapshot',
+            },
+        },
+        required: ['action'],
+    },
+    async execute(args) {
+        return runTool('advanced_memory_monitor', args.action, async () => {
+            const { action } = args;
+            switch (action) {
+                case 'startMonitoring': {
+                    const intervalMs = args.intervalMs ?? 30000;
+                    globalAdvancedMemoryMonitor.startMonitoring(intervalMs);
+                    return ok({
+                        success: true,
+                        message: `Advanced memory monitoring started with ${intervalMs}ms interval`,
+                    });
+                }
+                case 'stopMonitoring': {
+                    globalAdvancedMemoryMonitor.stopMonitoring();
+                    return ok({
+                        success: true,
+                        message: 'Advanced memory monitoring stopped',
+                    });
+                }
+                case 'getMemoryPressure': {
+                    const pressure = globalAdvancedMemoryMonitor.getMemoryPressure();
+                    return ok(pressure);
+                }
+                case 'detectLeaks': {
+                    const ageThresholdMs = args.ageThresholdMs ?? 300000;
+                    const leaks = await globalAdvancedMemoryMonitor.detectMemoryLeaks(ageThresholdMs);
+                    return ok({
+                        totalLeaks: leaks.length,
+                        criticalLeaks: leaks.filter(l => l.severity === 'critical').length,
+                        highSeverityLeaks: leaks.filter(l => l.severity === 'high').length,
+                        leaks,
+                    });
+                }
+                case 'analyzeHeap': {
+                    const analysis = await globalAdvancedMemoryMonitor.analyzeHeap();
+                    return ok(analysis);
+                }
+                case 'performGC': {
+                    const forceFullGC = args.forceFullGC ?? false;
+                    const result = await globalAdvancedMemoryMonitor.performIntelligentGC({
+                        forceFullGC,
+                        waitForCompletion: true,
+                    });
+                    return ok(result);
+                }
+                case 'generateReport': {
+                    const report = await globalAdvancedMemoryMonitor.getMemoryReport();
+                    return ok(report);
+                }
+                case 'cleanupLeaks': {
+                    const ageThresholdMs = args.ageThresholdMs ?? 300000;
+                    const result = await globalAdvancedMemoryMonitor.cleanupLeakedObjects(ageThresholdMs);
+                    return ok(result);
+                }
+                case 'generateSnapshot': {
+                    const { filename } = args;
+                    const snapshotPath = await globalAdvancedMemoryMonitor.generateHeapSnapshot(filename);
+                    return ok({
+                        success: snapshotPath !== null,
+                        filename: snapshotPath,
+                        message: snapshotPath
+                            ? `Heap snapshot generated: ${snapshotPath}`
+                            : 'Failed to generate heap snapshot - V8 profiler not available',
+                    });
+                }
+                case 'trackObject': {
+                    if (!args.objectType) {
+                        throw new Error('objectType is required for trackObject action');
+                    }
+                    const trackingId = globalAdvancedMemoryMonitor.trackObject({ type: args.objectType, timestamp: Date.now() }, args.objectType, args.objectMetadata ?? {});
+                    return ok({
+                        success: true,
+                        trackingId,
+                        objectType: args.objectType,
+                        message: `Object tracking started with ID: ${trackingId}`,
+                    });
+                }
+                default:
+                    throw ErrorPatterns.unknownAction(action, [
+                        'startMonitoring',
+                        'stopMonitoring',
+                        'getMemoryPressure',
+                        'detectLeaks',
+                        'analyzeHeap',
+                        'performGC',
+                        'generateReport',
+                        'cleanupLeaks',
+                        'generateSnapshot',
+                        'trackObject',
+                    ]);
+            }
+        });
+    },
+};
+//# sourceMappingURL=advanced-memory-monitor.js.map