bxo 0.0.5-dev.51 → 0.0.5-dev.53

package/index.ts

@@ -1,1550 +1,5 @@
-import { z } from 'zod';
+// Re-export everything from the refactored source
+export * from './src/index';
 
-// Type utilities for extracting types from Zod schemas
-type InferZodType<T> = T extends z.ZodType<infer U> ? U : never;
-
-// Response configuration types
-type ResponseSchema = z.ZodSchema<any>;
-type StatusResponseSchema = Record<number, ResponseSchema>;
-type ResponseConfig = ResponseSchema | StatusResponseSchema;
-
-// Type utility to extract response type from response config
-type InferResponseType<T> = T extends ResponseSchema
-  ? InferZodType<T>
-  : T extends StatusResponseSchema
-  ? { [K in keyof T]: InferZodType<T[K]> }[keyof T]
-  : never;
-
-// Cookie options interface for setting cookies
-interface CookieOptions {
-  domain?: string;
-  path?: string;
-  expires?: Date;
-  maxAge?: number;
-  secure?: boolean;
-  httpOnly?: boolean;
-  sameSite?: 'Strict' | 'Lax' | 'None';
-}
-
-// OpenAPI detail information
-interface RouteDetail {
-  summary?: string;
-  description?: string;
-  tags?: string[];
-  operationId?: string;
-  deprecated?: boolean;
-  produces?: string[];
-  consumes?: string[];
-  [key: string]: any; // Allow additional OpenAPI properties
-}
-
-// Configuration interface for route handlers
-interface RouteConfig {
-  params?: z.ZodSchema<any>;
-  query?: z.ZodSchema<any>;
-  body?: z.ZodSchema<any>;
-  headers?: z.ZodSchema<any>;
-  cookies?: z.ZodSchema<any>;
-  response?: ResponseConfig;
-  detail?: RouteDetail;
-}
-
-// Helper type to extract status codes from response config
-type StatusCodes<T> = T extends Record<number, any> ? keyof T : never;
-
-// Context type that's fully typed based on the route configuration
-export type Context<TConfig extends RouteConfig = {}> = {
-  params: TConfig['params'] extends z.ZodSchema<any> ? InferZodType<TConfig['params']> : Record<string, string>;
-  query: TConfig['query'] extends z.ZodSchema<any> ? InferZodType<TConfig['query']> : Record<string, string | undefined>;
-  body: TConfig['body'] extends z.ZodSchema<any> ? InferZodType<TConfig['body']> : unknown;
-  headers: TConfig['headers'] extends z.ZodSchema<any> ? InferZodType<TConfig['headers']> : Record<string, string>;
-  cookies: TConfig['cookies'] extends z.ZodSchema<any> ? InferZodType<TConfig['cookies']> : Record<string, string>;
-  path: string;
-  request: Request;
-  set: {
-    status: number;
-    headers: Record<string, string>;
-    cookies: (name: string, value: string, options?: CookieOptions) => void;
-    redirect?: { location: string; status?: number };
-  };
-  status: <T extends number>(
-    code: TConfig['response'] extends StatusResponseSchema
-      ? StatusCodes<TConfig['response']> | number
-      : T,
-    data?: TConfig['response'] extends StatusResponseSchema
-      ? T extends keyof TConfig['response']
-      ? InferZodType<TConfig['response'][T]>
-      : any
-      : TConfig['response'] extends ResponseSchema
-      ? InferZodType<TConfig['response']>
-      : any
-  ) => TConfig['response'] extends StatusResponseSchema
-    ? T extends keyof TConfig['response']
-    ? InferZodType<TConfig['response'][T]>
-    : any
-    : TConfig['response'] extends ResponseSchema
-    ? InferZodType<TConfig['response']>
-    : any;
-  redirect: (location: string, status?: number) => Response;
-  clearRedirect: () => void;
-  [key: string]: any;
-};
-
-// Internal cookie storage interface
-interface InternalCookie {
-  name: string;
-  value: string;
-  domain?: string;
-  path?: string;
-  expires?: Date;
-  maxAge?: number;
-  secure?: boolean;
-  httpOnly?: boolean;
-  sameSite?: 'Strict' | 'Lax' | 'None';
-}
-
-// Handler function type with proper response typing
-type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<InferResponseType<TConfig['response']> | any> | InferResponseType<TConfig['response']> | any;
-
-// Route definition
-interface Route {
-  method: string;
-  path: string;
-  handler: Handler<any>;
-  config?: RouteConfig;
-}
-
-// WebSocket handler interface
-interface WebSocketHandler {
-  onOpen?: (ws: any) => void;
-  onMessage?: (ws: any, message: string | Buffer) => void;
-  onClose?: (ws: any, code?: number, reason?: string) => void;
-  onError?: (ws: any, error: Error) => void;
-}
-
-// WebSocket route definition
-interface WSRoute {
-  path: string;
-  handler: WebSocketHandler;
-}
-
-// Lifecycle hooks
-interface LifecycleHooks {
-  onBeforeStart?: (instance: BXO) => Promise<void> | void;
-  onAfterStart?: (instance: BXO) => Promise<void> | void;
-  onBeforeStop?: (instance: BXO) => Promise<void> | void;
-  onAfterStop?: (instance: BXO) => Promise<void> | void;
-  onRequest?: (ctx: Context, instance: BXO) => Promise<void> | void;
-  onResponse?: (ctx: Context, response: any, instance: BXO) => Promise<any> | any;
-  onError?: (ctx: Context, error: Error, instance: BXO) => Promise<any> | any;
-}
-
-// Add global options for BXO
-interface BXOOptions {
-  enableValidation?: boolean;
-}
-
-// Plugin interface for middleware-style plugins
-interface Plugin {
-  name?: string;
-  onRequest?: (ctx: Context) => Promise<Response | void> | Response | void;
-  onResponse?: (ctx: Context, response: any) => Promise<any> | any;
-  onError?: (ctx: Context, error: Error) => Promise<any> | any;
-}
-
-export default class BXO {
-  private _routes: Route[] = [];
-  private _wsRoutes: WSRoute[] = [];
-  private plugins: BXO[] = [];
-  private middleware: Plugin[] = []; // New middleware array
-  private hooks: {
-    onBeforeStart?: (instance: BXO) => Promise<void> | void;
-    onAfterStart?: (instance: BXO) => Promise<void> | void;
-    onBeforeRestart?: (instance: BXO) => Promise<void> | void;
-    onAfterRestart?: (instance: BXO) => Promise<void> | void;
-    onBeforeStop?: (instance: BXO) => Promise<void> | void;
-    onAfterStop?: (instance: BXO) => Promise<void> | void;
-    onRequest?: (ctx: Context, instance: BXO) => Promise<Response | void> | Response | void;
-    onResponse?: (ctx: Context, response: any, instance: BXO) => Promise<any> | any;
-    onError?: (ctx: Context, error: Error, instance: BXO) => Promise<any> | any;
-  } = {};
-  private server?: any;
-  private isRunning: boolean = false;
-  private serverPort?: number;
-  private serverHostname?: string;
-  private enableValidation: boolean = true;
-
-  constructor(options?: BXOOptions) {
-    this.enableValidation = options?.enableValidation ?? true;
-  }
-
-  // Lifecycle hook methods
-  onBeforeStart(handler: (instance: BXO) => Promise<void> | void): this {
-    this.hooks.onBeforeStart = handler;
-    return this;
-  }
-
-  onAfterStart(handler: (instance: BXO) => Promise<void> | void): this {
-    this.hooks.onAfterStart = handler;
-    return this;
-  }
-
-  onBeforeStop(handler: (instance: BXO) => Promise<void> | void): this {
-    this.hooks.onBeforeStop = handler;
-    return this;
-  }
-
-  onAfterStop(handler: (instance: BXO) => Promise<void> | void): this {
-    this.hooks.onAfterStop = handler;
-    return this;
-  }
-
-
-
-  onRequest(handler: (ctx: Context, instance: BXO) => Promise<void> | void): this {
-    this.hooks.onRequest = handler;
-    return this;
-  }
-
-  onResponse(handler: (ctx: Context, response: any, instance: BXO) => Promise<any> | any): this {
-    this.hooks.onResponse = handler;
-    return this;
-  }
-
-  onError(handler: (ctx: Context, error: Error, instance: BXO) => Promise<any> | any): this {
-    this.hooks.onError = handler;
-    return this;
-  }
-
-  // Plugin system - now accepts both BXO instances and middleware plugins
-  use(plugin: BXO | Plugin): this {
-    if ('_routes' in plugin) {
-      // It's a BXO instance
-      this.plugins.push(plugin);
-    } else {
-      // It's a middleware plugin
-      this.middleware.push(plugin);
-    }
-    return this;
-  }
-
-  // HTTP method handlers with overloads for type safety
-  get<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  get<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  get<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'GET', path, handler, config });
-    return this;
-  }
-
-  post<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  post<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  post<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'POST', path, handler, config });
-    return this;
-  }
-
-  put<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  put<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  put<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'PUT', path, handler, config });
-    return this;
-  }
-
-  delete<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  delete<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  delete<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'DELETE', path, handler, config });
-    return this;
-  }
-
-  patch<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>
-  ): this;
-  patch<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config: TConfig
-  ): this;
-  patch<TConfig extends RouteConfig = {}>(
-    path: string,
-    handler: Handler<TConfig>,
-    config?: TConfig
-  ): this {
-    this._routes.push({ method: 'PATCH', path, handler, config });
-    return this;
-  }
-
-  // WebSocket route handler
-  ws(path: string, handler: WebSocketHandler): this {
-    this._wsRoutes.push({ path, handler });
-    return this;
-  }
-
-  // Helper methods to get all routes including plugin routes
-  private getAllRoutes(): Route[] {
-    const allRoutes = [...this._routes];
-    for (const plugin of this.plugins) {
-      allRoutes.push(...plugin._routes);
-    }
-    return allRoutes;
-  }
-
-  private getAllWSRoutes(): WSRoute[] {
-    const allWSRoutes = [...this._wsRoutes];
-    for (const plugin of this.plugins) {
-      allWSRoutes.push(...plugin._wsRoutes);
-    }
-    return allWSRoutes;
-  }
-
-  // Route matching utility
-  private matchRoute(method: string, pathname: string): { route: Route; params: Record<string, string> } | null {
-    const allRoutes = this.getAllRoutes();
-
-    for (const route of allRoutes) {
-      if (route.method !== method) continue;
-
-      const routeSegments = route.path.split('/').filter(Boolean);
-      const pathSegments = pathname.split('/').filter(Boolean);
-
-      const params: Record<string, string> = {};
-      let isMatch = true;
-
-      // Check for double wildcard (**) in the route
-      const hasDoubleWildcard = routeSegments.some(segment => segment === '**');
-
-      // Handle double wildcard at the end (catch-all with slashes)
-      const hasDoubleWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '**';
-
-      // Handle single wildcard at the end (catch-all)
-      const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
-
-      if (hasDoubleWildcardAtEnd) {
-        // For double wildcard at end, path must have at least as many segments as route (minus the double wildcard)
-        if (pathSegments.length < routeSegments.length - 1) continue;
-      } else if (hasWildcardAtEnd) {
-        // For single wildcard at end, path must have at least as many segments as route (minus the wildcard)
-        if (pathSegments.length < routeSegments.length - 1) continue;
-      } else if (!hasDoubleWildcard) {
-        // For exact matching (with possible single-segment wildcards), lengths must match
-        if (routeSegments.length !== pathSegments.length) continue;
-      }
-
-      for (let i = 0; i < routeSegments.length; i++) {
-        const routeSegment = routeSegments[i];
-        const pathSegment = pathSegments[i];
-
-        if (!routeSegment) {
-          isMatch = false;
-          break;
-        }
-
-        // Handle double wildcard at the end (matches everything including slashes)
-        if (routeSegment === '**' && i === routeSegments.length - 1) {
-          const remainingPath = pathSegments.slice(i).join('/');
-          params['**'] = remainingPath;
-          break;
-        }
-
-        // Handle single wildcard at the end (catch-all)
-        if (routeSegment === '*' && i === routeSegments.length - 1) {
-          // Wildcard at end matches remaining path segments
-          const remainingPath = pathSegments.slice(i).join('/');
-          params['*'] = remainingPath;
-          break;
-        }
-
-        // Handle double wildcard in the middle (matches everything including slashes)
-        if (routeSegment === '**') {
-          // Find the next non-wildcard segment to match against
-          let nextNonWildcardIndex = i + 1;
-          while (nextNonWildcardIndex < routeSegments.length &&
-            (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
-            nextNonWildcardIndex++;
-          }
-
-          if (nextNonWildcardIndex >= routeSegments.length) {
-            // Double wildcard is at the end or followed by other wildcards
-            const remainingPath = pathSegments.slice(i).join('/');
-            params['**'] = remainingPath;
-            break;
-          }
-
-          // Find the next matching segment in the path
-          const nextRouteSegment = routeSegments[nextNonWildcardIndex];
-          if (!nextRouteSegment) {
-            isMatch = false;
-            break;
-          }
-
-          let foundMatch = false;
-          let matchedPath = '';
-
-          for (let j = i; j < pathSegments.length; j++) {
-            const currentPathSegment = pathSegments[j];
-
-            // Check if this path segment matches the next route segment
-            if (nextRouteSegment.startsWith(':')) {
-              // Param segment - always matches
-              matchedPath = pathSegments.slice(i, j).join('/');
-              params['**'] = matchedPath;
-              i = j - 1; // Adjust index for the next iteration
-              foundMatch = true;
-              break;
-            } else if (nextRouteSegment === '*') {
-              // Single wildcard - always matches
-              matchedPath = pathSegments.slice(i, j).join('/');
-              params['**'] = matchedPath;
-              i = j - 1; // Adjust index for the next iteration
-              foundMatch = true;
-              break;
-            } else if (nextRouteSegment === currentPathSegment) {
-              // Exact match
-              matchedPath = pathSegments.slice(i, j).join('/');
-              params['**'] = matchedPath;
-              i = j - 1; // Adjust index for the next iteration
-              foundMatch = true;
-              break;
-            }
-          }
-
-          if (!foundMatch) {
-            isMatch = false;
-            break;
-          }
-
-          continue;
-        }
-
-        if (!pathSegment) {
-          isMatch = false;
-          break;
-        }
-
-        if (routeSegment.startsWith(':')) {
-          const paramName = routeSegment.slice(1);
-          params[paramName] = pathSegment;
-        } else if (routeSegment === '*') {
-          // Single segment wildcard
-          params['*'] = pathSegment;
-        } else if (routeSegment !== pathSegment) {
-          isMatch = false;
-          break;
-        }
-      }
-
-      if (isMatch) {
-        return { route, params };
-      }
-    }
-
-    return null;
-  }
-
-  // WebSocket route matching utility
-  private matchWSRoute(pathname: string): { route: WSRoute; params: Record<string, string> } | null {
-    const allWSRoutes = this.getAllWSRoutes();
-
-    for (const route of allWSRoutes) {
-      const routeSegments = route.path.split('/').filter(Boolean);
-      const pathSegments = pathname.split('/').filter(Boolean);
-
-      const params: Record<string, string> = {};
-      let isMatch = true;
-
-      // Check for double wildcard (**) in the route
-      const hasDoubleWildcard = routeSegments.some(segment => segment === '**');
-
-      // Handle double wildcard at the end (catch-all with slashes)
-      const hasDoubleWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '**';
-
-      // Handle single wildcard at the end (catch-all)
-      const hasWildcardAtEnd = routeSegments.length > 0 && routeSegments[routeSegments.length - 1] === '*';
-
-      if (hasDoubleWildcardAtEnd) {
-        // For double wildcard at end, path must have at least as many segments as route (minus the double wildcard)
-        if (pathSegments.length < routeSegments.length - 1) continue;
-      } else if (hasWildcardAtEnd) {
-        // For single wildcard at end, path must have at least as many segments as route (minus the wildcard)
-        if (pathSegments.length < routeSegments.length - 1) continue;
-      } else if (!hasDoubleWildcard) {
-        // For exact matching (with possible single-segment wildcards), lengths must match
-        if (routeSegments.length !== pathSegments.length) continue;
-      }
-
-      for (let i = 0; i < routeSegments.length; i++) {
-        const routeSegment = routeSegments[i];
-        const pathSegment = pathSegments[i];
-
-        if (!routeSegment) {
-          isMatch = false;
-          break;
-        }
-
-        // Handle double wildcard at the end (matches everything including slashes)
-        if (routeSegment === '**' && i === routeSegments.length - 1) {
-          const remainingPath = pathSegments.slice(i).join('/');
-          params['**'] = remainingPath;
-          break;
-        }
-
-        // Handle single wildcard at the end (catch-all)
-        if (routeSegment === '*' && i === routeSegments.length - 1) {
-          // Wildcard at end matches remaining path segments
-          const remainingPath = pathSegments.slice(i).join('/');
-          params['*'] = remainingPath;
-          break;
-        }
-
-        // Handle double wildcard in the middle (matches everything including slashes)
-        if (routeSegment === '**') {
-          // Find the next non-wildcard segment to match against
-          let nextNonWildcardIndex = i + 1;
-          while (nextNonWildcardIndex < routeSegments.length &&
-            (routeSegments[nextNonWildcardIndex] === '*' || routeSegments[nextNonWildcardIndex] === '**')) {
-            nextNonWildcardIndex++;
-          }
-
-          if (nextNonWildcardIndex >= routeSegments.length) {
-            // Double wildcard is at the end or followed by other wildcards
-            const remainingPath = pathSegments.slice(i).join('/');
-            params['**'] = remainingPath;
-            break;
-          }
-
-          // Find the next matching segment in the path
-          const nextRouteSegment = routeSegments[nextNonWildcardIndex];
-          if (!nextRouteSegment) {
-            isMatch = false;
-            break;
-          }
-
-          let foundMatch = false;
-          let matchedPath = '';
-
-          for (let j = i; j < pathSegments.length; j++) {
-            const currentPathSegment = pathSegments[j];
-
-            // Check if this path segment matches the next route segment
-            if (nextRouteSegment.startsWith(':')) {
-              // Param segment - always matches
-              matchedPath = pathSegments.slice(i, j).join('/');
-              params['**'] = matchedPath;
-              i = j - 1; // Adjust index for the next iteration
-              foundMatch = true;
-              break;
-            } else if (nextRouteSegment === '*') {
-              // Single wildcard - always matches
-              matchedPath = pathSegments.slice(i, j).join('/');
-              params['**'] = matchedPath;
-              i = j - 1; // Adjust index for the next iteration
-              foundMatch = true;
-              break;
-            } else if (nextRouteSegment === currentPathSegment) {
-              // Exact match
-              matchedPath = pathSegments.slice(i, j).join('/');
-              params['**'] = matchedPath;
-              i = j - 1; // Adjust index for the next iteration
-              foundMatch = true;
-              break;
-            }
-          }
-
-          if (!foundMatch) {
-            isMatch = false;
-            break;
-          }
-
-          continue;
-        }
-
-        if (!pathSegment) {
-          isMatch = false;
-          break;
-        }
-
-        if (routeSegment.startsWith(':')) {
-          const paramName = routeSegment.slice(1);
-          params[paramName] = pathSegment;
-        } else if (routeSegment === '*') {
-          // Single segment wildcard
-          params['*'] = pathSegment;
-        } else if (routeSegment !== pathSegment) {
-          isMatch = false;
-          break;
-        }
-      }
-
-      if (isMatch) {
-        return { route, params };
-      }
-    }
-
-    return null;
-  }
-
-  // Parse query string
-  private parseQuery(searchParams: URLSearchParams): Record<string, string | undefined> {
-    const query: Record<string, string | undefined> = {};
-    searchParams.forEach((value, key) => {
-      query[key] = value;
-    });
-    return query;
-  }
-
-  // Parse headers
-  private parseHeaders(headers: Headers): Record<string, string> {
-    const headerObj: Record<string, string> = {};
-    headers.forEach((value, key) => {
-      headerObj[key] = value;
-    });
-    return headerObj;
-  }
-
-  // Parse cookies from Cookie header
-  private parseCookies(cookieHeader: string | null): Record<string, string> {
-    const cookies: Record<string, string> = {};
-
-    if (!cookieHeader) return cookies;
-
-    const cookiePairs = cookieHeader.split(';');
-    for (const pair of cookiePairs) {
-      const [name, value] = pair.trim().split('=');
-      if (name && value) {
-        cookies[decodeURIComponent(name)] = decodeURIComponent(value);
-      }
-    }
-
-    return cookies;
-  }
-
-  // Validate data against Zod schema
-  private validateData<T>(schema: z.ZodSchema<T> | undefined, data: any): T {
-    if (!schema) return data;
-    return schema.parse(data);
-  }
-
-  // Validate response against response config (supports both simple and status-based schemas)
-  private validateResponse(responseConfig: ResponseConfig | undefined, data: any, status: number = 200): any {
-    if (!responseConfig || !this.enableValidation) return data;
-
-    // If it's a simple schema (not status-based)
-    if ('parse' in responseConfig && typeof responseConfig.parse === 'function') {
-      return responseConfig.parse(data);
-    }
-
-    // If it's a status-based schema
-    if (typeof responseConfig === 'object' && !('parse' in responseConfig)) {
-      const statusSchema = responseConfig[status];
-      if (statusSchema) {
-        return statusSchema.parse(data);
-      }
-
-      // If no specific status schema found, try to find a fallback
-      // Common fallback statuses: 200, 201, 400, 500
-      const fallbackStatuses = [200, 201, 400, 500];
-      for (const fallbackStatus of fallbackStatuses) {
-        if (responseConfig[fallbackStatus]) {
-          return responseConfig[fallbackStatus]?.parse(data);
-        }
-      }
-
-      // If no schema found for the status, return data as-is
-      return data;
-    }
-
-    return data;
-  }
-
-  // Main request handler
-  private async handleRequest(request: Request, server?: any): Promise<Response | undefined> {
-    const url = new URL(request.url);
-    const method = request.method;
-    const rawPathname = url.pathname;
-    let pathname: string;
-    try {
-      pathname = decodeURI(rawPathname);
-    } catch {
-      pathname = rawPathname;
-    }
-
-    // Check for WebSocket upgrade
-    if (request.headers.get('upgrade') === 'websocket') {
-      const wsMatchResult = this.matchWSRoute(pathname);
-      if (wsMatchResult && server) {
-        const success = server.upgrade(request, {
-          data: {
-            handler: wsMatchResult.route.handler,
-            params: wsMatchResult.params,
-            pathname
-          }
-        });
-
-        if (success) {
-          return; // undefined response means upgrade was successful
-        }
-      }
-      return new Response('WebSocket upgrade failed', { status: 400 });
-    }
-
-    // Handle OPTIONS requests for CORS preflight before route matching
-    if (method === 'OPTIONS') {
-      // Create a minimal context for OPTIONS requests
-      const ctx: Context = {
-        params: {},
-        query: {},
-        body: {},
-        headers: this.parseHeaders(request.headers),
-        cookies: {},
-        path: pathname,
-        request,
-        set: {
-          status: 200,
-          headers: {},
-          cookies: (name: string, value: string, options?: CookieOptions) => {
-            // This is a placeholder for setting cookies.
-            // In a real Bun.serve context, you'd use Bun.serve's cookie handling.
-            // For now, we'll just log it or throw an error if not Bun.serve.
-            console.warn(`Setting cookie '${name}' with value '${value}' via ctx.set.cookies is not directly supported by Bun.serve. Use Bun.serve's cookie handling.`);
-          },
-          redirect: undefined
-        },
-        status: ((code: number, data?: any) => {
-          ctx.set.status = code;
-          return data;
-        }) as any,
-        redirect: ((location: string, status: number = 302) => {
-          ctx.set.redirect = { location, status };
-          const responseHeaders: Record<string, string> = {
-            Location: location,
-            ...(ctx.set.headers || {})
-          };
-          return new Response(null, {
-            status,
-            headers: responseHeaders
-          });
-        }) as any,
-        clearRedirect: (() => {
-          delete ctx.set.redirect;
-          if (ctx.set.headers) {
-            for (const key of Object.keys(ctx.set.headers)) {
-              if (key.toLowerCase() === 'location') {
-                delete ctx.set.headers[key];
-              }
-            }
-          }
-          if (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400) {
-            ctx.set.status = 200;
-          }
-        }) as any
-      };
-
-      // Run middleware onRequest hooks for OPTIONS requests
-      for (const plugin of this.middleware) {
-        if (plugin.onRequest) {
-          const result = await plugin.onRequest(ctx);
-          // If middleware returns a response, return it immediately
-          if (result instanceof Response) {
-            return result;
-          }
-        }
-      }
-
-      // Run global onRequest hook
-      if (this.hooks.onRequest) {
-        const result = await this.hooks.onRequest(ctx, this);
-        if (result instanceof Response) {
-          return result;
-        }
-      }
-
-      // Run BXO instance onRequest hooks
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onRequest) {
-          const result = await bxoInstance.hooks.onRequest(ctx, this);
-          if (result instanceof Response) {
-            return result;
-          }
-        }
-      }
-
-      // If no middleware handled the OPTIONS request, return a default response
-      return new Response(null, {
-        status: 204,
-        headers: ctx.set.headers || {}
-      });
-    }
-
-    const matchResult = this.matchRoute(method, pathname);
-    if (!matchResult) {
-      return new Response('Not Found', { status: 404 });
-    }
-
-    const { route, params } = matchResult;
-    const query = this.parseQuery(url.searchParams);
-    const headers = this.parseHeaders(request.headers);
-    const cookies = this.parseCookies(request.headers.get('cookie'));
-
-    let body: any;
-    if (request.method !== 'GET' && request.method !== 'HEAD') {
-      const contentType = request.headers.get('content-type');
-      if (contentType?.includes('application/json')) {
-        try {
-          body = await request.json();
-        } catch {
-          body = {};
-        }
-      } else if (contentType?.includes('application/x-www-form-urlencoded')) {
-        const formData = await request.formData();
-        body = Object.fromEntries(formData.entries());
-      } else {
-        // Try to parse as JSON if it looks like JSON, otherwise treat as text
-        const textBody = await request.text();
-        try {
-          // Check if the text looks like JSON
-          if (textBody.trim().startsWith('{') || textBody.trim().startsWith('[')) {
-            body = JSON.parse(textBody);
-          } else {
-            body = textBody;
-          }
-        } catch {
-          body = textBody;
-        }
-      }
-    }
-
-    // Create internal cookie storage
-    const internalCookies: InternalCookie[] = [];
-
-    // Create context with validation
-    let ctx: Context;
-    try {
-      // Validate each part separately to get better error messages
-      const validatedParams = this.enableValidation && route.config?.params ? this.validateData(route.config.params, params) : params;
-      const validatedQuery = this.enableValidation && route.config?.query ? this.validateData(route.config.query, query) : query;
-      const validatedBody = this.enableValidation && route.config?.body ? this.validateData(route.config.body, body) : body;
-      const validatedHeaders = this.enableValidation && route.config?.headers ? this.validateData(route.config.headers, headers) : headers;
-      const validatedCookies = this.enableValidation && route.config?.cookies ? this.validateData(route.config.cookies, cookies) : cookies;
-
-      ctx = {
-        params: validatedParams,
-        query: validatedQuery,
-        body: validatedBody,
-        headers: validatedHeaders,
-        cookies: validatedCookies,
-        path: pathname,
-        request,
-        set: {
-          status: 200,
-          headers: {},
-          cookies: (name: string, value: string, options?: CookieOptions) => {
-            internalCookies.push({
-              name,
-              value,
-              domain: options?.domain,
-              path: options?.path,
-              expires: options?.expires,
-              maxAge: options?.maxAge,
-              secure: options?.secure,
-              httpOnly: options?.httpOnly,
-              sameSite: options?.sameSite
-            });
-          }
-        },
-        status: ((code: number, data?: any) => {
-          ctx.set.status = code;
-          return data;
-        }) as any,
-        redirect: ((location: string, status: number = 302) => {
-          // Record redirect intent only; avoid mutating generic status/headers so it can be canceled later
-          ctx.set.redirect = { location, status };
-
-          // Prepare headers for immediate Response return without persisting to ctx.set.headers
-          const responseHeaders = new Headers();
-          responseHeaders.set('Location', location);
-
-          // Add any additional headers from ctx.set.headers
-          if (ctx.set.headers) {
-            Object.entries(ctx.set.headers).forEach(([key, value]) => {
-              responseHeaders.set(key, value);
-            });
-          }
-
-          // Handle cookies if any are set on context
-          if (internalCookies.length > 0) {
-            const cookieHeaders = internalCookies.map(cookie => {
-              let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
-              if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
-              if (cookie.path) cookieString += `; Path=${cookie.path}`;
-              if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
-              if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
-              if (cookie.secure) cookieString += `; Secure`;
-              if (cookie.httpOnly) cookieString += `; HttpOnly`;
-              if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
-              return cookieString;
-            });
-            // Set multiple Set-Cookie headers properly
-            cookieHeaders.forEach(cookieHeader => {
-              responseHeaders.append('Set-Cookie', cookieHeader);
-            });
-          }
-
-          return new Response(null, {
-            status,
-            headers: responseHeaders
-          });
-        }) as any,
-        clearRedirect: (() => {
-          // Clear explicit redirect intent
-          delete ctx.set.redirect;
-          // Remove any Location header if present
-          if (ctx.set.headers) {
-            for (const key of Object.keys(ctx.set.headers)) {
-              if (key.toLowerCase() === 'location') {
-                delete ctx.set.headers[key];
-              }
-            }
-          }
-          // Reset status if it is a redirect
-          if (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400) {
-            ctx.set.status = 200;
-          }
-        }) as any
-      };
-    } catch (validationError) {
-      // Validation failed - return error response
-
-      // Extract detailed validation errors from Zod
-      let validationDetails = undefined;
-      if (validationError instanceof Error) {
-        if ('errors' in validationError && Array.isArray(validationError.errors)) {
-          validationDetails = validationError.errors;
-        } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
-          validationDetails = validationError.issues;
-        }
-      }
-
-      // Create a clean error message
-      const errorMessage = validationDetails && validationDetails.length > 0
-        ? `Validation failed for ${validationDetails.length} field(s)`
-        : 'Validation failed';
-
-      return new Response(JSON.stringify({
-        error: errorMessage,
-        details: validationDetails
-      }), {
-        status: 400,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-
-    try {
-      // Run middleware onRequest hooks
-      for (const plugin of this.middleware) {
-        if (plugin.onRequest) {
-          await plugin.onRequest(ctx);
-        }
-      }
-
-      // Run global onRequest hook
-      if (this.hooks.onRequest) {
-        await this.hooks.onRequest(ctx, this);
-      }
-
-      // Run BXO instance onRequest hooks
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onRequest) {
-          await bxoInstance.hooks.onRequest(ctx, this);
-        }
-      }
-
-      // Execute route handler
-      let response = await route.handler(ctx);
-
-      // Run middleware onResponse hooks
-      for (const plugin of this.middleware) {
-        if (plugin.onResponse) {
-          response = await plugin.onResponse(ctx, response) || response;
-        }
-      }
-
-      // Run global onResponse hook
-      if (this.hooks.onResponse) {
-        response = await this.hooks.onResponse(ctx, response, this) || response;
-      }
-
-      // Run BXO instance onResponse hooks
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onResponse) {
-          response = await bxoInstance.hooks.onResponse(ctx, response, this) || response;
-        }
-      }
-
-      // If the handler did not return a response, but a redirect was configured via ctx.set,
-      // automatically create a redirect Response so users can call ctx.redirect(...) or set headers without returning.
-      const hasImplicitRedirectIntent = !!ctx.set.redirect
-        || (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400);
-      if ((response === undefined || response === null) && hasImplicitRedirectIntent) {
-        const locationFromHeaders = ctx.set.headers && Object.entries(ctx.set.headers).find(([k]) => k.toLowerCase() === 'location')?.[1];
-        const location = ctx.set.redirect?.location || locationFromHeaders;
-        if (location) {
-          // Build headers, ensuring Location is present
-          let responseHeaders: Record<string, string> = ctx.set.headers ? { ...ctx.set.headers } : {};
-          if (!Object.keys(responseHeaders).some(k => k.toLowerCase() === 'location')) {
-            responseHeaders['Location'] = location;
-          }
-          // Determine status precedence: redirect.status > set.status > 302
-          const status = ctx.set.redirect?.status ?? ctx.set.status ?? 302;
-
-          // Handle cookies if any are set
-          if (internalCookies.length > 0) {
-            const cookieHeaders = internalCookies.map(cookie => {
-              let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
-              if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
-              if (cookie.path) cookieString += `; Path=${cookie.path}`;
-              if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
-              if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
-              if (cookie.secure) cookieString += `; Secure`;
-              if (cookie.httpOnly) cookieString += `; HttpOnly`;
-              if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
-              return cookieString;
-            });
-            // Convert responseHeaders to Headers object for proper multiple Set-Cookie handling
-            const headers = new Headers();
-            Object.entries(responseHeaders).forEach(([key, value]) => {
-              headers.set(key, value);
-            });
-            cookieHeaders.forEach(cookieHeader => {
-              headers.append('Set-Cookie', cookieHeader);
-            });
-            // Convert back to plain object for Response constructor
-            const finalHeaders: Record<string, string> = {};
-            headers.forEach((value, key) => {
-              finalHeaders[key] = value;
-            });
-            responseHeaders = finalHeaders;
-          }
-
-          return new Response(null, {
-            status,
-            headers: responseHeaders
-          });
-        }
-      }
-
-      // Validate response against schema if provided
-      if (this.enableValidation && route.config?.response && !(response instanceof Response)) {
-        try {
-          const status = ctx.set.status || 200;
-          response = this.validateResponse(route.config.response, response, status);
-        } catch (validationError) {
-          // Response validation failed
-
-          // Extract detailed validation errors from Zod
-          let validationDetails = undefined;
-          if (validationError instanceof Error) {
-            if ('errors' in validationError && Array.isArray(validationError.errors)) {
-              validationDetails = validationError.errors;
-            } else if ('issues' in validationError && Array.isArray(validationError.issues)) {
-              validationDetails = validationError.issues;
-            }
-          }
-
-          // Create a clean error message
-          const errorMessage = validationDetails && validationDetails.length > 0
-            ? `Response validation failed for ${validationDetails.length} field(s)`
-            : 'Response validation failed';
-
-          return new Response(JSON.stringify({
-            error: errorMessage,
-            details: validationDetails
-          }), {
-            status: 500,
-            headers: { 'Content-Type': 'application/json' }
-          });
-        }
-      }
-
-      // Convert response to Response object
-      if (response instanceof Response) {
-        // If there are headers set via ctx.set.headers, merge them with the Response headers
-        if (ctx.set.headers && Object.keys(ctx.set.headers).length > 0) {
-          const newHeaders = new Headers(response.headers);
-
-          // Add headers from ctx.set.headers
-          Object.entries(ctx.set.headers).forEach(([key, value]) => {
-            newHeaders.set(key, value);
-          });
-
-          // Handle cookies if any are set
-          if (internalCookies.length > 0) {
-            const cookieHeaders = internalCookies.map(cookie => {
-              let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
-              if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
-              if (cookie.path) cookieString += `; Path=${cookie.path}`;
-              if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
-              if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
-              if (cookie.secure) cookieString += `; Secure`;
-              if (cookie.httpOnly) cookieString += `; HttpOnly`;
-              if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
-              return cookieString;
-            });
-
-            // Add Set-Cookie headers
-            cookieHeaders.forEach(cookieHeader => {
-              newHeaders.append('Set-Cookie', cookieHeader);
-            });
-          }
-
-          // Create new Response with merged headers
-          return new Response(response.body, {
-            status: ctx.set.status || response.status,
-            statusText: response.statusText,
-            headers: newHeaders
-          });
-        }
-
-        return response;
-      }
-
-      // Handle File response (like Elysia)
-      if (response instanceof File || (typeof Bun !== 'undefined' && response instanceof Bun.file('').constructor)) {
-        const file = response as File;
-        const responseInit: ResponseInit = {
-          status: ctx.set.status || 200,
-          headers: {
-            'Content-Type': file.type || 'application/octet-stream',
-            'Content-Length': file.size.toString(),
-            ...ctx.set.headers
-          }
-        };
-        return new Response(file, responseInit);
-      }
-
-      // Handle Bun.file() response
-      if (typeof response === 'object' && response && 'stream' in response && 'size' in response) {
-        const bunFile = response as any;
-        const responseInit: ResponseInit = {
-          status: ctx.set.status || 200,
-          headers: {
-            'Content-Type': bunFile.type || 'application/octet-stream',
-            'Content-Length': bunFile.size?.toString() || '',
-            ...ctx.set.headers,
-            ...(bunFile.headers || {}) // Support custom headers from file helper
-          }
-        };
-        return new Response(bunFile, responseInit);
-      }
-
-      // Prepare headers with cookies
-      let responseHeaders = ctx.set.headers ? { ...ctx.set.headers } : {};
-
-      // Handle cookies if any are set
-      if (internalCookies.length > 0) {
-        const cookieHeaders = internalCookies.map(cookie => {
-          let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
-
-          if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
-          if (cookie.path) cookieString += `; Path=${cookie.path}`;
-          if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
-          if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
-          if (cookie.secure) cookieString += `; Secure`;
-          if (cookie.httpOnly) cookieString += `; HttpOnly`;
-          if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
-
-          return cookieString;
-        });
-
-        // Add Set-Cookie headers
-        // Use Headers object directly for Response constructor to handle multiple Set-Cookie headers properly
-        const headers = new Headers();
-        Object.entries(responseHeaders).forEach(([key, value]) => {
-          headers.set(key, value);
-        });
-        cookieHeaders.forEach(cookieHeader => {
-          headers.append('Set-Cookie', cookieHeader);
-        });
-
-        const responseInit: ResponseInit = {
-          status: ctx.set.status || 200,
-          headers: headers
-        };
-
-        if (typeof response === 'string') {
-          return new Response(response, responseInit);
-        }
-
-        return new Response(JSON.stringify(response), {
-          status: responseInit.status,
-          headers: headers
-        });
-      }
-
-      // If no cookies, use the original responseHeaders
-      const responseInit: ResponseInit = {
-        status: ctx.set.status || 200,
-        headers: responseHeaders
-      };
-
-      if (typeof response === 'string') {
-        return new Response(response, responseInit);
-      }
-
-      return new Response(JSON.stringify(response), {
-        ...responseInit,
-        headers: {
-          'Content-Type': 'application/json',
-          ...responseInit.headers
-        }
-      });
-
-    } catch (error) {
-      // Run error hooks
-      let errorResponse: any;
-
-      // Run middleware onError hooks
-      for (const plugin of this.middleware) {
-        if (plugin.onError) {
-          errorResponse = await plugin.onError(ctx, error as Error) || errorResponse;
-        }
-      }
-
-      if (this.hooks.onError) {
-        errorResponse = await this.hooks.onError(ctx, error as Error, this);
-      }
-
-      for (const bxoInstance of this.plugins) {
-        if (bxoInstance.hooks.onError) {
-          errorResponse = await bxoInstance.hooks.onError(ctx, error as Error, this) || errorResponse;
-        }
-      }
-
-      if (errorResponse) {
-        if (errorResponse instanceof Response) {
-          return errorResponse;
-        }
-        return new Response(JSON.stringify(errorResponse), {
-          status: 500,
-          headers: { 'Content-Type': 'application/json' }
-        });
-      }
-
-      // Default error response
-      const errorMessage = error instanceof Error ? error.message : 'Internal Server Error';
-      return new Response(JSON.stringify({ error: errorMessage }), {
-        status: 500,
-        headers: { 'Content-Type': 'application/json' }
-      });
-    }
-  }
-
-
-
-  // Server management methods
-  async start(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
-    if (this.isRunning) {
-      return;
-    }
-
-    try {
-      // Before start hook
-      if (this.hooks.onBeforeStart) {
-        await this.hooks.onBeforeStart(this);
-      }
-
-      this.server = Bun.serve({
-        port,
-        hostname,
-        fetch: (request, server) => this.handleRequest(request, server),
-        websocket: {
-          message: (ws: any, message: any) => {
-            const handler = ws.data?.handler;
-            if (handler?.onMessage) {
-              handler.onMessage(ws, message);
-            }
-          },
-          open: (ws: any) => {
-            const handler = ws.data?.handler;
-            if (handler?.onOpen) {
-              handler.onOpen(ws);
-            }
-          },
-          close: (ws: any, code?: number, reason?: string) => {
-            const handler = ws.data?.handler;
-            if (handler?.onClose) {
-              handler.onClose(ws, code, reason);
-            }
-          }
-        }
-      });
-
-      // Verify server was created successfully
-      if (!this.server) {
-        throw new Error('Failed to create server instance');
-      }
-
-      this.isRunning = true;
-      this.serverPort = port;
-      this.serverHostname = hostname;
-
-      // After start hook
-      if (this.hooks.onAfterStart) {
-        await this.hooks.onAfterStart(this);
-      }
-
-      // Handle graceful shutdown
-      const shutdownHandler = async () => {
-        await this.stop();
-        process.exit(0);
-      };
-
-      process.on('SIGINT', shutdownHandler);
-      process.on('SIGTERM', shutdownHandler);
-
-    } catch (error) {
-      console.error('❌ Failed to start server:', error);
-      throw error;
-    }
-  }
-
-  async stop(): Promise<void> {
-    if (!this.isRunning) {
-      return;
-    }
-
-    try {
-      // Before stop hook
-      if (this.hooks.onBeforeStop) {
-        await this.hooks.onBeforeStop(this);
-      }
-
-      if (this.server) {
-        try {
-          // Try to stop the server gracefully
-          if (typeof this.server.stop === 'function') {
-            this.server.stop();
-          } else {
-            console.warn('⚠️  Server stop method not available');
-          }
-        } catch (stopError) {
-          console.error('❌ Error calling server.stop():', stopError);
-        }
-
-        // Clear the server reference
-        this.server = undefined;
-      }
-
-      // Reset state regardless of server.stop() success
-      this.isRunning = false;
-      this.serverPort = undefined;
-      this.serverHostname = undefined;
-
-      // After stop hook
-      if (this.hooks.onAfterStop) {
-        await this.hooks.onAfterStop(this);
-      }
-
-    } catch (error) {
-      console.error('❌ Error stopping server:', error);
-      // Even if there's an error, reset the state
-      this.isRunning = false;
-      this.server = undefined;
-      this.serverPort = undefined;
-      this.serverHostname = undefined;
-      throw error;
-    }
-  }
-
-
-
-  // Backward compatibility
-  async listen(port: number = 3000, hostname: string = 'localhost'): Promise<void> {
-    return this.start(port, hostname);
-  }
-
-  // Server status
-  isServerRunning(): boolean {
-    return this.isRunning && this.server !== undefined;
-  }
-
-  getServerInfo(): { running: boolean } {
-    return {
-      running: this.isRunning
-    };
-  }
-
-  // Get server information (alias for getServerInfo)
-  get info() {
-    // Calculate total routes including plugins
-    const totalRoutes = this._routes.length + this.plugins.reduce((total, plugin) => total + plugin._routes.length, 0);
-    const totalWsRoutes = this._wsRoutes.length + this.plugins.reduce((total, plugin) => total + plugin._wsRoutes.length, 0);
-
-    return {
-      // Server status
-      running: this.isRunning,
-      server: this.server ? 'Bun' : null,
-
-      // Connection details
-      hostname: this.serverHostname,
-      port: this.serverPort,
-      url: this.isRunning && this.serverHostname && this.serverPort
-        ? `http://${this.serverHostname}:${this.serverPort}`
-        : null,
-
-      // Application statistics
-      totalRoutes,
-      totalWsRoutes,
-      totalPlugins: this.plugins.length,
-
-      // System information
-      runtime: 'Bun',
-      version: typeof Bun !== 'undefined' ? Bun.version : 'unknown',
-      pid: process.pid,
-      uptime: this.isRunning ? process.uptime() : 0
-    };
-  }
-
-  // Get all routes information
-  get routes() {
-    // Get routes from main instance
-    const mainRoutes = this._routes.map((route: Route) => ({
-      method: route.method,
-      path: route.path,
-      hasConfig: !!route.config,
-      config: route.config || null,
-      source: 'main' as const
-    }));
-
-    // Get routes from all plugins
-    const pluginRoutes = this.plugins.flatMap((plugin, pluginIndex) =>
-      plugin._routes.map((route: Route) => ({
-        method: route.method,
-        path: route.path,
-        hasConfig: !!route.config,
-        config: route.config || null,
-        source: 'plugin' as const,
-        pluginIndex
-      }))
-    );
-
-    return [...mainRoutes, ...pluginRoutes];
-  }
-
-  // Get all WebSocket routes information
-  get wsRoutes() {
-    // Get WebSocket routes from main instance
-    const mainWsRoutes = this._wsRoutes.map((route: WSRoute) => ({
-      path: route.path,
-      hasHandlers: {
-        onOpen: !!route.handler.onOpen,
-        onMessage: !!route.handler.onMessage,
-        onClose: !!route.handler.onClose,
-        onError: !!route.handler.onError
-      },
-      source: 'main' as const
-    }));
-
-    // Get WebSocket routes from all plugins
-    const pluginWsRoutes = this.plugins.flatMap((plugin, pluginIndex) =>
-      plugin._wsRoutes.map((route: WSRoute) => ({
-        path: route.path,
-        hasHandlers: {
-          onOpen: !!route.handler.onOpen,
-          onMessage: !!route.handler.onMessage,
-          onClose: !!route.handler.onClose,
-          onError: !!route.handler.onError
-        },
-        source: 'plugin' as const,
-        pluginIndex
-      }))
-    );
-
-    return [...mainWsRoutes, ...pluginWsRoutes];
-  }
-}
-
-const error = (error: Error | string, status: number = 500) => {
-  return new Response(JSON.stringify({ error: error instanceof Error ? error.message : error }), { status });
-}
-
-// File helper function (like Elysia)
-const file = (path: string, options?: { type?: string; headers?: Record<string, string> }) => {
-  const bunFile = Bun.file(path);
-
-  if (options?.type) {
-    // Create a wrapper to override the MIME type
-    return {
-      ...bunFile,
-      type: options.type,
-      headers: options.headers
-    };
-  }
-
-  return bunFile;
-}
-
-// Redirect helper function (like Elysia)
-const redirect = (location: string, status: number = 302) => {
-  return new Response(null, {
-    status,
-    headers: { Location: location }
-  });
-}
-
-// Export Zod for convenience
-export { z, error, file, redirect };
-
-// Export types for external use
-export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute, CookieOptions, BXOOptions, Plugin };
-
-// Helper function to create cookie options
-export const createCookieOptions = (
-  options: CookieOptions = {}
-): CookieOptions => ({
-  ...options
-});
+// Also export the default BXO class for backward compatibility
+export { default } from './src/index';