@dotdo/postgres 0.1.0

package/dist/worker/memory-pressure.js

@@ -0,0 +1,1990 @@
+/**
+ * Memory Pressure Monitoring and OOM Protection for PostgresDO
+ *
+ * This module provides memory monitoring capabilities for PGLite running
+ * in Cloudflare Workers (128MB limit). It detects high memory usage and
+ * can automatically take protective actions to prevent OOM crashes.
+ *
+ * ## Key Features
+ *
+ * - **Real-time memory pressure tracking** - Monitors heap usage and classifies
+ *   pressure levels (normal, warning, critical, oom)
+ * - **Automatic extension unloading** - Drops least-important PostgreSQL extensions
+ *   when memory is critically low
+ * - **GC hint triggering** - Suggests garbage collection at configurable thresholds
+ *   with rate limiting to prevent thrashing
+ * - **Cache eviction** - Automatically evicts cache entries under pressure using
+ *   configurable strategies (LRU, largest-first)
+ * - **Query management** - Pauses or rejects queries under extreme pressure
+ * - **Recovery with hysteresis** - Prevents oscillation by requiring sustained
+ *   normal pressure before full recovery
+ * - **Metrics export** - Prometheus and JSON format metrics for observability
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { createMemoryPressureManager } from './memory-pressure'
+ *
+ * const manager = createMemoryPressureManager({
+ *   warningThresholdPercent: 70,
+ *   criticalThresholdPercent: 85,
+ *   autoUnloadExtensions: true,
+ * })
+ *
+ * // Listen for pressure changes
+ * const unsubscribe = manager.onPressureChange((event) => {
+ *   console.log(`Pressure: ${event.previousLevel} -> ${event.currentLevel}`)
+ * })
+ *
+ * // Start monitoring
+ * manager.startMonitoring()
+ *
+ * // Check status at any time
+ * const stats = manager.getMemoryStats()
+ *
+ * // Clean up when done
+ * manager.dispose()
+ * ```
+ *
+ * ## Cloudflare Workers Constraints
+ *
+ * - 128MB total memory limit per isolate
+ * - ~15MB static (WASM + data + JS)
+ * - ~16MB shared_buffers
+ * - ~16MB WAL + buffers
+ * - ~10MB PostgreSQL catalog/metadata
+ * - ~71MB available for queries, results, and runtime
+ *
+ * @module worker/memory-pressure
+ */
+// =============================================================================
+// Imported Constants (from centralized config)
+// =============================================================================
+import { WORKER_MEMORY_LIMIT_BYTES, PGLITE_BASELINE_BYTES, DEFAULT_WARNING_THRESHOLD_PERCENT, DEFAULT_CRITICAL_THRESHOLD_PERCENT, DEFAULT_OOM_THRESHOLD_PERCENT, MEMORY_SPIKE_THRESHOLD_BYTES, DEFAULT_METRICS_HISTORY_SIZE, } from '../config/memory';
+import { DEFAULT_CHECK_INTERVAL_MS, DEFAULT_GC_HINT_MIN_INTERVAL_MS, DEFAULT_RECOVERY_HYSTERESIS_MS, DEFAULT_QUERY_PAUSE_TIMEOUT_MS, DEFAULT_RECOVERY_STEP_INTERVAL_MS, DEFAULT_SUSTAINED_PRESSURE_THRESHOLD_MS, DEFAULT_MAX_LISTENERS, } from '../config/timeouts';
+// =============================================================================
+// Local Constant Aliases (for backward compatibility in this module)
+// =============================================================================
+/** Default Cloudflare Worker memory limit: 128MB */
+const DEFAULT_MEMORY_LIMIT_BYTES = WORKER_MEMORY_LIMIT_BYTES;
+/** Default pressure thresholds (percentage of memory limit) */
+const DEFAULT_WARNING_THRESHOLD = DEFAULT_WARNING_THRESHOLD_PERCENT;
+const DEFAULT_CRITICAL_THRESHOLD = DEFAULT_CRITICAL_THRESHOLD_PERCENT;
+const DEFAULT_OOM_THRESHOLD = DEFAULT_OOM_THRESHOLD_PERCENT;
+/** Spike detection threshold: 10MB sudden increase */
+const SPIKE_DETECTION_THRESHOLD_BYTES = MEMORY_SPIKE_THRESHOLD_BYTES;
+/**
+ * Extensions safe to unload under memory pressure, ordered by priority.
+ * First = least important = dropped first.
+ */
+const DEFAULT_EXTENSION_UNLOAD_PRIORITY = [
+    'tablefunc', // Rarely used in typical workloads
+    'fuzzystrmatch', // Nice to have for fuzzy matching
+    'unaccent', // Text processing utility
+    'btree_gist', // Index type - usually not critical
+    'btree_gin', // Index type - usually not critical
+    'intarray', // Array functions
+    'cube', // Multi-dimensional data
+    'earthdistance', // Geo calculations (depends on cube)
+    'ltree', // Tree data
+    'hstore', // Key-value pairs
+    'citext', // Case-insensitive text
+    'pg_trgm', // Trigram matching
+    'pgcrypto', // Crypto functions - often important
+    'uuid_ossp', // UUID generation - often important
+    'vector', // Vector search - often critical for AI apps
+];
+/** Default features that can be disabled under pressure */
+const DEFAULT_FEATURES_TO_DISABLE = ['caching', 'prefetching', 'parallel-queries'];
+/** Default eviction target percentages by pressure level */
+const DEFAULT_EVICTION_TARGET_PERCENT = {
+    normal: 0,
+    warning: 20,
+    critical: 50,
+    oom: 100,
+};
+/** Pressure level numeric indices for fast comparison */
+const PRESSURE_LEVEL_INDEX = {
+    normal: 0,
+    warning: 1,
+    critical: 2,
+    oom: 3,
+};
+/** Default demotion configuration per pressure level */
+const DEFAULT_DEMOTION_CONFIG = {
+    warning: { hotEvictCount: 10, warmDemoteCount: 0 },
+    critical: { hotEvictCount: 25, warmDemoteCount: 5 },
+    oom: { hotEvictCount: 50, warmDemoteCount: 15 },
+};
+/** Default minimum interval between pressure-triggered demotions */
+const DEFAULT_DEMOTION_MIN_INTERVAL_MS = 500;
+// =============================================================================
+// Optimized Constants for Memory Pressure Heuristics
+// =============================================================================
+/**
+ * EMA (Exponential Moving Average) smoothing factor for heap usage.
+ * Range: 0-1, higher = more weight on recent samples, lower = more smoothing.
+ * 0.3 provides good balance between responsiveness and noise reduction.
+ */
+const EMA_SMOOTHING_FACTOR = 0.3;
+/**
+ * Minimum samples required for reliable trend detection.
+ * Below this, predictions have low confidence.
+ */
+const MIN_SAMPLES_FOR_TREND = 5;
+/**
+ * Minimum samples for high-confidence OOM prediction.
+ */
+const MIN_SAMPLES_FOR_OOM_PREDICTION = 10;
+/**
+ * Growth rate threshold for "stable" classification (1KB/s).
+ * Memory changes below this are considered noise.
+ */
+const STABLE_GROWTH_THRESHOLD_BYTES_PER_SEC = 1024;
+/**
+ * Rapid growth threshold (5MB/s) - triggers more aggressive responses.
+ */
+const RAPID_GROWTH_THRESHOLD_BYTES_PER_SEC = 5 * 1024 * 1024;
+/**
+ * OOM prediction horizon - warn if OOM predicted within this time.
+ */
+const OOM_PREDICTION_HORIZON_MS = 60000;
+/**
+ * Hysteresis margin for pressure level changes (2%).
+ * Prevents oscillation when hovering near thresholds.
+ * Reserved for future hysteresis implementation.
+ */
+const _PRESSURE_HYSTERESIS_PERCENT = 2;
+void _PRESSURE_HYSTERESIS_PERCENT; // Suppress unused warning - reserved for future use
+/**
+ * Heap sampling constants - optimized for balance between accuracy and speed.
+ * Reserved for future heap sampling implementation.
+ */
+const _HEAP_SAMPLE_STRIDE_SHIFT = 8; // ~256 samples, uses bit shift for speed
+const _HEAP_SAMPLE_UNROLL_FACTOR = 4; // Unroll factor for loop optimization
+void _HEAP_SAMPLE_STRIDE_SHIFT; // Suppress unused warning - reserved for future use
+void _HEAP_SAMPLE_UNROLL_FACTOR; // Suppress unused warning - reserved for future use
+/**
+ * Error thrown when memory pressure prevents an operation
+ */
+export class MemoryPressureError extends Error {
+    code = 'MEMORY_PRESSURE_HIGH';
+    memoryStats;
+    constructor(message, memoryStats) {
+        super(message);
+        this.name = 'MemoryPressureError';
+        this.memoryStats = memoryStats;
+    }
+}
+// =============================================================================
+// Helper Functions
+// =============================================================================
+// Cache performance.memory reference to avoid repeated property access
+let cachedPerformanceMemory;
+/**
+ * Estimate WASM heap memory usage.
+ *
+ * In Cloudflare Workers, we can't directly access Emscripten's HEAP.
+ * This function provides an estimate based on available metrics.
+ *
+ * Optimized: Caches performance.memory reference to reduce property lookups.
+ *
+ * Priority:
+ * 1. performance.memory.usedJSHeapSize (if available)
+ * 2. Conservative estimate based on typical PGLite footprint
+ */
+function estimateHeapUsage() {
+    // Check cache first (undefined = not checked, null = not available)
+    if (cachedPerformanceMemory === undefined) {
+        if (typeof performance !== 'undefined' && 'memory' in performance) {
+            cachedPerformanceMemory = performance.memory ?? null;
+        }
+        else {
+            cachedPerformanceMemory = null;
+        }
+    }
+    if (cachedPerformanceMemory && typeof cachedPerformanceMemory.usedJSHeapSize === 'number') {
+        return cachedPerformanceMemory.usedJSHeapSize;
+    }
+    // Fallback: use pre-computed constant
+    return PGLITE_BASELINE_BYTES;
+}
+/**
+ * Determine memory pressure level from usage percentage.
+ * Optimized: Uses direct comparisons in descending order for early exit.
+ */
+function getPressureLevelFromPercent(usagePercent, thresholds) {
+    // Check highest threshold first for fast rejection
+    if (usagePercent >= thresholds.oomThresholdPercent)
+        return 'oom';
+    if (usagePercent >= thresholds.criticalThresholdPercent)
+        return 'critical';
+    if (usagePercent >= thresholds.warningThresholdPercent)
+        return 'warning';
+    return 'normal';
+}
+/**
+ * Get numeric index for pressure level comparison.
+ * Optimized: Uses pre-computed lookup table instead of array search.
+ */
+function getPressureLevelIndex(level) {
+    return PRESSURE_LEVEL_INDEX[level];
+}
+/**
+ * Calculate average of an array of numbers.
+ * Optimized: Uses for loop instead of reduce for better performance.
+ */
+function average(values) {
+    const len = values.length;
+    if (len === 0)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < len; i++) {
+        sum += values[i] ?? 0;
+    }
+    return sum / len;
+}
+/**
+ * Calculate variance of an array of numbers.
+ * Optimized: Single-pass Welford's algorithm for numerical stability.
+ */
+function variance(values) {
+    const len = values.length;
+    if (len < 2)
+        return 0;
+    let mean = 0;
+    let m2 = 0;
+    for (let i = 0; i < len; i++) {
+        const value = values[i] ?? 0;
+        const delta = value - mean;
+        mean += delta / (i + 1);
+        m2 += delta * (value - mean);
+    }
+    return m2 / (len - 1);
+}
+/**
+ * Simple linear regression for trend analysis.
+ * Returns slope (bytes/ms), intercept, and R-squared.
+ * Optimized: Single-pass calculation.
+ */
+function linearRegression(samples) {
+    const n = samples.length;
+    if (n < 2)
+        return { slope: 0, intercept: 0, rSquared: 0 };
+    // Use first timestamp as origin for numerical stability
+    const t0 = samples[0].timestamp.getTime();
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumX2 = 0;
+    let sumY2 = 0;
+    for (let i = 0; i < n; i++) {
+        const sample = samples[i];
+        const x = sample.timestamp.getTime() - t0;
+        const y = sample.heapUsed;
+        sumX += x;
+        sumY += y;
+        sumXY += x * y;
+        sumX2 += x * x;
+        sumY2 += y * y;
+    }
+    const denom = n * sumX2 - sumX * sumX;
+    if (Math.abs(denom) < 1e-10)
+        return { slope: 0, intercept: sumY / n, rSquared: 0 };
+    const slope = (n * sumXY - sumX * sumY) / denom;
+    const intercept = (sumY - slope * sumX) / n;
+    // Calculate R-squared
+    const meanY = sumY / n;
+    let ssRes = 0;
+    let ssTot = 0;
+    for (let i = 0; i < n; i++) {
+        const sample = samples[i];
+        const x = sample.timestamp.getTime() - t0;
+        const y = sample.heapUsed;
+        const yPred = slope * x + intercept;
+        ssRes += (y - yPred) ** 2;
+        ssTot += (y - meanY) ** 2;
+    }
+    const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+    return { slope, intercept, rSquared };
+}
+/**
+ * Apply EMA (Exponential Moving Average) update.
+ * @param current - Current EMA value
+ * @param newValue - New sample value
+ * @param alpha - Smoothing factor (0-1)
+ */
+function updateEMA(current, newValue, alpha = EMA_SMOOTHING_FACTOR) {
+    return alpha * newValue + (1 - alpha) * current;
+}
+/**
+ * Ring buffer for efficient fixed-size history storage.
+ * Avoids shift() operations which are O(n) on arrays.
+ */
+class RingBuffer {
+    buffer;
+    capacity;
+    head = 0;
+    _size = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buffer = new Array(capacity);
+    }
+    push(item) {
+        this.buffer[this.head] = item;
+        this.head = (this.head + 1) % this.capacity;
+        if (this._size < this.capacity)
+            this._size++;
+    }
+    get size() {
+        return this._size;
+    }
+    /** Get item at logical index (0 = oldest, size-1 = newest) */
+    get(index) {
+        if (index < 0 || index >= this._size)
+            return undefined;
+        const bufferIndex = (this.head - this._size + index + this.capacity) % this.capacity;
+        return this.buffer[bufferIndex];
+    }
+    /** Get the oldest item */
+    first() {
+        return this._size > 0 ? this.get(0) : undefined;
+    }
+    /** Get the newest item */
+    last() {
+        return this._size > 0 ? this.get(this._size - 1) : undefined;
+    }
+    /** Convert to array (oldest to newest) */
+    toArray() {
+        const result = [];
+        for (let i = 0; i < this._size; i++) {
+            const item = this.get(i);
+            if (item !== undefined)
+                result.push(item);
+        }
+        return result;
+    }
+    clear() {
+        this.head = 0;
+        this._size = 0;
+        // Don't clear buffer - items will be overwritten
+    }
+}
+// =============================================================================
+// Memory Pressure Manager
+// =============================================================================
+/**
+ * Memory Pressure Manager for PostgresDO
+ *
+ * Monitors memory usage and takes protective actions to prevent OOM crashes
+ * in Cloudflare Workers. Provides configurable thresholds, automatic actions,
+ * and detailed metrics for observability.
+ *
+ * @example
+ * ```typescript
+ * const manager = new MemoryPressureManager({
+ *   warningThresholdPercent: 70,
+ *   criticalThresholdPercent: 85,
+ *   onGCHint: (level, { aggressive }) => {
+ *     if (aggressive) globalThis.gc?.()
+ *   },
+ * })
+ *
+ * manager.onPressureChange((event) => {
+ *   console.log(`Pressure: ${event.currentLevel}`)
+ * })
+ *
+ * manager.startMonitoring()
+ * ```
+ */
+export class MemoryPressureManager {
+    // === Configuration ===
+    config;
+    extendedConfig;
+    metricsHistorySize;
+    // === External Dependencies ===
+    pglite = null;
+    wasmModule = null;
+    cacheManager = null;
+    // === State Tracking ===
+    lastPressureLevel = 'normal';
+    pressureLevelStartTime = Date.now();
+    pressureDurations = { normal: 0, warning: 0, critical: 0, oom: 0 };
+    sustainedPressureAlerted = false;
+    // === Recovery State ===
+    inRecoveryMode = false;
+    recoveryProgress = 1.0;
+    recoveryStartTime = null;
+    recoveryPaused = false;
+    recoveryStepsExecuted = [];
+    // === Feature Management ===
+    enabledFeatures;
+    disabledFeatures = new Set();
+    unloadedExtensions = new Set();
+    // === Query Management ===
+    pausedQueries = new Map();
+    inFlightQueries = new Map();
+    // === Metrics & History (using ring buffers for efficiency) ===
+    metricsHistory;
+    lastHeapSample = 0;
+    gcMetrics;
+    lastGCHintTime = 0;
+    // === Listeners ===
+    listeners = [];
+    memorySpikeListeners = [];
+    recoveryListeners = [];
+    pressureDemotionListeners = [];
+    // === Tiered Storage Integration ===
+    tieredStorageOrchestrator = null;
+    demotionMetrics = {
+        pressureTriggeredDemotions: 0,
+        demotionsByPressureLevel: { normal: 0, warning: 0, critical: 0, oom: 0 },
+        failedDemotions: 0,
+        bytesFreedByDemotion: 0,
+        lastDemotionTimestamp: null,
+    };
+    lastPressureDemotionTime = 0;
+    // === Intervals ===
+    checkInterval = null;
+    sustainedPressureCheckInterval = null;
+    gradualRecoveryInterval = null;
+    // === Smoothed Pressure State (for EMA-based detection) ===
+    smoothedState = {
+        emaHeapUsage: 0,
+        emaPressureLevel: 0,
+        recentVariance: 0,
+        trend: 'stable',
+        lastRawHeapUsage: 0,
+    };
+    smoothedStateInitialized = false;
+    // === Testing Support ===
+    simulatedHeapBytes = 0;
+    forcedHeapUsage = null;
+    constructor(config = {}) {
+        this.extendedConfig = config;
+        this.config = {
+            enabled: config.enabled ?? true,
+            memoryLimitBytes: config.memoryLimitBytes ?? DEFAULT_MEMORY_LIMIT_BYTES,
+            warningThresholdPercent: config.warningThresholdPercent ?? DEFAULT_WARNING_THRESHOLD,
+            criticalThresholdPercent: config.criticalThresholdPercent ?? DEFAULT_CRITICAL_THRESHOLD,
+            oomThresholdPercent: config.oomThresholdPercent ?? DEFAULT_OOM_THRESHOLD,
+            checkIntervalMs: config.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS,
+            autoUnloadExtensions: config.autoUnloadExtensions ?? true,
+            extensionUnloadPriority: config.extensionUnloadPriority ?? DEFAULT_EXTENSION_UNLOAD_PRIORITY,
+            maxListeners: config.maxListeners ?? DEFAULT_MAX_LISTENERS,
+        };
+        this.metricsHistorySize = config.metricsHistorySize ?? DEFAULT_METRICS_HISTORY_SIZE;
+        this.enabledFeatures = new Set(config.featuresToDisable ?? DEFAULT_FEATURES_TO_DISABLE);
+        // Initialize ring buffers for efficient history storage
+        this.metricsHistory = new RingBuffer(this.metricsHistorySize);
+        this.gcMetrics = {
+            hints: 0,
+            bytesFreed: new RingBuffer(50), // Keep last 50 GC results
+            durations: new RingBuffer(50),
+        };
+    }
+    // ===========================================================================
+    // Configuration & Setup
+    // ===========================================================================
+    /**
+     * Set the PGlite instance for extension unloading operations.
+     *
+     * @param pglite - PGLite instance with query method
+     */
+    setPGlite(pglite) {
+        this.pglite = pglite;
+    }
+    /**
+     * Set the WASM module for real-time heap tracking.
+     *
+     * When set, heap usage is calculated by sampling the HEAPU8 array
+     * instead of using estimates.
+     *
+     * @param module - Emscripten module with HEAPU8 property
+     */
+    setWasmHeapSource(module) {
+        this.wasmModule = module;
+    }
+    /**
+     * Set the cache manager for eviction operations.
+     *
+     * @param manager - Cache manager with eviction methods
+     */
+    setCacheManager(manager) {
+        this.cacheManager = manager;
+    }
+    /**
+     * Get the current configuration.
+     *
+     * @returns Copy of the current configuration
+     */
+    getConfig() {
+        return { ...this.config };
+    }
+    /**
+     * Update configuration at runtime.
+     *
+     * If checkIntervalMs is changed and monitoring is active, it will be restarted.
+     *
+     * @param config - Partial configuration to merge
+     */
+    setConfig(config) {
+        Object.assign(this.config, config);
+        // Restart monitoring if interval changed
+        if (config.checkIntervalMs !== undefined && this.checkInterval) {
+            this.stopMonitoring();
+            this.startMonitoring();
+        }
+    }
+    // ===========================================================================
+    // Tiered Storage Orchestrator Integration
+    // ===========================================================================
+    /**
+     * Connect a TieredStorageOrchestrator for pressure-triggered demotions.
+     *
+     * When connected, the manager will automatically trigger demotions
+     * when memory pressure rises above warning level.
+     *
+     * @param orchestrator - TieredStorageOrchestrator instance or null to disconnect
+     */
+    setTieredStorageOrchestrator(orchestrator) {
+        this.tieredStorageOrchestrator = orchestrator;
+    }
+    /**
+     * Check if a TieredStorageOrchestrator is connected.
+     *
+     * @returns True if an orchestrator is connected
+     */
+    hasTieredStorageOrchestrator() {
+        return this.tieredStorageOrchestrator !== null;
+    }
+    /**
+     * Get demotion metrics for pressure-triggered demotions.
+     *
+     * @returns Demotion metrics
+     */
+    getDemotionMetrics() {
+        return { ...this.demotionMetrics };
+    }
+    /**
+     * Add a listener for pressure-triggered demotion events.
+     *
+     * @param listener - Callback for demotion events
+     * @returns Unsubscribe function
+     */
+    onPressureDemotion(listener) {
+        this.pressureDemotionListeners.push(listener);
+        return () => {
+            const index = this.pressureDemotionListeners.indexOf(listener);
+            if (index >= 0)
+                this.pressureDemotionListeners.splice(index, 1);
+        };
+    }
+    /**
+     * Manually trigger demotions.
+     *
+     * @param options - Demotion options specifying counts
+     * @returns Result of the demotion operation
+     */
+    async triggerDemotion(options) {
+        if (!this.tieredStorageOrchestrator) {
+            return { success: false, demotedCount: 0, error: 'Tiered storage orchestrator not connected' };
+        }
+        try {
+            let totalDemoted = 0;
+            // Evict from hot tier
+            if (options.hotEvictCount > 0) {
+                const hotEvents = await this.tieredStorageOrchestrator.evictLRUFromHot(options.hotEvictCount);
+                totalDemoted += hotEvents.filter((e) => e.success).length;
+            }
+            // Demote from warm tier
+            if (options.warmDemoteCount > 0) {
+                const warmEvents = await this.tieredStorageOrchestrator.runDemotionCycle(options.warmDemoteCount);
+                totalDemoted += warmEvents.filter((e) => e.success).length;
+            }
+            return { success: true, demotedCount: totalDemoted };
+        }
+        catch (error) {
+            return {
+                success: false,
+                demotedCount: 0,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Handle pressure-triggered demotion based on the current level.
+     *
+     * This is called automatically when pressure changes if autoDemoteOnPressure is enabled.
+     *
+     * @param level - Current pressure level
+     * @param forceBypassRateLimit - If true, bypass rate limiting (used when pressure escalates)
+     */
+    async handlePressureDemotion(level, forceBypassRateLimit = false) {
+        // Skip if auto-demotion is disabled
+        if (this.extendedConfig.autoDemoteOnPressure === false)
+            return;
+        // Skip if no orchestrator connected
+        if (!this.tieredStorageOrchestrator)
+            return;
+        // Skip for normal pressure
+        if (level === 'normal')
+            return;
+        // Check rate limiting (can be bypassed for escalation)
+        const now = Date.now();
+        const minInterval = this.extendedConfig.demotionMinIntervalMs ?? DEFAULT_DEMOTION_MIN_INTERVAL_MS;
+        if (!forceBypassRateLimit && now - this.lastPressureDemotionTime < minInterval)
+            return;
+        // Get demotion config for this level
+        const demotionConfig = this.extendedConfig.demotionConfig ?? DEFAULT_DEMOTION_CONFIG;
+        const levelConfig = demotionConfig[level];
+        if (!levelConfig || (levelConfig.hotEvictCount === 0 && levelConfig.warmDemoteCount === 0))
+            return;
+        // Optionally trigger GC before demotion
+        if (this.extendedConfig.gcBeforeDemotion && this.extendedConfig.onGCHint) {
+            this.extendedConfig.onGCHint(level, { aggressive: level === 'critical' || level === 'oom' });
+        }
+        this.lastPressureDemotionTime = now;
+        try {
+            const allDemotions = [];
+            let bytesFreed = 0;
+            // Evict from hot tier
+            if (levelConfig.hotEvictCount > 0) {
+                const hotEvents = await this.tieredStorageOrchestrator.evictLRUFromHot(levelConfig.hotEvictCount);
+                allDemotions.push(...hotEvents);
+                // Track bytes freed
+                for (const event of hotEvents) {
+                    if (event.success) {
+                        const entry = this.tieredStorageOrchestrator.getIndexEntry(event.key);
+                        if (entry)
+                            bytesFreed += entry.size;
+                    }
+                }
+            }
+            // Demote from warm tier if critical or oom
+            if (levelConfig.warmDemoteCount > 0 && (level === 'critical' || level === 'oom')) {
+                const warmEvents = await this.tieredStorageOrchestrator.runDemotionCycle(levelConfig.warmDemoteCount);
+                allDemotions.push(...warmEvents);
+            }
+            // Update metrics
+            const successCount = allDemotions.filter((e) => e.success).length;
+            const failCount = allDemotions.filter((e) => !e.success).length;
+            this.demotionMetrics.pressureTriggeredDemotions += successCount;
+            this.demotionMetrics.demotionsByPressureLevel[level] += successCount;
+            this.demotionMetrics.failedDemotions += failCount;
+            this.demotionMetrics.bytesFreedByDemotion += bytesFreed;
+            this.demotionMetrics.lastDemotionTimestamp = now;
+            // Emit demotion event
+            if (allDemotions.length > 0) {
+                const event = {
+                    pressureLevel: level,
+                    demotions: allDemotions,
+                    totalDemoted: successCount,
+                    timestamp: new Date(),
+                };
+                for (const listener of this.pressureDemotionListeners) {
+                    try {
+                        listener(event);
+                    }
+                    catch {
+                        // Ignore listener errors
+                    }
+                }
+            }
+        }
+        catch (error) {
+            this.demotionMetrics.failedDemotions++;
+            console.error('Pressure-triggered demotion failed:', error);
+        }
+    }
+    // ===========================================================================
+    // Monitoring Control
+    // ===========================================================================
+    /**
+     * Start periodic memory monitoring.
+     *
+     * Checks memory pressure at the configured interval and takes
+     * automatic actions when thresholds are crossed.
+     */
+    startMonitoring() {
+        if (!this.config.enabled || this.checkInterval)
+            return;
+        this.checkInterval = setInterval(() => {
+            this.checkMemoryPressure();
+        }, this.config.checkIntervalMs);
+    }
+    /**
+     * Stop periodic memory monitoring.
+     */
+    stopMonitoring() {
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = null;
+        }
+    }
+    // ===========================================================================
+    // Memory Stats & Pressure Detection
+    // ===========================================================================
+    /**
+     * Get current memory statistics.
+     *
+     * @returns Current memory stats including pressure level
+     */
+    getMemoryStats() {
+        const heapUsed = this.getCurrentHeapUsage();
+        const heapLimit = this.config.memoryLimitBytes;
+        const usagePercent = (heapUsed / heapLimit) * 100;
+        const pressureLevel = getPressureLevelFromPercent(usagePercent, this.config);
+        return {
+            heapUsed,
+            heapLimit,
+            usagePercent,
+            pressureLevel,
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Get current memory pressure level.
+     *
+     * This calculates the level based on current heap usage,
+     * not the cached lastPressureLevel.
+     *
+     * @returns Current pressure level
+     */
+    getPressureLevel() {
+        return this.getMemoryStats().pressureLevel;
+    }
+    /**
+     * Check if current pressure is at or above a threshold.
+     *
+     * Uses the cached lastPressureLevel for efficiency.
+     *
+     * @param level - Level to compare against
+     * @returns True if current pressure >= level
+     */
+    isPressureAtOrAbove(level) {
+        return getPressureLevelIndex(this.lastPressureLevel) >= getPressureLevelIndex(level);
+    }
+    /**
+     * Get current heap usage from the best available source.
+     *
+     * Priority:
+     * 1. Forced heap usage (for testing)
+     * 2. Simulated heap (for testing)
+     * 3. WASM module HEAPU8 (sampled)
+     * 4. Estimation fallback
+     */
+    getCurrentHeapUsage() {
+        // Testing overrides
+        if (this.forcedHeapUsage !== null)
+            return this.forcedHeapUsage;
+        if (this.simulatedHeapBytes > 0)
+            return this.simulatedHeapBytes;
+        // Real WASM heap measurement via sampling
+        if (this.wasmModule?.HEAPU8) {
+            return this.sampleHeapUsage(this.wasmModule.HEAPU8);
+        }
+        // Fallback estimation
+        return estimateHeapUsage();
+    }
+    /**
+     * Sample WASM heap to estimate used bytes.
+     *
+     * Optimized: Uses bit-shift for stride calculation (avoiding division),
+     * reduced sample size for lower overhead, and unrolled loop for better
+     * CPU branch prediction.
+     */
+    sampleHeapUsage(heap) {
+        const len = heap.length;
+        if (len === 0)
+            return 0;
+        // Use bit shift for fast stride calculation (4KB stride = 2^12)
+        // This gives us len >> 12 samples, capped at HEAP_SAMPLE_SIZE
+        const stride = Math.max(1, len >> 8); // ~256 samples for typical heaps
+        let nonZeroCount = 0;
+        let sampledCount = 0;
+        // Unrolled loop: check 4 positions per iteration when possible
+        const end = len - (stride * 3);
+        let i = 0;
+        for (; i < end; i += stride * 4) {
+            if (heap[i] !== 0)
+                nonZeroCount++;
+            if (heap[i + stride] !== 0)
+                nonZeroCount++;
+            if (heap[i + stride * 2] !== 0)
+                nonZeroCount++;
+            if (heap[i + stride * 3] !== 0)
+                nonZeroCount++;
+            sampledCount += 4;
+        }
+        // Handle remaining samples
+        for (; i < len; i += stride) {
+            if (heap[i] !== 0)
+                nonZeroCount++;
+            sampledCount++;
+        }
+        if (sampledCount === 0)
+            return 0;
+        // Use integer math where possible
+        return ((len * nonZeroCount) / sampledCount) | 0;
+    }
+    // ===========================================================================
+    // Pressure Check & Response
+    // ===========================================================================
+    /**
+     * Check current memory pressure and take appropriate actions.
+     *
+     * This is called periodically by startMonitoring() and can also
+     * be called manually before expensive operations.
+     *
+     * @returns Pressure event if level changed, null otherwise
+     */
+    async checkMemoryPressure() {
+        if (!this.config.enabled)
+            return null;
+        const stats = this.getMemoryStats();
+        const previousLevel = this.lastPressureLevel;
+        const currentLevel = stats.pressureLevel;
+        const now = Date.now();
+        // Always record metrics
+        this.recordMetricSample();
+        // No change - handle sustained pressure check
+        if (previousLevel === currentLevel) {
+            this.handleSustainedPressure(currentLevel, now);
+            return null;
+        }
+        // Level changed - update tracking
+        this.updatePressureDuration(previousLevel, now);
+        this.lastPressureLevel = currentLevel;
+        this.sustainedPressureAlerted = false;
+        // Handle transitions
+        const previousIndex = getPressureLevelIndex(previousLevel);
+        const currentIndex = getPressureLevelIndex(currentLevel);
+        const actionsTaken = [];
+        if (currentIndex < previousIndex) {
+            // Pressure dropped - handle recovery
+            this.handleRecovery(previousLevel, currentLevel, now);
+        }
+        else {
+            // Pressure rose - exit recovery mode
+            this.exitRecoveryMode();
+        }
+        // Take actions based on new pressure level
+        if (currentLevel !== 'normal') {
+            actionsTaken.push(...(await this.handleElevatedPressure(currentLevel, now)));
+        }
+        // Emit event
+        const event = {
+            previousLevel,
+            currentLevel,
+            stats,
+            actionsTaken,
+            timestamp: new Date(),
+        };
+        this.emitPressureEvent(event);
+        return event;
+    }
+    /**
+     * Handle sustained pressure alerts.
+     */
+    handleSustainedPressure(level, now) {
+        if (level === 'normal' || this.sustainedPressureAlerted)
+            return;
+        const threshold = this.extendedConfig.sustainedPressureThresholdMs ?? DEFAULT_SUSTAINED_PRESSURE_THRESHOLD_MS;
+        const elapsed = now - this.pressureLevelStartTime;
+        if (elapsed >= threshold && this.extendedConfig.onSustainedPressure) {
+            this.extendedConfig.onSustainedPressure(level, elapsed);
+            this.sustainedPressureAlerted = true;
+        }
+    }
+    /**
+     * Handle recovery from elevated pressure.
+     */
+    handleRecovery(fromLevel, toLevel, now) {
+        this.inRecoveryMode = true;
+        this.recoveryStartTime = now;
+        this.recoveryProgress = 0;
+        if (toLevel === 'normal') {
+            this.resumePausedOperations();
+            if (this.extendedConfig.autoDisableFeatures) {
+                this.enableFeaturesAfterRecovery();
+            }
+            const elapsed = now - this.pressureLevelStartTime;
+            const recoveryEvent = {
+                fromLevel,
+                toLevel,
+                recoveryDurationMs: elapsed,
+            };
+            this.extendedConfig.onRecovery?.(recoveryEvent);
+            this.recoveryListeners.forEach((listener) => listener(recoveryEvent));
+        }
+    }
+    /**
+     * Exit recovery mode when pressure rises.
+     */
+    exitRecoveryMode() {
+        this.inRecoveryMode = false;
+        this.recoveryProgress = 0;
+        this.recoveryStartTime = null;
+        this.pauseGradualRecovery();
+    }
+    /**
+     * Handle actions for elevated pressure levels.
+     * Optimized: Uses adaptive GC timing based on pressure level and memory growth rate.
+     */
+    async handleElevatedPressure(level, now) {
+        const actionsTaken = [];
+        // GC hint with adaptive timing based on pressure level
+        if (this.extendedConfig.onGCHint) {
+            const minInterval = this.getAdaptiveGCInterval(level, now);
+            if (now - this.lastGCHintTime >= minInterval) {
+                this.lastGCHintTime = now;
+                const aggressive = level === 'critical' || level === 'oom';
+                this.extendedConfig.onGCHint(level, { aggressive });
+                actionsTaken.push('gc_triggered');
+            }
+        }
+        // Cache eviction
+        if (this.extendedConfig.autoCacheEviction && this.cacheManager) {
+            const evicted = this.evictCache(level);
+            if (evicted)
+                actionsTaken.push('cache_cleared');
+        }
+        // Feature disabling
+        if ((level === 'critical' || level === 'oom') && this.extendedConfig.autoDisableFeatures) {
+            this.disableFeaturesUnderPressure();
+        }
+        // Extension unloading
+        if ((level === 'critical' || level === 'oom') && this.config.autoUnloadExtensions && this.pglite) {
+            const result = await this.unloadLeastImportantExtension();
+            if (result.success)
+                actionsTaken.push('extension_unloaded');
+            actionsTaken.push('warning_emitted');
+        }
+        return actionsTaken;
+    }
+    /**
+     * Calculate adaptive GC interval based on pressure level and memory growth rate.
+     *
+     * - At OOM: Minimal delay (500ms) to maximize chances of freeing memory
+     * - At critical: Reduced delay (2s) with faster triggering if memory is growing rapidly
+     * - At warning: Standard delay (5s) unless memory is growing rapidly
+     *
+     * @param level - Current pressure level
+     * @param now - Current timestamp
+     * @returns Minimum interval in milliseconds before next GC hint
+     */
+    getAdaptiveGCInterval(level, _now) {
+        const baseInterval = this.extendedConfig.gcHintMinIntervalMs ?? DEFAULT_GC_HINT_MIN_INTERVAL_MS;
+        // At OOM, be very aggressive
+        if (level === 'oom') {
+            return Math.min(500, baseInterval);
+        }
+        // At critical, reduce interval and consider growth rate
+        if (level === 'critical') {
+            const growthRate = this.getMemoryGrowthRate();
+            // If memory is growing rapidly (>5MB/s), be more aggressive
+            if (growthRate.bytesPerSecond > 5 * 1024 * 1024) {
+                return Math.min(1000, baseInterval / 2);
+            }
+            return Math.min(2000, baseInterval);
+        }
+        // At warning level, check if we should trigger earlier based on OOM prediction
+        if (level === 'warning') {
+            const prediction = this.predictTimeToOOM();
+            // If OOM predicted within 30 seconds with high confidence, reduce interval
+            if (prediction.willOOM && prediction.estimatedMs < 30000 && prediction.confidence > 0.7) {
+                return Math.min(2000, baseInterval / 2);
+            }
+        }
+        return baseInterval;
+    }
+    /**
+     * Evict cache entries based on pressure level.
+     */
+    evictCache(level) {
+        if (!this.cacheManager)
+            return false;
+        const evictionTargets = this.extendedConfig.evictionTargetPercent ?? DEFAULT_EVICTION_TARGET_PERCENT;
+        const targetPercent = evictionTargets[level] ?? 0;
+        if (targetPercent <= 0)
+            return false;
+        const totalCacheSize = this.cacheManager.getTotalSize();
+        const targetBytes = Math.floor(totalCacheSize * (targetPercent / 100));
+        if (level === 'oom' && this.cacheManager.clear) {
+            this.cacheManager.clear();
+            return true;
+        }
+        if (this.cacheManager.evictLRU) {
+            this.cacheManager.evictLRU(targetBytes);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Update pressure duration tracking.
+     */
+    updatePressureDuration(level, now) {
+        const elapsed = now - this.pressureLevelStartTime;
+        this.pressureDurations[level] += elapsed;
+        this.pressureLevelStartTime = now;
+    }
+    // ===========================================================================
+    // Extension Management
+    // ===========================================================================
+    /**
+     * Unload the least important extension to free memory.
+     *
+     * Uses the extensionUnloadPriority list to determine which extension
+     * to drop first.
+     *
+     * @returns Result of the unload operation
+     */
+    async unloadLeastImportantExtension() {
+        if (!this.pglite) {
+            return { action: 'extension_unloaded', success: false, error: 'PGlite not available' };
+        }
+        // Get installed extensions
+        let installedExtensions;
+        try {
+            const result = await this.pglite.query(`SELECT extname FROM pg_extension WHERE extname != 'plpgsql'`);
+            installedExtensions = new Set(result.rows
+                .map((r) => r.extname)
+                .filter((name) => !this.unloadedExtensions.has(name)));
+        }
+        catch (error) {
+            return {
+                action: 'extension_unloaded',
+                success: false,
+                error: `Failed to get extensions: ${error instanceof Error ? error.message : 'Unknown'}`,
+            };
+        }
+        // Find and unload the least important
+        for (const extName of this.config.extensionUnloadPriority) {
+            if (installedExtensions.has(extName)) {
+                try {
+                    await this.pglite.query(`DROP EXTENSION IF EXISTS "${extName}" CASCADE`);
+                    this.unloadedExtensions.add(extName);
+                    return { action: 'extension_unloaded', success: true, extensionName: extName };
+                }
+                catch (error) {
+                    return {
+                        action: 'extension_unloaded',
+                        success: false,
+                        extensionName: extName,
+                        error: `Failed to unload: ${error instanceof Error ? error.message : 'Unknown'}`,
+                    };
+                }
+            }
+        }
+        return { action: 'extension_unloaded', success: false, error: 'No extensions available to unload' };
+    }
+    /**
+     * Get list of extensions unloaded due to memory pressure.
+     */
+    getUnloadedExtensions() {
+        return Array.from(this.unloadedExtensions);
+    }
+    /**
+     * Check if an extension was unloaded due to memory pressure.
+     */
+    wasExtensionUnloaded(extensionName) {
+        return this.unloadedExtensions.has(extensionName);
+    }
+    /**
+     * Clear the list of unloaded extensions.
+     */
+    clearUnloadedExtensions() {
+        this.unloadedExtensions.clear();
+    }
+    // ===========================================================================
+    // GC Hints
+    // ===========================================================================
+    /**
+     * Request a garbage collection hint.
+     *
+     * Attempts to trigger GC if available and tracks effectiveness.
+     * Optimized: Uses performance.now() for higher precision timing.
+     *
+     * @returns Result including bytes freed estimate
+     */
+    async requestGC() {
+        const startTime = performance.now();
+        const heapBefore = this.getCurrentHeapUsage();
+        let triggered = false;
+        // Try to trigger GC if available
+        const gc = globalThis.gc;
+        if (typeof gc === 'function') {
+            try {
+                gc();
+                triggered = true;
+            }
+            catch {
+                // GC not available or failed
+            }
+        }
+        const durationMs = performance.now() - startTime;
+        const heapAfter = this.getCurrentHeapUsage();
+        const bytesFreedEstimate = Math.max(0, heapBefore - heapAfter);
+        // Track metrics using ring buffers
+        this.gcMetrics.hints++;
+        this.gcMetrics.bytesFreed.push(bytesFreedEstimate);
+        this.gcMetrics.durations.push(durationMs);
+        return { triggered, bytesFreedEstimate, durationMs };
+    }
+    /**
+     * Get aggregated GC metrics.
+     * Optimized: Uses ring buffer's toArray() for efficient conversion.
+     */
+    getGCMetrics() {
+        const { hints, bytesFreed, durations } = this.gcMetrics;
+        const bytesFreedArray = bytesFreed.toArray();
+        const durationsArray = durations.toArray();
+        // Count successful GC hints (where memory was actually freed)
+        let successCount = 0;
+        for (let i = 0; i < bytesFreedArray.length; i++) {
+            if ((bytesFreedArray[i] ?? 0) > 0)
+                successCount++;
+        }
+        return {
+            totalHints: hints,
+            avgBytesFreed: average(bytesFreedArray),
+            avgDurationMs: average(durationsArray),
+            successRate: hints > 0 ? successCount / Math.min(hints, bytesFreedArray.length) : 0,
+        };
+    }
+    // ===========================================================================
+    // Metrics & History
+    // ===========================================================================
+    /**
+     * Record a metric sample for history tracking.
+     *
+     * Also detects memory spikes, updates EMA state, and emits events.
+     * Optimized: Uses ring buffer (no shift operations).
+     */
+    recordMetricSample() {
+        const stats = this.getMemoryStats();
+        const sample = {
+            timestamp: new Date(),
+            heapUsed: stats.heapUsed,
+            pressureLevel: stats.pressureLevel,
+        };
+        // Add to ring buffer (automatically handles size limit)
+        this.metricsHistory.push(sample);
+        // Update smoothed state for EMA-based detection
+        this.updateSmoothedState(stats.heapUsed, PRESSURE_LEVEL_INDEX[stats.pressureLevel]);
+        // Spike detection
+        if (this.lastHeapSample > 0 && stats.heapUsed - this.lastHeapSample >= SPIKE_DETECTION_THRESHOLD_BYTES) {
+            const spike = {
+                deltaBytes: stats.heapUsed - this.lastHeapSample,
+                previousBytes: this.lastHeapSample,
+                currentBytes: stats.heapUsed,
+                timestamp: new Date(),
+            };
+            // Use for loop instead of forEach for better performance
+            const listeners = this.memorySpikeListeners;
+            for (let i = 0; i < listeners.length; i++) {
+                const listener = listeners[i];
+                if (listener)
+                    listener(spike);
+            }
+        }
+        this.lastHeapSample = stats.heapUsed;
+    }
+    /**
+     * Update smoothed pressure state using EMA.
+     * This provides noise-resistant pressure tracking.
+     */
+    updateSmoothedState(rawHeapUsage, rawPressureLevel) {
+        if (!this.smoothedStateInitialized) {
+            // Initialize with first sample
+            this.smoothedState = {
+                emaHeapUsage: rawHeapUsage,
+                emaPressureLevel: rawPressureLevel,
+                recentVariance: 0,
+                trend: 'stable',
+                lastRawHeapUsage: rawHeapUsage,
+            };
+            this.smoothedStateInitialized = true;
+            return;
+        }
+        // Update EMAs
+        this.smoothedState.emaHeapUsage = updateEMA(this.smoothedState.emaHeapUsage, rawHeapUsage);
+        this.smoothedState.emaPressureLevel = updateEMA(this.smoothedState.emaPressureLevel, rawPressureLevel);
+        // Calculate variance from recent samples
+        if (this.metricsHistory.size >= 3) {
+            const recentSamples = this.metricsHistory.toArray().slice(-10);
+            const heapValues = recentSamples.map((s) => s.heapUsed);
+            this.smoothedState.recentVariance = variance(heapValues);
+        }
+        // Determine trend from delta
+        const delta = rawHeapUsage - this.smoothedState.lastRawHeapUsage;
+        if (delta > STABLE_GROWTH_THRESHOLD_BYTES_PER_SEC) {
+            this.smoothedState.trend = 'rising';
+        }
+        else if (delta < -STABLE_GROWTH_THRESHOLD_BYTES_PER_SEC) {
+            this.smoothedState.trend = 'falling';
+        }
+        else {
+            this.smoothedState.trend = 'stable';
+        }
+        this.smoothedState.lastRawHeapUsage = rawHeapUsage;
+    }
+    /**
+     * Get the smoothed pressure state.
+     * Useful for observability and debugging.
+     */
+    getSmoothedPressureState() {
+        return { ...this.smoothedState };
+    }
+    /**
+     * Get the smoothed pressure level (EMA-based).
+     * This is less sensitive to momentary spikes than raw pressure level.
+     */
+    getSmoothedPressureLevel() {
+        const levelIndex = Math.round(this.smoothedState.emaPressureLevel);
+        const levels = ['normal', 'warning', 'critical', 'oom'];
+        return levels[Math.max(0, Math.min(3, levelIndex))] ?? 'normal';
+    }
+    /**
+     * Check if pressure is volatile (high variance in recent samples).
+     * Useful for deciding whether to take aggressive action.
+     */
+    isPressureVolatile() {
+        const stats = this.getMemoryStats();
+        // Coefficient of variation > 10% indicates volatility
+        const cv = stats.heapUsed > 0
+            ? Math.sqrt(this.smoothedState.recentVariance) / stats.heapUsed
+            : 0;
+        return cv > 0.1;
+    }
+    /**
+     * Get adaptive thresholds based on current memory behavior.
+     *
+     * Adjusts thresholds based on:
+     * 1. Memory growth rate - faster growth = lower thresholds
+     * 2. Volatility - high volatility = higher thresholds (less sensitive)
+     * 3. OOM prediction - imminent OOM = lower thresholds
+     */
+    getAdaptiveThresholds() {
+        const baseConfig = this.config;
+        // Return base thresholds if insufficient data
+        if (this.metricsHistory.size < MIN_SAMPLES_FOR_TREND) {
+            return {
+                warningThresholdPercent: baseConfig.warningThresholdPercent,
+                criticalThresholdPercent: baseConfig.criticalThresholdPercent,
+                oomThresholdPercent: baseConfig.oomThresholdPercent,
+            };
+        }
+        const growthRate = this.getMemoryGrowthRate();
+        const oomPrediction = this.predictTimeToOOM();
+        let warningAdjustment = 0;
+        let criticalAdjustment = 0;
+        // Adjust for growth rate
+        if (growthRate.bytesPerSecond > RAPID_GROWTH_THRESHOLD_BYTES_PER_SEC) {
+            // Rapid growth - lower thresholds by up to 10%
+            warningAdjustment -= 10;
+            criticalAdjustment -= 5;
+        }
+        else if (growthRate.trend === 'increasing') {
+            // Moderate growth - lower thresholds by up to 5%
+            warningAdjustment -= 5;
+            criticalAdjustment -= 3;
+        }
+        // Adjust for volatility (increase thresholds if volatile to reduce false alarms)
+        if (this.isPressureVolatile()) {
+            warningAdjustment += 3;
+            criticalAdjustment += 2;
+        }
+        // Adjust for imminent OOM prediction
+        if (oomPrediction.willOOM && (oomPrediction.rSquared ?? 0) > 0.5) {
+            warningAdjustment -= 5;
+            criticalAdjustment -= 3;
+        }
+        // Apply adjustments with clamping
+        const warningThresholdPercent = Math.max(50, Math.min(80, baseConfig.warningThresholdPercent + warningAdjustment));
+        const criticalThresholdPercent = Math.max(warningThresholdPercent + 5, Math.min(90, baseConfig.criticalThresholdPercent + criticalAdjustment));
+        const oomThresholdPercent = Math.max(criticalThresholdPercent + 5, baseConfig.oomThresholdPercent);
+        return { warningThresholdPercent, criticalThresholdPercent, oomThresholdPercent };
+    }
+    /**
+     * Get pressure level using adaptive thresholds.
+     * This provides more intelligent pressure detection based on memory behavior.
+     */
+    getAdaptivePressureLevel() {
+        const stats = this.getMemoryStats();
+        const adaptiveThresholds = this.getAdaptiveThresholds();
+        return getPressureLevelFromPercent(stats.usagePercent, adaptiveThresholds);
+    }
+    /**
+     * Get metrics history.
+     * Returns a copy of the samples array.
+     */
+    getMetricsHistory() {
+        return { samples: this.metricsHistory.toArray() };
+    }
+    /**
+     * Calculate memory growth rate using linear regression.
+     *
+     * Optimized improvements over simple first/last calculation:
+     * 1. Uses all samples via linear regression for more accurate trend
+     * 2. Filters out noise using configurable threshold
+     * 3. Provides confidence via R-squared value
+     *
+     * Falls back to simple calculation if insufficient samples.
+     */
+    getMemoryGrowthRate() {
+        const historySize = this.metricsHistory.size;
+        if (historySize < 2) {
+            return { bytesPerSecond: 0, trend: 'stable' };
+        }
+        // For small sample counts, use simple first/last calculation
+        if (historySize < MIN_SAMPLES_FOR_TREND) {
+            const first = this.metricsHistory.first();
+            const last = this.metricsHistory.last();
+            if (!first || !last)
+                return { bytesPerSecond: 0, trend: 'stable' };
+            const timeDeltaMs = last.timestamp.getTime() - first.timestamp.getTime();
+            if (timeDeltaMs <= 0)
+                return { bytesPerSecond: 0, trend: 'stable' };
+            const bytesDelta = last.heapUsed - first.heapUsed;
+            const bytesPerSecond = (bytesDelta / timeDeltaMs) * 1000;
+            return {
+                bytesPerSecond,
+                trend: this.classifyGrowthTrend(bytesPerSecond),
+            };
+        }
+        // Use linear regression for more accurate trend analysis
+        const samples = this.metricsHistory.toArray();
+        const { slope, rSquared } = linearRegression(samples);
+        // slope is in bytes/ms, convert to bytes/second
+        const bytesPerSecond = slope * 1000;
+        // If regression fit is poor (R² < 0.5), the trend is likely noisy/unstable
+        // Use a higher threshold for stable classification
+        const effectiveThreshold = rSquared < 0.5
+            ? STABLE_GROWTH_THRESHOLD_BYTES_PER_SEC * 2
+            : STABLE_GROWTH_THRESHOLD_BYTES_PER_SEC;
+        return {
+            bytesPerSecond,
+            trend: this.classifyGrowthTrend(bytesPerSecond, effectiveThreshold),
+        };
+    }
+    /**
+     * Classify growth trend based on bytes per second.
+     */
+    classifyGrowthTrend(bytesPerSecond, threshold = STABLE_GROWTH_THRESHOLD_BYTES_PER_SEC) {
+        if (bytesPerSecond > threshold)
+            return 'increasing';
+        if (bytesPerSecond < -threshold)
+            return 'decreasing';
+        return 'stable';
+    }
+    /**
+     * Predict time to OOM using linear regression and statistical analysis.
+     *
+     * Improved prediction algorithm:
+     * 1. Uses linear regression for trend-based prediction
+     * 2. Includes R-squared for confidence estimation
+     * 3. Accounts for variance in samples (high variance = lower confidence)
+     * 4. Predicts usage at OOM horizon for early warning
+     */
+    predictTimeToOOM() {
+        const stats = this.getMemoryStats();
+        const historySize = this.metricsHistory.size;
+        // Default return for insufficient data
+        const defaultPrediction = {
+            estimatedMs: Infinity,
+            confidence: 0,
+            willOOM: false,
+            rSquared: 0,
+            predictedUsageAtHorizon: stats.heapUsed,
+        };
+        if (historySize < 2) {
+            return defaultPrediction;
+        }
+        const samples = this.metricsHistory.toArray();
+        const { slope, intercept, rSquared } = linearRegression(samples);
+        // slope is bytes/ms
+        // If not growing (slope <= 0), no OOM predicted
+        if (slope <= 0) {
+            return {
+                ...defaultPrediction,
+                rSquared,
+                predictedUsageAtHorizon: Math.max(0, stats.heapUsed + slope * OOM_PREDICTION_HORIZON_MS),
+            };
+        }
+        // Calculate time to reach OOM threshold
+        const oomThresholdBytes = (stats.heapLimit * this.config.oomThresholdPercent) / 100;
+        const bytesRemaining = oomThresholdBytes - stats.heapUsed;
+        if (bytesRemaining <= 0) {
+            // Already at or above OOM threshold
+            return {
+                estimatedMs: 0,
+                confidence: 1.0,
+                willOOM: true,
+                rSquared,
+                predictedUsageAtHorizon: stats.heapUsed,
+            };
+        }
+        // Time to OOM in milliseconds: (oomThreshold - currentUsage) / slope
+        const estimatedMs = bytesRemaining / slope;
+        // Calculate confidence based on multiple factors:
+        // 1. Sample count (more samples = more confidence)
+        // 2. R-squared (better fit = more confidence)
+        // 3. Variance consistency (less variance = more confidence)
+        const sampleConfidence = Math.min(1.0, historySize / MIN_SAMPLES_FOR_OOM_PREDICTION);
+        const fitConfidence = Math.max(0, rSquared); // R² is already 0-1
+        // Calculate variance confidence
+        const heapValues = samples.map((s) => s.heapUsed);
+        const sampleVariance = variance(heapValues);
+        const meanHeap = average(heapValues);
+        // Coefficient of variation - lower is more consistent
+        const cv = meanHeap > 0 ? Math.sqrt(sampleVariance) / meanHeap : 0;
+        const varianceConfidence = Math.max(0, 1 - cv * 10); // Scale CV to 0-1 range
+        // Combined confidence (weighted average)
+        const confidence = Math.min(1.0, sampleConfidence * 0.3 +
+            fitConfidence * 0.5 +
+            varianceConfidence * 0.2);
+        // Predict usage at the OOM horizon
+        const now = Date.now();
+        const horizonTime = now + OOM_PREDICTION_HORIZON_MS;
+        const t0 = samples[0]?.timestamp.getTime() ?? now;
+        const predictedUsageAtHorizon = Math.max(0, slope * (horizonTime - t0) + intercept);
+        return {
+            estimatedMs: Math.max(0, estimatedMs),
+            confidence,
+            willOOM: estimatedMs < OOM_PREDICTION_HORIZON_MS && confidence > 0.5,
+            rSquared,
+            predictedUsageAtHorizon,
+        };
+    }
+    /**
+     * Get time spent at each pressure level.
+     */
+    getPressureDurations() {
+        const now = Date.now();
+        const currentElapsed = now - this.pressureLevelStartTime;
+        const durations = { ...this.pressureDurations };
+        durations[this.lastPressureLevel] += currentElapsed;
+        return durations;
+    }
+    /**
+     * Export metrics in Prometheus format.
+     * Enhanced: Includes heuristics metrics for better observability.
+     */
+    exportPrometheusMetrics() {
+        const stats = this.getMemoryStats();
+        const gcMetrics = this.getGCMetrics();
+        const demotionMetrics = this.getDemotionMetrics();
+        const growthRate = this.getMemoryGrowthRate();
+        const oomPrediction = this.predictTimeToOOM();
+        const smoothedState = this.getSmoothedPressureState();
+        const adaptiveThresholds = this.getAdaptiveThresholds();
+        const levels = { normal: 0, warning: 1, critical: 2, oom: 3 };
+        const trends = { decreasing: -1, stable: 0, increasing: 1 };
+        return [
+            // Core metrics
+            `# HELP postgres_memory_heap_bytes Current WASM heap usage in bytes`,
+            `# TYPE postgres_memory_heap_bytes gauge`,
+            `postgres_memory_heap_bytes ${stats.heapUsed}`,
+            `# HELP postgres_memory_pressure_level Current memory pressure level (0=normal, 1=warning, 2=critical, 3=oom)`,
+            `# TYPE postgres_memory_pressure_level gauge`,
+            `postgres_memory_pressure_level ${levels[stats.pressureLevel]}`,
+            `# HELP postgres_memory_gc_count Total number of GC hints triggered`,
+            `# TYPE postgres_memory_gc_count counter`,
+            `postgres_memory_gc_count ${gcMetrics.totalHints}`,
+            `# HELP postgres_memory_pressure_demotions_total Total number of pressure-triggered demotions`,
+            `# TYPE postgres_memory_pressure_demotions_total counter`,
+            `postgres_memory_pressure_demotions_total ${demotionMetrics.pressureTriggeredDemotions}`,
+            `# HELP postgres_memory_pressure_demotions_failed Total number of failed pressure-triggered demotions`,
+            `# TYPE postgres_memory_pressure_demotions_failed counter`,
+            `postgres_memory_pressure_demotions_failed ${demotionMetrics.failedDemotions}`,
+            // Heuristics metrics
+            `# HELP postgres_memory_heap_ema_bytes Exponential moving average of heap usage`,
+            `# TYPE postgres_memory_heap_ema_bytes gauge`,
+            `postgres_memory_heap_ema_bytes ${Math.round(smoothedState.emaHeapUsage)}`,
+            `# HELP postgres_memory_growth_rate_bytes_per_sec Memory growth rate in bytes per second`,
+            `# TYPE postgres_memory_growth_rate_bytes_per_sec gauge`,
+            `postgres_memory_growth_rate_bytes_per_sec ${Math.round(growthRate.bytesPerSecond)}`,
+            `# HELP postgres_memory_growth_trend Memory growth trend (-1=decreasing, 0=stable, 1=increasing)`,
+            `# TYPE postgres_memory_growth_trend gauge`,
+            `postgres_memory_growth_trend ${trends[growthRate.trend] ?? 0}`,
+            `# HELP postgres_memory_oom_prediction_ms Predicted time to OOM in milliseconds (-1 if not growing)`,
+            `# TYPE postgres_memory_oom_prediction_ms gauge`,
+            `postgres_memory_oom_prediction_ms ${oomPrediction.estimatedMs === Infinity ? -1 : Math.round(oomPrediction.estimatedMs)}`,
+            `# HELP postgres_memory_oom_prediction_confidence Confidence in OOM prediction (0-1)`,
+            `# TYPE postgres_memory_oom_prediction_confidence gauge`,
+            `postgres_memory_oom_prediction_confidence ${oomPrediction.confidence.toFixed(3)}`,
+            `# HELP postgres_memory_pressure_volatile Whether pressure readings are currently volatile (0=stable, 1=volatile)`,
+            `# TYPE postgres_memory_pressure_volatile gauge`,
+            `postgres_memory_pressure_volatile ${this.isPressureVolatile() ? 1 : 0}`,
+            `# HELP postgres_memory_adaptive_warning_threshold Current adaptive warning threshold percentage`,
+            `# TYPE postgres_memory_adaptive_warning_threshold gauge`,
+            `postgres_memory_adaptive_warning_threshold ${adaptiveThresholds.warningThresholdPercent}`,
+            `# HELP postgres_memory_adaptive_critical_threshold Current adaptive critical threshold percentage`,
+            `# TYPE postgres_memory_adaptive_critical_threshold gauge`,
+            `postgres_memory_adaptive_critical_threshold ${adaptiveThresholds.criticalThresholdPercent}`,
+        ].join('\n');
+    }
+    /**
+     * Export metrics in JSON format.
+     * Optimized: Calculates aggregates in a single pass.
+     * Enhanced: Includes heuristics data for observability.
+     */
+    exportJSONMetrics() {
+        const current = this.getMemoryStats();
+        const history = this.getMetricsHistory();
+        const gcMetrics = this.getGCMetrics();
+        // Single-pass calculation of avg and peak
+        const samples = history.samples;
+        let sum = 0;
+        let peak = current.heapUsed;
+        if (samples.length > 0) {
+            for (let i = 0; i < samples.length; i++) {
+                const sample = samples[i];
+                if (sample) {
+                    const heapUsed = sample.heapUsed;
+                    sum += heapUsed;
+                    if (heapUsed > peak)
+                        peak = heapUsed;
+                }
+            }
+        }
+        const avgHeapUsed = samples.length > 0 ? sum / samples.length : current.heapUsed;
+        const demotionMetrics = this.getDemotionMetrics();
+        return {
+            current,
+            history,
+            aggregates: {
+                avgHeapUsed,
+                peakHeapUsed: peak,
+                totalGCCount: gcMetrics.totalHints,
+                pressureTriggeredDemotions: demotionMetrics.pressureTriggeredDemotions,
+                failedDemotions: demotionMetrics.failedDemotions,
+                bytesFreedByDemotion: demotionMetrics.bytesFreedByDemotion,
+            },
+            heuristics: {
+                smoothedState: this.getSmoothedPressureState(),
+                adaptiveThresholds: this.getAdaptiveThresholds(),
+                oomPrediction: this.predictTimeToOOM(),
+                growthRate: this.getMemoryGrowthRate(),
+                isVolatile: this.isPressureVolatile(),
+            },
+        };
+    }
+    // ===========================================================================
+    // Query Management
+    // ===========================================================================
+    /**
+     * Execute a query with memory pressure guards.
+     *
+     * - Pauses at critical pressure (with timeout)
+     * - Rejects at OOM pressure
+     * - Enforces hard limits if configured
+     */
+    async guardedQuery(sql, params, options) {
+        const stats = this.getMemoryStats();
+        // Hard limit enforcement
+        if (this.extendedConfig.hardLimitEnforcement && this.forcedHeapUsage !== null) {
+            const estimatedUsage = options?.estimatedResultBytes ?? 0;
+            if (this.forcedHeapUsage + estimatedUsage > this.config.memoryLimitBytes) {
+                throw new MemoryPressureError('Would exceed Worker memory limit', stats);
+            }
+        }
+        // OOM rejection
+        if (this.extendedConfig.queryRejectionEnabled && this.lastPressureLevel === 'oom') {
+            throw new MemoryPressureError('Memory pressure too high', stats);
+        }
+        // Critical pausing
+        if (this.extendedConfig.queryPausingEnabled && this.lastPressureLevel === 'critical') {
+            await this.waitForPressureRelief();
+        }
+        // Execute query
+        if (this.pglite) {
+            const result = await this.pglite.query(sql, params);
+            return result;
+        }
+        return { rows: [], fields: [] };
+    }
+    /**
+     * Wait for pressure to drop with timeout.
+     */
+    async waitForPressureRelief() {
+        const timeoutMs = this.extendedConfig.queryPauseTimeoutMs ?? DEFAULT_QUERY_PAUSE_TIMEOUT_MS;
+        const operation = this.pauseOperation(`query-${Date.now()}`);
+        // Track the operation so it can be resumed when pressure drops
+        const dummyPromise = Promise.resolve();
+        this.pausedQueries.set(dummyPromise, operation);
+        const timeoutPromise = new Promise((_, reject) => {
+            setTimeout(() => {
+                operation.status = 'cancelled';
+                this.pausedQueries.delete(dummyPromise);
+                reject(new Error('Query paused due to memory pressure and timed out'));
+            }, timeoutMs);
+        });
+        try {
+            await Promise.race([operation.resumePromise, timeoutPromise]);
+        }
+        finally {
+            this.pausedQueries.delete(dummyPromise);
+        }
+    }
+    /**
+     * Get status of a query promise.
+     */
+    getQueryStatus(queryPromise) {
+        const operation = this.pausedQueries.get(queryPromise);
+        if (operation) {
+            return operation.status === 'paused' ? 'paused' : 'executing';
+        }
+        return 'unknown';
+    }
+    /**
+     * Pause an operation and return a handle.
+     */
+    pauseOperation(id) {
+        let resolveFunc = () => { };
+        let rejectFunc = () => { };
+        const resumePromise = new Promise((resolve, reject) => {
+            resolveFunc = resolve;
+            rejectFunc = reject;
+        });
+        return {
+            id,
+            status: 'paused',
+            pausedAt: new Date(),
+            resumePromise,
+            resolve: resolveFunc,
+            reject: rejectFunc,
+        };
+    }
+    /**
+     * Resume all paused operations.
+     */
+    resumePausedOperations() {
+        for (const [, operation] of this.pausedQueries) {
+            if (operation.status === 'paused') {
+                operation.status = 'resumed';
+                operation.resolve();
+            }
+        }
+        this.pausedQueries.clear();
+    }
+    /**
+     * Enforce a hard allocation limit.
+     *
+     * Throws if the allocation would exceed the memory limit.
+     */
+    async guardedAllocation(bytes) {
+        const currentUsage = this.forcedHeapUsage ?? this.getCurrentHeapUsage();
+        const totalAfter = currentUsage + bytes;
+        if (this.extendedConfig.hardLimitEnforcement && totalAfter > this.config.memoryLimitBytes) {
+            throw new MemoryPressureError('Would exceed Worker memory limit', this.getMemoryStats());
+        }
+        return { allowed: true };
+    }
+    // ===========================================================================
+    // Feature Management
+    // ===========================================================================
+    /**
+     * Check if a feature is currently enabled.
+     */
+    isFeatureEnabled(feature) {
+        return this.enabledFeatures.has(feature) && !this.disabledFeatures.has(feature);
+    }
+    /**
+     * Get count of enabled features.
+     */
+    getEnabledFeatureCount() {
+        let count = 0;
+        for (const feature of this.enabledFeatures) {
+            if (!this.disabledFeatures.has(feature))
+                count++;
+        }
+        return count;
+    }
+    /**
+     * Disable features under pressure.
+     */
+    disableFeaturesUnderPressure() {
+        if (!this.extendedConfig.autoDisableFeatures)
+            return;
+        const features = this.extendedConfig.featuresToDisable ?? DEFAULT_FEATURES_TO_DISABLE;
+        for (const feature of features) {
+            this.disabledFeatures.add(feature);
+        }
+    }
+    /**
+     * Re-enable features after recovery.
+     */
+    enableFeaturesAfterRecovery() {
+        if (!this.extendedConfig.autoDisableFeatures)
+            return;
+        this.disabledFeatures.clear();
+    }
+    // ===========================================================================
+    // Recovery Management
+    // ===========================================================================
+    /**
+     * Check if manager is in recovery mode.
+     */
+    isInRecoveryMode() {
+        return this.inRecoveryMode;
+    }
+    /**
+     * Get recovery progress (0.0 to 1.0).
+     */
+    getRecoveryProgress() {
+        if (!this.inRecoveryMode) {
+            return this.lastPressureLevel === 'normal' ? 1.0 : 0.0;
+        }
+        const hysteresisMs = this.extendedConfig.recoveryHysteresisMs ?? DEFAULT_RECOVERY_HYSTERESIS_MS;
+        if (this.recoveryStartTime && hysteresisMs > 0) {
+            const elapsed = Date.now() - this.recoveryStartTime;
+            this.recoveryProgress = Math.min(1.0, elapsed / hysteresisMs);
+            if (this.recoveryProgress >= 1.0 && this.lastPressureLevel === 'normal') {
+                this.inRecoveryMode = false;
+            }
+        }
+        return this.recoveryProgress;
+    }
+    /**
+     * Start gradual recovery of features.
+     */
+    async startGradualRecovery() {
+        if (!this.extendedConfig.gradualRecovery)
+            return;
+        this.recoveryPaused = false;
+        const intervalMs = this.extendedConfig.recoveryStepIntervalMs ?? DEFAULT_RECOVERY_STEP_INTERVAL_MS;
+        const features = this.extendedConfig.featuresToDisable ?? DEFAULT_FEATURES_TO_DISABLE;
+        let featureIndex = 0;
+        this.gradualRecoveryInterval = setInterval(() => {
+            if (this.recoveryPaused || featureIndex >= features.length) {
+                if (this.gradualRecoveryInterval) {
+                    clearInterval(this.gradualRecoveryInterval);
+                    this.gradualRecoveryInterval = null;
+                }
+                return;
+            }
+            const feature = features[featureIndex];
+            if (feature) {
+                this.disabledFeatures.delete(feature);
+                this.recoveryStepsExecuted.push(feature);
+                this.extendedConfig.onRecoveryStep?.(feature);
+            }
+            featureIndex++;
+        }, intervalMs);
+    }
+    /**
+     * Pause gradual recovery.
+     */
+    pauseGradualRecovery() {
+        this.recoveryPaused = true;
+        if (this.gradualRecoveryInterval) {
+            clearInterval(this.gradualRecoveryInterval);
+            this.gradualRecoveryInterval = null;
+        }
+    }
+    /**
+     * Check if recovery is paused.
+     */
+    isRecoveryPaused() {
+        return this.recoveryPaused;
+    }
+    // ===========================================================================
+    // Event Listeners
+    // ===========================================================================
+    /**
+     * Add a memory pressure event listener.
+     *
+     * @param listener - Callback for pressure events
+     * @returns Unsubscribe function
+     */
+    onPressureChange(listener) {
+        // Warn when approaching limit
+        const warningThreshold = Math.floor(this.config.maxListeners * 0.8);
+        if (this.listeners.length >= warningThreshold && this.listeners.length < this.config.maxListeners) {
+            console.warn(`Approaching memory pressure listener limit: ${this.listeners.length}/${this.config.maxListeners}`);
+        }
+        // Cap at max listeners (drop oldest)
+        if (this.listeners.length >= this.config.maxListeners) {
+            console.warn(`Memory pressure listener limit (${this.config.maxListeners}) reached. Dropping oldest listener.`);
+            this.listeners.shift();
+        }
+        this.listeners.push(listener);
+        return () => {
+            const index = this.listeners.indexOf(listener);
+            if (index >= 0)
+                this.listeners.splice(index, 1);
+        };
+    }
+    /**
+     * Get current listener count.
+     */
+    getListenerCount() {
+        return this.listeners.length;
+    }
+    /**
+     * Add a memory spike listener.
+     *
+     * @param listener - Callback for spike events
+     * @returns Unsubscribe function
+     */
+    onMemorySpike(listener) {
+        this.memorySpikeListeners.push(listener);
+        return () => {
+            const index = this.memorySpikeListeners.indexOf(listener);
+            if (index >= 0)
+                this.memorySpikeListeners.splice(index, 1);
+        };
+    }
+    /**
+     * Add a recovery event listener.
+     *
+     * @param listener - Callback for recovery events
+     * @returns Unsubscribe function
+     */
+    onRecovery(listener) {
+        this.recoveryListeners.push(listener);
+        return () => {
+            const index = this.recoveryListeners.indexOf(listener);
+            if (index >= 0)
+                this.recoveryListeners.splice(index, 1);
+        };
+    }
+    /**
+     * Emit a pressure event to all listeners.
+     */
+    emitPressureEvent(event) {
+        for (const listener of this.listeners) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                console.error('Memory pressure listener error:', error);
+            }
+        }
+    }
+    // ===========================================================================
+    // Testing Support
+    // ===========================================================================
+    /**
+     * Simulate heap growth for testing.
+     * @internal
+     */
+    _simulateHeapGrowth(bytes) {
+        this.simulatedHeapBytes += bytes;
+    }
+    /**
+     * Set current heap usage for testing.
+     * @internal
+     */
+    _setCurrentHeapUsage(bytes) {
+        this.forcedHeapUsage = bytes;
+    }
+    /**
+     * Force a memory pressure level for testing.
+     *
+     * This updates the internal state and emits events as if the pressure
+     * had actually changed. Useful for testing pressure handling without
+     * actually consuming memory.
+     *
+     * @internal
+     */
+    _forceMemoryPressure(level) {
+        const previousLevel = this.lastPressureLevel;
+        if (previousLevel === level)
+            return null;
+        const now = Date.now();
+        this.updatePressureDuration(previousLevel, now);
+        // Handle recovery/escalation transitions
+        const previousIndex = getPressureLevelIndex(previousLevel);
+        const newIndex = getPressureLevelIndex(level);
+        if (previousIndex > 0 && newIndex < previousIndex) {
+            // Pressure dropped
+            this.handleRecovery(previousLevel, level, now);
+        }
+        else if (newIndex > 0 && newIndex >= previousIndex) {
+            // Pressure rose
+            this.exitRecoveryMode();
+        }
+        this.lastPressureLevel = level;
+        // Create synthetic stats
+        const usagePercent = level === 'oom' ? 96 : level === 'critical' ? 88 : level === 'warning' ? 75 : 50;
+        const stats = {
+            heapUsed: this.config.memoryLimitBytes * (usagePercent / 100),
+            heapLimit: this.config.memoryLimitBytes,
+            usagePercent,
+            pressureLevel: level,
+            timestamp: new Date(),
+        };
+        const event = {
+            previousLevel,
+            currentLevel: level,
+            stats,
+            actionsTaken: [],
+            timestamp: new Date(),
+        };
+        this.emitPressureEvent(event);
+        // Trigger pressure-triggered demotion if pressure rose
+        if (newIndex > previousIndex && level !== 'normal') {
+            // Fire and forget - don't await to avoid blocking test
+            // Pass true to bypass rate limiting since this is a pressure escalation
+            this.handlePressureDemotion(level, true).catch(() => { });
+        }
+        return event;
+    }
+    // ===========================================================================
+    // Cleanup
+    // ===========================================================================
+    /**
+     * Dispose of the manager and clean up all resources.
+     *
+     * This stops all intervals, clears all listeners, and releases references.
+     * Always call this when the manager is no longer needed.
+     */
+    dispose() {
+        // Stop all intervals
+        this.stopMonitoring();
+        this.pauseGradualRecovery();
+        if (this.sustainedPressureCheckInterval) {
+            clearInterval(this.sustainedPressureCheckInterval);
+            this.sustainedPressureCheckInterval = null;
+        }
+        // Clear all listeners (set to empty arrays to avoid memory leaks)
+        this.listeners.length = 0;
+        this.memorySpikeListeners.length = 0;
+        this.recoveryListeners.length = 0;
+        this.pressureDemotionListeners.length = 0;
+        // Release external references
+        this.pglite = null;
+        this.wasmModule = null;
+        this.cacheManager = null;
+        this.tieredStorageOrchestrator = null;
+        // Clear state
+        this.unloadedExtensions.clear();
+        this.pausedQueries.clear();
+        this.inFlightQueries.clear();
+        this.metricsHistory.clear();
+        this.gcMetrics.bytesFreed.clear();
+        this.gcMetrics.durations.clear();
+        this.disabledFeatures.clear();
+        this.recoveryStepsExecuted.length = 0;
+        // Reset testing state
+        this.simulatedHeapBytes = 0;
+        this.forcedHeapUsage = null;
+    }
+}
+// =============================================================================
+// Factory Function
+// =============================================================================
+/**
+ * Create a memory pressure manager with default configuration.
+ *
+ * @param config - Optional configuration overrides
+ * @returns Configured MemoryPressureManager instance
+ */
+export function createMemoryPressureManager(config) {
+    return new MemoryPressureManager(config);
+}
+//# sourceMappingURL=memory-pressure.js.map