@gravito/core 1.2.0 → 1.6.0

package/dist/engine/index.cjs

@@ -239,13 +239,25 @@ var RadixRouter = class _RadixRouter {
 // 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 */
+  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
    *
@@ -259,6 +271,7 @@ var AOTRouter = class {
    * @param middleware - Route-specific middleware
    */
   add(method, path, handler, middleware = []) {
+    this.routeDefinitions.push({ method, path, handler, middleware });
     const normalizedMethod = method.toLowerCase();
     if (this.isStaticPath(path)) {
       const key = `${normalizedMethod}:${path}`;
@@ -266,11 +279,47 @@ var AOTRouter = class {
     } else {
       const wrappedHandler = handler;
       this.dynamicRouter.add(normalizedMethod, path, [wrappedHandler]);
+      this.dynamicRoutePatterns.set(wrappedHandler, path);
       if (middleware.length > 0) {
         this.pathMiddleware.set(`${normalizedMethod}:${path}`, middleware);
       }
     }
   }
+  /**
+   * Mount another router at a prefix
+   */
+  mount(prefix, other) {
+    if (other.globalMiddleware.length > 0) {
+      this.usePattern(prefix, ...other.globalMiddleware);
+      const wildcard = prefix === "/" ? "/*" : `${prefix}/*`;
+      this.usePattern(wildcard, ...other.globalMiddleware);
+    }
+    for (const [pattern, mws] of other.pathMiddleware) {
+      if (pattern.includes(":")) {
+        continue;
+      }
+      let newPattern;
+      if (pattern === "*") {
+        newPattern = prefix === "/" ? "/*" : `${prefix}/*`;
+      } else if (pattern.startsWith("/")) {
+        newPattern = prefix === "/" ? pattern : `${prefix}${pattern}`;
+      } else {
+        newPattern = prefix === "/" ? `/${pattern}` : `${prefix}/${pattern}`;
+      }
+      this.usePattern(newPattern, ...mws);
+    }
+    for (const def of other.routeDefinitions) {
+      let newPath;
+      if (prefix === "/") {
+        newPath = def.path;
+      } else if (def.path === "/") {
+        newPath = prefix;
+      } else {
+        newPath = `${prefix}${def.path}`;
+      }
+      this.add(def.method, newPath, def.handler, def.middleware);
+    }
+  }
   /**
    * Add global middleware
    *
@@ -280,6 +329,7 @@ var AOTRouter = class {
    */
   use(...middleware) {
     this.globalMiddleware.push(...middleware);
+    this.version++;
   }
   /**
    * Add path-based middleware
@@ -290,8 +340,13 @@ var AOTRouter = class {
    * @param middleware - Middleware functions
    */
   usePattern(pattern, ...middleware) {
-    const existing = this.pathMiddleware.get(pattern) ?? [];
-    this.pathMiddleware.set(pattern, [...existing, ...middleware]);
+    if (pattern === "*") {
+      this.globalMiddleware.push(...middleware);
+    } else {
+      const existing = this.pathMiddleware.get(pattern) ?? [];
+      this.pathMiddleware.set(pattern, [...existing, ...middleware]);
+    }
+    this.version++;
   }
   /**
    * Match a request to a route
@@ -310,18 +365,22 @@ var AOTRouter = class {
       return {
         handler: staticRoute.handler,
         params: {},
-        middleware: this.collectMiddleware(path, staticRoute.middleware)
+        middleware: this.collectMiddleware(path, staticRoute.middleware),
+        routePattern: path
       };
     }
     const match = this.dynamicRouter.match(normalizedMethod, path);
     if (match && match.handlers.length > 0) {
       const handler = match.handlers[0];
-      const routeKey = this.findDynamicRouteKey(normalizedMethod, path);
+      const wrappedHandler = match.handlers[0];
+      const routePattern = this.dynamicRoutePatterns.get(wrappedHandler);
+      const routeKey = routePattern ? `${normalizedMethod}:${routePattern}` : null;
       const routeMiddleware = routeKey ? this.pathMiddleware.get(routeKey) ?? [] : [];
       return {
         handler,
         params: match.params,
-        middleware: this.collectMiddleware(path, routeMiddleware)
+        middleware: this.collectMiddleware(path, routeMiddleware),
+        routePattern
       };
     }
     return {
@@ -349,13 +408,20 @@ var AOTRouter = class {
     if (this.globalMiddleware.length === 0 && this.pathMiddleware.size === 0 && routeMiddleware.length === 0) {
       return [];
     }
+    const cacheKey = `${path}:${routeMiddleware.length}`;
+    const cached = this.middlewareCache.get(cacheKey);
+    if (cached !== void 0 && cached.version === this.version) {
+      return cached.data;
+    }
     const middleware = [];
     if (this.globalMiddleware.length > 0) {
       middleware.push(...this.globalMiddleware);
     }
     if (this.pathMiddleware.size > 0) {
       for (const [pattern, mw] of this.pathMiddleware) {
-        if (pattern.includes(":")) continue;
+        if (pattern.includes(":")) {
+          continue;
+        }
         if (this.matchPattern(pattern, path)) {
           middleware.push(...mw);
         }
@@ -364,6 +430,9 @@ var AOTRouter = class {
     if (routeMiddleware.length > 0) {
       middleware.push(...routeMiddleware);
     }
+    if (this.middlewareCache.size < this.cacheMaxSize) {
+      this.middlewareCache.set(cacheKey, { data: middleware, version: this.version });
+    }
     return middleware;
   }
   /**
@@ -384,32 +453,18 @@ var AOTRouter = class {
    * @returns True if pattern matches
    */
   matchPattern(pattern, path) {
-    if (pattern === "*") return true;
-    if (pattern === path) return true;
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern === path) {
+      return true;
+    }
     if (pattern.endsWith("/*")) {
       const prefix = pattern.slice(0, -2);
       return path.startsWith(prefix);
     }
     return false;
   }
-  /**
-   * Find the original route key for a matched dynamic route
-   *
-   * This is needed to look up route-specific middleware.
-   * It's a bit of a hack, but avoids storing duplicate data.
-   *
-   * @param method - HTTP method
-   * @param path - Matched path
-   * @returns Route key or null
-   */
-  findDynamicRouteKey(method, _path) {
-    for (const key of this.pathMiddleware.keys()) {
-      if (key.startsWith(`${method}:`)) {
-        return key;
-      }
-    }
-    return null;
-  }
   /**
    * Get all registered routes (for debugging)
    */
@@ -450,48 +505,111 @@ function getOptimalContextType(analysis) {
   return "fast";
 }
 
+// src/engine/constants.ts
+var encoder = new TextEncoder();
+var CACHED_RESPONSES = {
+  NOT_FOUND: encoder.encode('{"error":"Not Found"}'),
+  INTERNAL_ERROR: encoder.encode('{"error":"Internal Server Error"}'),
+  OK: encoder.encode('{"ok":true}'),
+  EMPTY: new Uint8Array(0)
+};
+var HEADERS = {
+  JSON: { "Content-Type": "application/json; charset=utf-8" },
+  TEXT: { "Content-Type": "text/plain; charset=utf-8" },
+  HTML: { "Content-Type": "text/html; charset=utf-8" }
+};
+
 // src/engine/FastContext.ts
 var FastRequestImpl = class {
   _request;
   _params;
-  _url = new URL("http://localhost");
-  // Reuse this object
+  _path;
+  _routePattern;
+  _url = null;
   _query = null;
   _headers = null;
+  _cachedJson = void 0;
+  _jsonParsed = false;
+  // Back-reference for release check optimization
+  _ctx;
+  constructor(ctx) {
+    this._ctx = ctx;
+  }
   /**
-   * Reset for pooling
+   * Initialize for new request
    */
-  reset(request, params = {}) {
+  init(request, params = {}, path = "", routePattern) {
     this._request = request;
     this._params = params;
-    this._url.href = request.url;
+    this._path = path;
+    this._routePattern = routePattern;
+    this._url = null;
     this._query = null;
     this._headers = null;
+    this._cachedJson = void 0;
+    this._jsonParsed = false;
+    return this;
+  }
+  /**
+   * Reset for pooling
+   */
+  reset() {
+    this._request = void 0;
+    this._params = void 0;
+    this._url = null;
+    this._query = null;
+    this._headers = null;
+    this._cachedJson = void 0;
+    this._jsonParsed = false;
+  }
+  checkReleased() {
+    if (this._ctx._isReleased) {
+      throw new Error(
+        "FastContext usage after release detected! (Object Pool Strict Lifecycle Guard)"
+      );
+    }
   }
   get url() {
+    this.checkReleased();
     return this._request.url;
   }
   get method() {
+    this.checkReleased();
     return this._request.method;
   }
   get path() {
-    return this._url.pathname;
+    this.checkReleased();
+    return this._path;
+  }
+  get routePattern() {
+    this.checkReleased();
+    return this._routePattern;
   }
   param(name) {
+    this.checkReleased();
     return this._params[name];
   }
   params() {
+    this.checkReleased();
     return { ...this._params };
   }
+  getUrl() {
+    if (!this._url) {
+      this._url = new URL(this._request.url);
+    }
+    return this._url;
+  }
   query(name) {
+    this.checkReleased();
     if (!this._query) {
-      this._query = this._url.searchParams;
+      this._query = this.getUrl().searchParams;
     }
     return this._query.get(name) ?? void 0;
   }
   queries() {
+    this.checkReleased();
     if (!this._query) {
-      this._query = this._url.searchParams;
+      this._query = this.getUrl().searchParams;
     }
     const result = {};
     for (const [key, value] of this._query.entries()) {
@@ -507,9 +625,11 @@ var FastRequestImpl = class {
     return result;
   }
   header(name) {
+    this.checkReleased();
     return this._request.headers.get(name) ?? void 0;
   }
   headers() {
+    this.checkReleased();
     if (!this._headers) {
       this._headers = {};
       for (const [key, value] of this._request.headers.entries()) {
@@ -519,41 +639,70 @@ var FastRequestImpl = class {
     return { ...this._headers };
   }
   async json() {
-    return this._request.json();
+    this.checkReleased();
+    if (!this._jsonParsed) {
+      this._cachedJson = await this._request.json();
+      this._jsonParsed = true;
+    }
+    return this._cachedJson;
   }
   async text() {
+    this.checkReleased();
     return this._request.text();
   }
   async formData() {
+    this.checkReleased();
     return this._request.formData();
   }
   get raw() {
+    this.checkReleased();
     return this._request;
   }
 };
 var FastContext = class {
-  _req = new FastRequestImpl();
+  req = new FastRequestImpl(this);
   // private _statusCode = 200
   _headers = new Headers();
   // Reuse this object
+  _isReleased = false;
+  // Made public for internal check access
   /**
-   * Reset context for pooling
+   * Initialize context for a new request
    *
    * This is called when acquiring from the pool.
-   * Must clear all state from previous request.
    */
-  reset(request, params = {}) {
-    this._req.reset(request, params);
+  init(request, params = {}, path = "", routePattern) {
+    this._isReleased = false;
+    this.req.init(request, params, path, routePattern);
     this._headers = new Headers();
     return this;
   }
-  get req() {
-    return this._req;
+  /**
+   * 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();
+  }
+  /**
+   * Check if context is released
+   */
+  checkReleased() {
+    if (this._isReleased) {
+      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,
@@ -561,6 +710,7 @@ var FastContext = class {
     });
   }
   text(text, status = 200) {
+    this.checkReleased();
     this._headers.set("Content-Type", "text/plain; charset=utf-8");
     return new Response(text, {
       status,
@@ -568,6 +718,7 @@ var FastContext = class {
     });
   }
   html(html, status = 200) {
+    this.checkReleased();
     this._headers.set("Content-Type", "text/html; charset=utf-8");
     return new Response(html, {
       status,
@@ -575,6 +726,7 @@ var FastContext = class {
     });
   }
   redirect(url, status = 302) {
+    this.checkReleased();
     this._headers.set("Location", url);
     return new Response(null, {
       status,
@@ -582,28 +734,89 @@ var FastContext = class {
     });
   }
   body(data, status = 200) {
+    this.checkReleased();
     return new Response(data, {
       status,
       headers: this._headers
     });
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Header Management
-  // ─────────────────────────────────────────────────────────────────────────
+  stream(stream, status = 200) {
+    this.checkReleased();
+    this._headers.set("Content-Type", "application/octet-stream");
+    return new Response(stream, {
+      status,
+      headers: this._headers
+    });
+  }
+  notFound(message = "Not Found") {
+    return this.text(message, 404);
+  }
+  forbidden(message = "Forbidden") {
+    return this.text(message, 403);
+  }
+  unauthorized(message = "Unauthorized") {
+    return this.text(message, 401);
+  }
+  badRequest(message = "Bad Request") {
+    return this.text(message, 400);
+  }
+  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 searchParams = new URLSearchParams(url.search);
+    searchParams.forEach((v, k) => {
+      targetUrl.searchParams.set(k, v);
+    });
+    return fetch(targetUrl.toString(), {
+      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._headers.set(name, value);
+    this.checkReleased();
+    if (value !== void 0) {
+      this._headers.set(name, value);
+      return;
+    }
+    return this.req.header(name);
   }
   status(_code) {
+    this.checkReleased();
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Context Variables
+  // ─────────────────────────────────────────────────────────────────────────
+  _store = /* @__PURE__ */ new Map();
+  get(key) {
+    return this._store.get(key);
+  }
+  set(key, value) {
+    this._store.set(key, value);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // Lifecycle helpers
+  // ─────────────────────────────────────────────────────────────────────────
+  route = () => "";
+  get native() {
+    return this;
   }
 };
 
 // src/engine/MinimalContext.ts
 var MinimalRequest = class {
-  constructor(_request, _params, _path) {
+  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;
   }
@@ -613,20 +826,39 @@ var MinimalRequest = class {
   get path() {
     return this._path;
   }
+  get routePattern() {
+    return this._routePattern;
+  }
   param(name) {
     return this._params[name];
   }
   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();
+      } else {
+        const hashStart = url.indexOf("#", queryStart);
+        const queryString = hashStart === -1 ? url.slice(queryStart + 1) : url.slice(queryStart + 1, hashStart);
+        this._searchParams = new URLSearchParams(queryString);
+      }
+    }
+    return this._searchParams;
+  }
   query(name) {
-    const url = new URL(this._request.url);
-    return url.searchParams.get(name) ?? void 0;
+    return this.getSearchParams().get(name) ?? void 0;
   }
   queries() {
-    const url = new URL(this._request.url);
+    const params = this.getSearchParams();
     const result = {};
-    for (const [key, value] of url.searchParams.entries()) {
+    for (const [key, value] of params.entries()) {
       const existing = result[key];
       if (existing === void 0) {
         result[key] = value;
@@ -662,49 +894,103 @@ var MinimalRequest = class {
   }
 };
 var MinimalContext = class {
-  _req;
-  constructor(request, params, path) {
-    this._req = new MinimalRequest(request, params, path);
+  req;
+  _resHeaders = {};
+  constructor(request, params, path, routePattern) {
+    this.req = new MinimalRequest(request, params, path, routePattern);
   }
-  get req() {
-    return this._req;
+  // get req(): FastRequest {
+  //   return this._req
+  // }
+  // Response helpers - merge custom headers with defaults
+  getHeaders(contentType) {
+    return {
+      ...this._resHeaders,
+      "Content-Type": contentType
+    };
   }
-  // Response helpers - create headers inline (no reuse overhead)
   json(data, status = 200) {
     return new Response(JSON.stringify(data), {
       status,
-      headers: { "Content-Type": "application/json; charset=utf-8" }
+      headers: this.getHeaders("application/json; charset=utf-8")
     });
   }
   text(text, status = 200) {
     return new Response(text, {
       status,
-      headers: { "Content-Type": "text/plain; charset=utf-8" }
+      headers: this.getHeaders("text/plain; charset=utf-8")
     });
   }
   html(html, status = 200) {
     return new Response(html, {
       status,
-      headers: { "Content-Type": "text/html; charset=utf-8" }
+      headers: this.getHeaders("text/html; charset=utf-8")
     });
   }
   redirect(url, status = 302) {
     return new Response(null, {
       status,
-      headers: { Location: url }
+      headers: { ...this._resHeaders, Location: url }
     });
   }
   body(data, status = 200) {
-    return new Response(data, { status });
+    return new Response(data, {
+      status,
+      headers: this._resHeaders
+    });
   }
-  header(_name, _value) {
-    console.warn("MinimalContext.header() is a no-op. Use FastContext for custom headers.");
+  header(name, value) {
+    if (value !== void 0) {
+      this._resHeaders[name] = value;
+      return;
+    }
+    return this.req.header(name);
   }
   status(_code) {
   }
+  stream(stream, status = 200) {
+    return new Response(stream, {
+      status,
+      headers: this.getHeaders("application/octet-stream")
+    });
+  }
+  notFound(message = "Not Found") {
+    return this.text(message, 404);
+  }
+  forbidden(message = "Forbidden") {
+    return this.text(message, 403);
+  }
+  unauthorized(message = "Unauthorized") {
+    return this.text(message, 401);
+  }
+  badRequest(message = "Bad Request") {
+    return this.text(message, 400);
+  }
+  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}`
+    );
+    return fetch(targetUrl.toString(), {
+      method: this.req.method,
+      headers: this.req.raw.headers
+    });
+  }
+  get(_key) {
+    return void 0;
+  }
+  set(_key, _value) {
+  }
+  route = () => "";
+  get native() {
+    return this;
+  }
   // Required for interface compatibility
-  reset(_request, _params) {
-    throw new Error("MinimalContext does not support reset. Create a new instance instead.");
+  init(_request, _params, _path) {
+    throw new Error("MinimalContext does not support init. Create a new instance instead.");
+  }
+  // Required for interface compatibility
+  reset() {
   }
 };
 
@@ -808,16 +1094,40 @@ var ObjectPool = class {
 };
 
 // src/engine/Gravito.ts
+function compileMiddlewareChain(middleware, handler) {
+  if (middleware.length === 0) {
+    return handler;
+  }
+  let compiled = handler;
+  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);
+        return nextResult;
+      };
+      const result = await mw(ctx, next);
+      return result ?? nextResult;
+    };
+  }
+  return compiled;
+}
 var Gravito = class {
   router = new AOTRouter();
   contextPool;
   errorHandler;
   notFoundHandler;
   // Direct reference to static routes Map (O(1) access)
-  // Optimization: Bypass getter/setter overhead
+  /** @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
    *
@@ -827,7 +1137,7 @@ var Gravito = class {
     const poolSize = options.poolSize ?? 256;
     this.contextPool = new ObjectPool(
       () => new FastContext(),
-      (ctx) => ctx.reset(new Request("http://localhost")),
+      (ctx) => ctx.reset(),
       poolSize
     );
     this.contextPool.prewarm(Math.min(32, poolSize));
@@ -871,7 +1181,7 @@ var Gravito = class {
     return this.addRoute("delete", path, handlers);
   }
   /**
-   * Register a PATCH route
+   * Register a PDF route
    */
   patch(path, ...handlers) {
     return this.addRoute("patch", path, handlers);
@@ -905,6 +1215,8 @@ var Gravito = class {
     } else {
       this.router.use(pathOrMiddleware, ...middleware);
     }
+    this.middlewareVersion++;
+    this.compileRoutes();
     return this;
   }
   // ─────────────────────────────────────────────────────────────────────────
@@ -912,19 +1224,10 @@ var Gravito = class {
   // ─────────────────────────────────────────────────────────────────────────
   /**
    * Mount a sub-application at a path prefix
-   *
-   * @example
-   * ```typescript
-   * const api = new Gravito()
-   * api.get('/users', (c) => c.json({ users: [] }))
-   *
-   * const app = new Gravito()
-   * app.route('/api', api)
-   * // Now accessible at /api/users
-   * ```
    */
-  route(_path, _app) {
-    console.warn("route() method is not yet fully implemented");
+  route(path, app) {
+    this.router.mount(path, app.router);
+    this.compileRoutes();
     return this;
   }
   // ─────────────────────────────────────────────────────────────────────────
@@ -932,14 +1235,6 @@ var Gravito = class {
   // ─────────────────────────────────────────────────────────────────────────
   /**
    * Set custom error handler
-   *
-   * @example
-   * ```typescript
-   * app.onError((err, c) => {
-   *   console.error(err)
-   *   return c.json({ error: err.message }, 500)
-   * })
-   * ```
    */
   onError(handler) {
     this.errorHandler = handler;
@@ -947,13 +1242,6 @@ var Gravito = class {
   }
   /**
    * Set custom 404 handler
-   *
-   * @example
-   * ```typescript
-   * app.notFound((c) => {
-   *   return c.json({ error: 'Not Found' }, 404)
-   * })
-   * ```
    */
   notFound(handler) {
     this.notFoundHandler = handler;
@@ -963,35 +1251,44 @@ var Gravito = class {
   // Request Handling (Bun.serve integration)
   // ─────────────────────────────────────────────────────────────────────────
   /**
-   * Handle an incoming request
+   * Predictive Route Warming (JIT Optimization)
    *
-   * Optimized for minimal allocations and maximum throughput.
-   * Uses sync/async dual-path strategy inspired by Hono.
+   * Simulates requests to specified routes to trigger JIT compilation (FTL)
+   * before real traffic arrives.
    *
-   * @param request - Incoming Request object
-   * @returns Response object (sync or async)
+   * @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) {
+      const req = new Request(`http://localhost${path}`, dummyReqOpts);
+      await this.fetch(req);
+    }
+  }
+  /**
+   * Handle an incoming request
    */
-  fetch = (request) => {
+  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);
+        const ctx = new MinimalContext(request, {}, path, path);
         try {
           const result = staticRoute.handler(ctx);
           if (result instanceof Response) {
             return result;
           }
-          return result;
+          return await result;
         } catch (error) {
           return this.handleErrorSync(error, request, path);
         }
       }
-      return this.handleWithMiddleware(request, path, staticRoute);
+      return await this.handleWithMiddleware(request, path, staticRoute);
     }
-    return this.handleDynamicRoute(request, method, path);
+    return await this.handleDynamicRoute(request, method, path);
   };
   /**
    * Handle routes with middleware (async path)
@@ -999,7 +1296,10 @@ var Gravito = class {
   async handleWithMiddleware(request, path, route) {
     const ctx = this.contextPool.acquire();
     try {
-      ctx.reset(request, {});
+      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);
@@ -1019,14 +1319,21 @@ var Gravito = class {
     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 () => {
       try {
-        ctx.reset(request, match.params);
-        if (match.middleware.length === 0) {
-          return await match.handler(ctx);
-        }
-        return await this.executeMiddleware(ctx, match.middleware, match.handler);
+        ctx.init(request, match.params, path, match.routePattern);
+        return await entry?.compiled(ctx);
       } catch (error) {
         return await this.handleError(error, ctx);
       } finally {
@@ -1048,16 +1355,10 @@ var Gravito = class {
       return result;
     }
     console.error("Unhandled error:", error);
-    return new Response(
-      JSON.stringify({
-        error: "Internal Server Error",
-        message: error.message
-      }),
-      {
-        status: 500,
-        headers: { "Content-Type": "application/json" }
-      }
-    );
+    return new Response(CACHED_RESPONSES.INTERNAL_ERROR, {
+      status: 500,
+      headers: HEADERS.JSON
+    });
   }
   /**
    * Sync 404 handler (for ultra-fast path)
@@ -1071,14 +1372,13 @@ var Gravito = class {
       }
       return result;
     }
-    return new Response(JSON.stringify({ error: "Not Found" }), {
+    return new Response(CACHED_RESPONSES.NOT_FOUND, {
       status: 404,
-      headers: { "Content-Type": "application/json" }
+      headers: HEADERS.JSON
     });
   }
   /**
    * Collect middleware for a specific path
-   * (Simplified version - assumes we've already checked for pure static)
    */
   collectMiddlewareForPath(path, routeMiddleware) {
     if (this.router.globalMiddleware.length === 0 && this.router.pathMiddleware.size === 0) {
@@ -1088,22 +1388,26 @@ var Gravito = class {
   }
   /**
    * Compile routes for optimization
-   * Called once during initialization and when routes change
    */
   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) {
+    for (const [key, route] of this.staticRoutes) {
+      if (route.compiledVersion === this.middlewareVersion) {
+        continue;
+      }
       const analysis = analyzeHandler(route.handler);
       const optimalType = getOptimalContextType(analysis);
       route.useMinimal = this.isPureStaticApp && route.middleware.length === 0 && optimalType === "minimal";
+      if (!route.useMinimal) {
+        const allMiddleware = this.collectMiddlewareForPath(key.split(":")[1], route.middleware);
+        route.compiled = compileMiddlewareChain(allMiddleware, route.handler);
+      }
+      route.compiledVersion = this.middlewareVersion;
     }
   }
-  // ─────────────────────────────────────────────────────────────────────────
-  // Internal Methods
-  // ─────────────────────────────────────────────────────────────────────────
   /**
    * Add a route to the router
    */
@@ -1119,9 +1423,6 @@ var Gravito = class {
   }
   /**
    * Execute middleware chain followed by handler
-   *
-   * Implements the standard middleware pattern:
-   * Each middleware can call next() to continue the chain.
    */
   async executeMiddleware(ctx, middleware, handler) {
     let index = 0;
@@ -1138,16 +1439,6 @@ var Gravito = class {
     }
     return await handler(ctx);
   }
-  /*
-   * Handle 404 Not Found (Async version for dynamic/middleware paths)
-   * Note: Currently unused as we handle 404s via handleNotFoundSync or inline
-   */
-  // private async handleNotFound(ctx: FastContext): Promise<Response> {
-  //   if (this.notFoundHandler) {
-  //     return await this.notFoundHandler(ctx)
-  //   }
-  //   return ctx.json({ error: 'Not Found' }, 404)
-  // }
   /**
    * Handle errors (Async version for dynamic/middleware paths)
    */