@gravito/core 1.6.0 → 2.0.0

package/dist/engine/index.js

@@ -1,26 +1,52 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  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: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+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/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 +64,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 +146,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 +157,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 +188,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 +223,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 +232,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,42 +243,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;
-  version = 0;
-  /**
-   * 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
-   */
+  pathMiddleware = new Map;
+  dynamicRoutePatterns = new Map;
+  middlewareCache = new Map;
+  cacheMaxSize = 1000;
+  _version = 0;
+  get version() {
+    return this._version;
+  }
   add(method, path, handler, middleware = []) {
     this.routeDefinitions.push({ method, path, handler, middleware });
     const normalizedMethod = method.toLowerCase();
@@ -254,9 +274,6 @@ var AOTRouter = class {
       }
     }
   }
-  /**
-   * Mount another router at a prefix
-   */
   mount(prefix, other) {
     if (other.globalMiddleware.length > 0) {
       this.usePattern(prefix, ...other.globalMiddleware);
@@ -264,7 +281,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;
@@ -289,25 +307,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
-   */
+    this._version++;
+  }
   usePattern(pattern, ...middleware) {
     if (pattern === "*") {
       this.globalMiddleware.push(...middleware);
@@ -315,17 +318,8 @@ var AOTRouter = class {
       const existing = this.pathMiddleware.get(pattern) ?? [];
       this.pathMiddleware.set(pattern, [...existing, ...middleware]);
     }
-    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
-   */
+    this._version++;
+  }
   match(method, path) {
     const normalizedMethod = method.toLowerCase();
     const staticKey = `${normalizedMethod}:${path}`;
@@ -358,28 +352,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}:${routeMiddleware.length}`;
+    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 = [];
@@ -400,27 +382,27 @@ var AOTRouter = class {
       middleware.push(...routeMiddleware);
     }
     if (this.middlewareCache.size < this.cacheMaxSize) {
-      this.middlewareCache.set(cacheKey, { data: middleware, version: this.version });
+      this.middlewareCache.set(cacheKey, { data: middleware, version: this._version });
+    } else if (this.middlewareCache.has(cacheKey)) {
+      this.middlewareCache.set(cacheKey, { data: middleware, version: this._version });
     }
     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;
@@ -434,9 +416,6 @@ var AOTRouter = class {
     }
     return false;
   }
-  /**
-   * Get all registered routes (for debugging)
-   */
   getRoutes() {
     const routes = [];
     for (const key of this.staticRoutes.keys()) {
@@ -445,11 +424,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)"),
@@ -458,6 +533,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";
@@ -475,7 +556,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"}'),
@@ -488,8 +569,154 @@ var HEADERS = {
   HTML: { "Content-Type": "text/html; charset=utf-8" }
 };
 
+// src/Container/RequestScopeMetrics.ts
+class RequestScopeMetrics {
+  cleanupStartTime = null;
+  cleanupDuration = null;
+  scopeSize = 0;
+  servicesCleaned = 0;
+  errorsOccurred = 0;
+  recordCleanupStart() {
+    this.cleanupStartTime = performance.now();
+  }
+  recordCleanupEnd(scopeSize, servicesCleaned, errorsOccurred = 0) {
+    if (this.cleanupStartTime !== null) {
+      this.cleanupDuration = performance.now() - this.cleanupStartTime;
+      this.cleanupStartTime = null;
+    }
+    this.scopeSize = scopeSize;
+    this.servicesCleaned = servicesCleaned;
+    this.errorsOccurred = errorsOccurred;
+  }
+  getCleanupDuration() {
+    return this.cleanupDuration;
+  }
+  isSlowCleanup(thresholdMs = 2) {
+    if (this.cleanupDuration === null) {
+      return false;
+    }
+    return this.cleanupDuration > thresholdMs;
+  }
+  toJSON() {
+    return {
+      cleanupDuration: this.cleanupDuration,
+      scopeSize: this.scopeSize,
+      servicesCleaned: this.servicesCleaned,
+      errorsOccurred: this.errorsOccurred,
+      hasErrors: this.errorsOccurred > 0,
+      isSlowCleanup: this.isSlowCleanup()
+    };
+  }
+  toString() {
+    const duration = this.cleanupDuration ?? "pending";
+    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
+class RequestScopeManager {
+  scoped = new Map;
+  metadata = new Map;
+  metrics = new RequestScopeMetrics;
+  observer = null;
+  constructor(observer) {
+    this.observer = observer || null;
+  }
+  setObserver(observer) {
+    this.observer = observer;
+  }
+  getMetrics() {
+    return this.metrics;
+  }
+  resolve(key, factory) {
+    const keyStr = String(key);
+    const isFromCache = this.scoped.has(keyStr);
+    if (!isFromCache) {
+      const instance = factory();
+      this.scoped.set(keyStr, instance);
+      if (instance && typeof instance === "object" && "cleanup" in instance) {
+        this.metadata.set(keyStr, { hasCleanup: true });
+      }
+    }
+    this.observer?.onServiceResolved?.(key, isFromCache);
+    return this.scoped.get(keyStr);
+  }
+  async cleanup() {
+    this.metrics.recordCleanupStart();
+    this.observer?.onCleanupStart?.();
+    const errors = [];
+    let servicesCleaned = 0;
+    for (const [, instance] of this.scoped) {
+      if (instance && typeof instance === "object" && "cleanup" in instance) {
+        const fn = instance.cleanup;
+        if (typeof fn === "function") {
+          try {
+            await fn.call(instance);
+            servicesCleaned++;
+          } catch (error) {
+            errors.push(error);
+            this.observer?.onCleanupError?.(error instanceof Error ? error : new Error(String(error)));
+          }
+        }
+      }
+    }
+    const scopeSize = this.scoped.size;
+    this.scoped.clear();
+    this.metadata.clear();
+    this.metrics.recordCleanupEnd(scopeSize, servicesCleaned, errors.length);
+    this.observer?.onCleanupEnd?.(this.metrics);
+    if (errors.length > 0) {
+      console.error("RequestScope cleanup errors:", errors);
+    }
+  }
+  size() {
+    return this.scoped.size;
+  }
+}
+
 // src/engine/FastContext.ts
-var FastRequestImpl = class {
+var bunEscapeHTML = globalThis.Bun.escapeHTML;
+
+class FastRequestImpl {
   _request;
   _params;
   _path;
@@ -497,16 +724,18 @@ var FastRequestImpl = class {
   _url = null;
   _query = null;
   _headers = null;
-  _cachedJson = void 0;
+  _cachedJson = undefined;
   _jsonParsed = false;
-  // Back-reference for release check optimization
+  _cachedText = undefined;
+  _textParsed = false;
+  _cachedFormData = undefined;
+  _formDataParsed = false;
+  _cachedQueries = null;
+  _cachedCookies = null;
   _ctx;
   constructor(ctx) {
     this._ctx = ctx;
   }
-  /**
-   * Initialize for new request
-   */
   init(request, params = {}, path = "", routePattern) {
     this._request = request;
     this._params = params;
@@ -515,27 +744,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 = undefined;
+    this._textParsed = false;
+    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 = undefined;
+    this._textParsed = false;
+    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() {
@@ -573,17 +809,20 @@ 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();
+    if (this._cachedQueries !== null) {
+      return this._cachedQueries;
+    }
     if (!this._query) {
       this._query = this.getUrl().searchParams;
     }
     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);
@@ -591,11 +830,12 @@ var FastRequestImpl = class {
         result[key] = [existing, value];
       }
     }
+    this._cachedQueries = result;
     return result;
   }
   header(name) {
     this.checkReleased();
-    return this._request.headers.get(name) ?? void 0;
+    return this._request.headers.get(name) ?? undefined;
   }
   headers() {
     this.checkReleased();
@@ -607,6 +847,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) {
@@ -617,89 +890,75 @@ var FastRequestImpl = class {
   }
   async text() {
     this.checkReleased();
-    return this._request.text();
+    if (!this._textParsed) {
+      this._cachedText = await this._request.text();
+      this._textParsed = true;
+    }
+    return this._cachedText;
   }
   async formData() {
     this.checkReleased();
-    return this._request.formData();
+    if (!this._formDataParsed) {
+      this._cachedFormData = await this._request.formData();
+      this._formDataParsed = true;
+    }
+    return this._cachedFormData;
   }
   get raw() {
     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
-  /**
-   * Initialize context for a new request
-   *
-   * This is called when acquiring from the pool.
-   */
+  _requestScope = null;
   init(request, params = {}, path = "", routePattern) {
     this._isReleased = false;
     this.req.init(request, params, path, routePattern);
-    this._headers = new Headers();
+    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) {
@@ -709,12 +968,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") {
@@ -732,9 +998,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);
@@ -743,13 +1007,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;
     }
@@ -758,34 +1021,47 @@ 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);
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Lifecycle helpers
-  // ─────────────────────────────────────────────────────────────────────────
+  requestScope() {
+    if (!this._requestScope) {
+      throw new Error("RequestScope not initialized. Call init() first.");
+    }
+    return this._requestScope;
+  }
+  scoped(key, factory) {
+    return this.requestScope().resolve(key, factory);
+  }
   route = () => "";
   get native() {
     return this;
   }
-};
+}
 
 // src/engine/MinimalContext.ts
-var MinimalRequest = class {
+var bunEscapeHTML2 = globalThis.Bun.escapeHTML;
+
+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;
   get url() {
     return this._request.url;
   }
@@ -804,15 +1080,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);
@@ -822,14 +1095,17 @@ 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) {
+      return this._cachedQueries;
+    }
     const params = this.getSearchParams();
     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);
@@ -837,10 +1113,11 @@ var MinimalRequest = class {
         result[key] = [existing, value];
       }
     }
+    this._cachedQueries = result;
     return result;
   }
   header(name) {
-    return this._request.headers.get(name) ?? void 0;
+    return this._request.headers.get(name) ?? undefined;
   }
   headers() {
     const result = {};
@@ -850,33 +1127,65 @@ var MinimalRequest = class {
     return result;
   }
   async json() {
-    return this._request.json();
+    if (this._cachedJsonPromise === null) {
+      this._cachedJsonPromise = this._request.json();
+    }
+    return this._cachedJsonPromise;
   }
   async text() {
-    return this._request.text();
+    if (this._cachedTextPromise === null) {
+      this._cachedTextPromise = this._request.text();
+    }
+    return this._cachedTextPromise;
   }
   async formData() {
-    return this._request.formData();
+    if (this._cachedFormDataPromise === null) {
+      this._cachedFormDataPromise = this._request.formData();
+    }
+    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;
   }
-  // get req(): FastRequest {
-  //   return this._req
-  // }
-  // Response helpers - merge custom headers with defaults
   getHeaders(contentType) {
-    return {
-      ...this._resHeaders,
-      "Content-Type": contentType
-    };
+    const headers = Object.assign({ "Content-Type": contentType }, this._resHeaders);
+    return headers;
   }
   json(data, status = 200) {
     return new Response(JSON.stringify(data), {
@@ -909,14 +1218,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,
@@ -937,31 +1245,34 @@ 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
     });
   }
+  escape(html) {
+    return bunEscapeHTML2(html);
+  }
   get(_key) {
-    return void 0;
+    return;
   }
-  set(_key, _value) {
+  set(_key, _value) {}
+  requestScope() {
+    return this._requestScope;
+  }
+  scoped(key, factory) {
+    return this._requestScope.resolve(key, factory);
   }
   route = () => "";
   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) {
@@ -979,79 +1290,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) {
@@ -1060,55 +1330,88 @@ var ObjectPool = class {
       this.pool.push(obj);
     }
   }
-};
+}
 
 // src/engine/Gravito.ts
+var bunPeek = globalThis.Bun.peek;
 function compileMiddlewareChain(middleware, handler) {
   if (middleware.length === 0) {
     return handler;
   }
+  if (middleware.length === 1) {
+    const mw = middleware[0];
+    return async (ctx) => {
+      let nextCalled = false;
+      const result = mw(ctx, async () => {
+        nextCalled = true;
+        return;
+      });
+      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) {
+        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 nextResult;
-      const next = async () => {
-        nextResult = await nextHandler(ctx);
+      let nextCalled = false;
+      const result = mw(ctx, async () => {
+        nextCalled = true;
+        return;
+      });
+      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) {
+        const nextResult = nextHandler(ctx);
+        if (nextResult instanceof Promise) {
+          const p = bunPeek(nextResult);
+          return p === nextResult ? await nextResult : p;
+        }
         return nextResult;
-      };
-      const result = await mw(ctx, next);
-      return result ?? 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();
-  // Version tracking for cache invalidation
-  middlewareVersion = 0;
-  /**
-   * 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;
@@ -1118,58 +1421,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) {
@@ -1184,49 +1456,22 @@ var Gravito = class {
     } else {
       this.router.use(pathOrMiddleware, ...middleware);
     }
-    this.middlewareVersion++;
     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) {
@@ -1234,86 +1479,135 @@ 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 = globalThis.Bun.file(optimized.key);
+      }
+      if (typeof optimized.cert === "string" && !optimized.cert.startsWith("-----BEGIN")) {
+        optimized.cert = globalThis.Bun.file(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 {
-      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.middlewareVersion) {
-      const compiled = compileMiddlewareChain(match.middleware, match.handler);
-      if (this.compiledDynamicRoutes.size > 1e3) {
-        this.compiledDynamicRoutes.clear();
-      }
-      entry = { compiled, version: this.middlewareVersion };
-      this.compiledDynamicRoutes.set(cacheKey, entry);
-    }
-    const ctx = this.contextPool.acquire();
-    const execute = async () => {
+  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 {
-        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 {
+        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);
@@ -1329,9 +1623,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);
@@ -1346,25 +1637,19 @@ 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;
     const hasPathMiddleware = this.router.pathMiddleware.size > 0;
     this.isPureStaticApp = !hasGlobalMiddleware && !hasPathMiddleware;
     for (const [key, route] of this.staticRoutes) {
-      if (route.compiledVersion === this.middlewareVersion) {
+      if (route.compiledVersion === this.router.version) {
         continue;
       }
       const analysis = analyzeHandler(route.handler);
@@ -1374,12 +1659,9 @@ var Gravito = class {
         const allMiddleware = this.collectMiddlewareForPath(key.split(":")[1], route.middleware);
         route.compiled = compileMiddlewareChain(allMiddleware, route.handler);
       }
-      route.compiledVersion = this.middlewareVersion;
+      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}`);
@@ -1390,46 +1672,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=13A90DBD3E511D5864756E2164756E21