@buenojs/bueno 0.8.3 → 0.8.5

package/dist/modules/index.js

@@ -0,0 +1,3346 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/context/index.ts
+var exports_context = {};
+__export(exports_context, {
+  createContext: () => createContext,
+  Context: () => Context
+});
+function parseCookies(cookieHeader) {
+  const cookies = {};
+  for (const part of cookieHeader.split(";")) {
+    const trimmed = part.trim();
+    if (trimmed) {
+      const [name, ...rest] = trimmed.split("=");
+      if (name && rest.length > 0) {
+        cookies[name.trim()] = rest.join("=").trim();
+      }
+    }
+  }
+  return cookies;
+}
+
+class Context {
+  req;
+  params;
+  query;
+  _cookies;
+  _bodyCache;
+  _response;
+  _variables = {};
+  constructor(request, params = {}) {
+    this.req = request;
+    this.params = params;
+    this.query = this.parseQuery(request.url);
+    this._response = {
+      status: 200,
+      headers: new Headers
+    };
+  }
+  get method() {
+    return this.req.method;
+  }
+  get url() {
+    return new URL(this.req.url);
+  }
+  get path() {
+    return this.url.pathname;
+  }
+  getHeader(name) {
+    return this.req.headers.get(name) ?? undefined;
+  }
+  getCookie(name) {
+    if (!this._cookies) {
+      const cookieHeader = this.req.headers.get("Cookie");
+      this._cookies = cookieHeader ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies[name];
+  }
+  get cookies() {
+    if (!this._cookies) {
+      const cookieHeader = this.req.headers.get("Cookie");
+      this._cookies = cookieHeader ? parseCookies(cookieHeader) : {};
+    }
+    return this._cookies;
+  }
+  async body() {
+    if (this._bodyCache !== undefined) {
+      return this._bodyCache;
+    }
+    const text = await this.req.text();
+    this._bodyCache = text ? JSON.parse(text) : null;
+    return this._bodyCache;
+  }
+  async parseBody() {
+    return this.body();
+  }
+  async bodyText() {
+    return this.req.text();
+  }
+  async bodyFormData() {
+    return this.req.formData();
+  }
+  async bodyArrayBuffer() {
+    return this.req.arrayBuffer();
+  }
+  async bodyBlob() {
+    return this.req.blob();
+  }
+  set(key, value) {
+    this._variables[key] = value;
+    return this;
+  }
+  get(key) {
+    return this._variables[key];
+  }
+  has(key) {
+    return key in this._variables;
+  }
+  status(code) {
+    this._response.status = code;
+    return this;
+  }
+  setHeader(name, value) {
+    this._response.headers.set(name, value);
+    return this;
+  }
+  appendHeader(name, value) {
+    this._response.headers.append(name, value);
+    return this;
+  }
+  json(data) {
+    this._response.headers.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(data), {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  text(data) {
+    if (!this._response.headers.has("Content-Type")) {
+      this._response.headers.set("Content-Type", "text/plain");
+    }
+    return new Response(data, {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  html(data) {
+    this._response.headers.set("Content-Type", "text/html; charset=utf-8");
+    return new Response(data, {
+      status: this._response.status,
+      headers: this._response.headers
+    });
+  }
+  redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: {
+        Location: url
+      }
+    });
+  }
+  notFound(message = "Not Found") {
+    return new Response(JSON.stringify({ error: message }), {
+      status: 404,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  error(message, status = 500) {
+    return new Response(JSON.stringify({ error: message }), {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  newResponse(body, options) {
+    return new Response(body, {
+      status: this._response.status,
+      headers: this._response.headers,
+      ...options
+    });
+  }
+  parseQuery(url) {
+    const query = {};
+    const searchParams = new URL(url).searchParams;
+    for (const [key, value] of searchParams.entries()) {
+      query[key] = value;
+    }
+    return query;
+  }
+  accepts(...types) {
+    const acceptHeader = this.req.headers.get("Accept");
+    if (!acceptHeader)
+      return types[0];
+    for (const type of types) {
+      if (acceptHeader.includes(type) || acceptHeader.includes("*/*")) {
+        return type;
+      }
+    }
+    return;
+  }
+  get isXHR() {
+    return this.req.headers.get("X-Requested-With") === "XMLHttpRequest";
+  }
+  get ip() {
+    return this.req.headers.get("x-forwarded-for")?.split(",")[0].trim() ?? this.req.headers.get("x-real-ip") ?? undefined;
+  }
+}
+function createContext(request, params = {}) {
+  return new Context(request, params);
+}
+
+// src/middleware/index.ts
+var exports_middleware = {};
+__export(exports_middleware, {
+  createPipeline: () => createPipeline,
+  compose: () => compose,
+  Pipeline: () => Pipeline
+});
+function compose(middleware) {
+  return async (context, handler) => {
+    let index = -1;
+    const dispatch = async (i) => {
+      if (i <= index) {
+        throw new Error("next() called multiple times");
+      }
+      index = i;
+      if (i >= middleware.length) {
+        return handler(context);
+      }
+      const fn = middleware[i];
+      return fn(context, async () => {
+        return dispatch(i + 1);
+      });
+    };
+    return dispatch(0);
+  };
+}
+
+class Pipeline {
+  middleware = [];
+  use(middleware) {
+    this.middleware.push(middleware);
+    return this;
+  }
+  async execute(context, handler) {
+    const fn = compose(this.middleware);
+    return fn(context, handler);
+  }
+  get length() {
+    return this.middleware.length;
+  }
+}
+function createPipeline() {
+  return new Pipeline;
+}
+
+// src/validation/index.ts
+async function validate(schema, data) {
+  try {
+    const result = await Promise.resolve(schema["~standard"].validate(data));
+    if ("value" in result) {
+      return { success: true, data: result.value };
+    }
+    return {
+      success: false,
+      issues: [...result.issues]
+    };
+  } catch (error) {
+    return {
+      success: false,
+      issues: [
+        {
+          message: error instanceof Error ? error.message : "Validation failed"
+        }
+      ]
+    };
+  }
+}
+function validateSync(schema, data) {
+  const result = schema["~standard"].validate(data);
+  if (result instanceof Promise) {
+    throw new Error("Schema uses async validation. Use validate() instead.");
+  }
+  if ("value" in result) {
+    return { success: true, data: result.value };
+  }
+  return { success: false, issues: [...result.issues] };
+}
+async function validateBody(context, schema) {
+  try {
+    const body = await context.body();
+    return validate(schema, body);
+  } catch (error) {
+    return {
+      success: false,
+      issues: [{ message: "Failed to parse request body" }]
+    };
+  }
+}
+function validateQuery(context, schema) {
+  return validateSync(schema, context.query);
+}
+function validateParams(context, schema) {
+  return validateSync(schema, context.params);
+}
+function validateHeaders(context, schema) {
+  const headers = {};
+  context.req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return validateSync(schema, headers);
+}
+function createValidator(options) {
+  return async (context, next) => {
+    if (options.body) {
+      const result = await validateBody(context, options.body);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("validatedBody", result.data);
+    }
+    if (options.query) {
+      const result = validateQuery(context, options.query);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("validatedQuery", result.data);
+    }
+    if (options.params) {
+      const result = validateParams(context, options.params);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("validatedParams", result.data);
+    }
+    if (options.headers) {
+      const result = validateHeaders(context, options.headers);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("validatedHeaders", result.data);
+    }
+    return next();
+  };
+}
+function WithBody(schema) {
+  return (target, propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = async function(context) {
+      const result = await validateBody(context, schema);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("body", result.data);
+      return original.call(this, context);
+    };
+    return descriptor;
+  };
+}
+function WithQuery(schema) {
+  return (target, propertyKey, descriptor) => {
+    const original = descriptor.value;
+    descriptor.value = async function(context) {
+      const result = validateQuery(context, schema);
+      if (!result.success) {
+        return context.status(400).json({ error: "Validation failed", issues: result.issues });
+      }
+      context.set("query", result.data);
+      return original.call(this, context);
+    };
+    return descriptor;
+  };
+}
+function isStandardSchema(value) {
+  return typeof value === "object" && value !== null && "~standard" in value && typeof value["~standard"]?.validate === "function";
+}
+function assertStandardSchema(schema, name = "Schema") {
+  if (!isStandardSchema(schema)) {
+    throw new Error(`${name} must implement Standard Schema interface. Supported: Zod 4+, Valibot v1+, ArkType, Typia 7+`);
+  }
+}
+function validateEnvSync(schema, envVars) {
+  try {
+    const result = validateSync(schema, envVars);
+    if (!result.success) {
+      const formattedIssues = result.issues.map((issue) => {
+        const path = issue.path?.join(".") || "root";
+        return {
+          ...issue,
+          message: `Environment variable validation failed for ${path}: ${issue.message}`
+        };
+      });
+      return {
+        success: false,
+        issues: formattedIssues
+      };
+    }
+    return result;
+  } catch (error) {
+    return {
+      success: false,
+      issues: [
+        {
+          message: `Environment variable validation failed: ${error instanceof Error ? error.message : "Unknown error"}`
+        }
+      ]
+    };
+  }
+}
+
+// src/container/forward-ref.ts
+var FORWARD_REF_SYMBOL = Symbol.for("buno.forwardRef");
+function forwardRef(fn) {
+  return {
+    __forwardRef: FORWARD_REF_SYMBOL,
+    forwardRef: fn
+  };
+}
+function isForwardRef(value) {
+  return typeof value === "object" && value !== null && "__forwardRef" in value && "forwardRef" in value && typeof value.forwardRef === "function";
+}
+function resolveForwardRef(ref) {
+  if (isForwardRef(ref)) {
+    return ref.forwardRef();
+  }
+  return ref;
+}
+
+// src/container/index.ts
+function createToken(description) {
+  return Symbol(description);
+}
+var Token = createToken;
+
+class ResolutionStack {
+  stack = new Set;
+  lazyResolutions = new Map;
+  push(token) {
+    if (this.stack.has(token)) {
+      throw new Error("Circular dependency detected: Token already in resolution stack");
+    }
+    this.stack.add(token);
+  }
+  pop(token) {
+    this.stack.delete(token);
+  }
+  has(token) {
+    return this.stack.has(token);
+  }
+  markLazy(token, placeholder) {
+    this.lazyResolutions.set(token, placeholder);
+  }
+  hasLazy(token) {
+    return this.lazyResolutions.has(token);
+  }
+  getLazy(token) {
+    return this.lazyResolutions.get(token);
+  }
+  clearLazy(token) {
+    this.lazyResolutions.delete(token);
+  }
+}
+
+class Container2 {
+  providers = new Map;
+  resolutionStack = new ResolutionStack;
+  register(provider) {
+    if (this.providers.has(provider.token)) {
+      throw new Error(`Provider already registered for token: ${String(provider.token)}`);
+    }
+    this.providers.set(provider.token, {
+      provider: {
+        ...provider,
+        scope: provider.scope ?? "singleton"
+      }
+    });
+  }
+  registerAll(providers) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+  }
+  has(token) {
+    return this.providers.has(token);
+  }
+  resolve(token) {
+    const resolved = this.providers.get(token);
+    if (!resolved) {
+      throw new Error(`No provider registered for token: ${String(token)}`);
+    }
+    const { provider } = resolved;
+    if (this.resolutionStack.has(token)) {
+      return this.createLazyProxy(token, resolved);
+    }
+    if (provider.scope === "singleton" && resolved.instance !== undefined) {
+      return resolved.instance;
+    }
+    this.resolutionStack.push(token);
+    try {
+      const instance = this.createInstance(provider);
+      if (provider.scope === "singleton") {
+        resolved.instance = instance;
+      }
+      return instance;
+    } finally {
+      this.resolutionStack.pop(token);
+    }
+  }
+  createLazyProxy(token, resolved) {
+    const existingLazy = this.resolutionStack.getLazy(token);
+    if (existingLazy && existingLazy.instance) {
+      return existingLazy.instance;
+    }
+    const placeholder = {
+      resolved: false
+    };
+    this.resolutionStack.markLazy(token, placeholder);
+    const proxy = new Proxy({}, {
+      get: (target, prop) => {
+        if (placeholder.resolved && placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        if (resolved.instance !== undefined) {
+          placeholder.instance = resolved.instance;
+          placeholder.resolved = true;
+        } else {
+          if (prop === "then") {
+            return;
+          }
+        }
+        if (placeholder.instance) {
+          const value = placeholder.instance[prop];
+          return typeof value === "function" ? value.bind(placeholder.instance) : value;
+        }
+        return () => {
+          return;
+        };
+      },
+      set: (target, prop, value) => {
+        if (placeholder.instance) {
+          placeholder.instance[prop] = value;
+          return true;
+        }
+        return false;
+      },
+      has: (target, prop) => {
+        if (placeholder.instance) {
+          return prop in placeholder.instance;
+        }
+        return false;
+      }
+    });
+    placeholder.instance = proxy;
+    return proxy;
+  }
+  createInstance(provider) {
+    if (provider.useValue !== undefined) {
+      return provider.useValue;
+    }
+    if (provider.useFactory) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return provider.useFactory(...deps);
+    }
+    if (provider.useClass) {
+      const deps = this.resolveDeps(provider.inject ?? []);
+      return new provider.useClass(...deps);
+    }
+    throw new Error(`Invalid provider configuration for token: ${String(provider.token)}`);
+  }
+  resolveDeps(tokens) {
+    return tokens.map((tokenOrRef) => {
+      const token = resolveForwardRef(tokenOrRef);
+      return this.resolve(token);
+    });
+  }
+  clear() {
+    this.providers.clear();
+  }
+  getTokens() {
+    return Array.from(this.providers.keys());
+  }
+  createChild() {
+    const child = new Container2;
+    for (const [token, resolved] of this.providers) {
+      if (resolved.provider.scope === "singleton") {
+        child.providers.set(token, resolved);
+      }
+    }
+    return child;
+  }
+}
+var containerMetadata = new WeakMap;
+function setContainerMetadata(target, key, value) {
+  if (!containerMetadata.has(target)) {
+    containerMetadata.set(target, new Map);
+  }
+  containerMetadata.get(target)?.set(key, value);
+}
+function getContainerMetadata(target, key) {
+  return containerMetadata.get(target)?.get(key);
+}
+function Injectable(token) {
+  return (target) => {
+    setContainerMetadata(target, "injectable", true);
+    if (token) {
+      setContainerMetadata(target, "token", token);
+    }
+    return target;
+  };
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const targetObj = target;
+    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
+    existingTokens[parameterIndex] = token;
+    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
+  };
+}
+// src/router/linear.ts
+function patternToRegex(pattern) {
+  const paramNames = [];
+  let isStatic = true;
+  let hasWildcard = false;
+  const segments = [];
+  let i = 0;
+  while (i < pattern.length) {
+    if (pattern[i] === ":") {
+      i++;
+      let name = "";
+      while (i < pattern.length && /[a-zA-Z0-9_]/.test(pattern[i])) {
+        name += pattern[i];
+        i++;
+      }
+      let optional = false;
+      if (i < pattern.length && pattern[i] === "?") {
+        optional = true;
+        i++;
+      }
+      let customRegex = "";
+      if (i < pattern.length && pattern[i] === "<") {
+        i++;
+        while (i < pattern.length && pattern[i] !== ">") {
+          customRegex += pattern[i];
+          i++;
+        }
+        i++;
+      }
+      paramNames.push(name);
+      isStatic = false;
+      if (optional) {
+        if (segments.length > 0 && segments[segments.length - 1] === "/") {
+          segments.pop();
+        }
+        segments.push("(?:/([^/]*))?");
+      } else if (customRegex) {
+        segments.push(`(${customRegex})`);
+      } else {
+        segments.push("([^/]+)");
+      }
+    } else if (pattern[i] === "*") {
+      hasWildcard = true;
+      isStatic = false;
+      paramNames.push("*");
+      segments.push("(.*)");
+      i++;
+    } else {
+      const char = pattern[i];
+      if (/[.+^${}()|[\]\\]/.test(char)) {
+        segments.push(`\\${char}`);
+      } else {
+        segments.push(char);
+      }
+      i++;
+    }
+  }
+  const regexStr = `^${segments.join("")}/?$`;
+  return {
+    regex: new RegExp(regexStr, "i"),
+    paramNames,
+    isStatic,
+    hasWildcard
+  };
+}
+function extractParams(regex, paramNames, pathname) {
+  const params = {};
+  const match = pathname.match(regex);
+  if (match) {
+    paramNames.forEach((name, index) => {
+      if (match[index + 1] !== undefined) {
+        params[name] = match[index + 1];
+      }
+    });
+  }
+  return params;
+}
+
+class LinearRouter {
+  staticRoutes = new Map;
+  dynamicRoutes = [];
+  groupPrefix = "";
+  groupMiddleware = [];
+  routeCounter = 0;
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const { regex, paramNames, isStatic } = patternToRegex(fullPattern);
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    const middleware = [...this.groupMiddleware, ...routeMiddleware];
+    if (isStatic) {
+      const normalizedPath = fullPattern.toLowerCase();
+      const key = `${method}:${normalizedPath}`;
+      this.staticRoutes.set(key, { handler, middleware, name: options?.name });
+      if (!normalizedPath.endsWith("/")) {
+        this.staticRoutes.set(`${method}:${normalizedPath}/`, {
+          handler,
+          middleware,
+          name: options?.name
+        });
+      } else if (normalizedPath.length > 1) {
+        this.staticRoutes.set(`${method}:${normalizedPath.slice(0, -1)}`, {
+          handler,
+          middleware,
+          name: options?.name
+        });
+      }
+    } else {
+      this.dynamicRoutes.push({
+        method,
+        pattern: fullPattern,
+        handler,
+        middleware,
+        name: options?.name,
+        regex,
+        paramNames,
+        priority: this.routeCounter++
+      });
+      this.sortDynamicRoutes();
+    }
+  }
+  sortDynamicRoutes() {
+    this.dynamicRoutes.sort((a, b) => {
+      if (a.paramNames.length !== b.paramNames.length) {
+        return a.paramNames.length - b.paramNames.length;
+      }
+      return a.priority - b.priority;
+    });
+  }
+  match(method, pathname) {
+    const normalizedPath = pathname.toLowerCase();
+    const staticKey = `${method}:${normalizedPath}`;
+    const staticRoute = this.staticRoutes.get(staticKey);
+    if (staticRoute) {
+      return {
+        handler: staticRoute.handler,
+        params: {},
+        middleware: staticRoute.middleware,
+        name: staticRoute.name
+      };
+    }
+    const allKey = `ALL:${normalizedPath}`;
+    const allRoute = this.staticRoutes.get(allKey);
+    if (allRoute) {
+      return {
+        handler: allRoute.handler,
+        params: {},
+        middleware: allRoute.middleware,
+        name: allRoute.name
+      };
+    }
+    for (const route of this.dynamicRoutes) {
+      if (route.method !== "ALL" && route.method !== method) {
+        continue;
+      }
+      if (route.regex.test(pathname)) {
+        const params = extractParams(route.regex, route.paramNames, pathname);
+        return {
+          handler: route.handler,
+          params,
+          middleware: route.middleware,
+          name: route.name
+        };
+      }
+    }
+    return;
+  }
+  group(prefix, options) {
+    const childRouter = new LinearRouter;
+    childRouter.staticRoutes = this.staticRoutes;
+    childRouter.dynamicRoutes = this.dynamicRoutes;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    childRouter.routeCounter = this.routeCounter;
+    return childRouter;
+  }
+  getRoutes() {
+    const routes = [];
+    const seenPatterns = new Set;
+    for (const [key, value] of this.staticRoutes) {
+      const [method, path] = key.split(":");
+      const pattern = path.endsWith("/") && path.length > 1 ? path.slice(0, -1) : path;
+      const dedupeKey = `${method}:${pattern}`;
+      if (!seenPatterns.has(dedupeKey)) {
+        seenPatterns.add(dedupeKey);
+        routes.push({ method, pattern: pattern || "/", name: value.name });
+      }
+    }
+    for (const route of this.dynamicRoutes) {
+      routes.push({
+        method: route.method,
+        pattern: route.pattern,
+        name: route.name
+      });
+    }
+    return routes;
+  }
+  getRouterType() {
+    return "linear";
+  }
+  getRouteCount() {
+    const staticCount = Math.floor(this.staticRoutes.size / 2);
+    return {
+      static: staticCount,
+      dynamic: this.dynamicRoutes.length,
+      total: staticCount + this.dynamicRoutes.length
+    };
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+
+// src/router/regex.ts
+function patternToRegex2(pattern) {
+  const paramNames = [];
+  let isStatic = true;
+  let hasWildcard = false;
+  const segments = [];
+  let i = 0;
+  while (i < pattern.length) {
+    if (pattern[i] === ":") {
+      i++;
+      let name = "";
+      while (i < pattern.length && /[a-zA-Z0-9_]/.test(pattern[i])) {
+        name += pattern[i];
+        i++;
+      }
+      let optional = false;
+      if (i < pattern.length && pattern[i] === "?") {
+        optional = true;
+        i++;
+      }
+      let customRegex = "";
+      if (i < pattern.length && pattern[i] === "<") {
+        i++;
+        while (i < pattern.length && pattern[i] !== ">") {
+          customRegex += pattern[i];
+          i++;
+        }
+        i++;
+      }
+      paramNames.push(name);
+      isStatic = false;
+      if (optional) {
+        if (segments.length > 0 && segments[segments.length - 1] === "/") {
+          segments.pop();
+        }
+        segments.push("(?:/([^/]*))?");
+      } else if (customRegex) {
+        segments.push(`(${customRegex})`);
+      } else {
+        segments.push("([^/]+)");
+      }
+    } else if (pattern[i] === "*") {
+      hasWildcard = true;
+      isStatic = false;
+      paramNames.push("*");
+      segments.push("(.*)");
+      i++;
+    } else {
+      const char = pattern[i];
+      if (/[.+^${}()|[\]\\]/.test(char)) {
+        segments.push(`\\${char}`);
+      } else {
+        segments.push(char);
+      }
+      i++;
+    }
+  }
+  const regexStr = `^${segments.join("")}/?$`;
+  return {
+    regex: new RegExp(regexStr, "i"),
+    paramNames,
+    isStatic,
+    hasWildcard
+  };
+}
+function extractParams2(regex, paramNames, pathname) {
+  const params = {};
+  const match = pathname.match(regex);
+  if (match) {
+    paramNames.forEach((name, index) => {
+      if (match[index + 1] !== undefined) {
+        params[name] = match[index + 1];
+      }
+    });
+  }
+  return params;
+}
+
+class RegexRouter {
+  routes = [];
+  groupPrefix = "";
+  groupMiddleware = [];
+  routeCounter = 0;
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const { regex, paramNames, isStatic } = patternToRegex2(fullPattern);
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    this.routes.push({
+      method,
+      pattern: fullPattern,
+      handler,
+      middleware: [...this.groupMiddleware, ...routeMiddleware],
+      name: options?.name,
+      regex,
+      paramNames,
+      isStatic,
+      priority: this.routeCounter++
+    });
+    this.sortRoutes();
+  }
+  sortRoutes() {
+    this.routes.sort((a, b) => {
+      if (a.isStatic !== b.isStatic) {
+        return a.isStatic ? -1 : 1;
+      }
+      if (a.paramNames.length !== b.paramNames.length) {
+        return a.paramNames.length - b.paramNames.length;
+      }
+      return a.priority - b.priority;
+    });
+  }
+  match(method, pathname) {
+    for (const route of this.routes) {
+      if (route.method !== "ALL" && route.method !== method) {
+        continue;
+      }
+      if (route.regex.test(pathname)) {
+        const params = extractParams2(route.regex, route.paramNames, pathname);
+        return {
+          handler: route.handler,
+          params,
+          middleware: route.middleware,
+          name: route.name
+        };
+      }
+    }
+    return;
+  }
+  group(prefix, options) {
+    const childRouter = new RegexRouter;
+    childRouter.routes = this.routes;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    childRouter.routeCounter = this.routeCounter;
+    return childRouter;
+  }
+  getRoutes() {
+    return this.routes.map((r) => ({
+      method: r.method,
+      pattern: r.pattern,
+      name: r.name
+    }));
+  }
+  getRouterType() {
+    return "regex";
+  }
+  getRouteCount() {
+    return this.routes.length;
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+
+// src/router/tree.ts
+class TreeRouter {
+  root;
+  groupPrefix = "";
+  groupMiddleware = [];
+  routeCount = 0;
+  constructor() {
+    this.root = this.createNode("");
+  }
+  createNode(path, paramName, paramRegex, isWildcard = false) {
+    return {
+      path,
+      children: new Map,
+      handlers: new Map,
+      paramName,
+      paramRegex,
+      isWildcard
+    };
+  }
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    const middleware = [...this.groupMiddleware, ...routeMiddleware];
+    const segments = this.parsePattern(fullPattern);
+    const node = this.insertSegments(this.root, segments, 0);
+    node.handlers.set(method, {
+      handler,
+      middleware,
+      name: options?.name
+    });
+    this.routeCount++;
+  }
+  parsePattern(pattern) {
+    const segments = [];
+    let normalized = pattern;
+    if (!normalized.startsWith("/")) {
+      normalized = `/${normalized}`;
+    }
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    if (normalized === "/") {
+      return [{ type: "static", value: "" }];
+    }
+    const parts = normalized.split("/").filter(Boolean);
+    for (const part of parts) {
+      if (part === "*") {
+        segments.push({ type: "wildcard" });
+      } else if (part.startsWith(":")) {
+        let name = part.slice(1);
+        let regex;
+        let optional = false;
+        if (name.endsWith("?")) {
+          optional = true;
+          name = name.slice(0, -1);
+        }
+        const regexMatch = name.match(/^(\w+)<(.+)>$/);
+        if (regexMatch) {
+          name = regexMatch[1];
+          regex = new RegExp(`^(${regexMatch[2]})$`);
+        }
+        segments.push({ type: "param", name, regex, optional });
+      } else {
+        segments.push({ type: "static", value: part.toLowerCase() });
+      }
+    }
+    return segments;
+  }
+  insertSegments(node, segments, index) {
+    if (index >= segments.length) {
+      return node;
+    }
+    const segment = segments[index];
+    if (segment.type === "wildcard") {
+      if (!node.wildcardChild) {
+        node.wildcardChild = this.createNode("*", "*", undefined, true);
+      }
+      return node.wildcardChild;
+    }
+    if (segment.type === "param") {
+      if (!node.paramChild) {
+        node.paramChild = this.createNode(`:${segment.name}`, segment.name, segment.regex);
+      }
+      return this.insertSegments(node.paramChild, segments, index + 1);
+    }
+    const value = segment.value;
+    let child = node.children.get(value);
+    if (!child) {
+      child = this.createNode(value);
+      node.children.set(value, child);
+    }
+    return this.insertSegments(child, segments, index + 1);
+  }
+  match(method, pathname) {
+    const params = {};
+    let normalized = pathname.toLowerCase();
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    const parts = normalized === "/" ? [""] : normalized.split("/").filter(Boolean);
+    const result = this.searchTree(this.root, parts, 0, method, params);
+    return result;
+  }
+  searchTree(node, parts, partIndex, method, params) {
+    if (partIndex >= parts.length) {
+      const handlerEntry = node.handlers.get(method) || node.handlers.get("ALL");
+      if (handlerEntry) {
+        return {
+          handler: handlerEntry.handler,
+          params: { ...params },
+          middleware: handlerEntry.middleware,
+          name: handlerEntry.name
+        };
+      }
+      return;
+    }
+    const part = parts[partIndex];
+    const staticChild = node.children.get(part);
+    if (staticChild) {
+      const result = this.searchTree(staticChild, parts, partIndex + 1, method, params);
+      if (result)
+        return result;
+    }
+    if (node.paramChild) {
+      const paramNode = node.paramChild;
+      if (paramNode.paramRegex) {
+        if (paramNode.paramRegex.test(part)) {
+          params[paramNode.paramName] = part;
+          const result = this.searchTree(paramNode, parts, partIndex + 1, method, params);
+          if (result)
+            return result;
+          delete params[paramNode.paramName];
+        }
+      } else {
+        params[paramNode.paramName] = part;
+        const result = this.searchTree(paramNode, parts, partIndex + 1, method, params);
+        if (result)
+          return result;
+        delete params[paramNode.paramName];
+      }
+    }
+    if (node.wildcardChild) {
+      const wildcardNode = node.wildcardChild;
+      params["*"] = parts.slice(partIndex).join("/");
+      const handlerEntry = wildcardNode.handlers.get(method) || wildcardNode.handlers.get("ALL");
+      if (handlerEntry) {
+        return {
+          handler: handlerEntry.handler,
+          params: { ...params },
+          middleware: handlerEntry.middleware,
+          name: handlerEntry.name
+        };
+      }
+    }
+    return;
+  }
+  group(prefix, options) {
+    const childRouter = new TreeRouter;
+    childRouter.root = this.root;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    childRouter.routeCount = this.routeCount;
+    return childRouter;
+  }
+  getRoutes() {
+    const routes = [];
+    this.traverseTree(this.root, "", routes);
+    return routes;
+  }
+  traverseTree(node, currentPath, routes) {
+    for (const [method, entry] of node.handlers) {
+      routes.push({
+        method,
+        pattern: currentPath || "/",
+        name: entry.name
+      });
+    }
+    for (const [path, child] of node.children) {
+      const childPath = `${currentPath}/${path}`;
+      this.traverseTree(child, childPath, routes);
+    }
+    if (node.paramChild) {
+      const childPath = `${currentPath}/:${node.paramChild.paramName}`;
+      this.traverseTree(node.paramChild, childPath, routes);
+    }
+    if (node.wildcardChild) {
+      const childPath = `${currentPath}/*`;
+      this.traverseTree(node.wildcardChild, childPath, routes);
+    }
+  }
+  getRouterType() {
+    return "tree";
+  }
+  getRouteCount() {
+    return this.routeCount;
+  }
+  getTreeStats() {
+    return {
+      nodes: this.countNodes(this.root),
+      depth: this.getTreeDepth(this.root),
+      routes: this.routeCount
+    };
+  }
+  countNodes(node) {
+    let count = 1;
+    for (const child of node.children.values()) {
+      count += this.countNodes(child);
+    }
+    if (node.paramChild) {
+      count += this.countNodes(node.paramChild);
+    }
+    if (node.wildcardChild) {
+      count += this.countNodes(node.wildcardChild);
+    }
+    return count;
+  }
+  getTreeDepth(node) {
+    let maxDepth = 0;
+    for (const child of node.children.values()) {
+      maxDepth = Math.max(maxDepth, this.getTreeDepth(child));
+    }
+    if (node.paramChild) {
+      maxDepth = Math.max(maxDepth, this.getTreeDepth(node.paramChild));
+    }
+    if (node.wildcardChild) {
+      maxDepth = Math.max(maxDepth, this.getTreeDepth(node.wildcardChild));
+    }
+    return maxDepth + 1;
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+
+// src/router/index.ts
+var DEFAULT_LINEAR_THRESHOLD = 10;
+var DEFAULT_REGEX_THRESHOLD = 50;
+
+class Router {
+  router;
+  config;
+  pendingRoutes = [];
+  isBuilt = false;
+  groupPrefix = "";
+  groupMiddleware = [];
+  constructor(config = {}) {
+    this.config = {
+      type: config.type ?? "auto",
+      linearThreshold: config.linearThreshold ?? DEFAULT_LINEAR_THRESHOLD,
+      regexThreshold: config.regexThreshold ?? DEFAULT_REGEX_THRESHOLD
+    };
+    if (this.config.type !== "auto") {
+      this.router = this.createRouter(this.config.type);
+    } else {
+      this.router = new LinearRouter;
+    }
+  }
+  createRouter(type) {
+    switch (type) {
+      case "linear":
+        return new LinearRouter;
+      case "regex":
+        return new RegexRouter;
+      case "tree":
+        return new TreeRouter;
+      default:
+        return new LinearRouter;
+    }
+  }
+  getOptimalRouterType(count) {
+    if (count <= this.config.linearThreshold) {
+      return "linear";
+    }
+    if (count <= this.config.regexThreshold) {
+      return "regex";
+    }
+    return "tree";
+  }
+  migrateRouter(newType) {
+    this.router = this.createRouter(newType);
+    for (const route of this.pendingRoutes) {
+      this.addToRouter(route.method, route.pattern, route.handler, route.options);
+    }
+  }
+  addToRouter(method, pattern, handler, options) {
+    switch (method) {
+      case "GET":
+        this.router.get(pattern, handler, options);
+        break;
+      case "POST":
+        this.router.post(pattern, handler, options);
+        break;
+      case "PUT":
+        this.router.put(pattern, handler, options);
+        break;
+      case "PATCH":
+        this.router.patch(pattern, handler, options);
+        break;
+      case "DELETE":
+        this.router.delete(pattern, handler, options);
+        break;
+      case "HEAD":
+        this.router.head(pattern, handler, options);
+        break;
+      case "OPTIONS":
+        this.router.options(pattern, handler, options);
+        break;
+      case "ALL":
+        this.router.all(pattern, handler, options);
+        break;
+    }
+  }
+  addRoute(method, pattern, handler, options) {
+    const fullPattern = this.groupPrefix + pattern;
+    const optsMiddleware = options?.middleware;
+    const routeMiddleware = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    const allMiddleware = [...this.groupMiddleware, ...routeMiddleware];
+    const fullOptions = options?.name || allMiddleware.length > 0 ? {
+      name: options?.name,
+      middleware: allMiddleware
+    } : undefined;
+    this.pendingRoutes.push({
+      method,
+      pattern: fullPattern,
+      handler,
+      options: fullOptions
+    });
+    this.addToRouter(method, fullPattern, handler, fullOptions);
+    if (this.config.type === "auto" && !this.isBuilt) {
+      const routeCount = this.pendingRoutes.length;
+      const optimalType = this.getOptimalRouterType(routeCount);
+      const currentType = this.router.getRouterType();
+      if (currentType !== optimalType) {
+        this.migrateRouter(optimalType);
+      }
+    }
+  }
+  match(method, pathname) {
+    this.isBuilt = true;
+    return this.router.match(method, pathname);
+  }
+  group(prefix, options) {
+    const childRouter = new Router(this.config);
+    childRouter.router = this.router;
+    childRouter.pendingRoutes = this.pendingRoutes;
+    childRouter.groupPrefix = this.groupPrefix + prefix;
+    childRouter.isBuilt = this.isBuilt;
+    const optsMiddleware = options?.middleware;
+    const middlewareArray = optsMiddleware ? Array.isArray(optsMiddleware) ? optsMiddleware : [optsMiddleware] : [];
+    childRouter.groupMiddleware = [...this.groupMiddleware, ...middlewareArray];
+    return childRouter;
+  }
+  getRoutes() {
+    return this.router.getRoutes();
+  }
+  getRouterType() {
+    return this.router.getRouterType();
+  }
+  getRouteCount() {
+    return this.pendingRoutes.length;
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+  get(pattern, handler, options) {
+    this.addRoute("GET", pattern, handler, options);
+  }
+  post(pattern, handler, options) {
+    this.addRoute("POST", pattern, handler, options);
+  }
+  put(pattern, handler, options) {
+    this.addRoute("PUT", pattern, handler, options);
+  }
+  patch(pattern, handler, options) {
+    this.addRoute("PATCH", pattern, handler, options);
+  }
+  delete(pattern, handler, options) {
+    this.addRoute("DELETE", pattern, handler, options);
+  }
+  head(pattern, handler, options) {
+    this.addRoute("HEAD", pattern, handler, options);
+  }
+  options(pattern, handler, options) {
+    this.addRoute("OPTIONS", pattern, handler, options);
+  }
+  all(pattern, handler, options) {
+    this.addRoute("ALL", pattern, handler, options);
+  }
+}
+function generateUrl(pattern, params = {}) {
+  return pattern.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)\?/g, (_, name) => params[name] ?? "").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)<[^>]+>/g, (_, name) => params[name] ?? "").replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, name) => {
+    if (params[name] === undefined) {
+      throw new Error(`Missing required parameter: ${name}`);
+    }
+    return params[name];
+  }).replace(/\*/g, () => params["*"] ?? "");
+}
+function createRouter(config) {
+  return new Router(config);
+}
+function createLinearRouter() {
+  return new LinearRouter;
+}
+function createRegexRouter() {
+  return new RegexRouter;
+}
+function createTreeRouter() {
+  return new TreeRouter;
+}
+
+// src/types/index.ts
+class BuenoError extends Error {
+  statusCode;
+  code;
+  constructor(message, statusCode = 500, code) {
+    super(message);
+    this.statusCode = statusCode;
+    this.code = code;
+    this.name = "BuenoError";
+  }
+}
+
+class ValidationError extends BuenoError {
+  issues;
+  constructor(message, issues) {
+    super(message, 422, "VALIDATION_ERROR");
+    this.issues = issues;
+    this.name = "ValidationError";
+  }
+}
+
+class NotFoundError extends BuenoError {
+  constructor(message = "Not Found") {
+    super(message, 404, "NOT_FOUND");
+    this.name = "NotFoundError";
+  }
+}
+
+// src/modules/filters.ts
+var filterMetadataStore = new WeakMap;
+var catchMetadataStore = new WeakMap;
+var filterPrototypeStore = new WeakMap;
+function setFilterMetadata(target, key, value) {
+  if (!filterMetadataStore.has(target)) {
+    filterMetadataStore.set(target, new Map);
+  }
+  filterMetadataStore.get(target)?.set(key, value);
+}
+function getFilterMetadata(target, key) {
+  return filterMetadataStore.get(target)?.get(key);
+}
+function setFilterPrototypeMetadata(target, key, value) {
+  if (!filterPrototypeStore.has(target)) {
+    filterPrototypeStore.set(target, new Map);
+  }
+  filterPrototypeStore.get(target)?.set(key, value);
+}
+function getFilterPrototypeMetadata(target, key) {
+  return filterPrototypeStore.get(target)?.get(key);
+}
+function UseFilters(...filters) {
+  const decorator = (target, propertyKey, descriptor) => {
+    if (descriptor && propertyKey !== undefined) {
+      const targetObj = target;
+      const existingFilters = getFilterPrototypeMetadata(targetObj, "filters:method") ?? [];
+      setFilterPrototypeMetadata(targetObj, "filters:method", [
+        ...existingFilters,
+        ...filters
+      ]);
+      return descriptor;
+    } else {
+      const targetClass = target;
+      const existingFilters = getFilterMetadata(targetClass, "filters:class") ?? [];
+      setFilterMetadata(targetClass, "filters:class", [
+        ...existingFilters,
+        ...filters
+      ]);
+    }
+  };
+  return decorator;
+}
+function Catch(exceptionType) {
+  const decorator = (target) => {
+    catchMetadataStore.set(target, {
+      exceptionType
+    });
+  };
+  return decorator;
+}
+function getClassFilters(target) {
+  return getFilterMetadata(target, "filters:class");
+}
+function getMethodFilters(target, propertyKey) {
+  const methodFilters = getFilterPrototypeMetadata(target, `filters:method:${String(propertyKey)}`);
+  if (methodFilters) {
+    return methodFilters;
+  }
+  return getFilterPrototypeMetadata(target, "filters:method");
+}
+function getCatchType(filter) {
+  if (typeof filter === "function" && filter.prototype !== undefined) {
+    const metadata = catchMetadataStore.get(filter);
+    return metadata?.exceptionType;
+  }
+  if (typeof filter === "object" && filter !== null && "catch" in filter) {
+    const constructor = filter.constructor;
+    const metadata = catchMetadataStore.get(constructor);
+    return metadata?.exceptionType;
+  }
+  return;
+}
+function canHandleException(filter, exception) {
+  const catchType = getCatchType(filter);
+  if (!catchType) {
+    return true;
+  }
+  return exception instanceof catchType;
+}
+function isExceptionFilter(value) {
+  return typeof value === "object" && value !== null && "catch" in value && typeof value.catch === "function";
+}
+function isFilterFn(value) {
+  return typeof value === "function" && value.length === 2;
+}
+async function executeFilter(filter, exception, context, resolveFilter) {
+  let filterInstance = null;
+  if (isExceptionFilter(filter)) {
+    filterInstance = filter;
+  } else if (isFilterFn(filter)) {
+    return filter(exception, context);
+  } else if (typeof filter === "function") {
+    if (resolveFilter) {
+      filterInstance = resolveFilter(filter);
+    }
+    if (!filterInstance) {
+      try {
+        const Constructor = filter;
+        filterInstance = new Constructor;
+      } catch {}
+    }
+  } else if (typeof filter === "object" && filter !== null && !isExceptionFilter(filter)) {
+    if (resolveFilter) {
+      filterInstance = resolveFilter(filter);
+    }
+  }
+  if (filterInstance && isExceptionFilter(filterInstance)) {
+    return filterInstance.catch(exception, context);
+  }
+  return createInternalErrorResponse(exception);
+}
+async function findAndExecuteFilter(exception, context, options) {
+  const { globalFilters, classFilters, methodFilters, resolveFilter } = options;
+  const allFilters = [...methodFilters, ...classFilters, ...globalFilters];
+  for (const filter of allFilters) {
+    if (canHandleException(filter, exception)) {
+      return executeFilter(filter, exception, context, resolveFilter);
+    }
+  }
+  return createDefaultErrorResponse(exception, context);
+}
+
+class HttpExceptionFilter {
+  catch(exception, context) {
+    return context.status(exception.statusCode).json({
+      error: exception.name,
+      message: exception.message,
+      code: exception.code,
+      statusCode: exception.statusCode
+    });
+  }
+}
+HttpExceptionFilter = __legacyDecorateClassTS([
+  Catch(BuenoError)
+], HttpExceptionFilter);
+
+class ValidationFilter {
+  catch(exception, context) {
+    return context.status(422).json({
+      error: "Validation Failed",
+      message: exception.message,
+      code: "VALIDATION_ERROR",
+      issues: exception.issues
+    });
+  }
+}
+ValidationFilter = __legacyDecorateClassTS([
+  Catch(ValidationError)
+], ValidationFilter);
+
+class NotFoundFilter {
+  catch(exception, context) {
+    return context.status(404).json({
+      error: "Not Found",
+      message: exception.message,
+      code: "NOT_FOUND"
+    });
+  }
+}
+NotFoundFilter = __legacyDecorateClassTS([
+  Catch(NotFoundError)
+], NotFoundFilter);
+
+class AllExceptionsFilter {
+  catch(exception, context) {
+    console.error("Unhandled exception:", exception);
+    if (exception instanceof BuenoError) {
+      return context.status(exception.statusCode).json({
+        error: exception.name,
+        message: exception.message,
+        code: exception.code
+      });
+    }
+    return context.status(500).json({
+      error: "Internal Server Error",
+      message: exception.message || "An unexpected error occurred"
+    });
+  }
+}
+function createDefaultErrorResponse(exception, context) {
+  console.error("Unhandled exception (no filter matched):", exception);
+  return context.status(500).json({
+    error: "Internal Server Error",
+    message: exception.message || "An unexpected error occurred"
+  });
+}
+function createInternalErrorResponse(exception) {
+  console.error("Internal server error:", exception);
+  return new Response(JSON.stringify({
+    error: "Internal Server Error",
+    message: "An unexpected error occurred"
+  }), {
+    status: 500,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+
+// src/modules/guards.ts
+var guardsClassMetadata = new WeakMap;
+var guardsMethodMetadata = new WeakMap;
+function setClassGuards(target, guards) {
+  guardsClassMetadata.set(target, guards);
+}
+function getClassGuards(target) {
+  return guardsClassMetadata.get(target);
+}
+function setMethodGuards(target, propertyKey, guards) {
+  if (!guardsMethodMetadata.has(target)) {
+    guardsMethodMetadata.set(target, new Map);
+  }
+  guardsMethodMetadata.get(target)?.set(propertyKey, guards);
+}
+function getMethodGuards(target, propertyKey) {
+  return guardsMethodMetadata.get(target)?.get(propertyKey);
+}
+function UseGuards(...guards) {
+  const decorator = (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined && descriptor !== undefined) {
+      const targetObj = target;
+      const existingGuards = getMethodGuards(targetObj, propertyKey) ?? [];
+      setMethodGuards(targetObj, propertyKey, [...existingGuards, ...guards]);
+      return descriptor;
+    } else {
+      const targetClass = target;
+      const existingGuards = getClassGuards(targetClass) ?? [];
+      setClassGuards(targetClass, [...existingGuards, ...guards]);
+    }
+  };
+  return decorator;
+}
+
+class AuthGuard {
+  canActivate(context) {
+    const authHeader = context.req.headers.get("Authorization");
+    return authHeader !== null && authHeader.length > 0;
+  }
+}
+var rolesMethodMetadata = new WeakMap;
+function setMethodRoles(target, propertyKey, roles) {
+  if (!rolesMethodMetadata.has(target)) {
+    rolesMethodMetadata.set(target, new Map);
+  }
+  rolesMethodMetadata.get(target)?.set(propertyKey, roles);
+}
+function getMethodRoles(target, propertyKey) {
+  return rolesMethodMetadata.get(target)?.get(propertyKey);
+}
+function Roles(...roles) {
+  return (target, propertyKey, descriptor) => {
+    const targetObj = target;
+    setMethodRoles(targetObj, propertyKey, roles);
+    return descriptor;
+  };
+}
+
+class RolesGuard {
+  canActivate(context) {
+    const requiredRoles = context.requiredRoles;
+    if (!requiredRoles || requiredRoles.length === 0) {
+      return true;
+    }
+    const user = context.user;
+    if (!user || !user.roles) {
+      return false;
+    }
+    return requiredRoles.some((role) => user.roles?.includes(role));
+  }
+}
+async function executeGuards(context, options) {
+  const {
+    globalGuards = [],
+    classGuards = [],
+    methodGuards = [],
+    resolveGuard
+  } = options;
+  const allGuards = [...globalGuards, ...classGuards, ...methodGuards];
+  for (const guard of allGuards) {
+    let guardInstance = null;
+    if (typeof guard === "function") {
+      const funcGuard = guard;
+      if (funcGuard.prototype && typeof funcGuard.prototype === "object" && "canActivate" in funcGuard.prototype) {
+        guardInstance = resolveGuard ? resolveGuard(guard) : null;
+        if (!guardInstance) {
+          const GuardClass = guard;
+          guardInstance = new GuardClass;
+        }
+      } else {
+        guardInstance = guard;
+      }
+    } else if (typeof guard === "object" && guard !== null) {
+      const objGuard = guard;
+      if ("canActivate" in objGuard && typeof objGuard.canActivate === "function") {
+        guardInstance = guard;
+      } else {
+        guardInstance = resolveGuard ? resolveGuard(guard) : null;
+      }
+    }
+    if (!guardInstance) {
+      console.warn("Guard could not be resolved:", guard);
+      continue;
+    }
+    let result;
+    if (typeof guardInstance === "function") {
+      result = await guardInstance(context);
+    } else {
+      result = await guardInstance.canActivate(context);
+    }
+    if (!result) {
+      return false;
+    }
+  }
+  return true;
+}
+function createForbiddenResponse() {
+  return new Response(JSON.stringify({
+    statusCode: 403,
+    error: "Forbidden",
+    message: "Access denied"
+  }), {
+    status: 403,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+
+// src/modules/interceptors.ts
+var interceptorsClassMetadata = new WeakMap;
+var interceptorsMethodMetadata = new WeakMap;
+function setClassInterceptors(target, interceptors) {
+  interceptorsClassMetadata.set(target, interceptors);
+}
+function getClassInterceptors(target) {
+  return interceptorsClassMetadata.get(target);
+}
+function setMethodInterceptors(target, propertyKey, interceptors) {
+  if (!interceptorsMethodMetadata.has(target)) {
+    interceptorsMethodMetadata.set(target, new Map);
+  }
+  interceptorsMethodMetadata.get(target)?.set(propertyKey, interceptors);
+}
+function getMethodInterceptors(target, propertyKey) {
+  return interceptorsMethodMetadata.get(target)?.get(propertyKey);
+}
+function UseInterceptors(...interceptors) {
+  const decorator = (target, propertyKey, descriptor) => {
+    if (propertyKey !== undefined && descriptor !== undefined) {
+      const targetObj = target;
+      const existingInterceptors = getMethodInterceptors(targetObj, propertyKey) ?? [];
+      setMethodInterceptors(targetObj, propertyKey, [
+        ...existingInterceptors,
+        ...interceptors
+      ]);
+      return descriptor;
+    } else {
+      const targetClass = target;
+      const existingInterceptors = getClassInterceptors(targetClass) ?? [];
+      setClassInterceptors(targetClass, [
+        ...existingInterceptors,
+        ...interceptors
+      ]);
+    }
+  };
+  return decorator;
+}
+
+class LoggingInterceptor {
+  async intercept(context, next) {
+    const method = context.method;
+    const path = context.path;
+    const startTime = Date.now();
+    console.log(`[${method}] ${path} - Started`);
+    try {
+      const result = await next.handle();
+      const duration = Date.now() - startTime;
+      console.log(`[${method}] ${path} - Completed in ${duration}ms`);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      console.error(`[${method}] ${path} - Failed in ${duration}ms`, error);
+      throw error;
+    }
+  }
+}
+
+class TransformInterceptor {
+  async intercept(context, next) {
+    const result = await next.handle();
+    return {
+      data: result,
+      timestamp: new Date().toISOString()
+    };
+  }
+}
+
+class TimeoutInterceptor {
+  timeoutMs;
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs;
+  }
+  async intercept(context, next) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => {
+        reject(new Error(`Request timeout after ${this.timeoutMs}ms`));
+      }, this.timeoutMs);
+    });
+    return Promise.race([next.handle(), timeoutPromise]);
+  }
+}
+
+class CacheInterceptor {
+  ttlMs;
+  static cache = new Map;
+  static cleanupInterval = null;
+  constructor(ttlMs = 60000) {
+    this.ttlMs = ttlMs;
+    CacheInterceptor.setupCleanup();
+  }
+  static setupCleanup() {
+    if (CacheInterceptor.cleanupInterval === null) {
+      CacheInterceptor.cleanupInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [key, entry] of CacheInterceptor.cache.entries()) {
+          if (entry.expiresAt < now) {
+            CacheInterceptor.cache.delete(key);
+          }
+        }
+      }, 60000);
+    }
+  }
+  getCacheKey(context) {
+    return `${context.method}:${context.path}:${context.url.search}`;
+  }
+  static clearCache() {
+    CacheInterceptor.cache.clear();
+  }
+  static clearCachePattern(pattern) {
+    for (const key of CacheInterceptor.cache.keys()) {
+      if (key.includes(pattern)) {
+        CacheInterceptor.cache.delete(key);
+      }
+    }
+  }
+  async intercept(context, next) {
+    const cacheKey = this.getCacheKey(context);
+    const now = Date.now();
+    const cached = CacheInterceptor.cache.get(cacheKey);
+    if (cached && cached.expiresAt > now) {
+      return cached.value;
+    }
+    const result = await next.handle();
+    CacheInterceptor.cache.set(cacheKey, {
+      value: result,
+      expiresAt: now + this.ttlMs
+    });
+    return result;
+  }
+}
+
+class HeaderInterceptor {
+  headers;
+  constructor(headers) {
+    this.headers = headers;
+  }
+  async intercept(context, next) {
+    const result = await next.handle();
+    if (result instanceof Response) {
+      const newHeaders = new Headers(result.headers);
+      for (const [key, value] of Object.entries(this.headers)) {
+        newHeaders.set(key, value);
+      }
+      return new Response(result.body, {
+        status: result.status,
+        statusText: result.statusText,
+        headers: newHeaders
+      });
+    }
+    return result;
+  }
+}
+function createCallHandler(interceptors, context, finalHandler, resolveInterceptor) {
+  let index = 0;
+  const execute = async () => {
+    if (index >= interceptors.length) {
+      return finalHandler();
+    }
+    const interceptor = interceptors[index++];
+    let interceptorInstance = interceptor;
+    if (resolveInterceptor && !isNestInterceptor(interceptor) && !isInterceptorFn(interceptor)) {
+      interceptorInstance = resolveInterceptor(interceptor);
+    }
+    if (!interceptorInstance) {
+      console.warn("Interceptor could not be resolved:", interceptor);
+      return execute();
+    }
+    const next = {
+      handle: () => execute()
+    };
+    if (isInterceptorFn(interceptorInstance)) {
+      return interceptorInstance(context, () => execute());
+    } else {
+      return interceptorInstance.intercept(context, next);
+    }
+  };
+  return {
+    handle: execute
+  };
+}
+async function executeInterceptors(context, handler, options) {
+  const {
+    globalInterceptors = [],
+    classInterceptors = [],
+    methodInterceptors = [],
+    resolveInterceptor
+  } = options;
+  const allInterceptors = [
+    ...globalInterceptors,
+    ...classInterceptors,
+    ...methodInterceptors
+  ];
+  if (allInterceptors.length === 0) {
+    return handler();
+  }
+  const resolvedInterceptors = [];
+  for (const interceptor of allInterceptors) {
+    let instance = null;
+    if (typeof interceptor === "function") {
+      const funcInterceptor = interceptor;
+      if (funcInterceptor.prototype && typeof funcInterceptor.prototype === "object" && "intercept" in funcInterceptor.prototype) {
+        instance = resolveInterceptor ? resolveInterceptor(interceptor) : null;
+        if (!instance) {
+          const InterceptorClass = interceptor;
+          instance = new InterceptorClass;
+        }
+      } else {
+        instance = interceptor;
+      }
+    } else if (typeof interceptor === "object" && interceptor !== null) {
+      const objInterceptor = interceptor;
+      if ("intercept" in objInterceptor && typeof objInterceptor.intercept === "function") {
+        instance = interceptor;
+      } else {
+        instance = resolveInterceptor ? resolveInterceptor(interceptor) : null;
+      }
+    }
+    if (instance) {
+      resolvedInterceptors.push(instance);
+    } else {
+      console.warn("Interceptor could not be resolved:", interceptor);
+    }
+  }
+  const callHandler = createCallHandler(resolvedInterceptors, context, handler, resolveInterceptor);
+  return callHandler.handle();
+}
+function isNestInterceptor(value) {
+  return typeof value === "object" && value !== null && "intercept" in value && typeof value.intercept === "function";
+}
+function isInterceptorFn(value) {
+  return typeof value === "function" && !isNestInterceptor(value);
+}
+
+// src/modules/metadata.ts
+var metadataStore = new WeakMap;
+function setMetadata(target, key, value) {
+  if (!metadataStore.has(target)) {
+    metadataStore.set(target, new Map);
+  }
+  metadataStore.get(target)?.set(key, value);
+}
+function getMetadata(target, key) {
+  return metadataStore.get(target)?.get(key);
+}
+var prototypeMetadataStore = new WeakMap;
+function setPrototypeMetadata(target, key, value) {
+  if (!prototypeMetadataStore.has(target)) {
+    prototypeMetadataStore.set(target, new Map);
+  }
+  prototypeMetadataStore.get(target)?.set(key, value);
+}
+function getPrototypeMetadata(target, key) {
+  return prototypeMetadataStore.get(target)?.get(key);
+}
+function Injectable2() {
+  return (target) => {
+    setMetadata(target, "injectable", true);
+    return target;
+  };
+}
+function Controller(path = "") {
+  return (target) => {
+    setMetadata(target, "controller", true);
+    setMetadata(target, "path", path);
+    return target;
+  };
+}
+function Module(metadata) {
+  return (target) => {
+    setMetadata(target, "module", metadata);
+    return target;
+  };
+}
+
+// src/modules/lazy.ts
+var lazyModuleMetadata = new WeakMap;
+function setLazyMetadata(target, metadata) {
+  lazyModuleMetadata.set(target, metadata);
+}
+function getLazyMetadata(target) {
+  return lazyModuleMetadata.get(target);
+}
+function isLazyModule(target) {
+  return lazyModuleMetadata.has(target);
+}
+
+class LazyModuleLoaderImpl {
+  loaded = false;
+  loadingPromise = null;
+  loader;
+  onModuleLoaded;
+  constructor(loader, onModuleLoaded) {
+    this.loader = loader;
+    this.onModuleLoaded = onModuleLoaded;
+  }
+  async load() {
+    if (this.loadingPromise) {
+      return this.loadingPromise;
+    }
+    if (this.loaded) {
+      return;
+    }
+    this.loadingPromise = this.doLoad();
+    await this.loadingPromise;
+    this.loadingPromise = null;
+  }
+  async doLoad() {
+    try {
+      const moduleClass = await this.loader();
+      this.loaded = true;
+      if (this.onModuleLoaded) {
+        await this.onModuleLoaded(moduleClass);
+      }
+    } catch (error) {
+      this.loadingPromise = null;
+      throw new Error(`Failed to load lazy module: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  isLoaded() {
+    return this.loaded;
+  }
+}
+function LazyModule(loader) {
+  return (target) => {
+    setLazyMetadata(target, {
+      loader,
+      loaded: false
+    });
+    return target;
+  };
+}
+var MODULE_LOADER_TOKEN = Symbol.for("ModuleLoader");
+
+class ModuleLoader {
+  container;
+  loadedModules = new Set;
+  moduleLoaders = new Map;
+  onModuleLoadCallback;
+  constructor(container) {
+    this.container = container;
+  }
+  setOnModuleLoadCallback(callback) {
+    this.onModuleLoadCallback = callback;
+  }
+  async load(moduleToken, options = {}) {
+    const moduleClass = typeof moduleToken === "function" ? moduleToken : null;
+    if (!moduleClass) {
+      throw new Error("Module token must be a class constructor");
+    }
+    if (this.isLoaded(moduleClass)) {
+      return;
+    }
+    const metadata = getLazyMetadata(moduleClass);
+    if (!metadata) {
+      throw new Error(`Module ${moduleClass.name} is not a lazy module. Use @LazyModule decorator.`);
+    }
+    let loader = this.moduleLoaders.get(moduleClass);
+    if (!loader) {
+      loader = new LazyModuleLoaderImpl(metadata.loader, async (loadedModule) => {
+        metadata.loaded = true;
+        metadata.loadedModule = loadedModule;
+        if (this.onModuleLoadCallback && !options.skipLifecycle) {
+          await this.onModuleLoadCallback(loadedModule);
+        }
+      });
+      this.moduleLoaders.set(moduleClass, loader);
+    }
+    await loader.load();
+    this.loadedModules.add(moduleClass);
+  }
+  isLoaded(moduleToken) {
+    if (typeof moduleToken === "function") {
+      const metadata = getLazyMetadata(moduleToken);
+      if (metadata) {
+        return metadata.loaded;
+      }
+      return this.loadedModules.has(moduleToken);
+    }
+    return this.loadedModules.has(moduleToken);
+  }
+  getLoadedModules() {
+    return Array.from(this.loadedModules);
+  }
+  async preload(moduleTokens) {
+    await Promise.all(moduleTokens.map((token) => this.load(token)));
+  }
+}
+ModuleLoader = __legacyDecorateClassTS([
+  Injectable2(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof Container === "undefined" ? Object : Container
+  ])
+], ModuleLoader);
+
+class LazyModuleRegistry {
+  static instance;
+  lazyModules = new Map;
+  constructor() {}
+  static getInstance() {
+    if (!LazyModuleRegistry.instance) {
+      LazyModuleRegistry.instance = new LazyModuleRegistry;
+    }
+    return LazyModuleRegistry.instance;
+  }
+  register(token, metadata) {
+    this.lazyModules.set(token, metadata);
+  }
+  get(token) {
+    return this.lazyModules.get(token);
+  }
+  has(token) {
+    return this.lazyModules.has(token);
+  }
+  getAllTokens() {
+    return Array.from(this.lazyModules.keys());
+  }
+  clear() {
+    this.lazyModules.clear();
+  }
+}
+function createLazyLoader(importFn, exportName = "default") {
+  return async () => {
+    const module = await importFn();
+    const moduleClass = module[exportName];
+    if (!moduleClass) {
+      throw new Error(`Export "${exportName}" not found in lazy loaded module`);
+    }
+    return moduleClass;
+  };
+}
+function areAllLazyModulesLoaded(modules) {
+  return modules.every((module) => {
+    const metadata = getLazyMetadata(module);
+    return !metadata || metadata.loaded;
+  });
+}
+function getUnloadedLazyModules(modules) {
+  return modules.filter((module) => {
+    const metadata = getLazyMetadata(module);
+    return metadata && !metadata.loaded;
+  });
+}
+
+// src/modules/lifecycle.ts
+function isOnModuleInit(instance) {
+  return typeof instance === "object" && instance !== null && "onModuleInit" in instance && typeof instance.onModuleInit === "function";
+}
+function isOnApplicationBootstrap(instance) {
+  return typeof instance === "object" && instance !== null && "onApplicationBootstrap" in instance && typeof instance.onApplicationBootstrap === "function";
+}
+function isOnModuleDestroy(instance) {
+  return typeof instance === "object" && instance !== null && "onModuleDestroy" in instance && typeof instance.onModuleDestroy === "function";
+}
+function isBeforeApplicationShutdown(instance) {
+  return typeof instance === "object" && instance !== null && "beforeApplicationShutdown" in instance && typeof instance.beforeApplicationShutdown === "function";
+}
+function isOnApplicationShutdown(instance) {
+  return typeof instance === "object" && instance !== null && "onApplicationShutdown" in instance && typeof instance.onApplicationShutdown === "function";
+}
+function isOnBeforeRequest(instance) {
+  return typeof instance === "object" && instance !== null && "onBeforeRequest" in instance && typeof instance.onBeforeRequest === "function";
+}
+function isOnAfterRequest(instance) {
+  return typeof instance === "object" && instance !== null && "onAfterRequest" in instance && typeof instance.onAfterRequest === "function";
+}
+function isOnRequestError(instance) {
+  return typeof instance === "object" && instance !== null && "onRequestError" in instance && typeof instance.onRequestError === "function";
+}
+
+class LifecycleHookManager {
+  instancesWithModuleInit = [];
+  instancesWithBootstrap = [];
+  instancesWithModuleDestroy = [];
+  instancesWithBeforeShutdown = [];
+  instancesWithShutdown = [];
+  instancesWithBeforeRequest = [];
+  instancesWithAfterRequest = [];
+  instancesWithRequestError = [];
+  registerInstance(instance) {
+    if (isOnModuleInit(instance)) {
+      this.instancesWithModuleInit.push(instance);
+    }
+    if (isOnApplicationBootstrap(instance)) {
+      this.instancesWithBootstrap.push(instance);
+    }
+    if (isOnModuleDestroy(instance)) {
+      this.instancesWithModuleDestroy.push(instance);
+    }
+    if (isBeforeApplicationShutdown(instance)) {
+      this.instancesWithBeforeShutdown.push(instance);
+    }
+    if (isOnApplicationShutdown(instance)) {
+      this.instancesWithShutdown.push(instance);
+    }
+    if (isOnBeforeRequest(instance)) {
+      this.instancesWithBeforeRequest.push(instance);
+    }
+    if (isOnAfterRequest(instance)) {
+      this.instancesWithAfterRequest.push(instance);
+    }
+    if (isOnRequestError(instance)) {
+      this.instancesWithRequestError.push(instance);
+    }
+  }
+  registerInstances(instances) {
+    for (const instance of instances) {
+      this.registerInstance(instance);
+    }
+  }
+  async executeOnModuleInit() {
+    for (const instance of this.instancesWithModuleInit) {
+      await instance.onModuleInit();
+    }
+  }
+  async executeOnApplicationBootstrap() {
+    for (const instance of this.instancesWithBootstrap) {
+      await instance.onApplicationBootstrap();
+    }
+  }
+  async executeBeforeApplicationShutdown(signal) {
+    for (const instance of this.instancesWithBeforeShutdown) {
+      await instance.beforeApplicationShutdown(signal);
+    }
+  }
+  async executeOnModuleDestroy() {
+    for (const instance of this.instancesWithModuleDestroy) {
+      await instance.onModuleDestroy();
+    }
+  }
+  async executeOnApplicationShutdown(signal) {
+    for (const instance of this.instancesWithShutdown) {
+      await instance.onApplicationShutdown(signal);
+    }
+  }
+  async executeOnBeforeRequest(context) {
+    for (const instance of this.instancesWithBeforeRequest) {
+      await instance.onBeforeRequest(context);
+    }
+  }
+  async executeOnAfterRequest(context, response) {
+    for (const instance of this.instancesWithAfterRequest) {
+      await instance.onAfterRequest(context, response);
+    }
+  }
+  async executeOnRequestError(context, error) {
+    for (const instance of this.instancesWithRequestError) {
+      await instance.onRequestError(context, error);
+    }
+  }
+  hasRegisteredHooks() {
+    return this.instancesWithModuleInit.length > 0 || this.instancesWithBootstrap.length > 0 || this.instancesWithModuleDestroy.length > 0 || this.instancesWithBeforeShutdown.length > 0 || this.instancesWithShutdown.length > 0 || this.instancesWithBeforeRequest.length > 0 || this.instancesWithAfterRequest.length > 0 || this.instancesWithRequestError.length > 0;
+  }
+  getHookCounts() {
+    return {
+      onModuleInit: this.instancesWithModuleInit.length,
+      onApplicationBootstrap: this.instancesWithBootstrap.length,
+      onModuleDestroy: this.instancesWithModuleDestroy.length,
+      beforeApplicationShutdown: this.instancesWithBeforeShutdown.length,
+      onApplicationShutdown: this.instancesWithShutdown.length,
+      onBeforeRequest: this.instancesWithBeforeRequest.length,
+      onAfterRequest: this.instancesWithAfterRequest.length,
+      onRequestError: this.instancesWithRequestError.length
+    };
+  }
+  clear() {
+    this.instancesWithModuleInit = [];
+    this.instancesWithBootstrap = [];
+    this.instancesWithModuleDestroy = [];
+    this.instancesWithBeforeShutdown = [];
+    this.instancesWithShutdown = [];
+    this.instancesWithBeforeRequest = [];
+    this.instancesWithAfterRequest = [];
+    this.instancesWithRequestError = [];
+  }
+}
+
+class ShutdownSignalHandler {
+  isShuttingDown = false;
+  signalListeners = [];
+  onSignal(listener) {
+    this.signalListeners.push(listener);
+  }
+  offSignal(listener) {
+    const index = this.signalListeners.indexOf(listener);
+    if (index > -1) {
+      this.signalListeners.splice(index, 1);
+    }
+  }
+  startListening() {
+    process.on("SIGTERM", () => this.handleSignal("SIGTERM"));
+    process.on("SIGINT", () => this.handleSignal("SIGINT"));
+  }
+  stopListening() {
+    process.off("SIGTERM", () => this.handleSignal("SIGTERM"));
+    process.off("SIGINT", () => this.handleSignal("SIGINT"));
+  }
+  async handleSignal(signal) {
+    if (this.isShuttingDown) {
+      console.log(`Already shutting down, ignoring ${signal}`);
+      return;
+    }
+    this.isShuttingDown = true;
+    console.log(`
+Received ${signal}, starting graceful shutdown...`);
+    for (const listener of this.signalListeners) {
+      try {
+        await listener(signal);
+      } catch (error) {
+        console.error("Error during shutdown:", error);
+      }
+    }
+    process.exit(0);
+  }
+  isShuttingDownNow() {
+    return this.isShuttingDown;
+  }
+}
+
+// src/modules/pipes.ts
+var pipesMethodMetadata = new WeakMap;
+function setMethodPipes(target, propertyKey, metadata) {
+  if (!pipesMethodMetadata.has(target)) {
+    pipesMethodMetadata.set(target, new Map);
+  }
+  pipesMethodMetadata.get(target)?.set(propertyKey, metadata);
+}
+function getMethodPipes(target, propertyKey) {
+  return pipesMethodMetadata.get(target)?.get(propertyKey);
+}
+function UsePipes(...pipes) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("UsePipes can only be used on method parameters");
+    }
+    const targetObj = target;
+    const existing = getMethodPipes(targetObj, propertyKey) ?? [];
+    const existingParam = existing.find((p) => p.index === parameterIndex);
+    if (existingParam) {
+      existingParam.pipes.push(...pipes);
+    } else {
+      existing.push({
+        index: parameterIndex,
+        decorator: "custom",
+        pipes: [...pipes]
+      });
+    }
+    setMethodPipes(targetObj, propertyKey, existing);
+  };
+}
+function Body(schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("Body can only be used on method parameters");
+    }
+    const targetObj = target;
+    const existing = getMethodPipes(targetObj, propertyKey) ?? [];
+    existing.push({
+      index: parameterIndex,
+      decorator: "body",
+      schema,
+      pipes: schema ? [new ValidationPipe(schema)] : []
+    });
+    setMethodPipes(targetObj, propertyKey, existing);
+  };
+}
+function Query(key, schema) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("Query can only be used on method parameters");
+    }
+    const targetObj = target;
+    const existing = getMethodPipes(targetObj, propertyKey) ?? [];
+    existing.push({
+      index: parameterIndex,
+      decorator: "query",
+      key,
+      schema,
+      pipes: schema ? [new ValidationPipe(schema)] : []
+    });
+    setMethodPipes(targetObj, propertyKey, existing);
+  };
+}
+function Param(key, ...pipes) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("Param can only be used on method parameters");
+    }
+    const targetObj = target;
+    const existing = getMethodPipes(targetObj, propertyKey) ?? [];
+    existing.push({
+      index: parameterIndex,
+      decorator: "param",
+      key,
+      pipes: [...pipes]
+    });
+    setMethodPipes(targetObj, propertyKey, existing);
+  };
+}
+
+class ValidationPipe {
+  schema;
+  constructor(schema) {
+    this.schema = schema;
+  }
+  async transform(value, context) {
+    const result = await validate(this.schema, value);
+    if (result.success) {
+      return result.data;
+    }
+    const failedResult = result;
+    const error = new Error("Validation failed");
+    error.issues = [...failedResult.issues];
+    throw error;
+  }
+}
+
+class ParseIntPipe {
+  transform(value, context) {
+    const parsed = Number.parseInt(value, 10);
+    if (isNaN(parsed)) {
+      throw new Error(`Validation failed: "${value}" is not a valid integer`);
+    }
+    return parsed;
+  }
+}
+
+class ParseFloatPipe {
+  transform(value, context) {
+    const parsed = Number.parseFloat(value);
+    if (isNaN(parsed)) {
+      throw new Error(`Validation failed: "${value}" is not a valid number`);
+    }
+    return parsed;
+  }
+}
+
+class ParseBoolPipe {
+  truthyValues = ["true", "1", "yes", "on"];
+  falsyValues = ["false", "0", "no", "off"];
+  transform(value, context) {
+    const lower = value.toLowerCase();
+    if (this.truthyValues.includes(lower)) {
+      return true;
+    }
+    if (this.falsyValues.includes(lower)) {
+      return false;
+    }
+    throw new Error(`Validation failed: "${value}" is not a valid boolean`);
+  }
+}
+
+class DefaultValuePipe {
+  defaultValue;
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
+  }
+  transform(value, context) {
+    if (value === undefined || value === null) {
+      return this.defaultValue;
+    }
+    return value;
+  }
+}
+
+class TrimPipe {
+  transform(value, context) {
+    if (typeof value !== "string") {
+      throw new Error("Value must be a string");
+    }
+    return value.trim();
+  }
+}
+
+class ParseJsonPipe {
+  transform(value, context) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      throw new Error(`Validation failed: "${value}" is not valid JSON`);
+    }
+  }
+}
+
+class ParseArrayPipe {
+  separator;
+  constructor(separator = ",") {
+    this.separator = separator;
+  }
+  transform(value, context) {
+    if (typeof value !== "string") {
+      throw new Error("Value must be a string");
+    }
+    return value.split(this.separator).map((s) => s.trim()).filter((s) => s.length > 0);
+  }
+}
+async function executePipes(value, context, options) {
+  const { globalPipes = [], parameterPipes = [], resolvePipe } = options;
+  const allPipes = [...globalPipes, ...parameterPipes];
+  let currentValue = value;
+  for (const pipe of allPipes) {
+    let pipeInstance = null;
+    if (typeof pipe === "function") {
+      const funcPipe = pipe;
+      if (funcPipe.prototype && typeof funcPipe.prototype === "object" && "transform" in funcPipe.prototype) {
+        pipeInstance = resolvePipe ? resolvePipe(pipe) : null;
+        if (!pipeInstance) {
+          const PipeClass = pipe;
+          pipeInstance = new PipeClass;
+        }
+      } else {
+        pipeInstance = pipe;
+      }
+    } else if (typeof pipe === "object" && pipe !== null) {
+      const objPipe = pipe;
+      if ("transform" in objPipe && typeof objPipe.transform === "function") {
+        pipeInstance = pipe;
+      } else {
+        pipeInstance = resolvePipe ? resolvePipe(pipe) : null;
+      }
+    }
+    if (!pipeInstance) {
+      console.warn("Pipe could not be resolved:", pipe);
+      continue;
+    }
+    if (typeof pipeInstance === "function") {
+      currentValue = await pipeInstance(currentValue, context);
+    } else {
+      currentValue = await pipeInstance.transform(currentValue, context);
+    }
+  }
+  return currentValue;
+}
+async function extractParameterValue(context, metadata) {
+  switch (metadata.decorator) {
+    case "body":
+      return await context.body();
+    case "query":
+      if (metadata.key) {
+        return context.query[metadata.key];
+      }
+      return context.query;
+    case "param":
+      if (metadata.key) {
+        return context.params[metadata.key];
+      }
+      return context.params;
+    case "custom":
+    default:
+      return;
+  }
+}
+function createBadRequestResponse(error) {
+  const issues = error.issues;
+  return new Response(JSON.stringify({
+    statusCode: 400,
+    error: "Bad Request",
+    message: error.message,
+    ...issues && { issues }
+  }), {
+    status: 400,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  });
+}
+function isPipeTransform(value) {
+  return typeof value === "object" && value !== null && "transform" in value && typeof value.transform === "function";
+}
+function isPipeFn(value) {
+  return typeof value === "function" && !isPipeTransform(value);
+}
+// src/modules/index.ts
+function Inject2(token) {
+  return (target, propertyKey, parameterIndex) => {
+    const targetObj = target;
+    const existingTokens = getContainerMetadata(targetObj, "inject:tokens") ?? [];
+    existingTokens[parameterIndex] = token;
+    setContainerMetadata(targetObj, "inject:tokens", existingTokens);
+  };
+}
+function createMethodDecorator(method) {
+  return (path = "") => {
+    return (target, propertyKey, descriptor) => {
+      const targetObj = target;
+      const routes = getPrototypeMetadata(targetObj, "routes") ?? [];
+      routes.push({
+        method,
+        path,
+        handler: propertyKey
+      });
+      setPrototypeMetadata(targetObj, "routes", routes);
+      return descriptor;
+    };
+  };
+}
+var Get = createMethodDecorator("GET");
+var Post = createMethodDecorator("POST");
+var Put = createMethodDecorator("PUT");
+var Patch = createMethodDecorator("PATCH");
+var Delete = createMethodDecorator("DELETE");
+var Head = createMethodDecorator("HEAD");
+var Options = createMethodDecorator("OPTIONS");
+
+class AppModule {
+  moduleClass;
+  metadata;
+  providers = [];
+  controllers = [];
+  visitedModules = new Set;
+  lazyModules = [];
+  constructor(moduleClass) {
+    this.moduleClass = moduleClass;
+    this.metadata = getMetadata(moduleClass, "module") ?? {};
+    this.processModule(moduleClass);
+  }
+  processModule(moduleClass) {
+    if (this.visitedModules.has(moduleClass)) {
+      return;
+    }
+    this.visitedModules.add(moduleClass);
+    if (isLazyModule(moduleClass)) {
+      this.lazyModules.push(moduleClass);
+      return;
+    }
+    const metadata = getMetadata(moduleClass, "module") ?? {};
+    if (metadata.imports) {
+      for (const importedModule of metadata.imports) {
+        this.processModule(importedModule);
+      }
+    }
+    if (metadata.providers) {
+      const normalizedProviders = metadata.providers.map((p) => {
+        if (typeof p === "function" && !p.token) {
+          return { token: p, useClass: p };
+        }
+        return p;
+      });
+      this.providers.push(...normalizedProviders);
+    }
+    if (metadata.controllers) {
+      this.controllers.push(...metadata.controllers);
+    }
+  }
+  getProviders() {
+    return [...this.providers];
+  }
+  getControllers() {
+    return [...this.controllers];
+  }
+  getLazyModules() {
+    return [...this.lazyModules];
+  }
+}
+
+class Application {
+  container;
+  router;
+  appModule;
+  lifecycleManager;
+  shutdownHandler;
+  server = null;
+  providerInstances = new Map;
+  controllerInstances = [];
+  isInitialized = false;
+  isShuttingDown = false;
+  globalGuards = [];
+  globalPipes = [];
+  globalFilters = [];
+  globalInterceptors = [];
+  routeGuardMetadata = new Map;
+  routePipeMetadata = new Map;
+  routeFilterMetadata = new Map;
+  routeInterceptorMetadata = new Map;
+  moduleLoader;
+  loadedLazyModules = new Set;
+  constructor(moduleClass) {
+    this.container = new Container2;
+    this.router = new Router;
+    this.appModule = new AppModule(moduleClass);
+    this.lifecycleManager = new LifecycleHookManager;
+    this.shutdownHandler = new ShutdownSignalHandler;
+    this.moduleLoader = new ModuleLoader(this.container);
+  }
+  useGlobalGuards(...guards) {
+    this.globalGuards.push(...guards);
+    return this;
+  }
+  useGlobalPipes(...pipes) {
+    this.globalPipes.push(...pipes);
+    return this;
+  }
+  useGlobalFilters(...filters) {
+    this.globalFilters.push(...filters);
+    return this;
+  }
+  useGlobalInterceptors(...interceptors) {
+    this.globalInterceptors.push(...interceptors);
+    return this;
+  }
+  registerProviders() {
+    const providers = this.appModule.getProviders();
+    this.container.registerAll(providers);
+  }
+  async resolveProviders() {
+    const providers = this.appModule.getProviders();
+    for (const provider of providers) {
+      const token = provider.token;
+      const instance = this.container.resolve(token);
+      this.providerInstances.set(token, instance);
+      this.lifecycleManager.registerInstance(instance);
+    }
+  }
+  registerControllers() {
+    const controllers = this.appModule.getControllers();
+    for (const controllerClass of controllers) {
+      const instance = this.registerController(controllerClass);
+      this.controllerInstances.push(instance);
+      this.lifecycleManager.registerInstance(instance);
+    }
+  }
+  registerController(controllerClass) {
+    const basePath = getMetadata(controllerClass, "path") ?? "";
+    const routes = getPrototypeMetadata(controllerClass.prototype, "routes") ?? [];
+    let injectTokens = getContainerMetadata(controllerClass, "inject:tokens") ?? [];
+    if (injectTokens.length === 0 && typeof Reflect !== "undefined" && typeof Reflect.getMetadata === "function") {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", controllerClass);
+      if (paramTypes) {
+        injectTokens = paramTypes.map((paramType) => paramType);
+      }
+    }
+    const deps = injectTokens.map((tokenOrRef) => {
+      const token = isForwardRef(tokenOrRef) ? resolveForwardRef(tokenOrRef) : tokenOrRef;
+      return this.container.resolve(token);
+    });
+    const instance = new controllerClass(...deps);
+    const classGuards = getClassGuards(controllerClass) ?? [];
+    const classInterceptors = getClassInterceptors(controllerClass) ?? [];
+    for (const route of routes) {
+      const fullPath = basePath + route.path;
+      const handler = instance[route.handler];
+      if (typeof handler === "function") {
+        const method = route.method.toLowerCase();
+        const routerMethod = method;
+        const methodGuards = getMethodGuards(controllerClass.prototype, route.handler) ?? [];
+        const parameterPipes = getMethodPipes(controllerClass.prototype, route.handler) ?? [];
+        const classFilters = getClassFilters(controllerClass) ?? [];
+        const methodFilters = getMethodFilters(controllerClass.prototype, route.handler) ?? [];
+        const methodInterceptors = getMethodInterceptors(controllerClass.prototype, route.handler) ?? [];
+        const routeKey = `${method.toUpperCase()}:${fullPath}`;
+        this.routeGuardMetadata.set(routeKey, {
+          controllerClass,
+          handlerName: route.handler,
+          classGuards,
+          methodGuards
+        });
+        if (parameterPipes.length > 0) {
+          this.routePipeMetadata.set(routeKey, {
+            controllerClass,
+            handlerName: route.handler,
+            parameterPipes
+          });
+        }
+        if (classFilters.length > 0 || methodFilters.length > 0) {
+          this.routeFilterMetadata.set(routeKey, {
+            controllerClass,
+            handlerName: route.handler,
+            classFilters,
+            methodFilters
+          });
+        }
+        if (classInterceptors.length > 0 || methodInterceptors.length > 0) {
+          this.routeInterceptorMetadata.set(routeKey, {
+            controllerClass,
+            handlerName: route.handler,
+            classInterceptors,
+            methodInterceptors
+          });
+        }
+        if (routerMethod in this.router && typeof this.router[routerMethod] === "function") {
+          this.router[routerMethod](fullPath, (context) => handler.call(instance, context));
+        }
+      }
+    }
+    return instance;
+  }
+  async init() {
+    if (this.isInitialized) {
+      return;
+    }
+    this.registerProviders();
+    this.container.register({
+      token: MODULE_LOADER_TOKEN,
+      useValue: this.moduleLoader
+    });
+    await this.resolveProviders();
+    await this.lifecycleManager.executeOnModuleInit();
+    this.registerControllers();
+    await this.lifecycleManager.executeOnApplicationBootstrap();
+    this.moduleLoader.setOnModuleLoadCallback(async (moduleClass) => {
+      await this.loadLazyModule(moduleClass);
+    });
+    this.isInitialized = true;
+  }
+  async loadLazyModule(moduleClass) {
+    if (this.loadedLazyModules.has(moduleClass)) {
+      return;
+    }
+    const metadata = getMetadata(moduleClass, "module") ?? {};
+    if (metadata.providers) {
+      for (const provider of metadata.providers) {
+        this.container.register(provider);
+        const instance = this.container.resolve(provider.token);
+        this.providerInstances.set(provider.token, instance);
+        this.lifecycleManager.registerInstance(instance);
+      }
+      await this.lifecycleManager.executeOnModuleInit();
+    }
+    if (metadata.controllers) {
+      for (const controllerClass of metadata.controllers) {
+        const instance = this.registerController(controllerClass);
+        this.controllerInstances.push(instance);
+        this.lifecycleManager.registerInstance(instance);
+      }
+    }
+    await this.lifecycleManager.executeOnApplicationBootstrap();
+    this.loadedLazyModules.add(moduleClass);
+  }
+  getModuleLoader() {
+    return this.moduleLoader;
+  }
+  setupShutdownHandlers() {
+    this.shutdownHandler.onSignal(async (signal) => {
+      await this.shutdown(signal);
+    });
+    this.shutdownHandler.startListening();
+  }
+  async shutdown(signal) {
+    if (this.isShuttingDown) {
+      return;
+    }
+    this.isShuttingDown = true;
+    console.log("Starting graceful shutdown...");
+    if (this.server) {
+      this.server.stop();
+      console.log("Server stopped accepting new connections");
+    }
+    await this.lifecycleManager.executeBeforeApplicationShutdown(signal);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    await this.lifecycleManager.executeOnModuleDestroy();
+    await this.lifecycleManager.executeOnApplicationShutdown(signal);
+    console.log("Graceful shutdown complete");
+  }
+  async listen(port = 3000, hostname = "localhost") {
+    await this.init();
+    this.setupShutdownHandlers();
+    const { Context: Context2 } = await Promise.resolve().then(() => exports_context);
+    const { compose: compose2 } = await Promise.resolve().then(() => exports_middleware);
+    this.server = Bun.serve({
+      port,
+      hostname,
+      fetch: async (request) => {
+        if (this.isShuttingDown) {
+          return new Response("Service Unavailable", { status: 503 });
+        }
+        const url = new URL(request.url);
+        const match = this.router.match(request.method, url.pathname);
+        if (!match) {
+          return new Response("Not Found", { status: 404 });
+        }
+        const context = new Context2(request, match.params);
+        try {
+          await this.lifecycleManager.executeOnBeforeRequest(context);
+        } catch (error) {
+          console.error("Error in onBeforeRequest hook:", error);
+        }
+        const routeKey = `${request.method}:${url.pathname}`;
+        const guardMetadata = this.routeGuardMetadata.get(routeKey);
+        if (guardMetadata || this.globalGuards.length > 0) {
+          const guardsPassed = await executeGuards(context, {
+            globalGuards: this.globalGuards,
+            classGuards: guardMetadata?.classGuards ?? [],
+            methodGuards: guardMetadata?.methodGuards ?? [],
+            resolveGuard: (guard) => {
+              if (typeof guard === "object" && guard !== null && !("canActivate" in guard)) {
+                try {
+                  return this.container.resolve(guard);
+                } catch {
+                  return null;
+                }
+              }
+              return null;
+            }
+          });
+          if (!guardsPassed) {
+            return createForbiddenResponse();
+          }
+        }
+        const interceptorMetadata = this.routeInterceptorMetadata.get(routeKey);
+        const executeHandler = async () => {
+          const pipeMetadata = this.routePipeMetadata.get(routeKey);
+          if (pipeMetadata || this.globalPipes.length > 0) {
+            try {
+              const params = pipeMetadata?.parameterPipes ?? [];
+              for (const paramMeta of params) {
+                const initialValue = await extractParameterValue(context, paramMeta);
+                const pipeContext = {
+                  context,
+                  metadata: {
+                    index: paramMeta.index,
+                    name: paramMeta.key,
+                    decorator: paramMeta.decorator
+                  }
+                };
+                const transformedValue = await executePipes(initialValue, pipeContext, {
+                  globalPipes: this.globalPipes,
+                  parameterPipes: paramMeta.pipes,
+                  resolvePipe: (pipe) => {
+                    if (typeof pipe === "object" && pipe !== null && !("transform" in pipe)) {
+                      try {
+                        return this.container.resolve(pipe);
+                      } catch {
+                        return null;
+                      }
+                    }
+                    return null;
+                  }
+                });
+                context.set(`pipe:param:${paramMeta.index}`, transformedValue);
+              }
+            } catch (error) {
+              if (error instanceof Error) {
+                return createBadRequestResponse(error);
+              }
+              return createBadRequestResponse(new Error("Pipe transformation failed"));
+            }
+          }
+          const pipeline = compose2(match.middleware ?? []);
+          return pipeline(context, match.handler);
+        };
+        try {
+          const response = await executeInterceptors(context, executeHandler, {
+            globalInterceptors: this.globalInterceptors,
+            classInterceptors: interceptorMetadata?.classInterceptors ?? [],
+            methodInterceptors: interceptorMetadata?.methodInterceptors ?? [],
+            resolveInterceptor: (interceptor) => {
+              if (typeof interceptor === "object" && interceptor !== null && !isNestInterceptor(interceptor) && !isInterceptorFn(interceptor)) {
+                try {
+                  return this.container.resolve(interceptor);
+                } catch {
+                  return null;
+                }
+              }
+              if (typeof interceptor === "function" && !isInterceptorFn(interceptor)) {
+                try {
+                  const Constructor = interceptor;
+                  const instance = new Constructor;
+                  if (isNestInterceptor(instance)) {
+                    return instance;
+                  }
+                } catch {}
+              }
+              return null;
+            }
+          });
+          try {
+            await this.lifecycleManager.executeOnAfterRequest(context, response);
+          } catch (error) {
+            console.error("Error in onAfterRequest hook:", error);
+          }
+          return response;
+        } catch (error) {
+          try {
+            await this.lifecycleManager.executeOnRequestError(context, error);
+          } catch (hookError) {
+            console.error("Error in onRequestError hook:", hookError);
+          }
+          return this.handleException(error, context, routeKey);
+        }
+      }
+    });
+    console.log(`Server running at http://${hostname}:${port}`);
+  }
+  async handle(request) {
+    const { Context: Context2 } = await Promise.resolve().then(() => exports_context);
+    const { compose: compose2 } = await Promise.resolve().then(() => exports_middleware);
+    const url = new URL(request.url);
+    const match = this.router.match(request.method, url.pathname);
+    if (!match) {
+      return new Response("Not Found", { status: 404 });
+    }
+    const context = new Context2(request, match.params);
+    const routeKey = `${request.method}:${url.pathname}`;
+    const guardMetadata = this.routeGuardMetadata.get(routeKey);
+    if (guardMetadata || this.globalGuards.length > 0) {
+      const guardsPassed = await executeGuards(context, {
+        globalGuards: this.globalGuards,
+        classGuards: guardMetadata?.classGuards ?? [],
+        methodGuards: guardMetadata?.methodGuards ?? [],
+        resolveGuard: (guard) => {
+          if (typeof guard === "object" && guard !== null && !("canActivate" in guard)) {
+            try {
+              return this.container.resolve(guard);
+            } catch {
+              return null;
+            }
+          }
+          return null;
+        }
+      });
+      if (!guardsPassed) {
+        return createForbiddenResponse();
+      }
+    }
+    const interceptorMetadata = this.routeInterceptorMetadata.get(routeKey);
+    const executeHandler = async () => {
+      const pipeMetadata = this.routePipeMetadata.get(routeKey);
+      if (pipeMetadata || this.globalPipes.length > 0) {
+        try {
+          const params = pipeMetadata?.parameterPipes ?? [];
+          for (const paramMeta of params) {
+            const initialValue = await extractParameterValue(context, paramMeta);
+            const pipeContext = {
+              context,
+              metadata: {
+                index: paramMeta.index,
+                name: paramMeta.key,
+                decorator: paramMeta.decorator
+              }
+            };
+            const transformedValue = await executePipes(initialValue, pipeContext, {
+              globalPipes: this.globalPipes,
+              parameterPipes: paramMeta.pipes,
+              resolvePipe: (pipe) => {
+                if (typeof pipe === "object" && pipe !== null && !("transform" in pipe)) {
+                  try {
+                    return this.container.resolve(pipe);
+                  } catch {
+                    return null;
+                  }
+                }
+                return null;
+              }
+            });
+            context.set(`pipe:param:${paramMeta.index}`, transformedValue);
+          }
+        } catch (error) {
+          if (error instanceof Error) {
+            return createBadRequestResponse(error);
+          }
+          return createBadRequestResponse(new Error("Pipe transformation failed"));
+        }
+      }
+      const pipeline = compose2(match.middleware ?? []);
+      return pipeline(context, match.handler);
+    };
+    try {
+      const response = await executeInterceptors(context, executeHandler, {
+        globalInterceptors: this.globalInterceptors,
+        classInterceptors: interceptorMetadata?.classInterceptors ?? [],
+        methodInterceptors: interceptorMetadata?.methodInterceptors ?? [],
+        resolveInterceptor: (interceptor) => {
+          if (typeof interceptor === "object" && interceptor !== null && !isNestInterceptor(interceptor) && !isInterceptorFn(interceptor)) {
+            try {
+              return this.container.resolve(interceptor);
+            } catch {
+              return null;
+            }
+          }
+          if (typeof interceptor === "function" && !isInterceptorFn(interceptor)) {
+            try {
+              const Constructor = interceptor;
+              const instance = new Constructor;
+              if (isNestInterceptor(instance)) {
+                return instance;
+              }
+            } catch {}
+          }
+          return null;
+        }
+      });
+      return response;
+    } catch (error) {
+      return this.handleException(error, context, routeKey);
+    }
+  }
+  getLifecycleManager() {
+    return this.lifecycleManager;
+  }
+  isShuttingDownNow() {
+    return this.isShuttingDown;
+  }
+  async handleException(exception, context, routeKey) {
+    const filterMetadata = this.routeFilterMetadata.get(routeKey);
+    return findAndExecuteFilter(exception, context, {
+      globalFilters: this.globalFilters,
+      classFilters: filterMetadata?.classFilters ?? [],
+      methodFilters: filterMetadata?.methodFilters ?? [],
+      resolveFilter: (filter) => {
+        if (typeof filter === "object" && filter !== null && !isExceptionFilter(filter)) {
+          try {
+            return this.container.resolve(filter);
+          } catch {
+            return null;
+          }
+        }
+        if (typeof filter === "function" && !isFilterFn(filter)) {
+          try {
+            const Constructor = filter;
+            const instance = new Constructor;
+            if (isExceptionFilter(instance)) {
+              return instance;
+            }
+          } catch {}
+        }
+        return null;
+      }
+    });
+  }
+}
+function createApp(moduleClass) {
+  return new Application(moduleClass);
+}
+export {
+  resolveForwardRef,
+  isPipeTransform,
+  isPipeFn,
+  isOnRequestError,
+  isOnModuleInit,
+  isOnModuleDestroy,
+  isOnBeforeRequest,
+  isOnApplicationShutdown,
+  isOnApplicationBootstrap,
+  isOnAfterRequest,
+  isNestInterceptor,
+  isLazyModule,
+  isInterceptorFn,
+  isForwardRef,
+  isFilterFn,
+  isExceptionFilter,
+  isBeforeApplicationShutdown,
+  getUnloadedLazyModules,
+  getMethodRoles,
+  getMethodPipes,
+  getMethodInterceptors,
+  getMethodGuards,
+  getMethodFilters,
+  getLazyMetadata,
+  getClassInterceptors,
+  getClassGuards,
+  getClassFilters,
+  getCatchType,
+  forwardRef,
+  findAndExecuteFilter,
+  extractParameterValue,
+  executePipes,
+  executeInterceptors,
+  executeGuards,
+  executeFilter,
+  createLazyLoader,
+  createInternalErrorResponse,
+  createForbiddenResponse,
+  createDefaultErrorResponse,
+  createBadRequestResponse,
+  createApp,
+  canHandleException,
+  areAllLazyModulesLoaded,
+  ValidationPipe,
+  ValidationFilter,
+  UsePipes,
+  UseInterceptors,
+  UseGuards,
+  UseFilters,
+  TrimPipe,
+  TransformInterceptor,
+  TimeoutInterceptor,
+  ShutdownSignalHandler,
+  RolesGuard,
+  Roles,
+  Query,
+  Put,
+  Post,
+  Patch,
+  ParseJsonPipe,
+  ParseIntPipe,
+  ParseFloatPipe,
+  ParseBoolPipe,
+  ParseArrayPipe,
+  Param,
+  Options,
+  NotFoundFilter,
+  ModuleLoader,
+  Module,
+  MODULE_LOADER_TOKEN,
+  LoggingInterceptor,
+  LifecycleHookManager,
+  LazyModuleRegistry,
+  LazyModuleLoaderImpl,
+  LazyModule,
+  Injectable2 as Injectable,
+  Inject2 as Inject,
+  HttpExceptionFilter,
+  HeaderInterceptor,
+  Head,
+  Get,
+  Delete,
+  DefaultValuePipe,
+  Controller,
+  Catch,
+  CacheInterceptor,
+  Body,
+  AuthGuard,
+  Application,
+  AppModule,
+  AllExceptionsFilter
+};