@gravito/core 2.0.0 → 2.0.1

package/dist/engine/index.cjs

@@ -1,1693 +0,0 @@
-// @bun @bun-cjs
-(function(exports, require, module, __filename, __dirname) {var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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 __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-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
-    });
-};
-
-// src/engine/index.ts
-var exports_engine = {};
-__export(exports_engine, {
-  extractPath: () => extractPath,
-  ObjectPool: () => ObjectPool,
-  MinimalContext: () => MinimalContext,
-  Gravito: () => Gravito,
-  FastContextImpl: () => FastContext,
-  AOTRouter: () => AOTRouter
-});
-module.exports = __toCommonJS(exports_engine);
-
-// src/adapters/bun/RadixNode.ts
-class RadixNode {
-  segment;
-  type;
-  children = new Map;
-  paramChild = null;
-  wildcardChild = null;
-  handlers = new Map;
-  paramName = null;
-  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
-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);
-  }
-  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);
-    this.routeCache.clear();
-  }
-  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 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("/");
-    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) {
-      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() {
-    return JSON.stringify({
-      root: this.root.toJSON(),
-      globalConstraints: Array.from(this.globalConstraints.entries()).map(([k, v]) => [
-        k,
-        v.source
-      ])
-    });
-  }
-  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
-class AOTRouter {
-  staticRoutes = new Map;
-  dynamicRouter = new RadixRouter;
-  routeDefinitions = [];
-  globalMiddleware = [];
-  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();
-    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(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) {
-      const hasMethodPrefix = /^(get|post|put|delete|patch|options|head):/.test(pattern);
-      if (hasMethodPrefix) {
-        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);
-    }
-  }
-  use(...middleware) {
-    this.globalMiddleware.push(...middleware);
-    this._version++;
-  }
-  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(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: []
-    };
-  }
-  collectMiddlewarePublic(path, routeMiddleware) {
-    return this.collectMiddleware(path, routeMiddleware);
-  }
-  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 !== undefined && 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;
-  }
-  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("*");
-  }
-  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;
-  }
-  getRoutes() {
-    const routes = [];
-    for (const key of this.staticRoutes.keys()) {
-      const [method, path] = key.split(":");
-      routes.push({ method, path, type: "static" });
-    }
-    return routes;
-  }
-}
-
-// 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)"),
-    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")
-  };
-}
-
-// src/engine/analyzer.ts
-function analyzeHandler(handler) {
-  const source = handler.toString();
-  return analyzeHandlerWithTranspiler(source);
-}
-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
-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 bunEscapeHTML = globalThis.Bun.escapeHTML;
-
-class FastRequestImpl {
-  _request;
-  _params;
-  _path;
-  _routePattern;
-  _url = null;
-  _query = null;
-  _headers = null;
-  _cachedJson = undefined;
-  _jsonParsed = false;
-  _cachedText = undefined;
-  _textParsed = false;
-  _cachedFormData = undefined;
-  _formDataParsed = false;
-  _cachedQueries = null;
-  _cachedCookies = null;
-  _ctx;
-  constructor(ctx) {
-    this._ctx = ctx;
-  }
-  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 = 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() {
-    this._request = undefined;
-    this._params = undefined;
-    this._url = null;
-    this._query = null;
-    this._headers = null;
-    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)");
-    }
-  }
-  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) ?? 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 === undefined) {
-        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) ?? undefined;
-  }
-  headers() {
-    this.checkReleased();
-    if (!this._headers) {
-      this._headers = {};
-      for (const [key, value] of this._request.headers.entries()) {
-        this._headers[key] = value;
-      }
-    }
-    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) {
-      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;
-  }
-}
-
-class FastContext {
-  req = new FastRequestImpl(this);
-  _headers = new Headers;
-  _isReleased = false;
-  _requestScope = null;
-  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() {
-    this._isReleased = true;
-    this.req.reset();
-    this._store.clear();
-    this._requestScope = null;
-  }
-  checkReleased() {
-    if (this._isReleased) {
-      throw new Error("FastContext usage after release detected! (Object Pool Strict Lifecycle Guard)");
-    }
-  }
-  json(data, status = 200) {
-    this.checkReleased();
-    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();
-    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();
-    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();
-    return new Response(null, {
-      status,
-      headers: { Location: url }
-    });
-  }
-  body(data, status = 200) {
-    this.checkReleased();
-    return new Response(data, {
-      status,
-      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();
-    return new Response(stream, {
-      status,
-      headers: { "Content-Type": "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 = {}) {
-    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,
-      duplex: "half"
-    });
-  }
-  header(name, value) {
-    this.checkReleased();
-    if (value !== undefined) {
-      this._headers.set(name, value);
-      return;
-    }
-    return this.req.header(name);
-  }
-  status(_code) {
-    this.checkReleased();
-  }
-  _store = new Map;
-  get(key) {
-    return this._store.get(key);
-  }
-  set(key, value) {
-    this._store.set(key, value);
-  }
-  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 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;
-  }
-  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 };
-  }
-  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) ?? 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 === undefined) {
-        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) ?? undefined;
-  }
-  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 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;
-  }
-}
-
-class MinimalContext {
-  req;
-  _resHeaders = {};
-  _requestScope;
-  constructor(request, params, path, routePattern) {
-    this.req = new MinimalRequest(request, params, path, routePattern);
-    this._requestScope = new RequestScopeManager;
-  }
-  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 !== undefined) {
-      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
-    });
-  }
-  escape(html) {
-    return bunEscapeHTML2(html);
-  }
-  get(_key) {
-    return;
-  }
-  set(_key, _value) {}
-  requestScope() {
-    return this._requestScope;
-  }
-  scoped(key, factory) {
-    return this._requestScope.resolve(key, factory);
-  }
-  route = () => "";
-  get native() {
-    return this;
-  }
-  init(_request, _params, _path) {
-    throw new Error("MinimalContext does not support init. Create a new instance instead.");
-  }
-  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
-class ObjectPool {
-  pool = [];
-  factory;
-  reset;
-  maxSize;
-  constructor(factory, reset, maxSize = 256) {
-    this.factory = factory;
-    this.reset = reset;
-    this.maxSize = maxSize;
-  }
-  acquire() {
-    const obj = this.pool.pop();
-    if (obj !== undefined) {
-      return obj;
-    }
-    return this.factory();
-  }
-  release(obj) {
-    if (this.pool.length < this.maxSize) {
-      this.reset(obj);
-      this.pool.push(obj);
-    }
-  }
-  clear() {
-    this.pool = [];
-  }
-  get size() {
-    return this.pool.length;
-  }
-  get capacity() {
-    return this.maxSize;
-  }
-  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
-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--) {
-    const mw = middleware[i];
-    const nextHandler = compiled;
-    compiled = 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 nextResult = nextHandler(ctx);
-        if (nextResult instanceof Promise) {
-          const p = bunPeek(nextResult);
-          return p === nextResult ? await nextResult : p;
-        }
-        return nextResult;
-      }
-      return ctx.json({ error: "Middleware did not call next or return response" }, 500);
-    };
-  }
-  return compiled;
-}
-
-class Gravito {
-  router = new AOTRouter;
-  contextPool;
-  errorHandler;
-  notFoundHandler;
-  staticRoutes;
-  isPureStaticApp = true;
-  compiledDynamicRoutes = new Map;
-  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();
-  }
-  get(path, ...handlers) {
-    return this.addRoute("get", path, handlers);
-  }
-  post(path, ...handlers) {
-    return this.addRoute("post", path, handlers);
-  }
-  put(path, ...handlers) {
-    return this.addRoute("put", path, handlers);
-  }
-  delete(path, ...handlers) {
-    return this.addRoute("delete", path, handlers);
-  }
-  patch(path, ...handlers) {
-    return this.addRoute("patch", path, handlers);
-  }
-  options(path, ...handlers) {
-    return this.addRoute("options", path, handlers);
-  }
-  head(path, ...handlers) {
-    return this.addRoute("head", path, handlers);
-  }
-  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(path, app) {
-    this.router.mount(path, app.router);
-    this.compileRoutes();
-    return this;
-  }
-  onError(handler) {
-    this.errorHandler = handler;
-    return this;
-  }
-  notFound(handler) {
-    this.notFoundHandler = handler;
-    return this;
-  }
-  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);
-    }
-  }
-  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) {
-      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.handleDynamicRoute(request, method, path);
-  };
-  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 {
-        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) {
-        const cleanup = ctx.requestScope().cleanup();
-        if (cleanup instanceof Promise)
-          await cleanup;
-        this.contextPool.release(ctx);
-        return this.handleErrorSync(error, request, path);
-      }
-    }
-    return this.handleNotFoundSync(request, 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
-    });
-  }
-  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
-    });
-  }
-  collectMiddlewareForPath(path, routeMiddleware) {
-    if (this.router.globalMiddleware.length === 0 && this.router.pathMiddleware.size === 0) {
-      return routeMiddleware;
-    }
-    return this.router.collectMiddlewarePublic(path, routeMiddleware);
-  }
-  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;
-    }
-  }
-  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;
-  }
-}
-})
-
-//# debugId=46FB5CAED852799864756E2164756E21