@africode/core 5.0.1 → 5.0.2

package/core/bun-runtime.js

@@ -1,799 +1,282 @@
 /**
  * Bun-Native Runtime Engine
- * Optimized runtime leveraging Bun's Zig-based architecture
- *
- * Provides ultra-fast startup, native APIs, and hot reloading
- * capabilities for high-performance fintech applications.
+ * Phase 1: Runtime Stability - Clean and predictable server
  *
  * @module core/bun-runtime
  */
 
-import { createReactiveState } from './state.js';
-import { FileBasedRouter } from './file-router.js';
+import { FileSystemRouter } from './router.js';
+import { RawHtml } from './html.js';
+import { getRequestIdentity } from './request-identity.js';
+import { sessionStore } from './session-store.js';
+import { actions } from './actions.js';
+import { MiddlewareManager, loggerMiddleware } from './middleware.js';
 import { EnhancedHMRMiddleware } from './enhanced-hmr.js';
+import { Database as BunSQLiteDatabase } from 'bun:sqlite';
+import { extname, join } from 'path';
 
-/**
- * Bun Runtime Configuration
- */
 export const BUN_CONFIG = {
-    startupTimeout: 5000, // 5ms target startup
-    memoryLimit: '1gb',
-    gcStrategy: 'generational',
-    threadPoolSize: 4
+  startupTimeout: 5000,
+  memoryLimit: '1gb',
+  gcStrategy: 'generational',
+  threadPoolSize: 4
 };
 
-/**
- * Bun HTTP Server with File-Based Routing
- * Autonomous application lifecycle management
- */
 export class BunHTTPServer {
-    constructor(options = {}) {
-        this.options = {
-            port: options.port || 3000,
-            pagesDir: options.pagesDir || 'pages',
-            publicDir: options.publicDir || 'public',
-            middleware: options.middleware || [],
-            enableHMR: options.enableHMR !== false,
-            ...options
-        };
-
-        this.router = new FileBasedRouter({
-            pagesDir: this.options.pagesDir
-        });
-
-        this.server = null;
-        this.hmr = null;
-    }
-
-    /**
-     * Start the HTTP server
-     */
-    async start() {
-        console.log(`🚀 Starting Bun HTTP Server on port ${this.options.port}`);
-
-        // Initialize HMR if enabled
-        if (this.options.enableHMR) {
-            this.hmr = new EnhancedHMRMiddleware({
-                port: this.options.port + 1,
-                watchPaths: [this.options.pagesDir, 'components', 'core']
-            });
-        }
-
-        // Create Bun server with file-based routing
-        this.server = Bun.serve({
-            port: this.options.port,
-            async fetch(request) {
-                const url = new URL(request.url);
-                const pathname = url.pathname;
-
-                // Handle static files
-                if (pathname.startsWith('/public/') || pathname.startsWith('/static/')) {
-                    return this._serveStaticFile(pathname);
-                }
-
-                // Handle HMR WebSocket upgrade
-                if (pathname === '/hmr' && this.hmr) {
-                    const upgrade = this.hmr.handleUpgrade(request);
-                    if (upgrade) return upgrade;
-                }
-
-                // Route to file-based handler
-                return this._handleRoute(request);
-            }.bind(this),
-
-            // WebSocket handling for HMR
-            websocket: this.hmr ? {
-                open: (ws) => this.hmr.handleClientConnect(ws),
-                message: (ws, message) => this.hmr.handleClientMessage(ws, message),
-                close: (ws) => this.hmr.handleClientDisconnect(ws)
-            } : undefined
-        });
-
-        // Start HMR watching
-        if (this.hmr) {
-            await this.hmr.initialize(this.server);
-        }
-
-        console.log(`📡 Server ready at http://localhost:${this.options.port}`);
-        console.log(`📊 Routes loaded:`, this.router.getRoutes());
-    }
+  constructor(options = {}) {
+    this.router = new FileSystemRouter(join(process.cwd(), options.pagesDir || 'pages'));
 
-    /**
-     * Handle incoming requests with file-based routing
-     */
-    async _handleRoute(request) {
-        const url = new URL(request.url);
-        const pathname = url.pathname;
-        const method = request.method;
+    this.middleware = new MiddlewareManager();
+    this.port = options.port || 3000;
+    this.server = null;
+  }
 
-        try {
-            // Match route
-            const routeMatch = this.router.matchRoute(pathname, method);
-
-            if (!routeMatch) {
-                return new Response('Not Found', { status: 404 });
-            }
-
-            // Load route handler/component
-            const handler = await this.router.loadRoute(routeMatch);
-
-            if (routeMatch.type === 'api') {
-                // Handle API route
-                return this._handleApiRoute(handler, request, routeMatch.params);
-            } else {
-                // Handle page route
-                return this._handlePageRoute(handler, request, routeMatch);
-            }
-
-        } catch (error) {
-            console.error('[Server] Route error:', error);
-            return new Response('Internal Server Error', { status: 500 });
-        }
-    }
+  async start() {
+    // Register middlewares
+    this.middleware.use(loggerMiddleware());
 
-    /**
-     * Handle API route execution
-     */
-    async _handleApiRoute(handler, request, params) {
-        try {
-            // Execute API handler
-            const result = await handler(request, { params });
-
-            if (result instanceof Response) {
-                return result;
-            }
-
-            // Convert to JSON response
-            return new Response(JSON.stringify(result), {
-                headers: { 'Content-Type': 'application/json' }
-            });
-
-        } catch (error) {
-            console.error('[Server] API error:', error);
-            return new Response(JSON.stringify({ error: error.message }), {
-                status: 500,
-                headers: { 'Content-Type': 'application/json' }
-            });
-        }
-    }
+    this.server = Bun.serve({
+      port: this.port,
 
-    /**
-     * Handle page route rendering
-     */
-    async _handlePageRoute(component, request, routeMatch) {
+      fetch: async (req) => {
         try {
-            // Render page component
-            const html = await this._renderPage(component, routeMatch);
-
-            return new Response(html, {
-                headers: { 'Content-Type': 'text/html' }
-            });
-
-        } catch (error) {
-            console.error('[Server] Page render error:', error);
-            return new Response('Render Error', { status: 500 });
-        }
-    }
-
-    /**
-     * Render page with layout
-     */
-    async _renderPage(component, routeMatch) {
-        let content = '';
-
-        // Render component
-        if (typeof component === 'function') {
-            content = component(routeMatch.params || {});
-        } else if (component.render) {
-            content = component.render(routeMatch.params || {});
-        } else {
-            content = String(component);
-        }
+          return await this.handleRequest(req);
+        } catch (err) {
+          console.error('Server Error:', err);
 
-        // Apply layout if available
-        if (routeMatch.layout) {
-            try {
-                const layoutModule = await import(routeMatch.layout);
-                const layout = layoutModule.default || layoutModule;
-
-                if (typeof layout === 'function') {
-                    content = layout({ children: content, params: routeMatch.params });
-                }
-            } catch (error) {
-                console.warn('[Server] Layout load error:', error.message);
-            }
+          return new Response('Internal Server Error', {
+            status: 500,
+          });
         }
+      },
+    });
+
+    console.log('AfriCode running on http://localhost:' + this.port);
+  }
+
+  async handleRequest(req) {
+    const url = new URL(req.url);
+    const pathname = url.pathname;
+    const sessionId = getRequestIdentity(req);
+    const session = sessionStore.get(sessionId);
+
+    if (pathname.startsWith('/public')) {
+      const response = await this.serveStatic(pathname);
+      return this.attachSessionCookie(response, sessionId);
+    }
+
+    let context = {
+      req,
+      url,
+      pathname,
+      params: {},
+      sessionId,
+      state: session,
+      actions,
+      sessionStore
+    };
 
-        // Wrap in basic HTML structure
-        return `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>AfriCode App</title>
-    <link rel="stylesheet" href="/public/styles.css">
-</head>
-<body>
-    ${content}
-    <script type="module" src="/public/app.js"></script>
-</body>
-</html>`;
-    }
-
-    /**
-     * Serve static files
-     */
-    _serveStaticFile(pathname) {
-        try {
-            const filePath = join(process.cwd(), pathname);
-            const file = Bun.file(filePath);
-            return new Response(file);
-        } catch {
-            return new Response('File Not Found', { status: 404 });
-        }
-    }
-
-    /**
-     * Stop the server
-     */
-    async stop() {
-        if (this.server) {
-            this.server.stop();
-        }
-        if (this.hmr) {
-            await this.hmr.shutdown();
-        }
-        console.log('🛑 Server stopped');
-    }
-}
-
-/**
- * Hot Reloading Engine
- * Enables zero-downtime updates with state preservation
- */
-export class HotReloadEngine {
-    constructor() {
-        this.modules = new Map();
-        this.state = createReactiveState({});
-        this.connections = new Set();
+    const mwResult = await this.middleware.run(context);
+    if (mwResult) {
+      return this.attachSessionCookie(mwResult, sessionId);
     }
 
-    /**
-     * Initialize hot reloading for a module
-     * @param {string} moduleId - Module identifier
-     * @param {Function} moduleFactory - Module factory function
-     */
-    initModule(moduleId, moduleFactory) {
-        const module = {
-            id: moduleId,
-            factory: moduleFactory,
-            instance: null,
-            lastModified: Date.now(),
-            dependencies: new Set()
-        };
-
-        this.modules.set(moduleId, module);
-        this._instantiateModule(module);
-        return module;
+    const route = this.router.resolve(pathname);
+    if (!route) {
+      return this.attachSessionCookie(new Response('Not Found', { status: 404 }), sessionId);
     }
 
-    /**
-     * Handle file change event
-     * @param {string} filePath - Changed file path
-     * @param {string} eventType - Change type (create, update, delete)
-     */
-    async handleFileChange(filePath, eventType) {
-        const moduleId = this._pathToModuleId(filePath);
-
-        if (eventType === 'delete') {
-            this.modules.delete(moduleId);
-            this._broadcastReload(moduleId, 'delete');
-            return;
+    try {
+      context = {
+        ...context,
+        params: route.params || {},
+        route: {
+          pathname,
+          filePath: route.filePath,
+          isApi: route.isApi,
+          isDynamic: route.isDynamic
         }
+      };
 
-        // Check if module needs reloading
-        const module = this.modules.get(moduleId);
-        if (!module) return;
-
-        try {
-            const stats = await Bun.file(filePath).stat();
-            if (stats.mtime > module.lastModified) {
-                await this._reloadModule(moduleId);
-            }
-        } catch (error) {
-            console.warn('[HMR] File stat error:', error.message);
-        }
-    }
+      if (!route.isApi && extname(route.filePath) === '.html') {
+        const html = await Bun.file(route.filePath).text();
+        const response = new Response(html, {
+          headers: { 'Content-Type': 'text/html; charset=utf-8' }
+        });
+        return this.attachSessionCookie(response, sessionId);
+      }
 
-    /**
-     * Reload a module with state preservation
-     * @param {string} moduleId - Module to reload
-     */
-    async _reloadModule(moduleId) {
-        const module = this.modules.get(moduleId);
-        if (!module) return;
+      const pageModule = await import(route.filePath);
 
-        // Preserve current state
-        const oldState = module.instance?.state || {};
+      if (route.isApi) {
+        const method = req.method.toUpperCase();
+        const handler = pageModule[method];
 
-        // Dispose old instance
-        if (module.instance?.dispose) {
-            module.instance.dispose();
+        if (!handler) {
+          throw new Error("No " + method + " handler in API route");
         }
 
-        // Reload module
-        try {
-            // Clear module cache if possible
-            if (typeof require !== 'undefined' && require.cache) {
-                delete require.cache[moduleId];
-            }
+        const result = await handler(context);
+        const response = this.normalizeResponse(result);
+        return this.attachSessionCookie(response, sessionId);
+      }
 
-            await this._instantiateModule(module);
+      const handler = pageModule.default;
+      if (!handler) {
+        throw new Error('No default export in page');
+      }
 
-            // Restore state
-            if (module.instance?.restoreState) {
-                module.instance.restoreState(oldState);
-            }
-
-            this._broadcastReload(moduleId, 'update');
-        } catch (error) {
-            console.error('[HMR] Module reload error:', error.message);
-        }
+      const result = await handler(context);
+      const response = this.normalizeResponse(result);
+      return this.attachSessionCookie(response, sessionId);
+    } catch (err) {
+      console.error('Route Error:', err);
+      return this.attachSessionCookie(new Response('Route Error', { status: 500 }), sessionId);
     }
+  }
+  attachSessionCookie(response, sessionId) {
+    const cookie = 'afri_session=' + sessionId + '; Path=/; HttpOnly; SameSite=Strict';
 
-    /**
-     * Instantiate a module
-     * @param {Object} module - Module object
-     */
-    async _instantiateModule(module) {
-        try {
-            module.instance = await module.factory();
-            module.lastModified = Date.now();
-        } catch (error) {
-            console.error('[HMR] Module instantiation error:', error.message);
-            module.instance = null;
-        }
-        return module;
+    if (response.headers.has('Set-Cookie')) {
+      response.headers.append('Set-Cookie', cookie);
+    } else {
+      response.headers.set('Set-Cookie', cookie);
     }
 
-    /**
-     * Convert file path to module ID
-     * @param {string} filePath - File path
-     * @returns {string} Module ID
-     */
-    _pathToModuleId(filePath) {
-        return filePath.replace(/\\/g, '/').replace(process.cwd() + '/', '');
-    }
+    return response;
+  }
 
-    /**
-     * Broadcast reload event to connected clients
-     * @param {string} moduleId - Module ID
-     * @param {string} eventType - Event type
-     */
-    _broadcastReload(moduleId, eventType) {
-        const message = {
-            type: 'module-update',
-            moduleId,
-            eventType,
-            timestamp: Date.now()
-        };
-
-        for (const ws of this.connections) {
-            try {
-                ws.send(JSON.stringify(message));
-            } catch (error) {
-                this.connections.delete(ws);
-            }
-        }
-    }
-}
+  normalizeResponse(result) {
+    // ✅ Already a Response
+    if (result instanceof Response) return result;
 
-// Import join function for static file serving
-import { join } from 'path';
-        this.connections = new Set();
+    // ✅ RawHtml (PRIMARY)
+    if (result instanceof RawHtml) {
+      return new Response(result.toString(), {
+        headers: { 'Content-Type': 'text/html' },
+      });
     }
 
-    /**
-     * Initialize hot reloading for a module
-     * @param {string} moduleId - Module identifier
-     * @param {Function} moduleFactory - Module factory function
-     */
-    initModule(moduleId, moduleFactory) {
-        const module = {
-            id: moduleId,
-            factory: moduleFactory,
-            instance: null,
-            lastModified: Date.now(),
-            dependencies: new Set()
-        };
-
-        this.modules.set(moduleId, module);
-        this._instantiateModule(module);
-
-        return module;
+    // ✅ String fallback
+    if (typeof result === 'string') {
+      return new Response(result, {
+        headers: { 'Content-Type': 'text/html' },
+      });
     }
 
-    /**
-     * Handle file change event
-     * @param {string} filePath - Changed file path
-     * @param {string} eventType - Change type (create, update, delete)
-     */
-    async handleFileChange(filePath, eventType) {
-        const moduleId = this._pathToModuleId(filePath);
-
-        if (eventType === 'delete') {
-            this.modules.delete(moduleId);
-            this._broadcastReload(moduleId, 'delete');
-            return;
-        }
-
-        // Check if module needs reloading
-        const module = this.modules.get(moduleId);
-        if (!module) return;
-
-        const stats = await Bun.file(filePath).stat();
-        if (stats.mtime > module.lastModified) {
-            await this._reloadModule(moduleId);
-        }
-    }
-
-    /**
-     * Reload a module with state preservation
-     * @param {string} moduleId - Module to reload
-     */
-    async _reloadModule(moduleId) {
-        const module = this.modules.get(moduleId);
-        if (!module) return;
-
-        // Preserve current state
-        const oldState = module.instance?.state || {};
+    // ❌ Invalid return type
+    console.error('Invalid render output:', result);
 
-        // Dispose old instance
-        if (module.instance?.dispose) {
-            module.instance.dispose();
-        }
-
-        // Reload module
-        delete require.cache[moduleId]; // Clear Node.js cache if applicable
-        await this._instantiateModule(module);
-
-        // Restore state
-        if (module.instance?.restoreState) {
-            module.instance.restoreState(oldState);
-        }
+    return new Response('Invalid response type', { status: 500 });
+  }
 
-        // Update timestamp
-        module.lastModified = Date.now();
-
-        // Broadcast reload to clients
-        this._broadcastReload(moduleId, 'update');
-    }
-
-    /**
-     * Instantiate a module
-     * @param {Object} module - Module definition
-     */
-    async _instantiateModule(module) {
-        try {
-            module.instance = await module.factory();
-
-            // Store state for hot reload
-            if (module.instance) {
-                module.instance.state = this.state[module.id] || {};
-            }
-        } catch (error) {
-            console.error(`Failed to instantiate module ${module.id}:`, error);
-        }
+  async serveStatic(pathname) {
+    // Basic path traversal protection
+    if (pathname.includes('..') || pathname.includes('\\')) {
+      return new Response('Forbidden', { status: 403 });
     }
 
-    /**
-     * Broadcast reload event to connected clients
-     * @param {string} moduleId - Reloaded module
-     * @param {string} type - Reload type
-     */
-    _broadcastReload(moduleId, type) {
-        const message = {
-            type: 'hot-reload',
-            moduleId,
-            reloadType: type,
-            timestamp: Date.now()
-        };
-
-        for (const ws of this.connections) {
-            if (ws.readyState === WebSocket.OPEN) {
-                ws.send(JSON.stringify(message));
-            }
-        }
-    }
+    const filePath = join(process.cwd(), pathname);
 
-    /**
-     * Add WebSocket connection for hot reload notifications
-     * @param {WebSocket} ws - WebSocket connection
-     */
-    addConnection(ws) {
-        this.connections.add(ws);
+    try {
+      const file = Bun.file(filePath);
 
-        ws.on('close', () => {
-            this.connections.delete(ws);
-        });
-    }
+      if (!(await file.exists())) {
+        return new Response('Not Found', { status: 404 });
+      }
 
-    /**
-     * Convert file path to module ID
-     * @param {string} filePath - File path
-     */
-    _pathToModuleId(filePath) {
-        return filePath.replace(/\\/g, '/').replace(/^.*\/src\//, '');
+      return new Response(file);
+    } catch (err) {
+      console.error('Static Error:', err);
+      return new Response('Static File Error', { status: 500 });
     }
+  }
 }
 
-/**
- * Bun-Optimized HTTP Server
- * Leveraging Bun.serve for maximum performance
- */
-export class BunHTTPServer {
-    constructor(config = {}) {
-        this.config = {
-            port: config.port || 3000,
-            hostname: config.hostname || 'localhost',
-            ...config
-        };
-
-        this.routes = new Map();
-        this.middlewares = [];
-        this.hotReload = new HotReloadEngine();
-    }
-
-    /**
-     * Register a route handler
-     * @param {string} method - HTTP method
-     * @param {string} path - Route path
-     * @param {Function} handler - Route handler
-     */
-    route(method, path, handler) {
-        const key = `${method}:${path}`;
-        this.routes.set(key, handler);
-    }
-
-    /**
-     * Add middleware
-     * @param {Function} middleware - Middleware function
-     */
-    use(middleware) {
-        this.middlewares.push(middleware);
-    }
-
-    /**
-     * Start the server
-     */
-    start() {
-        const server = Bun.serve({
-            port: this.config.port,
-            hostname: this.config.hostname,
-
-            async fetch(request) {
-                const url = new URL(request.url);
-                const method = request.method;
-                const path = url.pathname;
-
-                // Apply middlewares
-                let response = null;
-                for (const middleware of this.middlewares) {
-                    response = await middleware(request, () => null);
-                    if (response) break;
-                }
-
-                if (!response) {
-                    // Find route handler
-                    const key = `${method}:${path}`;
-                    const handler = this.routes.get(key);
-
-                    if (handler) {
-                        response = await handler(request);
-                    } else {
-                        response = new Response('Not Found', { status: 404 });
-                    }
-                }
-
-                return response;
-            },
-
-            websocket: {
-                open: (ws) => {
-                    this.hotReload.addConnection(ws);
-                },
-
-                message: (ws, message) => {
-                    // Handle WebSocket messages
-                    console.log('WebSocket message:', message);
-                }
-            }
-        });
-
-        console.log(`🚀 Bun Server running on ${server.url}`);
-        return server;
-    }
-
-    /**
-     * Enable hot reloading
-     * @param {string[]} watchPaths - Paths to watch for changes
-     */
-    enableHotReload(watchPaths = ['./src']) {
-        // File watcher using Bun's native file watching
-        console.log('Hot reload not yet implemented for this Bun version');
-        // TODO: Implement when Bun.watch is available
-        /*
-        for (const watchPath of watchPaths) {
-            const watcher = Bun.watch(watchPath, {
-                persistent: true
-            });
-
-            watcher.on('change', async (event, filename) => {
-                await this.hotReload.handleFileChange(filename, event);
-            });
-        }
-        */
-    }
-}
+export class HotReloadEngine extends EnhancedHMRMiddleware {}
 
-/**
- * Bun-Native Database Connection
- * Leveraging Bun.sql for type-safe SQLite operations
- */
 export class BunDatabase {
-    constructor(dbPath = './afriCode.db') {
-        this.db = new Bun.sql(`${dbPath}`);
+  constructor(dbPath = './afriCode.db') {
+    this.db = new BunSQLiteDatabase(dbPath, { create: true });
+  }
 
-        // Enable WAL mode for better concurrency
-        try {
-            this.db.query('PRAGMA journal_mode = WAL').run();
-            this.db.query('PRAGMA synchronous = NORMAL').run();
-            this.db.query('PRAGMA cache_size = 1000000').run();
-        } catch (e) {
-            // Ignore pragma errors in demo
-            console.warn('Database pragma setup failed:', e.message);
-        }
-    }
-
-    /**
-     * Execute a query with parameters
-     * @param {string} sql - SQL query
-     * @param {Array} params - Query parameters
-     */
-    query(sql, params = []) {
-        try {
-            return this.db.query(sql).all(...params);
-        } catch (e) {
-            console.warn('Query failed:', sql, e.message);
-            return [];
-        }
-    }
+  query(sql, params = []) {
+    return this.db.query(sql).all(...params);
+  }
 
-    /**
-     * Execute a query and get first result
-     * @param {string} sql - SQL query
-     * @param {Array} params - Query parameters
-     */
-    get(sql, params = []) {
-        try {
-            return this.db.query(sql).get(...params);
-        } catch (e) {
-            console.warn('Get query failed:', sql, e.message);
-            return null;
-        }
-    }
+  get(sql, params = []) {
+    return this.db.query(sql).get(...params);
+  }
 
-    /**
-     * Execute a mutation query
-     * @param {string} sql - SQL query
-     * @param {Array} params - Query parameters
-     */
-    run(sql, params = []) {
-        try {
-            return this.db.query(sql).run(...params);
-        } catch (e) {
-            console.warn('Run query failed:', sql, e.message);
-            return null;
-        }
-    }
+  run(sql, params = []) {
+    return this.db.query(sql).run(...params);
+  }
 
-    /**
-     * Execute multiple queries in a transaction
-     * @param {Function} callback - Transaction callback
-     */
-    transaction(callback) {
-        return this.db.transaction(callback)();
-    }
+  transaction(callback) {
+    return this.db.transaction(callback)();
+  }
 
-    /**
-     * Close database connection
-     */
-    close() {
-        this.db.close();
-    }
+  close() {
+    this.db.close();
+  }
 }
 
-/**
- * Performance Monitoring
- * Real-time performance metrics using Bun's high-resolution timers
- */
 export class PerformanceMonitor {
-    constructor() {
-        this.metrics = createReactiveState({
-            startupTime: 0,
-            requestCount: 0,
-            averageResponseTime: 0,
-            memoryUsage: 0,
-            activeConnections: 0
-        });
-
-        this.requestTimes = [];
-        this.startTime = performance.now();
-    }
-
-    /**
-     * Record request timing
-     * @param {number} duration - Request duration in ms
-     */
-    recordRequest(duration) {
-        this.requestTimes.push(duration);
+  constructor() {
+    this.metrics = {
+      startupTime: 0,
+      requestCount: 0,
+      averageResponseTime: 0,
+      memoryUsage: 0,
+      activeConnections: 0
+    };
+    this.requestTimes = [];
+    this.startTime = performance.now();
+  }
 
-        // Keep only last 1000 requests for averaging
-        if (this.requestTimes.length > 1000) {
-            this.requestTimes.shift();
-        }
+  recordRequest(duration) {
+    this.requestTimes.push(duration);
 
-        this.metrics.requestCount++;
-        this.metrics.averageResponseTime =
-            this.requestTimes.reduce((a, b) => a + b, 0) / this.requestTimes.length;
+    if (this.requestTimes.length > 1000) {
+      this.requestTimes.shift();
     }
 
-    /**
-     * Update memory usage
-     */
-    updateMemoryUsage() {
-        if (typeof process !== 'undefined' && process.memoryUsage) {
-            this.metrics.memoryUsage = process.memoryUsage().heapUsed;
-        }
-    }
+    this.metrics.requestCount++;
+    this.metrics.averageResponseTime =
+      this.requestTimes.reduce((a, b) => a + b, 0) / this.requestTimes.length;
+  }
 
-    /**
-     * Get current metrics
-     */
-    getMetrics() {
-        this.updateMemoryUsage();
-        return { ...this.metrics };
+  updateMemoryUsage() {
+    if (typeof process !== 'undefined' && process.memoryUsage) {
+      this.metrics.memoryUsage = process.memoryUsage().heapUsed;
     }
+  }
 
-    /**
-     * Start periodic metrics collection
-     * @param {number} interval - Collection interval in ms
-     */
-    startCollection(interval = 5000) {
-        setInterval(() => {
-            this.updateMemoryUsage();
-        }, interval);
-    }
+  getMetrics() {
+    this.updateMemoryUsage();
+    return { ...this.metrics };
+  }
+
+  startCollection(interval = 5000) {
+    setInterval(() => {
+      this.updateMemoryUsage();
+    }, interval);
+  }
 }
 
-/**
- * Initialize Bun-native runtime
- */
-export function initBunRuntime(config = {}) {
-    const runtime = {
-        server: new BunHTTPServer(config.server),
-        database: config.database ? new BunDatabase(config.database.path) : null,
-        monitor: new PerformanceMonitor(),
-        hotReload: new HotReloadEngine()
-    };
+export async function initBunRuntime(config = {}) {
+  const runtime = {
+    server: new BunHTTPServer(config.server),
+    database: config.database ? new BunDatabase(config.database.path) : null,
+    monitor: new PerformanceMonitor(),
+    hotReload: config.hotReload ? new HotReloadEngine(config.hotReload) : null
+  };
 
-    // Start performance monitoring
-    runtime.monitor.startCollection();
+  runtime.monitor.startCollection();
 
-    // Enable hot reloading if in development
-    if (config.hotReload) {
-        runtime.server.enableHotReload(config.hotReload.watchPaths);
-    }
+  if (runtime.hotReload && runtime.server) {
+    await runtime.hotReload.initialize(runtime.server);
+  }
 
-    return runtime;
-}
+  return runtime;
+}