@gravito/echo 3.1.1 → 3.1.2

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

@@ -1,123 +0,0 @@
-/**
- * @fileoverview FastContext - Pooled Request Context
- *
- * Minimal, high-performance context implementation designed for object pooling.
- * Lazy parsing strategy: only parse what's actually accessed.
- *
- * @module @gravito/core/engine
- */
-import { RequestScopeManager } from '../Container/RequestScopeManager';
-import type { FastRequest, FastContext as IFastContext } from './types';
-/**
- * Lazy-parsed request wrapper
- *
- * Delays parsing of query params, headers, and body until accessed.
- * This is a key optimization for requests that don't need all data.
- */
-declare class FastRequestImpl implements FastRequest {
-    private _request;
-    private _params;
-    private _path;
-    private _routePattern?;
-    private _url;
-    private _query;
-    private _headers;
-    private _cachedJson;
-    private _jsonParsed;
-    private _cachedText;
-    private _textParsed;
-    private _cachedFormData;
-    private _formDataParsed;
-    private _cachedQueries;
-    private _ctx;
-    constructor(ctx: FastContext);
-    /**
-     * Initialize for new request
-     */
-    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
-    /**
-     * Reset for pooling
-     */
-    reset(): void;
-    private checkReleased;
-    get url(): string;
-    get method(): string;
-    get path(): string;
-    get routePattern(): string | undefined;
-    param(name: string): string | undefined;
-    params(): Record<string, string>;
-    private getUrl;
-    query(name: string): string | undefined;
-    queries(): Record<string, string | string[]>;
-    header(name: string): string | undefined;
-    headers(): Record<string, string>;
-    json<T = unknown>(): Promise<T>;
-    text(): Promise<string>;
-    formData(): Promise<FormData>;
-    get raw(): Request;
-}
-/**
- * FastContext - Pooled request context
- *
- * Designed for minimal memory allocation and maximum reuse.
- * All response helpers create Response objects directly without intermediate wrappers.
- */
-export declare class FastContext implements IFastContext {
-    readonly req: FastRequestImpl;
-    private _headers;
-    _isReleased: boolean;
-    private _requestScope;
-    /**
-     * Initialize context for a new request
-     *
-     * This is called when acquiring from the pool.
-     */
-    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
-    /**
-     * Reset context for pooling (Cleanup)
-     *
-     * This is called when releasing back to the pool.
-     * Implements "Deep-Reset Protocol" and "Release Guard".
-     */
-    reset(): void;
-    /**
-     * Check if context is released
-     */
-    private checkReleased;
-    json<T>(data: T, status?: number): Response;
-    text(text: string, status?: number): Response;
-    html(html: string, status?: number): Response;
-    redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
-    body(data: BodyInit | null, status?: number): Response;
-    stream(stream: ReadableStream, status?: number): Response;
-    notFound(message?: string): Response;
-    forbidden(message?: string): Response;
-    unauthorized(message?: string): Response;
-    badRequest(message?: string): Response;
-    forward(target: string, _options?: any): Promise<Response>;
-    header(name: string): string | undefined;
-    header(name: string, value: string): void;
-    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;
-}
-export {};

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

@@ -1,136 +0,0 @@
-/**
- * @fileoverview Gravito - High-Performance Web Engine for Bun
- *
- * The standalone engine optimized exclusively for Bun runtime.
- * 99% API-compatible with Hono, but faster through Bun-specific optimizations.
- *
- * Key optimizations:
- * 1. Object pooling for zero-allocation request handling
- * 2. AOT router with O(1) static route lookup
- * 3. Lazy parsing - only parse what's accessed
- * 4. Direct Bun.serve integration without wrapper layers
- *
- * @module @gravito/core/engine
- */
-import type { EngineOptions, ErrorHandler, Handler, Middleware, NotFoundHandler, RouteMetadata } from './types';
-/**
- * Gravito - The High-Performance Web Engine
- */
-export declare class Gravito {
-    private router;
-    private contextPool;
-    private errorHandler?;
-    private notFoundHandler?;
-    /** @internal */
-    staticRoutes: Map<string, RouteMetadata>;
-    private isPureStaticApp;
-    private compiledDynamicRoutes;
-    /**
-     * Create a new Gravito instance
-     *
-     * @param options - Engine configuration options
-     */
-    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;
-    /**
-     * Register a POST route
-     */
-    post(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register a PUT route
-     */
-    put(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register a DELETE route
-     */
-    delete(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register a PDF route
-     */
-    patch(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register an OPTIONS route
-     */
-    options(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register a HEAD route
-     */
-    head(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register a route for all HTTP methods
-     */
-    all(path: string, ...handlers: Handler[]): this;
-    /**
-     * Register global or path-based middleware
-     */
-    use(path: string, ...middleware: Middleware[]): this;
-    use(...middleware: Middleware[]): this;
-    /**
-     * Mount a sub-application at a path prefix
-     */
-    route(path: string, app: Gravito): this;
-    /**
-     * Set custom error handler
-     */
-    onError(handler: ErrorHandler): this;
-    /**
-     * Set custom 404 handler
-     */
-    notFound(handler: NotFoundHandler): this;
-    /**
-     * Predictive Route Warming (JIT Optimization)
-     *
-     * Simulates requests to specified routes to trigger JIT compilation (FTL)
-     * before real traffic arrives.
-     *
-     * @param paths List of paths to warm up (e.g. ['/api/users', '/health'])
-     */
-    warmup(paths: string[]): Promise<void>;
-    /**
-     * Handle an incoming request
-     */
-    fetch: (request: Request) => Promise<Response>;
-    /**
-     * Handle routes with middleware (async path)
-     */
-    private handleWithMiddleware;
-    /**
-     * Handle dynamic routes (Radix Tree lookup)
-     */
-    private handleDynamicRoute;
-    /**
-     * Sync error handler (for ultra-fast path)
-     */
-    private handleErrorSync;
-    /**
-     * Sync 404 handler (for ultra-fast path)
-     */
-    private handleNotFoundSync;
-    /**
-     * Collect middleware for a specific path
-     */
-    private collectMiddlewareForPath;
-    /**
-     * Compile routes for optimization
-     */
-    private compileRoutes;
-    /**
-     * 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;
-}

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

@@ -1,100 +0,0 @@
-/**
- * @fileoverview MinimalContext - Ultra-lightweight Request Context
- *
- * Designed for zero-middleware static routes where pool overhead
- * exceeds the cost of creating a new object.
- *
- * Key difference from FastContext:
- * - No object pooling (direct instantiation is faster for simple cases)
- * - No Headers object reuse (creates inline)
- * - Minimal memory footprint
- *
- * @module @gravito/core/engine
- */
-import { RequestScopeManager } from '../Container/RequestScopeManager';
-import type { FastRequest, FastContext as IFastContext } from './types';
-/**
- * Minimal request wrapper
- */
-declare class MinimalRequest implements FastRequest {
-    private readonly _request;
-    private readonly _params;
-    private readonly _path;
-    private readonly _routePattern?;
-    private _searchParams;
-    private _cachedQueries;
-    private _cachedJsonPromise;
-    private _cachedTextPromise;
-    private _cachedFormDataPromise;
-    constructor(_request: Request, _params: Record<string, string>, _path: string, _routePattern?: string | undefined);
-    get url(): string;
-    get method(): string;
-    get path(): string;
-    get routePattern(): string | undefined;
-    param(name: string): string | undefined;
-    params(): Record<string, string>;
-    /**
-     * Lazy-initialize searchParams, only parse once
-     */
-    private getSearchParams;
-    query(name: string): string | undefined;
-    queries(): Record<string, string | string[]>;
-    header(name: string): string | undefined;
-    headers(): Record<string, string>;
-    json<T = unknown>(): Promise<T>;
-    text(): Promise<string>;
-    formData(): Promise<FormData>;
-    get raw(): Request;
-}
-/**
- * MinimalContext - Optimized for simple, fast responses
- *
- * Use when:
- * - No middleware
- * - Static routes
- * - Simple JSON/text responses
- * - No custom headers needed
- */
-export declare class MinimalContext implements IFastContext {
-    readonly req: MinimalRequest;
-    private _resHeaders;
-    private _requestScope;
-    constructor(request: Request, params: Record<string, string>, path: string, routePattern?: string);
-    private getHeaders;
-    json<T>(data: T, status?: number): Response;
-    text(text: string, status?: number): Response;
-    html(html: string, status?: number): Response;
-    redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
-    body(data: BodyInit | null, status?: number): Response;
-    header(name: string): string | undefined;
-    header(name: string, value: string): void;
-    status(_code: number): void;
-    stream(stream: ReadableStream, status?: number): Response;
-    notFound(message?: string): Response;
-    forbidden(message?: string): Response;
-    unauthorized(message?: string): Response;
-    badRequest(message?: string): Response;
-    forward(target: string, _options?: any): Promise<Response>;
-    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.
-     */
-    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;
-    init(_request: Request, _params?: Record<string, string>, _path?: string): this;
-    reset(): void;
-}
-export {};

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

@@ -1,27 +0,0 @@
-/**
- * Handler Static Analyzer (Elysia-inspired)
- *
- * Analyzes handler functions to determine what request properties
- * they access, allowing for optimized code paths.
- */
-/**
- * Represents the results of a static analysis performed on a handler function.
- *
- * @public
- * @since 3.0.0
- */
-export interface HandlerAnalysis {
-    usesHeaders: boolean;
-    usesQuery: boolean;
-    usesBody: boolean;
-    usesParams: boolean;
-    isAsync: boolean;
-}
-/**
- * Analyze a handler function to detect what it accesses
- */
-export declare function analyzeHandler(handler: Function): HandlerAnalysis;
-/**
- * Determine optimal context type based on analysis
- */
-export declare function getOptimalContextType(analysis: HandlerAnalysis): 'minimal' | 'fast' | 'full';

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

@@ -1,23 +0,0 @@
-/**
- * @fileoverview Engine Constants & Cached Buffers
- *
- * Pre-allocated resources to minimize runtime allocation overhead.
- * Specifically targets Bun's zero-copy capabilities.
- */
-export declare const CACHED_RESPONSES: {
-    readonly NOT_FOUND: Uint8Array<ArrayBuffer>;
-    readonly INTERNAL_ERROR: Uint8Array<ArrayBuffer>;
-    readonly OK: Uint8Array<ArrayBuffer>;
-    readonly EMPTY: Uint8Array<ArrayBuffer>;
-};
-export declare const HEADERS: {
-    readonly JSON: {
-        readonly 'Content-Type': "application/json; charset=utf-8";
-    };
-    readonly TEXT: {
-        readonly 'Content-Type': "text/plain; charset=utf-8";
-    };
-    readonly HTML: {
-        readonly 'Content-Type': "text/html; charset=utf-8";
-    };
-};

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

@@ -1,26 +0,0 @@
-/**
- * @fileoverview Gravito Core Engine - Public API
- *
- * The High-Performance Web Engine for Bun
- *
- * @module @gravito/core/engine
- * @packageDocumentation
- *
- * @example
- * ```typescript
- * import { Gravito } from '@gravito/core/engine'
- *
- * const app = new Gravito()
- *
- * app.get('/', (c) => c.json({ message: 'Hello, World!' }))
- *
- * export default app
- * ```
- */
-export { Gravito } from './Gravito';
-export type { EngineOptions, ErrorHandler, FastContext, FastRequest, Handler, Middleware, NotFoundHandler, RouteMatch, } from './types';
-export { AOTRouter } from './AOTRouter';
-export { FastContext as FastContextImpl } from './FastContext';
-export { MinimalContext } from './MinimalContext';
-export { extractPath } from './path';
-export { ObjectPool } from './pool';

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

@@ -1,26 +0,0 @@
-/**
- * @fileoverview Lightweight Path Utilities
- *
- * High-performance path extraction without creating URL objects.
- * Performance critical - every optimization matters.
- *
- * @module @gravito/core/engine
- */
-/**
- * Extract pathname from URL string without creating URL object
- *
- * @param url - Full URL string (e.g., "http://localhost:3000/api/users?id=1")
- * @returns pathname (e.g., "/api/users")
- *
- * @example
- * ```typescript
- * extractPath("http://localhost:3000/api/users?id=1") // "/api/users"
- * extractPath("https://example.com/") // "/"
- * ```
- */
-export declare function extractPath(url: string): string;
-/**
- * Extract pathname using simpler logic (alternative implementation)
- * Use this if the above doesn't cover edge cases
- */
-export declare function extractPathSimple(url: string): string;

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

@@ -1,83 +0,0 @@
-/**
- * @fileoverview Generic Object Pool Implementation
- *
- * High-performance object pooling to reduce GC pressure.
- * Implements "fixed pool + overflow fallback" strategy.
- *
- * @module @gravito/core/engine
- */
-/**
- * Generic object pool with fixed size and overflow handling
- *
- * @typeParam T - Type of objects to pool
- *
- * @example
- * ```typescript
- * const pool = new ObjectPool(
- *   () => new MyObject(),
- *   (obj) => obj.reset(),
- *   256
- * )
- *
- * const obj = pool.acquire()
- * try {
- *   // Use object
- * } finally {
- *   pool.release(obj)
- * }
- * ```
- */
-export declare class ObjectPool<T> {
-    private pool;
-    private readonly factory;
-    private readonly reset;
-    private readonly maxSize;
-    /**
-     * Create a new object pool
-     *
-     * @param factory - Function to create new objects
-     * @param reset - Function to reset objects before reuse
-     * @param maxSize - Maximum pool size (default: 256)
-     */
-    constructor(factory: () => T, reset: (obj: T) => void, maxSize?: number);
-    /**
-     * Acquire an object from the pool
-     *
-     * If the pool is empty, creates a new object (overflow strategy).
-     * This ensures the pool never blocks under high load.
-     *
-     * @returns Object from pool or newly created
-     */
-    acquire(): T;
-    /**
-     * Release an object back to the pool
-     *
-     * If the pool is full, the object is discarded (will be GC'd).
-     * This prevents unbounded memory growth.
-     *
-     * @param obj - Object to release
-     */
-    release(obj: T): void;
-    /**
-     * Clear all objects from the pool
-     *
-     * Useful for testing or when you need to force a clean slate.
-     */
-    clear(): void;
-    /**
-     * Get current pool size
-     */
-    get size(): number;
-    /**
-     * Get maximum pool size
-     */
-    get capacity(): number;
-    /**
-     * Pre-warm the pool by creating objects in advance
-     *
-     * This can reduce latency for the first N requests.
-     *
-     * @param count - Number of objects to pre-create
-     */
-    prewarm(count: number): void;
-}

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

@@ -1,146 +0,0 @@
-/**
- * @fileoverview Gravito Core Engine Types
- *
- * Minimal, high-performance types for the standalone engine.
- * These are intentionally simpler than the full framework types.
- *
- * @module @gravito/core/engine
- */
-import type { HttpMethod } from '../http/types';
-/**
- * FastContext - The pooled request context
- */
-export interface FastContext {
-    /** Request accessor */
-    readonly req: FastRequest;
-    /** Response helpers */
-    json<T>(data: T, status?: number): Response;
-    text(text: string, status?: number): Response;
-    html(html: string, status?: number): Response;
-    redirect(url: string, status?: 301 | 302 | 303 | 307 | 308): Response;
-    body(data: BodyInit | null, status?: number): Response;
-    stream(stream: ReadableStream, status?: number): Response;
-    notFound(message?: string): Response;
-    forbidden(message?: string): Response;
-    unauthorized(message?: string): Response;
-    badRequest(message?: string): Response;
-    forward(target: string, options?: any): Promise<Response>;
-    /** Header management */
-    header(name: string): string | undefined;
-    header(name: string, value: string): void;
-    status(code: number): void;
-    /** Context Variables */
-    get<T>(key: string): T;
-    set(key: string, value: any): void;
-    /** Request Scope Management */
-    requestScope(): any;
-    scoped<T>(key: string | symbol, factory: () => T): T;
-    /** Lifecycle helpers */
-    route: (name: string, params?: any, query?: any) => string;
-    readonly native: any;
-    /** Internal initialization for pooling */
-    init(request: Request, params?: Record<string, string>, path?: string, routePattern?: string): this;
-    /** Internal cleanup for pooling */
-    reset(): void;
-}
-/**
- * FastRequest - Minimal request interface
- */
-export interface FastRequest {
-    /** Full URL */
-    readonly url: string;
-    /** HTTP method */
-    readonly method: string;
-    /** Path without query */
-    readonly path: string;
-    /**
-     * Route pattern (e.g., /users/:id) for metrics labeling
-     * Prevents high cardinality issues in monitoring systems
-     */
-    readonly routePattern?: string;
-    /** Get route parameter */
-    param(name: string): string | undefined;
-    /** Get all route parameters */
-    params(): Record<string, string>;
-    /** Get query parameter */
-    query(name: string): string | undefined;
-    /** Get all query parameters */
-    queries(): Record<string, string | string[]>;
-    /** Get header */
-    header(name: string): string | undefined;
-    /** Get all headers */
-    headers(): Record<string, string>;
-    /** Parse JSON body */
-    json<T = unknown>(): Promise<T>;
-    /** Parse text body */
-    text(): Promise<string>;
-    /** Parse form data */
-    formData(): Promise<FormData>;
-    /** Raw Request object */
-    readonly raw: Request;
-}
-/**
- * Route handler function
- */
-export type Handler = (ctx: FastContext) => Response | Promise<Response>;
-/**
- * Middleware function
- */
-export type Middleware = (ctx: FastContext, next: () => Promise<Response | undefined>) => Response | undefined | Promise<Response | undefined>;
-/**
- * Error handler function
- */
-export type ErrorHandler = (error: Error, ctx: FastContext) => Response | Promise<Response>;
-/**
- * Not found handler function
- */
-export type NotFoundHandler = (ctx: FastContext) => Response | Promise<Response>;
-/**
- * Route metadata for middleware management
- */
-export interface RouteMetadata {
-    handler: Handler;
-    middleware: Middleware[];
-    compiled?: CompiledHandler;
-    useMinimal?: boolean;
-    compiledVersion?: number;
-}
-/**
- * Compiled handler function
- */
-export type CompiledHandler = (ctx: FastContext) => Promise<Response>;
-/**
- * Route match result from router
- */
-export interface RouteMatch {
-    /** Matched handler */
-    handler: Handler | null;
-    /** Extracted route parameters */
-    params: Record<string, string>;
-    /** Middleware to execute */
-    middleware: Middleware[];
-    /** Optional stable route pattern for caching */
-    routePattern?: string;
-}
-/**
- * Internal route node
- */
-export interface RouteNode {
-    method: HttpMethod;
-    path: string;
-    handler: Handler;
-    middleware: Middleware[];
-}
-/**
- * Engine configuration options
- */
-export interface EngineOptions {
-    /** Context pool size (default: 256) */
-    poolSize?: number;
-    /** Enable route compilation optimization (default: true) */
-    enableAOT?: boolean;
-    /** Custom error handler */
-    onError?: ErrorHandler;
-    /** Custom 404 handler */
-    onNotFound?: NotFoundHandler;
-}