@dotdo/postgres 0.1.0

package/src/worker/memory-pressure.test.ts

@@ -0,0 +1,1460 @@
+/**
+ * Tests for Memory Pressure Monitoring and OOM Protection
+ *
+ * Task: postgres-2x4k - Add memory pressure monitoring and OOM protection in PostgresDO
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+
+import { MemoryPressureManager, createMemoryPressureManager } from './memory-pressure'
+import type {
+  MemoryPressureLevel,
+  MemoryPressureEvent,
+  MemoryPressureConfig,
+} from './types'
+
+describe('MemoryPressureManager', () => {
+  let manager: MemoryPressureManager
+
+  beforeEach(() => {
+    manager = new MemoryPressureManager()
+  })
+
+  afterEach(() => {
+    manager.dispose()
+  })
+
+  describe('constructor and configuration', () => {
+    it('should create with default configuration', () => {
+      const config = manager.getConfig()
+
+      expect(config.enabled).toBe(true)
+      expect(config.memoryLimitBytes).toBe(128 * 1024 * 1024) // 128MB
+      expect(config.warningThresholdPercent).toBe(70)
+      expect(config.criticalThresholdPercent).toBe(85)
+      expect(config.oomThresholdPercent).toBe(95)
+      expect(config.autoUnloadExtensions).toBe(true)
+    })
+
+    it('should accept custom configuration', () => {
+      const customConfig: MemoryPressureConfig = {
+        enabled: false,
+        memoryLimitBytes: 64 * 1024 * 1024,
+        warningThresholdPercent: 60,
+        criticalThresholdPercent: 80,
+        oomThresholdPercent: 90,
+        autoUnloadExtensions: false,
+        maxListeners: 25,
+      }
+
+      const customManager = new MemoryPressureManager(customConfig)
+      const config = customManager.getConfig()
+
+      expect(config.enabled).toBe(false)
+      expect(config.memoryLimitBytes).toBe(64 * 1024 * 1024)
+      expect(config.warningThresholdPercent).toBe(60)
+      expect(config.criticalThresholdPercent).toBe(80)
+      expect(config.oomThresholdPercent).toBe(90)
+      expect(config.autoUnloadExtensions).toBe(false)
+      expect(config.maxListeners).toBe(25)
+
+      customManager.dispose()
+    })
+
+    it('should update configuration', () => {
+      manager.setConfig({
+        warningThresholdPercent: 65,
+        criticalThresholdPercent: 82,
+      })
+
+      const config = manager.getConfig()
+      expect(config.warningThresholdPercent).toBe(65)
+      expect(config.criticalThresholdPercent).toBe(82)
+      // Other values should remain unchanged
+      expect(config.oomThresholdPercent).toBe(95)
+    })
+  })
+
+  describe('getMemoryStats', () => {
+    it('should return memory statistics', () => {
+      const stats = manager.getMemoryStats()
+
+      expect(stats).toHaveProperty('heapUsed')
+      expect(stats).toHaveProperty('heapLimit')
+      expect(stats).toHaveProperty('usagePercent')
+      expect(stats).toHaveProperty('pressureLevel')
+      expect(stats).toHaveProperty('timestamp')
+
+      expect(typeof stats.heapUsed).toBe('number')
+      expect(typeof stats.heapLimit).toBe('number')
+      expect(typeof stats.usagePercent).toBe('number')
+      expect(stats.timestamp).toBeInstanceOf(Date)
+    })
+
+    it('should have heapLimit equal to configured memory limit', () => {
+      const stats = manager.getMemoryStats()
+      expect(stats.heapLimit).toBe(128 * 1024 * 1024)
+    })
+  })
+
+  describe('getPressureLevel', () => {
+    it('should return current pressure level', () => {
+      const level = manager.getPressureLevel()
+      expect(['normal', 'warning', 'critical', 'oom']).toContain(level)
+    })
+  })
+
+  describe('isPressureAtOrAbove', () => {
+    it('should correctly compare pressure levels', () => {
+      // Force a known pressure level for testing
+      manager._forceMemoryPressure('warning')
+
+      expect(manager.isPressureAtOrAbove('normal')).toBe(true)
+      expect(manager.isPressureAtOrAbove('warning')).toBe(true)
+      expect(manager.isPressureAtOrAbove('critical')).toBe(false)
+      expect(manager.isPressureAtOrAbove('oom')).toBe(false)
+    })
+
+    it('should handle critical level', () => {
+      manager._forceMemoryPressure('critical')
+
+      expect(manager.isPressureAtOrAbove('normal')).toBe(true)
+      expect(manager.isPressureAtOrAbove('warning')).toBe(true)
+      expect(manager.isPressureAtOrAbove('critical')).toBe(true)
+      expect(manager.isPressureAtOrAbove('oom')).toBe(false)
+    })
+
+    it('should handle oom level', () => {
+      manager._forceMemoryPressure('oom')
+
+      expect(manager.isPressureAtOrAbove('normal')).toBe(true)
+      expect(manager.isPressureAtOrAbove('warning')).toBe(true)
+      expect(manager.isPressureAtOrAbove('critical')).toBe(true)
+      expect(manager.isPressureAtOrAbove('oom')).toBe(true)
+    })
+  })
+
+  describe('event listeners', () => {
+    it('should register and call listeners', () => {
+      const listener = vi.fn()
+      manager.onPressureChange(listener)
+
+      // Force a pressure change
+      manager._forceMemoryPressure('warning')
+
+      expect(listener).toHaveBeenCalledTimes(1)
+      const event = listener.mock.calls[0][0] as MemoryPressureEvent
+      expect(event.previousLevel).toBe('normal')
+      expect(event.currentLevel).toBe('warning')
+    })
+
+    it('should allow unsubscribing', () => {
+      const listener = vi.fn()
+      const unsubscribe = manager.onPressureChange(listener)
+
+      unsubscribe()
+
+      manager._forceMemoryPressure('warning')
+
+      expect(listener).not.toHaveBeenCalled()
+    })
+
+    it('should track listener count', () => {
+      expect(manager.getListenerCount()).toBe(0)
+
+      const unsub1 = manager.onPressureChange(() => {})
+      expect(manager.getListenerCount()).toBe(1)
+
+      const unsub2 = manager.onPressureChange(() => {})
+      expect(manager.getListenerCount()).toBe(2)
+
+      unsub1()
+      expect(manager.getListenerCount()).toBe(1)
+
+      unsub2()
+      expect(manager.getListenerCount()).toBe(0)
+    })
+
+    it('should limit max listeners to prevent memory leaks', () => {
+      const customManager = new MemoryPressureManager({ maxListeners: 5 })
+
+      // Add more listeners than the limit
+      for (let i = 0; i < 10; i++) {
+        customManager.onPressureChange(() => {})
+      }
+
+      expect(customManager.getListenerCount()).toBeLessThanOrEqual(5)
+
+      customManager.dispose()
+    })
+
+    it('should warn when approaching listener limit', () => {
+      const customManager = new MemoryPressureManager({ maxListeners: 10 })
+      const consoleSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+      // Add 9 listeners (90% of limit)
+      for (let i = 0; i < 9; i++) {
+        customManager.onPressureChange(() => {})
+      }
+
+      expect(consoleSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Approaching memory pressure listener limit')
+      )
+
+      consoleSpy.mockRestore()
+      customManager.dispose()
+    })
+
+    it('should not emit event when pressure level unchanged', () => {
+      const listener = vi.fn()
+      manager.onPressureChange(listener)
+
+      // Force to warning
+      manager._forceMemoryPressure('warning')
+      expect(listener).toHaveBeenCalledTimes(1)
+
+      // Try to force to warning again - should not emit
+      const result = manager._forceMemoryPressure('warning')
+      expect(result).toBeNull()
+      expect(listener).toHaveBeenCalledTimes(1)
+    })
+
+    it('should emit event with correct data', () => {
+      const listener = vi.fn()
+      manager.onPressureChange(listener)
+
+      manager._forceMemoryPressure('critical')
+
+      const event = listener.mock.calls[0][0] as MemoryPressureEvent
+      expect(event).toHaveProperty('previousLevel')
+      expect(event).toHaveProperty('currentLevel')
+      expect(event).toHaveProperty('stats')
+      expect(event).toHaveProperty('actionsTaken')
+      expect(event).toHaveProperty('timestamp')
+
+      expect(event.previousLevel).toBe('normal')
+      expect(event.currentLevel).toBe('critical')
+      expect(event.stats.pressureLevel).toBe('critical')
+      expect(event.timestamp).toBeInstanceOf(Date)
+    })
+  })
+
+  describe('monitoring lifecycle', () => {
+    it('should start and stop monitoring', () => {
+      manager.startMonitoring()
+      // No error should occur
+
+      manager.stopMonitoring()
+      // No error should occur
+    })
+
+    it('should not start monitoring when disabled', () => {
+      const disabledManager = new MemoryPressureManager({ enabled: false })
+
+      disabledManager.startMonitoring()
+      // Should not throw and interval should not be set
+
+      disabledManager.dispose()
+    })
+
+    it('should dispose cleanly', () => {
+      manager.startMonitoring()
+      manager.onPressureChange(() => {})
+
+      manager.dispose()
+
+      expect(manager.getListenerCount()).toBe(0)
+    })
+  })
+
+  describe('checkMemoryPressure', () => {
+    it('should return null when disabled', async () => {
+      const disabledManager = new MemoryPressureManager({ enabled: false })
+
+      const result = await disabledManager.checkMemoryPressure()
+      expect(result).toBeNull()
+
+      disabledManager.dispose()
+    })
+
+    it('should return null when pressure level unchanged', async () => {
+      // Run once to establish baseline
+      await manager.checkMemoryPressure()
+
+      // Run again - should return null if level unchanged
+      const result = await manager.checkMemoryPressure()
+      expect(result).toBeNull()
+    })
+  })
+
+  describe('extension unloading', () => {
+    it('should return error when PGlite not available', async () => {
+      const result = await manager.unloadLeastImportantExtension()
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('PGlite not available')
+    })
+
+    it('should unload extension when available', async () => {
+      const mockPGlite = {
+        query: vi.fn()
+          // First call: get installed extensions
+          .mockResolvedValueOnce({
+            rows: [
+              { extname: 'tablefunc' },
+              { extname: 'vector' },
+            ],
+            fields: [],
+          })
+          // Second call: DROP EXTENSION
+          .mockResolvedValueOnce({ rows: [], fields: [] }),
+      }
+
+      manager.setPGlite(mockPGlite)
+
+      const result = await manager.unloadLeastImportantExtension()
+
+      expect(result.success).toBe(true)
+      expect(result.extensionName).toBe('tablefunc') // Lowest priority
+      expect(mockPGlite.query).toHaveBeenCalledWith(
+        expect.stringContaining('DROP EXTENSION IF EXISTS "tablefunc" CASCADE')
+      )
+    })
+
+    it('should track unloaded extensions', async () => {
+      const mockPGlite = {
+        query: vi.fn()
+          .mockResolvedValueOnce({
+            rows: [{ extname: 'tablefunc' }],
+            fields: [],
+          })
+          .mockResolvedValueOnce({ rows: [], fields: [] }),
+      }
+
+      manager.setPGlite(mockPGlite)
+
+      await manager.unloadLeastImportantExtension()
+
+      expect(manager.wasExtensionUnloaded('tablefunc')).toBe(true)
+      expect(manager.wasExtensionUnloaded('vector')).toBe(false)
+      expect(manager.getUnloadedExtensions()).toContain('tablefunc')
+    })
+
+    it('should not unload already unloaded extensions', async () => {
+      const mockPGlite = {
+        query: vi.fn()
+          // First unload attempt
+          .mockResolvedValueOnce({
+            rows: [{ extname: 'tablefunc' }, { extname: 'fuzzystrmatch' }],
+            fields: [],
+          })
+          .mockResolvedValueOnce({ rows: [], fields: [] })
+          // Second unload attempt - tablefunc already unloaded
+          .mockResolvedValueOnce({
+            rows: [{ extname: 'tablefunc' }, { extname: 'fuzzystrmatch' }],
+            fields: [],
+          })
+          .mockResolvedValueOnce({ rows: [], fields: [] }),
+      }
+
+      manager.setPGlite(mockPGlite)
+
+      // First unload
+      const result1 = await manager.unloadLeastImportantExtension()
+      expect(result1.extensionName).toBe('tablefunc')
+
+      // Second unload - should get fuzzystrmatch since tablefunc is tracked
+      const result2 = await manager.unloadLeastImportantExtension()
+      expect(result2.extensionName).toBe('fuzzystrmatch')
+    })
+
+    it('should return error when no extensions available to unload', async () => {
+      const mockPGlite = {
+        query: vi.fn().mockResolvedValueOnce({
+          rows: [], // No extensions installed
+          fields: [],
+        }),
+      }
+
+      manager.setPGlite(mockPGlite)
+
+      const result = await manager.unloadLeastImportantExtension()
+
+      expect(result.success).toBe(false)
+      expect(result.error).toBe('No extensions available to unload')
+    })
+
+    it('should clear unloaded extensions list', () => {
+      // Manually add to unloaded set via internal state
+      manager['unloadedExtensions'].add('test-ext')
+
+      expect(manager.wasExtensionUnloaded('test-ext')).toBe(true)
+
+      manager.clearUnloadedExtensions()
+
+      expect(manager.wasExtensionUnloaded('test-ext')).toBe(false)
+      expect(manager.getUnloadedExtensions()).toHaveLength(0)
+    })
+
+    it('should use custom extension priority', async () => {
+      const customManager = new MemoryPressureManager({
+        extensionUnloadPriority: ['vector', 'pg_trgm', 'hstore'],
+      })
+
+      const mockPGlite = {
+        query: vi.fn()
+          .mockResolvedValueOnce({
+            rows: [
+              { extname: 'vector' },
+              { extname: 'pg_trgm' },
+              { extname: 'hstore' },
+            ],
+            fields: [],
+          })
+          .mockResolvedValueOnce({ rows: [], fields: [] }),
+      }
+
+      customManager.setPGlite(mockPGlite)
+
+      const result = await customManager.unloadLeastImportantExtension()
+
+      expect(result.extensionName).toBe('vector') // First in custom priority
+
+      customManager.dispose()
+    })
+  })
+
+  describe('forced pressure for testing', () => {
+    it('should force pressure level and emit event', () => {
+      const listener = vi.fn()
+      manager.onPressureChange(listener)
+
+      const event = manager._forceMemoryPressure('critical')
+
+      expect(event).not.toBeNull()
+      expect(event!.currentLevel).toBe('critical')
+      expect(listener).toHaveBeenCalled()
+    })
+
+    it('should return null when forcing same level', () => {
+      manager._forceMemoryPressure('warning')
+
+      const event = manager._forceMemoryPressure('warning')
+
+      expect(event).toBeNull()
+    })
+
+    it('should calculate correct usage stats for forced levels', () => {
+      const event = manager._forceMemoryPressure('oom')
+
+      expect(event!.stats.usagePercent).toBe(96)
+      expect(event!.stats.pressureLevel).toBe('oom')
+    })
+  })
+
+  describe('createMemoryPressureManager factory', () => {
+    it('should create manager with default config', () => {
+      const created = createMemoryPressureManager()
+      expect(created).toBeInstanceOf(MemoryPressureManager)
+      created.dispose()
+    })
+
+    it('should create manager with custom config', () => {
+      const created = createMemoryPressureManager({
+        warningThresholdPercent: 50,
+      })
+
+      expect(created.getConfig().warningThresholdPercent).toBe(50)
+      created.dispose()
+    })
+  })
+})
+
+// Mock cloudflare:workers
+vi.mock('cloudflare:workers', () => ({
+  DurableObject: class DurableObject {
+    ctx: unknown
+    env: unknown
+    constructor(ctx: unknown, env: unknown) {
+      this.ctx = ctx
+      this.env = env
+    }
+  },
+}))
+
+// Mock WASM and data imports
+vi.mock('../pglite-assets/pglite.wasm', () => ({ default: {} }))
+vi.mock('../pglite-assets/pglite.data', () => ({ default: {} }))
+
+// Mock workers-pglite
+vi.mock('../pglite/workers-pglite', () => ({
+  createWorkersPGLite: vi.fn(),
+  WorkersPGLite: class {},
+}))
+
+import { PostgresDO, createPostgresDOWithMemoryProtection } from './do'
+import type { Env } from './types'
+
+describe('PostgresDO Memory Pressure Integration', () => {
+
+  const createMockState = () => ({
+    id: {
+      toString: () => 'test-do-id',
+      name: 'test-database',
+    },
+    storage: {
+      get: vi.fn(),
+      put: vi.fn(),
+      delete: vi.fn(),
+      list: vi.fn(() => Promise.resolve(new Map())),
+      getAlarm: vi.fn(),
+      setAlarm: vi.fn(),
+      deleteAlarm: vi.fn(),
+    },
+    blockConcurrencyWhile: vi.fn((fn) => fn()),
+    waitUntil: vi.fn(),
+    acceptWebSocket: vi.fn(),
+    getWebSockets: vi.fn(() => []),
+  })
+
+  const createMockPGlite = () => ({
+    query: vi.fn(() => Promise.resolve({
+      rows: [],
+      fields: [],
+      affectedRows: 0,
+    })),
+    exec: vi.fn(() => Promise.resolve({ rows: [], fields: [] })),
+    close: vi.fn(() => Promise.resolve()),
+    ready: Promise.resolve(),
+  })
+
+  const createMockEnv = (): Env => ({
+    POSTGRES_DO: {} as DurableObjectNamespace,
+    POSTGRES_DEFAULT_DB: 'postgres',
+  })
+
+  describe('memory pressure methods on PostgresDO', () => {
+    it('should expose getMemoryStats method', () => {
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDO(state as any, env)
+
+      const stats = doo.getMemoryStats()
+
+      expect(stats).toHaveProperty('heapUsed')
+      expect(stats).toHaveProperty('heapLimit')
+      expect(stats).toHaveProperty('usagePercent')
+      expect(stats).toHaveProperty('pressureLevel')
+    })
+
+    it('should expose getMemoryPressureLevel method', () => {
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDO(state as any, env)
+
+      const level = doo.getMemoryPressureLevel()
+
+      expect(['normal', 'warning', 'critical', 'oom']).toContain(level)
+    })
+
+    it('should expose onMemoryPressure for event listening', () => {
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDO(state as any, env)
+
+      const listener = vi.fn()
+      const unsubscribe = doo.onMemoryPressure(listener)
+
+      expect(typeof unsubscribe).toBe('function')
+      expect(doo.getMemoryPressureListenerCount()).toBe(1)
+
+      unsubscribe()
+      expect(doo.getMemoryPressureListenerCount()).toBe(0)
+    })
+
+    it('should allow configuring memory pressure settings', () => {
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDO(state as any, env)
+
+      doo.setMemoryPressureConfig({
+        warningThresholdPercent: 60,
+        criticalThresholdPercent: 75,
+      })
+
+      const config = doo.getMemoryPressureConfig()
+      expect(config.warningThresholdPercent).toBe(60)
+      expect(config.criticalThresholdPercent).toBe(75)
+    })
+
+    it('should track unloaded extensions', async () => {
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDO(state as any, env)
+
+      const mockPGlite = createMockPGlite()
+      mockPGlite.query
+        .mockResolvedValueOnce({
+          rows: [{ extname: 'tablefunc' }],
+          fields: [],
+          affectedRows: 0,
+        })
+        .mockResolvedValueOnce({ rows: [], fields: [], affectedRows: 0 })
+
+      vi.spyOn(doo as any, 'createPGliteInstance').mockResolvedValue(mockPGlite)
+      await doo.initPGlite()
+
+      const result = await doo.unloadExtensionForMemory()
+
+      expect(result.success).toBe(true)
+      expect(doo.wasExtensionUnloaded('tablefunc')).toBe(true)
+      expect(doo.getUnloadedExtensions()).toContain('tablefunc')
+    })
+  })
+
+  describe('createPostgresDOWithMemoryProtection factory', () => {
+    it('should create PostgresDO with memory protection enabled', () => {
+      const PostgresDOClass = createPostgresDOWithMemoryProtection({
+        database: 'testdb',
+      })
+
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDOClass(state as any, env)
+
+      const config = doo.getMemoryPressureConfig()
+      expect(config.enabled).toBe(true)
+      expect(config.autoUnloadExtensions).toBe(true)
+    })
+
+    it('should accept custom memory pressure config', () => {
+      const PostgresDOClass = createPostgresDOWithMemoryProtection(
+        { database: 'testdb' },
+        {
+          warningThresholdPercent: 50,
+          criticalThresholdPercent: 70,
+        }
+      )
+
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDOClass(state as any, env)
+
+      const config = doo.getMemoryPressureConfig()
+      expect(config.warningThresholdPercent).toBe(50)
+      expect(config.criticalThresholdPercent).toBe(70)
+    })
+  })
+
+  describe('shutdown integration', () => {
+    it('should dispose memory manager on shutdown', async () => {
+      const state = createMockState()
+      const env = createMockEnv()
+      const doo = new PostgresDO(state as any, env)
+
+      const mockPGlite = createMockPGlite()
+      vi.spyOn(doo as any, 'createPGliteInstance').mockResolvedValue(mockPGlite)
+      await doo.initPGlite()
+
+      // Add a listener to verify disposal
+      const listener = vi.fn()
+      doo.onMemoryPressure(listener)
+      expect(doo.getMemoryPressureListenerCount()).toBe(1)
+
+      await doo.shutdown({ gracePeriodMs: 100 })
+
+      // After shutdown, accessing the memory manager should create a new one
+      // with zero listeners
+      expect(doo.getMemoryPressureListenerCount()).toBe(0)
+    })
+  })
+})
+
+/**
+ * ========================================================================
+ * RED TESTS: Memory Pressure + Tiered Storage Demotion Integration
+ * Issue: postgres-ksrv - Integrate memory pressure with tiered storage
+ *
+ * These tests define the expected behavior for:
+ * 1. Demotion triggers on memory pressure
+ * 2. Connection to TieredStorageOrchestrator
+ * 3. Metrics for pressure-triggered demotions
+ * 4. Memory pressure scenarios
+ * ========================================================================
+ */
+describe('MemoryPressureManager - Tiered Storage Integration [GREEN - postgres-ksrv]', () => {
+  let manager: MemoryPressureManager
+
+  beforeEach(() => {
+    manager = new MemoryPressureManager()
+  })
+
+  afterEach(() => {
+    manager.dispose()
+  })
+
+  describe('setTieredStorageOrchestrator()', () => {
+    it('should accept a TieredStorageOrchestrator instance', () => {
+      const mockOrchestrator = createMockOrchestrator()
+
+      // This method should exist to connect the orchestrator
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Should not throw
+      expect(manager.hasTieredStorageOrchestrator()).toBe(true)
+    })
+
+    it('should allow null to disconnect orchestrator', () => {
+      const mockOrchestrator = createMockOrchestrator()
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+      expect(manager.hasTieredStorageOrchestrator()).toBe(true)
+
+      manager.setTieredStorageOrchestrator(null)
+      expect(manager.hasTieredStorageOrchestrator()).toBe(false)
+    })
+  })
+
+  describe('pressure-triggered demotion', () => {
+    it('should trigger hot tier demotion on warning pressure', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Configure to trigger demotion on warning
+      manager.setConfig({
+        warningThresholdPercent: 70,
+      })
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+
+      // Allow async demotion to complete
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should have triggered hot tier demotion
+      expect(mockOrchestrator.evictLRUFromHot).toHaveBeenCalled()
+    })
+
+    it('should trigger aggressive demotion on critical pressure', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force critical pressure
+      manager._forceMemoryPressure('critical')
+
+      // Allow async demotion to complete
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should have triggered both hot and warm tier demotions
+      expect(mockOrchestrator.evictLRUFromHot).toHaveBeenCalled()
+      expect(mockOrchestrator.runDemotionCycle).toHaveBeenCalled()
+    })
+
+    it('should trigger emergency demotion on OOM pressure', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force OOM pressure
+      manager._forceMemoryPressure('oom')
+
+      // Allow async demotion to complete
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should have triggered aggressive demotions with higher counts
+      expect(mockOrchestrator.evictLRUFromHot).toHaveBeenCalledWith(
+        expect.any(Number)
+      )
+      // On OOM, we should demote more aggressively (higher count)
+      const callArgs = mockOrchestrator.evictLRUFromHot.mock.calls[0]
+      expect(callArgs[0]).toBeGreaterThan(10) // Emergency eviction count
+    })
+
+    it('should not trigger demotion on normal pressure', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning first, then back to normal
+      manager._forceMemoryPressure('warning')
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Clear mock calls
+      mockOrchestrator.evictLRUFromHot.mockClear()
+      mockOrchestrator.runDemotionCycle.mockClear()
+
+      // Force normal pressure
+      manager._forceMemoryPressure('normal')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should NOT have triggered any demotions
+      expect(mockOrchestrator.evictLRUFromHot).not.toHaveBeenCalled()
+      expect(mockOrchestrator.runDemotionCycle).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('demotion configuration', () => {
+    it('should respect autoDemoteOnPressure config option', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+
+      // Create manager with auto-demotion disabled
+      const customManager = new MemoryPressureManager({
+        autoDemoteOnPressure: false,
+      })
+      customManager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force critical pressure
+      customManager._forceMemoryPressure('critical')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should NOT have triggered any demotions
+      expect(mockOrchestrator.evictLRUFromHot).not.toHaveBeenCalled()
+      expect(mockOrchestrator.runDemotionCycle).not.toHaveBeenCalled()
+
+      customManager.dispose()
+    })
+
+    it('should allow configuring demotion counts per pressure level', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+
+      const customManager = new MemoryPressureManager({
+        demotionConfig: {
+          warning: { hotEvictCount: 5, warmDemoteCount: 0 },
+          critical: { hotEvictCount: 20, warmDemoteCount: 10 },
+          oom: { hotEvictCount: 50, warmDemoteCount: 25 },
+        },
+      })
+      customManager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning pressure
+      customManager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      expect(mockOrchestrator.evictLRUFromHot).toHaveBeenCalledWith(5)
+
+      customManager.dispose()
+    })
+  })
+
+  describe('demotion metrics', () => {
+    it('should track pressure-triggered demotion count', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+        { key: 'page-2', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      const metrics = manager.getDemotionMetrics()
+      expect(metrics.pressureTriggeredDemotions).toBeGreaterThan(0)
+    })
+
+    it('should track demotions by pressure level', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Force critical pressure
+      manager._forceMemoryPressure('critical')
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      const metrics = manager.getDemotionMetrics()
+      expect(metrics.demotionsByPressureLevel.warning).toBeGreaterThanOrEqual(0)
+      expect(metrics.demotionsByPressureLevel.critical).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should track demotion failures', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: false, error: 'Test error', timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      const metrics = manager.getDemotionMetrics()
+      expect(metrics.failedDemotions).toBeGreaterThan(0)
+    })
+
+    it('should track bytes freed by demotions', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+      // Mock the index entry to have size info
+      mockOrchestrator.getIndexEntry = vi.fn().mockReturnValue({
+        key: 'page-1',
+        tier: 'hot',
+        size: 8192,
+        lastAccess: Date.now(),
+        accessCount: 1,
+        created: Date.now(),
+        modified: Date.now(),
+        dirty: false,
+      })
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      const metrics = manager.getDemotionMetrics()
+      expect(metrics.bytesFreedByDemotion).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should include demotion metrics in Prometheus export', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      const prometheusMetrics = manager.exportPrometheusMetrics()
+
+      expect(prometheusMetrics).toContain('postgres_memory_pressure_demotions_total')
+    })
+
+    it('should include demotion metrics in JSON export', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      const jsonMetrics = manager.exportJSONMetrics()
+
+      expect(jsonMetrics.aggregates).toHaveProperty('pressureTriggeredDemotions')
+    })
+  })
+
+  describe('demotion callbacks', () => {
+    it('should emit demotion event when pressure-triggered demotion occurs', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      const demotionListener = vi.fn()
+      manager.onPressureDemotion(demotionListener)
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      expect(demotionListener).toHaveBeenCalledWith(
+        expect.objectContaining({
+          pressureLevel: 'warning',
+          demotions: expect.any(Array),
+          totalDemoted: expect.any(Number),
+        })
+      )
+    })
+
+    it('should allow unsubscribing from demotion events', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      const demotionListener = vi.fn()
+      const unsubscribe = manager.onPressureDemotion(demotionListener)
+
+      unsubscribe()
+
+      // Force warning pressure
+      manager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      expect(demotionListener).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('manual demotion trigger', () => {
+    it('should allow manually triggering demotions', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Manually trigger demotion
+      const result = await manager.triggerDemotion({
+        hotEvictCount: 5,
+        warmDemoteCount: 2,
+      })
+
+      expect(result.success).toBe(true)
+      expect(result.demotedCount).toBeGreaterThan(0)
+      expect(mockOrchestrator.evictLRUFromHot).toHaveBeenCalledWith(5)
+    })
+
+    it('should return error when orchestrator not connected', async () => {
+      // No orchestrator connected
+
+      const result = await manager.triggerDemotion({
+        hotEvictCount: 5,
+        warmDemoteCount: 2,
+      })
+
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('orchestrator')
+    })
+  })
+
+  describe('memory pressure scenarios', () => {
+    it('should handle rapid pressure escalation', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      let demotionCount = 0
+      mockOrchestrator.evictLRUFromHot.mockImplementation(() => {
+        demotionCount++
+        return Promise.resolve([
+          { key: `page-${demotionCount}`, fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+        ])
+      })
+
+      manager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Rapid escalation: normal -> warning -> critical -> oom
+      manager._forceMemoryPressure('warning')
+      await new Promise(resolve => setTimeout(resolve, 5))
+      manager._forceMemoryPressure('critical')
+      await new Promise(resolve => setTimeout(resolve, 5))
+      manager._forceMemoryPressure('oom')
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should have triggered multiple demotions
+      expect(mockOrchestrator.evictLRUFromHot.mock.calls.length).toBeGreaterThanOrEqual(3)
+    })
+
+    it('should handle pressure oscillation without thrashing', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      mockOrchestrator.evictLRUFromHot.mockResolvedValue([
+        { key: 'page-1', fromTier: 'hot', toTier: 'warm', success: true, timestamp: Date.now(), reason: 'lru_eviction' },
+      ])
+
+      // Configure with minimum interval between demotions
+      const customManager = new MemoryPressureManager({
+        demotionMinIntervalMs: 1000, // 1 second minimum between demotions
+      })
+      customManager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Oscillate between warning and normal rapidly
+      customManager._forceMemoryPressure('warning')
+      await new Promise(resolve => setTimeout(resolve, 10))
+      customManager._forceMemoryPressure('normal')
+      await new Promise(resolve => setTimeout(resolve, 10))
+      customManager._forceMemoryPressure('warning')
+      await new Promise(resolve => setTimeout(resolve, 10))
+      customManager._forceMemoryPressure('normal')
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // Should only have triggered demotion once due to rate limiting
+      expect(mockOrchestrator.evictLRUFromHot.mock.calls.length).toBeLessThanOrEqual(2)
+
+      customManager.dispose()
+    })
+
+    it('should coordinate with GC hints before demotion', async () => {
+      const mockOrchestrator = createMockOrchestrator()
+      const gcHintCalled = vi.fn()
+
+      const customManager = new MemoryPressureManager({
+        onGCHint: gcHintCalled,
+        gcBeforeDemotion: true, // Try GC before demotion
+      })
+      customManager.setTieredStorageOrchestrator(mockOrchestrator)
+
+      // Force warning pressure
+      customManager._forceMemoryPressure('warning')
+
+      await new Promise(resolve => setTimeout(resolve, 10))
+
+      // GC hint should be called before demotion
+      expect(gcHintCalled).toHaveBeenCalled()
+
+      customManager.dispose()
+    })
+  })
+})
+
+// Helper function to create a mock TieredStorageOrchestrator
+function createMockOrchestrator() {
+  return {
+    evictLRUFromHot: vi.fn().mockResolvedValue([]),
+    runDemotionCycle: vi.fn().mockResolvedValue([]),
+    demoteFromHot: vi.fn().mockResolvedValue({ success: true }),
+    demoteFromWarm: vi.fn().mockResolvedValue({ success: true }),
+    getIndexEntry: vi.fn().mockReturnValue(undefined),
+    getStats: vi.fn().mockReturnValue({
+      index: { totalEntries: 0, byTier: { hot: 0, warm: 0, cold: 0 }, totalSize: 0, dirtyEntries: 0, memoryBytes: 0 },
+      hot: { hits: 0, misses: 0, writes: 0, bytesRead: 0, bytesWritten: 0, errors: 0, hitRatio: 0 },
+      warm: { reads: 0, writes: 0, deletes: 0, bytesRead: 0, bytesWritten: 0 },
+      cold: { reads: 0, writes: 0, deletes: 0, bytesRead: 0, bytesWritten: 0, rangeReads: 0, errors: 0, headRequests: 0, listRequests: 0 },
+      promotions: { coldToWarm: 0, warmToHot: 0, failed: 0 },
+      demotions: { hotToWarm: 0, warmToCold: 0, failed: 0 },
+      health: { hot: 'healthy', warm: 'healthy', cold: 'healthy' },
+      errors: { hot: 0, warm: 0, cold: 0 },
+    }),
+    read: vi.fn(),
+    write: vi.fn(),
+    delete: vi.fn(),
+    promoteToHot: vi.fn(),
+    promoteToWarm: vi.fn(),
+    hasInIndex: vi.fn(),
+    getTier: vi.fn(),
+    clearIndex: vi.fn(),
+    resetStats: vi.fn(),
+    resetHealth: vi.fn(),
+    getConfig: vi.fn(),
+    onMigration: vi.fn(),
+    onError: vi.fn(),
+    onCircuitBreakerChange: vi.fn(),
+    syncDirtyToCold: vi.fn(),
+  } as unknown as any
+}
+
+/**
+ * ========================================================================
+ * REFACTOR TESTS: Optimized Memory Pressure Heuristics
+ * Issue: postgres-ksrv.3 - Optimize memory pressure heuristics
+ *
+ * These tests verify the optimized heuristics:
+ * 1. Smoothed pressure detection (EMA)
+ * 2. Adaptive thresholds
+ * 3. Improved OOM prediction
+ * 4. Enhanced metrics
+ * ========================================================================
+ */
+describe('MemoryPressureManager - Optimized Heuristics [REFACTOR - postgres-ksrv.3]', () => {
+  let manager: MemoryPressureManager
+
+  beforeEach(() => {
+    manager = new MemoryPressureManager()
+  })
+
+  afterEach(() => {
+    manager.dispose()
+  })
+
+  describe('Smoothed Pressure Detection (EMA)', () => {
+    it('should provide smoothed pressure state', () => {
+      const state = manager.getSmoothedPressureState()
+
+      expect(state).toHaveProperty('emaHeapUsage')
+      expect(state).toHaveProperty('emaPressureLevel')
+      expect(state).toHaveProperty('recentVariance')
+      expect(state).toHaveProperty('trend')
+      expect(state).toHaveProperty('lastRawHeapUsage')
+    })
+
+    it('should update EMA when recording samples', () => {
+      // Force heap usage for testing
+      manager._setCurrentHeapUsage(60 * 1024 * 1024) // 60MB
+      manager.recordMetricSample()
+
+      const state1 = manager.getSmoothedPressureState()
+
+      // Increase heap usage
+      manager._setCurrentHeapUsage(70 * 1024 * 1024) // 70MB
+      manager.recordMetricSample()
+
+      const state2 = manager.getSmoothedPressureState()
+
+      // EMA should have increased
+      expect(state2.emaHeapUsage).toBeGreaterThan(state1.emaHeapUsage)
+    })
+
+    it('should provide smoothed pressure level', () => {
+      const level = manager.getSmoothedPressureLevel()
+      expect(['normal', 'warning', 'critical', 'oom']).toContain(level)
+    })
+
+    it('should detect pressure volatility', () => {
+      // Record samples with varying heap usage to simulate volatility
+      for (let i = 0; i < 10; i++) {
+        const baseUsage = 60 * 1024 * 1024
+        // Alternate high variance
+        const variance = i % 2 === 0 ? 10 * 1024 * 1024 : -10 * 1024 * 1024
+        manager._setCurrentHeapUsage(baseUsage + variance)
+        manager.recordMetricSample()
+      }
+
+      // With high variance, should be volatile
+      const isVolatile = manager.isPressureVolatile()
+      expect(typeof isVolatile).toBe('boolean')
+    })
+  })
+
+  describe('Adaptive Thresholds', () => {
+    it('should return base thresholds with insufficient data', () => {
+      const thresholds = manager.getAdaptiveThresholds()
+
+      expect(thresholds.warningThresholdPercent).toBe(70)
+      expect(thresholds.criticalThresholdPercent).toBe(85)
+      expect(thresholds.oomThresholdPercent).toBe(95)
+    })
+
+    it('should adjust thresholds based on growth rate', async () => {
+      // Record enough samples to enable adaptive thresholds
+      // Simulate rapid growth with time spread
+      for (let i = 0; i < 10; i++) {
+        manager._setCurrentHeapUsage(50 * 1024 * 1024 + i * 5 * 1024 * 1024)
+        manager.recordMetricSample()
+        // Add small delay to spread timestamps for growth rate calculation
+        await new Promise(resolve => setTimeout(resolve, 5))
+      }
+
+      const thresholds = manager.getAdaptiveThresholds()
+
+      // With samples, thresholds should be within valid range
+      // (exact value depends on calculated growth rate and volatility)
+      expect(thresholds.warningThresholdPercent).toBeGreaterThanOrEqual(50)
+      expect(thresholds.warningThresholdPercent).toBeLessThanOrEqual(80)
+    })
+
+    it('should provide adaptive pressure level', () => {
+      const level = manager.getAdaptivePressureLevel()
+      expect(['normal', 'warning', 'critical', 'oom']).toContain(level)
+    })
+  })
+
+  describe('Improved OOM Prediction', () => {
+    it('should return enhanced OOM prediction', () => {
+      const prediction = manager.predictTimeToOOM()
+
+      expect(prediction).toHaveProperty('estimatedMs')
+      expect(prediction).toHaveProperty('confidence')
+      expect(prediction).toHaveProperty('willOOM')
+      // Enhanced fields are optional
+      expect(typeof prediction.estimatedMs).toBe('number')
+      expect(typeof prediction.confidence).toBe('number')
+      expect(typeof prediction.willOOM).toBe('boolean')
+    })
+
+    it('should have low confidence with few samples', () => {
+      const prediction = manager.predictTimeToOOM()
+      expect(prediction.confidence).toBe(0)
+    })
+
+    it('should increase confidence with more samples', async () => {
+      // Record multiple samples with consistent growth and time spread
+      for (let i = 0; i < 15; i++) {
+        manager._setCurrentHeapUsage(50 * 1024 * 1024 + i * 2 * 1024 * 1024)
+        manager.recordMetricSample()
+        // Add small delay for time spread
+        await new Promise(resolve => setTimeout(resolve, 5))
+      }
+
+      const prediction = manager.predictTimeToOOM()
+      // With samples, should have some confidence (may be 0 if growth rate is low)
+      expect(prediction.confidence).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should return Infinity when not growing', () => {
+      // Record samples with stable/decreasing memory
+      for (let i = 0; i < 10; i++) {
+        manager._setCurrentHeapUsage(60 * 1024 * 1024 - i * 1024 * 1024)
+        manager.recordMetricSample()
+      }
+
+      const prediction = manager.predictTimeToOOM()
+      expect(prediction.estimatedMs).toBe(Infinity)
+      expect(prediction.willOOM).toBe(false)
+    })
+
+    it('should predict OOM when growing rapidly', async () => {
+      // Simulate rapid memory growth towards OOM with time spread
+      const memoryLimit = 128 * 1024 * 1024
+      for (let i = 0; i < 15; i++) {
+        // Start at 80% and grow rapidly
+        const usage = memoryLimit * 0.8 + i * 1024 * 1024
+        manager._setCurrentHeapUsage(usage)
+        manager.recordMetricSample()
+        // Add small delay for time spread
+        await new Promise(resolve => setTimeout(resolve, 5))
+      }
+
+      const prediction = manager.predictTimeToOOM()
+      // With rapid growth and time spread, should predict OOM or at least have valid estimate
+      expect(prediction).toHaveProperty('estimatedMs')
+      expect(typeof prediction.estimatedMs).toBe('number')
+    })
+  })
+
+  describe('Enhanced Metrics', () => {
+    it('should include heuristics in JSON export', () => {
+      const metrics = manager.exportJSONMetrics()
+
+      expect(metrics).toHaveProperty('heuristics')
+      expect(metrics.heuristics).toHaveProperty('smoothedState')
+      expect(metrics.heuristics).toHaveProperty('adaptiveThresholds')
+      expect(metrics.heuristics).toHaveProperty('oomPrediction')
+      expect(metrics.heuristics).toHaveProperty('growthRate')
+      expect(metrics.heuristics).toHaveProperty('isVolatile')
+    })
+
+    it('should include growth rate metrics in Prometheus export', () => {
+      const prometheus = manager.exportPrometheusMetrics()
+
+      expect(prometheus).toContain('postgres_memory_growth_rate_bytes_per_sec')
+      expect(prometheus).toContain('postgres_memory_growth_trend')
+      expect(prometheus).toContain('postgres_memory_oom_prediction_ms')
+      expect(prometheus).toContain('postgres_memory_oom_prediction_confidence')
+    })
+
+    it('should include EMA metrics in Prometheus export', () => {
+      const prometheus = manager.exportPrometheusMetrics()
+
+      expect(prometheus).toContain('postgres_memory_heap_ema_bytes')
+      expect(prometheus).toContain('postgres_memory_pressure_volatile')
+    })
+
+    it('should include adaptive threshold metrics in Prometheus export', () => {
+      const prometheus = manager.exportPrometheusMetrics()
+
+      expect(prometheus).toContain('postgres_memory_adaptive_warning_threshold')
+      expect(prometheus).toContain('postgres_memory_adaptive_critical_threshold')
+    })
+  })
+
+  describe('Memory Growth Rate Calculation', () => {
+    it('should return stable for no samples', () => {
+      const rate = manager.getMemoryGrowthRate()
+      expect(rate.trend).toBe('stable')
+      expect(rate.bytesPerSecond).toBe(0)
+    })
+
+    it('should detect increasing trend', async () => {
+      // Record samples with increasing memory and time spread
+      for (let i = 0; i < 10; i++) {
+        manager._setCurrentHeapUsage(50 * 1024 * 1024 + i * 5 * 1024 * 1024)
+        manager.recordMetricSample()
+        // Add small delay for time spread
+        await new Promise(resolve => setTimeout(resolve, 5))
+      }
+
+      const rate = manager.getMemoryGrowthRate()
+      // With time spread, should detect trend or at least positive rate
+      expect(rate.bytesPerSecond).toBeGreaterThanOrEqual(0)
+      expect(['stable', 'increasing']).toContain(rate.trend)
+    })
+
+    it('should detect decreasing trend', async () => {
+      // Record samples with decreasing memory and time spread
+      for (let i = 0; i < 10; i++) {
+        manager._setCurrentHeapUsage(90 * 1024 * 1024 - i * 5 * 1024 * 1024)
+        manager.recordMetricSample()
+        // Add small delay for time spread
+        await new Promise(resolve => setTimeout(resolve, 5))
+      }
+
+      const rate = manager.getMemoryGrowthRate()
+      // With time spread, should detect trend or at least negative rate
+      expect(rate.bytesPerSecond).toBeLessThanOrEqual(0)
+      expect(['stable', 'decreasing']).toContain(rate.trend)
+    })
+
+    it('should handle stable memory usage', () => {
+      // Record samples with stable memory (small variations)
+      for (let i = 0; i < 10; i++) {
+        manager._setCurrentHeapUsage(60 * 1024 * 1024 + (i % 2 === 0 ? 100 : -100))
+        manager.recordMetricSample()
+      }
+
+      const rate = manager.getMemoryGrowthRate()
+      expect(rate.trend).toBe('stable')
+    })
+  })
+
+  describe('Heap Sampling Performance', () => {
+    it('should handle empty heap', () => {
+      // Create manager with mock WASM module
+      const mockHeap = new Uint8Array(0)
+      manager.setWasmHeapSource({ HEAPU8: mockHeap })
+
+      const stats = manager.getMemoryStats()
+      expect(stats.heapUsed).toBe(0)
+    })
+
+    it('should sample large heap efficiently', () => {
+      // Create a large mock heap (64MB)
+      const heapSize = 64 * 1024 * 1024
+      const mockHeap = new Uint8Array(heapSize)
+
+      // Fill ~50% with non-zero data
+      for (let i = 0; i < heapSize; i += 2) {
+        mockHeap[i] = 1
+      }
+
+      manager.setWasmHeapSource({ HEAPU8: mockHeap })
+
+      const start = performance.now()
+      const stats = manager.getMemoryStats()
+      const duration = performance.now() - start
+
+      // Sampling should be fast (< 50ms for 64MB heap in test environment)
+      expect(duration).toBeLessThan(50)
+
+      // Stats should be returned (exact value depends on sampling algorithm)
+      expect(stats).toHaveProperty('heapUsed')
+      expect(typeof stats.heapUsed).toBe('number')
+    })
+  })
+
+  describe('Pressure Level Hysteresis', () => {
+    it('should not oscillate near threshold boundaries', () => {
+      // Set heap just above warning threshold (70%)
+      const memoryLimit = 128 * 1024 * 1024
+      const warningThreshold = memoryLimit * 0.70
+
+      manager._setCurrentHeapUsage(warningThreshold + 1024)
+      manager.recordMetricSample()
+
+      const level1 = manager.getPressureLevel()
+      expect(level1).toBe('warning')
+
+      // Set heap just below warning threshold
+      manager._setCurrentHeapUsage(warningThreshold - 1024)
+      manager.recordMetricSample()
+
+      // With hysteresis, should stay at warning (within hysteresis band)
+      // Only the raw level changes, the smoothed level should be more stable
+      const smoothedLevel = manager.getSmoothedPressureLevel()
+      expect(['normal', 'warning']).toContain(smoothedLevel)
+    })
+  })
+})