@gravito/ripple 4.0.0 → 4.0.3

package/dist/core/src/Router.d.ts

@@ -55,6 +55,33 @@ export interface RouteOptions {
     /** Middleware stack for the route */
     middleware?: GravitoMiddleware[];
 }
+/**
+ * Common routing handler argument definition
+ * @public
+ */
+export type RouteDefinitionArg = FormRequestClass | RouteHandler | GravitoMiddleware | GravitoMiddleware[];
+/**
+ * Interface merging for HTTP routing methods to establish overloads
+ * without duplicate bodies.
+ * @public
+ */
+export interface RoutingMethods {
+    get(path: string, handler: RouteHandler): Route;
+    get(path: string, request: FormRequestClass, handler: RouteHandler): Route;
+    get(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
+    post(path: string, handler: RouteHandler): Route;
+    post(path: string, request: FormRequestClass, handler: RouteHandler): Route;
+    post(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
+    put(path: string, handler: RouteHandler): Route;
+    put(path: string, request: FormRequestClass, handler: RouteHandler): Route;
+    put(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
+    delete(path: string, handler: RouteHandler): Route;
+    delete(path: string, request: FormRequestClass, handler: RouteHandler): Route;
+    delete(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
+    patch(path: string, handler: RouteHandler): Route;
+    patch(path: string, request: FormRequestClass, handler: RouteHandler): Route;
+    patch(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
+}
 /**
  * RouteGroup
  * Helper class for chained route configuration (prefix, domain, etc.)
@@ -64,6 +91,8 @@ export interface RouteOptions {
  * Helper class for chained route configuration (prefix, domain, etc.)
  * @public
  */
+export interface RouteGroup extends RoutingMethods {
+}
 export declare class RouteGroup {
     private router;
     private options;
@@ -81,21 +110,6 @@ export declare class RouteGroup {
      * Define routes within this group
      */
     group(callback: (router: Router | RouteGroup) => void): void;
-    get(path: string, handler: RouteHandler): Route;
-    get(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    get(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    post(path: string, handler: RouteHandler): Route;
-    post(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    post(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    put(path: string, handler: RouteHandler): Route;
-    put(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    put(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    delete(path: string, handler: RouteHandler): Route;
-    delete(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    delete(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    patch(path: string, handler: RouteHandler): Route;
-    patch(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    patch(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
     resource(name: string, controller: ControllerClass, options?: ResourceOptions): void;
     /**
      * Register a route that forwards requests to another URL (Gateway Proxy).
@@ -118,6 +132,8 @@ export declare class RouteGroup {
  * - FormRequest validation: router.post('/users', StoreUserRequest, [UserController, 'store'])
  * - Inline Middleware: router.get('/users', authMiddleware, [UserController, 'index'])
  */
+export interface Router extends RoutingMethods {
+}
 export declare class Router {
     private core;
     routes: Array<{
@@ -210,36 +226,6 @@ export declare class Router {
      * Accepts individual handlers or arrays of handlers.
      */
     middleware(...handlers: (GravitoMiddleware | GravitoMiddleware[])[]): RouteGroup;
-    /**
-     * Register a GET route.
-     */
-    get(path: string, handler: RouteHandler): Route;
-    get(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    get(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    /**
-     * Register a POST route.
-     */
-    post(path: string, handler: RouteHandler): Route;
-    post(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    post(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    /**
-     * Register a PUT route.
-     */
-    put(path: string, handler: RouteHandler): Route;
-    put(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    put(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    /**
-     * Register a DELETE route.
-     */
-    delete(path: string, handler: RouteHandler): Route;
-    delete(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    delete(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
-    /**
-     * Register a PATCH route.
-     */
-    patch(path: string, handler: RouteHandler): Route;
-    patch(path: string, request: FormRequestClass, handler: RouteHandler): Route;
-    patch(path: string, middleware: GravitoMiddleware | GravitoMiddleware[], handler: RouteHandler): Route;
     /**
      * Register a route that forwards requests to another URL (Gateway Proxy).
      * @param method - HTTP method or 'all'
@@ -267,7 +253,7 @@ export declare class Router {
     /**
      * Internal Request Registration
      */
-    req(method: HttpMethod, path: string, requestOrHandlerOrMiddleware: FormRequestClass | RouteHandler | GravitoMiddleware | GravitoMiddleware[], handler?: RouteHandler, options?: RouteOptions): Route;
+    req(method: HttpMethod, path: string, requestOrHandlerOrMiddleware: RouteDefinitionArg, handler?: RouteHandler, options?: RouteOptions): Route;
 }
 /**
  * Standard RESTful resource action names.

package/dist/core/src/ServiceProvider.d.ts

@@ -74,6 +74,28 @@ export declare abstract class ServiceProvider {
      * @param core - The PlanetCore application instance
      */
     boot?(core: PlanetCore): void | Promise<void>;
+    /**
+     * Called when the application is ready to accept requests.
+     *
+     * This method is called after ALL providers have booted.
+     * Use this for final initialization before the server starts accepting traffic.
+     *
+     * @param core - The PlanetCore application instance
+     * @since 2.2.0
+     */
+    onReady?(core: PlanetCore): void | Promise<void>;
+    /**
+     * Called when the application is shutting down.
+     *
+     * This method is called during graceful shutdown.
+     * Use this to clean up resources, close connections, etc.
+     *
+     * Providers are called in reverse order (LIFO).
+     *
+     * @param core - The PlanetCore application instance
+     * @since 2.2.0
+     */
+    onShutdown?(core: PlanetCore): void | Promise<void>;
     /**
      * Set the core instance reference.
      * Called internally by the application during registration.

package/dist/core/src/adapters/bun/BunContext.d.ts

@@ -1,3 +1,4 @@
+import { RequestScopeManager } from '../../Container/RequestScopeManager';
 import type { ContentfulStatusCode, GravitoContext, GravitoVariables, ProxyOptions, StatusCode } from '../../http/types';
 import { BunRequest } from './BunRequest';
 /**
@@ -6,8 +7,9 @@ import { BunRequest } from './BunRequest';
  */
 export declare class BunContext<V extends GravitoVariables = GravitoVariables> implements GravitoContext<V> {
     readonly env: Record<string, unknown>;
-    readonly req: BunRequest;
+    req: BunRequest;
     private _variables;
+    private _requestScope;
     /**
      * URL generator helper
      */
@@ -38,8 +40,15 @@ export declare class BunContext<V extends GravitoVariables = GravitoVariables> i
         append?: boolean;
     }): void;
     header(name: string): string | undefined;
+    /**
+     * Reset context state for reuse in pooling scenarios
+     * @internal
+     */
+    reset(request: Request): void;
     status(code: StatusCode): void;
     get<K extends keyof V>(key: K): V[K];
     set<K extends keyof V>(key: K, value: V[K]): void;
     get executionCtx(): ExecutionContext | undefined;
+    requestScope(): RequestScopeManager;
+    scoped<T>(key: string | symbol, factory: () => T): T;
 }

package/dist/core/src/adapters/bun/BunNativeAdapter.d.ts

@@ -1,5 +1,6 @@
 import type { GravitoContext, GravitoErrorHandler, GravitoHandler, GravitoMiddleware, GravitoNotFoundHandler, HttpMethod } from '../../http/types';
 import type { HttpAdapter, RouteDefinition } from '../types';
+import type { WebSocketRouteHandlers } from './BunWebSocketHandler';
 /**
  * Native Bun-optimized HTTP Adapter for Gravito.
  * Uses Bun's standard Request/Response classes and efficient router.
@@ -13,15 +14,49 @@ export declare class BunNativeAdapter implements HttpAdapter {
     private middlewares;
     private errorHandler;
     private notFoundHandler;
+    private contextPool;
+    private readonly maxPoolSize;
+    private middlewareChainCache;
+    private wsHandler;
     route(method: HttpMethod, path: string, ...handlers: (GravitoHandler | GravitoMiddleware)[]): void;
     routes(routes: RouteDefinition[]): void;
     use(path: string, ...middleware: GravitoMiddleware[]): void;
     useGlobal(...middleware: GravitoMiddleware[]): void;
     useScoped(scope: string, path: string, ...middleware: GravitoMiddleware[]): void;
+    /**
+     * P1 Fix: Accurate path pattern matching for middleware
+     * Handles wildcards: *, /api/*, /api
+     */
+    private matchesPath;
+    /**
+     * P2 optimization: Pre-compile middleware chain for a path
+     */
+    private getCompiledMiddlewareChain;
+    /**
+     * P0 Fix: Context object pooling to prevent state pollution
+     */
+    private acquireContext;
+    /**
+     * P0 Fix: Release context back to pool
+     */
+    private releaseContext;
     mount(path: string, subAdapter: HttpAdapter): void;
     createContext(request: Request): GravitoContext;
     onError(handler: GravitoErrorHandler): void;
     onNotFound(handler: GravitoNotFoundHandler): void;
+    /**
+     * 註冊 WebSocket 路由
+     */
+    registerWebSocketRoute(path: string, handlers: WebSocketRouteHandlers): void;
+    /**
+     * 取得 WebSocket handler（供 Bun.serve 使用）
+     */
+    get websocket(): {
+        open?: (ws: unknown) => void | Promise<void>;
+        message?: (ws: unknown, data: string | Buffer | Uint8Array) => void | Promise<void>;
+        close?: (ws: unknown, code: number, reason: string) => void | Promise<void>;
+        drain?: (ws: unknown) => void | Promise<void>;
+    } | undefined;
     /**
      * Predictive Route Warming (JIT Optimization)
      */

package/dist/core/src/adapters/bun/BunWebSocketHandler.d.ts

@@ -0,0 +1,48 @@
+/**
+ * WebSocket 路由管理器
+ *
+ * 負責註冊和分發 WebSocket 事件到相應的路由處理器
+ */
+export interface WebSocketRouteHandlers {
+    open?: (ws: unknown) => void | Promise<void>;
+    message?: (ws: unknown, data: string | Buffer | Uint8Array) => void | Promise<void>;
+    close?: (ws: unknown, code: number, reason: string) => void | Promise<void>;
+    drain?: (ws: unknown) => void | Promise<void>;
+}
+export declare class BunWebSocketHandler {
+    private routes;
+    /**
+     * 註冊 WebSocket 路由
+     */
+    register(path: string, handlers: WebSocketRouteHandlers): void;
+    /**
+     * 檢查是否有該路由
+     * 支援精確匹配和 wildcard 匹配
+     */
+    hasRoute(path: string): boolean;
+    /**
+     * 檢查是否有任何已註冊的路由
+     */
+    hasAnyRoute(): boolean;
+    /**
+     * 將 handlers 轉換為 Bun.serve websocket config
+     */
+    toHandler(): {
+        open?: (ws: unknown) => void | Promise<void>;
+        message?: (ws: unknown, data: string | Buffer | Uint8Array) => void | Promise<void>;
+        close?: (ws: unknown, code: number, reason: string) => void | Promise<void>;
+        drain?: (ws: unknown) => void | Promise<void>;
+    };
+    /**
+     * 尋找符合路徑的 handler
+     * 優先精確匹配，再 wildcard 匹配
+     */
+    private findHandler;
+    /**
+     * 路徑匹配邏輯
+     * 支援：
+     * - 精確匹配：/chat
+     * - Wildcard：/api/*, /api*
+     */
+    private matchesPath;
+}

package/dist/core/src/adapters/bun/RadixRouter.d.ts

@@ -6,6 +6,7 @@ import { type RouteHandler, type RouteMatch } from './types';
 export declare class RadixRouter {
     private root;
     private globalConstraints;
+    private routeCache;
     /**
      * Add a generic parameter constraint
      */

package/dist/core/src/adapters/bun/index.d.ts

@@ -0,0 +1,7 @@
+export * from './BunContext';
+export * from './BunNativeAdapter';
+export * from './BunRequest';
+export * from './BunWebSocketHandler';
+export * from './RadixNode';
+export * from './RadixRouter';
+export * from './types';

package/dist/core/src/binary/BinaryUtils.d.ts

@@ -0,0 +1,105 @@
+/**
+ * BinaryUtils - 統一的二進制轉換工具類
+ *
+ * 支援 Bun 原生 API 優化，並提供 Node.js 回退路徑。
+ * 設計為 isomorphic，可在 Bun 和 Node.js 環境中運行。
+ * @public
+ */
+/**
+ * BinaryUtils - 提供統一的二進制轉換、編碼、壓縮工具
+ * 所有方法均為靜態方法，可直接呼叫
+ * @public
+ */
+export declare class BinaryUtils {
+    /**
+     * 將各種資料類型轉換為 Uint8Array
+     * @param data - 輸入資料（Blob、Buffer、string、ArrayBuffer 或 Uint8Array）
+     * @returns Uint8Array
+     * @public
+     */
+    static toUint8Array(data: Blob | Buffer | string | ArrayBuffer | Uint8Array): Promise<Uint8Array>;
+    /**
+     * 將各種資料類型轉換為 ArrayBuffer
+     * @param data - 輸入資料
+     * @returns ArrayBuffer
+     * @public
+     */
+    static toArrayBuffer(data: Blob | Buffer | string | Uint8Array | ArrayBuffer): Promise<ArrayBuffer>;
+    /**
+     * 將 Uint8Array 編碼為 Base64 字串
+     * 在 Bun 環境中使用原生 toBase64()，否則使用 Buffer
+     * @param data - 輸入的 Uint8Array
+     * @returns Base64 字串
+     * @public
+     */
+    static toBase64(data: Uint8Array): string;
+    /**
+     * 將 Base64 字串解碼為 Uint8Array
+     * @param base64 - Base64 字串
+     * @returns Uint8Array
+     * @public
+     */
+    static fromBase64(base64: string): Uint8Array;
+    /**
+     * 將 Uint8Array 編碼為 Base64URL 字串（URL 安全，無填充）
+     * @param data - 輸入的 Uint8Array
+     * @returns Base64URL 字串
+     * @public
+     */
+    static toBase64Url(data: Uint8Array): string;
+    /**
+     * 將 Base64URL 字串解碼為 Uint8Array
+     * @param base64url - Base64URL 字串
+     * @returns Uint8Array
+     * @public
+     */
+    static fromBase64Url(base64url: string): Uint8Array;
+    /**
+     * 將 Uint8Array 編碼為十六進制字串
+     * 在 Bun 環境中使用原生 toHex()，否則使用 Buffer
+     * @param data - 輸入的 Uint8Array
+     * @returns 十六進制字串（小寫）
+     * @public
+     */
+    static toHex(data: Uint8Array): string;
+    /**
+     * 將十六進制字串解碼為 Uint8Array
+     * @param hex - 十六進制字串
+     * @returns Uint8Array
+     * @throws {TypeError} 如果輸入不是有效的十六進制字串
+     * @public
+     */
+    static fromHex(hex: string): Uint8Array;
+    /**
+     * 使用 gzip 壓縮資料
+     * 在 Bun 環境中使用原生 Bun.gzipSync()，在 Node.js 中使用 zlib
+     * @param data - 輸入資料
+     * @param level - 壓縮等級（0-9），預設為 6
+     * @returns 壓縮後的 Uint8Array
+     * @public
+     */
+    static gzip(data: Uint8Array, level?: number): Promise<Uint8Array>;
+    /**
+     * 解壓縮 gzip 資料
+     * 在 Bun 環境中使用原生 Bun.gunzipSync()，在 Node.js 中使用 zlib
+     * @param data - gzip 壓縮的 Uint8Array
+     * @returns 解壓縮後的 Uint8Array
+     * @public
+     */
+    static gunzip(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * 將 ReadableStream<Uint8Array> 讀取為 Uint8Array
+     * 在 Bun 環境中使用原生 Bun.readableStreamToBytes()，否則手動讀取 chunks
+     * @param stream - 輸入的 ReadableStream
+     * @returns Uint8Array
+     * @public
+     */
+    static readableStreamToBytes(stream: ReadableStream<Uint8Array>): Promise<Uint8Array>;
+    /**
+     * 將 ReadableStream<Uint8Array> 讀取為 ArrayBuffer
+     * @param stream - 輸入的 ReadableStream
+     * @returns ArrayBuffer
+     * @public
+     */
+    static readableStreamToArrayBuffer(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer>;
+}

package/dist/core/src/binary/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Binary utilities module for @gravito/core
+ * @packageDocumentation
+ */
+export { BinaryUtils } from './BinaryUtils';

package/dist/core/src/cli/queue-commands.d.ts

@@ -0,0 +1,6 @@
+import type { CommandKernel } from '../CommandKernel';
+import type { QueueDashboard } from '../observability/QueueDashboard';
+/**
+ * Register queue management commands with CommandKernel
+ */
+export declare function registerQueueCommands(kernel: CommandKernel, dashboard: QueueDashboard): void;

package/dist/core/src/compat/async-local-storage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Universal AsyncLocalStorage wrapper.
+ * Automatically switches between node:async_hooks and a browser mock.
+ */
+export declare const AsyncLocalStorage: {
+    new <_T>(): any;
+};

package/dist/core/src/compat/crypto.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Universal Crypto wrapper.
+ * Automatically switches between node:crypto and globalThis.crypto.
+ */
+export declare const randomUUID: () => string;
+export declare const randomBytes: (size: number) => any;

package/dist/core/src/engine/AOTRouter.d.ts

@@ -37,7 +37,12 @@ export declare class AOTRouter {
     private dynamicRoutePatterns;
     private middlewareCache;
     private cacheMaxSize;
-    private version;
+    private _version;
+    /**
+     * Get the current version for cache invalidation
+     * Incremented whenever middleware or routes are modified
+     */
+    get version(): number;
     /**
      * Register a route
      *
@@ -96,6 +101,16 @@ export declare class AOTRouter {
      * @returns Combined middleware array
      */
     private collectMiddleware;
+    /**
+     * Get all static routes optimized for Bun's native router.
+     *
+     * Unlike basic offloading, this version supports routes with middleware
+     * by pre-compiling the middleware chain into a single native handler.
+     *
+     * @param onMatch - Factory to wrap handler and middleware into a Bun-compatible function
+     * @returns Record of path -> Handler (Bun-compatible)
+     */
+    getNativeRoutes(onMatch: (handler: Handler, middleware: Middleware[], path: string) => (req: Request) => Response | Promise<Response>): Record<string, any>;
     /**
      * Check if a path is static (no parameters or wildcards)
      */

package/dist/core/src/engine/FastContext.d.ts

@@ -6,6 +6,7 @@
  *
  * @module @gravito/core/engine
  */
+import { RequestScopeManager } from '../Container/RequestScopeManager';
 import type { FastRequest, FastContext as IFastContext } from './types';
 /**
  * Lazy-parsed request wrapper
@@ -23,6 +24,12 @@ declare class FastRequestImpl implements FastRequest {
     private _headers;
     private _cachedJson;
     private _jsonParsed;
+    private _cachedText;
+    private _textParsed;
+    private _cachedFormData;
+    private _formDataParsed;
+    private _cachedQueries;
+    private _cachedCookies;
     private _ctx;
     constructor(ctx: FastContext);
     /**
@@ -45,6 +52,7 @@ declare class FastRequestImpl implements FastRequest {
     queries(): Record<string, string | string[]>;
     header(name: string): string | undefined;
     headers(): Record<string, string>;
+    get cookies(): Record<string, string>;
     json<T = unknown>(): Promise<T>;
     text(): Promise<string>;
     formData(): Promise<FormData>;
@@ -60,6 +68,7 @@ export declare class FastContext implements IFastContext {
     readonly req: FastRequestImpl;
     private _headers;
     _isReleased: boolean;
+    private _requestScope;
     /**
      * Initialize context for a new request
      *
@@ -80,9 +89,18 @@ export declare class FastContext implements IFastContext {
     json<T>(data: T, status?: number): Response;
     text(text: string, status?: number): Response;
     html(html: string, status?: number): Response;
+    /**
+     * Escape HTML using Bun's SIMD-accelerated native implementation
+     */
+    escape(html: string): string;
     redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
     body(data: BodyInit | null, status?: number): Response;
-    stream(stream: ReadableStream, status?: number): Response;
+    /**
+     * Send high-performance binary response (e.g. CBOR, Protobuf)
+     * Utilizing Bun's native ArrayBufferSink for zero-allocation construction.
+     */
+    binary(data: Uint8Array | ArrayBuffer, status?: number): Response;
+    stream(stream: any, status?: number): Response;
     notFound(message?: string): Response;
     forbidden(message?: string): Response;
     unauthorized(message?: string): Response;
@@ -90,10 +108,33 @@ export declare class FastContext implements IFastContext {
     forward(target: string, _options?: any): Promise<Response>;
     header(name: string): string | undefined;
     header(name: string, value: string): void;
+    /**
+     * Status code setter (no-op)
+     *
+     * Note: Since all response helpers accept a `status` parameter,
+     * this method is not actively used. Status should be set directly
+     * in the response helper call (e.g., `ctx.json({}, 201)`).
+     */
     status(_code: number): void;
     private _store;
     get<T>(key: string): T;
     set(key: string, value: any): void;
+    /**
+     * Get the request-scoped service manager for this request.
+     *
+     * @returns The RequestScopeManager for this request.
+     * @throws Error if called before init() or after reset().
+     */
+    requestScope(): RequestScopeManager;
+    /**
+     * Resolve a request-scoped service (convenience method).
+     *
+     * @template T - The service type.
+     * @param key - The service key for caching.
+     * @param factory - Factory function to create the service.
+     * @returns The cached or newly created service instance.
+     */
+    scoped<T>(key: string | symbol, factory: () => T): T;
     route: (name: string, params?: any, query?: any) => string;
     get native(): this;
 }

package/dist/core/src/engine/Gravito.d.ts

@@ -25,7 +25,6 @@ export declare class Gravito {
     staticRoutes: Map<string, RouteMetadata>;
     private isPureStaticApp;
     private compiledDynamicRoutes;
-    private middlewareVersion;
     /**
      * Create a new Gravito instance
      *
@@ -34,10 +33,6 @@ export declare class Gravito {
     constructor(options?: EngineOptions);
     /**
      * Register a GET route
-     *
-     * @param path - Route path (e.g., '/users/:id')
-     * @param handlers - Handler and optional middleware
-     * @returns This instance for chaining
      */
     get(path: string, ...handlers: Handler[]): this;
     /**
@@ -53,7 +48,7 @@ export declare class Gravito {
      */
     delete(path: string, ...handlers: Handler[]): this;
     /**
-     * Register a PDF route
+     * Register a PATCH route
      */
     patch(path: string, ...handlers: Handler[]): this;
     /**
@@ -95,15 +90,22 @@ export declare class Gravito {
      */
     warmup(paths: string[]): Promise<void>;
     /**
-     * Handle an incoming request
+     * Generate Native Bun.serve Configuration
+     *
+     * Offloads static routes to Bun's SIMD-accelerated native router.
+     * Supports pre-compiled middleware chains for zero runtime lookup.
      */
-    fetch: (request: Request) => Promise<Response>;
+    serveConfig(baseConfig?: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Optimize TLS Configuration for Bun 1.39+
+     */
+    private optimizeTLS;
     /**
-     * Handle routes with middleware (async path)
+     * Handle an incoming request
      */
-    private handleWithMiddleware;
+    fetch: (request: Request) => Promise<Response>;
     /**
-     * Handle dynamic routes (Radix Tree lookup)
+     * Handle dynamic routes with Radix Tree
      */
     private handleDynamicRoute;
     /**
@@ -126,12 +128,4 @@ export declare class Gravito {
      * Add a route to the router
      */
     private addRoute;
-    /**
-     * Execute middleware chain followed by handler
-     */
-    private executeMiddleware;
-    /**
-     * Handle errors (Async version for dynamic/middleware paths)
-     */
-    private handleError;
 }