@dangao/bun-server 1.9.0 → 1.12.0

package/dist/index.js

@@ -1,42 +1,39 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __moduleCache = /* @__PURE__ */ new WeakMap;
+function __accessProp(key) {
+  return this[key];
+}
 var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
   if (entry)
     return entry;
   entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
   __moduleCache.set(from, entry);
   return entry;
 };
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __legacyDecorateClassTS = function(decorators, target, key, desc) {
@@ -286,28 +283,31 @@ class Route {
     this.handler = handler;
     this.controllerClass = controllerClass;
     this.methodName = methodName;
-    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}`;
+    } else {
+      const { pattern, paramNames } = Route.parsePath(path);
+      this.pattern = pattern;
+      this.paramNames = paramNames;
     }
+    this.middlewarePipeline = middlewares.length > 0 ? new MiddlewarePipeline(middlewares) : null;
   }
-  parsePath(path) {
+  static parsePath(path) {
     const paramNames = [];
     const patternString = path.replace(/:([^/]+)/g, (_, paramName) => {
       paramNames.push(paramName);
       return "([^/]+)";
     }).replace(/\*/g, ".*");
-    const pattern = new RegExp(`^${patternString}$`);
-    return { pattern, paramNames };
+    return { pattern: new RegExp(`^${patternString}$`), paramNames };
   }
   match(method, path) {
     if (this.method !== method) {
       return { matched: false, params: {} };
     }
+    if (this.isStatic) {
+      return path === this.path ? { matched: true, params: {} } : { matched: false, params: {} };
+    }
     const match = path.match(this.pattern);
     if (!match) {
       return { matched: false, params: {} };
@@ -4006,6 +4006,7 @@ class BunServer {
     this.server = Bun.serve({
       port: this.options.port ?? 3000,
       hostname: this.options.hostname,
+      reusePort: this.options.reusePort,
       fetch: (request, server) => {
         if (this.isShuttingDown) {
           return new Response("Server is shutting down", { status: 503 });
@@ -4061,7 +4062,7 @@ class BunServer {
       }
     });
     const hostname = this.options.hostname ?? "localhost";
-    const port = this.options.port ?? 3000;
+    const port = this.server.port;
     logger.info(`Server started at http://${hostname}:${port}`);
   }
   stop() {
@@ -4115,6 +4116,9 @@ class BunServer {
     return this.server !== undefined;
   }
   getPort() {
+    if (this.server) {
+      return this.server.port ?? this.options.port ?? 3000;
+    }
     return this.options.port ?? 3000;
   }
   getHostname() {
@@ -4178,14 +4182,13 @@ class WebSocketGatewayRegistry {
     }
     return WebSocketGatewayRegistry.instance;
   }
-  parsePath(path) {
+  static parsePath(path) {
     const paramNames = [];
     const patternString = path.replace(/:([^/]+)/g, (_, paramName) => {
       paramNames.push(paramName);
       return "([^/]+)";
     }).replace(/\*/g, ".*");
-    const pattern = new RegExp(`^${patternString}$`);
-    return { pattern, paramNames };
+    return { pattern: new RegExp(`^${patternString}$`), paramNames };
   }
   register(gatewayClass) {
     const metadata = getGatewayMetadata(gatewayClass);
@@ -4199,7 +4202,7 @@ class WebSocketGatewayRegistry {
     if (!this.container.isRegistered(gatewayClass)) {
       this.container.register(gatewayClass);
     }
-    const { pattern, paramNames } = this.parsePath(metadata.path);
+    const { pattern, paramNames } = WebSocketGatewayRegistry.parsePath(metadata.path);
     const isStatic = !metadata.path.includes(":") && !metadata.path.includes("*");
     const definition = {
       path: metadata.path,
@@ -4359,6 +4362,51 @@ init_types();
 init_module();
 init_decorators();
 
+// src/di/lifecycle.ts
+function hasOnModuleInit(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onModuleInit" in instance && typeof instance.onModuleInit === "function";
+}
+function hasOnModuleDestroy(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onModuleDestroy" in instance && typeof instance.onModuleDestroy === "function";
+}
+function hasOnApplicationBootstrap(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onApplicationBootstrap" in instance && typeof instance.onApplicationBootstrap === "function";
+}
+function hasOnApplicationShutdown(instance) {
+  return instance !== null && instance !== undefined && typeof instance === "object" && "onApplicationShutdown" in instance && typeof instance.onApplicationShutdown === "function";
+}
+async function callOnModuleInit(instances) {
+  for (const instance of instances) {
+    if (hasOnModuleInit(instance)) {
+      await instance.onModuleInit();
+    }
+  }
+}
+async function callOnApplicationBootstrap(instances) {
+  for (const instance of instances) {
+    if (hasOnApplicationBootstrap(instance)) {
+      await instance.onApplicationBootstrap();
+    }
+  }
+}
+async function callOnModuleDestroy(instances) {
+  for (let i = instances.length - 1;i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnModuleDestroy(instance)) {
+      await instance.onModuleDestroy();
+    }
+  }
+}
+async function callOnApplicationShutdown(instances, signal) {
+  for (let i = instances.length - 1;i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnApplicationShutdown(instance)) {
+      await instance.onApplicationShutdown(signal);
+    }
+  }
+}
+
+// src/di/module-registry.ts
 class ModuleRegistry {
   static instance;
   moduleRefs = new Map;
@@ -4380,6 +4428,13 @@ class ModuleRegistry {
   getModuleRef(moduleClass) {
     return this.moduleRefs.get(moduleClass);
   }
+  getAllModuleContainers() {
+    const containers = [];
+    for (const [, ref] of this.moduleRefs) {
+      containers.push(ref.container);
+    }
+    return containers;
+  }
   clear() {
     this.moduleRefs.clear();
     this.processing.clear();
@@ -4508,6 +4563,42 @@ class ModuleRegistry {
     }
     return moduleRef.middlewares;
   }
+  resolveAllProviderInstances() {
+    const instances = [];
+    for (const [, ref] of this.moduleRefs) {
+      for (const provider of ref.metadata.providers) {
+        try {
+          if (typeof provider === "function") {
+            instances.push(ref.container.resolve(provider));
+          } else if ("useClass" in provider) {
+            const token = provider.provide ?? provider.useClass;
+            instances.push(ref.container.resolve(token));
+          } else if ("useValue" in provider) {
+            instances.push(provider.useValue);
+          } else if ("useFactory" in provider) {
+            instances.push(ref.container.resolve(provider.provide));
+          }
+        } catch {}
+      }
+    }
+    return instances;
+  }
+  async callModuleInitHooks() {
+    const instances = this.resolveAllProviderInstances();
+    await callOnModuleInit(instances);
+  }
+  async callBootstrapHooks() {
+    const instances = this.resolveAllProviderInstances();
+    await callOnApplicationBootstrap(instances);
+  }
+  async callModuleDestroyHooks() {
+    const instances = this.resolveAllProviderInstances();
+    await callOnModuleDestroy(instances);
+  }
+  async callShutdownHooks(signal) {
+    const instances = this.resolveAllProviderInstances();
+    await callOnApplicationShutdown(instances, signal);
+  }
   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`);
@@ -4537,8 +4628,114 @@ var CONFIG_CENTER_TOKEN = Symbol("CONFIG_CENTER_TOKEN");
 // src/config/config-module.ts
 init_controller();
 
+// src/di/async-module.ts
+init_module();
+class AsyncProviderRegistry {
+  static instance;
+  pendingFactories = [];
+  static getInstance() {
+    if (!AsyncProviderRegistry.instance) {
+      AsyncProviderRegistry.instance = new AsyncProviderRegistry;
+    }
+    return AsyncProviderRegistry.instance;
+  }
+  register(token, factory) {
+    this.pendingFactories.push({ token, factory });
+  }
+  async initializeAll(container) {
+    const moduleContainers = ModuleRegistry.getInstance().getAllModuleContainers();
+    for (const { token, factory } of this.pendingFactories) {
+      const value = await factory(container);
+      container.registerInstance(token, value);
+      for (const moduleContainer of moduleContainers) {
+        if (moduleContainer.isRegistered(token)) {
+          moduleContainer.registerInstance(token, value);
+        }
+      }
+    }
+    this.pendingFactories.length = 0;
+  }
+  hasPending() {
+    return this.pendingFactories.length > 0;
+  }
+  clear() {
+    this.pendingFactories.length = 0;
+  }
+}
+function registerAsyncProviders(moduleClass, asyncOptions, tokenMap, extraProviders) {
+  const providers = [];
+  const exports = [];
+  for (const [token] of tokenMap) {
+    providers.push({
+      provide: token,
+      useFactory: () => {
+        throw new Error(`Async provider ${String(token)} not yet initialized. ` + "Ensure Application.listen() is called before resolving async providers.");
+      }
+    });
+    exports.push(token);
+  }
+  if (extraProviders) {
+    providers.push(...extraProviders);
+  }
+  const registry = AsyncProviderRegistry.getInstance();
+  for (const [token, mapper] of tokenMap) {
+    registry.register(token, async (container) => {
+      const deps = [];
+      if (asyncOptions.inject) {
+        for (const injectToken of asyncOptions.inject) {
+          deps.push(container.resolve(injectToken));
+        }
+      }
+      const config = await asyncOptions.useFactory(...deps);
+      return mapper(config);
+    });
+  }
+  const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, moduleClass) || {};
+  const metadata = {
+    ...existingMetadata,
+    imports: [...existingMetadata.imports || [], ...asyncOptions.imports || []],
+    providers: [...existingMetadata.providers || [], ...providers],
+    exports: [...existingMetadata.exports || [], ...exports]
+  };
+  Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, moduleClass);
+  return moduleClass;
+}
+
 // src/config/service.ts
 class ConfigService {
+  static parseConfigContent(content, format) {
+    if (format === "jsonc") {
+      return Bun.JSONC.parse(content);
+    }
+    if (format === "json5") {
+      return Bun.JSON5.parse(content);
+    }
+    if (format === "json") {
+      return JSON.parse(content);
+    }
+    try {
+      return JSON.parse(content);
+    } catch {
+      try {
+        return Bun.JSONC.parse(content);
+      } catch {
+        return Bun.JSON5.parse(content);
+      }
+    }
+  }
+  static async loadConfigFile(filePath) {
+    const file = Bun.file(filePath);
+    const content = await file.text();
+    let format;
+    if (filePath.endsWith(".json5")) {
+      format = "json5";
+    } else if (filePath.endsWith(".jsonc")) {
+      format = "jsonc";
+    } else if (filePath.endsWith(".json")) {
+      format = "json";
+    }
+    return ConfigService.parseConfigContent(content, format);
+  }
   config;
   namespace;
   configUpdateListeners = [];
@@ -4662,6 +4859,27 @@ class ConfigModule {
     Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, ConfigModule);
     return ConfigModule;
   }
+  static forRootAsync(asyncOptions) {
+    const tokenMap = new Map;
+    tokenMap.set(CONFIG_SERVICE_TOKEN, async (options) => {
+      const env = ConfigModule.snapshotEnv();
+      const defaultConfig = options.defaultConfig ?? {};
+      let fileConfig = {};
+      if (options.configFiles?.length) {
+        const fileConfigs = await Promise.all(options.configFiles.map((f) => ConfigService.loadConfigFile(f)));
+        for (const fc of fileConfigs) {
+          fileConfig = { ...fileConfig, ...fc };
+        }
+      }
+      const loadedConfig = options.load ? options.load(env) : {};
+      const mergedConfig = { ...defaultConfig, ...fileConfig, ...loadedConfig };
+      if (options.validate) {
+        options.validate(mergedConfig);
+      }
+      return new ConfigService(mergedConfig, options.namespace);
+    });
+    return registerAsyncProviders(ConfigModule, asyncOptions, tokenMap);
+  }
   static snapshotEnv() {
     const env = {};
     for (const [key, value] of Object.entries(process.env)) {
@@ -4716,7 +4934,7 @@ class ConfigModule {
       for (const [configPath, configInfo] of configCenterOptions.configs.entries()) {
         loadPromises.push(configCenter.getConfig(configInfo.dataId, configInfo.groupName, configInfo.namespaceId).then((result) => {
           try {
-            const parsed = JSON.parse(result.content);
+            const parsed = ConfigService.parseConfigContent(result.content);
             ConfigModule.setValueByPath(configMap, configPath, parsed);
           } catch {
             ConfigModule.setValueByPath(configMap, configPath, result.content);
@@ -4744,7 +4962,7 @@ class ConfigModule {
           try {
             let parsedValue;
             try {
-              parsedValue = JSON.parse(result.content);
+              parsedValue = ConfigService.parseConfigContent(result.content);
             } catch {
               parsedValue = result.content;
             }
@@ -5391,6 +5609,18 @@ class CacheModule {
     Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, CacheModule);
     return CacheModule;
   }
+  static forRootAsync(asyncOptions) {
+    const tokenMap = new Map;
+    tokenMap.set(CACHE_SERVICE_TOKEN, (config) => {
+      const resolvedConfig = {
+        ...config,
+        store: config.store ?? new MemoryCacheStore({ cleanupInterval: 60000 })
+      };
+      return new CacheService(resolvedConfig);
+    });
+    tokenMap.set(CACHE_OPTIONS_TOKEN, (config) => config);
+    return registerAsyncProviders(CacheModule, asyncOptions, tokenMap);
+  }
   static getPostProcessor() {
     return CacheModule.postProcessor;
   }
@@ -5852,14 +6082,22 @@ class Application {
     if (this.server?.isRunning()) {
       throw new Error("Application is already running");
     }
+    const asyncRegistry = AsyncProviderRegistry.getInstance();
+    if (asyncRegistry.hasPending()) {
+      await asyncRegistry.initializeAll(this.getContainer());
+    }
     await this.initializeExtensions();
     await this.initializeConfigCenter();
     this.initializeEventListeners();
+    const registry = ModuleRegistry.getInstance();
+    await registry.callModuleInitHooks();
+    await registry.callBootstrapHooks();
     const finalPort = port ?? this.options.port ?? 3000;
     const finalHostname = hostname ?? this.options.hostname;
     const serverOptions = {
       port: finalPort,
       hostname: finalHostname,
+      reusePort: this.options.reusePort,
       fetch: this.handleRequest.bind(this),
       websocketRegistry: this.websocketRegistry,
       gracefulShutdownTimeout: this.options.gracefulShutdownTimeout
@@ -5910,12 +6148,18 @@ class Application {
   }
   async stop() {
     this.removeSignalHandlers();
+    const moduleRegistry = ModuleRegistry.getInstance();
+    await moduleRegistry.callShutdownHooks();
+    await moduleRegistry.callModuleDestroyHooks();
     await this.deregisterServices();
     await this.closeExtensions();
     this.server?.stop();
   }
   async gracefulShutdown(timeout) {
     this.removeSignalHandlers();
+    const moduleRegistry = ModuleRegistry.getInstance();
+    await moduleRegistry.callShutdownHooks();
+    await moduleRegistry.callModuleDestroyHooks();
     await this.deregisterServices();
     await this.closeExtensions();
     if (this.server) {
@@ -6057,6 +6301,110 @@ class Application {
     this.signalHandlersInstalled = false;
   }
 }
+// src/core/apply-decorators.ts
+function applyDecorators(...decorators) {
+  return (target, propertyKey, descriptor) => {
+    for (const decorator of decorators.reverse()) {
+      if (descriptor) {
+        const result = decorator(target, propertyKey, descriptor);
+        if (result) {
+          descriptor = result;
+        }
+      } else if (propertyKey) {
+        decorator(target, propertyKey);
+      } else {
+        decorator(target);
+      }
+    }
+    return descriptor;
+  };
+}
+// src/core/cluster.ts
+var {spawn } = globalThis.Bun;
+import { LoggerManager as LoggerManager12 } from "@dangao/logsmith";
+
+class ClusterManager {
+  workerCount;
+  workers = [];
+  scriptPath;
+  port;
+  hostname;
+  constructor(options) {
+    this.workerCount = options.workers === "auto" ? navigator.hardwareConcurrency : options.workers;
+    this.scriptPath = options.scriptPath;
+    this.port = options.port;
+    this.hostname = options.hostname;
+  }
+  start() {
+    const logger = LoggerManager12.getLogger();
+    logger.info(`[Cluster] Starting ${this.workerCount} workers on port ${this.port}`);
+    for (let i = 0;i < this.workerCount; i++) {
+      const worker = spawn({
+        cmd: ["bun", "run", this.scriptPath],
+        env: {
+          ...process.env,
+          PORT: String(this.port),
+          REUSE_PORT: "1",
+          CLUSTER_WORKER: "1",
+          WORKER_ID: String(i),
+          ...this.hostname ? { HOSTNAME: this.hostname } : {}
+        },
+        stdout: "inherit",
+        stderr: "inherit"
+      });
+      this.workers.push(worker);
+    }
+    logger.info(`[Cluster] ${this.workerCount} workers started (reusePort mode)`);
+    this.monitorWorkers();
+  }
+  async stop() {
+    const logger = LoggerManager12.getLogger();
+    logger.info("[Cluster] Stopping all workers...");
+    for (const worker of this.workers) {
+      worker.kill("SIGTERM");
+    }
+    const timeout = setTimeout(() => {
+      for (const worker of this.workers) {
+        worker.kill("SIGKILL");
+      }
+    }, 5000);
+    await Promise.all(this.workers.map((w) => w.exited));
+    clearTimeout(timeout);
+    this.workers.length = 0;
+    logger.info("[Cluster] All workers stopped");
+  }
+  monitorWorkers() {
+    for (let i = 0;i < this.workers.length; i++) {
+      const index = i;
+      this.workers[index].exited.then((exitCode) => {
+        if (exitCode !== 0 && exitCode !== null) {
+          const logger = LoggerManager12.getLogger();
+          logger.warn(`[Cluster] Worker ${index} exited with code ${exitCode}, restarting...`);
+          const newWorker = spawn({
+            cmd: ["bun", "run", this.scriptPath],
+            env: {
+              ...process.env,
+              PORT: String(this.port),
+              REUSE_PORT: "1",
+              CLUSTER_WORKER: "1",
+              WORKER_ID: String(index),
+              ...this.hostname ? { HOSTNAME: this.hostname } : {}
+            },
+            stdout: "inherit",
+            stderr: "inherit"
+          });
+          this.workers[index] = newWorker;
+        }
+      });
+    }
+  }
+  static isWorker() {
+    return process.env.CLUSTER_WORKER === "1";
+  }
+  static getWorkerId() {
+    return Number(process.env.WORKER_ID ?? -1);
+  }
+}
 
 // src/index.ts
 init_context_service();
@@ -6406,6 +6754,88 @@ class SwaggerGenerator {
     }
     return document;
   }
+  generateMarkdown() {
+    const doc = this.generate();
+    const lines = [];
+    lines.push(`# ${doc.info.title}`);
+    lines.push("");
+    if (doc.info.description) {
+      lines.push(doc.info.description);
+      lines.push("");
+    }
+    lines.push(`**Version:** ${doc.info.version}`);
+    lines.push("");
+    if (doc.servers?.length) {
+      lines.push("## Servers");
+      lines.push("");
+      for (const server of doc.servers) {
+        lines.push(`- \`${server.url}\`${server.description ? " \u2014 " + server.description : ""}`);
+      }
+      lines.push("");
+    }
+    if (doc.tags?.length) {
+      lines.push("## Tags");
+      lines.push("");
+      for (const tag of doc.tags) {
+        lines.push(`- **${tag.name}**${tag.description ? ": " + tag.description : ""}`);
+      }
+      lines.push("");
+    }
+    lines.push("## Endpoints");
+    lines.push("");
+    const methods = ["get", "post", "put", "delete", "patch"];
+    for (const [path, pathObj] of Object.entries(doc.paths)) {
+      for (const method of methods) {
+        const operation = pathObj[method];
+        if (!operation)
+          continue;
+        lines.push(`### \`${method.toUpperCase()}\` ${path}`);
+        lines.push("");
+        if (operation.summary) {
+          lines.push(`**${operation.summary}**`);
+          lines.push("");
+        }
+        if (operation.description) {
+          lines.push(operation.description);
+          lines.push("");
+        }
+        if (operation.tags?.length) {
+          lines.push(`Tags: ${operation.tags.map((t) => `\`${t}\``).join(", ")}`);
+          lines.push("");
+        }
+        if (operation.deprecated) {
+          lines.push("> **Deprecated**");
+          lines.push("");
+        }
+        if (operation.parameters?.length) {
+          lines.push("| Parameter | In | Type | Required | Description |");
+          lines.push("|---|---|---|---|---|");
+          for (const param of operation.parameters) {
+            const type = param.schema?.type ?? "string";
+            const required = param.required ? "Yes" : "No";
+            lines.push(`| \`${param.name}\` | ${param.in} | ${type} | ${required} | ${param.description ?? ""} |`);
+          }
+          lines.push("");
+        }
+        if (operation.responses) {
+          lines.push("**Responses:**");
+          lines.push("");
+          for (const [status, resp] of Object.entries(operation.responses)) {
+            lines.push(`- **${status}**: ${resp.description ?? ""}`);
+          }
+          lines.push("");
+        }
+        lines.push("---");
+        lines.push("");
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateMarkdownHtml() {
+    const md = this.generateMarkdown();
+    return Bun.markdown.html(md, { headings: true });
+  }
   normalizePath(path) {
     path = path.replace(/\/+/g, "/");
     if (!path.startsWith("/")) {
@@ -7740,6 +8170,417 @@ HealthModule = __legacyDecorateClassTS([
 
 // src/health/index.ts
 init_types5();
+// src/dashboard/dashboard-module.ts
+init_module();
+
+// src/dashboard/controller.ts
+init_registry();
+
+// src/dashboard/ui.ts
+function createDashboardHTML(basePath) {
+  const apiBase = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Bun Server Dashboard</title>
+  <style>
+    :root {
+      --bg-primary: #0f0f12;
+      --bg-secondary: #18181c;
+      --bg-card: #1e1e24;
+      --border: #2a2a32;
+      --text-primary: #e4e4e7;
+      --text-secondary: #a1a1aa;
+      --accent: #6366f1;
+      --accent-hover: #818cf8;
+      --success: #22c55e;
+      --warning: #eab308;
+      --error: #ef4444;
+    }
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: var(--bg-primary);
+      color: var(--text-primary);
+      min-height: 100vh;
+      padding: 1.5rem;
+      line-height: 1.5;
+    }
+    .header {
+      margin-bottom: 1.5rem;
+      padding-bottom: 1rem;
+      border-bottom: 1px solid var(--border);
+    }
+    .header h1 {
+      font-size: 1.5rem;
+      font-weight: 600;
+      color: var(--text-primary);
+    }
+    .header p {
+      font-size: 0.875rem;
+      color: var(--text-secondary);
+      margin-top: 0.25rem;
+    }
+    .grid {
+      display: grid;
+      grid-template-columns: repeat(auto-fit, minmax(320px, 1fr));
+      gap: 1rem;
+      margin-bottom: 1.5rem;
+    }
+    .card {
+      background: var(--bg-card);
+      border: 1px solid var(--border);
+      border-radius: 0.5rem;
+      padding: 1rem;
+      overflow: hidden;
+    }
+    .card-title {
+      font-size: 0.875rem;
+      font-weight: 600;
+      color: var(--text-secondary);
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+      margin-bottom: 0.75rem;
+    }
+    .stat-row {
+      display: flex;
+      justify-content: space-between;
+      padding: 0.375rem 0;
+      font-size: 0.875rem;
+    }
+    .stat-label { color: var(--text-secondary); }
+    .stat-value { font-weight: 500; }
+    .status-up { color: var(--success); }
+    .status-down { color: var(--error); }
+    .table-wrap {
+      overflow-x: auto;
+      margin: 0 -1rem -1rem;
+    }
+    table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 0.8125rem;
+    }
+    th, td {
+      padding: 0.5rem 1rem;
+      text-align: left;
+      border-top: 1px solid var(--border);
+    }
+    th {
+      color: var(--text-secondary);
+      font-weight: 500;
+      text-transform: uppercase;
+      letter-spacing: 0.05em;
+    }
+    .method {
+      display: inline-block;
+      padding: 0.125rem 0.375rem;
+      border-radius: 0.25rem;
+      font-size: 0.75rem;
+      font-weight: 600;
+    }
+    .method-GET { background: rgba(34, 197, 94, 0.2); color: var(--success); }
+    .method-POST { background: rgba(99, 102, 241, 0.2); color: var(--accent); }
+    .method-PUT { background: rgba(234, 179, 8, 0.2); color: var(--warning); }
+    .method-DELETE { background: rgba(239, 68, 68, 0.2); color: var(--error); }
+    .method-PATCH { background: rgba(168, 85, 247, 0.2); color: #a855f7; }
+    .refresh-badge {
+      display: inline-block;
+      font-size: 0.75rem;
+      color: var(--text-secondary);
+      margin-top: 1rem;
+    }
+    .loading { color: var(--text-secondary); font-style: italic; }
+    .error-msg { color: var(--error); font-size: 0.875rem; }
+  </style>
+</head>
+<body>
+  <div class="header">
+    <h1>Bun Server Dashboard</h1>
+    <p>Monitoring UI - Auto-refresh every 5 seconds</p>
+  </div>
+  <div class="grid">
+    <div class="card">
+      <div class="card-title">System Info</div>
+      <div id="system-info" class="loading">Loading...</div>
+    </div>
+    <div class="card">
+      <div class="card-title">Health Status</div>
+      <div id="health-info" class="loading">Loading...</div>
+    </div>
+  </div>
+  <div class="card">
+    <div class="card-title">Registered Routes</div>
+    <div class="table-wrap">
+      <table>
+        <thead>
+          <tr>
+            <th>Method</th>
+            <th>Path</th>
+            <th>Controller</th>
+            <th>Method</th>
+          </tr>
+        </thead>
+        <tbody id="routes-body">
+          <tr><td colspan="4" class="loading">Loading...</td></tr>
+        </tbody>
+      </table>
+    </div>
+  </div>
+  <div class="refresh-badge" id="last-update">Last update: -</div>
+  <script>
+    (function() {
+      var base = '${apiBase}';
+      function fetchJson(path) {
+        return fetch(base + path).then(function(r) {
+          if (!r.ok) throw new Error(r.status);
+          return r.json();
+        });
+      }
+      function formatBytes(n) {
+        if (n < 1024) return n + ' B';
+        if (n < 1048576) return (n / 1024).toFixed(1) + ' KB';
+        return (n / 1048576).toFixed(2) + ' MB';
+      }
+      function renderSystem(data) {
+        var el = document.getElementById('system-info');
+        if (!data) { el.innerHTML = '<span class="error-msg">Failed to load</span>'; return; }
+        el.innerHTML = '<div class="stat-row"><span class="stat-label">Uptime</span><span class="stat-value">' + Math.floor(data.uptime || 0) + 's</span></div>' +
+          '<div class="stat-row"><span class="stat-label">RSS</span><span class="stat-value">' + formatBytes(data.memory?.rss || 0) + '</span></div>' +
+          '<div class="stat-row"><span class="stat-label">Heap Used</span><span class="stat-value">' + formatBytes(data.memory?.heapUsed || 0) + '</span></div>' +
+          '<div class="stat-row"><span class="stat-label">Heap Total</span><span class="stat-value">' + formatBytes(data.memory?.heapTotal || 0) + '</span></div>' +
+          '<div class="stat-row"><span class="stat-label">Platform</span><span class="stat-value">' + (data.platform || '-') + '</span></div>' +
+          '<div class="stat-row"><span class="stat-label">Bun</span><span class="stat-value">' + (data.bunVersion || '-') + '</span></div>';
+      }
+      function renderHealth(data) {
+        var el = document.getElementById('health-info');
+        if (!data) { el.innerHTML = '<span class="error-msg">Failed to load</span>'; return; }
+        var statusClass = data.status === 'up' ? 'status-up' : 'status-down';
+        el.innerHTML = '<div class="stat-row"><span class="stat-label">Status</span><span class="stat-value ' + statusClass + '">' + (data.status || 'unknown') + '</span></div>' +
+          '<div class="stat-row"><span class="stat-label">Timestamp</span><span class="stat-value">' + (data.timestamp ? new Date(data.timestamp).toLocaleTimeString() : '-') + '</span></div>';
+      }
+      function renderRoutes(data) {
+        var tbody = document.getElementById('routes-body');
+        if (!data || !Array.isArray(data)) {
+          tbody.innerHTML = '<tr><td colspan="4" class="error-msg">Failed to load</td></tr>';
+          return;
+        }
+        if (data.length === 0) {
+          tbody.innerHTML = '<tr><td colspan="4" class="loading">No routes registered</td></tr>';
+          return;
+        }
+        tbody.innerHTML = data.map(function(r) {
+          return '<tr><td><span class="method method-' + (r.method || 'GET') + '">' + (r.method || 'GET') + '</span></td>' +
+            '<td><code>' + (r.path || '') + '</code></td>' +
+            '<td>' + (r.controller || '-') + '</td>' +
+            '<td>' + (r.methodName || '-') + '</td></tr>';
+        }).join('');
+      }
+      function update() {
+        fetchJson('/api/system').then(renderSystem).catch(function() { renderSystem(null); });
+        fetchJson('/api/health').then(renderHealth).catch(function() { renderHealth(null); });
+        fetchJson('/api/routes').then(renderRoutes).catch(function() { renderRoutes(null); });
+        document.getElementById('last-update').textContent = 'Last update: ' + new Date().toLocaleTimeString();
+      }
+      update();
+      setInterval(update, 5000);
+    })();
+  </script>
+</body>
+</html>`;
+}
+
+// src/dashboard/controller.ts
+init_controller();
+init_types5();
+
+class DashboardService {
+  basePath;
+  auth;
+  startTime = Date.now();
+  constructor(basePath, auth) {
+    this.basePath = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
+    this.auth = auth;
+  }
+  registerRoutes() {
+    const registry = RouteRegistry.getInstance();
+    registry.register("GET", this.basePath, (ctx) => this.handleDashboard(ctx));
+    registry.register("GET", `${this.basePath}/api/system`, (ctx) => this.handleSystem(ctx));
+    registry.register("GET", `${this.basePath}/api/routes`, (ctx) => this.handleRoutes(ctx));
+    registry.register("GET", `${this.basePath}/api/health`, (ctx) => this.handleHealth(ctx));
+    registry.register("POST", `${this.basePath}/api/markdown`, (ctx) => this.handleMarkdownRender(ctx));
+  }
+  checkAuth(ctx) {
+    if (!this.auth) {
+      return true;
+    }
+    const authHeader = ctx.getHeader("Authorization");
+    if (!authHeader || !authHeader.startsWith("Basic ")) {
+      return false;
+    }
+    try {
+      const decoded = atob(authHeader.slice(6));
+      const [username, password] = decoded.split(":");
+      return username === this.auth.username && password === this.auth.password;
+    } catch {
+      return false;
+    }
+  }
+  unauthorizedResponse() {
+    return new Response("Unauthorized", {
+      status: 401,
+      headers: {
+        "WWW-Authenticate": 'Basic realm="Dashboard"',
+        "Content-Type": "text/plain"
+      }
+    });
+  }
+  async handleDashboard(ctx) {
+    if (!this.checkAuth(ctx)) {
+      return this.unauthorizedResponse();
+    }
+    const html = createDashboardHTML(this.basePath);
+    return new Response(html, {
+      headers: { "Content-Type": "text/html; charset=utf-8" }
+    });
+  }
+  async handleSystem(ctx) {
+    if (!this.checkAuth(ctx)) {
+      return this.unauthorizedResponse();
+    }
+    const mem = process.memoryUsage();
+    const data = {
+      uptime: Math.floor(process.uptime()),
+      memory: {
+        rss: mem.rss,
+        heapUsed: mem.heapUsed,
+        heapTotal: mem.heapTotal
+      },
+      platform: process.platform,
+      bunVersion: typeof Bun !== "undefined" ? Bun.version : undefined
+    };
+    return new Response(JSON.stringify(data), {
+      headers: { "Content-Type": "application/json; charset=utf-8" }
+    });
+  }
+  async handleRoutes(ctx) {
+    if (!this.checkAuth(ctx)) {
+      return this.unauthorizedResponse();
+    }
+    const registry = RouteRegistry.getInstance();
+    const router = registry.getRouter();
+    const routes = router.getRoutes();
+    const data = routes.map((r) => ({
+      method: r.method,
+      path: r.path,
+      controller: r.controllerClass?.name ?? undefined,
+      methodName: r.methodName ?? undefined
+    }));
+    return new Response(JSON.stringify(data), {
+      headers: { "Content-Type": "application/json; charset=utf-8" }
+    });
+  }
+  async handleMarkdownRender(ctx) {
+    if (!this.checkAuth(ctx)) {
+      return this.unauthorizedResponse();
+    }
+    try {
+      const body = await ctx.request.json();
+      if (!body.content) {
+        return new Response(JSON.stringify({ error: "content field is required" }), {
+          status: 400,
+          headers: { "Content-Type": "application/json; charset=utf-8" }
+        });
+      }
+      const html = Bun.markdown.html(body.content, { headings: true });
+      return new Response(JSON.stringify({ html }), {
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      });
+    } catch (err) {
+      return new Response(JSON.stringify({ error: err.message }), {
+        status: 500,
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      });
+    }
+  }
+  async handleHealth(ctx) {
+    if (!this.checkAuth(ctx)) {
+      return this.unauthorizedResponse();
+    }
+    try {
+      const container = ControllerRegistry.getInstance().getContainer();
+      const indicators = container.resolve(HEALTH_INDICATORS_TOKEN);
+      const details = {};
+      for (const indicator of indicators) {
+        try {
+          const result = await indicator.check();
+          details[indicator.name] = result;
+        } catch (err) {
+          details[indicator.name] = {
+            status: "down",
+            details: { error: err.message }
+          };
+        }
+      }
+      const allUp = Object.keys(details).length === 0 || Object.values(details).every((r) => r.status === "up");
+      const data = {
+        status: allUp ? "up" : "down",
+        timestamp: Date.now(),
+        details
+      };
+      return new Response(JSON.stringify(data), {
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      });
+    } catch {
+      const data = {
+        status: "up",
+        timestamp: Date.now()
+      };
+      return new Response(JSON.stringify(data), {
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      });
+    }
+  }
+}
+
+// src/dashboard/dashboard-extension.ts
+class DashboardExtension {
+  service;
+  constructor(service) {
+    this.service = service;
+  }
+  register(_container) {
+    this.service.registerRoutes();
+  }
+}
+
+// src/dashboard/dashboard-module.ts
+class DashboardModule {
+  static forRoot(options = {}) {
+    const path = options.path ?? "/_dashboard";
+    const basePath = path.endsWith("/") ? path.slice(0, -1) : path;
+    const service = new DashboardService(basePath, options.auth);
+    const extension = new DashboardExtension(service);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, DashboardModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      extensions: [extension]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, DashboardModule);
+    return DashboardModule;
+  }
+}
+DashboardModule = __legacyDecorateClassTS([
+  Module({
+    extensions: [],
+    controllers: [],
+    providers: []
+  })
+], DashboardModule);
+// src/dashboard/types.ts
+var DASHBOARD_OPTIONS_TOKEN = Symbol("@dangao/bun-server:dashboard:options");
 // src/metrics/metrics-module.ts
 init_module();
 
@@ -8946,6 +9787,12 @@ class DatabaseModule {
     Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, DatabaseModule);
     return DatabaseModule;
   }
+  static forRootAsync(asyncOptions) {
+    const tokenMap = new Map;
+    tokenMap.set(DATABASE_SERVICE_TOKEN, (config) => new DatabaseService2(config));
+    tokenMap.set(DATABASE_OPTIONS_TOKEN, (config) => config);
+    return registerAsyncProviders(DatabaseModule, asyncOptions, tokenMap);
+  }
   static createHealthIndicator(databaseService) {
     return new DatabaseHealthIndicator(databaseService);
   }
@@ -9095,6 +9942,707 @@ class DrizzleBaseRepository {
     this.databaseService = databaseService;
   }
 }
+// src/debug/debug-module.ts
+init_module();
+
+// src/debug/recorder.ts
+class RequestRecorder {
+  buffer;
+  maxRecords;
+  writeIndex = 0;
+  count = 0;
+  idCounter = 0;
+  idMap = new Map;
+  constructor(maxRecords = 500) {
+    this.maxRecords = maxRecords;
+    this.buffer = new Array(maxRecords).fill(null);
+  }
+  generateId() {
+    this.idCounter += 1;
+    const ts = Date.now().toString(16);
+    const counter = this.idCounter.toString(16);
+    return `${ts}-${counter}`;
+  }
+  record(record) {
+    const id = this.generateId();
+    const fullRecord = { ...record, id };
+    const oldRecord = this.buffer[this.writeIndex];
+    if (oldRecord) {
+      this.idMap.delete(oldRecord.id);
+    }
+    this.buffer[this.writeIndex] = fullRecord;
+    this.idMap.set(id, this.writeIndex);
+    this.writeIndex = (this.writeIndex + 1) % this.maxRecords;
+    if (this.count < this.maxRecords) {
+      this.count += 1;
+    }
+  }
+  getAll() {
+    const records = [];
+    for (let i = 0;i < this.count; i++) {
+      const idx = (this.writeIndex - 1 - i + this.maxRecords) % this.maxRecords;
+      const record = this.buffer[idx];
+      if (record) {
+        records.push(record);
+      }
+    }
+    return records;
+  }
+  getById(id) {
+    const index = this.idMap.get(id);
+    if (index === undefined) {
+      return;
+    }
+    return this.buffer[index] ?? undefined;
+  }
+  clear() {
+    for (let i = 0;i < this.maxRecords; i++) {
+      this.buffer[i] = null;
+    }
+    this.writeIndex = 0;
+    this.count = 0;
+    this.idMap.clear();
+  }
+  getCount() {
+    return this.count;
+  }
+  exportToJsonl() {
+    const records = this.getAll();
+    return records.map((r) => JSON.stringify(r)).join(`
+`) + `
+`;
+  }
+  importFromJsonl(content) {
+    const records = Bun.JSONL.parse(content);
+    for (const record of records) {
+      if (record.id) {
+        const oldRecord = this.buffer[this.writeIndex];
+        if (oldRecord) {
+          this.idMap.delete(oldRecord.id);
+        }
+        this.buffer[this.writeIndex] = record;
+        this.idMap.set(record.id, this.writeIndex);
+        this.writeIndex = (this.writeIndex + 1) % this.maxRecords;
+        if (this.count < this.maxRecords) {
+          this.count += 1;
+        }
+      }
+    }
+  }
+  static parseJsonl(content) {
+    return Bun.JSONL.parse(content);
+  }
+}
+
+// src/debug/middleware.ts
+init_registry();
+function headersToRecord(headers) {
+  const record = {};
+  headers.forEach((value, key) => {
+    record[key] = value;
+  });
+  return record;
+}
+async function getResponseBodySize(response) {
+  const contentLength = response.headers.get("content-length");
+  if (contentLength) {
+    const n = parseInt(contentLength, 10);
+    if (!Number.isNaN(n)) {
+      return n;
+    }
+  }
+  if (response.body) {
+    const clone = response.clone();
+    const buf = await clone.arrayBuffer();
+    return buf.byteLength;
+  }
+  return 0;
+}
+function createDebugMiddleware(recorder, options = {}) {
+  const recordBody = options.recordBody ?? true;
+  const basePath = options.basePath ?? "/_debug";
+  return async (context2, next) => {
+    const startTime = Date.now();
+    const requestHeaders = {};
+    context2.headers.forEach((value, key) => {
+      requestHeaders[key] = value;
+    });
+    let requestBody = undefined;
+    if (recordBody && ["POST", "PUT", "PATCH"].includes(context2.method)) {
+      try {
+        requestBody = await context2.getBody();
+      } catch {
+        requestBody = undefined;
+      }
+    }
+    const response = await next();
+    const endTime = Date.now();
+    const totalMs = endTime - startTime;
+    if (context2.path.startsWith(basePath)) {
+      return response;
+    }
+    const responseHeaders = headersToRecord(response.headers);
+    const bodySize = await getResponseBodySize(response);
+    const routeHandler = context2.routeHandler;
+    let matchedRoute;
+    try {
+      const registry = RouteRegistry.getInstance();
+      const router = registry.getRouter();
+      const route = router.findRoute(context2.method, context2.path);
+      if (route) {
+        matchedRoute = route.path;
+      }
+    } catch {
+      matchedRoute = undefined;
+    }
+    const record = {
+      timestamp: startTime,
+      request: {
+        method: context2.method,
+        path: context2.path,
+        headers: requestHeaders,
+        body: requestBody
+      },
+      response: {
+        status: response.status,
+        headers: responseHeaders,
+        bodySize
+      },
+      timing: {
+        total: totalMs
+      },
+      metadata: {
+        matchedRoute,
+        controller: routeHandler?.controller?.name,
+        methodName: routeHandler?.method
+      }
+    };
+    recorder.record(record);
+    return response;
+  };
+}
+
+// src/debug/ui.ts
+function createDebugHTML(basePath) {
+  const apiBase = `${basePath}/api`;
+  const normalizePath = (p) => p.endsWith("/") && p.length > 1 ? p.slice(0, -1) : p;
+  const base = normalizePath(basePath);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Debug - Request Replay</title>
+  <style>
+    :root {
+      --bg-primary: #0d1117;
+      --bg-secondary: #161b22;
+      --bg-tertiary: #21262d;
+      --text-primary: #e6edf3;
+      --text-secondary: #8b949e;
+      --border: #30363d;
+      --accent: #58a6ff;
+      --accent-hover: #79b8ff;
+      --success: #3fb950;
+      --warning: #d29922;
+      --error: #f85149;
+      --get: #3fb950;
+      --post: #58a6ff;
+      --put: #d29922;
+      --delete: #f85149;
+      --patch: #a371f7;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      background: var(--bg-primary);
+      color: var(--text-primary);
+      line-height: 1.5;
+      min-height: 100vh;
+    }
+    .container {
+      max-width: 1400px;
+      margin: 0 auto;
+      padding: 1.5rem;
+    }
+    header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      margin-bottom: 1.5rem;
+      padding-bottom: 1rem;
+      border-bottom: 1px solid var(--border);
+    }
+    h1 {
+      margin: 0;
+      font-size: 1.5rem;
+      font-weight: 600;
+    }
+    .toolbar {
+      display: flex;
+      gap: 0.75rem;
+      align-items: center;
+    }
+    .btn {
+      padding: 0.5rem 1rem;
+      border: 1px solid var(--border);
+      border-radius: 6px;
+      background: var(--bg-secondary);
+      color: var(--text-primary);
+      cursor: pointer;
+      font-size: 0.875rem;
+      transition: background 0.15s;
+    }
+    .btn:hover {
+      background: var(--bg-tertiary);
+    }
+    .btn-primary {
+      background: var(--accent);
+      border-color: var(--accent);
+      color: #fff;
+    }
+    .btn-primary:hover {
+      background: var(--accent-hover);
+    }
+    .btn-danger {
+      background: var(--error);
+      border-color: var(--error);
+      color: #fff;
+    }
+    .toggle-label {
+      display: flex;
+      align-items: center;
+      gap: 0.5rem;
+      font-size: 0.875rem;
+      color: var(--text-secondary);
+    }
+    .toggle {
+      width: 36px;
+      height: 20px;
+      background: var(--bg-tertiary);
+      border-radius: 10px;
+      position: relative;
+      cursor: pointer;
+      transition: background 0.2s;
+    }
+    .toggle.active { background: var(--accent); }
+    .toggle::after {
+      content: '';
+      position: absolute;
+      width: 16px;
+      height: 16px;
+      background: #fff;
+      border-radius: 50%;
+      top: 2px;
+      left: 2px;
+      transition: transform 0.2s;
+    }
+    .toggle.active::after { transform: translateX(16px); }
+    .main-grid {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 1.5rem;
+    }
+    @media (max-width: 900px) {
+      .main-grid { grid-template-columns: 1fr; }
+    }
+    .panel {
+      background: var(--bg-secondary);
+      border: 1px solid var(--border);
+      border-radius: 8px;
+      overflow: hidden;
+    }
+    .panel-header {
+      padding: 0.75rem 1rem;
+      background: var(--bg-tertiary);
+      font-weight: 600;
+      font-size: 0.875rem;
+    }
+    .record-list {
+      max-height: 70vh;
+      overflow-y: auto;
+    }
+    .record-item {
+      padding: 0.75rem 1rem;
+      border-bottom: 1px solid var(--border);
+      cursor: pointer;
+      transition: background 0.15s;
+      display: grid;
+      grid-template-columns: 70px 1fr 60px 70px;
+      gap: 0.75rem;
+      align-items: center;
+      font-size: 0.8125rem;
+    }
+    .record-item:hover { background: var(--bg-tertiary); }
+    .record-item.selected { background: var(--bg-tertiary); border-left: 3px solid var(--accent); }
+    .method {
+      font-weight: 600;
+      font-size: 0.75rem;
+      padding: 0.2rem 0.5rem;
+      border-radius: 4px;
+    }
+    .method-GET { background: rgba(63,185,80,0.2); color: var(--get); }
+    .method-POST { background: rgba(88,166,255,0.2); color: var(--post); }
+    .method-PUT { background: rgba(210,153,34,0.2); color: var(--warning); }
+    .method-DELETE { background: rgba(248,81,73,0.2); color: var(--error); }
+    .method-PATCH { background: rgba(163,113,247,0.2); color: var(--patch); }
+    .path { font-family: monospace; word-break: break-all; }
+    .status { font-weight: 500; }
+    .status-2xx { color: var(--success); }
+    .status-4xx { color: var(--warning); }
+    .status-5xx { color: var(--error); }
+    .detail-content {
+      padding: 1rem;
+      font-size: 0.8125rem;
+      max-height: 70vh;
+      overflow-y: auto;
+    }
+    .detail-section {
+      margin-bottom: 1rem;
+    }
+    .detail-section h4 {
+      margin: 0 0 0.5rem;
+      font-size: 0.75rem;
+      text-transform: uppercase;
+      color: var(--text-secondary);
+    }
+    .detail-section pre {
+      margin: 0;
+      padding: 0.75rem;
+      background: var(--bg-primary);
+      border-radius: 6px;
+      overflow-x: auto;
+      font-size: 0.75rem;
+      white-space: pre-wrap;
+      word-break: break-all;
+    }
+    .empty {
+      padding: 2rem;
+      text-align: center;
+      color: var(--text-secondary);
+    }
+    .loading { opacity: 0.6; pointer-events: none; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <header>
+      <h1>Debug - Request Replay</h1>
+      <div class="toolbar">
+        <label class="toggle-label">
+          <span>Auto-refresh</span>
+          <div class="toggle" id="autoRefresh" title="Toggle auto-refresh"></div>
+        </label>
+        <button class="btn btn-primary" id="replayBtn" disabled>Replay</button>
+        <button class="btn btn-danger" id="clearBtn">Clear</button>
+      </div>
+    </header>
+    <div class="main-grid">
+      <div class="panel">
+        <div class="panel-header">Recorded Requests (<span id="count">0</span>)</div>
+        <div class="record-list" id="recordList"></div>
+      </div>
+      <div class="panel">
+        <div class="panel-header">Request Details</div>
+        <div class="detail-content" id="detailContent">
+          <div class="empty" id="emptyDetail">Select a request to view details</div>
+          <div id="detailBody" style="display:none"></div>
+        </div>
+      </div>
+    </div>
+  </div>
+  <script>
+    (function() {
+      const apiBase = '${apiBase}';
+      const recordList = document.getElementById('recordList');
+      const countEl = document.getElementById('count');
+      const emptyDetail = document.getElementById('emptyDetail');
+      const detailBody = document.getElementById('detailBody');
+      const replayBtn = document.getElementById('replayBtn');
+      const clearBtn = document.getElementById('clearBtn');
+      const autoRefreshToggle = document.getElementById('autoRefresh');
+
+      let records = [];
+      let selectedId = null;
+      let autoRefreshInterval = null;
+
+      function methodClass(m) {
+        return 'method-' + (m || 'GET');
+      }
+      function statusClass(s) {
+        if (s >= 200 && s < 300) return 'status-2xx';
+        if (s >= 400 && s < 500) return 'status-4xx';
+        if (s >= 500) return 'status-5xx';
+        return '';
+      }
+
+      async function fetchRecords() {
+        const res = await fetch(apiBase + '/records');
+        if (!res.ok) throw new Error('Failed to fetch');
+        return res.json();
+      }
+
+      async function fetchRecord(id) {
+        const res = await fetch(apiBase + '/records/' + id);
+        if (!res.ok) throw new Error('Failed to fetch');
+        return res.json();
+      }
+
+      async function loadRecords() {
+        try {
+          records = await fetchRecords();
+          countEl.textContent = records.length;
+          renderList();
+        } catch (e) {
+          recordList.innerHTML = '<div class="empty">Failed to load records</div>';
+        }
+      }
+
+      function renderList() {
+        if (records.length === 0) {
+          recordList.innerHTML = '<div class="empty">No requests recorded yet</div>';
+          return;
+        }
+        recordList.innerHTML = records.map(function(r) {
+          return '<div class="record-item' + (r.id === selectedId ? ' selected' : '') + '" data-id="' + r.id + '">' +
+            '<span class="method ' + methodClass(r.request.method) + '">' + (r.request.method || 'GET') + '</span>' +
+            '<span class="path">' + escapeHtml(r.request.path) + '</span>' +
+            '<span class="status ' + statusClass(r.response.status) + '">' + r.response.status + '</span>' +
+            '<span>' + r.timing.total + 'ms</span>' +
+            '</div>';
+        }).join('');
+        recordList.querySelectorAll('.record-item').forEach(function(el) {
+          el.addEventListener('click', function() {
+            selectedId = el.dataset.id;
+            loadDetail(selectedId);
+            renderList();
+            replayBtn.disabled = false;
+          });
+        });
+      }
+
+      function escapeHtml(s) {
+        if (s == null) return '';
+        const div = document.createElement('div');
+        div.textContent = s;
+        return div.innerHTML;
+      }
+
+      async function loadDetail(id) {
+        try {
+          const record = await fetchRecord(id);
+          emptyDetail.style.display = 'none';
+          detailBody.style.display = 'block';
+          const body = record.request.body !== undefined
+            ? JSON.stringify(record.request.body, null, 2)
+            : '(no body)';
+          const respBody = record.response.bodySize + ' bytes';
+          const meta = [];
+          if (record.metadata.matchedRoute) meta.push('Route: ' + record.metadata.matchedRoute);
+          if (record.metadata.controller) meta.push('Controller: ' + record.metadata.controller);
+          if (record.metadata.methodName) meta.push('Method: ' + record.metadata.methodName);
+          detailBody.innerHTML =
+            '<div class="detail-section"><h4>Request Headers</h4><pre>' + escapeHtml(JSON.stringify(record.request.headers, null, 2)) + '</pre></div>' +
+            '<div class="detail-section"><h4>Request Body</h4><pre>' + escapeHtml(body) + '</pre></div>' +
+            '<div class="detail-section"><h4>Response</h4><pre>Status: ' + record.response.status + '\\nHeaders: ' + JSON.stringify(record.response.headers, null, 2) + '\\nBody size: ' + respBody + '</pre></div>' +
+            (meta.length ? '<div class="detail-section"><h4>Metadata</h4><pre>' + escapeHtml(meta.join('\\n')) + '</pre></div>' : '');
+        } catch (e) {
+          detailBody.innerHTML = '<div class="empty">Failed to load details</div>';
+        }
+      }
+
+      async function replay(id) {
+        if (!id) return;
+        replayBtn.disabled = true;
+        replayBtn.textContent = 'Replaying...';
+        try {
+          const res = await fetch(apiBase + '/replay/' + id, { method: 'POST' });
+          const data = await res.json();
+          if (data.ok) {
+            await loadRecords();
+            if (data.newId) selectedId = data.newId;
+            renderList();
+            loadDetail(selectedId || id);
+          } else {
+            alert('Replay failed: ' + (data.error || res.statusText));
+          }
+        } catch (e) {
+          alert('Replay failed: ' + e.message);
+        }
+        replayBtn.disabled = false;
+        replayBtn.textContent = 'Replay';
+      }
+
+      async function clear() {
+        if (!confirm('Clear all recorded requests?')) return;
+        try {
+          await fetch(apiBase + '/records', { method: 'DELETE' });
+          records = [];
+          selectedId = null;
+          emptyDetail.style.display = 'block';
+          detailBody.style.display = 'none';
+          detailBody.innerHTML = '';
+          replayBtn.disabled = true;
+          loadRecords();
+        } catch (e) {
+          alert('Clear failed: ' + e.message);
+        }
+      }
+
+      replayBtn.addEventListener('click', function() {
+        if (selectedId) replay(selectedId);
+      });
+      clearBtn.addEventListener('click', clear);
+
+      autoRefreshToggle.addEventListener('click', function() {
+        autoRefreshToggle.classList.toggle('active');
+        if (autoRefreshToggle.classList.contains('active')) {
+          autoRefreshInterval = setInterval(loadRecords, 2000);
+        } else {
+          clearInterval(autoRefreshInterval);
+          autoRefreshInterval = null;
+        }
+      });
+
+      loadRecords();
+    })();
+  </script>
+</body>
+</html>`;
+}
+
+// src/debug/debug-ui-middleware.ts
+function createDebugUIMiddleware(recorder, basePath) {
+  const normalizedBase = basePath.endsWith("/") && basePath.length > 1 ? basePath.slice(0, -1) : basePath;
+  const apiPrefix = `${normalizedBase}/api`;
+  return async (context2, next) => {
+    const path = context2.path;
+    if (!path.startsWith(normalizedBase)) {
+      return await next();
+    }
+    const jsonResponse = (data, status = 200) => {
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: { "Content-Type": "application/json; charset=utf-8" }
+      });
+    };
+    if (path === normalizedBase || path === `${normalizedBase}/`) {
+      const html = createDebugHTML(normalizedBase);
+      return new Response(html, {
+        headers: { "Content-Type": "text/html; charset=utf-8" }
+      });
+    }
+    if (path === `${apiPrefix}/records`) {
+      if (context2.method === "GET") {
+        const records = recorder.getAll();
+        return jsonResponse(records);
+      }
+      if (context2.method === "DELETE") {
+        recorder.clear();
+        return jsonResponse({ ok: true });
+      }
+      return jsonResponse({ error: "Method not allowed" }, 405);
+    }
+    const recordsIdPrefix = `${apiPrefix}/records/`;
+    if (path.startsWith(recordsIdPrefix)) {
+      const id = path.slice(recordsIdPrefix.length).split("/")[0];
+      if (!id) {
+        return jsonResponse({ error: "Invalid record id" }, 400);
+      }
+      const record = recorder.getById(id);
+      if (!record) {
+        return jsonResponse({ error: "Not found" }, 404);
+      }
+      return jsonResponse(record);
+    }
+    const replayPrefix = `${apiPrefix}/replay/`;
+    if (path.startsWith(replayPrefix) && context2.method === "POST") {
+      const id = path.slice(replayPrefix.length).split("/")[0];
+      if (!id) {
+        return jsonResponse({ ok: false, error: "Invalid record id" }, 400);
+      }
+      const record = recorder.getById(id);
+      if (!record) {
+        return jsonResponse({ ok: false, error: "Record not found" }, 404);
+      }
+      try {
+        const origin = new URL(context2.request.url).origin;
+        const targetUrl = new URL(record.request.path, origin).href;
+        const headers = new Headers(record.request.headers);
+        let body;
+        if (record.request.body !== undefined && record.request.body !== null) {
+          body = JSON.stringify(record.request.body);
+        }
+        const replayedRequest = new Request(targetUrl, {
+          method: record.request.method,
+          headers,
+          body
+        });
+        const response = await fetch(replayedRequest);
+        const responseText = await response.text();
+        return jsonResponse({
+          ok: true,
+          status: response.status,
+          body: responseText
+        });
+      } catch (error) {
+        return jsonResponse({
+          ok: false,
+          error: error.message
+        }, 500);
+      }
+    }
+    return await next();
+  };
+}
+
+// src/debug/types.ts
+var DEBUG_OPTIONS_TOKEN = Symbol("@dangao/bun-server:debug:options");
+var DEBUG_RECORDER_TOKEN = Symbol("@dangao/bun-server:debug:recorder");
+
+// src/debug/debug-module.ts
+class DebugModule {
+  static forRoot(options = {}) {
+    const enabled = options.enabled ?? true;
+    const maxRecords = options.maxRecords ?? 500;
+    const recordBody = options.recordBody ?? true;
+    const path = options.path ?? "/_debug";
+    const normalizedPath = path.endsWith("/") && path.length > 1 ? path.slice(0, -1) : path;
+    const recorder = new RequestRecorder(maxRecords);
+    const opts = {
+      enabled,
+      maxRecords,
+      recordBody,
+      path: normalizedPath
+    };
+    const debugUIMiddleware = createDebugUIMiddleware(recorder, normalizedPath);
+    const recordingMiddleware = createDebugMiddleware(recorder, {
+      recordBody,
+      basePath: normalizedPath
+    });
+    const providers2 = [
+      { provide: DEBUG_OPTIONS_TOKEN, useValue: opts },
+      { provide: DEBUG_RECORDER_TOKEN, useValue: recorder }
+    ];
+    const middlewares = enabled ? [debugUIMiddleware, recordingMiddleware] : [];
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, DebugModule) ?? {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers ?? [], ...providers2],
+      middlewares: [...existingMetadata.middlewares ?? [], ...middlewares]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, DebugModule);
+    return DebugModule;
+  }
+}
+DebugModule = __legacyDecorateClassTS([
+  Module({
+    providers: [],
+    extensions: [],
+    middlewares: []
+  })
+], DebugModule);
 // src/testing/harness.ts
 import { performance as performance2 } from "perf_hooks";
 
@@ -9155,6 +10703,293 @@ class StressTester {
     };
   }
 }
+// src/testing/testing-module.ts
+import"reflect-metadata";
+
+// src/testing/test-client.ts
+class TestHttpClient {
+  baseUrl;
+  app;
+  constructor(baseUrl, app) {
+    this.baseUrl = baseUrl;
+    this.app = app;
+  }
+  async get(path, options) {
+    return this.request("GET", path, options);
+  }
+  async post(path, options) {
+    return this.request("POST", path, options);
+  }
+  async put(path, options) {
+    return this.request("PUT", path, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, options);
+  }
+  async patch(path, options) {
+    return this.request("PATCH", path, options);
+  }
+  async close() {
+    await this.app.stop();
+  }
+  async request(method, path, options) {
+    let url = `${this.baseUrl}${path}`;
+    if (options?.query) {
+      const params = new URLSearchParams(options.query);
+      url += `?${params.toString()}`;
+    }
+    const fetchOptions = {
+      method,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers || {}
+      }
+    };
+    if (options?.body && method !== "GET") {
+      fetchOptions.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+    }
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+    let body;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = text;
+    }
+    return {
+      status: response.status,
+      headers: response.headers,
+      body,
+      text,
+      ok: response.ok
+    };
+  }
+}
+
+// src/testing/testing-module.ts
+class TestingModuleBuilder {
+  metadata;
+  overrides = [];
+  constructor(metadata) {
+    this.metadata = { ...metadata };
+  }
+  overrideProvider(token) {
+    return new ProviderOverrideBuilder(this, token);
+  }
+  async compile() {
+    const providers2 = this.buildProviders();
+    return new TestingModule(this.metadata, providers2, this.overrides);
+  }
+  addOverride(override) {
+    this.overrides.push(override);
+  }
+  buildProviders() {
+    const providers2 = [...this.metadata.providers || []];
+    const overrideMap = new Map;
+    for (const override of this.overrides) {
+      const key = typeof override.token === "function" ? override.token.name : override.token;
+      overrideMap.set(key, override);
+    }
+    const result = [];
+    for (const provider of providers2) {
+      const token = typeof provider === "function" ? provider.name : provider.provide;
+      const key = typeof token === "function" ? token.name : token;
+      const override = overrideMap.get(key);
+      if (override) {
+        if (override.useValue !== undefined) {
+          result.push({ provide: override.token, useValue: override.useValue });
+        } else if (override.useClass) {
+          result.push({ provide: override.token, useClass: override.useClass });
+        } else if (override.useFactory) {
+          result.push({ provide: override.token, useFactory: override.useFactory });
+        }
+        overrideMap.delete(key);
+      } else {
+        result.push(provider);
+      }
+    }
+    for (const override of overrideMap.values()) {
+      if (override.useValue !== undefined) {
+        result.push({ provide: override.token, useValue: override.useValue });
+      }
+    }
+    return result;
+  }
+}
+
+class ProviderOverrideBuilder {
+  builder;
+  token;
+  constructor(builder, token) {
+    this.builder = builder;
+    this.token = token;
+  }
+  useValue(value) {
+    this.builder.addOverride({ token: this.token, useValue: value });
+    return this.builder;
+  }
+  useClass(cls) {
+    this.builder.addOverride({ token: this.token, useClass: cls });
+    return this.builder;
+  }
+  useFactory(factory) {
+    this.builder.addOverride({ token: this.token, useFactory: factory });
+    return this.builder;
+  }
+}
+
+class TestingModule {
+  metadata;
+  providers;
+  overrides;
+  app;
+  container;
+  constructor(metadata, providers2, overrides) {
+    this.metadata = metadata;
+    this.providers = providers2;
+    this.overrides = overrides;
+  }
+  get(token) {
+    return this.getContainer().resolve(token);
+  }
+  createApplication(options = {}) {
+    if (this.app)
+      return this.app;
+    this.app = new Application({
+      enableSignalHandlers: false,
+      ...options
+    });
+    const container = this.app.getContainer();
+    this.container = container;
+    for (const provider of this.providers) {
+      if (typeof provider === "function") {
+        container.register(provider);
+      } else if ("useValue" in provider && provider.provide) {
+        container.registerInstance(provider.provide, provider.useValue);
+      } else if ("useFactory" in provider && provider.provide) {
+        container.register(provider.provide, {
+          factory: () => provider.useFactory(container)
+        });
+      } else if ("useClass" in provider) {
+        const token = provider.provide ?? provider.useClass;
+        container.register(token, {
+          implementation: provider.useClass
+        });
+      }
+    }
+    if (this.metadata.imports) {
+      for (const moduleClass of this.metadata.imports) {
+        this.app.registerModule(moduleClass);
+      }
+    }
+    if (this.metadata.controllers) {
+      for (const ctrl of this.metadata.controllers) {
+        this.app.registerController(ctrl);
+      }
+    }
+    return this.app;
+  }
+  async createHttpClient(options = {}) {
+    const app = this.createApplication(options);
+    await app.listen(0);
+    const server = app.getServer();
+    const port = server?.getPort() ?? 3000;
+    return new TestHttpClient(`http://localhost:${port}`, app);
+  }
+  getContainer() {
+    if (this.container)
+      return this.container;
+    this.createApplication();
+    return this.container;
+  }
+}
+
+class Test {
+  static createTestingModule(metadata) {
+    return new TestingModuleBuilder(metadata);
+  }
+}
+// src/client/generator.ts
+init_registry();
+
+class ClientGenerator {
+  static generate() {
+    const registry = RouteRegistry.getInstance();
+    const router = registry.getRouter();
+    const routes = router.getRoutes();
+    const entries = [];
+    for (const route of routes) {
+      entries.push({
+        method: route.method,
+        path: route.path,
+        controllerName: route.controllerClass?.name ?? "unknown",
+        methodName: route.methodName ?? "unknown"
+      });
+    }
+    return { routes: entries };
+  }
+  static generateJSON() {
+    return JSON.stringify(ClientGenerator.generate(), null, 2);
+  }
+}
+// src/client/runtime.ts
+function buildUrl(baseUrl, path, options) {
+  let resolvedPath = path;
+  if (options?.params) {
+    for (const [key, value] of Object.entries(options.params)) {
+      resolvedPath = resolvedPath.replace(`:${key}`, encodeURIComponent(value));
+    }
+  }
+  let url = `${baseUrl}${resolvedPath}`;
+  if (options?.query) {
+    const params = new URLSearchParams(options.query);
+    url += `?${params.toString()}`;
+  }
+  return url;
+}
+function createClient(manifest, config) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const groups = new Map;
+  for (const route of manifest.routes) {
+    const groupName = route.controllerName.replace(/Controller$/i, "").replace(/^./, (c) => c.toLowerCase());
+    if (!groups.has(groupName)) {
+      groups.set(groupName, new Map);
+    }
+    groups.get(groupName).set(route.methodName, {
+      method: route.method,
+      path: route.path
+    });
+  }
+  const client = {};
+  for (const [groupName, methods] of groups) {
+    const group = {};
+    for (const [methodName, routeInfo] of methods) {
+      group[methodName] = async (options) => {
+        const url = buildUrl(config.baseUrl, routeInfo.path, options);
+        const fetchOptions = {
+          method: routeInfo.method,
+          headers: {
+            "Content-Type": "application/json",
+            ...config.headers || {},
+            ...options?.headers || {}
+          }
+        };
+        if (options?.body && routeInfo.method !== "GET") {
+          fetchOptions.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
+        }
+        const response = await fetchFn(url, fetchOptions);
+        const text = await response.text();
+        try {
+          return JSON.parse(text);
+        } catch {
+          return text;
+        }
+      };
+    }
+    client[groupName] = group;
+  }
+  return client;
+}
 // src/queue/queue-module.ts
 init_module();
 
@@ -11121,10 +12956,13 @@ export {
   createHttpMetricsMiddleware,
   createFileUploadMiddleware,
   createErrorHandlingMiddleware,
+  createDebugMiddleware,
   createCustomValidator,
   createCorsMiddleware,
+  createClient,
   contextStore,
   checkRoles,
+  applyDecorators,
   WeightedRoundRobinLoadBalancer,
   WebSocketGatewayRegistry,
   WebSocketGateway,
@@ -11144,6 +12982,10 @@ export {
   TransactionInterceptor,
   Tracer,
   TraceIdRequestInterceptor,
+  TestingModuleBuilder,
+  TestingModule,
+  TestHttpClient,
+  Test,
   TRANSACTION_SERVICE_TOKEN,
   SwaggerModule,
   SwaggerGenerator,
@@ -11174,6 +13016,7 @@ export {
   ResponseLogInterceptor,
   ResponseBuilder,
   RequestWrapper,
+  RequestRecorder,
   RequestLogInterceptor,
   Repository,
   Reflector,
@@ -11319,14 +13162,20 @@ export {
   EVENT_LISTENER_CLASS_METADATA_KEY,
   EVENT_EMITTER_TOKEN,
   DrizzleBaseRepository,
+  DebugModule,
   DatabaseService2 as DatabaseService,
   DatabaseModule,
   DatabaseHealthIndicator,
   DatabaseExtension,
   DatabaseConnectionManager,
+  DashboardService,
+  DashboardModule,
   DELETE,
+  DEBUG_RECORDER_TOKEN,
+  DEBUG_OPTIONS_TOKEN,
   DATABASE_SERVICE_TOKEN,
   DATABASE_OPTIONS_TOKEN,
+  DASHBOARD_OPTIONS_TOKEN,
   Cron,
   ControllerRegistry,
   Controller,
@@ -11342,6 +13191,8 @@ export {
   ConfigModule,
   ConfigCenterModule,
   Column,
+  ClusterManager,
+  ClientGenerator,
   CircuitBreakerState,
   CircuitBreaker,
   CacheableInterceptor,
@@ -11372,6 +13223,7 @@ export {
   AuthenticationManager,
   AuthGuard,
   Auth,
+  AsyncProviderRegistry,
   ArrayUnique,
   ArrayNotEmpty,
   ArrayNotContains,