@gravito/core 1.2.1 → 1.6.1

package/dist/engine/index.cjs

@@ -0,0 +1,1764 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/engine/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AOTRouter: () => AOTRouter,
+  FastContextImpl: () => FastContext,
+  Gravito: () => Gravito,
+  MinimalContext: () => MinimalContext,
+  ObjectPool: () => ObjectPool,
+  extractPath: () => extractPath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/adapters/bun/RadixNode.ts
+var RadixNode = class _RadixNode {
+  // Path segment for this node (e.g., "users", ":id")
+  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)
+  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")
+  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;
+    this.type = type;
+  }
+  toJSON() {
+    return {
+      segment: this.segment,
+      type: this.type,
+      children: Array.from(this.children.entries()).map(([k, v]) => [k, v.toJSON()]),
+      paramChild: this.paramChild?.toJSON() || null,
+      wildcardChild: this.wildcardChild?.toJSON() || null,
+      paramName: this.paramName,
+      regex: this.regex ? this.regex.source : null
+    };
+  }
+  static fromJSON(json) {
+    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));
+      }
+    }
+    if (json.paramChild) {
+      node.paramChild = _RadixNode.fromJSON(json.paramChild);
+    }
+    if (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
+   */
+  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++) {
+      const segment = segments[i];
+      if (segment === "*") {
+        if (!node.wildcardChild) {
+          node.wildcardChild = new RadixNode("*", 2 /* WILDCARD */);
+        }
+        node = node.wildcardChild;
+        break;
+      } else if (segment.startsWith(":")) {
+        const paramName = segment.slice(1);
+        if (!node.paramChild) {
+          const child = new RadixNode(segment, 1 /* PARAM */);
+          child.paramName = paramName;
+          const constraint = this.globalConstraints.get(paramName);
+          if (constraint) {
+            child.regex = constraint;
+          }
+          node.paramChild = child;
+        }
+        node = node.paramChild;
+      } else {
+        if (!node.children.has(segment)) {
+          node.children.set(segment, new RadixNode(segment, 0 /* STATIC */));
+        }
+        node = node.children.get(segment);
+      }
+    }
+    node.handlers.set(method.toLowerCase(), handlers);
+  }
+  /**
+   * Match a request
+   */
+  match(method, path) {
+    const normalizedMethod = method.toLowerCase();
+    if (path === "/" || path === "") {
+      const handlers = this.root.handlers.get(normalizedMethod);
+      if (handlers) {
+        return { handlers, params: {} };
+      }
+      return null;
+    }
+    const searchPath = path.startsWith("/") ? path.slice(1) : path;
+    const segments = searchPath.split("/");
+    return this.matchRecursive(this.root, segments, 0, {}, normalizedMethod);
+  }
+  matchRecursive(node, segments, depth, params, method) {
+    if (depth >= segments.length) {
+      let handlers = node.handlers.get(method);
+      if (!handlers) {
+        handlers = node.handlers.get("all");
+      }
+      if (handlers) {
+        return { handlers, params };
+      }
+      return null;
+    }
+    const segment = segments[depth];
+    const staticChild = node.children.get(segment);
+    if (staticChild) {
+      const match = this.matchRecursive(staticChild, segments, depth + 1, params, method);
+      if (match) {
+        return match;
+      }
+    }
+    const paramChild = node.paramChild;
+    if (paramChild) {
+      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);
+          if (match) {
+            return match;
+          }
+          delete params[paramChild.paramName];
+        }
+      }
+    }
+    if (node.wildcardChild) {
+      let handlers = node.wildcardChild.handlers.get(method);
+      if (!handlers) {
+        handlers = node.wildcardChild.handlers.get("all");
+      }
+      if (handlers) {
+        return { handlers, params };
+      }
+    }
+    return null;
+  }
+  splitPath(path) {
+    if (path === "/" || path === "") {
+      return [];
+    }
+    let p = path;
+    if (p.startsWith("/")) {
+      p = p.slice(1);
+    }
+    if (p.endsWith("/")) {
+      p = p.slice(0, -1);
+    }
+    return p.split("/");
+  }
+  /**
+   * Serialize the router to a JSON string
+   */
+  serialize() {
+    return JSON.stringify({
+      root: this.root.toJSON(),
+      globalConstraints: Array.from(this.globalConstraints.entries()).map(([k, v]) => [
+        k,
+        v.source
+      ])
+    });
+  }
+  /**
+   * Restore a router from a serialized JSON string
+   */
+  static fromSerialized(json) {
+    const data = JSON.parse(json);
+    const router = new _RadixRouter();
+    router.root = RadixNode.fromJSON(data.root);
+    if (data.globalConstraints) {
+      for (const [key, source] of data.globalConstraints) {
+        router.globalConstraints.set(key, new RegExp(source));
+      }
+    }
+    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 */
+  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;
+  /**
+   * 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();
+    if (this.isStaticPath(path)) {
+      const key = `${normalizedMethod}:${path}`;
+      this.staticRoutes.set(key, { handler, middleware });
+    } 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
+   *
+   * 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);
+    } else {
+      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
+   */
+  match(method, path) {
+    const normalizedMethod = method.toLowerCase();
+    const staticKey = `${normalizedMethod}:${path}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      return {
+        handler: staticRoute.handler,
+        params: {},
+        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 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),
+        routePattern
+      };
+    }
+    return {
+      handler: null,
+      params: {},
+      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) {
+      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 (this.matchPattern(pattern, path)) {
+          middleware.push(...mw);
+        }
+      }
+    }
+    if (routeMiddleware.length > 0) {
+      middleware.push(...routeMiddleware);
+    }
+    if (this.middlewareCache.size < this.cacheMaxSize) {
+      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)
+   */
+  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;
+    }
+    if (pattern === path) {
+      return true;
+    }
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      return path.startsWith(prefix);
+    }
+    return false;
+  }
+  /**
+   * Get all registered routes (for debugging)
+   */
+  getRoutes() {
+    const routes = [];
+    for (const key of this.staticRoutes.keys()) {
+      const [method, path] = key.split(":");
+      routes.push({ method, path, type: "static" });
+    }
+    return routes;
+  }
+};
+
+// src/engine/analyzer.ts
+function analyzeHandler(handler) {
+  const source = handler.toString();
+  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)"),
+    usesBody: source.includes(".json()") || source.includes(".text()") || source.includes(".formData()") || source.includes(".body"),
+    usesParams: source.includes(".param(") || source.includes(".param)") || source.includes(".params(") || source.includes(".params)"),
+    isAsync: source.includes("async") || source.includes("await")
+  };
+}
+function getOptimalContextType(analysis) {
+  if (analysis.usesHeaders) {
+    return "fast";
+  }
+  if (!analysis.usesQuery && !analysis.usesBody && !analysis.usesParams) {
+    return "minimal";
+  }
+  if (!analysis.usesQuery && !analysis.usesBody && analysis.usesParams) {
+    return "minimal";
+  }
+  if (analysis.usesBody) {
+    return "full";
+  }
+  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/Container/RequestScopeMetrics.ts
+var RequestScopeMetrics = class {
+  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;
+      this.cleanupStartTime = null;
+    }
+    this.scopeSize = scopeSize;
+    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;
+    return this.cleanupDuration > thresholdMs;
+  }
+  /**
+   * Export metrics as JSON for logging/monitoring
+   */
+  toJSON() {
+    return {
+      cleanupDuration: this.cleanupDuration,
+      scopeSize: this.scopeSize,
+      servicesCleaned: this.servicesCleaned,
+      errorsOccurred: this.errorsOccurred,
+      hasErrors: this.errorsOccurred > 0,
+      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}`;
+  }
+};
+
+// src/Container/RequestScopeManager.ts
+var RequestScopeManager = class {
+  scoped = /* @__PURE__ */ new Map();
+  metadata = /* @__PURE__ */ 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);
+    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);
+  }
+  /**
+   * 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?.();
+    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);
+    }
+  }
+  /**
+   * 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 {
+  _request;
+  _params;
+  _path;
+  _routePattern;
+  _url = null;
+  _query = null;
+  _headers = null;
+  _cachedJson = void 0;
+  _jsonParsed = false;
+  _cachedText = void 0;
+  _textParsed = false;
+  _cachedFormData = void 0;
+  _formDataParsed = false;
+  _cachedQueries = null;
+  // Back-reference for release check optimization
+  _ctx;
+  constructor(ctx) {
+    this._ctx = ctx;
+  }
+  /**
+   * Initialize for new request
+   */
+  init(request, params = {}, path = "", routePattern) {
+    this._request = request;
+    this._params = params;
+    this._path = path;
+    this._routePattern = routePattern;
+    this._url = null;
+    this._query = null;
+    this._headers = null;
+    this._cachedJson = void 0;
+    this._jsonParsed = false;
+    this._cachedText = void 0;
+    this._textParsed = false;
+    this._cachedFormData = void 0;
+    this._formDataParsed = false;
+    this._cachedQueries = null;
+    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;
+    this._cachedText = void 0;
+    this._textParsed = false;
+    this._cachedFormData = void 0;
+    this._formDataParsed = false;
+    this._cachedQueries = null;
+  }
+  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() {
+    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.getUrl().searchParams;
+    }
+    return this._query.get(name) ?? void 0;
+  }
+  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) {
+        result[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    }
+    this._cachedQueries = result;
+    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()) {
+        this._headers[key] = value;
+      }
+    }
+    return { ...this._headers };
+  }
+  async json() {
+    this.checkReleased();
+    if (!this._jsonParsed) {
+      this._cachedJson = await this._request.json();
+      this._jsonParsed = true;
+    }
+    return this._cachedJson;
+  }
+  async text() {
+    this.checkReleased();
+    if (!this._textParsed) {
+      this._cachedText = await this._request.text();
+      this._textParsed = true;
+    }
+    return this._cachedText;
+  }
+  async formData() {
+    this.checkReleased();
+    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 {
+  req = new FastRequestImpl(this);
+  // private _statusCode = 200
+  _headers = new Headers();
+  // Reuse this object
+  _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();
+    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();
+  }
+  /**
+   * 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,
+      headers: this._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
+    });
+  }
+  html(html, status = 200) {
+    this.checkReleased();
+    this._headers.set("Content-Type", "text/html; charset=utf-8");
+    return new Response(html, {
+      status,
+      headers: this._headers
+    });
+  }
+  redirect(url, status = 302) {
+    this.checkReleased();
+    this._headers.set("Location", url);
+    return new Response(null, {
+      status,
+      headers: this._headers
+    });
+  }
+  body(data, status = 200) {
+    this.checkReleased();
+    return new Response(data, {
+      status,
+      headers: this._headers
+    });
+  }
+  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.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);
+  }
+  // ─────────────────────────────────────────────────────────────────────────
+  // 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 {
+  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;
+  }
+  get method() {
+    return this._request.method;
+  }
+  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) {
+    return this.getSearchParams().get(name) ?? void 0;
+  }
+  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) {
+        result[key] = value;
+      } else if (Array.isArray(existing)) {
+        existing.push(value);
+      } else {
+        result[key] = [existing, value];
+      }
+    }
+    this._cachedQueries = result;
+    return result;
+  }
+  header(name) {
+    return this._request.headers.get(name) ?? void 0;
+  }
+  headers() {
+    const result = {};
+    for (const [key, value] of this._request.headers.entries()) {
+      result[key] = value;
+    }
+    return result;
+  }
+  async json() {
+    if (this._cachedJsonPromise === null) {
+      this._cachedJsonPromise = this._request.json();
+    }
+    return this._cachedJsonPromise;
+  }
+  async text() {
+    if (this._cachedTextPromise === null) {
+      this._cachedTextPromise = this._request.text();
+    }
+    return this._cachedTextPromise;
+  }
+  async formData() {
+    if (this._cachedFormDataPromise === null) {
+      this._cachedFormDataPromise = this._request.formData();
+    }
+    return this._cachedFormDataPromise;
+  }
+  get raw() {
+    return this._request;
+  }
+};
+var MinimalContext = class {
+  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
+  // 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;
+  }
+  json(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: this.getHeaders("application/json; charset=utf-8")
+    });
+  }
+  text(text, status = 200) {
+    return new Response(text, {
+      status,
+      headers: this.getHeaders("text/plain; charset=utf-8")
+    });
+  }
+  html(html, status = 200) {
+    return new Response(html, {
+      status,
+      headers: this.getHeaders("text/html; charset=utf-8")
+    });
+  }
+  redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: { ...this._resHeaders, Location: url }
+    });
+  }
+  body(data, status = 200) {
+    return new Response(data, {
+      status,
+      headers: this._resHeaders
+    });
+  }
+  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) {
+  }
+  /**
+   * Get the request-scoped service manager for this request.
+   *
+   * @returns The RequestScopeManager for this request.
+   */
+  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);
+  }
+  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() {
+  }
+};
+
+// src/engine/path.ts
+function extractPath(url) {
+  const protocolEnd = url.indexOf("://");
+  const searchStart = protocolEnd === -1 ? 0 : protocolEnd + 3;
+  const pathStart = url.indexOf("/", searchStart);
+  if (pathStart === -1) {
+    return "/";
+  }
+  const queryStart = url.indexOf("?", pathStart);
+  if (queryStart === -1) {
+    return url.slice(pathStart);
+  }
+  return url.slice(pathStart, queryStart);
+}
+
+// src/engine/pool.ts
+var ObjectPool = class {
+  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) {
+      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) {
+      const obj = this.factory();
+      this.reset(obj);
+      this.pool.push(obj);
+    }
+  }
+};
+
+// src/engine/Gravito.ts
+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 = await mw(ctx, async () => {
+        nextCalled = true;
+        return void 0;
+      });
+      if (result instanceof Response) {
+        return result;
+      }
+      if (nextCalled) {
+        return await handler(ctx);
+      }
+      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--) {
+    const mw = middleware[i];
+    const nextHandler = compiled;
+    compiled = async (ctx) => {
+      let nextCalled = false;
+      const result = await mw(ctx, async () => {
+        nextCalled = true;
+        return void 0;
+      });
+      if (result instanceof Response) {
+        return result;
+      }
+      if (nextCalled) {
+        return await nextHandler(ctx);
+      }
+      return ctx.json({ error: "Middleware did not call next or return response" }, 500);
+    };
+  }
+  return compiled;
+}
+var Gravito = class {
+  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
+   */
+  constructor(options = {}) {
+    const poolSize = options.poolSize ?? 256;
+    this.contextPool = new ObjectPool(
+      () => new FastContext(),
+      (ctx) => ctx.reset(),
+      poolSize
+    );
+    this.contextPool.prewarm(Math.min(32, poolSize));
+    if (options.onError) {
+      this.errorHandler = options.onError;
+    }
+    if (options.onNotFound) {
+      this.notFoundHandler = options.onNotFound;
+    }
+    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) {
+      this.addRoute(method, path, handlers);
+    }
+    return this;
+  }
+  use(pathOrMiddleware, ...middleware) {
+    this.isPureStaticApp = false;
+    if (typeof pathOrMiddleware === "string") {
+      this.router.usePattern(pathOrMiddleware, ...middleware);
+    } else {
+      this.router.use(pathOrMiddleware, ...middleware);
+    }
+    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) {
+      const req = new Request(`http://localhost${path}`, dummyReqOpts);
+      await this.fetch(req);
+    }
+  }
+  /**
+   * Handle an incoming 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, path);
+        try {
+          const result = staticRoute.handler(ctx);
+          if (result instanceof Response) {
+            return result;
+          }
+          return await result;
+        } catch (error) {
+          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 {
+      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);
+      } catch (error) {
+        return await this.handleError(error, ctx);
+      } finally {
+        try {
+          await ctx.requestScope().cleanup();
+        } catch (cleanupError) {
+          console.error("RequestScope cleanup failed:", cleanupError);
+        }
+        this.contextPool.release(ctx);
+      }
+    };
+    return execute();
+  }
+  /**
+   * Sync error handler (for ultra-fast path)
+   */
+  handleErrorSync(error, request, path) {
+    if (this.errorHandler) {
+      const ctx = new MinimalContext(request, {}, path);
+      const result = this.errorHandler(error, ctx);
+      if (result instanceof Response) {
+        return result;
+      }
+      return result;
+    }
+    console.error("Unhandled error:", error);
+    return new Response(CACHED_RESPONSES.INTERNAL_ERROR, {
+      status: 500,
+      headers: HEADERS.JSON
+    });
+  }
+  /**
+   * Sync 404 handler (for ultra-fast path)
+   */
+  handleNotFoundSync(request, path) {
+    if (this.notFoundHandler) {
+      const ctx = new MinimalContext(request, {}, path);
+      const result = this.notFoundHandler(ctx);
+      if (result instanceof Response) {
+        return result;
+      }
+      return result;
+    }
+    return new Response(CACHED_RESPONSES.NOT_FOUND, {
+      status: 404,
+      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.router.version) {
+        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.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}`);
+    }
+    const handler = handlers[handlers.length - 1];
+    const middleware = handlers.slice(0, -1);
+    this.router.add(method, path, handler, middleware);
+    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
+    );
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AOTRouter,
+  FastContextImpl,
+  Gravito,
+  MinimalContext,
+  ObjectPool,
+  extractPath
+});