@dangao/bun-server 0.1.0

package/dist/index.js

@@ -0,0 +1,2118 @@
+// @bun
+// src/request/body-parser.ts
+class BodyParser {
+  static async parse(request) {
+    const contentType = request.headers.get("content-type") ?? "";
+    if (request.method === "GET" || request.method === "HEAD") {
+      return;
+    }
+    const contentLength = request.headers.get("content-length");
+    if (contentLength === "0") {
+      return;
+    }
+    try {
+      if (contentType.includes("application/json")) {
+        const result = await this.parseJSON(request);
+        return result;
+      }
+      if (contentType.includes("multipart/form-data")) {
+        return await this.parseFormData(request);
+      }
+      if (contentType.includes("application/x-www-form-urlencoded")) {
+        const result = await this.parseURLEncoded(request);
+        return result;
+      }
+      if (contentType.includes("text/")) {
+        return await this.parseText(request);
+      }
+      if (!contentType && !contentLength) {
+        try {
+          const text = await request.text();
+          if (!text || text.length === 0) {
+            return;
+          }
+          try {
+            return JSON.parse(text);
+          } catch {
+            return text;
+          }
+        } catch {
+          return;
+        }
+      }
+      const fallbackText = await request.text();
+      if (!fallbackText) {
+        return;
+      }
+      try {
+        return JSON.parse(fallbackText);
+      } catch {
+        return fallbackText;
+      }
+    } catch (error) {
+      return;
+    }
+  }
+  static async parseJSON(request) {
+    const text = await request.text();
+    if (!text) {
+      return;
+    }
+    return JSON.parse(text);
+  }
+  static async parseFormData(request) {
+    return await request.formData();
+  }
+  static async parseURLEncoded(request) {
+    const text = await request.text();
+    if (!text || text.length === 0) {
+      return;
+    }
+    const params = new URLSearchParams(text);
+    const result = {};
+    params.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  static async parseText(request) {
+    return await request.text();
+  }
+}
+
+// src/core/context.ts
+class Context {
+  request;
+  response;
+  url;
+  method;
+  path;
+  query;
+  params = {};
+  headers;
+  responseHeaders;
+  statusCode = 200;
+  files = [];
+  _body;
+  _bodyParsed = false;
+  constructor(request) {
+    this.request = request;
+    this.url = new URL(request.url);
+    this.method = request.method;
+    this.path = this.url.pathname;
+    this.query = this.url.searchParams;
+    this.headers = request.headers;
+    this.responseHeaders = new Headers;
+  }
+  async getBody() {
+    if (!this._bodyParsed) {
+      this._body = await BodyParser.parse(this.request);
+      this._bodyParsed = true;
+    }
+    return this._body;
+  }
+  get body() {
+    return this._body;
+  }
+  set body(body) {
+    this._body = body;
+    this._bodyParsed = true;
+  }
+  getQuery(key) {
+    return this.query.get(key);
+  }
+  getQueryAll() {
+    const result = {};
+    this.query.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  getParam(key) {
+    return this.params[key];
+  }
+  getHeader(key) {
+    return this.headers.get(key);
+  }
+  setHeader(key, value) {
+    this.responseHeaders.set(key, value);
+  }
+  setStatus(code) {
+    this.statusCode = code;
+  }
+  createResponse(body, init) {
+    const headers = new Headers(this.responseHeaders);
+    if (body !== undefined && body !== null) {
+      if (typeof body === "object" && !(body instanceof Response) && !(body instanceof ArrayBuffer)) {
+        headers.set("Content-Type", "application/json");
+        const jsonString = JSON.stringify(body);
+        return new Response(jsonString, {
+          status: this.statusCode,
+          headers,
+          ...init
+        });
+      }
+    }
+    return new Response(body, {
+      status: this.statusCode,
+      headers,
+      ...init
+    });
+  }
+}
+
+// src/core/server.ts
+import { LoggerManager } from "@dangao/logsmith";
+
+class BunServer {
+  server;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  start() {
+    if (this.server) {
+      throw new Error("Server is already running");
+    }
+    const logger = LoggerManager.getLogger();
+    this.server = Bun.serve({
+      port: this.options.port ?? 3000,
+      hostname: this.options.hostname,
+      fetch: (request, server) => {
+        const upgradeHeader = request.headers.get("upgrade");
+        if (this.options.websocketRegistry && upgradeHeader && upgradeHeader.toLowerCase() === "websocket") {
+          const url = new URL(request.url);
+          if (!this.options.websocketRegistry.hasGateway(url.pathname)) {
+            return new Response("WebSocket gateway not found", { status: 404 });
+          }
+          const upgraded = server.upgrade(request, {
+            data: { path: url.pathname }
+          });
+          if (upgraded) {
+            return;
+          }
+          return new Response("WebSocket upgrade failed", { status: 400 });
+        }
+        const context = new Context(request);
+        return this.options.fetch(context);
+      },
+      websocket: {
+        open: (ws) => {
+          this.options.websocketRegistry?.handleOpen(ws);
+        },
+        message: (ws, message) => {
+          this.options.websocketRegistry?.handleMessage(ws, message);
+        },
+        close: (ws, code, reason) => {
+          this.options.websocketRegistry?.handleClose(ws, code, reason);
+        }
+      }
+    });
+    const hostname = this.options.hostname ?? "localhost";
+    const port = this.options.port ?? 3000;
+    logger.info(`Server started at http://${hostname}:${port}`);
+  }
+  stop() {
+    if (this.server) {
+      const logger = LoggerManager.getLogger();
+      this.server.stop();
+      this.server = undefined;
+      logger.info("Server stopped");
+    }
+  }
+  getServer() {
+    return this.server;
+  }
+  isRunning() {
+    return this.server !== undefined;
+  }
+}
+
+// src/middleware/pipeline.ts
+class MiddlewarePipeline {
+  middlewares = [];
+  constructor(initialMiddlewares = []) {
+    this.middlewares.push(...initialMiddlewares);
+  }
+  use(middleware) {
+    this.middlewares.push(middleware);
+  }
+  clear() {
+    this.middlewares.length = 0;
+  }
+  hasMiddlewares() {
+    return this.middlewares.length > 0;
+  }
+  async run(context, finalHandler) {
+    const length = this.middlewares.length;
+    if (length === 0) {
+      return await finalHandler();
+    }
+    const called = new Array(length).fill(false);
+    const chain = new Array(length + 1);
+    chain[length] = finalHandler;
+    for (let i = length - 1;i >= 0; i--) {
+      const middleware = this.middlewares[i];
+      const downstream = chain[i + 1];
+      chain[i] = async () => {
+        if (called[i]) {
+          throw new Error("next() called multiple times");
+        }
+        called[i] = true;
+        return await middleware(context, downstream);
+      };
+    }
+    return await chain[0]();
+  }
+}
+
+// src/router/route.ts
+class Route {
+  method;
+  path;
+  handler;
+  pattern;
+  paramNames;
+  middlewarePipeline;
+  staticKey;
+  isStatic;
+  constructor(method, path, handler, middlewares = []) {
+    this.method = method;
+    this.path = path;
+    this.handler = handler;
+    const { pattern, paramNames } = this.parsePath(path);
+    this.pattern = pattern;
+    this.paramNames = paramNames;
+    this.middlewarePipeline = middlewares.length > 0 ? new MiddlewarePipeline(middlewares) : null;
+    this.isStatic = !path.includes(":") && !path.includes("*");
+    if (this.isStatic) {
+      this.staticKey = `${method}:${path}`;
+    }
+  }
+  parsePath(path) {
+    const paramNames = [];
+    const patternString = path.replace(/:([^/]+)/g, (_, paramName) => {
+      paramNames.push(paramName);
+      return "([^/]+)";
+    }).replace(/\*/g, ".*");
+    const pattern = new RegExp(`^${patternString}$`);
+    return { pattern, paramNames };
+  }
+  match(method, path) {
+    if (this.method !== method) {
+      return { matched: false, params: {} };
+    }
+    const match = path.match(this.pattern);
+    if (!match) {
+      return { matched: false, params: {} };
+    }
+    const params = {};
+    for (let i = 0;i < this.paramNames.length; i++) {
+      params[this.paramNames[i]] = match[i + 1] ?? "";
+    }
+    return { matched: true, params };
+  }
+  async execute(context) {
+    if (!this.middlewarePipeline || !this.middlewarePipeline.hasMiddlewares()) {
+      return await this.handler(context);
+    }
+    return await this.middlewarePipeline.run(context, async () => this.handler(context));
+  }
+  getStaticKey() {
+    return this.staticKey;
+  }
+}
+
+// src/router/router.ts
+class Router {
+  routes = [];
+  staticRoutes = new Map;
+  dynamicRoutes = [];
+  register(method, path, handler, middlewares = []) {
+    const route = new Route(method, path, handler, middlewares);
+    this.routes.push(route);
+    const staticKey = route.getStaticKey();
+    if (staticKey) {
+      this.staticRoutes.set(staticKey, route);
+    } else {
+      this.dynamicRoutes.push(route);
+    }
+  }
+  get(path, handler, middlewares = []) {
+    this.register("GET", path, handler, middlewares);
+  }
+  post(path, handler, middlewares = []) {
+    this.register("POST", path, handler, middlewares);
+  }
+  put(path, handler, middlewares = []) {
+    this.register("PUT", path, handler, middlewares);
+  }
+  delete(path, handler, middlewares = []) {
+    this.register("DELETE", path, handler, middlewares);
+  }
+  patch(path, handler, middlewares = []) {
+    this.register("PATCH", path, handler, middlewares);
+  }
+  findRoute(method, path) {
+    const staticRoute = this.staticRoutes.get(`${method}:${path}`);
+    if (staticRoute) {
+      return staticRoute;
+    }
+    for (const route of this.dynamicRoutes) {
+      const match = route.match(method, path);
+      if (match.matched) {
+        return route;
+      }
+    }
+    return;
+  }
+  async handle(context) {
+    const method = context.method;
+    const route = this.findRoute(method, context.path);
+    if (!route) {
+      return;
+    }
+    const match = route.match(method, context.path);
+    if (match.matched) {
+      context.params = match.params;
+    }
+    return await route.execute(context);
+  }
+  getRoutes() {
+    return this.routes;
+  }
+  clear() {
+    this.routes.length = 0;
+    this.dynamicRoutes.length = 0;
+    this.staticRoutes.clear();
+  }
+}
+
+// src/router/registry.ts
+class RouteRegistry {
+  static instance;
+  router;
+  constructor() {
+    this.router = new Router;
+  }
+  static getInstance() {
+    if (!RouteRegistry.instance) {
+      RouteRegistry.instance = new RouteRegistry;
+    }
+    return RouteRegistry.instance;
+  }
+  register(method, path, handler, middlewares = []) {
+    this.router.register(method, path, handler, middlewares);
+  }
+  get(path, handler, middlewares = []) {
+    this.router.get(path, handler, middlewares);
+  }
+  post(path, handler, middlewares = []) {
+    this.router.post(path, handler, middlewares);
+  }
+  put(path, handler, middlewares = []) {
+    this.router.put(path, handler, middlewares);
+  }
+  delete(path, handler, middlewares = []) {
+    this.router.delete(path, handler, middlewares);
+  }
+  patch(path, handler, middlewares = []) {
+    this.router.patch(path, handler, middlewares);
+  }
+  getRouter() {
+    return this.router;
+  }
+  clear() {
+    this.router.clear();
+  }
+}
+
+// src/controller/controller.ts
+import"reflect-metadata";
+
+// src/di/container.ts
+import"reflect-metadata";
+
+// src/di/types.ts
+var Lifecycle;
+((Lifecycle2) => {
+  Lifecycle2["Singleton"] = "singleton";
+  Lifecycle2["Transient"] = "transient";
+  Lifecycle2["Scoped"] = "scoped";
+})(Lifecycle ||= {});
+
+// src/di/decorators.ts
+import"reflect-metadata";
+import { LoggerManager as LoggerManager2 } from "@dangao/logsmith";
+var DEPENDENCY_METADATA_KEY = Symbol("dependency:metadata");
+var INJECTABLE_METADATA_KEY = Symbol("injectable");
+var typeReferenceMap = new WeakMap;
+function Injectable(config) {
+  return function(target) {
+    Reflect.defineMetadata(INJECTABLE_METADATA_KEY, true, target);
+    if (config?.lifecycle) {
+      Reflect.defineMetadata("lifecycle", config.lifecycle, target);
+    }
+  };
+}
+function Inject(token) {
+  return function(target, _propertyKey, parameterIndex) {
+    const logger = LoggerManager2.getLogger();
+    const constructor = typeof target === "function" ? target : target?.constructor;
+    if (!constructor) {
+      return;
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", constructor);
+    const paramType = paramTypes?.[parameterIndex];
+    let metadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor) || [];
+    const paramCount = paramTypes?.length || 0;
+    while (metadata.length < paramCount) {
+      metadata.push(undefined);
+    }
+    let dependencyType;
+    let dependencyToken;
+    if (token) {
+      if (typeof token === "string" || typeof token === "symbol") {
+        dependencyToken = token;
+        dependencyType = paramType || Object;
+      } else {
+        dependencyType = token;
+      }
+    } else {
+      if (!paramType) {
+        throw new Error(`Cannot determine dependency type for parameter ${parameterIndex} of ${constructor.name}. ` + "Please provide explicit type using @Inject(Type) or ensure emitDecoratorMetadata is enabled.");
+      }
+      dependencyType = paramType;
+    }
+    if (!typeReferenceMap.has(constructor)) {
+      typeReferenceMap.set(constructor, new Map);
+    }
+    const typeRefs = typeReferenceMap.get(constructor);
+    typeRefs.set(String(parameterIndex), dependencyType);
+    metadata[parameterIndex] = {
+      index: parameterIndex,
+      type: dependencyType,
+      token: dependencyToken
+    };
+    if (constructor.name === "Service" || constructor.name === "Level2") {
+      logger.debug(`[DI Debug] @Inject(${token ? typeof token === "function" ? token.name : String(token) : "auto"}) on ${constructor.name}[${parameterIndex}]: saving metadata.length=${metadata.length}`);
+    }
+    Reflect.defineMetadata(DEPENDENCY_METADATA_KEY, metadata, constructor);
+    if (constructor.name === "Service" || constructor.name === "Level2") {
+      const savedMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
+      logger.debug(`[DI Debug] @Inject on ${constructor.name}: saved metadata.exists=${savedMetadata ? "yes" : "no"}, length=${savedMetadata?.length || 0}`);
+    }
+  };
+}
+function getDependencyMetadata(target) {
+  const constructor = typeof target === "function" ? target : target?.constructor;
+  if (!constructor) {
+    return [];
+  }
+  const rawMetadata = Reflect.getMetadata(DEPENDENCY_METADATA_KEY, constructor);
+  const metadata = rawMetadata || [];
+  if (constructor.name === "Service" || constructor.name === "Level2") {
+    LoggerManager2.getLogger().debug(`[DI Debug] getDependencyMetadata(${constructor.name}): rawMetadata=${rawMetadata ? "exists" : "undefined"}, length=${metadata.length}`);
+  }
+  const typeRefs = typeReferenceMap.get(constructor);
+  if (typeRefs) {
+    for (let i = 0;i < metadata.length; i++) {
+      const meta = metadata[i];
+      if (meta !== undefined && meta !== null) {
+        const typeRef = typeRefs.get(String(meta.index));
+        if (typeRef && typeof typeRef === "function") {
+          meta.type = typeRef;
+        }
+      }
+    }
+  }
+  return metadata;
+}
+function getLifecycle(target) {
+  return Reflect.getMetadata("lifecycle", target);
+}
+function getTypeReference(constructor, parameterIndex) {
+  const typeRefs = typeReferenceMap.get(constructor);
+  if (typeRefs) {
+    return typeRefs.get(String(parameterIndex));
+  }
+  return;
+}
+
+// src/di/container.ts
+import { LoggerManager as LoggerManager3 } from "@dangao/logsmith";
+
+class Container {
+  parent;
+  constructor(options = {}) {
+    this.parent = options.parent;
+  }
+  providers = new Map;
+  singletons = new Map;
+  typeToToken = new Map;
+  dependencyPlans = new Map;
+  register(token, config) {
+    const tokenKey = this.getTokenKey(token);
+    let lifecycle = config?.lifecycle;
+    if (!lifecycle && typeof token === "function") {
+      lifecycle = getLifecycle(token);
+    }
+    const providerConfig = {
+      lifecycle: lifecycle || "singleton" /* Singleton */,
+      ...config
+    };
+    if (typeof token === "function" && !providerConfig.factory && !providerConfig.implementation) {
+      providerConfig.implementation = token;
+    }
+    this.providers.set(tokenKey, providerConfig);
+    if (typeof token === "function") {
+      this.typeToToken.set(token, tokenKey);
+    }
+  }
+  registerInstance(token, instance) {
+    const tokenKey = this.getTokenKey(token);
+    this.singletons.set(tokenKey, instance);
+    this.providers.set(tokenKey, {
+      lifecycle: "singleton" /* Singleton */
+    });
+  }
+  resolve(token) {
+    const tokenKey = this.getTokenKey(token);
+    const provider = this.providers.get(tokenKey);
+    if (!provider) {
+      if (this.parent) {
+        return this.parent.resolve(token);
+      }
+      if (typeof token === "function") {
+        const paramTypes = Reflect.getMetadata("design:paramtypes", token);
+        if (paramTypes && paramTypes.length > 0) {
+          throw new Error(`Provider not found for token: ${String(tokenKey)}`);
+        }
+        return new token;
+      }
+      throw new Error(`Provider not found for token: ${String(tokenKey)}`);
+    }
+    if (provider.lifecycle === "singleton" /* Singleton */) {
+      const singleton = this.singletons.get(tokenKey);
+      if (singleton) {
+        return singleton;
+      }
+    }
+    let instance;
+    if (provider.factory) {
+      instance = provider.factory();
+    } else if (typeof token === "function") {
+      instance = this.instantiate(token);
+    } else if (provider.implementation && typeof provider.implementation === "function") {
+      instance = this.instantiate(provider.implementation);
+    } else {
+      throw new Error(`Cannot instantiate token: ${String(tokenKey)}. Factory function required.`);
+    }
+    if (provider.lifecycle === "singleton" /* Singleton */) {
+      this.singletons.set(tokenKey, instance);
+    }
+    return instance;
+  }
+  resolveInternal(token) {
+    const tokenType = typeof token;
+    const tokenString = String(token);
+    const logger = LoggerManager3.getLogger();
+    if (tokenString.includes("Level2") || tokenString.includes("Dependency") || tokenString.includes("Service")) {
+      logger.debug(`[DI Debug] resolveInternal: token=${tokenString}, tokenType=${tokenType}`);
+    }
+    if (typeof token === "string" || typeof token === "symbol") {
+      const provider = this.providers.get(token);
+      if (!provider) {
+        if (this.parent) {
+          return this.parent.resolveInternal(token);
+        }
+        throw new Error(`Provider not found for token: ${String(token)}`);
+      }
+      if (provider.lifecycle === "singleton" /* Singleton */) {
+        const singleton = this.singletons.get(token);
+        if (singleton) {
+          return singleton;
+        }
+      }
+      if (provider.factory) {
+        const instance = provider.factory();
+        if (provider.lifecycle === "singleton" /* Singleton */) {
+          this.singletons.set(token, instance);
+        }
+        return instance;
+      }
+      if (provider.implementation && typeof provider.implementation === "function") {
+        const instance = this.instantiate(provider.implementation);
+        if (provider.lifecycle === "singleton" /* Singleton */) {
+          this.singletons.set(token, instance);
+        }
+        return instance;
+      }
+      throw new Error(`Cannot instantiate token: ${String(token)}. Factory function required.`);
+    }
+    if (typeof token === "function") {
+      return this.resolve(token);
+    }
+    throw new Error(`Invalid token type: ${tokenType}. Token: ${String(token)}`);
+  }
+  instantiate(constructor) {
+    const plan = this.getDependencyPlan(constructor);
+    if (plan.paramLength === 0) {
+      return new constructor;
+    }
+    const dependencies = new Array(plan.paramLength);
+    for (let index = 0;index < plan.paramLength; index++) {
+      dependencies[index] = this.resolveFromPlan(constructor, plan, index);
+    }
+    return new constructor(...dependencies);
+  }
+  getTokenKey(token) {
+    if (typeof token === "function") {
+      return token.name || Symbol(token.toString());
+    }
+    return token;
+  }
+  clear() {
+    this.providers.clear();
+    this.singletons.clear();
+    this.typeToToken.clear();
+    this.dependencyPlans.clear();
+  }
+  isRegistered(token) {
+    const tokenKey = this.getTokenKey(token);
+    return this.providers.has(tokenKey);
+  }
+  getDependencyPlan(constructor) {
+    let plan = this.dependencyPlans.get(constructor);
+    if (plan) {
+      return plan;
+    }
+    const paramTypes = Reflect.getMetadata("design:paramtypes", constructor) ?? [];
+    const dependencyMetadata = getDependencyMetadata(constructor);
+    const metadataMap = new Map;
+    let paramLength = paramTypes.length;
+    for (const meta of dependencyMetadata) {
+      if (meta && typeof meta.index === "number") {
+        metadataMap.set(meta.index, meta);
+        if (meta.index + 1 > paramLength) {
+          paramLength = meta.index + 1;
+        }
+      }
+    }
+    const resolvedTypes = new Map;
+    for (let i = 0;i < paramLength; i++) {
+      const typeRef = getTypeReference(constructor, i);
+      if (typeRef && typeof typeRef === "function") {
+        resolvedTypes.set(i, typeRef);
+      }
+    }
+    for (const [index, meta] of metadataMap.entries()) {
+      const depType = meta?.type;
+      if (typeof depType === "function") {
+        resolvedTypes.set(index, depType);
+      } else if (typeof depType === "string") {
+        const globalType = globalThis[depType];
+        if (typeof globalType === "function") {
+          resolvedTypes.set(index, globalType);
+        }
+      }
+    }
+    plan = {
+      paramTypes,
+      metadataMap,
+      resolvedTypes,
+      paramLength
+    };
+    this.dependencyPlans.set(constructor, plan);
+    return plan;
+  }
+  resolveFromPlan(constructor, plan, index) {
+    const meta = plan.metadataMap.get(index);
+    if (meta?.token) {
+      return this.resolveInternal(meta.token);
+    }
+    const resolvedType = plan.resolvedTypes.get(index);
+    if (resolvedType) {
+      return this.resolveInternal(resolvedType);
+    }
+    const paramType = plan.paramTypes[index];
+    if (paramType) {
+      const token = this.typeToToken.get(paramType);
+      if (token) {
+        return this.resolveInternal(token);
+      }
+      return this.resolveInternal(paramType);
+    }
+    throw new Error(`Cannot resolve dependency at index ${index} of ${constructor.name}. ` + "Parameter type is undefined. Use @Inject() decorator to specify the dependency type.");
+  }
+}
+
+// src/controller/decorators.ts
+import"reflect-metadata";
+var PARAM_METADATA_KEY = Symbol("param");
+function createParamDecorator(type, key) {
+  return function(target, propertyKey, parameterIndex) {
+    const existingParams = Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
+    existingParams.push({ type, key, index: parameterIndex });
+    Reflect.defineMetadata(PARAM_METADATA_KEY, existingParams, target, propertyKey);
+  };
+}
+function Body(key) {
+  return createParamDecorator("body" /* BODY */, key);
+}
+function Query(key) {
+  return createParamDecorator("query" /* QUERY */, key);
+}
+function Param(key) {
+  return createParamDecorator("param" /* PARAM */, key);
+}
+function Header(key) {
+  return createParamDecorator("header" /* HEADER */, key);
+}
+function getParamMetadata(target, propertyKey) {
+  return Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
+}
+
+// src/controller/param-binder.ts
+class ParamBinder {
+  static async bind(target, propertyKey, context) {
+    const metadata = getParamMetadata(target, propertyKey);
+    const params = [];
+    metadata.sort((a, b) => a.index - b.index);
+    for (const meta of metadata) {
+      const value = await this.getValue(meta, context);
+      params[meta.index] = value;
+    }
+    const maxIndex = metadata.length > 0 ? Math.max(...metadata.map((m) => m.index)) : -1;
+    for (let i = 0;i <= maxIndex; i++) {
+      if (!(i in params)) {
+        params[i] = undefined;
+      }
+    }
+    return params;
+  }
+  static async getValue(meta, context) {
+    switch (meta.type) {
+      case "body" /* BODY */:
+        return await this.getBodyValue(meta.key, context);
+      case "query" /* QUERY */:
+        if (!meta.key) {
+          throw new Error("@Query() decorator requires a key parameter");
+        }
+        return this.getQueryValue(meta.key, context);
+      case "param" /* PARAM */:
+        if (!meta.key) {
+          throw new Error("@Param() decorator requires a key parameter");
+        }
+        return this.getParamValue(meta.key, context);
+      case "header" /* HEADER */:
+        if (!meta.key) {
+          throw new Error("@Header() decorator requires a key parameter");
+        }
+        return this.getHeaderValue(meta.key, context);
+      default:
+        return;
+    }
+  }
+  static async getBodyValue(key, context) {
+    const body = await context.getBody();
+    if (!key) {
+      return body;
+    }
+    if (typeof body === "object" && body !== null) {
+      return body[key];
+    }
+    return;
+  }
+  static getQueryValue(key, context) {
+    return context.getQuery(key);
+  }
+  static getParamValue(key, context) {
+    return context.getParam(key);
+  }
+  static getHeaderValue(key, context) {
+    return context.getHeader(key);
+  }
+}
+
+// src/controller/metadata.ts
+import"reflect-metadata";
+
+// src/router/decorators.ts
+import"reflect-metadata";
+var ROUTE_METADATA_KEY = Symbol("route");
+function createRouteDecorator(method, path) {
+  return function(target, propertyKey, descriptor) {
+    const controllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA_KEY, target.constructor);
+    if (controllerMetadata) {
+      const existingRoutes = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+      let propertyKeyStr;
+      if (propertyKey && propertyKey !== "") {
+        propertyKeyStr = typeof propertyKey === "string" ? propertyKey : String(propertyKey);
+      } else {
+        propertyKeyStr = descriptor.value.name || "";
+      }
+      if (!propertyKeyStr) {
+        const propertyNames = Object.getOwnPropertyNames(target);
+        for (const key of propertyNames) {
+          const targetDescriptor = Object.getOwnPropertyDescriptor(target, key);
+          if (targetDescriptor?.value === descriptor.value) {
+            propertyKeyStr = key;
+            break;
+          }
+        }
+      }
+      existingRoutes.push({
+        method,
+        path,
+        handler: descriptor.value,
+        propertyKey: propertyKeyStr || undefined
+      });
+      Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
+    } else {
+      const handler = descriptor.value;
+      const registry = RouteRegistry.getInstance();
+      registry.register(method, path, handler);
+      const existingRoutes = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+      existingRoutes.push({ method, path, handler });
+      Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
+    }
+  };
+}
+function GET(path) {
+  return createRouteDecorator("GET", path);
+}
+function POST(path) {
+  return createRouteDecorator("POST", path);
+}
+function PUT(path) {
+  return createRouteDecorator("PUT", path);
+}
+function DELETE(path) {
+  return createRouteDecorator("DELETE", path);
+}
+function PATCH(path) {
+  return createRouteDecorator("PATCH", path);
+}
+
+// src/controller/metadata.ts
+function getControllerMetadata(target) {
+  return Reflect.getMetadata(CONTROLLER_METADATA_KEY, target);
+}
+function getRouteMetadata(target) {
+  return Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+}
+// src/middleware/decorators.ts
+import"reflect-metadata";
+var CLASS_MIDDLEWARE_METADATA_KEY = Symbol("middleware:class");
+var METHOD_MIDDLEWARE_METADATA_KEY = Symbol("middleware:method");
+function appendMiddlewareMetadata(target, propertyKey, middlewares) {
+  if (!middlewares.length) {
+    return;
+  }
+  if (propertyKey === undefined) {
+    const existing2 = Reflect.getMetadata(CLASS_MIDDLEWARE_METADATA_KEY, target) || [];
+    Reflect.defineMetadata(CLASS_MIDDLEWARE_METADATA_KEY, existing2.concat(middlewares), target);
+    return;
+  }
+  const existing = Reflect.getMetadata(METHOD_MIDDLEWARE_METADATA_KEY, target, propertyKey) || [];
+  Reflect.defineMetadata(METHOD_MIDDLEWARE_METADATA_KEY, existing.concat(middlewares), target, propertyKey);
+}
+function UseMiddleware(...middlewares) {
+  return function(target, propertyKey) {
+    appendMiddlewareMetadata(propertyKey === undefined ? target : target, propertyKey, middlewares);
+  };
+}
+function getClassMiddlewares(constructor) {
+  return Reflect.getMetadata(CLASS_MIDDLEWARE_METADATA_KEY, constructor) || [];
+}
+function getMethodMiddlewares(target, propertyKey) {
+  return Reflect.getMetadata(METHOD_MIDDLEWARE_METADATA_KEY, target, propertyKey) || [];
+}
+// src/middleware/builtin/logger.ts
+import { LoggerManager as LoggerManager4 } from "@dangao/logsmith";
+function createLoggerMiddleware(options = {}) {
+  const log = options.logger ?? ((message, details) => {
+    const logger = LoggerManager4.getLogger();
+    if (details) {
+      logger.info(message, details);
+    } else {
+      logger.info(message);
+    }
+  });
+  const prefix = options.prefix ?? "[Logger]";
+  return async (context, next) => {
+    let response;
+    try {
+      response = await next();
+      return response;
+    } finally {
+      const status = response?.status ?? context.statusCode ?? 200;
+      log(`${prefix} ${context.method} ${context.path} ${status}`);
+    }
+  };
+}
+function createRequestLoggingMiddleware(options = {}) {
+  const log = options.logger ?? ((message, details) => {
+    const logger = LoggerManager4.getLogger();
+    logger.info(message, details);
+  });
+  const prefix = options.prefix ?? "[Request]";
+  const setHeader = options.setHeader ?? true;
+  return async (context, next) => {
+    const start = performance.now();
+    try {
+      const response = await next();
+      const duration = performance.now() - start;
+      log(`${prefix} ${context.method} ${context.path} ${response.status} ${duration.toFixed(2)}ms`);
+      if (setHeader) {
+        context.setHeader("x-request-duration", duration.toFixed(2));
+      }
+      return response;
+    } catch (error) {
+      const duration = performance.now() - start;
+      log(`${prefix} ${context.method} ${context.path} error ${duration.toFixed(2)}ms`, error instanceof Error ? { error: error.message } : undefined);
+      throw error;
+    }
+  };
+}
+// src/validation/decorators.ts
+import"reflect-metadata";
+var VALIDATION_METADATA_KEY = Symbol("validation:param");
+function getOrCreateMetadata(target, propertyKey) {
+  const existing = Reflect.getMetadata(VALIDATION_METADATA_KEY, target, propertyKey);
+  if (existing) {
+    return existing;
+  }
+  const metadata = [];
+  Reflect.defineMetadata(VALIDATION_METADATA_KEY, metadata, target, propertyKey);
+  return metadata;
+}
+function Validate(...rules) {
+  return (target, propertyKey, parameterIndex) => {
+    if (!propertyKey) {
+      throw new Error("@Validate decorator can only be used on methods");
+    }
+    if (!rules.length) {
+      throw new Error("@Validate requires at least one validation rule");
+    }
+    const metadata = getOrCreateMetadata(target, propertyKey);
+    let entry = metadata.find((item) => item.index === parameterIndex);
+    if (!entry) {
+      entry = { index: parameterIndex, rules: [] };
+      metadata.push(entry);
+    }
+    entry.rules.push(...rules);
+  };
+}
+function IsString(options = {}) {
+  return {
+    name: "isString",
+    message: options.message ?? "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32",
+    validate: (value) => typeof value === "string"
+  };
+}
+function IsNumber(options = {}) {
+  return {
+    name: "isNumber",
+    message: options.message ?? "\u5FC5\u987B\u662F\u6570\u5B57",
+    validate: (value) => typeof value === "number" && !Number.isNaN(value)
+  };
+}
+function IsEmail(options = {}) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return {
+    name: "isEmail",
+    message: options.message ?? "\u5FC5\u987B\u662F\u5408\u6CD5\u7684\u90AE\u7BB1\u5730\u5740",
+    validate: (value) => typeof value === "string" && emailRegex.test(value)
+  };
+}
+function IsOptional() {
+  return {
+    name: "isOptional",
+    message: "",
+    optional: true,
+    validate: () => true
+  };
+}
+function MinLength(min, options = {}) {
+  return {
+    name: "minLength",
+    message: options.message ?? `\u957F\u5EA6\u4E0D\u80FD\u5C0F\u4E8E ${min}`,
+    validate: (value) => typeof value === "string" && value.length >= min
+  };
+}
+function getValidationMetadata(target, propertyKey) {
+  return Reflect.getMetadata(VALIDATION_METADATA_KEY, target, propertyKey) || [];
+}
+// src/validation/errors.ts
+class ValidationError extends Error {
+  issues;
+  constructor(message, issues) {
+    super(message);
+    this.name = "ValidationError";
+    this.issues = issues;
+  }
+}
+
+// src/validation/validator.ts
+function shouldSkip(rule, value) {
+  return rule.optional === true && (value === undefined || value === null);
+}
+function validateRule(rule, value, index) {
+  if (shouldSkip(rule, value)) {
+    return null;
+  }
+  const passed = rule.validate(value);
+  if (passed) {
+    return null;
+  }
+  return {
+    index,
+    rule: rule.name,
+    message: rule.message
+  };
+}
+function validateParameters(params, metadata) {
+  if (!metadata.length) {
+    return;
+  }
+  const issues = [];
+  for (const item of metadata) {
+    const value = params[item.index];
+    let skipped = false;
+    for (const rule of item.rules) {
+      if (rule.optional && (value === undefined || value === null)) {
+        skipped = true;
+        break;
+      }
+      const issue = validateRule(rule, value, item.index);
+      if (issue) {
+        issues.push(issue);
+      }
+    }
+    if (skipped) {
+      continue;
+    }
+  }
+  if (issues.length > 0) {
+    throw new ValidationError("Validation failed", issues);
+  }
+}
+// src/middleware/builtin/error-handler.ts
+import { LoggerManager as LoggerManager5 } from "@dangao/logsmith";
+
+// src/error/http-exception.ts
+class HttpException extends Error {
+  status;
+  details;
+  constructor(status, message, details) {
+    super(message);
+    this.name = this.constructor.name;
+    this.status = status;
+    this.details = details;
+  }
+}
+
+class BadRequestException extends HttpException {
+  constructor(message = "Bad Request", details) {
+    super(400, message, details);
+  }
+}
+
+class UnauthorizedException extends HttpException {
+  constructor(message = "Unauthorized", details) {
+    super(401, message, details);
+  }
+}
+
+class ForbiddenException extends HttpException {
+  constructor(message = "Forbidden", details) {
+    super(403, message, details);
+  }
+}
+
+class NotFoundException extends HttpException {
+  constructor(message = "Not Found", details) {
+    super(404, message, details);
+  }
+}
+
+class InternalServerErrorException extends HttpException {
+  constructor(message = "Internal Server Error", details) {
+    super(500, message, details);
+  }
+}
+// src/error/filter.ts
+class ExceptionFilterRegistry {
+  static instance;
+  filters = [];
+  constructor() {}
+  static getInstance() {
+    if (!ExceptionFilterRegistry.instance) {
+      ExceptionFilterRegistry.instance = new ExceptionFilterRegistry;
+    }
+    return ExceptionFilterRegistry.instance;
+  }
+  register(filter) {
+    this.filters.push(filter);
+  }
+  clear() {
+    this.filters.length = 0;
+  }
+  async execute(error, context) {
+    for (const filter of this.filters) {
+      const result = await filter.catch(error, context);
+      if (result) {
+        return result;
+      }
+    }
+    return;
+  }
+}
+// src/error/handler.ts
+async function handleError(error, context) {
+  const registry = ExceptionFilterRegistry.getInstance();
+  const filterResponse = await registry.execute(error, context);
+  if (filterResponse) {
+    return filterResponse;
+  }
+  if (error instanceof HttpException) {
+    context.setStatus(error.status);
+    return context.createResponse({
+      error: error.message,
+      details: error.details
+    });
+  }
+  if (error instanceof ValidationError) {
+    context.setStatus(400);
+    return context.createResponse({
+      error: error.message,
+      issues: error.issues
+    });
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  context.setStatus(500);
+  return context.createResponse({
+    error: "Internal Server Error",
+    details: message
+  });
+}
+// src/middleware/builtin/error-handler.ts
+function createErrorHandlingMiddleware(options = {}) {
+  const log = options.logger ?? ((error, context) => {
+    LoggerManager5.getLogger().error("[Error]", { ...context, error });
+  });
+  const expose = options.exposeError ?? false;
+  const defaultStatus = options.statusCode ?? 500;
+  return async (context, next) => {
+    const logger = LoggerManager5.getLogger();
+    try {
+      return await next();
+    } catch (error) {
+      log(error, { method: context.method, path: context.path });
+      logger.error("Unhandled error", {
+        method: context.method,
+        path: context.path,
+        error
+      });
+      if (error instanceof Response) {
+        return error;
+      }
+      if (error instanceof ValidationError) {
+        return context.createResponse({
+          error: error.message,
+          issues: error.issues
+        }, {
+          status: 400
+        });
+      }
+      if (error instanceof HttpException) {
+        if (!expose) {
+          return await handleError(error, context);
+        }
+        return context.createResponse({
+          error: error.message,
+          details: error.details
+        }, { status: error.status });
+      }
+      if (error instanceof Error && !expose) {
+        return await handleError(error, context);
+      }
+      if (error instanceof Error) {
+        return context.createResponse({
+          error: error.message
+        }, {
+          status: defaultStatus
+        });
+      }
+      return await handleError(error, context);
+    }
+  };
+}
+// src/middleware/builtin/cors.ts
+function getOriginHeader(option, requestOrigin) {
+  if (!option || option === "*") {
+    return "*";
+  }
+  if (Array.isArray(option)) {
+    if (requestOrigin && option.includes(requestOrigin)) {
+      return requestOrigin;
+    }
+    return option[0];
+  }
+  return option;
+}
+function createCorsMiddleware(options = {}) {
+  const methods = options.methods ?? ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"];
+  const allowedHeaders = options.allowedHeaders ?? ["Content-Type", "Authorization"];
+  const exposedHeaders = options.exposedHeaders ?? [];
+  const credentials = options.credentials ?? true;
+  const maxAge = options.maxAge ?? 600;
+  return async (context, next) => {
+    const requestOrigin = context.getHeader("Origin");
+    const originHeader = getOriginHeader(options.origin ?? "*", requestOrigin);
+    context.setHeader("Access-Control-Allow-Origin", originHeader);
+    if (credentials) {
+      context.setHeader("Access-Control-Allow-Credentials", "true");
+    }
+    context.setHeader("Access-Control-Allow-Methods", methods.join(","));
+    context.setHeader("Access-Control-Allow-Headers", allowedHeaders.join(","));
+    if (exposedHeaders.length > 0) {
+      context.setHeader("Access-Control-Expose-Headers", exposedHeaders.join(","));
+    }
+    context.setHeader("Access-Control-Max-Age", maxAge.toString());
+    if (context.method === "OPTIONS") {
+      return new Response(null, { status: 204, headers: context.responseHeaders });
+    }
+    return await next();
+  };
+}
+// src/request/file-handler.ts
+class FileHandler {
+  static MAX_SIZE = 10 * 1024 * 1024;
+  static async parseFormData(context) {
+    const contentType = context.getHeader("Content-Type");
+    if (!contentType || !contentType.includes("multipart/form-data")) {
+      throw new Error("Content-Type must be multipart/form-data");
+    }
+    const request = context.request;
+    return await request.formData();
+  }
+  static async getFiles(formData) {
+    const files = {};
+    for (const [key, value] of formData.entries()) {
+      if (value instanceof File) {
+        const buffer = await value.arrayBuffer();
+        if (buffer.byteLength > this.MAX_SIZE) {
+          throw new Error(`File ${value.name} exceeds maximum size`);
+        }
+        if (!files[key]) {
+          files[key] = [];
+        }
+        files[key].push({
+          name: value.name,
+          type: value.type,
+          size: value.size,
+          data: buffer
+        });
+      }
+    }
+    return files;
+  }
+}
+
+// src/middleware/builtin/file-upload.ts
+function createFileUploadMiddleware(options = {}) {
+  const maxSize = options.maxSize ?? 10 * 1024 * 1024;
+  return async (context, next) => {
+    const contentType = context.getHeader("Content-Type");
+    if (!contentType || !contentType.includes("multipart/form-data")) {
+      return await next();
+    }
+    const formData = await FileHandler.parseFormData(context);
+    const files = await FileHandler.getFiles(formData);
+    for (const fileList of Object.values(files)) {
+      for (const file of fileList) {
+        if (file.size > maxSize) {
+          context.setStatus(413);
+          return context.createResponse({ error: `File ${file.name} exceeds max size` });
+        }
+      }
+    }
+    context.body = {
+      fields: Object.fromEntries(formData.entries()),
+      files
+    };
+    return await next();
+  };
+}
+// src/middleware/builtin/static-file.ts
+import { normalize, resolve, sep } from "path";
+function isSubPath(root, target) {
+  const normalizedRoot = normalize(root);
+  const normalizedTarget = normalize(target);
+  if (normalizedRoot === normalizedTarget) {
+    return true;
+  }
+  const rootWithSep = normalizedRoot.endsWith(sep) ? normalizedRoot : normalizedRoot + sep;
+  return normalizedTarget.startsWith(rootWithSep);
+}
+function createStaticFileMiddleware(options) {
+  if (!options.root) {
+    throw new Error("Static file middleware requires a root directory");
+  }
+  const root = resolve(options.root);
+  const prefix = options.prefix ?? "/";
+  const indexFile = options.indexFile ?? "index.html";
+  const enableCache = options.enableCache ?? true;
+  return async (context, next) => {
+    if (!context.path.startsWith(prefix)) {
+      return await next();
+    }
+    let relativePath = context.path.slice(prefix.length);
+    if (!relativePath || relativePath === "") {
+      relativePath = "/";
+    }
+    let cleanPath = relativePath.startsWith("/") ? relativePath.slice(1) : relativePath;
+    if (cleanPath === "") {
+      cleanPath = ".";
+    }
+    const segments = cleanPath.split("/").filter((segment) => segment.length > 0);
+    if (segments.some((segment) => segment === "..")) {
+      context.setStatus(403);
+      return context.createResponse({ error: "Forbidden" });
+    }
+    let targetPath = resolve(root, cleanPath);
+    if (context.path.endsWith("/") || relativePath === "/") {
+      targetPath = resolve(root, cleanPath, indexFile);
+    }
+    if (!isSubPath(root, targetPath)) {
+      context.setStatus(403);
+      return context.createResponse({ error: "Forbidden" });
+    }
+    const file = Bun.file(targetPath);
+    if (!await file.exists()) {
+      return await next();
+    }
+    const headers = new Headers(options.headers);
+    if (enableCache) {
+      headers.set("Cache-Control", "public, max-age=31536000, immutable");
+    }
+    if (!headers.has("Content-Type") && file.type) {
+      headers.set("Content-Type", file.type);
+    }
+    return new Response(file, {
+      status: 200,
+      headers
+    });
+  };
+}
+// src/controller/controller.ts
+var CONTROLLER_METADATA_KEY = Symbol("controller");
+function Controller(path = "") {
+  return function(target) {
+    Reflect.defineMetadata(CONTROLLER_METADATA_KEY, { path, target }, target);
+  };
+}
+
+class ControllerRegistry {
+  static instance;
+  container;
+  controllers = new Map;
+  controllerContainers = new Map;
+  constructor() {
+    this.container = new Container;
+  }
+  static getInstance() {
+    if (!ControllerRegistry.instance) {
+      ControllerRegistry.instance = new ControllerRegistry;
+    }
+    return ControllerRegistry.instance;
+  }
+  register(controllerClass, container) {
+    const targetContainer = container ?? this.container;
+    this.controllerContainers.set(controllerClass, targetContainer);
+    if (!targetContainer.isRegistered(controllerClass)) {
+      targetContainer.register(controllerClass);
+    }
+    const metadata = getControllerMetadata(controllerClass);
+    if (!metadata) {
+      throw new Error(`Controller ${controllerClass.name} must be decorated with @Controller()`);
+    }
+    const prototype = controllerClass.prototype;
+    const routes = getRouteMetadata(prototype);
+    if (!routes || routes.length === 0) {
+      return;
+    }
+    const classMiddlewares = getClassMiddlewares(controllerClass);
+    const basePath = metadata.path;
+    const registry = RouteRegistry.getInstance();
+    for (const route of routes) {
+      const fullPath = this.combinePaths(basePath, route.path);
+      let propertyKey = route.propertyKey;
+      if (!propertyKey) {
+        const prototype2 = controllerClass.prototype;
+        const propertyNames = Object.getOwnPropertyNames(prototype2);
+        for (const key of propertyNames) {
+          if (key === "constructor")
+            continue;
+          const descriptor = Object.getOwnPropertyDescriptor(prototype2, key);
+          if (descriptor && descriptor.value === route.handler) {
+            propertyKey = key;
+            break;
+          }
+        }
+      }
+      if (!propertyKey) {
+        continue;
+      }
+      const handler = async (context) => {
+        try {
+          const controllerContainer = this.controllerContainers.get(controllerClass) ?? this.container;
+          const controllerInstance = controllerContainer.resolve(controllerClass);
+          const prototype2 = controllerClass.prototype;
+          const params = await ParamBinder.bind(prototype2, propertyKey, context);
+          const validationMetadata = getValidationMetadata(prototype2, propertyKey);
+          if (validationMetadata.length > 0) {
+            validateParameters(params, validationMetadata);
+          }
+          let method = controllerInstance[propertyKey];
+          if (!method || typeof method !== "function") {
+            const prototype3 = controllerClass.prototype;
+            method = prototype3[propertyKey];
+          }
+          if (!method || typeof method !== "function") {
+            throw new Error(`Method ${propertyKey} not found on controller ${controllerClass.name}`);
+          }
+          const result = method.apply(controllerInstance, params);
+          const responseData = await Promise.resolve(result);
+          return context.createResponse(responseData);
+        } catch (error) {
+          if (error instanceof ValidationError) {
+            context.setStatus(400);
+            return context.createResponse({
+              error: error.message,
+              issues: error.issues
+            });
+          }
+          if (error instanceof HttpException) {
+            context.setStatus(error.status);
+            return context.createResponse({
+              error: error.message,
+              details: error.details
+            });
+          }
+          context.setStatus(500);
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          return context.createResponse({ error: errorMessage });
+        }
+      };
+      const middlewares = [...classMiddlewares];
+      if (propertyKey) {
+        middlewares.push(...getMethodMiddlewares(prototype, propertyKey));
+      }
+      registry.register(route.method, fullPath, handler, middlewares);
+    }
+  }
+  combinePaths(basePath, methodPath) {
+    const base = basePath.replace(/\/$/, "").replace(/^\/?/, "/");
+    const method = methodPath.replace(/^\//, "");
+    if (!method) {
+      return base === "/" ? "/" : base;
+    }
+    return base + "/" + method;
+  }
+  getContainer() {
+    return this.container;
+  }
+  clear() {
+    this.controllers.clear();
+    this.container.clear();
+    this.controllerContainers.clear();
+  }
+}
+
+// src/websocket/decorators.ts
+import"reflect-metadata";
+var GATEWAY_METADATA_KEY = Symbol("websocket:gateway");
+var HANDLER_METADATA_KEY = Symbol("websocket:handlers");
+function WebSocketGateway(path) {
+  return (target) => {
+    Reflect.defineMetadata(GATEWAY_METADATA_KEY, { path }, target);
+  };
+}
+function createHandlerDecorator(type) {
+  return function(target, propertyKey) {
+    if (typeof propertyKey !== "string") {
+      throw new Error("@OnOpen/@OnMessage/@OnClose only support string method names");
+    }
+    const existing = Reflect.getMetadata(HANDLER_METADATA_KEY, target) || {};
+    existing[type] = propertyKey;
+    Reflect.defineMetadata(HANDLER_METADATA_KEY, existing, target);
+  };
+}
+var OnOpen = createHandlerDecorator("open");
+var OnMessage = createHandlerDecorator("message");
+var OnClose = createHandlerDecorator("close");
+function getGatewayMetadata(constructor) {
+  return Reflect.getMetadata(GATEWAY_METADATA_KEY, constructor);
+}
+function getHandlerMetadata(target) {
+  return Reflect.getMetadata(HANDLER_METADATA_KEY, target) || {};
+}
+
+// src/websocket/registry.ts
+class WebSocketGatewayRegistry {
+  static instance;
+  container;
+  gateways = new Map;
+  constructor() {
+    this.container = ControllerRegistry.getInstance().getContainer();
+  }
+  static getInstance() {
+    if (!WebSocketGatewayRegistry.instance) {
+      WebSocketGatewayRegistry.instance = new WebSocketGatewayRegistry;
+    }
+    return WebSocketGatewayRegistry.instance;
+  }
+  register(gatewayClass) {
+    const metadata = getGatewayMetadata(gatewayClass);
+    if (!metadata) {
+      throw new Error(`WebSocket gateway ${gatewayClass.name} must use @WebSocketGateway()`);
+    }
+    const handlers = getHandlerMetadata(gatewayClass.prototype);
+    if (!handlers.open && !handlers.message && !handlers.close) {
+      throw new Error(`WebSocket gateway ${gatewayClass.name} must define at least one handler`);
+    }
+    if (!this.container.isRegistered(gatewayClass)) {
+      this.container.register(gatewayClass);
+    }
+    this.gateways.set(metadata.path, {
+      path: metadata.path,
+      gatewayClass,
+      handlers
+    });
+  }
+  hasGateway(path) {
+    return this.gateways.has(path);
+  }
+  clear() {
+    this.gateways.clear();
+  }
+  getGateway(path) {
+    return this.gateways.get(path);
+  }
+  getGatewayInstance(definition) {
+    if (!definition.instance) {
+      definition.instance = this.container.resolve(definition.gatewayClass);
+    }
+    return definition.instance;
+  }
+  invokeHandler(ws, definition, handlerName, ...args) {
+    if (!handlerName) {
+      return;
+    }
+    const instance = this.getGatewayInstance(definition);
+    const handler = instance[handlerName];
+    if (typeof handler === "function") {
+      handler.apply(instance, [ws, ...args]);
+    }
+  }
+  handleOpen(ws) {
+    const path = ws.data?.path;
+    const definition = path ? this.getGateway(path) : undefined;
+    if (!definition) {
+      ws.close(1008, "Gateway not found");
+      return;
+    }
+    this.invokeHandler(ws, definition, definition.handlers.open);
+  }
+  handleMessage(ws, message) {
+    const path = ws.data?.path;
+    const definition = path ? this.getGateway(path) : undefined;
+    if (!definition) {
+      ws.close(1008, "Gateway not found");
+      return;
+    }
+    this.invokeHandler(ws, definition, definition.handlers.message, message);
+  }
+  handleClose(ws, code, reason) {
+    const path = ws.data?.path;
+    const definition = path ? this.getGateway(path) : undefined;
+    if (!definition) {
+      return;
+    }
+    this.invokeHandler(ws, definition, definition.handlers.close, code, reason);
+  }
+}
+
+// src/extensions/logger-extension.ts
+import {
+  LoggerManager as LoggerManager6,
+  LogLevel,
+  SimpleLogger
+} from "@dangao/logsmith";
+var LOGGER_TOKEN = Symbol("@dangao/bun-server:logger");
+
+class LoggerExtension {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      level: LogLevel.INFO,
+      ...options
+    };
+  }
+  register(container) {
+    const logger = new SimpleLogger(this.options);
+    LoggerManager6.setLogger(logger);
+    container.registerInstance(SimpleLogger, logger);
+    container.registerInstance(LOGGER_TOKEN, logger);
+  }
+}
+
+// src/di/module.ts
+import"reflect-metadata";
+var MODULE_METADATA_KEY = Symbol("@dangao/bun-server:module");
+function Module(metadata) {
+  return (target) => {
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, target);
+  };
+}
+function getModuleMetadata(moduleClass) {
+  const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, moduleClass) ?? {};
+  return {
+    imports: metadata.imports ?? [],
+    controllers: metadata.controllers ?? [],
+    providers: metadata.providers ?? [],
+    exports: metadata.exports ?? []
+  };
+}
+
+// src/di/module-registry.ts
+class ModuleRegistry {
+  static instance;
+  moduleRefs = new Map;
+  processing = new Set;
+  rootContainer;
+  static getInstance() {
+    if (!ModuleRegistry.instance) {
+      ModuleRegistry.instance = new ModuleRegistry;
+    }
+    return ModuleRegistry.instance;
+  }
+  register(moduleClass, parentContainer) {
+    if (!this.rootContainer) {
+      this.rootContainer = parentContainer;
+    }
+    return this.processModule(moduleClass, parentContainer);
+  }
+  getModuleRef(moduleClass) {
+    return this.moduleRefs.get(moduleClass);
+  }
+  clear() {
+    this.moduleRefs.clear();
+    this.processing.clear();
+    this.rootContainer = undefined;
+  }
+  processModule(moduleClass, parentContainer) {
+    if (this.processing.has(moduleClass)) {
+      throw new Error(`Circular module dependency detected for ${moduleClass.name}`);
+    }
+    const moduleRef = this.getOrCreateModuleRef(moduleClass);
+    this.processing.add(moduleClass);
+    for (const imported of moduleRef.metadata.imports) {
+      this.processModule(imported, moduleRef.container);
+    }
+    this.processing.delete(moduleClass);
+    this.attachModuleToParent(moduleRef, parentContainer);
+    return moduleRef;
+  }
+  getOrCreateModuleRef(moduleClass) {
+    let ref = this.moduleRefs.get(moduleClass);
+    if (ref) {
+      return ref;
+    }
+    if (!this.rootContainer) {
+      throw new Error("ModuleRegistry is not initialized with a root container");
+    }
+    const metadata = getModuleMetadata(moduleClass);
+    const container = new Container({ parent: this.rootContainer });
+    this.registerProviders(container, metadata.providers);
+    ref = {
+      moduleClass,
+      metadata,
+      container,
+      controllersRegistered: false,
+      attachedParents: new Set
+    };
+    this.registerControllers(ref);
+    this.moduleRefs.set(moduleClass, ref);
+    return ref;
+  }
+  registerProviders(container, providers) {
+    for (const provider of providers) {
+      if (typeof provider === "function") {
+        if (!container.isRegistered(provider)) {
+          container.register(provider);
+        }
+        continue;
+      }
+      if ("useValue" in provider) {
+        container.registerInstance(provider.provide, provider.useValue);
+        continue;
+      }
+      if ("useFactory" in provider) {
+        container.register(provider.provide, {
+          lifecycle: provider.lifecycle ?? "singleton" /* Singleton */,
+          factory: () => provider.useFactory(container)
+        });
+        continue;
+      }
+      if ("useClass" in provider) {
+        const token = provider.provide ?? provider.useClass;
+        container.register(token, {
+          lifecycle: provider.lifecycle ?? "singleton" /* Singleton */,
+          implementation: provider.useClass
+        });
+      }
+    }
+  }
+  registerControllers(moduleRef) {
+    if (moduleRef.controllersRegistered) {
+      return;
+    }
+    const controllerRegistry = ControllerRegistry.getInstance();
+    for (const controller of moduleRef.metadata.controllers) {
+      controllerRegistry.register(controller, moduleRef.container);
+    }
+    moduleRef.controllersRegistered = true;
+  }
+  attachModuleToParent(moduleRef, parentContainer) {
+    if (moduleRef.attachedParents.has(parentContainer)) {
+      return;
+    }
+    moduleRef.attachedParents.add(parentContainer);
+    for (const exportedToken of moduleRef.metadata.exports) {
+      this.registerExport(parentContainer, moduleRef, exportedToken);
+    }
+  }
+  registerExport(parentContainer, moduleRef, token) {
+    if (!moduleRef.container.isRegistered(token)) {
+      throw new Error(`Module ${moduleRef.moduleClass.name} cannot export ${typeof token === "function" ? token.name : String(token)} because it is not registered`);
+    }
+    if (parentContainer.isRegistered(token)) {
+      return;
+    }
+    parentContainer.register(token, {
+      lifecycle: "singleton" /* Singleton */,
+      factory: () => moduleRef.container.resolve(token)
+    });
+  }
+}
+
+// src/core/application.ts
+class Application {
+  server;
+  options;
+  middlewarePipeline;
+  websocketRegistry;
+  extensions = [];
+  constructor(options = {}) {
+    this.options = options;
+    this.middlewarePipeline = new MiddlewarePipeline([createErrorHandlingMiddleware()]);
+    this.websocketRegistry = WebSocketGatewayRegistry.getInstance();
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    ModuleRegistry.getInstance().clear();
+    this.registerExtension(new LoggerExtension);
+  }
+  use(middleware) {
+    this.middlewarePipeline.use(middleware);
+  }
+  listen(port, hostname) {
+    if (this.server?.isRunning()) {
+      throw new Error("Application is already running");
+    }
+    const serverOptions = {
+      port: port ?? this.options.port ?? 3000,
+      hostname: hostname ?? this.options.hostname,
+      fetch: this.handleRequest.bind(this),
+      websocketRegistry: this.websocketRegistry
+    };
+    this.server = new BunServer(serverOptions);
+    this.server.start();
+  }
+  stop() {
+    this.server?.stop();
+  }
+  async handleRequest(context) {
+    if (["POST", "PUT", "PATCH"].includes(context.method)) {
+      await context.getBody();
+    }
+    const registry = RouteRegistry.getInstance();
+    const router = registry.getRouter();
+    return await this.middlewarePipeline.run(context, async () => {
+      const response = await router.handle(context);
+      if (response) {
+        return response;
+      }
+      context.setStatus(404);
+      return context.createResponse({ error: "Not Found" });
+    });
+  }
+  registerController(controllerClass) {
+    const registry = ControllerRegistry.getInstance();
+    registry.register(controllerClass);
+  }
+  registerModule(moduleClass) {
+    const registry = ModuleRegistry.getInstance();
+    registry.register(moduleClass, this.getContainer());
+  }
+  registerWebSocketGateway(gatewayClass) {
+    this.websocketRegistry.register(gatewayClass);
+  }
+  registerExtension(extension) {
+    this.extensions.push(extension);
+    extension.register(this.getContainer());
+  }
+  getServer() {
+    return this.server;
+  }
+  getContainer() {
+    return ControllerRegistry.getInstance().getContainer();
+  }
+}
+// src/request/request.ts
+class RequestWrapper {
+  request;
+  url;
+  method;
+  path;
+  query;
+  headers;
+  _body;
+  _bodyParsed = false;
+  constructor(request) {
+    this.request = request;
+    this.url = new URL(request.url);
+    this.method = request.method;
+    this.path = this.url.pathname;
+    this.query = this.url.searchParams;
+    this.headers = request.headers;
+  }
+  async body() {
+    if (!this._bodyParsed) {
+      this._body = await BodyParser.parse(this.request);
+      this._bodyParsed = true;
+    }
+    return this._body;
+  }
+  getBody() {
+    return this._body;
+  }
+  getQuery(key) {
+    return this.query.get(key);
+  }
+  getQueryAll() {
+    const result = {};
+    this.query.forEach((value, key) => {
+      result[key] = value;
+    });
+    return result;
+  }
+  getHeader(key) {
+    return this.headers.get(key);
+  }
+}
+// src/request/response.ts
+class ResponseBuilder {
+  static json(data, status = 200, headers) {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set("Content-Type", "application/json");
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: responseHeaders
+    });
+  }
+  static text(text, status = 200, headers) {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set("Content-Type", "text/plain");
+    return new Response(text, {
+      status,
+      headers: responseHeaders
+    });
+  }
+  static html(html, status = 200, headers) {
+    const responseHeaders = new Headers(headers);
+    responseHeaders.set("Content-Type", "text/html");
+    return new Response(html, {
+      status,
+      headers: responseHeaders
+    });
+  }
+  static empty(status = 204, headers) {
+    const responseHeaders = headers ? new Headers(headers) : undefined;
+    return new Response(null, {
+      status,
+      headers: responseHeaders
+    });
+  }
+  static redirect(url, status = 302) {
+    return new Response(null, {
+      status,
+      headers: {
+        Location: url
+      }
+    });
+  }
+  static error(message, status = 500) {
+    return this.json({ error: message }, status);
+  }
+  static file(source, options = {}) {
+    const headers = new Headers(options.headers);
+    if (options.fileName) {
+      headers.set("Content-Disposition", `attachment; filename="${options.fileName}"`);
+    }
+    if (options.contentType) {
+      headers.set("Content-Type", options.contentType);
+    }
+    if (typeof source === "string") {
+      const file = Bun.file(source);
+      if (!headers.has("Content-Type") && file.type) {
+        headers.set("Content-Type", file.type);
+      }
+      return new Response(file, {
+        status: options.status ?? 200,
+        headers
+      });
+    }
+    return new Response(source, {
+      status: options.status ?? 200,
+      headers
+    });
+  }
+}
+// src/extensions/index.ts
+import { LoggerManager as LoggerManager7, LogLevel as LogLevel2, SimpleLogger as SimpleLogger2 } from "@dangao/logsmith";
+// src/testing/harness.ts
+import { performance as performance2 } from "perf_hooks";
+
+class PerformanceHarness {
+  static async benchmark(name, iterations, runner) {
+    if (iterations <= 0) {
+      throw new Error("iterations must be greater than 0");
+    }
+    const start = performance2.now();
+    for (let i = 0;i < iterations; i++) {
+      await runner(i);
+    }
+    const durationMs = performance2.now() - start;
+    const opsPerSecond = iterations / Math.max(durationMs / 1000, 0.0001);
+    return {
+      name,
+      iterations,
+      durationMs,
+      opsPerSecond
+    };
+  }
+}
+
+class StressTester {
+  static async run(name, iterations, concurrency, task) {
+    if (iterations <= 0) {
+      throw new Error("iterations must be greater than 0");
+    }
+    if (concurrency <= 0) {
+      throw new Error("concurrency must be greater than 0");
+    }
+    let next = 0;
+    let errors = 0;
+    const start = performance2.now();
+    const worker = async () => {
+      while (true) {
+        const current = next;
+        next += 1;
+        if (current >= iterations) {
+          break;
+        }
+        try {
+          await task(current);
+        } catch (error) {
+          errors += 1;
+        }
+      }
+    };
+    const workers = Array.from({ length: Math.min(concurrency, iterations) }, () => worker());
+    await Promise.all(workers);
+    const durationMs = performance2.now() - start;
+    return {
+      name,
+      iterations,
+      concurrency: Math.min(concurrency, iterations),
+      durationMs,
+      errors
+    };
+  }
+}
+export {
+  createStaticFileMiddleware,
+  createRequestLoggingMiddleware,
+  createLoggerMiddleware,
+  createFileUploadMiddleware,
+  createErrorHandlingMiddleware,
+  createCorsMiddleware,
+  WebSocketGatewayRegistry,
+  WebSocketGateway,
+  ValidationError,
+  Validate,
+  UseMiddleware,
+  UnauthorizedException,
+  StressTester,
+  Router,
+  RouteRegistry,
+  Route,
+  ResponseBuilder,
+  RequestWrapper,
+  Query,
+  PerformanceHarness,
+  ParamBinder,
+  Param,
+  PUT,
+  POST,
+  PATCH,
+  OnOpen,
+  OnMessage,
+  OnClose,
+  NotFoundException,
+  ModuleRegistry,
+  Module,
+  MinLength,
+  MiddlewarePipeline,
+  LoggerExtension,
+  LogLevel2 as LogLevel,
+  Lifecycle,
+  LOGGER_TOKEN,
+  IsString,
+  IsOptional,
+  IsNumber,
+  IsEmail,
+  InternalServerErrorException,
+  Injectable,
+  Inject,
+  HttpException,
+  Header,
+  GET,
+  ForbiddenException,
+  ExceptionFilterRegistry,
+  DELETE,
+  ControllerRegistry,
+  Controller,
+  Context,
+  Container,
+  BunServer,
+  BodyParser,
+  Body,
+  BadRequestException,
+  Application
+};