diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..7941c46
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,57 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  ci:
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 10
+    
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        node-version: ["20.x", "22.x", "24.x"]
+        include:
+          - os: ubuntu-latest
+            node-version: "20.x"
+            lint: true
+            build: true
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Setup Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v4
+      with:
+        node-version: ${{ matrix.node-version }}
+        
+    - name: Install dependencies
+      run: npm install
+      
+    - name: Run tests
+      run: npm test
+      
+    - name: Run linting
+      if: matrix.lint
+      run: npm run lint
+
+    - name: Build and package
+      if: matrix.build
+      run: |
+        npm pack --dry-run
+        echo "Package size:"
+        npm pack --silent | xargs ls -lh
+        
+    - name: Test CLI installation
+      if: matrix.build
+      run: |
+        npm pack
+        npm install -g *.tgz
+        flame --help
+        
diff --git a/.gitignore b/.gitignore
index 9a5aced..478d6ff 100644
--- a/.gitignore
+++ b/.gitignore
@@ -137,3 +137,7 @@ dist
 # Vite logs files
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
+
+# Generated profile files from flame profiling
+cpu-profile-*.*
+**/*.csv
diff --git a/README.md b/README.md
index 71018ef..f9f1a64 100644
--- a/README.md
+++ b/README.md
@@ -1,2 +1,242 @@
-# flame
-Utility to generate flamegraphs
+# @platformatic/flame
+
+🔥 CPU profiling and flamegraph visualization tool built on top of [@platformatic/react-pprof](https://github.com/platformatic/react-pprof).
+
+## Features
+
+- **Auto-Start Profiling**: CPU profiling starts immediately when using `flame run` (default behavior)
+- **Automatic Flamegraph Generation**: Interactive HTML flamegraphs are created automatically on exit
+- **Clear File Path Display**: Shows exact paths and browser URLs for generated files
+- **Manual Control**: Optional manual mode with signal-based control using `SIGUSR2`
+- **Interactive Visualization**: WebGL-based HTML flamegraphs with zoom, search, and filtering
+- **CLI Interface**: Simple command-line tool for profiling and visualization
+- **Zero Config**: Works out of the box with sensible defaults
+
+## Installation
+
+```bash
+npm install -g @platformatic/flame
+```
+
+## Quick Start
+
+### Profile a Node.js Script (Auto-Start Mode)
+
+```bash
+# Start profiling your application (profiling begins immediately)
+flame run server.js
+
+# The application runs with CPU profiling active
+# When you stop the app (Ctrl-C or normal exit), you'll see:
+# 🔥 CPU profile written to: cpu-profile-2025-08-27T12-00-00-000Z.pb
+# 🔥 Generating flamegraph...
+# 🔥 Flamegraph will be saved as: cpu-profile-2025-08-27T12-00-00-000Z.html
+# 🔥 Open file:///path/to/cpu-profile-2025-08-27T12-00-00-000Z.html in your browser
+```
+
+### Manual Profiling Mode
+
+```bash
+# Start profiling in manual mode (requires signals to start)
+flame run --manual server.js
+
+# In another terminal, toggle profiling on/off
+kill -USR2 <PID>
+
+# Or use the built-in toggle command
+flame toggle
+```
+
+### Generate Flamegraph
+
+```bash
+# Generate HTML flamegraph from pprof file
+flame generate cpu-profile-2024-01-01T12-00-00-000Z.pb
+
+# Specify custom output file
+flame generate -o my-flamegraph.html profile.pb.gz
+```
+
+## CLI Usage
+
+```bash
+flame [options] <command>
+
+Commands:
+  run <script>           Run a script with profiling enabled
+  generate <pprof-file>  Generate HTML flamegraph from pprof file
+  toggle                 Toggle profiling for running flame processes
+
+Options:
+  -o, --output <file>    Output HTML file (for generate command)
+  -m, --manual          Manual profiling mode (require SIGUSR2 to start)
+  -h, --help            Show help message
+  -v, --version         Show version number
+```
+
+## Programmatic API
+
+```javascript
+const { startProfiling, generateFlamegraph, parseProfile } = require('@platformatic/flame')
+
+// Start profiling a script with auto-start (default)
+const { pid, toggleProfiler } = startProfiling('server.js', ['--port', '3000'], { autoStart: true })
+
+// Or start in manual mode
+const { pid, toggleProfiler } = startProfiling('server.js', ['--port', '3000'], { autoStart: false })
+
+console.log(`Started profiling process ${pid}`)
+
+// Toggle profiling programmatically (useful in manual mode)
+toggleProfiler()
+
+// Generate interactive flamegraph from pprof file
+await generateFlamegraph('profile.pb.gz', 'flamegraph.html')
+
+// Parse profile data
+const profile = await parseProfile('profile.pb')
+```
+
+## How It Works
+
+1. **Auto-Start Mode (Default)**: Profiling begins immediately when `flame run` starts your script
+2. **Auto-Generation on Exit**: Profile (.pb) and interactive HTML flamegraph are automatically created when the process exits
+3. **Manual Mode**: Use `--manual` flag to require `SIGUSR2` signals for start/stop control (no auto-HTML generation)
+4. **Interactive Visualization**: The `@platformatic/react-pprof` library generates interactive WebGL-based HTML flamegraphs
+
+## Profile Files
+
+Profile files are saved with timestamps in the format:
+```
+cpu-profile-2024-01-01T12-00-00-000Z.pb
+```
+
+The files are compressed Protocol Buffer format compatible with the pprof ecosystem.
+
+## Integration with Existing Apps
+
+### Express.js Example
+
+```javascript
+// server.js
+const express = require('express')
+const app = express()
+
+app.get('/', (req, res) => {
+  // Your application logic
+  res.json({ message: 'Hello World' })
+})
+
+app.listen(3000)
+```
+
+**Auto-Start Mode (Recommended):**
+```bash
+# Profile the Express app (profiling starts immediately)
+flame run server.js
+
+# In another terminal, make some requests while profiling is active
+curl http://localhost:3000
+curl http://localhost:3000
+curl http://localhost:3000
+
+# Stop the server (Ctrl-C) to automatically save profile and generate HTML flamegraph
+# You'll see the exact file paths and browser URL in the output:
+# 🔥 CPU profile written to: cpu-profile-2025-08-27T15-30-45-123Z.pb
+# 🔥 Flamegraph generated: cpu-profile-2025-08-27T15-30-45-123Z.html
+# 🔥 Open file:///path/to/cpu-profile-2025-08-27T15-30-45-123Z.html in your browser
+```
+
+**Manual Mode:**
+```bash
+# Profile the Express app in manual mode
+flame run --manual server.js
+
+# In another terminal, start profiling
+flame toggle
+
+# Make some requests
+curl http://localhost:3000
+curl http://localhost:3000
+
+# Stop profiling and save profile
+flame toggle
+
+# Generate flamegraph
+flame generate cpu-profile-*.pb
+```
+
+### Example Applications
+
+Two comprehensive benchmark applications are included for testing profiling overhead and feature Express.js middlewares and Fastify plugins with realistic computation endpoints.
+
+#### Running Benchmark Apps
+```bash
+# Run individual apps without profiling
+node examples/express-benchmark-app.js
+node examples/fastify-benchmark-app.js
+
+# Run comprehensive performance overhead analysis
+node examples/run-performance-benchmark.js
+```
+
+Both apps include:
+- Health check endpoint (no computation)
+- Light computation endpoint (~1k iterations)
+- Medium computation endpoint (~10k iterations)
+- Heavy computation endpoint (~100k iterations)
+- Multiple middleware layers for realistic overhead testing
+- Comprehensive test suites
+
+#### Performance Overhead Results
+
+Based on comprehensive benchmarks with 10 concurrent connections over 10 seconds per endpoint:
+
+**Express.js Framework:**
+| Endpoint | Load Level | Without Profiling | With Profiling | Throughput Overhead | Latency Overhead |
+|----------|------------|-------------------|----------------|--------------------|--------------------|
+| Health Check | Minimal | 13,571 req/s | 13,752 req/s | -1.3% | -6.3% |
+| Light Computation | Low | 10,187 req/s | 9,979 req/s | +2.0% | +12.0% |
+| Medium Computation | Moderate | 71 req/s | 66 req/s | +6.1% | +6.3% |
+| Heavy Computation | High | 295 req/s | 291 req/s | +1.3% | +1.4% |
+| Mixed Computation | Very High | 56 req/s | 53 req/s | +5.2% | +5.8% |
+
+**Express Summary:** Average throughput overhead of **2.7%** and latency overhead of **3.9%**
+
+**Fastify Framework:**
+| Endpoint | Load Level | Without Profiling | With Profiling | Throughput Overhead | Latency Overhead |
+|----------|------------|-------------------|----------------|--------------------|--------------------|
+| Health Check | Minimal | 41,174 req/s | 38,747 req/s | +5.9% | 0.0% |
+| Light Computation | Low | 35,056 req/s | 32,847 req/s | +6.3% | 0.0% |
+| Medium Computation | Moderate | 3,235 req/s | 3,126 req/s | +3.4% | +4.2% |
+| Heavy Computation | High | 345 req/s | 336 req/s | +2.6% | +2.6% |
+| Mixed Computation | Very High | 311 req/s | 304 req/s | +2.3% | +2.3% |
+
+**Fastify Summary:** Average throughput overhead of **4.1%** and latency overhead of **1.8%**
+
+*CSV data is automatically generated when running `node examples/run-performance-benchmark.js` for further analysis.*
+
+### Load Testing Example
+
+You can run load tests manually:
+
+```bash
+# Terminal 1: Start the test server with profiling
+flame run examples/load-test-server.js
+
+# Terminal 2: Run load test with autocannon
+npx autocannon -c 10 -d 10 http://localhost:3000
+
+# Terminal 1: Toggle profiling (start/stop)
+kill -USR2 <PID>
+```
+
+## Requirements
+
+- Node.js >= 18.0.0
+- `@datadog/pprof` for CPU profiling
+- `@platformatic/react-pprof` for flamegraph generation
+
+## License
+
+MIT
\ No newline at end of file
diff --git a/bin/flame.js b/bin/flame.js
new file mode 100755
index 0000000..b788753
--- /dev/null
+++ b/bin/flame.js
@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+
+const { parseArgs } = require('node:util')
+const fs = require('fs')
+const path = require('path')
+const { startProfiling, generateFlamegraph } = require('../lib/index.js')
+
+const { values: args, positionals } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    output: {
+      type: 'string',
+      short: 'o'
+    },
+    profile: {
+      type: 'string',
+      short: 'p'
+    },
+    help: {
+      type: 'boolean',
+      short: 'h'
+    },
+    version: {
+      type: 'boolean',
+      short: 'v'
+    },
+    manual: {
+      type: 'boolean',
+      short: 'm'
+    }
+  },
+  allowPositionals: true
+})
+
+if (args.version) {
+  const pkg = require('../package.json')
+  console.log(pkg.version)
+  process.exit(0)
+}
+
+if (args.help) {
+  console.log(`
+Usage: flame [options] <command>
+
+Commands:
+  run <script>           Run a script with profiling enabled
+  generate <pprof-file>  Generate HTML flamegraph from pprof file
+
+Options:
+  -o, --output <file>    Output HTML file (for generate command)
+  -p, --profile <file>   Profile file to use (for run command)
+  -m, --manual          Manual profiling mode (require SIGUSR2 to start)
+  -h, --help            Show this help message
+  -v, --version         Show version number
+
+Examples:
+  flame run server.js              # Auto-start profiling
+  flame run -m server.js           # Manual profiling (send SIGUSR2 to start)
+  flame generate profile.pb.gz
+  flame generate -o flamegraph.html profile.pb.gz
+`)
+  process.exit(0)
+}
+
+const command = positionals[0]
+
+if (!command) {
+  console.error('Error: No command specified. Use --help for usage information.')
+  process.exit(1)
+}
+
+async function main () {
+  try {
+    switch (command) {
+      case 'run': {
+        const script = positionals[1]
+        if (!script) {
+          console.error('Error: No script specified for run command')
+          process.exit(1)
+        }
+
+        if (!fs.existsSync(script)) {
+          console.error(`Error: Script '${script}' not found`)
+          process.exit(1)
+        }
+
+        const scriptArgs = positionals.slice(2)
+        const autoStart = !args.manual
+        const { pid, process: childProcess } = startProfiling(script, scriptArgs, { autoStart })
+
+        console.log(`🔥 Started profiling process ${pid}`)
+        if (autoStart) {
+          console.log('🔥 CPU profiling is active and will generate profile on exit')
+          console.log('🔥 Profile (.pb) and interactive HTML flamegraph will be auto-generated')
+          console.log('🔥 Generated files will be saved in the current directory')
+          console.log('Send SIGUSR2 to manually toggle profiling:')
+        } else {
+          console.log('📋 Manual profiling mode - send SIGUSR2 to start profiling:')
+        }
+        console.log(`  kill -USR2 ${pid}`)
+        console.log('Press CTRL-C to stop profiling and exit')
+
+        // Handle CTRL-C gracefully
+        process.on('SIGINT', () => {
+          console.log('\n🔥 Stopping flame profiler...')
+          childProcess.kill('SIGTERM')
+          // Give more time for HTML generation to complete
+          setTimeout(() => {
+            childProcess.kill('SIGKILL')
+            process.exit(0)
+          }, 5000) // Increased from 1000ms to 5000ms
+        })
+
+        // Exit when child process exits
+        childProcess.on('close', (code) => {
+          console.log(`\n🔥 Profiled process exited with code ${code}`)
+          process.exit(code)
+        })
+
+        break
+      }
+
+      case 'generate': {
+        const pprofFile = positionals[1]
+        if (!pprofFile) {
+          console.error('Error: No pprof file specified for generate command')
+          process.exit(1)
+        }
+
+        if (!fs.existsSync(pprofFile)) {
+          console.error(`Error: File '${pprofFile}' not found`)
+          process.exit(1)
+        }
+
+        const outputFile = args.output || `${path.basename(pprofFile, path.extname(pprofFile))}.html`
+
+        console.log(`Generating flamegraph from ${pprofFile}...`)
+        const result = await generateFlamegraph(pprofFile, outputFile)
+        console.log(`Flamegraph generated: ${outputFile}`)
+        console.log(result.stdout)
+        break
+      }
+
+      case 'toggle': {
+        if (process.platform !== 'win32') {
+          // Unix-like systems: Find running flame processes and send SIGUSR2
+          const { spawn } = require('child_process')
+
+          const ps = spawn('ps', ['aux'])
+          let output = ''
+
+          ps.stdout.on('data', (data) => {
+            output += data.toString()
+          })
+
+          ps.on('close', (code) => {
+            if (code !== 0) {
+              console.error('Error: Could not list processes')
+              process.exit(1)
+            }
+
+            const lines = output.split('\n')
+            const flameProcesses = lines.filter(line =>
+              line.includes('preload.js') || line.includes('flame run')
+            )
+
+            if (flameProcesses.length === 0) {
+              console.error('No running flame processes found')
+              process.exit(1)
+            }
+
+            flameProcesses.forEach(line => {
+              const parts = line.trim().split(/\s+/)
+              const pid = parts[1]
+              if (pid && !isNaN(pid)) {
+                console.log(`Toggling profiler for process ${pid}`)
+                process.kill(parseInt(pid), 'SIGUSR2')
+              }
+            })
+          })
+        } else {
+          // Windows: Use tasklist to find processes
+          const { spawn } = require('child_process')
+
+          const tasklist = spawn('tasklist', ['/fi', 'IMAGENAME eq node.exe', '/fo', 'csv'])
+          let output = ''
+
+          tasklist.stdout.on('data', (data) => {
+            output += data.toString()
+          })
+
+          tasklist.on('close', (code) => {
+            if (code !== 0) {
+              console.error('Error: Could not list processes')
+              process.exit(1)
+            }
+
+            const lines = output.split('\n')
+            const processes = []
+
+            for (let i = 1; i < lines.length; i++) {
+              if (lines[i].trim()) {
+                const parts = lines[i].split(',')
+                if (parts.length >= 2) {
+                  const pid = parts[1].replace(/"/g, '')
+                  processes.push(pid)
+                }
+              }
+            }
+
+            if (processes.length === 0) {
+              console.error('No running Node.js processes found')
+              process.exit(1)
+            }
+
+            console.log('Windows detected: Direct signal toggle not supported.')
+            console.log('Available Node.js processes:')
+            processes.forEach(pid => {
+              console.log(`  PID: ${pid}`)
+            })
+            console.log('Please use Ctrl-C or restart your flame application to toggle profiling.')
+          })
+        }
+        break
+      }
+
+      default:
+        console.error(`Error: Unknown command '${command}'. Use --help for usage information.`)
+        process.exit(1)
+    }
+  } catch (error) {
+    console.error('Error:', error.message)
+    process.exit(1)
+  }
+}
+
+if (require.main === module) {
+  main()
+}
diff --git a/eslint.config.js b/eslint.config.js
new file mode 100644
index 0000000..df0ddfc
--- /dev/null
+++ b/eslint.config.js
@@ -0,0 +1,5 @@
+const neostandard = require('neostandard')
+
+module.exports = neostandard({
+  ignores: ['node_modules', '**/cpu-profile-*', 'flamegraph-*']
+})
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 0000000..a8d9628
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,251 @@
+# Flame Profiling Examples
+
+This directory contains example applications for testing and benchmarking the flame profiling solution.
+
+## Express.js Benchmark Application
+
+### Overview
+
+The `express-benchmark-app.js` provides a comprehensive Express.js server with multiple endpoints designed to test different computational loads and measure the overhead introduced by flame profiling.
+
+### Features
+
+- **Multiple middleware**: Uses common Express.js middleware (cors, helmet, compression, morgan)
+- **Various computational loads**: Light, medium, and heavy CPU-intensive operations
+- **Realistic workloads**: Simple for loops with array/string operations (not artificial fibonacci)
+- **Detailed timing**: Each endpoint returns execution time and iteration counts
+- **Health monitoring**: Memory usage, uptime, and process information
+- **Batch processing**: Test multiple operations of the same type
+- **Error handling**: Comprehensive error handling and validation
+
+### Endpoints
+
+| Endpoint | Load Level | Iterations | Purpose |
+|----------|------------|------------|---------|
+| `GET /` | None | 0 | API documentation |
+| `GET /health` | Minimal | 0 | Health check with system info |
+| `GET /light` | Low | ~1,000 | Light computational load |
+| `GET /medium` | Moderate | ~50,000 | Medium computational load |
+| `GET /heavy` | High | ~500,000 | Heavy computational load |
+| `GET /mixed` | Very High | ~551,000 | All three computations combined |
+| `GET /batch/:type/:count` | Variable | Variable | Batch processing (1-20 operations) |
+
+### Usage
+
+#### Running without profiling:
+```bash
+node examples/express-benchmark-app.js
+```
+
+#### Running with flame profiling:
+```bash
+flame run examples/express-benchmark-app.js
+```
+
+#### Testing endpoints:
+```bash
+# Health check
+curl http://localhost:3000/health
+
+# Light computation
+curl http://localhost:3000/light
+
+# Heavy computation with timing
+curl http://localhost:3000/heavy | jq '.computation.executionTimeMs'
+
+# Batch processing (5 light computations)
+curl http://localhost:3000/batch/light/5
+```
+
+### Benchmarking with Load Testing Tools
+
+#### Using autocannon:
+```bash
+# Test light endpoint
+autocannon -c 10 -d 10 http://localhost:3000/light
+
+# Test heavy endpoint with fewer connections
+autocannon -c 5 -d 10 http://localhost:3000/heavy
+
+# Test multiple endpoints
+autocannon -c 10 -d 10 -m GET -H "Content-Type: application/json" \
+  -R 100 http://localhost:3000/light
+```
+
+#### Using wrk:
+```bash
+# Test medium endpoint
+wrk -t 4 -c 10 -d 10s http://localhost:3000/medium
+
+# Test with custom script
+wrk -t 4 -c 10 -d 10s --script examples/wrk-script.lua http://localhost:3000/
+```
+
+## Automated Benchmark Runner
+
+The `run-express-benchmark.js` script automatically runs performance tests both with and without profiling to measure overhead.
+
+### Usage
+
+```bash
+node examples/run-express-benchmark.js
+```
+
+### What it does
+
+1. **Phase 1**: Starts Express app without profiling and runs benchmarks
+2. **Phase 2**: Starts Express app with flame profiling and runs the same benchmarks
+3. **Comparison**: Generates a detailed report showing performance differences
+4. **Profile Generation**: Creates flamegraph files for analysis
+
+### Sample Output
+
+```
+🔥 Express.js Flame Profiling Overhead Benchmark
+═══════════════════════════════════════════════════════════════
+
+📊 PHASE 1: Testing WITHOUT flame profiling
+─────────────────────────────────────────────────
+🚀 Starting server WITHOUT flame profiling...
+   ✅ Server started on port 3002
+
+📈 Running benchmarks (10s each, 10 connections)...
+   📊 Testing Health Check (/health)...
+      Requests/sec: 8234.12
+      Avg latency:  1.18ms
+      P99 latency:  3.45ms
+
+🔥 PHASE 2: Testing WITH flame profiling
+─────────────────────────────────────────────────
+🚀 Starting server WITH flame profiling...
+   ✅ Server started on port 3002
+
+📈 Running benchmarks (10s each, 10 connections)...
+   📊 Testing Health Check (/health)...
+      Requests/sec: 7891.34
+      Avg latency:  1.24ms
+      P99 latency:  3.78ms
+
+🔥 FLAME PROFILING OVERHEAD REPORT
+════════════════════════════════════════════════════════════════════════
+
+Performance Comparison:
+┌─────────────────────────┬─────────────────┬─────────────────┬─────────────────┐
+│ Endpoint                │ Without Profile │ With Profile    │ Overhead        │
+├─────────────────────────┼─────────────────┼─────────────────┼─────────────────┤
+│ Health Check            │ 8234.12 req/s   │ 7891.34 req/s   │ +4.16%          │
+│ Light Computation       │ 6543.21 req/s   │ 6102.89 req/s   │ +6.73%          │
+│ Medium Computation      │ 234.56 req/s    │ 221.43 req/s    │ +5.59%          │
+│ Heavy Computation       │ 12.34 req/s     │ 11.78 req/s     │ +4.54%          │
+└─────────────────────────┴─────────────────┴─────────────────┴─────────────────┘
+
+Summary:
+  Average throughput overhead: 5.26%
+  Average latency overhead:    4.82%
+
+Generated Profile Files:
+  📄 cpu-profile-2025-08-27T17-45-23-047Z.pb
+  📄 cpu-profile-2025-08-27T17-45-23-047Z.html
+
+To view the interactive flamegraph:
+  🔥 open cpu-profile-2025-08-27T17-45-23-047Z.html
+```
+
+## Configuration
+
+### Environment Variables
+
+- `PORT` - Server port (default: 3000)
+- `HOST` - Server host (default: localhost)
+- `LOG_LEVEL` - Morgan logging level (default: combined)
+
+### Benchmark Configuration
+
+Modify the `config` object in `run-express-benchmark.js`:
+
+```javascript
+const config = {
+  port: 3002,
+  host: 'localhost',
+  duration: 10,        // seconds per test
+  connections: 10,     // concurrent connections
+  pipelining: 1,       // requests per connection
+  endpoints: [...]     // which endpoints to test
+}
+```
+
+## Interpreting Results
+
+### Expected Overhead
+
+Typical flame profiling overhead should be:
+- **Throughput**: 3-8% reduction in requests/second
+- **Latency**: 3-8% increase in response time
+- **CPU**: 5-15% additional CPU usage
+- **Memory**: 10-30MB additional memory usage
+
+### When Overhead is Concerning
+
+Consider the overhead excessive if:
+- Throughput drops by more than 15%
+- Latency increases by more than 20%
+- Memory usage increases by more than 100MB
+- Application becomes unresponsive
+
+### Optimization Tips
+
+To minimize profiling overhead:
+- Use profiling only in development/staging
+- Profile specific endpoints rather than entire application
+- Use sampling-based profiling for production
+- Limit profiling duration to minimize file sizes
+
+## Quick Start
+
+```bash
+# 1. Install dependencies (if not already installed)
+npm install
+
+# 2. Run the Express benchmark app without profiling
+node examples/express-benchmark-app.js
+
+# 3. In another terminal, test the endpoints
+curl http://localhost:3000/light
+curl http://localhost:3000/heavy
+
+# 4. Stop the server (Ctrl+C) and run with profiling
+flame run examples/express-benchmark-app.js
+
+# 5. Test the same endpoints to generate profile data
+curl http://localhost:3001/light
+curl http://localhost:3001/heavy
+
+# 6. Stop the server to generate flamegraph files
+# Profile files will be saved as cpu-profile-*.pb and cpu-profile-*.html
+
+# 7. Run automated benchmark comparison
+node examples/run-express-benchmark.js
+```
+
+## Files
+
+- `express-benchmark-app.js` - Main Express.js benchmark application
+- `run-express-benchmark.js` - Automated benchmark runner
+- `README.md` - This documentation
+- `load-test-server.js` - Original basic HTTP server (legacy)
+
+## Dependencies
+
+The Express benchmark app requires these additional packages (installed as devDependencies):
+
+```json
+{
+  "express": "^4.19.2",
+  "cors": "^2.8.5",
+  "helmet": "^7.1.0",
+  "compression": "^1.7.4",
+  "morgan": "^1.10.0"
+}
+```
+
+These are already included in the project's `package.json` for convenience.
\ No newline at end of file
diff --git a/examples/express-benchmark-app.js b/examples/express-benchmark-app.js
new file mode 100755
index 0000000..8592ed7
--- /dev/null
+++ b/examples/express-benchmark-app.js
@@ -0,0 +1,455 @@
+#!/usr/bin/env node
+
+/**
+ * Express.js Benchmark Application for Flame Profiling Overhead Testing
+ *
+ * This application provides multiple endpoints with different computational loads
+ * to measure the overhead introduced by the flame profiling solution.
+ *
+ * Usage:
+ *   Without profiling: node express-benchmark-app.js
+ *   With profiling:    flame run express-benchmark-app.js
+ *
+ * The goal is to compare performance metrics (requests/sec, latency, CPU usage)
+ * between profiled and non-profiled runs to quantify profiling overhead.
+ */
+
+const express = require('express')
+const cors = require('cors')
+const helmet = require('helmet')
+const compression = require('compression')
+const morgan = require('morgan')
+
+// Configuration
+const config = {
+  port: process.env.PORT || 3000,
+  host: process.env.HOST || 'localhost',
+  logLevel: process.env.LOG_LEVEL || 'combined'
+}
+
+// Create Express application
+const app = express()
+
+// Middleware setup for realistic application overhead
+app.use(helmet()) // Security headers
+app.use(cors()) // Cross-origin resource sharing
+app.use(compression()) // Response compression
+app.use(morgan(config.logLevel)) // HTTP request logging
+app.use(express.json({ limit: '10mb' })) // JSON parsing
+app.use(express.urlencoded({ extended: true, limit: '10mb' })) // URL-encoded parsing
+
+/**
+ * CPU-intensive computation functions
+ * Using simple for loops with array operations for realistic CPU work
+ */
+
+/**
+ * Light computational load - ~1000 iterations
+ * Simulates basic data processing operations
+ */
+function lightComputation () {
+  const startTime = process.hrtime.bigint()
+  const data = []
+
+  // Simple array operations with 1000 iterations
+  for (let i = 0; i < 1000; i++) {
+    data.push({
+      id: i,
+      value: Math.sqrt(i * 2.5),
+      timestamp: Date.now()
+    })
+  }
+
+  // Basic data manipulation
+  const sum = data.reduce((acc, item) => acc + item.value, 0)
+  const average = sum / data.length
+
+  const endTime = process.hrtime.bigint()
+  const executionTime = Number(endTime - startTime) / 1000000 // Convert to milliseconds
+
+  return {
+    type: 'light',
+    iterations: 1000,
+    dataPoints: data.length,
+    sum: Math.round(sum * 100) / 100,
+    average: Math.round(average * 100) / 100,
+    executionTimeMs: Math.round(executionTime * 100) / 100,
+    timestamp: new Date().toISOString()
+  }
+}
+
+/**
+ * Medium computational load - ~50000 iterations
+ * Simulates moderate data processing with string operations
+ */
+function mediumComputation () {
+  const startTime = process.hrtime.bigint()
+  const data = []
+  const strings = []
+
+  // More intensive operations with 50000 iterations
+  for (let i = 0; i < 50000; i++) {
+    const value = Math.pow(i, 1.5) + Math.sin(i / 1000)
+    data.push({
+      id: i,
+      value,
+      squared: value * value,
+      stringified: `item_${i}_${Math.floor(value)}`
+    })
+
+    // String operations for additional CPU load
+    strings.push(data[i].stringified.toUpperCase().split('_').join('-'))
+  }
+
+  // Data aggregation operations
+  const sum = data.reduce((acc, item) => acc + item.value, 0)
+  const squaredSum = data.reduce((acc, item) => acc + item.squared, 0)
+  const stringLength = strings.reduce((acc, str) => acc + str.length, 0)
+
+  const endTime = process.hrtime.bigint()
+  const executionTime = Number(endTime - startTime) / 1000000
+
+  return {
+    type: 'medium',
+    iterations: 50000,
+    dataPoints: data.length,
+    sum: Math.round(sum * 100) / 100,
+    squaredSum: Math.round(squaredSum * 100) / 100,
+    avgStringLength: Math.round((stringLength / strings.length) * 100) / 100,
+    executionTimeMs: Math.round(executionTime * 100) / 100,
+    timestamp: new Date().toISOString()
+  }
+}
+
+/**
+ * Heavy computational load - ~500000 iterations
+ * Simulates intensive data processing with complex operations
+ */
+function heavyComputation () {
+  const startTime = process.hrtime.bigint()
+  const results = {
+    primes: [],
+    squares: [],
+    stats: {}
+  }
+
+  let sum = 0
+  let primeCount = 0
+
+  // Intensive computation with 500000 iterations
+  for (let i = 2; i < 500000; i++) {
+    const value = i * 1.1 + Math.cos(i / 10000)
+    sum += value
+
+    // Simple prime check for additional CPU work (every 1000th number)
+    if (i % 1000 === 0) {
+      let isPrime = true
+      const limit = Math.sqrt(i)
+      for (let j = 2; j <= limit; j++) {
+        if (i % j === 0) {
+          isPrime = false
+          break
+        }
+      }
+      if (isPrime) {
+        results.primes.push(i)
+        primeCount++
+      }
+    }
+
+    // Store squares for numbers divisible by 10000
+    if (i % 10000 === 0) {
+      results.squares.push({
+        number: i,
+        square: i * i,
+        cube: i * i * i
+      })
+    }
+  }
+
+  results.stats = {
+    totalSum: Math.round(sum * 100) / 100,
+    average: Math.round((sum / 499998) * 100) / 100, // 500000 - 2 (starting from 2)
+    primeCount,
+    squareCount: results.squares.length
+  }
+
+  const endTime = process.hrtime.bigint()
+  const executionTime = Number(endTime - startTime) / 1000000
+
+  return {
+    type: 'heavy',
+    iterations: 499998,
+    stats: results.stats,
+    samplePrimes: results.primes.slice(0, 10), // First 10 primes found
+    sampleSquares: results.squares.slice(0, 5), // First 5 squares
+    executionTimeMs: Math.round(executionTime * 100) / 100,
+    timestamp: new Date().toISOString()
+  }
+}
+
+/**
+ * API Endpoints
+ */
+
+// Health check endpoint - minimal overhead
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    uptime: process.uptime(),
+    memory: process.memoryUsage(),
+    pid: process.pid,
+    timestamp: new Date().toISOString()
+  })
+})
+
+// Light computational load endpoint
+app.get('/light', (req, res) => {
+  try {
+    const result = lightComputation()
+    res.json({
+      success: true,
+      computation: result,
+      message: 'Light computation completed successfully'
+    })
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'Light computation failed',
+      message: error.message,
+      timestamp: new Date().toISOString()
+    })
+  }
+})
+
+// Medium computational load endpoint
+app.get('/medium', (req, res) => {
+  try {
+    const result = mediumComputation()
+    res.json({
+      success: true,
+      computation: result,
+      message: 'Medium computation completed successfully'
+    })
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'Medium computation failed',
+      message: error.message,
+      timestamp: new Date().toISOString()
+    })
+  }
+})
+
+// Heavy computational load endpoint
+app.get('/heavy', (req, res) => {
+  try {
+    const result = heavyComputation()
+    res.json({
+      success: true,
+      computation: result,
+      message: 'Heavy computation completed successfully'
+    })
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'Heavy computation failed',
+      message: error.message,
+      timestamp: new Date().toISOString()
+    })
+  }
+})
+
+// Mixed load endpoint - combines all three computation types
+app.get('/mixed', (req, res) => {
+  try {
+    const results = {
+      light: lightComputation(),
+      medium: mediumComputation(),
+      heavy: heavyComputation()
+    }
+
+    const totalExecutionTime = results.light.executionTimeMs +
+                              results.medium.executionTimeMs +
+                              results.heavy.executionTimeMs
+
+    res.json({
+      success: true,
+      computations: results,
+      summary: {
+        totalExecutionTimeMs: Math.round(totalExecutionTime * 100) / 100,
+        totalIterations: results.light.iterations +
+                        results.medium.iterations +
+                        results.heavy.iterations
+      },
+      message: 'Mixed computation completed successfully'
+    })
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: 'Mixed computation failed',
+      message: error.message,
+      timestamp: new Date().toISOString()
+    })
+  }
+})
+
+// Batch endpoint - runs multiple operations of the same type
+app.get('/batch/:type/:count?', (req, res) => {
+  const { type, count = 5 } = req.params
+  const batchCount = Math.min(Math.max(parseInt(count), 1), 20) // Limit between 1-20
+
+  try {
+    let computationFunction
+    switch (type) {
+      case 'light':
+        computationFunction = lightComputation
+        break
+      case 'medium':
+        computationFunction = mediumComputation
+        break
+      case 'heavy':
+        computationFunction = heavyComputation
+        break
+      default:
+        return res.status(400).json({
+          success: false,
+          error: 'Invalid computation type',
+          validTypes: ['light', 'medium', 'heavy'],
+          timestamp: new Date().toISOString()
+        })
+    }
+
+    const startTime = process.hrtime.bigint()
+    const results = []
+
+    for (let i = 0; i < batchCount; i++) {
+      results.push(computationFunction())
+    }
+
+    const endTime = process.hrtime.bigint()
+    const totalExecutionTime = Number(endTime - startTime) / 1000000
+
+    res.json({
+      success: true,
+      batchType: type,
+      batchCount,
+      results,
+      summary: {
+        totalBatchTimeMs: Math.round(totalExecutionTime * 100) / 100,
+        avgExecutionTimeMs: Math.round((totalExecutionTime / batchCount) * 100) / 100,
+        totalIterations: results.reduce((acc, r) => acc + r.iterations, 0)
+      },
+      message: `Batch ${type} computation completed successfully`
+    })
+  } catch (error) {
+    res.status(500).json({
+      success: false,
+      error: `Batch ${type} computation failed`,
+      message: error.message,
+      timestamp: new Date().toISOString()
+    })
+  }
+})
+
+// Root endpoint - provides API documentation
+app.get('/', (req, res) => {
+  res.json({
+    name: 'Express.js Flame Profiling Benchmark App',
+    version: '1.0.0',
+    description: 'Benchmark application for testing flame profiling overhead',
+    endpoints: {
+      'GET /': 'This documentation',
+      'GET /health': 'Health check (minimal computation)',
+      'GET /light': 'Light computational load (~1,000 iterations)',
+      'GET /medium': 'Medium computational load (~50,000 iterations)',
+      'GET /heavy': 'Heavy computational load (~500,000 iterations)',
+      'GET /mixed': 'Mixed load (combines all three computation types)',
+      'GET /batch/:type/:count': 'Batch processing (type: light|medium|heavy, count: 1-20)'
+    },
+    benchmarkInfo: {
+      purpose: 'Measure overhead introduced by flame profiling',
+      usage: [
+        'Without profiling: node express-benchmark-app.js',
+        'With profiling: flame run express-benchmark-app.js'
+      ],
+      metrics: 'Compare requests/sec, latency, CPU usage between profiled and non-profiled runs'
+    },
+    server: {
+      pid: process.pid,
+      uptime: process.uptime(),
+      nodeVersion: process.version,
+      platform: process.platform
+    },
+    timestamp: new Date().toISOString()
+  })
+})
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error('Unhandled error:', err)
+  res.status(500).json({
+    success: false,
+    error: 'Internal server error',
+    message: err.message,
+    timestamp: new Date().toISOString()
+  })
+})
+
+// 404 handler
+app.use((req, res) => {
+  res.status(404).json({
+    success: false,
+    error: 'Endpoint not found',
+    path: req.path,
+    method: req.method,
+    availableEndpoints: ['/', '/health', '/light', '/medium', '/heavy', '/mixed', '/batch/:type/:count'],
+    timestamp: new Date().toISOString()
+  })
+})
+
+// Start server
+const server = app.listen(config.port, config.host, () => {
+  console.log(`🔥 Express Benchmark Server running on http://${config.host}:${config.port}`)
+  console.log(`📊 PID: ${process.pid}`)
+  console.log(`🚀 Node.js version: ${process.version}`)
+  console.log(`💻 Platform: ${process.platform}`)
+  console.log('')
+  console.log('📋 Available endpoints:')
+  console.log('   GET  /           - API documentation')
+  console.log('   GET  /health     - Health check (minimal load)')
+  console.log('   GET  /light      - Light computation (~1K iterations)')
+  console.log('   GET  /medium     - Medium computation (~50K iterations)')
+  console.log('   GET  /heavy      - Heavy computation (~500K iterations)')
+  console.log('   GET  /mixed      - Mixed computation (all types)')
+  console.log('   GET  /batch/:type/:count - Batch processing')
+  console.log('')
+  console.log('🔬 Benchmarking Instructions:')
+  console.log('   Without profiling: node express-benchmark-app.js')
+  console.log('   With profiling:    flame run express-benchmark-app.js')
+  console.log('')
+  console.log('📈 Use load testing tools like autocannon, wrk, or ab to measure overhead:')
+  console.log(`   autocannon http://${config.host}:${config.port}/light`)
+  console.log(`   autocannon http://${config.host}:${config.port}/medium`)
+  console.log(`   autocannon http://${config.host}:${config.port}/heavy`)
+})
+
+// Graceful shutdown handling
+process.on('SIGTERM', () => {
+  console.log('\n🛑 Received SIGTERM, shutting down gracefully...')
+  server.close(() => {
+    console.log('✅ Server closed')
+    process.exit(0)
+  })
+})
+
+process.on('SIGINT', () => {
+  console.log('\n🛑 Received SIGINT, shutting down gracefully...')
+  server.close(() => {
+    console.log('✅ Server closed')
+    process.exit(0)
+  })
+})
+
+// Export for testing
+module.exports = { app, server, config }
diff --git a/examples/fastify-benchmark-app.js b/examples/fastify-benchmark-app.js
new file mode 100644
index 0000000..675bd12
--- /dev/null
+++ b/examples/fastify-benchmark-app.js
@@ -0,0 +1,379 @@
+'use strict'
+
+/**
+ * Fastify Benchmark Application
+ *
+ * A comprehensive Fastify application designed for benchmarking the overhead
+ * of CPU profiling solutions like flame. This application provides multiple
+ * endpoints with varying computational loads to measure profiling impact
+ * on response times and throughput.
+ *
+ * Features:
+ * - Multiple endpoints with different CPU loads (light, medium, heavy)
+ * - Realistic computational workloads using simple for loops
+ * - Comprehensive plugin integration (CORS, Helmet, Compression)
+ * - Detailed timing and metadata in responses
+ * - Configurable server settings
+ * - Health check endpoint for monitoring
+ *
+ * Usage:
+ *   const { createBenchmarkApp } = require('./fastify-benchmark-app.js');
+ *   const app = await createBenchmarkApp({ port: 3000 });
+ *   await app.listen({ port: 3000, host: '0.0.0.0' });
+ */
+
+const fastify = require('fastify')
+
+/**
+ * Performs a simple computational task with a specified number of iterations.
+ * This simulates realistic CPU work for benchmarking purposes.
+ *
+ * @param {number} iterations - Number of loop iterations to perform
+ * @returns {object} - Object containing the computation result and timing
+ */
+function performComputation (iterations) {
+  const startTime = process.hrtime.bigint()
+
+  let result = 0
+  let temp = 1
+
+  // Simple mathematical operations that provide consistent CPU load
+  for (let i = 0; i < iterations; i++) {
+    temp = (temp * 1.1) % 1000000
+    result += Math.floor(temp)
+
+    // Add some additional operations for more realistic workload
+    if (i % 100 === 0) {
+      result = result % 1000000
+    }
+  }
+
+  const endTime = process.hrtime.bigint()
+  const computeTimeNs = endTime - startTime
+  const computeTimeMs = Number(computeTimeNs) / 1000000
+
+  return {
+    result: Math.floor(result),
+    computeTime: Math.round(computeTimeMs * 100) / 100 // Round to 2 decimal places
+  }
+}
+
+/**
+ * Creates and configures a Fastify application with benchmark endpoints
+ *
+ * @param {object} config - Configuration options
+ * @param {number} config.port - Server port (default: 3000)
+ * @param {string} config.host - Server host (default: '0.0.0.0')
+ * @param {object} config.logger - Logger configuration
+ * @returns {Promise<FastifyInstance>} - Configured Fastify application
+ */
+async function createBenchmarkApp (config = {}) {
+  const {
+    logger = { level: 'info' }
+  } = config
+
+  // Create Fastify instance with configuration
+  const app = fastify({
+    logger,
+    // Disable request logging for cleaner benchmark output
+    disableRequestLogging: process.env.NODE_ENV === 'production'
+  })
+
+  // Register plugins for realistic application setup
+
+  // CORS support for cross-origin requests
+  await app.register(import('@fastify/cors'), {
+    origin: true,
+    credentials: true,
+    // Ensure headers are always present for testing
+    preflightContinue: false,
+    optionsSuccessStatus: 200
+  })
+
+  // Security headers
+  await app.register(import('@fastify/helmet'), {
+    // Configure helmet for benchmark-friendly settings
+    contentSecurityPolicy: false,
+    crossOriginEmbedderPolicy: false
+  })
+
+  // Response compression
+  await app.register(import('@fastify/compress'), {
+    global: true,
+    encodings: ['gzip', 'deflate']
+  })
+
+  // Store server start time for uptime calculation
+  const serverStartTime = Date.now()
+
+  // Health check endpoint
+  app.get('/health', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'string' },
+            timestamp: { type: 'string' },
+            uptime: { type: 'number' },
+            memory: { type: 'object' },
+            version: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const memoryUsage = process.memoryUsage()
+
+    return {
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      uptime: Date.now() - serverStartTime,
+      memory: {
+        rss: Math.round(memoryUsage.rss / 1024 / 1024),
+        heapUsed: Math.round(memoryUsage.heapUsed / 1024 / 1024),
+        heapTotal: Math.round(memoryUsage.heapTotal / 1024 / 1024)
+      },
+      version: process.version
+    }
+  })
+
+  // Light computational load endpoint (~1ms)
+  app.get('/light', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            endpoint: { type: 'string' },
+            iterations: { type: 'number' },
+            result: { type: 'number' },
+            computeTime: { type: 'number' },
+            timestamp: { type: 'string' },
+            requestId: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const iterations = 1000
+    const computation = performComputation(iterations)
+
+    return {
+      endpoint: 'light',
+      iterations,
+      result: computation.result,
+      computeTime: computation.computeTime,
+      timestamp: new Date().toISOString(),
+      requestId: request.id
+    }
+  })
+
+  // Medium computational load endpoint (~10-50ms)
+  app.get('/medium', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            endpoint: { type: 'string' },
+            iterations: { type: 'number' },
+            result: { type: 'number' },
+            computeTime: { type: 'number' },
+            timestamp: { type: 'string' },
+            requestId: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const iterations = 50000
+    const computation = performComputation(iterations)
+
+    return {
+      endpoint: 'medium',
+      iterations,
+      result: computation.result,
+      computeTime: computation.computeTime,
+      timestamp: new Date().toISOString(),
+      requestId: request.id
+    }
+  })
+
+  // Heavy computational load endpoint (~100-500ms)
+  app.get('/heavy', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            endpoint: { type: 'string' },
+            iterations: { type: 'number' },
+            result: { type: 'number' },
+            computeTime: { type: 'number' },
+            timestamp: { type: 'string' },
+            requestId: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const iterations = 500000
+    const computation = performComputation(iterations)
+
+    return {
+      endpoint: 'heavy',
+      iterations,
+      result: computation.result,
+      computeTime: computation.computeTime,
+      timestamp: new Date().toISOString(),
+      requestId: request.id
+    }
+  })
+
+  // Mixed computational load endpoint - combines all three computations
+  app.get('/mixed', {
+    schema: {
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            endpoint: { type: 'string' },
+            computations: {
+              type: 'array',
+              items: {
+                type: 'object',
+                properties: {
+                  type: { type: 'string' },
+                  iterations: { type: 'number' },
+                  result: { type: 'number' },
+                  computeTime: { type: 'number' }
+                }
+              }
+            },
+            totalComputeTime: { type: 'number' },
+            totalIterations: { type: 'number' },
+            timestamp: { type: 'string' },
+            requestId: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async (request, reply) => {
+    const computations = [
+      { type: 'light', iterations: 1000 },
+      { type: 'medium', iterations: 50000 },
+      { type: 'heavy', iterations: 500000 }
+    ]
+
+    const results = []
+    let totalComputeTime = 0
+    let totalIterations = 0
+
+    for (const comp of computations) {
+      const computation = performComputation(comp.iterations)
+      results.push({
+        type: comp.type,
+        iterations: comp.iterations,
+        result: computation.result,
+        computeTime: computation.computeTime
+      })
+      totalComputeTime += computation.computeTime
+      totalIterations += comp.iterations
+    }
+
+    return {
+      endpoint: 'mixed',
+      computations: results,
+      totalComputeTime: Math.round(totalComputeTime * 100) / 100,
+      totalIterations,
+      timestamp: new Date().toISOString(),
+      requestId: request.id
+    }
+  })
+
+  // Error handling
+  app.setErrorHandler(async (error, request, reply) => {
+    request.log.error(error)
+
+    const statusCode = error.statusCode || 500
+
+    return reply.status(statusCode).send({
+      error: true,
+      message: error.message,
+      statusCode,
+      timestamp: new Date().toISOString()
+    })
+  })
+
+  // 404 handler
+  app.setNotFoundHandler(async (request, reply) => {
+    return reply.status(404).send({
+      error: true,
+      message: 'Route not found',
+      statusCode: 404,
+      path: request.url,
+      timestamp: new Date().toISOString()
+    })
+  })
+
+  return app
+}
+
+/**
+ * Main function to start the server when run directly
+ */
+async function main () {
+  try {
+    const config = {
+      port: parseInt(process.env.PORT) || 3000,
+      host: process.env.HOST || '0.0.0.0',
+      logger: {
+        level: process.env.LOG_LEVEL || 'info'
+      }
+    }
+
+    const app = await createBenchmarkApp(config)
+
+    // Start server
+    await app.listen({
+      port: config.port,
+      host: config.host
+    })
+
+    console.log(`
+🔥 Fastify Benchmark Server Started
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Server: http://${config.host}:${config.port}
+
+Endpoints:
+  GET /health - Health check and server stats
+  GET /light  - Light computational load (~1ms)
+  GET /medium - Medium computational load (~10-50ms)  
+  GET /heavy  - Heavy computational load (~100-500ms)
+  GET /mixed  - Combined light + medium + heavy computation
+
+Usage for profiling comparison:
+  1. Baseline: Run without profiling
+  2. Profiled: Run with flame profiler
+  3. Compare response times and throughput
+
+Configuration:
+  PORT=${config.port}
+  HOST=${config.host}
+  LOG_LEVEL=${config.logger.level}
+`)
+  } catch (err) {
+    console.error('Failed to start server:', err)
+    process.exit(1)
+  }
+}
+
+// Export the function for testing
+module.exports = { createBenchmarkApp }
+
+// Run server if this file is executed directly
+if (require.main === module) {
+  main()
+}
diff --git a/examples/load-test-server.js b/examples/load-test-server.js
new file mode 100644
index 0000000..8c96bf7
--- /dev/null
+++ b/examples/load-test-server.js
@@ -0,0 +1,40 @@
+const http = require('http')
+
+// Simulate some CPU-intensive work
+function fibonacci (n) {
+  if (n <= 1) return n
+  return fibonacci(n - 1) + fibonacci(n - 2)
+}
+
+function heavyComputation () {
+  // Do some work that will show up in the profile
+  const result = fibonacci(30)
+  return { result, timestamp: Date.now() }
+}
+
+const server = http.createServer((req, res) => {
+  if (req.url === '/') {
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    res.end(JSON.stringify({ message: 'Hello World', ...heavyComputation() }))
+  } else if (req.url === '/heavy') {
+    // More intensive work
+    res.writeHead(200, { 'Content-Type': 'application/json' })
+    const results = []
+    for (let i = 0; i < 5; i++) {
+      results.push(heavyComputation())
+    }
+    res.end(JSON.stringify({ results }))
+  } else {
+    res.writeHead(404, { 'Content-Type': 'text/plain' })
+    res.end('Not Found')
+  }
+})
+
+const port = process.env.PORT || 3000
+server.listen(port, () => {
+  console.log(`Server running on port ${port}`)
+  console.log(`PID: ${process.pid}`)
+  console.log('Available endpoints:')
+  console.log(`  http://localhost:${port}/`)
+  console.log(`  http://localhost:${port}/heavy`)
+})
diff --git a/examples/run-performance-benchmark.js b/examples/run-performance-benchmark.js
new file mode 100755
index 0000000..6199a9a
--- /dev/null
+++ b/examples/run-performance-benchmark.js
@@ -0,0 +1,470 @@
+#!/usr/bin/env node
+
+/**
+ * Performance Benchmark Runner for Flame Profiling Overhead Testing
+ *
+ * This script runs comprehensive performance benchmarks on the Express benchmark app
+ * both with and without flame profiling to measure overhead using autocannon.
+ *
+ * Usage:
+ *   node run-performance-benchmark.js
+ *
+ * The script will:
+ * 1. Start the Express app without profiling
+ * 2. Run performance tests using autocannon on all endpoints
+ * 3. Stop the server and collect baseline metrics
+ * 4. Start the Express app with flame profiling enabled
+ * 5. Run the same performance tests with profiling active
+ * 6. Stop the server and generate detailed comparison report
+ */
+
+const autocannon = require('autocannon')
+const { spawn } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+const { once } = require('events')
+const { setTimeout: sleep } = require('timers/promises')
+
+// Configuration
+const apps = [
+  {
+    name: 'Express',
+    script: path.join(__dirname, 'express-benchmark-app.js'),
+    port: 3001
+  },
+  {
+    name: 'Fastify',
+    script: path.join(__dirname, 'fastify-benchmark-app.js'),
+    port: 3002
+  }
+]
+
+const config = {
+  host: 'localhost',
+  duration: 10, // seconds
+  connections: 10,
+  pipelining: 1,
+  endpoints: [
+    { name: 'Health Check', path: '/health', expectedLoad: 'minimal' },
+    { name: 'Light Computation', path: '/light', expectedLoad: 'low' },
+    { name: 'Medium Computation', path: '/medium', expectedLoad: 'moderate' },
+    { name: 'Heavy Computation', path: '/heavy', expectedLoad: 'high' },
+    { name: 'Mixed Computation', path: '/mixed', expectedLoad: 'very-high' }
+  ]
+}
+
+/**
+ * Utility functions
+ */
+function wait (ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+function formatNumber (num) {
+  return Number(num).toFixed(2)
+}
+
+function calculateOverhead (withoutProfiling, withProfiling) {
+  if (!withoutProfiling || !withProfiling) return 'N/A'
+  const overhead = ((withoutProfiling - withProfiling) / withoutProfiling) * 100
+  return `${overhead > 0 ? '+' : ''}${formatNumber(overhead)}%`
+}
+
+/**
+ * Start server (with or without profiling)
+ */
+async function startServer (app, withProfiling = false) {
+  console.log(`\n🚀 Starting ${app.name} server ${withProfiling ? 'WITH' : 'WITHOUT'} flame profiling...`)
+
+  const flamePath = path.join(__dirname, '..', 'bin', 'flame.js')
+
+  let serverProcess
+  if (withProfiling) {
+    serverProcess = spawn('node', [flamePath, 'run', app.script], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, PORT: app.port }
+    })
+  } else {
+    serverProcess = spawn('node', [app.script], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, PORT: app.port }
+    })
+  }
+
+  let serverOutput = ''
+  serverProcess.stdout.on('data', (data) => {
+    const output = data.toString()
+    serverOutput += output
+    // Uncomment for debugging: console.log('   Server:', output.trim())
+  })
+
+  serverProcess.stderr.on('data', (data) => {
+    console.log('   Server Error:', data.toString().trim())
+  })
+
+  // Wait for server to start
+  console.log('   Waiting for server to start...')
+  await new Promise((resolve) => {
+    const checkServer = setInterval(() => {
+      const serverStartedExpress = serverOutput.includes('Express Benchmark Server running')
+      const serverStartedFastify = serverOutput.includes('Fastify Benchmark Server Started')
+      if (serverStartedExpress || serverStartedFastify) {
+        clearInterval(checkServer)
+        resolve()
+      }
+    }, 100)
+  })
+
+  if (withProfiling) {
+    console.log('   Starting CPU profiler...')
+    await wait(500) // Give profiler time to initialize
+  }
+
+  console.log(`   ✅ ${app.name} server started on port ${app.port}`)
+  return serverProcess
+}
+
+/**
+ * Run benchmark for a specific endpoint
+ */
+async function runEndpointBenchmark (app, endpoint) {
+  const url = `http://${config.host}:${app.port}${endpoint.path}`
+
+  console.log(`\n   📊 Testing ${endpoint.name} (${endpoint.path})...`)
+
+  try {
+    const result = await autocannon({
+      url,
+      connections: config.connections,
+      pipelining: config.pipelining,
+      duration: config.duration
+    })
+
+    const stats = {
+      requestsPerSec: formatNumber(result.requests.average),
+      latencyAvg: formatNumber(result.latency.average),
+      latencyP99: formatNumber(result.latency.p99),
+      totalRequests: result.requests.total,
+      throughputMB: formatNumber(result.throughput.average / 1024 / 1024),
+      errors: result.non2xx || 0
+    }
+
+    console.log(`      Requests/sec: ${stats.requestsPerSec}`)
+    console.log(`      Avg latency:  ${stats.latencyAvg}ms`)
+    console.log(`      P99 latency:  ${stats.latencyP99}ms`)
+    console.log(`      Total reqs:   ${stats.totalRequests}`)
+    console.log(`      Throughput:   ${stats.throughputMB}MB/s`)
+    console.log(`      Errors:       ${stats.errors}`)
+
+    return stats
+  } catch (error) {
+    console.error(`      ❌ Benchmark failed: ${error.message}`)
+    return null
+  }
+}
+
+/**
+ * Run all benchmarks for current server setup
+ */
+async function runAllBenchmarks (app) {
+  console.log(`\n📈 Running ${app.name} benchmarks (${config.duration}s each, ${config.connections} connections)...`)
+
+  const results = {}
+
+  for (const endpoint of config.endpoints) {
+    const stats = await runEndpointBenchmark(app, endpoint)
+    if (stats) {
+      results[endpoint.path] = {
+        name: endpoint.name,
+        expectedLoad: endpoint.expectedLoad,
+        ...stats
+      }
+    }
+    await wait(1000) // Brief pause between tests
+  }
+
+  return results
+}
+
+/**
+ * Stop server process
+ */
+async function stopServer (serverProcess, withProfiling = false) {
+  console.log('\n🛑 Stopping server...')
+
+  serverProcess.kill('SIGINT')
+
+  await Promise.race([
+    once(serverProcess, 'close'),
+    sleep(10000).then(() => {
+      console.log('   Server did not shut down in time, forcing termination...')
+      serverProcess.kill('SIGKILL')
+    })
+  ])
+
+  console.log('   ✅ Server stopped')
+}
+
+/**
+ * Generate CSV data for further processing
+ */
+function generateCsvData (appName, withoutProfiling, withProfiling) {
+  const csvRows = []
+
+  // CSV Header
+  csvRows.push('Framework,Endpoint,Load Level,Without Profiling (req/s),With Profiling (req/s),Throughput Overhead (%),Without Profiling Latency (ms),With Profiling Latency (ms),Latency Overhead (%)')
+
+  for (const path of Object.keys(withoutProfiling)) {
+    const without = withoutProfiling[path]
+    const with_ = withProfiling[path]
+
+    if (without && with_) {
+      const throughputOverhead = ((parseFloat(without.requestsPerSec) - parseFloat(with_.requestsPerSec)) / parseFloat(without.requestsPerSec)) * 100
+      const latencyOverhead = ((parseFloat(with_.latencyAvg) - parseFloat(without.latencyAvg)) / parseFloat(without.latencyAvg)) * 100
+
+      csvRows.push([
+        appName,
+        without.name,
+        without.expectedLoad,
+        without.requestsPerSec,
+        with_.requestsPerSec,
+        formatNumber(throughputOverhead),
+        without.latencyAvg,
+        with_.latencyAvg,
+        formatNumber(latencyOverhead)
+      ].join(','))
+    }
+  }
+
+  return csvRows.join('\n')
+}
+
+/**
+ * Generate comparison report
+ */
+function generateReport (appName, withoutProfiling, withProfiling) {
+  console.log(`\n\n🔥 ${appName.toUpperCase()} FLAME PROFILING OVERHEAD REPORT`)
+  console.log('════════════════════════════════════════════════════════════════════════')
+  console.log('Test Configuration:')
+  console.log(`  Duration:     ${config.duration} seconds per endpoint`)
+  console.log(`  Connections:  ${config.connections}`)
+  console.log(`  Pipelining:   ${config.pipelining}`)
+  console.log('')
+
+  console.log('Performance Comparison:')
+  console.log('')
+  console.log('┌─────────────────────────┬─────────────────┬─────────────────┬─────────────────┐')
+  console.log('│ Endpoint                │ Without Profile │ With Profile    │ Overhead        │')
+  console.log('├─────────────────────────┼─────────────────┼─────────────────┼─────────────────┤')
+
+  for (const path of Object.keys(withoutProfiling)) {
+    const without = withoutProfiling[path]
+    const with_ = withProfiling[path]
+
+    if (without && with_) {
+      const name = without.name.padEnd(23)
+      const withoutReqs = `${without.requestsPerSec} req/s`.padEnd(15)
+      const withReqs = `${with_.requestsPerSec} req/s`.padEnd(15)
+      const overhead = calculateOverhead(parseFloat(without.requestsPerSec), parseFloat(with_.requestsPerSec)).padEnd(15)
+
+      console.log(`│ ${name} │ ${withoutReqs} │ ${withReqs} │ ${overhead} │`)
+    }
+  }
+
+  console.log('└─────────────────────────┴─────────────────┴─────────────────┴─────────────────┘')
+  console.log('')
+
+  console.log('Latency Comparison (Average):')
+  console.log('')
+  console.log('┌─────────────────────────┬─────────────────┬─────────────────┬─────────────────┐')
+  console.log('│ Endpoint                │ Without Profile │ With Profile    │ Overhead        │')
+  console.log('├─────────────────────────┼─────────────────┼─────────────────┼─────────────────┤')
+
+  for (const path of Object.keys(withoutProfiling)) {
+    const without = withoutProfiling[path]
+    const with_ = withProfiling[path]
+
+    if (without && with_) {
+      const name = without.name.padEnd(23)
+      const withoutLatency = `${without.latencyAvg}ms`.padEnd(15)
+      const withLatency = `${with_.latencyAvg}ms`.padEnd(15)
+      const overhead = calculateOverhead(parseFloat(with_.latencyAvg), parseFloat(without.latencyAvg)).padEnd(15)
+
+      console.log(`│ ${name} │ ${withoutLatency} │ ${withLatency} │ ${overhead} │`)
+    }
+  }
+
+  console.log('└─────────────────────────┴─────────────────┴─────────────────┴─────────────────┘')
+  console.log('')
+
+  // Calculate summary statistics
+  const reqSecOverheads = []
+  const latencyOverheads = []
+
+  for (const path of Object.keys(withoutProfiling)) {
+    const without = withoutProfiling[path]
+    const with_ = withProfiling[path]
+
+    if (without && with_) {
+      const reqOverhead = ((parseFloat(without.requestsPerSec) - parseFloat(with_.requestsPerSec)) / parseFloat(without.requestsPerSec)) * 100
+      const latOverhead = ((parseFloat(with_.latencyAvg) - parseFloat(without.latencyAvg)) / parseFloat(without.latencyAvg)) * 100
+
+      if (!isNaN(reqOverhead)) reqSecOverheads.push(reqOverhead)
+      if (!isNaN(latOverhead)) latencyOverheads.push(latOverhead)
+    }
+  }
+
+  if (reqSecOverheads.length > 0) {
+    const avgReqOverhead = reqSecOverheads.reduce((a, b) => a + b, 0) / reqSecOverheads.length
+    const avgLatOverhead = latencyOverheads.reduce((a, b) => a + b, 0) / latencyOverheads.length
+
+    console.log('Summary:')
+    console.log(`  Average throughput overhead: ${formatNumber(avgReqOverhead)}%`)
+    console.log(`  Average latency overhead:    ${formatNumber(avgLatOverhead)}%`)
+    console.log('')
+  }
+
+  // Look for generated profile files
+  const files = fs.readdirSync(process.cwd())
+  const profileFiles = files.filter(f => f.startsWith('cpu-profile-') && (f.endsWith('.pb') || f.endsWith('.html')))
+
+  if (profileFiles.length > 0) {
+    console.log('Generated Profile Files:')
+    profileFiles.forEach(file => {
+      console.log(`  📄 ${file}`)
+    })
+    console.log('')
+    console.log('To view the interactive flamegraph:')
+    const htmlFile = profileFiles.find(f => f.endsWith('.html'))
+    if (htmlFile) {
+      console.log(`  🔥 open ${htmlFile}`)
+    } else {
+      const pbFile = profileFiles.find(f => f.endsWith('.pb'))
+      if (pbFile) {
+        console.log(`  🔥 flame generate ${pbFile}`)
+      }
+    }
+  }
+
+  // Generate and save CSV data
+  const csvData = generateCsvData(appName, withoutProfiling, withProfiling)
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5)
+  const csvFilename = `flame-benchmark-${appName.toLowerCase()}-${timestamp}.csv`
+
+  fs.writeFileSync(csvFilename, csvData)
+  console.log(`\n📊 CSV data saved to: ${csvFilename}`)
+  console.log('\n✅ Benchmark complete!')
+}
+
+/**
+ * Run benchmark for a specific app
+ */
+async function runAppBenchmark (app, returnResults = false) {
+  console.log(`\n🚀 Benchmarking ${app.name}`)
+  console.log('═'.repeat(50))
+
+  let serverProcess
+  let resultsWithoutProfiling = {}
+  let resultsWithProfiling = {}
+
+  try {
+    // Phase 1: Test without profiling
+    console.log(`\n📊 PHASE 1: Testing ${app.name} WITHOUT flame profiling`)
+    console.log('─────────────────────────────────────────────────')
+
+    serverProcess = await startServer(app, false)
+    resultsWithoutProfiling = await runAllBenchmarks(app)
+    await stopServer(serverProcess, false)
+
+    await wait(3000) // Wait for port to be fully released
+
+    // Phase 2: Test with profiling
+    console.log(`\n\n🔥 PHASE 2: Testing ${app.name} WITH flame profiling`)
+    console.log('─────────────────────────────────────────────────')
+
+    serverProcess = await startServer(app, true)
+    resultsWithProfiling = await runAllBenchmarks(app)
+    await stopServer(serverProcess, true)
+
+    // Generate comparison report
+    generateReport(app.name, resultsWithoutProfiling, resultsWithProfiling)
+
+    if (returnResults) {
+      return {
+        appName: app.name,
+        withoutProfiling: resultsWithoutProfiling,
+        withProfiling: resultsWithProfiling
+      }
+    }
+  } catch (error) {
+    console.error(`\n❌ ${app.name} benchmark failed:`, error.message)
+    if (serverProcess) {
+      serverProcess.kill('SIGKILL')
+    }
+    throw error
+  }
+}
+
+/**
+ * Main benchmark execution
+ */
+async function runBenchmark () {
+  console.log('🔥 Comprehensive Flame Profiling Overhead Benchmark')
+  console.log('═══════════════════════════════════════════════════════════════')
+
+  const appName = process.argv[2]
+
+  if (appName) {
+    const app = apps.find(a => a.name.toLowerCase() === appName.toLowerCase())
+    if (!app) {
+      console.error(`❌ Unknown app: ${appName}. Available: express, fastify`)
+      process.exit(1)
+    }
+    await runAppBenchmark(app)
+  } else {
+    console.log('🎯 Running benchmarks for both Express and Fastify')
+    console.log('📝 Use "node run-performance-benchmark.js express" or "node run-performance-benchmark.js fastify" to run individual benchmarks\n')
+
+    const allResults = []
+    for (const app of apps) {
+      const results = await runAppBenchmark(app, true)
+      if (results) allResults.push(results)
+
+      if (app !== apps[apps.length - 1]) {
+        console.log('\n⏳ Waiting 5 seconds before starting next benchmark...')
+        await wait(5000)
+      }
+    }
+
+    // Generate combined CSV file
+    if (allResults.length > 0) {
+      const combinedCsvRows = []
+      combinedCsvRows.push('Framework,Endpoint,Load Level,Without Profiling (req/s),With Profiling (req/s),Throughput Overhead (%),Without Profiling Latency (ms),With Profiling Latency (ms),Latency Overhead (%)')
+
+      for (const result of allResults) {
+        const csvData = generateCsvData(result.appName, result.withoutProfiling, result.withProfiling)
+        const dataRows = csvData.split('\n').slice(1) // Skip header
+        combinedCsvRows.push(...dataRows)
+      }
+
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5)
+      const combinedCsvFilename = `flame-benchmark-combined-${timestamp}.csv`
+      fs.writeFileSync(combinedCsvFilename, combinedCsvRows.join('\n'))
+      console.log(`\n📊 Combined CSV data saved to: ${combinedCsvFilename}`)
+    }
+
+    console.log('\n🎉 All benchmarks completed!')
+  }
+}
+
+// Run benchmark if called directly
+if (require.main === module) {
+  runBenchmark().then(() => {
+    process.exit(0)
+  }).catch(error => {
+    console.error('Benchmark error:', error)
+    process.exit(1)
+  })
+}
+
+module.exports = { runBenchmark, config }
diff --git a/lib/index.js b/lib/index.js
new file mode 100644
index 0000000..8640600
--- /dev/null
+++ b/lib/index.js
@@ -0,0 +1,110 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const zlib = require('zlib')
+const { spawn } = require('child_process')
+
+/**
+ * Start profiling a Node.js process using the preload script
+ * @param {string} script - Path to the script to profile
+ * @param {string[]} args - Arguments to pass to the script
+ * @param {object} options - Options for profiling
+ * @param {boolean} options.autoStart - Whether to start profiling immediately (default: false)
+ * @returns {Promise<object>} Process information
+ */
+function startProfiling (script, args = [], options = {}) {
+  const preloadPath = path.join(__dirname, '..', 'preload.js')
+
+  const env = {
+    ...process.env,
+    ...options.env,
+    FLAME_AUTO_START: options.autoStart ? 'true' : 'false'
+  }
+
+  const child = spawn('node', ['-r', preloadPath, script, ...args], {
+    stdio: 'inherit',
+    env,
+    ...options
+  })
+
+  return {
+    pid: child.pid,
+    process: child,
+    toggleProfiler: () => {
+      if (process.platform !== 'win32') {
+        process.kill(child.pid, 'SIGUSR2')
+      } else {
+        // On Windows, we'll need to use a different approach
+        console.warn('Direct signal toggle not supported on Windows. Use the CLI toggle command instead.')
+      }
+    }
+  }
+}
+
+/**
+ * Parse a pprof profile file
+ * @param {string} filePath - Path to the pprof file
+ * @returns {Promise<object>} Parsed profile data
+ */
+async function parseProfile (filePath) {
+  if (!fs.existsSync(filePath)) {
+    throw new Error(`Profile file not found: ${filePath}`)
+  }
+
+  let data = fs.readFileSync(filePath)
+
+  // Check if the file is gzipped
+  const isGzipped = data[0] === 0x1f && data[1] === 0x8b
+  if (isGzipped) {
+    data = zlib.gunzipSync(data)
+  }
+
+  const { Profile } = await import('pprof-format')
+  return Profile.decode(data)
+}
+
+/**
+ * Generate an HTML flamegraph from a pprof file using @platformatic/react-pprof CLI
+ * @param {string} pprofPath - Path to the pprof file
+ * @param {string} outputPath - Path to write the HTML file
+ * @returns {Promise<object>} CLI result with stdout/stderr
+ */
+async function generateFlamegraph (pprofPath, outputPath) {
+  return new Promise((resolve, reject) => {
+    // Use the react-pprof CLI to generate the flamegraph
+    const cliPath = require.resolve('react-pprof/cli.js')
+
+    const args = [cliPath, '--output', outputPath, pprofPath]
+    const child = spawn('node', args, { stdio: 'pipe' })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr })
+      } else {
+        reject(new Error(`CLI failed with exit code ${code}: ${stderr || stdout}`))
+      }
+    })
+
+    child.on('error', (error) => {
+      reject(new Error(`Failed to start CLI: ${error.message}`))
+    })
+  })
+}
+
+module.exports = {
+  startProfiling,
+  parseProfile,
+  generateFlamegraph
+}
diff --git a/package.json b/package.json
new file mode 100644
index 0000000..ddc87c8
--- /dev/null
+++ b/package.json
@@ -0,0 +1,58 @@
+{
+  "name": "@platformatic/flame",
+  "version": "1.0.0",
+  "description": "CPU profiling and flamegraph visualization tool using @platformatic/react-pprof",
+  "main": "lib/index.js",
+  "bin": {
+    "flame": "./bin/flame.js"
+  },
+  "files": [
+    "lib",
+    "bin",
+    "preload.js"
+  ],
+  "scripts": {
+    "test": "borp --timeout=30000",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "clean": "rm -f cpu-profile-*.* && rm -f test/cpu-profile-*.* && rm -f examples/cpu-profile-*.* && rm *.csv"
+  },
+  "keywords": [
+    "pprof",
+    "profiling",
+    "flamegraph",
+    "cpu",
+    "performance"
+  ],
+  "author": "Platformatic Inc. <oss@platformatic.dev> (http://platformatic.dev/)",
+  "license": "MIT",
+  "dependencies": {
+    "@datadog/pprof": "^5.9.0",
+    "fastify": "^5.5.0",
+    "pprof-format": "^2.2.1",
+    "react-pprof": "0.1.x"
+  },
+  "devDependencies": {
+    "@fastify/compress": "^8.1.0",
+    "@fastify/cors": "^11.1.0",
+    "@fastify/helmet": "^13.0.1",
+    "@fastify/pre-commit": "^2.2.0",
+    "autocannon": "^8.0.0",
+    "borp": "^0.20.1",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "eslint": "^9.0.0",
+    "express": "^4.19.2",
+    "helmet": "^7.1.0",
+    "light-my-request": "^6.6.0",
+    "morgan": "^1.10.0",
+    "neostandard": "^0.11.6"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "pre-commit": [
+    "lint",
+    "test"
+  ]
+}
diff --git a/preload.js b/preload.js
new file mode 100644
index 0000000..c8ada4f
--- /dev/null
+++ b/preload.js
@@ -0,0 +1,204 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const pprof = require('@datadog/pprof')
+const { spawn } = require('child_process')
+
+const profiler = pprof.time
+let isProfilerRunning = false
+const autoStart = process.env.FLAME_AUTO_START === 'true'
+
+function generateFlamegraph (pprofPath, outputPath) {
+  return new Promise((resolve, reject) => {
+    // Find the flame CLI
+    const flameBinPath = path.resolve(__dirname, 'bin', 'flame.js')
+    const args = [flameBinPath, 'generate', '-o', outputPath, pprofPath]
+
+    const child = spawn('node', args, { stdio: 'pipe' })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr })
+      } else {
+        reject(new Error(`Flamegraph generation failed: ${stderr || stdout}`))
+      }
+    })
+
+    child.on('error', (error) => {
+      reject(error)
+    })
+  })
+}
+
+function stopProfilerQuick () {
+  if (!isProfilerRunning) {
+    return null
+  }
+
+  console.log('Stopping CPU profiler and writing profile to disk...')
+  try {
+    const profileData = profiler.stop()
+    const profile = profileData.encode()
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+    const filename = `cpu-profile-${timestamp}.pb`
+
+    fs.writeFileSync(filename, profile)
+    console.log(`🔥 CPU profile written to: ${filename}`)
+
+    isProfilerRunning = false
+    return filename
+  } catch (error) {
+    console.error('Error generating profile:', error)
+    isProfilerRunning = false
+    return null
+  }
+}
+
+async function stopProfilerAndSave (generateHtml = false) {
+  if (!isProfilerRunning) {
+    return null
+  }
+
+  console.log('Stopping CPU profiler and writing profile to disk...')
+  try {
+    const profileData = profiler.stop()
+    const profile = profileData.encode()
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+    const filename = `cpu-profile-${timestamp}.pb`
+
+    fs.writeFileSync(filename, profile)
+    console.log(`🔥 CPU profile written to: ${filename}`)
+
+    if (generateHtml) {
+      // Auto-generate HTML flamegraph on exit
+      const htmlFilename = filename.replace('.pb', '.html')
+      console.log('🔥 Generating flamegraph...')
+
+      try {
+        await generateFlamegraph(filename, htmlFilename)
+        console.log(`🔥 Flamegraph generated: ${htmlFilename}`)
+        console.log(`🔥 Open file://${path.resolve(htmlFilename)} in your browser to view the flamegraph`)
+      } catch (error) {
+        console.error('Warning: Failed to generate flamegraph:', error.message)
+      }
+    }
+
+    isProfilerRunning = false
+    return filename
+  } catch (error) {
+    console.error('Error generating profile:', error)
+    isProfilerRunning = false
+    return null
+  }
+}
+
+function generateHtmlAsync (filename) {
+  const htmlFilename = filename.replace('.pb', '.html')
+  console.log('🔥 Generating flamegraph...')
+  console.log(`🔥 Flamegraph will be saved as: ${htmlFilename}`)
+  console.log(`🔥 Open file://${path.resolve(htmlFilename)} in your browser once generation completes`)
+
+  generateFlamegraph(filename, htmlFilename)
+    .then(() => {
+      console.log('🔥 Flamegraph generation completed')
+    })
+    .catch(error => {
+      console.error('Warning: Failed to generate flamegraph:', error.message)
+    })
+}
+
+function toggleProfiler () {
+  if (!isProfilerRunning) {
+    console.log('Starting CPU profiler...')
+    profiler.start()
+    isProfilerRunning = true
+  } else {
+    // Manual toggle - don't generate HTML
+    stopProfilerAndSave(false)
+  }
+}
+
+// Set up signal handling (SIGUSR2 on Unix-like systems)
+if (process.platform !== 'win32') {
+  process.on('SIGUSR2', toggleProfiler)
+  console.log('Flame preload script loaded. Send SIGUSR2 to toggle profiling.')
+} else {
+  // On Windows, we use SIGINT (Ctrl-C) or set up alternative IPC
+  console.log('Flame preload script loaded. Windows platform detected.')
+  console.log('Use the CLI toggle command or send SIGINT to control profiling.')
+}
+
+console.log(`Process PID: ${process.pid}`)
+
+// Auto-start profiling if enabled
+if (autoStart) {
+  console.log('🔥 Auto-starting CPU profiler...')
+  toggleProfiler()
+
+  let exitHandlerCalled = false
+
+  // Auto-stop profiling when the process is about to exit
+  process.on('beforeExit', async () => {
+    if (isProfilerRunning && !exitHandlerCalled) {
+      exitHandlerCalled = true
+      console.log('🔥 Process exiting, stopping profiler...')
+      await stopProfilerAndSave(true) // Generate HTML on exit
+    }
+  })
+
+  // Handle explicit process.exit() calls
+  const originalExit = process.exit
+  process.exit = function (code) {
+    if (isProfilerRunning && !exitHandlerCalled) {
+      exitHandlerCalled = true
+      console.log('🔥 Process exiting, stopping profiler...')
+      // For process.exit(), we need to handle async differently since we can't await here
+      stopProfilerAndSave(true).then(() => {
+        return originalExit.call(this, code)
+      }).catch(() => {
+        return originalExit.call(this, code)
+      })
+      // Return without calling originalExit immediately - let the promise handle it
+      return
+    }
+    return originalExit.call(this, code)
+  }
+
+  process.on('SIGINT', () => {
+    if (isProfilerRunning && !exitHandlerCalled) {
+      exitHandlerCalled = true
+      console.log('\n🔥 SIGINT received, stopping profiler...')
+      // For signals, do a quick synchronous save and show HTML info immediately
+      const filename = stopProfilerQuick()
+      if (filename) {
+        generateHtmlAsync(filename)
+      }
+    }
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', () => {
+    if (isProfilerRunning && !exitHandlerCalled) {
+      exitHandlerCalled = true
+      console.log('\n🔥 SIGTERM received, stopping profiler...')
+      // For signals, do a quick synchronous save and show HTML info immediately
+      const filename = stopProfilerQuick()
+      if (filename) {
+        generateHtmlAsync(filename)
+      }
+    }
+    process.exit(0)
+  })
+}
diff --git a/test/cli.test.js b/test/cli.test.js
new file mode 100644
index 0000000..95f1732
--- /dev/null
+++ b/test/cli.test.js
@@ -0,0 +1,139 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { spawn } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+const { once } = require('node:events')
+
+const cliPath = path.join(__dirname, '..', 'bin', 'flame.js')
+
+function runCli (args = [], options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('node', [cliPath, ...args], {
+      stdio: 'pipe',
+      ...options
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      resolve({ code, stdout, stderr })
+    })
+
+    child.on('error', reject)
+  })
+}
+
+test('CLI should show help when --help is passed', async (t) => {
+  const result = await runCli(['--help'])
+
+  assert.strictEqual(result.code, 0, 'Should exit successfully')
+  assert.ok(result.stdout.includes('Usage: flame'), 'Should show usage information')
+  assert.ok(result.stdout.includes('Commands:'), 'Should show commands section')
+  assert.ok(result.stdout.includes('run <script>'), 'Should show run command')
+  assert.ok(result.stdout.includes('generate <pprof-file>'), 'Should show generate command')
+})
+
+test('CLI should show version when --version is passed', async (t) => {
+  const result = await runCli(['--version'])
+
+  assert.strictEqual(result.code, 0, 'Should exit successfully')
+  assert.ok(result.stdout.trim().match(/^\d+\.\d+\.\d+$/), 'Should show version number')
+})
+
+test('CLI should show error for no command', async (t) => {
+  const result = await runCli([])
+
+  assert.strictEqual(result.code, 1, 'Should exit with error code')
+  assert.ok(result.stderr.includes('No command specified'), 'Should show error message')
+})
+
+test('CLI should show error for unknown command', async (t) => {
+  const result = await runCli(['unknown'])
+
+  assert.strictEqual(result.code, 1, 'Should exit with error code')
+  assert.ok(result.stderr.includes('Unknown command'), 'Should show unknown command error')
+})
+
+test('CLI run command should show error for no script', async (t) => {
+  const result = await runCli(['run'])
+
+  assert.strictEqual(result.code, 1, 'Should exit with error code')
+  assert.ok(result.stderr.includes('No script specified'), 'Should show no script error')
+})
+
+test('CLI run command should show error for non-existent script', async (t) => {
+  const result = await runCli(['run', 'non-existent.js'])
+
+  assert.strictEqual(result.code, 1, 'Should exit with error code')
+  assert.ok(result.stderr.includes('not found'), 'Should show file not found error')
+})
+
+test('CLI generate command should show error for no file', async (t) => {
+  const result = await runCli(['generate'])
+
+  assert.strictEqual(result.code, 1, 'Should exit with error code')
+  assert.ok(result.stderr.includes('No pprof file specified'), 'Should show no file error')
+})
+
+test('CLI generate command should show error for non-existent file', async (t) => {
+  const result = await runCli(['generate', 'non-existent.pb'])
+
+  assert.strictEqual(result.code, 1, 'Should exit with error code')
+  assert.ok(result.stderr.includes('not found'), 'Should show file not found error')
+})
+
+test('CLI should handle SIGINT gracefully', async (t) => {
+  // Create a simple test script that runs for a while
+  const testScript = path.join(__dirname, 'temp-long-script.js')
+  fs.writeFileSync(testScript, `
+    console.log('Starting...');
+    setInterval(() => {
+      console.log('Running...');
+    }, 1000);
+  `)
+
+  const child = spawn('node', [cliPath, 'run', testScript], {
+    stdio: 'pipe'
+  })
+
+  let stdout = ''
+
+  child.stdout.on('data', (data) => {
+    stdout += data.toString()
+  })
+
+  // Wait 2 seconds then send SIGINT to give the script time to start
+  setTimeout(() => {
+    child.kill('SIGINT')
+  }, 2000)
+
+  // Wait for the process to close
+  const [exitCode] = await Promise.race([
+    once(child, 'close'),
+    new Promise((resolve) => {
+      setTimeout(() => {
+        child.kill('SIGKILL')
+        resolve([-1])
+      }, 3000)
+    })
+  ])
+
+  // Clean up
+  fs.unlinkSync(testScript)
+
+  // Verify the CLI responded to SIGINT by exiting
+  assert.notStrictEqual(exitCode, undefined, 'Process should exit after receiving SIGINT')
+  assert.ok(stdout.includes('Starting'), 'Should have started the script')
+})
diff --git a/test/express-benchmark-app.test.js b/test/express-benchmark-app.test.js
new file mode 100644
index 0000000..64d4150
--- /dev/null
+++ b/test/express-benchmark-app.test.js
@@ -0,0 +1,478 @@
+'use strict'
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+const inject = require('light-my-request')
+const expressModule = require('../examples/express-benchmark-app.js')
+
+describe('Express Benchmark Application', () => {
+  let app
+
+  test('should export app, server, and config objects', async () => {
+    assert(expressModule.app, 'app should be exported')
+    assert(expressModule.server, 'server should be exported')
+    assert(expressModule.config, 'config should be exported')
+
+    // Store app for testing
+    app = expressModule.app
+
+    // Clean up server to avoid port conflicts
+    expressModule.server.close()
+  })
+
+  describe('Health Endpoint', () => {
+    test('should respond to GET /health with success', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/health'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.status, 'healthy')
+      assert(typeof payload.timestamp === 'string')
+      assert(typeof payload.uptime === 'number')
+      assert(typeof payload.memory === 'object')
+      assert(typeof payload.pid === 'number')
+    })
+  })
+
+  describe('Light Endpoint', () => {
+    test('should respond to GET /light with computational work result', async () => {
+      const startTime = Date.now()
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/light'
+      })
+      const endTime = Date.now()
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, true)
+      assert.strictEqual(payload.computation.type, 'light')
+      assert.strictEqual(payload.computation.iterations, 1000)
+      assert(typeof payload.computation.dataPoints === 'number')
+      assert(typeof payload.computation.sum === 'number')
+      assert(typeof payload.computation.average === 'number')
+      assert(typeof payload.computation.executionTimeMs === 'number')
+      assert(typeof payload.computation.timestamp === 'string')
+      assert(payload.computation.executionTimeMs >= 0)
+      assert(endTime - startTime >= 0)
+      assert(payload.message.includes('Light computation completed successfully'))
+    })
+
+    test('should perform consistent computational work', async () => {
+      const response1 = await inject(app, { method: 'GET', url: '/light' })
+      const response2 = await inject(app, { method: 'GET', url: '/light' })
+
+      const payload1 = JSON.parse(response1.payload)
+      const payload2 = JSON.parse(response2.payload)
+
+      // Results should be the same (deterministic computation)
+      assert.strictEqual(payload1.computation.sum, payload2.computation.sum)
+      assert.strictEqual(payload1.computation.iterations, payload2.computation.iterations)
+      assert.strictEqual(payload1.computation.dataPoints, payload2.computation.dataPoints)
+    })
+  })
+
+  describe('Medium Endpoint', () => {
+    test('should respond to GET /medium with computational work result', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/medium'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, true)
+      assert.strictEqual(payload.computation.type, 'medium')
+      assert.strictEqual(payload.computation.iterations, 50000)
+      assert(typeof payload.computation.dataPoints === 'number')
+      assert(typeof payload.computation.sum === 'number')
+      assert(typeof payload.computation.squaredSum === 'number')
+      assert(typeof payload.computation.avgStringLength === 'number')
+      assert(typeof payload.computation.executionTimeMs === 'number')
+      assert(payload.computation.executionTimeMs >= 0)
+      assert(payload.message.includes('Medium computation completed successfully'))
+    })
+
+    test('should take longer than light endpoint', async () => {
+      const lightResponse = await inject(app, { method: 'GET', url: '/light' })
+      const mediumResponse = await inject(app, { method: 'GET', url: '/medium' })
+
+      const lightPayload = JSON.parse(lightResponse.payload)
+      const mediumPayload = JSON.parse(mediumResponse.payload)
+
+      // Medium should generally take longer than light
+      assert(mediumPayload.computation.executionTimeMs >= lightPayload.computation.executionTimeMs)
+    })
+  })
+
+  describe('Heavy Endpoint', () => {
+    test('should respond to GET /heavy with computational work result', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/heavy'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, true)
+      assert.strictEqual(payload.computation.type, 'heavy')
+      assert.strictEqual(payload.computation.iterations, 499998)
+      assert(typeof payload.computation.stats === 'object')
+      assert(typeof payload.computation.stats.totalSum === 'number')
+      assert(typeof payload.computation.stats.average === 'number')
+      assert(typeof payload.computation.stats.primeCount === 'number')
+      assert(typeof payload.computation.stats.squareCount === 'number')
+      assert(Array.isArray(payload.computation.samplePrimes))
+      assert(Array.isArray(payload.computation.sampleSquares))
+      assert(typeof payload.computation.executionTimeMs === 'number')
+      assert(payload.computation.executionTimeMs >= 0)
+      assert(payload.message.includes('Heavy computation completed successfully'))
+    })
+
+    test('should take longer than medium endpoint', async () => {
+      const mediumResponse = await inject(app, { method: 'GET', url: '/medium' })
+      const heavyResponse = await inject(app, { method: 'GET', url: '/heavy' })
+
+      const mediumPayload = JSON.parse(mediumResponse.payload)
+      const heavyPayload = JSON.parse(heavyResponse.payload)
+
+      // Heavy should generally take longer than medium, but timing can vary
+      // Just verify both have positive execution times and heavy has more iterations
+      assert(heavyPayload.computation.executionTimeMs >= 0)
+      assert(mediumPayload.computation.executionTimeMs >= 0)
+      assert(heavyPayload.computation.iterations > mediumPayload.computation.iterations)
+    })
+  })
+
+  describe('Mixed Endpoint', () => {
+    test('should respond to GET /mixed with all three computation types', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/mixed'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, true)
+      assert(typeof payload.computations === 'object')
+      assert(typeof payload.computations.light === 'object')
+      assert(typeof payload.computations.medium === 'object')
+      assert(typeof payload.computations.heavy === 'object')
+      assert(typeof payload.summary === 'object')
+      assert(typeof payload.summary.totalExecutionTimeMs === 'number')
+      assert(typeof payload.summary.totalIterations === 'number')
+      assert(payload.message.includes('Mixed computation completed successfully'))
+
+      // Verify individual computation results
+      assert.strictEqual(payload.computations.light.type, 'light')
+      assert.strictEqual(payload.computations.medium.type, 'medium')
+      assert.strictEqual(payload.computations.heavy.type, 'heavy')
+    })
+  })
+
+  describe('Batch Endpoint', () => {
+    test('should respond to GET /batch/light with default count', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/batch/light'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, true)
+      assert.strictEqual(payload.batchType, 'light')
+      assert.strictEqual(payload.batchCount, 5) // Default count
+      assert(Array.isArray(payload.results))
+      assert.strictEqual(payload.results.length, 5)
+      assert(typeof payload.summary === 'object')
+      assert(typeof payload.summary.totalBatchTimeMs === 'number')
+      assert(typeof payload.summary.avgExecutionTimeMs === 'number')
+      assert(typeof payload.summary.totalIterations === 'number')
+    })
+
+    test('should respond to GET /batch/medium/3 with custom count', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/batch/medium/3'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, true)
+      assert.strictEqual(payload.batchType, 'medium')
+      assert.strictEqual(payload.batchCount, 3)
+      assert(Array.isArray(payload.results))
+      assert.strictEqual(payload.results.length, 3)
+    })
+
+    test('should return 400 for invalid computation type', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/batch/invalid/2'
+      })
+
+      assert.strictEqual(response.statusCode, 400)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, false)
+      assert(payload.error.includes('Invalid computation type'))
+      assert(Array.isArray(payload.validTypes))
+      assert(payload.validTypes.includes('light'))
+      assert(payload.validTypes.includes('medium'))
+      assert(payload.validTypes.includes('heavy'))
+    })
+
+    test('should limit batch count to maximum of 20', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/batch/light/25'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.batchCount, 20) // Should be limited to 20
+      assert.strictEqual(payload.results.length, 20)
+    })
+  })
+
+  describe('Root Endpoint', () => {
+    test('should respond to GET / with API documentation', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert(payload.name.includes('Express.js Flame Profiling Benchmark App'))
+      assert(typeof payload.version === 'string')
+      assert(typeof payload.description === 'string')
+      assert(typeof payload.endpoints === 'object')
+      assert(typeof payload.benchmarkInfo === 'object')
+      assert(typeof payload.server === 'object')
+      assert(typeof payload.timestamp === 'string')
+
+      // Check that key endpoints are documented
+      assert(payload.endpoints['GET /health'])
+      assert(payload.endpoints['GET /light'])
+      assert(payload.endpoints['GET /medium'])
+      assert(payload.endpoints['GET /heavy'])
+    })
+  })
+
+  describe('Middleware Integration', () => {
+    test('should have CORS headers for cross-origin requests', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/health',
+        headers: {
+          origin: 'https://example.com'
+        }
+      })
+
+      assert(response.headers['access-control-allow-origin'])
+    })
+
+    test('should have security headers from helmet', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/health'
+      })
+
+      // Helmet should add security headers
+      assert(response.headers['x-dns-prefetch-control'] || response.headers['x-frame-options'] || response.headers['x-content-type-options'])
+    })
+
+    test('should support compression', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/heavy',
+        headers: {
+          'accept-encoding': 'gzip'
+        }
+      })
+
+      // Should accept compression header without error
+      assert.strictEqual(response.statusCode, 200)
+    })
+
+    test('should parse JSON requests', async () => {
+      const response = await inject(app, {
+        method: 'POST',
+        url: '/health',
+        headers: {
+          'content-type': 'application/json'
+        },
+        payload: JSON.stringify({ test: 'data' })
+      })
+
+      // Should handle JSON payload without error (even if method not supported)
+      // The endpoint doesn't support POST, but middleware should parse JSON
+      assert(response.statusCode === 404) // Express returns 404 for unsupported methods on existing routes
+    })
+  })
+
+  describe('Error Handling', () => {
+    test('should return 404 for non-existent routes', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/non-existent'
+      })
+
+      assert.strictEqual(response.statusCode, 404)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, false)
+      assert(payload.error.includes('Endpoint not found'))
+      assert(payload.path === '/non-existent')
+      assert(payload.method === 'GET')
+      assert(Array.isArray(payload.availableEndpoints))
+    })
+
+    test('should return 404 for unsupported HTTP methods on existing routes', async () => {
+      const response = await inject(app, {
+        method: 'POST',
+        url: '/light'
+      })
+
+      assert.strictEqual(response.statusCode, 404)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.success, false)
+      assert(payload.error.includes('Endpoint not found'))
+    })
+
+    test('should handle invalid JSON gracefully', async () => {
+      const response = await inject(app, {
+        method: 'POST',
+        url: '/health',
+        headers: {
+          'content-type': 'application/json'
+        },
+        payload: '{ invalid json'
+      })
+
+      // Should return an error for invalid JSON (400 from Express body parser)
+      assert(response.statusCode >= 400)
+    })
+  })
+
+  describe('Performance Characteristics', () => {
+    test('should complete light computation within reasonable time', async () => {
+      const startTime = Date.now()
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/light'
+      })
+      const endTime = Date.now()
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      const totalTime = endTime - startTime
+
+      // Light computation should complete relatively quickly (< 1000ms typically)
+      assert(totalTime < 5000, `Light computation took ${totalTime}ms, expected < 5000ms`)
+      // Execution time should be positive
+      assert(payload.computation.executionTimeMs >= 0)
+    })
+
+    test('should show increasing iterations across endpoint types', async () => {
+      const lightResponse = await inject(app, { method: 'GET', url: '/light' })
+      const mediumResponse = await inject(app, { method: 'GET', url: '/medium' })
+      const heavyResponse = await inject(app, { method: 'GET', url: '/heavy' })
+
+      const lightPayload = JSON.parse(lightResponse.payload)
+      const mediumPayload = JSON.parse(mediumResponse.payload)
+      const heavyPayload = JSON.parse(heavyResponse.payload)
+
+      // Iterations should definitely increase across endpoint types
+      assert(lightPayload.computation.iterations < mediumPayload.computation.iterations)
+      assert(mediumPayload.computation.iterations < heavyPayload.computation.iterations)
+
+      // All execution times should be positive
+      assert(lightPayload.computation.executionTimeMs >= 0)
+      assert(mediumPayload.computation.executionTimeMs >= 0)
+      assert(heavyPayload.computation.executionTimeMs >= 0)
+    })
+
+    test('should provide consistent results for the same computation type', async () => {
+      const responses = await Promise.all([
+        inject(app, { method: 'GET', url: '/light' }),
+        inject(app, { method: 'GET', url: '/light' }),
+        inject(app, { method: 'GET', url: '/light' })
+      ])
+
+      const payloads = responses.map(r => JSON.parse(r.payload))
+
+      // All light computations should have same iterations and similar results
+      payloads.forEach(payload => {
+        assert.strictEqual(payload.computation.iterations, 1000)
+        assert.strictEqual(payload.computation.type, 'light')
+      })
+
+      // Results should be deterministic (same sum for same computation)
+      const firstSum = payloads[0].computation.sum
+      payloads.forEach(payload => {
+        assert.strictEqual(payload.computation.sum, firstSum)
+      })
+    })
+  })
+
+  describe('Response Structure Validation', () => {
+    test('should have consistent response structure for computation endpoints', async () => {
+      const endpoints = ['/light', '/medium', '/heavy']
+
+      for (const endpoint of endpoints) {
+        const response = await inject(app, { method: 'GET', url: endpoint })
+        const payload = JSON.parse(response.payload)
+
+        // Common structure validation
+        assert(typeof payload.success === 'boolean')
+        assert(payload.success === true)
+        assert(typeof payload.computation === 'object')
+        assert(typeof payload.message === 'string')
+        assert(typeof payload.computation.type === 'string')
+        assert(typeof payload.computation.iterations === 'number')
+        assert(typeof payload.computation.executionTimeMs === 'number')
+        assert(typeof payload.computation.timestamp === 'string')
+
+        // Validate timestamp format (ISO string)
+        assert(!isNaN(Date.parse(payload.computation.timestamp)))
+      }
+    })
+
+    test('should have consistent error response structure', async () => {
+      const response = await inject(app, {
+        method: 'GET',
+        url: '/non-existent'
+      })
+
+      const payload = JSON.parse(response.payload)
+
+      // Error structure validation
+      assert(typeof payload.success === 'boolean')
+      assert(payload.success === false)
+      assert(typeof payload.error === 'string')
+      assert(typeof payload.path === 'string')
+      assert(typeof payload.method === 'string')
+      assert(typeof payload.timestamp === 'string')
+      assert(Array.isArray(payload.availableEndpoints))
+
+      // Validate timestamp format
+      assert(!isNaN(Date.parse(payload.timestamp)))
+    })
+  })
+})
diff --git a/test/fastify-benchmark-app.test.js b/test/fastify-benchmark-app.test.js
new file mode 100644
index 0000000..8e2315e
--- /dev/null
+++ b/test/fastify-benchmark-app.test.js
@@ -0,0 +1,233 @@
+'use strict'
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+const { createBenchmarkApp } = require('../examples/fastify-benchmark-app.js')
+
+describe('Fastify Benchmark Application', () => {
+  test('should export a function to create the Fastify app', async () => {
+    assert.strictEqual(typeof createBenchmarkApp, 'function')
+  })
+
+  test('should create app with default configuration', async () => {
+    const app = await createBenchmarkApp()
+
+    assert(app)
+    assert.strictEqual(typeof app.inject, 'function')
+    assert.strictEqual(typeof app.listen, 'function')
+
+    await app.close()
+  })
+
+  test('should create app with custom configuration', async () => {
+    const config = {
+      port: 4000,
+      host: '127.0.0.1',
+      logger: { level: 'debug' }
+    }
+
+    const app = await createBenchmarkApp(config)
+    assert(app)
+    await app.close()
+  })
+
+  describe('Health Endpoint', () => {
+    test('should respond to GET /health with success', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/health'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.status, 'healthy')
+      assert(typeof payload.timestamp === 'string')
+      assert(typeof payload.uptime === 'number')
+
+      await app.close()
+    })
+  })
+
+  describe('Light Endpoint', () => {
+    test('should respond to GET /light with computational work result', async () => {
+      const app = await createBenchmarkApp()
+
+      const startTime = Date.now()
+      const response = await app.inject({
+        method: 'GET',
+        url: '/light'
+      })
+      const endTime = Date.now()
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.endpoint, 'light')
+      assert.strictEqual(payload.iterations, 1000)
+      assert(typeof payload.result === 'number')
+      assert(typeof payload.computeTime === 'number')
+      assert(typeof payload.timestamp === 'string')
+      assert(payload.computeTime >= 0)
+      assert(endTime - startTime >= payload.computeTime)
+
+      await app.close()
+    })
+
+    test('should perform consistent computational work', async () => {
+      const app = await createBenchmarkApp()
+
+      const response1 = await app.inject({ method: 'GET', url: '/light' })
+      const response2 = await app.inject({ method: 'GET', url: '/light' })
+
+      const payload1 = JSON.parse(response1.payload)
+      const payload2 = JSON.parse(response2.payload)
+
+      // Results should be the same (deterministic computation)
+      assert.strictEqual(payload1.result, payload2.result)
+      assert.strictEqual(payload1.iterations, payload2.iterations)
+
+      await app.close()
+    })
+  })
+
+  describe('Medium Endpoint', () => {
+    test('should respond to GET /medium with computational work result', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/medium'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.endpoint, 'medium')
+      assert.strictEqual(payload.iterations, 50000)
+      assert(typeof payload.result === 'number')
+      assert(typeof payload.computeTime === 'number')
+      assert(payload.computeTime >= 0)
+
+      await app.close()
+    })
+
+    test('should take longer than light endpoint', async () => {
+      const app = await createBenchmarkApp()
+
+      const lightResponse = await app.inject({ method: 'GET', url: '/light' })
+      const mediumResponse = await app.inject({ method: 'GET', url: '/medium' })
+
+      const lightPayload = JSON.parse(lightResponse.payload)
+      const mediumPayload = JSON.parse(mediumResponse.payload)
+
+      // Medium should generally take longer than light
+      assert(mediumPayload.computeTime >= lightPayload.computeTime)
+
+      await app.close()
+    })
+  })
+
+  describe('Heavy Endpoint', () => {
+    test('should respond to GET /heavy with computational work result', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/heavy'
+      })
+
+      assert.strictEqual(response.statusCode, 200)
+
+      const payload = JSON.parse(response.payload)
+      assert.strictEqual(payload.endpoint, 'heavy')
+      assert.strictEqual(payload.iterations, 500000)
+      assert(typeof payload.result === 'number')
+      assert(typeof payload.computeTime === 'number')
+      assert(payload.computeTime >= 0)
+
+      await app.close()
+    })
+
+    test('should take longer than medium endpoint', async () => {
+      const app = await createBenchmarkApp()
+
+      const mediumResponse = await app.inject({ method: 'GET', url: '/medium' })
+      const heavyResponse = await app.inject({ method: 'GET', url: '/heavy' })
+
+      const mediumPayload = JSON.parse(mediumResponse.payload)
+      const heavyPayload = JSON.parse(heavyResponse.payload)
+
+      // Heavy should generally take longer than medium
+      assert(heavyPayload.computeTime >= mediumPayload.computeTime)
+
+      await app.close()
+    })
+  })
+
+  describe('Plugin Integration', () => {
+    test('should have CORS headers for cross-origin requests', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/health',
+        headers: {
+          origin: 'https://example.com'
+        }
+      })
+
+      assert(response.headers['access-control-allow-origin'])
+
+      await app.close()
+    })
+
+    test('should have security headers from helmet', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/health'
+      })
+
+      // Helmet should add security headers
+      assert(response.headers['x-frame-options'] || response.headers['x-content-type-options'])
+
+      await app.close()
+    })
+
+    test('should support compression', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/heavy',
+        headers: {
+          'accept-encoding': 'gzip'
+        }
+      })
+
+      // Should accept compression header without error
+      assert.strictEqual(response.statusCode, 200)
+
+      await app.close()
+    })
+  })
+
+  describe('Error Handling', () => {
+    test('should return 404 for non-existent routes', async () => {
+      const app = await createBenchmarkApp()
+
+      const response = await app.inject({
+        method: 'GET',
+        url: '/non-existent'
+      })
+
+      assert.strictEqual(response.statusCode, 404)
+
+      await app.close()
+    })
+  })
+})
diff --git a/test/fixtures/test-script.js b/test/fixtures/test-script.js
new file mode 100644
index 0000000..9fe2ce7
--- /dev/null
+++ b/test/fixtures/test-script.js
@@ -0,0 +1,19 @@
+'use strict'
+
+// Simple test script for testing profiling
+console.log('Test script starting...')
+
+function fibonacci (n) {
+  if (n <= 1) return n
+  return fibonacci(n - 1) + fibonacci(n - 2)
+}
+
+function busyWork () {
+  const result = fibonacci(30)
+  console.log(`Fibonacci result: ${result}`)
+}
+
+// Do some work
+busyWork()
+
+console.log('Test script finished')
diff --git a/test/integration.test.js b/test/integration.test.js
new file mode 100644
index 0000000..3cd0fe1
--- /dev/null
+++ b/test/integration.test.js
@@ -0,0 +1,234 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { spawn } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+
+test('integration: full workflow from profiling to flamegraph generation', { skip: process.platform === 'win32' ? 'SIGUSR2 not supported on Windows' : false }, async (t) => {
+  const cliPath = path.join(__dirname, '..', 'bin', 'flame.js')
+  const outputDir = __dirname
+
+  // Step 1: Create a test script that does some work
+  const workScript = path.join(__dirname, 'temp-work-script.js')
+  fs.writeFileSync(workScript, `
+    function fibonacci(n) {
+      if (n <= 1) return n;
+      return fibonacci(n - 1) + fibonacci(n - 2);
+    }
+    
+    function doWork() {
+      console.log('Starting CPU intensive work...');
+      const result = fibonacci(30); // More work to make profiling meaningful
+      console.log('Work result:', result);
+      console.log('Work complete');
+    }
+    
+    // Do work immediately - profiling is already started by flame run
+    doWork();
+    
+    // Exit cleanly to trigger profile generation
+    process.exit(0);
+  `)
+
+  // Step 2: Start profiling the script using flame run command (auto-starts profiling)
+  const child = spawn('node', [cliPath, 'run', workScript], {
+    stdio: 'pipe',
+    cwd: outputDir
+  })
+
+  let profileFile = null
+
+  child.stdout.on('data', (data) => {
+    const output = data.toString()
+
+    // With auto-start, profiling begins immediately and stops on exit
+    // Just capture the profile filename when it's written
+    const profileMatch = output.match(/CPU profile written to: (cpu-profile-[^\s]+\.pb)/)
+    if (profileMatch) {
+      profileFile = profileMatch[1]
+      // The process will exit naturally after creating the profile and HTML
+    }
+  })
+
+  child.stderr.on('data', (data) => {
+    console.error('Server error:', data.toString())
+  })
+
+  // Wait for the profiling process to complete (should be much faster with auto-start)
+  await new Promise((resolve) => {
+    child.on('close', resolve)
+    // Timeout after 10 seconds (longer to allow for profile generation)
+    setTimeout(() => {
+      child.kill('SIGKILL')
+      resolve()
+    }, 10000)
+  })
+
+  // Clean up the work script
+  fs.unlinkSync(workScript)
+
+  // Check if profile was created
+  if (!profileFile) {
+    assert.fail('Profile generation failed - no profile file was created. Check if profiling signals were processed correctly.')
+  }
+
+  const profilePath = path.join(outputDir, profileFile)
+  assert.ok(fs.existsSync(profilePath), 'Profile file should be created')
+  assert.ok(fs.statSync(profilePath).size > 0, 'Profile file should not be empty')
+
+  // HTML generation is asynchronous - give it some time
+  await new Promise(resolve => setTimeout(resolve, 2000))
+
+  // Check that HTML file was also auto-generated (with some tolerance for async generation)
+  const autoHtmlFile = profilePath.replace('.pb', '.html')
+  const htmlExists = fs.existsSync(autoHtmlFile)
+
+  if (htmlExists) {
+    console.log('✅ HTML file auto-generated successfully')
+    assert.ok(fs.statSync(autoHtmlFile).size > 0, 'HTML file should not be empty')
+
+    // Check that JS file was also created
+    const autoJsFile = profilePath.replace('.pb', '.js')
+    if (fs.existsSync(autoJsFile)) {
+      assert.ok(fs.statSync(autoJsFile).size > 0, 'JS file should not be empty')
+    }
+  } else {
+    console.log('⚠️ HTML file not generated yet (async generation in progress)')
+  }
+
+  // Step 3: Generate flamegraph from the profile
+  try {
+    require.resolve('react-pprof/cli.js')
+  } catch (error) {
+    // Clean up and fail if react-pprof CLI is not available
+    fs.unlinkSync(profilePath)
+    assert.fail('react-pprof CLI not available - dependency should be installed')
+  }
+
+  const htmlFile = path.join(outputDir, 'test-flamegraph.html')
+  const generateResult = await new Promise((resolve) => {
+    const generateChild = spawn('node', [cliPath, 'generate', '-o', htmlFile, profilePath], {
+      stdio: 'pipe'
+    })
+
+    let generateStdout = ''
+    let generateStderr = ''
+
+    generateChild.stdout.on('data', (data) => {
+      generateStdout += data.toString()
+    })
+
+    generateChild.stderr.on('data', (data) => {
+      generateStderr += data.toString()
+    })
+
+    generateChild.on('close', (code) => {
+      resolve({ code, stdout: generateStdout, stderr: generateStderr })
+    })
+  })
+
+  // Clean up profile file
+  fs.unlinkSync(profilePath)
+
+  if (generateResult.code !== 0) {
+    assert.fail(`Flamegraph generation failed with exit code ${generateResult.code}: ${generateResult.stderr || generateResult.stdout}`)
+  }
+
+  // Verify HTML file was created and has content
+  assert.ok(fs.existsSync(htmlFile), 'HTML file should be created')
+  assert.ok(fs.statSync(htmlFile).size > 0, 'HTML file should not be empty')
+
+  // Verify the output contains expected success messages
+  assert.ok(
+    generateResult.stdout.includes('Generated HTML output') ||
+    generateResult.stdout.includes('HTML'),
+    'Should indicate successful HTML generation'
+  )
+
+  // Clean up generated files
+  if (fs.existsSync(htmlFile)) {
+    fs.unlinkSync(htmlFile)
+  }
+
+  const jsFile = htmlFile.replace('.html', '.js')
+  if (fs.existsSync(jsFile)) {
+    fs.unlinkSync(jsFile)
+  }
+
+  // Clean up auto-generated files too
+  if (fs.existsSync(autoHtmlFile)) {
+    fs.unlinkSync(autoHtmlFile)
+  }
+
+  const autoJsFile = autoHtmlFile.replace('.html', '.js')
+  if (fs.existsSync(autoJsFile)) {
+    fs.unlinkSync(autoJsFile)
+  }
+})
+
+test('integration: Windows compatibility test', { skip: process.platform !== 'win32' ? 'Windows-only test' : false }, async (t) => {
+  const cliPath = path.join(__dirname, '..', 'bin', 'flame.js')
+
+  // Test basic CLI functionality on Windows
+  const helpResult = await new Promise((resolve) => {
+    const helpChild = spawn('node', [cliPath, '--help'], {
+      stdio: 'pipe'
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    helpChild.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    helpChild.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    helpChild.on('close', (code) => {
+      resolve({ code, stdout, stderr })
+    })
+  })
+
+  assert.strictEqual(helpResult.code, 0, 'Help command should work on Windows')
+  assert.ok(helpResult.stdout.includes('Usage: flame'), 'Should show usage information')
+
+  // Test toggle command on Windows (should show warning about Windows compatibility)
+  const toggleResult = await new Promise((resolve) => {
+    const toggleChild = spawn('node', [cliPath, 'toggle'], {
+      stdio: 'pipe'
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    toggleChild.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    toggleChild.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    toggleChild.on('close', (code) => {
+      resolve({ code, stdout, stderr })
+    })
+
+    // Kill after timeout to prevent hanging
+    setTimeout(() => {
+      toggleChild.kill('SIGKILL')
+      resolve({ code: -1, stdout, stderr })
+    }, 3000)
+  })
+
+  // On Windows, the toggle command should either find processes or show a message
+  assert.ok(
+    toggleResult.stdout.includes('Windows detected') ||
+    toggleResult.stdout.includes('processes') ||
+    toggleResult.stderr.includes('Error'),
+    'Toggle command should handle Windows appropriately'
+  )
+})
diff --git a/test/lib.test.js b/test/lib.test.js
new file mode 100644
index 0000000..03841df
--- /dev/null
+++ b/test/lib.test.js
@@ -0,0 +1,85 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const fs = require('fs')
+const path = require('path')
+const { once } = require('node:events')
+const { startProfiling, parseProfile, generateFlamegraph } = require('../lib/index.js')
+
+test('startProfiling should spawn process with preload script', async (t) => {
+  // Create a simple test script
+  const testScript = path.join(__dirname, 'temp-script.js')
+  fs.writeFileSync(testScript, 'console.log("Hello World"); process.exit(0);')
+
+  const result = startProfiling(testScript, [], { stdio: 'pipe' })
+
+  assert.ok(result.pid, 'Should return a PID')
+  assert.ok(result.process, 'Should return a process object')
+  assert.ok(typeof result.toggleProfiler === 'function', 'Should return toggleProfiler function')
+
+  // Clean up
+  result.process.kill()
+  fs.unlinkSync(testScript)
+})
+
+test('startProfiling should handle non-existent script', async (t) => {
+  const nonExistentScript = path.join(__dirname, 'non-existent.js')
+
+  // Should be able to start the process (spawn doesn't fail immediately)
+  const result = startProfiling(nonExistentScript)
+  assert.ok(typeof result.pid === 'number', 'Should return a PID')
+  assert.ok(result.process, 'Should return a process object')
+  assert.ok(typeof result.toggleProfiler === 'function', 'Should return toggleProfiler function')
+
+  // Wait for the process to exit (it will fail when trying to load the non-existent file)
+  const [exitCode] = await Promise.race([
+    once(result.process, 'exit'),
+    once(result.process, 'error').then(() => [-1])
+  ])
+
+  // On Windows, exit codes may be different, so just verify it's not a successful exit
+  assert.notStrictEqual(exitCode, 0, 'Process should not exit successfully with non-existent script')
+})
+
+test('parseProfile should throw error for non-existent file', async (t) => {
+  const nonExistentFile = path.join(__dirname, 'non-existent.pb')
+
+  await assert.rejects(
+    async () => parseProfile(nonExistentFile),
+    /Profile file not found/
+  )
+})
+
+test('generateFlamegraph should create HTML file', async (t) => {
+  // Skip this test if @platformatic/react-pprof is not available
+  try {
+    require.resolve('react-pprof/cli.js')
+  } catch (error) {
+    t.skip('react-pprof not available')
+    return
+  }
+
+  // Create a mock pprof file (this would need actual pprof data in real scenario)
+  const mockProfile = path.join(__dirname, 'temp-profile.pb')
+  const outputFile = path.join(__dirname, 'temp-output.html')
+
+  // Create minimal pprof data (this is just for testing the file handling)
+  fs.writeFileSync(mockProfile, Buffer.alloc(100))
+
+  try {
+    await generateFlamegraph(mockProfile, outputFile)
+    // The actual CLI might fail with invalid data, but we test the interface
+  } catch (error) {
+    // Expected to fail with mock data, but should not be a file system error
+    assert.ok(error.message.includes('CLI failed') || error.message.includes('Profile'), 'Should fail with profile parsing error, not file system error')
+  }
+
+  // Clean up
+  if (fs.existsSync(mockProfile)) fs.unlinkSync(mockProfile)
+  if (fs.existsSync(outputFile)) fs.unlinkSync(outputFile)
+
+  // Also clean up the JS file that the CLI creates
+  const jsFile = outputFile.replace('.html', '.js')
+  if (fs.existsSync(jsFile)) fs.unlinkSync(jsFile)
+})
diff --git a/test/preload.test.js b/test/preload.test.js
new file mode 100644
index 0000000..c641275
--- /dev/null
+++ b/test/preload.test.js
@@ -0,0 +1,169 @@
+'use strict'
+
+const test = require('node:test')
+const assert = require('node:assert')
+const { spawn } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+
+const preloadPath = path.join(__dirname, '..', 'preload.js')
+
+test('preload script should start without errors', async (t) => {
+  const testScript = path.join(__dirname, 'temp-preload-test.js')
+  fs.writeFileSync(testScript, `
+    console.log('Script started');
+    setTimeout(() => {
+      console.log('Script finished');
+      process.exit(0);
+    }, 100);
+  `)
+
+  const child = spawn('node', ['-r', preloadPath, testScript], {
+    stdio: 'pipe'
+  })
+
+  const result = await new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      resolve({ code, stdout, stderr })
+    })
+  })
+
+  // Clean up
+  fs.unlinkSync(testScript)
+
+  assert.strictEqual(result.code, 0, 'Should exit successfully')
+  assert.ok(result.stdout.includes('Flame preload script loaded'), 'Should show preload message')
+  assert.ok(result.stdout.includes('Process PID:'), 'Should show PID')
+  assert.ok(result.stdout.includes('Script started'), 'Should run the target script')
+  assert.ok(result.stdout.includes('Script finished'), 'Should complete the target script')
+})
+
+test('preload script should respond to SIGUSR2', { skip: process.platform === 'win32' ? 'SIGUSR2 not supported on Windows' : false }, async (t) => {
+  const testScript = path.join(__dirname, 'temp-signal-test.js')
+  fs.writeFileSync(testScript, `
+    console.log('Script started');
+    
+    // Keep the process alive for a bit
+    const timer = setTimeout(() => {
+      process.exit(0);
+    }, 2000);
+    
+    // Exit early if we get the expected profiler messages
+    process.stdout.on('data', (data) => {
+      if (data.includes('Starting CPU profiler')) {
+        clearTimeout(timer);
+        setTimeout(() => process.exit(0), 200);
+      }
+    });
+  `)
+
+  const child = spawn('node', ['-r', preloadPath, testScript], {
+    stdio: 'pipe'
+  })
+
+  // Send SIGUSR2 after a short delay
+  setTimeout(() => {
+    child.kill('SIGUSR2')
+  }, 500)
+
+  const result = await new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      resolve({ code, stdout, stderr })
+    })
+
+    // Force kill after timeout
+    setTimeout(() => {
+      child.kill('SIGKILL')
+      resolve({ code: -1, stdout, stderr })
+    }, 3000)
+  })
+
+  // Clean up
+  fs.unlinkSync(testScript)
+
+  assert.ok(result.stdout.includes('Starting CPU profiler'), 'Should start profiler on SIGUSR2')
+})
+
+test('preload script should create profile file on double SIGUSR2', { skip: process.platform === 'win32' ? 'SIGUSR2 not supported on Windows' : false }, async (t) => {
+  const testScript = path.join(__dirname, 'temp-profile-test.js')
+  fs.writeFileSync(testScript, `
+    console.log('Script started');
+    
+    let profileCount = 0;
+    const originalLog = console.log;
+    console.log = (...args) => {
+      originalLog(...args);
+      if (args[0] && args[0].includes('CPU profile written')) {
+        profileCount++;
+        if (profileCount >= 1) {
+          setTimeout(() => process.exit(0), 100);
+        }
+      }
+    };
+    
+    setTimeout(() => process.exit(0), 3000);
+  `)
+
+  const child = spawn('node', ['-r', preloadPath, testScript], {
+    stdio: 'pipe',
+    cwd: __dirname // Run in test directory so profile files are created here
+  })
+
+  // Send two SIGUSR2 signals to start and stop profiling
+  setTimeout(() => child.kill('SIGUSR2'), 500) // Start
+  setTimeout(() => child.kill('SIGUSR2'), 1000) // Stop
+
+  const result = await new Promise((resolve) => {
+    let stdout = ''
+    let stderr = ''
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString()
+    })
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString()
+    })
+
+    child.on('close', (code) => {
+      resolve({ code, stdout, stderr })
+    })
+  })
+
+  // Clean up script
+  fs.unlinkSync(testScript)
+
+  // Clean up any generated profile files
+  const files = fs.readdirSync(__dirname)
+  files.forEach(file => {
+    if (file.startsWith('cpu-profile-') && file.endsWith('.pb')) {
+      fs.unlinkSync(path.join(__dirname, file))
+    }
+  })
+
+  assert.ok(result.stdout.includes('Starting CPU profiler'), 'Should start profiler')
+  assert.ok(result.stdout.includes('Stopping CPU profiler'), 'Should stop profiler')
+  assert.ok(result.stdout.includes('CPU profile written'), 'Should write profile file')
+})