@gravito/core 1.6.1 → 2.0.1

package/dist/engine/index.js

@@ -1,26 +1,78 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __require = import.meta.require;
+
+// src/engine/index.ts
+var exports_engine = {};
+__export(exports_engine, {
+  extractPath: () => extractPath,
+  ObjectPool: () => ObjectPool,
+  MinimalContext: () => MinimalContext,
+  Gravito: () => Gravito,
+  FastContextImpl: () => FastContext,
+  AOTRouter: () => AOTRouter
+});
+
+// src/adapters/bun/types.ts
+var NodeType;
+((NodeType2) => {
+  NodeType2[NodeType2["STATIC"] = 0] = "STATIC";
+  NodeType2[NodeType2["PARAM"] = 1] = "PARAM";
+  NodeType2[NodeType2["WILDCARD"] = 2] = "WILDCARD";
+})(NodeType ||= {});
+
 // src/adapters/bun/RadixNode.ts
-var RadixNode = class _RadixNode {
-  // Path segment for this node (e.g., "users", ":id")
+class RadixNode {
   segment;
-  // Node type (Static, Param, Wildcard)
   type;
-  // Children nodes (mapped by segment for fast lookup)
-  children = /* @__PURE__ */ new Map();
-  // Specialized child for parameter node (only one per level allowed usually to avoid ambiguity, though some routers support multiple)
+  children = new Map;
   paramChild = null;
-  // Specialized child for wildcard node
   wildcardChild = null;
-  // Handlers registered at this node (keyed by HTTP method)
-  handlers = /* @__PURE__ */ new Map();
-  // Parameter name if this is a PARAM node (e.g., "id" for ":id")
+  handlers = new Map;
   paramName = null;
-  // Parameter constraints (regex) - only applicable if this is a PARAM node
-  // If we support per-route constraints, they might need to be stored differently,
-  // but for now assume constraints are defined at node level (uncommon) or checked at match time.
-  // Laravel allows global pattern constraints or per-route.
-  // Ideally, constraints should be stored with the handler or part of matching logic.
-  // For a Radix tree, if we have constraints, we might need to backtrack if constraint fails?
-  // Or simply store constraint with the param node.
   regex = null;
   constructor(segment = "", type = 0 /* STATIC */) {
     this.segment = segment;
@@ -38,44 +90,61 @@ var RadixNode = class _RadixNode {
     };
   }
   static fromJSON(json) {
-    const node = new _RadixNode(json.segment, json.type);
+    const node = new RadixNode(json.segment, json.type);
     node.paramName = json.paramName;
     if (json.regex) {
       node.regex = new RegExp(json.regex);
     }
     if (json.children) {
       for (const [key, childJson] of json.children) {
-        node.children.set(key, _RadixNode.fromJSON(childJson));
+        node.children.set(key, RadixNode.fromJSON(childJson));
       }
     }
     if (json.paramChild) {
-      node.paramChild = _RadixNode.fromJSON(json.paramChild);
+      node.paramChild = RadixNode.fromJSON(json.paramChild);
     }
     if (json.wildcardChild) {
-      node.wildcardChild = _RadixNode.fromJSON(json.wildcardChild);
+      node.wildcardChild = RadixNode.fromJSON(json.wildcardChild);
     }
     return node;
   }
-};
+}
 
 // src/adapters/bun/RadixRouter.ts
-var RadixRouter = class _RadixRouter {
-  root = new RadixNode();
-  // Global parameter constraints (e.g., id => /^\d+$/)
-  globalConstraints = /* @__PURE__ */ new Map();
-  /**
-   * Add a generic parameter constraint
-   */
+class RouteCache {
+  cache = new Map;
+  maxSize = 1e4;
+  get(key) {
+    return this.cache.get(key);
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, value);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+}
+
+class RadixRouter {
+  root = new RadixNode;
+  globalConstraints = new Map;
+  routeCache = new RouteCache;
   where(param, regex) {
     this.globalConstraints.set(param, regex);
   }
-  /**
-   * Register a route
-   */
   add(method, path, handlers) {
     let node = this.root;
     const segments = this.splitPath(path);
-    for (let i = 0; i < segments.length; i++) {
+    for (let i = 0;i < segments.length; i++) {
       const segment = segments[i];
       if (segment === "*") {
         if (!node.wildcardChild) {
@@ -103,10 +172,8 @@ var RadixRouter = class _RadixRouter {
       }
     }
     node.handlers.set(method.toLowerCase(), handlers);
+    this.routeCache.clear();
   }
-  /**
-   * Match a request
-   */
   match(method, path) {
     const normalizedMethod = method.toLowerCase();
     if (path === "/" || path === "") {
@@ -116,9 +183,15 @@ var RadixRouter = class _RadixRouter {
       }
       return null;
     }
+    const cacheKey = `${normalizedMethod}:${path}`;
+    if (this.routeCache.has(cacheKey)) {
+      return this.routeCache.get(cacheKey) ?? null;
+    }
     const searchPath = path.startsWith("/") ? path.slice(1) : path;
     const segments = searchPath.split("/");
-    return this.matchRecursive(this.root, segments, 0, {}, normalizedMethod);
+    const result = this.matchRecursive(this.root, segments, 0, {}, normalizedMethod);
+    this.routeCache.set(cacheKey, result);
+    return result;
   }
   matchRecursive(node, segments, depth, params, method) {
     if (depth >= segments.length) {
@@ -141,8 +214,7 @@ var RadixRouter = class _RadixRouter {
     }
     const paramChild = node.paramChild;
     if (paramChild) {
-      if (paramChild.regex && !paramChild.regex.test(segment)) {
-      } else {
+      if (paramChild.regex && !paramChild.regex.test(segment)) {} else {
         if (paramChild.paramName) {
           params[paramChild.paramName] = decodeURIComponent(segment);
           const match = this.matchRecursive(paramChild, segments, depth + 1, params, method);
@@ -177,9 +249,6 @@ var RadixRouter = class _RadixRouter {
     }
     return p.split("/");
   }
-  /**
-   * Serialize the router to a JSON string
-   */
   serialize() {
     return JSON.stringify({
       root: this.root.toJSON(),
@@ -189,12 +258,9 @@ var RadixRouter = class _RadixRouter {
       ])
     });
   }
-  /**
-   * Restore a router from a serialized JSON string
-   */
   static fromSerialized(json) {
     const data = JSON.parse(json);
-    const router = new _RadixRouter();
+    const router = new RadixRouter;
     router.root = RadixNode.fromJSON(data.root);
     if (data.globalConstraints) {
       for (const [key, source] of data.globalConstraints) {
@@ -203,49 +269,22 @@ var RadixRouter = class _RadixRouter {
     }
     return router;
   }
-};
+}
 
 // src/engine/AOTRouter.ts
-var AOTRouter = class {
-  // Static route cache: "METHOD:PATH" -> RouteMetadata
-  /** @internal */
-  staticRoutes = /* @__PURE__ */ new Map();
-  // Dynamic route handler (Radix Tree)
-  dynamicRouter = new RadixRouter();
-  // Store all route definitions to support mounting/merging
-  /** @internal */
+class AOTRouter {
+  staticRoutes = new Map;
+  dynamicRouter = new RadixRouter;
   routeDefinitions = [];
-  // Global middleware (applies to all routes)
-  /** @internal */
   globalMiddleware = [];
-  // Path-based middleware: pattern -> middleware[]
-  /** @internal */
-  pathMiddleware = /* @__PURE__ */ new Map();
-  // Dynamic route patterns: handler function -> route pattern
-  // 用於追蹤動態路由的模式，防止高基數問題
-  dynamicRoutePatterns = /* @__PURE__ */ new Map();
-  middlewareCache = /* @__PURE__ */ new Map();
-  cacheMaxSize = 1e3;
+  pathMiddleware = new Map;
+  dynamicRoutePatterns = new Map;
+  middlewareCache = new Map;
+  cacheMaxSize = 1000;
   _version = 0;
-  /**
-   * Get the current version for cache invalidation
-   * Incremented whenever middleware or routes are modified
-   */
   get version() {
     return this._version;
   }
-  /**
-   * Register a route
-   *
-   * Automatically determines if route is static or dynamic.
-   * Static routes are stored in a Map for O(1) lookup.
-   * Dynamic routes use the Radix Tree.
-   *
-   * @param method - HTTP method
-   * @param path - Route path
-   * @param handler - Route handler
-   * @param middleware - Route-specific middleware
-   */
   add(method, path, handler, middleware = []) {
     this.routeDefinitions.push({ method, path, handler, middleware });
     const normalizedMethod = method.toLowerCase();
@@ -261,9 +300,6 @@ var AOTRouter = class {
       }
     }
   }
-  /**
-   * Mount another router at a prefix
-   */
   mount(prefix, other) {
     if (other.globalMiddleware.length > 0) {
       this.usePattern(prefix, ...other.globalMiddleware);
@@ -271,7 +307,8 @@ var AOTRouter = class {
       this.usePattern(wildcard, ...other.globalMiddleware);
     }
     for (const [pattern, mws] of other.pathMiddleware) {
-      if (pattern.includes(":")) {
+      const hasMethodPrefix = /^(get|post|put|delete|patch|options|head):/.test(pattern);
+      if (hasMethodPrefix) {
         continue;
       }
       let newPattern;
@@ -296,25 +333,10 @@ var AOTRouter = class {
       this.add(def.method, newPath, def.handler, def.middleware);
     }
   }
-  /**
-   * Add global middleware
-   *
-   * These run for every request, before route-specific middleware.
-   *
-   * @param middleware - Middleware functions
-   */
   use(...middleware) {
     this.globalMiddleware.push(...middleware);
     this._version++;
   }
-  /**
-   * Add path-based middleware
-   *
-   * Supports wildcard patterns like '/api/*'
-   *
-   * @param pattern - Path pattern
-   * @param middleware - Middleware functions
-   */
   usePattern(pattern, ...middleware) {
     if (pattern === "*") {
       this.globalMiddleware.push(...middleware);
@@ -324,15 +346,6 @@ var AOTRouter = class {
     }
     this._version++;
   }
-  /**
-   * Match a request to a route
-   *
-   * Returns the handler, params, and all applicable middleware.
-   *
-   * @param method - HTTP method
-   * @param path - Request path
-   * @returns Route match or null if not found
-   */
   match(method, path) {
     const normalizedMethod = method.toLowerCase();
     const staticKey = `${normalizedMethod}:${path}`;
@@ -365,28 +378,16 @@ var AOTRouter = class {
       middleware: []
     };
   }
-  /**
-   * Public wrapper for collectMiddleware (used by Gravito for optimization)
-   */
   collectMiddlewarePublic(path, routeMiddleware) {
     return this.collectMiddleware(path, routeMiddleware);
   }
-  /**
-   * Collect all applicable middleware for a path
-   *
-   * Order: global -> pattern-based -> route-specific
-   *
-   * @param path - Request path
-   * @param routeMiddleware - Route-specific middleware
-   * @returns Combined middleware array
-   */
   collectMiddleware(path, routeMiddleware) {
     if (this.globalMiddleware.length === 0 && this.pathMiddleware.size === 0 && routeMiddleware.length === 0) {
       return [];
     }
     const cacheKey = path;
     const cached = this.middlewareCache.get(cacheKey);
-    if (cached !== void 0 && cached.version === this._version) {
+    if (cached !== undefined && cached.version === this._version) {
       return cached.data;
     }
     const middleware = [];
@@ -413,23 +414,21 @@ var AOTRouter = class {
     }
     return middleware;
   }
-  /**
-   * Check if a path is static (no parameters or wildcards)
-   */
+  getNativeRoutes(onMatch) {
+    const routes = {};
+    for (const [key, metadata] of this.staticRoutes) {
+      const [method, path] = key.split(":");
+      if (method !== "get") {
+        continue;
+      }
+      const allMiddleware = this.collectMiddleware(path, metadata.middleware);
+      routes[path] = onMatch(metadata.handler, allMiddleware, path);
+    }
+    return routes;
+  }
   isStaticPath(path) {
     return !path.includes(":") && !path.includes("*");
   }
-  /**
-   * Match a pattern against a path
-   *
-   * Supports:
-   * - Exact match: '/api/users'
-   * - Wildcard suffix: '/api/*'
-   *
-   * @param pattern - Pattern to match
-   * @param path - Path to test
-   * @returns True if pattern matches
-   */
   matchPattern(pattern, path) {
     if (pattern === "*") {
       return true;
@@ -443,9 +442,6 @@ var AOTRouter = class {
     }
     return false;
   }
-  /**
-   * Get all registered routes (for debugging)
-   */
   getRoutes() {
     const routes = [];
     for (const key of this.staticRoutes.keys()) {
@@ -454,11 +450,107 @@ var AOTRouter = class {
     }
     return routes;
   }
-};
+}
 
-// src/engine/analyzer.ts
-function analyzeHandler(handler) {
-  const source = handler.toString();
+// src/transpiler-utils.ts
+class TranspilerCache {
+  static instance = null;
+  transpiler;
+  cache;
+  maxSize;
+  ttlMs;
+  constructor(maxSize = 512, ttlMs = 5 * 60 * 1000) {
+    this.transpiler = new Bun.Transpiler({ loader: "ts" });
+    this.cache = new Map;
+    this.maxSize = maxSize;
+    this.ttlMs = ttlMs;
+  }
+  static getInstance() {
+    TranspilerCache.instance ??= new TranspilerCache;
+    return TranspilerCache.instance;
+  }
+  static resetInstance() {
+    TranspilerCache.instance = null;
+  }
+  transform(source) {
+    const cached = this.cache.get(source);
+    if (cached !== undefined) {
+      if (Date.now() - cached.createdAt < this.ttlMs) {
+        return cached.transformed;
+      }
+      this.cache.delete(source);
+    }
+    const transformed = this.doTransform(source);
+    if (transformed === null) {
+      return null;
+    }
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(source, { transformed, createdAt: Date.now() });
+    return transformed;
+  }
+  doTransform(source) {
+    try {
+      const out = this.transpiler.transformSync(source);
+      if (out.trim().length > 0) {
+        return out;
+      }
+      return this.transformWrapped(source);
+    } catch {
+      return this.transformWrapped(source);
+    }
+  }
+  transformWrapped(source) {
+    try {
+      const wrapped = `const __fn = ${source}`;
+      const out = this.transpiler.transformSync(wrapped);
+      return out.trim().length > 0 ? out : null;
+    } catch {
+      return null;
+    }
+  }
+  get size() {
+    return this.cache.size;
+  }
+  clear() {
+    this.cache.clear();
+  }
+}
+var PATTERNS = {
+  HEADERS_CALL: /\.req\.headers?\s*\(/,
+  HEADERS_DESTR: /\{[^}]*\bheaders?\b[^}]*\}\s*=\s*\w+\.req/,
+  QUERY_CALL: /\.req\.quer(?:y|ies)\s*\(/,
+  QUERY_DESTR: /\{[^}]*\bquer(?:y|ies)\b[^}]*\}\s*=\s*\w+\.req/,
+  BODY_CALL: /\.req\.(?:json|text|formData|blob|arrayBuffer)\s*\(/,
+  BODY_DESTR: /\{[^}]*\bbody\b[^}]*\}\s*=\s*\w+\.req/,
+  BODY_PROP: /\.req\.body\b/,
+  PARAMS_CALL: /\.req\.params?\s*\(/,
+  PARAMS_DESTR: /\{[^}]*\bparams?\b[^}]*\}\s*=\s*\w+\.req/,
+  IS_ASYNC: /\basync\b/
+};
+function analyzeHandlerWithTranspiler(source) {
+  const cache = TranspilerCache.getInstance();
+  const transformed = cache.transform(source);
+  const isAsync = PATTERNS.IS_ASYNC.test(source);
+  if (transformed !== null) {
+    return { ...analyzeTransformedCode(transformed), isAsync };
+  }
+  return { ...fallbackStringAnalysis(source), isAsync };
+}
+function analyzeTransformedCode(code) {
+  return {
+    usesHeaders: PATTERNS.HEADERS_CALL.test(code) || PATTERNS.HEADERS_DESTR.test(code),
+    usesQuery: PATTERNS.QUERY_CALL.test(code) || PATTERNS.QUERY_DESTR.test(code),
+    usesBody: PATTERNS.BODY_CALL.test(code) || PATTERNS.BODY_DESTR.test(code) || PATTERNS.BODY_PROP.test(code),
+    usesParams: PATTERNS.PARAMS_CALL.test(code) || PATTERNS.PARAMS_DESTR.test(code),
+    isAsync: PATTERNS.IS_ASYNC.test(code)
+  };
+}
+function fallbackStringAnalysis(source) {
   return {
     usesHeaders: source.includes(".header(") || source.includes(".header)") || source.includes(".headers(") || source.includes(".headers)"),
     usesQuery: source.includes(".query(") || source.includes(".query)") || source.includes(".queries(") || source.includes(".queries)"),
@@ -467,6 +559,12 @@ function analyzeHandler(handler) {
     isAsync: source.includes("async") || source.includes("await")
   };
 }
+
+// src/engine/analyzer.ts
+function analyzeHandler(handler) {
+  const source = handler.toString();
+  return analyzeHandlerWithTranspiler(source);
+}
 function getOptimalContextType(analysis) {
   if (analysis.usesHeaders) {
     return "fast";
@@ -484,7 +582,7 @@ function getOptimalContextType(analysis) {
 }
 
 // src/engine/constants.ts
-var encoder = new TextEncoder();
+var encoder = new TextEncoder;
 var CACHED_RESPONSES = {
   NOT_FOUND: encoder.encode('{"error":"Not Found"}'),
   INTERNAL_ERROR: encoder.encode('{"error":"Internal Server Error"}'),
@@ -498,25 +596,15 @@ var HEADERS = {
 };
 
 // src/Container/RequestScopeMetrics.ts
-var RequestScopeMetrics = class {
+class RequestScopeMetrics {
   cleanupStartTime = null;
   cleanupDuration = null;
   scopeSize = 0;
   servicesCleaned = 0;
   errorsOccurred = 0;
-  /**
-   * Record start of cleanup operation
-   */
   recordCleanupStart() {
     this.cleanupStartTime = performance.now();
   }
-  /**
-   * Record end of cleanup operation
-   *
-   * @param scopeSize - Number of services in the scope
-   * @param servicesCleaned - Number of services that had cleanup called
-   * @param errorsOccurred - Number of cleanup errors
-   */
   recordCleanupEnd(scopeSize, servicesCleaned, errorsOccurred = 0) {
     if (this.cleanupStartTime !== null) {
       this.cleanupDuration = performance.now() - this.cleanupStartTime;
@@ -526,28 +614,15 @@ var RequestScopeMetrics = class {
     this.servicesCleaned = servicesCleaned;
     this.errorsOccurred = errorsOccurred;
   }
-  /**
-   * Get cleanup duration in milliseconds
-   *
-   * @returns Duration in ms, or null if cleanup not completed
-   */
   getCleanupDuration() {
     return this.cleanupDuration;
   }
-  /**
-   * Check if cleanup took longer than threshold (default 2ms)
-   * Useful for detecting slow cleanups
-   *
-   * @param thresholdMs - Threshold in milliseconds
-   * @returns True if cleanup exceeded threshold
-   */
   isSlowCleanup(thresholdMs = 2) {
-    if (this.cleanupDuration === null) return false;
+    if (this.cleanupDuration === null) {
+      return false;
+    }
     return this.cleanupDuration > thresholdMs;
   }
-  /**
-   * Export metrics as JSON for logging/monitoring
-   */
   toJSON() {
     return {
       cleanupDuration: this.cleanupDuration,
@@ -558,49 +633,66 @@ var RequestScopeMetrics = class {
       isSlowCleanup: this.isSlowCleanup()
     };
   }
-  /**
-   * Export metrics as compact string for logging
-   */
   toString() {
     const duration = this.cleanupDuration ?? "pending";
-    return `cleanup: ${duration}ms, scope: ${this.scopeSize}, cleaned: ${this.servicesCleaned}, errors: ${this.errorsOccurred}`;
+    return `cleanup: ${duration}ms, ` + `scope: ${this.scopeSize}, ` + `cleaned: ${this.servicesCleaned}, ` + `errors: ${this.errorsOccurred}`;
   }
-};
+}
+
+class RequestScopeMetricsCollector {
+  metrics = [];
+  record(metrics) {
+    this.metrics.push(metrics);
+  }
+  getStats() {
+    if (this.metrics.length === 0) {
+      return {
+        count: 0,
+        averageCleanupTime: null,
+        maxCleanupTime: null,
+        minCleanupTime: null,
+        totalErrorCount: 0,
+        errorRate: 0
+      };
+    }
+    const durations = this.metrics.map((m) => m.getCleanupDuration()).filter((d) => d !== null);
+    const errorCounts = this.metrics.map((m) => m.toJSON().errorsOccurred);
+    const totalErrors = errorCounts.reduce((a, b) => a + b, 0);
+    return {
+      count: this.metrics.length,
+      averageCleanupTime: durations.length > 0 ? durations.reduce((a, b) => a + b) / durations.length : null,
+      maxCleanupTime: durations.length > 0 ? Math.max(...durations) : null,
+      minCleanupTime: durations.length > 0 ? Math.min(...durations) : null,
+      totalErrorCount: totalErrors,
+      errorRate: totalErrors / this.metrics.length
+    };
+  }
+  clear() {
+    this.metrics = [];
+  }
+  size() {
+    return this.metrics.length;
+  }
+  toJSON() {
+    return this.metrics.map((m) => m.toJSON());
+  }
+}
 
 // src/Container/RequestScopeManager.ts
-var RequestScopeManager = class {
-  scoped = /* @__PURE__ */ new Map();
-  metadata = /* @__PURE__ */ new Map();
-  metrics = new RequestScopeMetrics();
+class RequestScopeManager {
+  scoped = new Map;
+  metadata = new Map;
+  metrics = new RequestScopeMetrics;
   observer = null;
   constructor(observer) {
     this.observer = observer || null;
   }
-  /**
-   * Set observer for monitoring scope lifecycle
-   */
   setObserver(observer) {
     this.observer = observer;
   }
-  /**
-   * Get metrics for this scope
-   */
   getMetrics() {
     return this.metrics;
   }
-  /**
-   * Resolve or retrieve a request-scoped service instance.
-   *
-   * If the service already exists in this scope, returns the cached instance.
-   * Otherwise, calls the factory function to create a new instance and caches it.
-   *
-   * Automatically detects and records services with cleanup methods.
-   *
-   * @template T - The type of the service.
-   * @param key - The service key (for caching).
-   * @param factory - Factory function to create the instance if not cached.
-   * @returns The cached or newly created instance.
-   */
   resolve(key, factory) {
     const keyStr = String(key);
     const isFromCache = this.scoped.has(keyStr);
@@ -614,15 +706,6 @@ var RequestScopeManager = class {
     this.observer?.onServiceResolved?.(key, isFromCache);
     return this.scoped.get(keyStr);
   }
-  /**
-   * Clean up all request-scoped instances.
-   *
-   * Calls the cleanup() method on each service that has one.
-   * Silently ignores cleanup errors to prevent cascading failures.
-   * Called automatically by the Gravito engine in the request finally block.
-   *
-   * @returns Promise that resolves when all cleanup is complete.
-   */
   async cleanup() {
     this.metrics.recordCleanupStart();
     this.observer?.onCleanupStart?.();
@@ -637,9 +720,7 @@ var RequestScopeManager = class {
             servicesCleaned++;
           } catch (error) {
             errors.push(error);
-            this.observer?.onCleanupError?.(
-              error instanceof Error ? error : new Error(String(error))
-            );
+            this.observer?.onCleanupError?.(error instanceof Error ? error : new Error(String(error)));
           }
         }
       }
@@ -653,18 +734,20 @@ var RequestScopeManager = class {
       console.error("RequestScope cleanup errors:", errors);
     }
   }
-  /**
-   * Get the number of services in this scope (for monitoring).
-   *
-   * @returns The count of cached services.
-   */
   size() {
     return this.scoped.size;
   }
-};
+}
 
 // src/engine/FastContext.ts
-var FastRequestImpl = class {
+var bunEscapeHTML = (html) => {
+  return html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+};
+try {
+  bunEscapeHTML = globalThis.Bun.escapeHTML;
+} catch {}
+
+class FastRequestImpl {
   _request;
   _params;
   _path;
@@ -672,21 +755,18 @@ var FastRequestImpl = class {
   _url = null;
   _query = null;
   _headers = null;
-  _cachedJson = void 0;
+  _cachedJson = undefined;
   _jsonParsed = false;
-  _cachedText = void 0;
+  _cachedText = undefined;
   _textParsed = false;
-  _cachedFormData = void 0;
+  _cachedFormData = undefined;
   _formDataParsed = false;
   _cachedQueries = null;
-  // Back-reference for release check optimization
+  _cachedCookies = null;
   _ctx;
   constructor(ctx) {
     this._ctx = ctx;
   }
-  /**
-   * Initialize for new request
-   */
   init(request, params = {}, path = "", routePattern) {
     this._request = request;
     this._params = params;
@@ -695,37 +775,34 @@ var FastRequestImpl = class {
     this._url = null;
     this._query = null;
     this._headers = null;
-    this._cachedJson = void 0;
+    this._cachedJson = undefined;
     this._jsonParsed = false;
-    this._cachedText = void 0;
+    this._cachedText = undefined;
     this._textParsed = false;
-    this._cachedFormData = void 0;
+    this._cachedFormData = undefined;
     this._formDataParsed = false;
     this._cachedQueries = null;
+    this._cachedCookies = null;
     return this;
   }
-  /**
-   * Reset for pooling
-   */
   reset() {
-    this._request = void 0;
-    this._params = void 0;
+    this._request = undefined;
+    this._params = undefined;
     this._url = null;
     this._query = null;
     this._headers = null;
-    this._cachedJson = void 0;
+    this._cachedJson = undefined;
     this._jsonParsed = false;
-    this._cachedText = void 0;
+    this._cachedText = undefined;
     this._textParsed = false;
-    this._cachedFormData = void 0;
+    this._cachedFormData = undefined;
     this._formDataParsed = false;
     this._cachedQueries = null;
+    this._cachedCookies = null;
   }
   checkReleased() {
     if (this._ctx._isReleased) {
-      throw new Error(
-        "FastContext usage after release detected! (Object Pool Strict Lifecycle Guard)"
-      );
+      throw new Error("FastContext usage after release detected! (Object Pool Strict Lifecycle Guard)");
     }
   }
   get url() {
@@ -763,7 +840,7 @@ var FastRequestImpl = class {
     if (!this._query) {
       this._query = this.getUrl().searchParams;
     }
-    return this._query.get(name) ?? void 0;
+    return this._query.get(name) ?? undefined;
   }
   queries() {
     this.checkReleased();
@@ -776,7 +853,7 @@ var FastRequestImpl = class {
     const result = {};
     for (const [key, value] of this._query.entries()) {
       const existing = result[key];
-      if (existing === void 0) {
+      if (existing === undefined) {
         result[key] = value;
       } else if (Array.isArray(existing)) {
         existing.push(value);
@@ -789,7 +866,7 @@ var FastRequestImpl = class {
   }
   header(name) {
     this.checkReleased();
-    return this._request.headers.get(name) ?? void 0;
+    return this._request.headers.get(name) ?? undefined;
   }
   headers() {
     this.checkReleased();
@@ -801,6 +878,39 @@ var FastRequestImpl = class {
     }
     return { ...this._headers };
   }
+  get cookies() {
+    this.checkReleased();
+    if (this._cachedCookies !== null) {
+      return this._cachedCookies;
+    }
+    const nativeCookies = this._request.cookies;
+    if (nativeCookies) {
+      this._cachedCookies = nativeCookies;
+      return nativeCookies;
+    }
+    const cookieHeader = this._request.headers.get("cookie");
+    if (!cookieHeader) {
+      this._cachedCookies = {};
+      return {};
+    }
+    const cookies = {};
+    const pairs = cookieHeader.split(/;\s*/);
+    for (let i = 0;i < pairs.length; i++) {
+      const pair = pairs[i];
+      const idx = pair.indexOf("=");
+      if (idx > 0) {
+        const name = pair.substring(0, idx);
+        const value = pair.substring(idx + 1);
+        try {
+          cookies[name] = decodeURIComponent(value);
+        } catch {
+          cookies[name] = value;
+        }
+      }
+    }
+    this._cachedCookies = cookies;
+    return cookies;
+  }
   async json() {
     this.checkReleased();
     if (!this._jsonParsed) {
@@ -829,82 +939,57 @@ var FastRequestImpl = class {
     this.checkReleased();
     return this._request;
   }
-};
-var FastContext = class {
+}
+
+class FastContext {
   req = new FastRequestImpl(this);
-  // private _statusCode = 200
-  _headers = new Headers();
-  // Reuse this object
+  _headers = new Headers;
   _isReleased = false;
-  // Made public for internal check access
   _requestScope = null;
-  // Request-scoped services
-  /**
-   * Initialize context for a new request
-   *
-   * This is called when acquiring from the pool.
-   */
   init(request, params = {}, path = "", routePattern) {
     this._isReleased = false;
     this.req.init(request, params, path, routePattern);
-    this._headers = new Headers();
-    this._requestScope = new RequestScopeManager();
+    this._headers = new Headers;
+    this._requestScope = new RequestScopeManager;
     return this;
   }
-  /**
-   * Reset context for pooling (Cleanup)
-   *
-   * This is called when releasing back to the pool.
-   * Implements "Deep-Reset Protocol" and "Release Guard".
-   */
   reset() {
     this._isReleased = true;
     this.req.reset();
     this._store.clear();
+    this._requestScope = null;
   }
-  /**
-   * Check if context is released
-   */
   checkReleased() {
     if (this._isReleased) {
-      throw new Error(
-        "FastContext usage after release detected! (Object Pool Strict Lifecycle Guard)"
-      );
+      throw new Error("FastContext usage after release detected! (Object Pool Strict Lifecycle Guard)");
     }
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Response Helpers
-  // ─────────────────────────────────────────────────────────────────────────
   json(data, status = 200) {
     this.checkReleased();
-    this._headers.set("Content-Type", "application/json; charset=utf-8");
-    return new Response(JSON.stringify(data), {
-      status,
-      headers: this._headers
-    });
+    const headers = new Headers(this._headers);
+    headers.set("Content-Type", "application/json; charset=utf-8");
+    return Response.json(data, { status, headers });
   }
   text(text, status = 200) {
     this.checkReleased();
-    this._headers.set("Content-Type", "text/plain; charset=utf-8");
-    return new Response(text, {
-      status,
-      headers: this._headers
-    });
+    const headers = new Headers(this._headers);
+    headers.set("Content-Type", "text/plain; charset=utf-8");
+    return new Response(text, { status, headers });
   }
   html(html, status = 200) {
     this.checkReleased();
-    this._headers.set("Content-Type", "text/html; charset=utf-8");
-    return new Response(html, {
-      status,
-      headers: this._headers
-    });
+    const headers = new Headers(this._headers);
+    headers.set("Content-Type", "text/html; charset=utf-8");
+    return new Response(html, { status, headers });
+  }
+  escape(html) {
+    return bunEscapeHTML(html);
   }
   redirect(url, status = 302) {
     this.checkReleased();
-    this._headers.set("Location", url);
     return new Response(null, {
       status,
-      headers: this._headers
+      headers: { Location: url }
     });
   }
   body(data, status = 200) {
@@ -914,12 +999,19 @@ var FastContext = class {
       headers: this._headers
     });
   }
+  binary(data, status = 200) {
+    this.checkReleased();
+    const body = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    return new Response(body, {
+      status,
+      headers: { "Content-Type": "application/octet-stream" }
+    });
+  }
   stream(stream, status = 200) {
     this.checkReleased();
-    this._headers.set("Content-Type", "application/octet-stream");
     return new Response(stream, {
       status,
-      headers: this._headers
+      headers: { "Content-Type": "application/octet-stream" }
     });
   }
   notFound(message = "Not Found") {
@@ -937,9 +1029,7 @@ var FastContext = class {
   async forward(target, _options = {}) {
     this.checkReleased();
     const url = new URL(this.req.url);
-    const targetUrl = new URL(
-      target.startsWith("http") ? target : `${url.protocol}//${target}${this.req.path}`
-    );
+    const targetUrl = new URL(target.startsWith("http") ? target : `${url.protocol}//${target}${this.req.path}`);
     const searchParams = new URLSearchParams(url.search);
     searchParams.forEach((v, k) => {
       targetUrl.searchParams.set(k, v);
@@ -948,13 +1038,12 @@ var FastContext = class {
       method: this.req.method,
       headers: this.req.raw.headers,
       body: this.req.method !== "GET" && this.req.method !== "HEAD" ? this.req.raw.body : null,
-      // @ts-expect-error - Bun/Fetch specific
       duplex: "half"
     });
   }
   header(name, value) {
     this.checkReleased();
-    if (value !== void 0) {
+    if (value !== undefined) {
       this._headers.set(name, value);
       return;
     }
@@ -963,64 +1052,52 @@ var FastContext = class {
   status(_code) {
     this.checkReleased();
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Context Variables
-  // ─────────────────────────────────────────────────────────────────────────
-  _store = /* @__PURE__ */ new Map();
+  _store = new Map;
   get(key) {
     return this._store.get(key);
   }
   set(key, value) {
     this._store.set(key, value);
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Request Scope Management
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * 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() {
     if (!this._requestScope) {
       throw new Error("RequestScope not initialized. Call init() first.");
     }
     return this._requestScope;
   }
-  /**
-   * 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(key, factory) {
     return this.requestScope().resolve(key, factory);
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Lifecycle helpers
-  // ─────────────────────────────────────────────────────────────────────────
   route = () => "";
   get native() {
     return this;
   }
-};
+}
 
 // src/engine/MinimalContext.ts
-var MinimalRequest = class {
+var bunEscapeHTML2 = (html) => {
+  return html.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+};
+try {
+  bunEscapeHTML2 = globalThis.Bun.escapeHTML;
+} catch {}
+
+class MinimalRequest {
+  _request;
+  _params;
+  _path;
+  _routePattern;
+  _searchParams = null;
+  _cachedQueries = null;
+  _cachedJsonPromise = null;
+  _cachedTextPromise = null;
+  _cachedFormDataPromise = null;
   constructor(_request, _params, _path, _routePattern) {
     this._request = _request;
     this._params = _params;
     this._path = _path;
     this._routePattern = _routePattern;
   }
-  _searchParams = null;
-  _cachedQueries = null;
-  _cachedJsonPromise = null;
-  _cachedTextPromise = null;
-  _cachedFormDataPromise = null;
   get url() {
     return this._request.url;
   }
@@ -1039,15 +1116,12 @@ var MinimalRequest = class {
   params() {
     return { ...this._params };
   }
-  /**
-   * Lazy-initialize searchParams, only parse once
-   */
   getSearchParams() {
     if (this._searchParams === null) {
       const url = this._request.url;
       const queryStart = url.indexOf("?");
       if (queryStart === -1) {
-        this._searchParams = new URLSearchParams();
+        this._searchParams = new URLSearchParams;
       } else {
         const hashStart = url.indexOf("#", queryStart);
         const queryString = hashStart === -1 ? url.slice(queryStart + 1) : url.slice(queryStart + 1, hashStart);
@@ -1057,7 +1131,7 @@ var MinimalRequest = class {
     return this._searchParams;
   }
   query(name) {
-    return this.getSearchParams().get(name) ?? void 0;
+    return this.getSearchParams().get(name) ?? undefined;
   }
   queries() {
     if (this._cachedQueries !== null) {
@@ -1067,7 +1141,7 @@ var MinimalRequest = class {
     const result = {};
     for (const [key, value] of params.entries()) {
       const existing = result[key];
-      if (existing === void 0) {
+      if (existing === undefined) {
         result[key] = value;
       } else if (Array.isArray(existing)) {
         existing.push(value);
@@ -1079,7 +1153,7 @@ var MinimalRequest = class {
     return result;
   }
   header(name) {
-    return this._request.headers.get(name) ?? void 0;
+    return this._request.headers.get(name) ?? undefined;
   }
   headers() {
     const result = {};
@@ -1106,23 +1180,45 @@ var MinimalRequest = class {
     }
     return this._cachedFormDataPromise;
   }
+  get cookies() {
+    const nativeCookies = this._request.cookies;
+    if (nativeCookies) {
+      return nativeCookies;
+    }
+    const cookieHeader = this._request.headers.get("cookie");
+    if (!cookieHeader) {
+      return {};
+    }
+    const cookies = {};
+    const pairs = cookieHeader.split(/;\s*/);
+    for (let i = 0;i < pairs.length; i++) {
+      const pair = pairs[i];
+      const idx = pair.indexOf("=");
+      if (idx > 0) {
+        const name = pair.substring(0, idx);
+        const value = pair.substring(idx + 1);
+        try {
+          cookies[name] = decodeURIComponent(value);
+        } catch {
+          cookies[name] = value;
+        }
+      }
+    }
+    return cookies;
+  }
   get raw() {
     return this._request;
   }
-};
-var MinimalContext = class {
+}
+
+class MinimalContext {
   req;
   _resHeaders = {};
   _requestScope;
   constructor(request, params, path, routePattern) {
     this.req = new MinimalRequest(request, params, path, routePattern);
-    this._requestScope = new RequestScopeManager();
+    this._requestScope = new RequestScopeManager;
   }
-  // get req(): FastRequest {
-  //   return this._req
-  // }
-  // Response helpers - merge custom headers with defaults
-  // Optimized: use Object.assign instead of spread to avoid shallow copy overhead
   getHeaders(contentType) {
     const headers = Object.assign({ "Content-Type": contentType }, this._resHeaders);
     return headers;
@@ -1158,14 +1254,13 @@ var MinimalContext = class {
     });
   }
   header(name, value) {
-    if (value !== void 0) {
+    if (value !== undefined) {
       this._resHeaders[name] = value;
       return;
     }
     return this.req.header(name);
   }
-  status(_code) {
-  }
+  status(_code) {}
   stream(stream, status = 200) {
     return new Response(stream, {
       status,
@@ -1186,35 +1281,22 @@ var MinimalContext = class {
   }
   async forward(target, _options = {}) {
     const url = new URL(this.req.url);
-    const targetUrl = new URL(
-      target.startsWith("http") ? target : `${url.protocol}//${target}${this.req.path}`
-    );
+    const targetUrl = new URL(target.startsWith("http") ? target : `${url.protocol}//${target}${this.req.path}`);
     return fetch(targetUrl.toString(), {
       method: this.req.method,
       headers: this.req.raw.headers
     });
   }
-  get(_key) {
-    return void 0;
+  escape(html) {
+    return bunEscapeHTML2(html);
   }
-  set(_key, _value) {
+  get(_key) {
+    return;
   }
-  /**
-   * Get the request-scoped service manager for this request.
-   *
-   * @returns The RequestScopeManager for this request.
-   */
+  set(_key, _value) {}
   requestScope() {
     return this._requestScope;
   }
-  /**
-   * 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(key, factory) {
     return this._requestScope.resolve(key, factory);
   }
@@ -1222,14 +1304,11 @@ var MinimalContext = class {
   get native() {
     return this;
   }
-  // Required for interface compatibility
   init(_request, _params, _path) {
     throw new Error("MinimalContext does not support init. Create a new instance instead.");
   }
-  // Required for interface compatibility
-  reset() {
-  }
-};
+  reset() {}
+}
 
 // src/engine/path.ts
 function extractPath(url) {
@@ -1247,79 +1326,38 @@ function extractPath(url) {
 }
 
 // src/engine/pool.ts
-var ObjectPool = class {
+class ObjectPool {
   pool = [];
   factory;
   reset;
   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, reset, maxSize = 256) {
     this.factory = factory;
     this.reset = reset;
     this.maxSize = maxSize;
   }
-  /**
-   * 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() {
     const obj = this.pool.pop();
-    if (obj !== void 0) {
+    if (obj !== undefined) {
       return obj;
     }
     return this.factory();
   }
-  /**
-   * 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) {
     if (this.pool.length < this.maxSize) {
       this.reset(obj);
       this.pool.push(obj);
     }
   }
-  /**
-   * Clear all objects from the pool
-   *
-   * Useful for testing or when you need to force a clean slate.
-   */
   clear() {
     this.pool = [];
   }
-  /**
-   * Get current pool size
-   */
   get size() {
     return this.pool.length;
   }
-  /**
-   * Get maximum pool size
-   */
   get capacity() {
     return this.maxSize;
   }
-  /**
-   * 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) {
     const targetSize = Math.min(count, this.maxSize);
     while (this.pool.length < targetSize) {
@@ -1328,9 +1366,16 @@ var ObjectPool = class {
       this.pool.push(obj);
     }
   }
-};
+}
 
 // src/engine/Gravito.ts
+var bunPeek = (promise) => promise;
+var bunFile = (path) => path;
+try {
+  const bunModule = globalThis.Bun;
+  bunPeek = bunModule.peek;
+  bunFile = bunModule.file;
+} catch {}
 function compileMiddlewareChain(middleware, handler) {
   if (middleware.length === 0) {
     return handler;
@@ -1339,64 +1384,76 @@ function compileMiddlewareChain(middleware, handler) {
     const mw = middleware[0];
     return async (ctx) => {
       let nextCalled = false;
-      const result = await mw(ctx, async () => {
+      const result = mw(ctx, async () => {
         nextCalled = true;
-        return void 0;
+        return;
       });
-      if (result instanceof Response) {
-        return result;
+      let finalResult;
+      if (result instanceof Promise) {
+        const peeked = bunPeek(result);
+        finalResult = peeked === result ? await result : peeked;
+      } else {
+        finalResult = result;
+      }
+      if (finalResult instanceof Response) {
+        return finalResult;
       }
       if (nextCalled) {
-        return await handler(ctx);
+        const hResult = handler(ctx);
+        if (hResult instanceof Promise) {
+          const p = bunPeek(hResult);
+          return p === hResult ? await hResult : p;
+        }
+        return hResult;
       }
       return ctx.json({ error: "Middleware did not call next or return response" }, 500);
     };
   }
   let compiled = handler;
-  for (let i = middleware.length - 1; i >= 0; i--) {
+  for (let i = middleware.length - 1;i >= 0; i--) {
     const mw = middleware[i];
     const nextHandler = compiled;
     compiled = async (ctx) => {
       let nextCalled = false;
-      const result = await mw(ctx, async () => {
+      const result = mw(ctx, async () => {
         nextCalled = true;
-        return void 0;
+        return;
       });
-      if (result instanceof Response) {
-        return result;
+      let finalResult;
+      if (result instanceof Promise) {
+        const peeked = bunPeek(result);
+        finalResult = peeked === result ? await result : peeked;
+      } else {
+        finalResult = result;
+      }
+      if (finalResult instanceof Response) {
+        return finalResult;
       }
       if (nextCalled) {
-        return await nextHandler(ctx);
+        const nextResult = nextHandler(ctx);
+        if (nextResult instanceof Promise) {
+          const p = bunPeek(nextResult);
+          return p === nextResult ? await nextResult : p;
+        }
+        return nextResult;
       }
       return ctx.json({ error: "Middleware did not call next or return response" }, 500);
     };
   }
   return compiled;
 }
-var Gravito = class {
-  router = new AOTRouter();
+
+class Gravito {
+  router = new AOTRouter;
   contextPool;
   errorHandler;
   notFoundHandler;
-  // Direct reference to static routes Map (O(1) access)
-  /** @internal */
   staticRoutes;
-  // Flag: pure static app (no middleware at all) allows ultra-fast path
   isPureStaticApp = true;
-  // Cache for precompiled dynamic routes
-  compiledDynamicRoutes = /* @__PURE__ */ new Map();
-  /**
-   * Create a new Gravito instance
-   *
-   * @param options - Engine configuration options
-   */
+  compiledDynamicRoutes = new Map;
   constructor(options = {}) {
     const poolSize = options.poolSize ?? 256;
-    this.contextPool = new ObjectPool(
-      () => new FastContext(),
-      (ctx) => ctx.reset(),
-      poolSize
-    );
+    this.contextPool = new ObjectPool(() => new FastContext, (ctx) => ctx.reset(), poolSize);
     this.contextPool.prewarm(Math.min(32, poolSize));
     if (options.onError) {
       this.errorHandler = options.onError;
@@ -1406,58 +1463,27 @@ var Gravito = class {
     }
     this.compileRoutes();
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // HTTP Method Registration
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * 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, ...handlers) {
     return this.addRoute("get", path, handlers);
   }
-  /**
-   * Register a POST route
-   */
   post(path, ...handlers) {
     return this.addRoute("post", path, handlers);
   }
-  /**
-   * Register a PUT route
-   */
   put(path, ...handlers) {
     return this.addRoute("put", path, handlers);
   }
-  /**
-   * Register a DELETE route
-   */
   delete(path, ...handlers) {
     return this.addRoute("delete", path, handlers);
   }
-  /**
-   * Register a PDF route
-   */
   patch(path, ...handlers) {
     return this.addRoute("patch", path, handlers);
   }
-  /**
-   * Register an OPTIONS route
-   */
   options(path, ...handlers) {
     return this.addRoute("options", path, handlers);
   }
-  /**
-   * Register a HEAD route
-   */
   head(path, ...handlers) {
     return this.addRoute("head", path, handlers);
   }
-  /**
-   * Register a route for all HTTP methods
-   */
   all(path, ...handlers) {
     const methods = ["get", "post", "put", "delete", "patch", "options", "head"];
     for (const method of methods) {
@@ -1475,45 +1501,19 @@ var Gravito = class {
     this.compileRoutes();
     return this;
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Route Grouping
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * Mount a sub-application at a path prefix
-   */
   route(path, app) {
     this.router.mount(path, app.router);
     this.compileRoutes();
     return this;
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Error Handling
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * Set custom error handler
-   */
   onError(handler) {
     this.errorHandler = handler;
     return this;
   }
-  /**
-   * Set custom 404 handler
-   */
   notFound(handler) {
     this.notFoundHandler = handler;
     return this;
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Request Handling (Bun.serve integration)
-  // ─────────────────────────────────────────────────────────────────────────
-  /**
-   * 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'])
-   */
   async warmup(paths) {
     const dummyReqOpts = { headers: { "User-Agent": "Gravito-Warmup/1.0" } };
     for (const path of paths) {
@@ -1521,96 +1521,141 @@ var Gravito = class {
       await this.fetch(req);
     }
   }
-  /**
-   * Handle an incoming request
-   */
+  serveConfig(baseConfig = {}) {
+    const nativeRoutes = this.router.getNativeRoutes((handler, middleware, path) => {
+      const compiled = compileMiddlewareChain(middleware, handler);
+      return async (req) => {
+        const ctx = this.contextPool.acquire();
+        ctx.init(req, {}, path, path);
+        try {
+          const result = compiled(ctx);
+          let response;
+          if (result instanceof Promise) {
+            const peeked = bunPeek(result);
+            response = peeked === result ? await result : peeked;
+          } else {
+            response = result;
+          }
+          const cleanup = ctx.requestScope().cleanup();
+          if (cleanup instanceof Promise) {
+            await cleanup;
+          }
+          this.contextPool.release(ctx);
+          return response;
+        } catch (error) {
+          const cleanup = ctx.requestScope().cleanup();
+          if (cleanup instanceof Promise) {
+            await cleanup;
+          }
+          this.contextPool.release(ctx);
+          return this.handleErrorSync(error, req, path);
+        }
+      };
+    });
+    return {
+      ...baseConfig,
+      routes: nativeRoutes,
+      fetch: this.fetch,
+      tls: baseConfig.tls ? this.optimizeTLS(baseConfig.tls) : undefined,
+      error: (error) => {
+        console.error("Native route error:", error);
+        return new Response(CACHED_RESPONSES.INTERNAL_ERROR, {
+          status: 500,
+          headers: HEADERS.JSON
+        });
+      }
+    };
+  }
+  optimizeTLS(tls) {
+    const isProd = false;
+    const optimizeEntry = (entry) => {
+      const optimized = { ...entry };
+      if (typeof optimized.key === "string" && !optimized.key.startsWith("-----BEGIN")) {
+        optimized.key = bunFile(optimized.key);
+      }
+      if (typeof optimized.cert === "string" && !optimized.cert.startsWith("-----BEGIN")) {
+        optimized.cert = bunFile(optimized.cert);
+      }
+      if (isProd && optimized.lowMemoryMode === undefined) {
+        optimized.lowMemoryMode = true;
+      }
+      return optimized;
+    };
+    return Array.isArray(tls) ? tls.map(optimizeEntry) : optimizeEntry(tls);
+  }
   fetch = async (request) => {
     const path = extractPath(request.url);
     const method = request.method.toLowerCase();
     const staticKey = `${method}:${path}`;
     const staticRoute = this.staticRoutes.get(staticKey);
     if (staticRoute) {
-      if (staticRoute.useMinimal) {
-        const ctx = new MinimalContext(request, {}, path, path);
-        try {
-          const result = staticRoute.handler(ctx);
-          if (result instanceof Response) {
-            return result;
-          }
-          return await result;
-        } catch (error) {
-          return this.handleErrorSync(error, request, path);
+      const ctx = this.contextPool.acquire();
+      ctx.init(request, {}, path, path);
+      try {
+        const compiled = staticRoute.compiled || compileMiddlewareChain(staticRoute.middleware, staticRoute.handler);
+        const result = compiled(ctx);
+        let response;
+        if (result instanceof Promise) {
+          const peeked = bunPeek(result);
+          response = peeked === result ? await result : peeked;
+        } else {
+          response = result;
+        }
+        const cleanup = ctx.requestScope().cleanup();
+        if (cleanup instanceof Promise) {
+          await cleanup;
+        }
+        this.contextPool.release(ctx);
+        return response;
+      } catch (error) {
+        const cleanup = ctx.requestScope().cleanup();
+        if (cleanup instanceof Promise) {
+          await cleanup;
         }
+        this.contextPool.release(ctx);
+        return this.handleErrorSync(error, request, path);
       }
-      return await this.handleWithMiddleware(request, path, staticRoute);
     }
     return await this.handleDynamicRoute(request, method, path);
   };
-  /**
-   * Handle routes with middleware (async path)
-   */
-  async handleWithMiddleware(request, path, route) {
-    const ctx = this.contextPool.acquire();
-    try {
-      ctx.init(request, {}, path, path);
-      if (route.compiled) {
-        return await route.compiled(ctx);
-      }
-      const middleware = this.collectMiddlewareForPath(path, route.middleware);
-      if (middleware.length === 0) {
-        return await route.handler(ctx);
-      }
-      return await this.executeMiddleware(ctx, middleware, route.handler);
-    } catch (error) {
-      return await this.handleError(error, ctx);
-    } finally {
+  async handleDynamicRoute(request, method, path) {
+    const match = this.router.match(method, path);
+    if (match.handler) {
+      const ctx = this.contextPool.acquire();
+      ctx.init(request, match.params, path, match.routePattern);
       try {
-        await ctx.requestScope().cleanup();
-      } catch (cleanupError) {
-        console.error("RequestScope cleanup failed:", cleanupError);
-      }
-      this.contextPool.release(ctx);
-    }
-  }
-  /**
-   * Handle dynamic routes (Radix Tree lookup)
-   */
-  handleDynamicRoute(request, method, path) {
-    const match = this.router.match(method.toUpperCase(), path);
-    if (!match.handler) {
-      return this.handleNotFoundSync(request, path);
-    }
-    const cacheKey = `${method}:${match.routePattern ?? path}`;
-    let entry = this.compiledDynamicRoutes.get(cacheKey);
-    if (!entry || entry.version !== this.router.version) {
-      const compiled = compileMiddlewareChain(match.middleware, match.handler);
-      if (this.compiledDynamicRoutes.size > 1e3) {
-        this.compiledDynamicRoutes.clear();
-      }
-      entry = { compiled, version: this.router.version };
-      this.compiledDynamicRoutes.set(cacheKey, entry);
-    }
-    const ctx = this.contextPool.acquire();
-    const execute = async () => {
-      try {
-        ctx.init(request, match.params, path, match.routePattern);
-        return await entry?.compiled(ctx);
+        const routeKey = `${method}:${match.routePattern}`;
+        let compiledObj = this.compiledDynamicRoutes.get(routeKey);
+        if (!compiledObj || compiledObj.version !== this.router.version) {
+          const compiled = compileMiddlewareChain(match.middleware, match.handler);
+          compiledObj = { compiled, version: this.router.version };
+          this.compiledDynamicRoutes.set(routeKey, compiledObj);
+        }
+        const result = compiledObj.compiled(ctx);
+        let response;
+        if (result instanceof Promise) {
+          const peeked = bunPeek(result);
+          response = peeked === result ? await result : peeked;
+        } else {
+          response = result;
+        }
+        const cleanup = ctx.requestScope().cleanup();
+        if (cleanup instanceof Promise) {
+          await cleanup;
+        }
+        this.contextPool.release(ctx);
+        return response;
       } catch (error) {
-        return await this.handleError(error, ctx);
-      } finally {
-        try {
-          await ctx.requestScope().cleanup();
-        } catch (cleanupError) {
-          console.error("RequestScope cleanup failed:", cleanupError);
+        const cleanup = ctx.requestScope().cleanup();
+        if (cleanup instanceof Promise) {
+          await cleanup;
         }
         this.contextPool.release(ctx);
+        return this.handleErrorSync(error, request, path);
       }
-    };
-    return execute();
+    }
+    return this.handleNotFoundSync(request, path);
   }
-  /**
-   * Sync error handler (for ultra-fast path)
-   */
   handleErrorSync(error, request, path) {
     if (this.errorHandler) {
       const ctx = new MinimalContext(request, {}, path);
@@ -1626,9 +1671,6 @@ var Gravito = class {
       headers: HEADERS.JSON
     });
   }
-  /**
-   * Sync 404 handler (for ultra-fast path)
-   */
   handleNotFoundSync(request, path) {
     if (this.notFoundHandler) {
       const ctx = new MinimalContext(request, {}, path);
@@ -1643,18 +1685,12 @@ var Gravito = class {
       headers: HEADERS.JSON
     });
   }
-  /**
-   * Collect middleware for a specific path
-   */
   collectMiddlewareForPath(path, routeMiddleware) {
     if (this.router.globalMiddleware.length === 0 && this.router.pathMiddleware.size === 0) {
       return routeMiddleware;
     }
     return this.router.collectMiddlewarePublic(path, routeMiddleware);
   }
-  /**
-   * Compile routes for optimization
-   */
   compileRoutes() {
     this.staticRoutes = this.router.staticRoutes;
     const hasGlobalMiddleware = this.router.globalMiddleware.length > 0;
@@ -1674,9 +1710,6 @@ var Gravito = class {
       route.compiledVersion = this.router.version;
     }
   }
-  /**
-   * Add a route to the router
-   */
   addRoute(method, path, handlers) {
     if (handlers.length === 0) {
       throw new Error(`No handler provided for ${method.toUpperCase()} ${path}`);
@@ -1687,46 +1720,14 @@ var Gravito = class {
     this.compileRoutes();
     return this;
   }
-  /**
-   * Execute middleware chain followed by handler
-   */
-  async executeMiddleware(ctx, middleware, handler) {
-    let index = 0;
-    const next = async () => {
-      if (index < middleware.length) {
-        const mw = middleware[index++];
-        return await mw(ctx, next);
-      }
-      return void 0;
-    };
-    const result = await next();
-    if (result instanceof Response) {
-      return result;
-    }
-    return await handler(ctx);
-  }
-  /**
-   * Handle errors (Async version for dynamic/middleware paths)
-   */
-  async handleError(error, ctx) {
-    if (this.errorHandler) {
-      return await this.errorHandler(error, ctx);
-    }
-    console.error("Unhandled error:", error);
-    return ctx.json(
-      {
-        error: "Internal Server Error",
-        message: error.message
-      },
-      500
-    );
-  }
-};
+}
 export {
-  AOTRouter,
-  FastContext as FastContextImpl,
-  Gravito,
-  MinimalContext,
+  extractPath,
   ObjectPool,
-  extractPath
+  MinimalContext,
+  Gravito,
+  FastContext as FastContextImpl,
+  AOTRouter
 };
+
+//# debugId=1A9EA2323316056B64756E2164756E21