@dotdo/postgres 0.1.0

package/src/pglite/cold-start-optimizer.test.ts

@@ -0,0 +1,937 @@
+/**
+ * Cold Start Optimizer Tests
+ *
+ * [GREEN PHASE] - Tests that verify cold start optimizations meet baselines.
+ *
+ * @issue postgres-w6l6
+ * @module pglite/cold-start-optimizer.test
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+import {
+  createColdStartOptimizer,
+  createColdStartOptimizerFactory,
+  createAutoTieredOptimizer,
+  clearWasmCache,
+  getWasmCacheStats,
+  getPooledBuffer,
+  returnPooledBuffer,
+  clearBufferPool,
+  profileWasmStrategy,
+  compareWasmStrategies,
+  formatProfilingResult,
+  type ColdStartConfig,
+  type ColdStartMetrics,
+  type ColdStartPhase,
+  type WasmLoadingStrategy,
+  type ColdStartProfilingResult,
+} from './cold-start-optimizer'
+
+// ============================================================================
+// Mock PGLite
+// ============================================================================
+
+vi.mock('@dotdo/pglite', () => ({
+  PGlite: {
+    create: vi.fn().mockImplementation(async (options) => {
+      // Simulate PGLite initialization time
+      await new Promise((resolve) => setTimeout(resolve, 50))
+      return {
+        query: vi.fn().mockResolvedValue({ rows: [{ result: 1 }] }),
+        exec: vi.fn().mockResolvedValue(undefined),
+        close: vi.fn().mockResolvedValue(undefined),
+      }
+    }),
+  },
+}))
+
+// ============================================================================
+// Mock Cache Layer
+// ============================================================================
+
+function createMockCacheLayer(data: Uint8Array | null = null) {
+  return {
+    get: vi.fn().mockResolvedValue(data),
+    put: vi.fn().mockResolvedValue(undefined),
+    has: vi.fn().mockResolvedValue(data !== null),
+    delete: vi.fn().mockResolvedValue(true),
+    getWithMetadata: vi.fn().mockResolvedValue(
+      data ? { data, metadata: { lastAccessed: Date.now(), accessCount: 1 } } : null
+    ),
+  }
+}
+
+// ============================================================================
+// Mock R2 Layer
+// ============================================================================
+
+function createMockR2Layer(data: Uint8Array | null = null) {
+  return {
+    get: vi.fn().mockResolvedValue(data),
+    put: vi.fn().mockResolvedValue(undefined),
+    has: vi.fn().mockResolvedValue(data !== null),
+    delete: vi.fn().mockResolvedValue(true),
+    list: vi.fn().mockResolvedValue({ objects: [], truncated: false }),
+    head: vi.fn().mockResolvedValue(
+      data
+        ? { key: 'test', size: data.length, etag: 'test', uploaded: new Date() }
+        : null
+    ),
+  }
+}
+
+// ============================================================================
+// Mock R2 Bucket
+// ============================================================================
+
+function createMockR2Bucket(data: Uint8Array | null = null): R2Bucket {
+  return {
+    get: vi.fn().mockResolvedValue(
+      data
+        ? {
+            arrayBuffer: () => Promise.resolve(data.buffer),
+            body: null,
+            bodyUsed: false,
+            httpEtag: 'test',
+            key: 'test',
+            size: data.length,
+            uploaded: new Date(),
+            etag: 'test',
+            version: 'test',
+            httpMetadata: {},
+            customMetadata: {},
+            range: undefined,
+            checksums: {},
+            storageClass: 'Standard' as const,
+            text: () => Promise.resolve(''),
+            json: () => Promise.resolve({}),
+            blob: () => Promise.resolve(new Blob()),
+            writeHttpMetadata: () => {},
+          }
+        : null
+    ),
+    put: vi.fn().mockResolvedValue(undefined),
+    delete: vi.fn().mockResolvedValue(undefined),
+    list: vi.fn().mockResolvedValue({ objects: [], truncated: false }),
+    head: vi.fn().mockResolvedValue(
+      data
+        ? { key: 'test', size: data.length, etag: 'test', uploaded: new Date() }
+        : null
+    ),
+    createMultipartUpload: vi.fn(),
+    resumeMultipartUpload: vi.fn(),
+  } as unknown as R2Bucket
+}
+
+// ============================================================================
+// Test Helpers
+// ============================================================================
+
+function createMockWasmModule(): WebAssembly.Module {
+  // Create a minimal valid WASM module
+  // Magic number (0x00 0x61 0x73 0x6D) + version (0x01 0x00 0x00 0x00)
+  const wasmBytes = new Uint8Array([0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00])
+  return new WebAssembly.Module(wasmBytes)
+}
+
+function createTestConfig(overrides: Partial<ColdStartConfig> = {}): ColdStartConfig {
+  return {
+    wasmModule: createMockWasmModule(),
+    debug: false,
+    ...overrides,
+  }
+}
+
+// ============================================================================
+// Tests
+// ============================================================================
+
+describe('ColdStartOptimizer', () => {
+  beforeEach(() => {
+    clearWasmCache()
+    clearBufferPool()
+    vi.clearAllMocks()
+  })
+
+  afterEach(() => {
+    clearWasmCache()
+    clearBufferPool()
+  })
+
+  describe('Basic Functionality', () => {
+    it('should create an optimizer instance', () => {
+      const optimizer = createColdStartOptimizer(createTestConfig())
+      expect(optimizer).toBeDefined()
+      expect(optimizer.isReady()).toBe(false)
+      expect(optimizer.getPhase()).toBe('not_started')
+    })
+
+    it('should initialize lazily by default', async () => {
+      const optimizer = createColdStartOptimizer(createTestConfig({ lazy: true }))
+
+      // Should not be initialized yet
+      expect(optimizer.isReady()).toBe(false)
+      expect(optimizer.getPhase()).toBe('not_started')
+
+      // First query should trigger initialization
+      await optimizer.query('SELECT 1')
+
+      expect(optimizer.isReady()).toBe(true)
+      expect(optimizer.getPhase()).toBe('ready')
+    })
+
+    it('should initialize eagerly when lazy=false', async () => {
+      const optimizer = createColdStartOptimizer(createTestConfig({ lazy: false }))
+
+      // Wait for initialization
+      await optimizer.initialize()
+
+      expect(optimizer.isReady()).toBe(true)
+      expect(optimizer.getPhase()).toBe('ready')
+    })
+
+    it('should return metrics after initialization', async () => {
+      const optimizer = createColdStartOptimizer(createTestConfig())
+
+      expect(optimizer.getMetrics()).toBeNull()
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics).not.toBeNull()
+      expect(metrics?.phase).toBe('ready')
+      expect(metrics?.totalMs).toBeGreaterThan(0)
+    })
+
+    it('should close properly', async () => {
+      const optimizer = createColdStartOptimizer(createTestConfig())
+
+      await optimizer.initialize()
+      expect(optimizer.isReady()).toBe(true)
+
+      await optimizer.close()
+
+      // After close, should throw on new operations
+      await expect(optimizer.query('SELECT 1')).rejects.toThrow('closed')
+    })
+  })
+
+  describe('WASM Caching', () => {
+    it('should cache PGLite instance for warm starts', async () => {
+      const config = createTestConfig({ database: 'test-db' })
+
+      // First optimizer - cold start
+      const optimizer1 = createColdStartOptimizer(config)
+      await optimizer1.initialize()
+
+      const metrics1 = optimizer1.getMetrics()
+      expect(metrics1?.isWarmStart).toBe(false)
+
+      // Second optimizer with same config - should be warm start
+      const optimizer2 = createColdStartOptimizer(config)
+      await optimizer2.initialize()
+
+      const metrics2 = optimizer2.getMetrics()
+      expect(metrics2?.isWarmStart).toBe(true)
+    })
+
+    it('should track WASM cache statistics', async () => {
+      const config = createTestConfig({ database: 'stats-db' })
+
+      // Initial state
+      let stats = getWasmCacheStats()
+      expect(stats.size).toBe(0)
+
+      // After cold start
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      stats = getWasmCacheStats()
+      expect(stats.size).toBe(1)
+      expect(stats.entries[0]?.reuseCount).toBe(0)
+
+      // After warm start
+      const optimizer2 = createColdStartOptimizer(config)
+      await optimizer2.initialize()
+
+      stats = getWasmCacheStats()
+      expect(stats.size).toBe(1)
+      expect(stats.entries[0]?.reuseCount).toBe(1)
+    })
+
+    it('should clear WASM cache', async () => {
+      const config = createTestConfig({ database: 'clear-db' })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      expect(getWasmCacheStats().size).toBe(1)
+
+      clearWasmCache()
+
+      expect(getWasmCacheStats().size).toBe(0)
+    })
+  })
+
+  describe('Parallel Data Fetching', () => {
+    it('should use hot data when provided', async () => {
+      const hotData = new Uint8Array([1, 2, 3, 4, 5])
+      const config = createTestConfig({ hotData })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataSource).toBe('hot')
+      expect(metrics?.dataSizeBytes).toBe(5)
+    })
+
+    it('should fetch from warm cache', async () => {
+      const warmData = new Uint8Array([10, 20, 30])
+      const cacheLayer = createMockCacheLayer(warmData)
+
+      const config = createTestConfig({
+        cacheLayer: cacheLayer as any,
+        warmCacheKey: 'test-warm-key',
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataSource).toBe('warm')
+      expect(metrics?.dataSizeBytes).toBe(3)
+      expect(cacheLayer.get).toHaveBeenCalledWith('test-warm-key')
+    })
+
+    it('should fetch from cold storage when warm misses', async () => {
+      const coldData = new Uint8Array([100, 200])
+      const cacheLayer = createMockCacheLayer(null) // Cache miss
+      const r2Layer = createMockR2Layer(coldData)
+
+      const config = createTestConfig({
+        cacheLayer: cacheLayer as any,
+        warmCacheKey: 'test-warm-key',
+        r2Layer: r2Layer as any,
+        coldStorageKey: 'test-cold-key',
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataSource).toBe('cold')
+      expect(metrics?.dataSizeBytes).toBe(2)
+    })
+
+    it('should handle R2 bucket directly', async () => {
+      const coldData = new Uint8Array([1, 2, 3, 4])
+      const r2Bucket = createMockR2Bucket(coldData)
+
+      const config = createTestConfig({
+        r2Bucket,
+        coldStorageKey: 'databases/test/data.tar',
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataSource).toBe('cold')
+      expect(r2Bucket.get).toHaveBeenCalledWith('databases/test/data.tar')
+    })
+
+    it('should return empty when no data sources available', async () => {
+      const config = createTestConfig({})
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataSource).toBe('empty')
+      expect(metrics?.dataSizeBytes).toBe(0)
+    })
+
+    it('should timeout on slow cold fetches', async () => {
+      const r2Layer = {
+        get: vi.fn().mockImplementation(
+          () => new Promise((resolve) => setTimeout(() => resolve(new Uint8Array([1])), 10000))
+        ),
+      }
+
+      const config = createTestConfig({
+        r2Layer: r2Layer as any,
+        coldStorageKey: 'slow-key',
+        coldFetchTimeoutMs: 100, // Very short timeout
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      // Should timeout and return empty
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataSource).toBe('empty')
+    })
+  })
+
+  describe('Lazy Initialization', () => {
+    it('should not initialize until first query', async () => {
+      const { PGlite } = await import('@dotdo/pglite')
+
+      const config = createTestConfig({ lazy: true })
+      const optimizer = createColdStartOptimizer(config)
+
+      // PGLite.create should not be called yet
+      expect(PGlite.create).not.toHaveBeenCalled()
+
+      // First query triggers init
+      await optimizer.query('SELECT 1')
+
+      expect(PGlite.create).toHaveBeenCalled()
+    })
+
+    it('should deduplicate concurrent initialization requests', async () => {
+      const { PGlite } = await import('@dotdo/pglite')
+
+      const config = createTestConfig({ lazy: true })
+      const optimizer = createColdStartOptimizer(config)
+
+      // Start multiple concurrent queries
+      const promises = [
+        optimizer.query('SELECT 1'),
+        optimizer.query('SELECT 2'),
+        optimizer.query('SELECT 3'),
+      ]
+
+      await Promise.all(promises)
+
+      // PGLite.create should only be called once
+      expect(PGlite.create).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('Pre-warming', () => {
+    it('should run prewarm queries by default', async () => {
+      const config = createTestConfig({ prewarm: true })
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+      const pglite = await optimizer.getInstance()
+
+      // Default prewarm queries: SELECT 1, SELECT current_database(), SELECT version()
+      expect(pglite.query).toHaveBeenCalledTimes(3)
+    })
+
+    it('should run custom prewarm queries', async () => {
+      const config = createTestConfig({
+        prewarm: true,
+        prewarmQueries: ['SELECT 1', 'SELECT 2'],
+      })
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+      const pglite = await optimizer.getInstance()
+
+      expect(pglite.query).toHaveBeenCalledTimes(2)
+    })
+
+    it('should skip prewarm when disabled', async () => {
+      const config = createTestConfig({ prewarm: false })
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+      const pglite = await optimizer.getInstance()
+
+      // No prewarm queries should be called
+      expect(pglite.query).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('Memory Optimization', () => {
+    it('should manage buffer pool', () => {
+      // Get a small buffer
+      const buffer1 = getPooledBuffer('small')
+      expect(buffer1.byteLength).toBe(4096)
+
+      // Return it to the pool
+      returnPooledBuffer(buffer1, 'small')
+
+      // Get it again - should be the same buffer
+      const buffer2 = getPooledBuffer('small')
+      expect(buffer2).toBe(buffer1)
+    })
+
+    it('should provide correct buffer sizes', () => {
+      const smallBuffer = getPooledBuffer('small')
+      expect(smallBuffer.byteLength).toBe(4096) // 4KB
+
+      const mediumBuffer = getPooledBuffer('medium')
+      expect(mediumBuffer.byteLength).toBe(65536) // 64KB
+
+      const largeBuffer = getPooledBuffer('large')
+      expect(largeBuffer.byteLength).toBe(1048576) // 1MB
+    })
+
+    it('should clear buffer pool', () => {
+      const buffer = getPooledBuffer('small')
+      returnPooledBuffer(buffer, 'small')
+
+      clearBufferPool()
+
+      // After clearing, should get a new buffer
+      const newBuffer = getPooledBuffer('small')
+      expect(newBuffer).not.toBe(buffer)
+    })
+  })
+
+  describe('Phase Callbacks', () => {
+    it('should call onPhaseChange callback', async () => {
+      const phases: ColdStartPhase[] = []
+      const config = createTestConfig({
+        onPhaseChange: (phase) => phases.push(phase),
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      expect(phases).toContain('wasm_loading')
+      expect(phases).toContain('parallel_loading')
+      expect(phases).toContain('pglite_init')
+      expect(phases).toContain('ready')
+    })
+
+    it('should call onReady callback with metrics', async () => {
+      let receivedMetrics: ColdStartMetrics | null = null
+      const config = createTestConfig({
+        onReady: (metrics) => {
+          receivedMetrics = metrics
+        },
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      expect(receivedMetrics).not.toBeNull()
+      expect(receivedMetrics?.phase).toBe('ready')
+    })
+
+    it('should call onError callback on failure', async () => {
+      // Mock PGLite to throw
+      const { PGlite } = await import('@dotdo/pglite')
+      vi.mocked(PGlite.create).mockRejectedValueOnce(new Error('Init failed'))
+
+      let receivedError: Error | null = null
+      const config = createTestConfig({
+        onError: (error) => {
+          receivedError = error
+        },
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+
+      await expect(optimizer.initialize()).rejects.toThrow('Init failed')
+      expect(receivedError?.message).toBe('Init failed')
+    })
+  })
+
+  describe('Factory Functions', () => {
+    it('should create optimizer factory', async () => {
+      const factory = createColdStartOptimizerFactory({
+        prewarm: false,
+        debug: false,
+      })
+
+      const optimizer = factory(createTestConfig())
+      await optimizer.initialize()
+
+      expect(optimizer.isReady()).toBe(true)
+    })
+
+    it('should create auto-tiered optimizer', async () => {
+      const r2Bucket = createMockR2Bucket(new Uint8Array([1, 2, 3]))
+
+      const optimizer = createAutoTieredOptimizer({
+        wasmModule: createMockWasmModule(),
+        databaseId: 'my-database',
+        env: { R2_BUCKET: r2Bucket },
+      })
+
+      await optimizer.initialize()
+
+      expect(optimizer.isReady()).toBe(true)
+      expect(r2Bucket.get).toHaveBeenCalledWith('databases/my-database/data.tar')
+    })
+  })
+
+  describe('Performance Baselines', () => {
+    it('should track data fetch timing', async () => {
+      const warmData = new Uint8Array([1, 2, 3])
+      const cacheLayer = createMockCacheLayer(warmData)
+
+      const config = createTestConfig({
+        cacheLayer: cacheLayer as any,
+        warmCacheKey: 'perf-test',
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.dataFetchMs).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should track PGLite init timing', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.pgliteInitMs).toBeGreaterThan(0)
+    })
+
+    it('should calculate total cold start time', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.totalMs).toBeGreaterThan(0)
+      // Total should be >= data fetch + pglite init
+      expect(metrics?.totalMs).toBeGreaterThanOrEqual(
+        metrics!.dataFetchMs + metrics!.pgliteInitMs
+      )
+    })
+  })
+
+  describe('Detailed Phase Timing Metrics', () => {
+    it('should include phase breakdown in metrics', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.phaseBreakdown).toBeDefined()
+      expect(Array.isArray(metrics?.phaseBreakdown)).toBe(true)
+      expect(metrics?.phaseBreakdown?.length).toBeGreaterThan(0)
+    })
+
+    it('should track WASM strategy in metrics', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.wasmStrategy).toBeDefined()
+      expect(metrics?.wasmStrategy?.strategy).toBe('static_import')
+      expect(metrics?.wasmStrategy?.fromCache).toBe(false)
+    })
+
+    it('should track tier fetch timings', async () => {
+      const warmData = new Uint8Array([1, 2, 3])
+      const cacheLayer = createMockCacheLayer(warmData)
+
+      const config = createTestConfig({
+        cacheLayer: cacheLayer as any,
+        warmCacheKey: 'tier-test',
+      })
+
+      const optimizer = createColdStartOptimizer(config)
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.tierFetchTimings).toBeDefined()
+      expect(metrics?.tierFetchTimings?.warm).toBeDefined()
+      expect(metrics?.tierFetchTimings?.warm?.attempted).toBe(true)
+      expect(metrics?.tierFetchTimings?.warm?.success).toBe(true)
+    })
+
+    it('should track PGLite import time separately', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.pgliteImportMs).toBeDefined()
+      expect(metrics?.pgliteImportMs).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should track individual prewarm query timings', async () => {
+      const config = createTestConfig({
+        prewarm: true,
+        prewarmQueries: ['SELECT 1', 'SELECT 2'],
+      })
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.prewarmTimings).toBeDefined()
+      expect(Array.isArray(metrics?.prewarmTimings)).toBe(true)
+      expect(metrics?.prewarmTimings?.length).toBe(2)
+      metrics?.prewarmTimings?.forEach((timing) => {
+        expect(timing.query).toBeDefined()
+        expect(timing.durationMs).toBeGreaterThanOrEqual(0)
+      })
+    })
+
+    it('should include sub-phases in phase breakdown', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      const pglitePhase = metrics?.phaseBreakdown?.find((p) => p.phase === 'pglite_init')
+      expect(pglitePhase?.subPhases).toBeDefined()
+      expect(pglitePhase?.subPhases?.length).toBeGreaterThan(0)
+
+      // Check for dynamic_import sub-phase
+      const importSubPhase = pglitePhase?.subPhases?.find((s) => s.name === 'dynamic_import')
+      expect(importSubPhase).toBeDefined()
+      expect(importSubPhase?.durationMs).toBeGreaterThanOrEqual(0)
+    })
+
+    it('should report cached strategy for warm starts', async () => {
+      const config = createTestConfig({ database: 'warm-strategy-test' })
+
+      // First optimizer - cold start
+      const optimizer1 = createColdStartOptimizer(config)
+      await optimizer1.initialize()
+
+      const metrics1 = optimizer1.getMetrics()
+      expect(metrics1?.wasmStrategy?.strategy).toBe('static_import')
+      expect(metrics1?.wasmStrategy?.fromCache).toBe(false)
+
+      // Second optimizer - warm start
+      const optimizer2 = createColdStartOptimizer(config)
+      await optimizer2.initialize()
+
+      const metrics2 = optimizer2.getMetrics()
+      expect(metrics2?.wasmStrategy?.strategy).toBe('cached')
+      expect(metrics2?.wasmStrategy?.fromCache).toBe(true)
+    })
+  })
+
+  describe('WASM Strategy Comparison', () => {
+    it('should profile a single WASM loading strategy', async () => {
+      const mockLoader = async () => {
+        await new Promise((resolve) => setTimeout(resolve, 10))
+        return createMockWasmModule()
+      }
+
+      const result = await profileWasmStrategy('static_import', mockLoader, 3)
+
+      expect(result.strategy).toBe('static_import')
+      expect(result.samples).toBe(3)
+      expect(result.meanMs).toBeGreaterThan(0)
+      expect(result.medianMs).toBeGreaterThan(0)
+      expect(result.p95Ms).toBeGreaterThan(0)
+      expect(result.minMs).toBeGreaterThan(0)
+      expect(result.maxMs).toBeGreaterThan(0)
+      expect(result.available).toBe(true)
+    })
+
+    it('should compare multiple WASM loading strategies', async () => {
+      const strategies = new Map<WasmLoadingStrategy, () => Promise<WebAssembly.Module | void>>([
+        [
+          'static_import',
+          async () => {
+            await new Promise((resolve) => setTimeout(resolve, 10))
+            return createMockWasmModule()
+          },
+        ],
+        [
+          'dynamic_import',
+          async () => {
+            await new Promise((resolve) => setTimeout(resolve, 15))
+            return createMockWasmModule()
+          },
+        ],
+      ])
+
+      const comparison = await compareWasmStrategies(strategies, 2)
+
+      expect(comparison.results.length).toBe(2)
+      expect(comparison.recommendation).toBeDefined()
+      expect(comparison.analysis).toBeDefined()
+      expect(comparison.analysis).toContain('WASM Loading Strategy Analysis')
+
+      // Static import should be baseline (no vsBaselinePercent)
+      const staticResult = comparison.results.find((r) => r.strategy === 'static_import')
+      expect(staticResult?.vsBaselinePercent).toBeUndefined()
+
+      // Dynamic import should have comparison percentage
+      const dynamicResult = comparison.results.find((r) => r.strategy === 'dynamic_import')
+      expect(dynamicResult?.vsBaselinePercent).toBeDefined()
+    })
+
+    it('should handle unavailable strategies gracefully', async () => {
+      const strategies = new Map<WasmLoadingStrategy, () => Promise<WebAssembly.Module | void>>([
+        ['static_import', async () => createMockWasmModule()],
+        [
+          'streaming',
+          async () => {
+            throw new Error('Streaming not available')
+          },
+        ],
+      ])
+
+      const comparison = await compareWasmStrategies(strategies, 2)
+
+      const streamingResult = comparison.results.find((r) => r.strategy === 'streaming')
+      expect(streamingResult?.available).toBe(false)
+      expect(streamingResult?.samples).toBe(0)
+    })
+  })
+
+  describe('Performance Regression Tests', () => {
+    const PERFORMANCE_BASELINES = {
+      wasmPrepMs: { p50: 300, p95: 500 },
+      pgliteInitMs: { p50: 500, p95: 800 },
+      firstQueryMs: { p50: 20, p95: 50 },
+      totalMs: { p50: 800, p95: 1500 },
+    }
+
+    it('should not regress on WASM preparation time', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.wasmPrepMs).toBeLessThan(PERFORMANCE_BASELINES.wasmPrepMs.p95)
+    })
+
+    it('should not regress on total cold start time', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      expect(metrics?.totalMs).toBeLessThan(PERFORMANCE_BASELINES.totalMs.p95)
+    })
+
+    it('should track performance variance (coefficient of variation)', async () => {
+      const samples: number[] = []
+
+      for (let i = 0; i < 5; i++) {
+        clearWasmCache()
+        const config = createTestConfig({ database: `variance-test-${i}` })
+        const optimizer = createColdStartOptimizer(config)
+        await optimizer.initialize()
+        const metrics = optimizer.getMetrics()
+        if (metrics) samples.push(metrics.totalMs)
+        await optimizer.close()
+      }
+
+      const mean = samples.reduce((a, b) => a + b, 0) / samples.length
+      const variance = samples.reduce((a, b) => a + Math.pow(b - mean, 2), 0) / samples.length
+      const stdDev = Math.sqrt(variance)
+      const cv = stdDev / mean
+
+      expect(cv).toBeLessThan(0.5)
+    })
+
+    it('should detect warm start performance improvement', async () => {
+      const config = createTestConfig({ database: 'warm-perf-test' })
+
+      clearWasmCache()
+      const coldOptimizer = createColdStartOptimizer(config)
+      await coldOptimizer.initialize()
+      const coldMetrics = coldOptimizer.getMetrics()
+
+      const warmOptimizer = createColdStartOptimizer(config)
+      await warmOptimizer.initialize()
+      const warmMetrics = warmOptimizer.getMetrics()
+
+      expect(warmMetrics?.isWarmStart).toBe(true)
+      expect(warmMetrics?.totalMs).toBeLessThan(coldMetrics!.totalMs)
+    })
+
+    it('should track memory usage for regression detection', async () => {
+      const config = createTestConfig()
+      const optimizer = createColdStartOptimizer(config)
+
+      await optimizer.initialize()
+
+      const metrics = optimizer.getMetrics()
+      if (typeof process !== 'undefined' && process.memoryUsage) {
+        expect(metrics?.memoryUsedMB).toBeDefined()
+        expect(metrics?.memoryUsedMB).toBeLessThan(64)
+      }
+    })
+  })
+
+  describe('Profiling Result Formatting', () => {
+    it('should format profiling results as readable string', () => {
+      const mockResult: ColdStartProfilingResult = {
+        samples: 5,
+        totalMs: {
+          mean: 100,
+          median: 95,
+          p95: 120,
+          p99: 130,
+          min: 80,
+          max: 140,
+          stdDev: 15,
+        },
+        phases: {
+          wasmPrep: { mean: 5, median: 5, p95: 8 },
+          dataFetch: { mean: 20, median: 18, p95: 25 },
+          pgliteInit: { mean: 60, median: 58, p95: 70 },
+          prewarm: { mean: 15, median: 14, p95: 17 },
+        },
+        dataSourceDistribution: { hot: 2, warm: 2, cold: 1 },
+        memoryMB: { mean: 32, max: 40 },
+        rawMetrics: [],
+      }
+
+      const formatted = formatProfilingResult(mockResult)
+
+      expect(formatted).toContain('Cold Start Profiling Results')
+      expect(formatted).toContain('Samples: 5')
+      expect(formatted).toContain('Mean: 100.00ms')
+      expect(formatted).toContain('Median (p50): 95.00ms')
+      expect(formatted).toContain('P95: 120.00ms')
+      expect(formatted).toContain('WASM Prep: 5.00ms')
+      expect(formatted).toContain('Data Fetch: 18.00ms')
+      expect(formatted).toContain('PGLite Init: 58.00ms')
+      expect(formatted).toContain('hot: 2')
+      expect(formatted).toContain('Memory Usage:')
+      expect(formatted).toContain('Mean: 32.00MB')
+    })
+
+    it('should handle missing memory data in formatting', () => {
+      const mockResult: ColdStartProfilingResult = {
+        samples: 3,
+        totalMs: {
+          mean: 50,
+          median: 48,
+          p95: 55,
+          p99: 58,
+          min: 45,
+          max: 60,
+          stdDev: 5,
+        },
+        phases: {
+          wasmPrep: { mean: 2, median: 2, p95: 3 },
+          dataFetch: { mean: 10, median: 9, p95: 12 },
+          pgliteInit: { mean: 30, median: 29, p95: 35 },
+          prewarm: { mean: 8, median: 8, p95: 10 },
+        },
+        dataSourceDistribution: { empty: 3 },
+        rawMetrics: [],
+      }
+
+      const formatted = formatProfilingResult(mockResult)
+
+      expect(formatted).not.toContain('Memory Usage:')
+    })
+  })
+})